LLVMFuzzerTestOneInput: 145| 225|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 146| 225| lua_State *L = luaL_newstate(); 147| 225| if (L == NULL) { ------------------ | Branch (147:9): [True: 0, False: 225] ------------------ 148| 0| return 0; 149| 0| } 150| 225| dochunk(L, luaL_loadbufferx(L, (const char *)data, size, "test", "t")); 151| | 152| | 153| 225| lua_close(L); 154| 225| return 0; 155| 225|} fuzz_lua.c:dochunk: 134| 225|static int dochunk (lua_State *L, int status) { 135| 225| if (status == LUA_OK) status = docall(L, 0, 0); ------------------ | | 48| 225|#define LUA_OK 0 ------------------ | Branch (135:7): [True: 45, False: 180] ------------------ 136| 225| return report(L, status); 137| 225|} fuzz_lua.c:docall: 120| 45|static int docall (lua_State *L, int narg, int nres) { 121| 45| int status; 122| 45| int base = lua_gettop(L) - narg; /* function index */ 123| 45| lua_pushcfunction(L, msghandler); /* push message handler */ ------------------ | | 381| 45|#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0) ------------------ 124| 45| lua_insert(L, base); /* put it under function and args */ ------------------ | | 400| 45|#define lua_insert(L,idx) lua_rotate(L, (idx), 1) ------------------ 125| 45| globalL = L; /* to be available to 'laction' */ 126| 45| signal(SIGINT, laction); /* set C-signal handler */ 127| 45| status = lua_pcall(L, narg, nres, base); ------------------ | | 297| 45|#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) ------------------ 128| 45| signal(SIGINT, SIG_DFL); /* reset C-signal handler */ 129| 45| lua_remove(L, base); /* remove message handler from the stack */ ------------------ | | 402| 45|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 375| 45|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 130| 45| return status; 131| 45|} fuzz_lua.c:msghandler: 101| 40|static int msghandler (lua_State *L) { 102| 40| const char *msg = lua_tostring(L, 1); ------------------ | | 397| 40|#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) ------------------ 103| 40| if (msg == NULL) { /* is error object not a string? */ ------------------ | Branch (103:7): [True: 0, False: 40] ------------------ 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? */ ------------------ | | 68| 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| 40| luaL_traceback(L, L, msg, 1); /* append a standard traceback */ 112| 40| return 1; /* return the traceback */ 113| 40|} fuzz_lua.c:report: 89| 225|static int report (lua_State *L, int status) { 90| 225| if (status != LUA_OK) { ------------------ | | 48| 225|#define LUA_OK 0 ------------------ | Branch (90:7): [True: 220, False: 5] ------------------ 91| 220| const char *msg = lua_tostring(L, -1); ------------------ | | 397| 220|#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) ------------------ 92| 220| l_message(progname, msg); 93| 220| lua_pop(L, 1); /* remove message */ ------------------ | | 375| 220|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 94| 220| } 95| 225| return status; 96| 225|} fuzz_lua.c:l_message: 78| 220|static void l_message (const char *pname, const char *msg) { 79| 220| if (pname) lua_writestringerror("%s: ", pname); ------------------ | | 271| 220| (fprintf(stderr, (s), (p)), fflush(stderr)) ------------------ | Branch (79:7): [True: 220, False: 0] ------------------ 80| 220| lua_writestringerror("%s\n", msg); ------------------ | | 271| 220| (fprintf(stderr, (s), (p)), fflush(stderr)) ------------------ 81| 220|} lua_checkstack: 111| 12|LUA_API int lua_checkstack (lua_State *L, int n) { 112| 12| int res; 113| 12| CallInfo *ci; 114| 12| lua_lock(L); ------------------ | | 264| 12|#define lua_lock(L) ((void) 0) ------------------ 115| 12| ci = L->ci; 116| 12| api_check(L, n >= 0, "negative 'n'"); ------------------ | | 126| 12|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 12|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 117| 12| if (L->stack_last.p - L->top.p > n) /* stack large enough? */ ------------------ | Branch (117:7): [True: 12, False: 0] ------------------ 118| 12| res = 1; /* yes; check is OK */ 119| 0| else /* need to grow stack */ 120| 0| res = luaD_growstack(L, n, 0); 121| 12| if (res && ci->top.p < L->top.p + n) ------------------ | Branch (121:7): [True: 12, False: 0] | Branch (121:14): [True: 0, False: 12] ------------------ 122| 0| ci->top.p = L->top.p + n; /* adjust frame top */ 123| 12| lua_unlock(L); ------------------ | | 265| 12|#define lua_unlock(L) ((void) 0) ------------------ 124| 12| return res; 125| 12|} lua_atpanic: 144| 225|LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) { 145| 225| lua_CFunction old; 146| 225| lua_lock(L); ------------------ | | 264| 225|#define lua_lock(L) ((void) 0) ------------------ 147| 225| old = G(L)->panic; ------------------ | | 335| 225|#define G(L) (L->l_G) ------------------ 148| 225| G(L)->panic = panicf; ------------------ | | 335| 225|#define G(L) (L->l_G) ------------------ 149| 225| lua_unlock(L); ------------------ | | 265| 225|#define lua_unlock(L) ((void) 0) ------------------ 150| 225| return old; 151| 225|} lua_gettop: 176| 85|LUA_API int lua_gettop (lua_State *L) { 177| 85| return cast_int(L->top.p - (L->ci->func.p + 1)); ------------------ | | 141| 85|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 85|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 178| 85|} lua_settop: 181| 461|LUA_API void lua_settop (lua_State *L, int idx) { 182| 461| CallInfo *ci; 183| 461| StkId func, newtop; 184| 461| ptrdiff_t diff; /* difference for new top */ 185| 461| lua_lock(L); ------------------ | | 264| 461|#define lua_lock(L) ((void) 0) ------------------ 186| 461| ci = L->ci; 187| 461| func = ci->func.p; 188| 461| if (idx >= 0) { ------------------ | Branch (188:7): [True: 40, False: 421] ------------------ 189| 40| api_check(L, idx <= ci->top.p - (func + 1), "new top too large"); ------------------ | | 126| 40|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 40|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 190| 40| diff = ((func + 1) + idx) - L->top.p; 191| 40| for (; diff > 0; diff--) ------------------ | Branch (191:12): [True: 0, False: 40] ------------------ 192| 40| setnilvalue(s2v(L->top.p++)); /* clear new slots */ ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 40|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 193| 40| } 194| 421| else { 195| 421| api_check(L, -(idx+1) <= (L->top.p - (func + 1)), "invalid new top"); ------------------ | | 126| 421|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 421|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 196| 421| diff = idx + 1; /* will "subtract" index (as it is negative) */ 197| 421| } 198| 461| api_check(L, L->tbclist.p < L->top.p, "previous pop of an unclosed slot"); ------------------ | | 126| 461|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 461|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 199| 461| newtop = L->top.p + diff; 200| 461| if (diff < 0 && L->tbclist.p >= newtop) { ------------------ | Branch (200:7): [True: 449, False: 12] | Branch (200:19): [True: 0, False: 449] ------------------ 201| 0| lua_assert(hastocloseCfunc(ci->nresults)); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ 202| 0| newtop = luaF_close(L, newtop, CLOSEKTOP, 0); ------------------ | | 47| 0|#define CLOSEKTOP (-1) ------------------ 203| 0| } 204| 461| L->top.p = newtop; /* correct top only after closing any upvalue */ 205| 461| lua_unlock(L); ------------------ | | 265| 461|#define lua_unlock(L) ((void) 0) ------------------ 206| 461|} lua_closeslot: 209| 12|LUA_API void lua_closeslot (lua_State *L, int idx) { 210| 12| StkId level; 211| 12| lua_lock(L); ------------------ | | 264| 12|#define lua_lock(L) ((void) 0) ------------------ 212| 12| level = index2stack(L, idx); 213| 12| api_check(L, hastocloseCfunc(L->ci->nresults) && L->tbclist.p == level, ------------------ | | 126| 12|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 12|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 214| 12| "no variable to close at given level"); 215| 12| level = luaF_close(L, level, CLOSEKTOP, 0); ------------------ | | 47| 12|#define CLOSEKTOP (-1) ------------------ 216| 12| setnilvalue(s2v(level)); ------------------ | | 200| 12|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 217| 12| lua_unlock(L); ------------------ | | 265| 12|#define lua_unlock(L) ((void) 0) ------------------ 218| 12|} lua_rotate: 241| 154|LUA_API void lua_rotate (lua_State *L, int idx, int n) { 242| 154| StkId p, t, m; 243| 154| lua_lock(L); ------------------ | | 264| 154|#define lua_lock(L) ((void) 0) ------------------ 244| 154| t = L->top.p - 1; /* end of stack segment being rotated */ 245| 154| p = index2stack(L, idx); /* start of segment */ 246| 154| api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'"); ------------------ | | 126| 154|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 154|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 247| 154| m = (n >= 0 ? t - n : p - n - 1); /* end of prefix */ ------------------ | Branch (247:8): [True: 57, False: 97] ------------------ 248| 154| reverse(L, p, m); /* reverse the prefix with length 'n' */ 249| 154| reverse(L, m + 1, t); /* reverse the suffix */ 250| 154| reverse(L, p, t); /* reverse the entire segment */ 251| 154| lua_unlock(L); ------------------ | | 265| 154|#define lua_unlock(L) ((void) 0) ------------------ 252| 154|} lua_pushvalue: 270| 12|LUA_API void lua_pushvalue (lua_State *L, int idx) { 271| 12| lua_lock(L); ------------------ | | 264| 12|#define lua_lock(L) ((void) 0) ------------------ 272| 12| setobj2s(L, L->top.p, index2value(L, idx)); ------------------ | | 131| 12|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 12| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 12| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 12| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 12| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 192|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 12| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 273| 12| api_incr_top(L); ------------------ | | 16| 12|#define api_incr_top(L) {L->top.p++; \ | | 17| 12| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 12|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 12|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 12| "stack overflow");} ------------------ 274| 12| lua_unlock(L); ------------------ | | 265| 12|#define lua_unlock(L) ((void) 0) ------------------ 275| 12|} lua_type: 284| 40|LUA_API int lua_type (lua_State *L, int idx) { 285| 40| const TValue *o = index2value(L, idx); 286| 40| return (isvalid(L, o) ? ttype(o) : LUA_TNONE); ------------------ | | 46| 40|#define isvalid(L, o) (!ttisnil(o) || o != &G(L)->nilvalue) | | ------------------ | | | | 193| 40|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 80|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 40|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 40|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define isvalid(L, o) (!ttisnil(o) || o != &G(L)->nilvalue) | | ------------------ | | | | 335| 40|#define G(L) (L->l_G) | | ------------------ | | | Branch (46:24): [True: 0, False: 40] | | | Branch (46:39): [True: 40, False: 0] | | ------------------ ------------------ return (isvalid(L, o) ? ttype(o) : LUA_TNONE); ------------------ | | 87| 40|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 40|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ return (isvalid(L, o) ? ttype(o) : LUA_TNONE); ------------------ | | 62| 0|#define LUA_TNONE (-1) ------------------ 287| 40|} lua_tolstring: 405| 340|LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) { 406| 340| TValue *o; 407| 340| lua_lock(L); ------------------ | | 264| 340|#define lua_lock(L) ((void) 0) ------------------ 408| 340| o = index2value(L, idx); 409| 340| if (!ttisstring(o)) { ------------------ | | 363| 340|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 340|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 340|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 340|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (409:7): [True: 0, False: 340] ------------------ 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| 340| if (len != NULL) ------------------ | Branch (419:7): [True: 80, False: 260] ------------------ 420| 80| *len = tsslen(tsvalue(o)); ------------------ | | 411| 640| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 80, False: 0] | | | Branch (411:4): [True: 0, False: 80] | | | Branch (411:4): [True: 80, False: 0] | | | Branch (411:4): [True: 0, False: 80] | | | Branch (411:4): [True: 80, False: 0] | | | Branch (411:26): [True: 0, False: 80] | | | Branch (411:26): [True: 80, False: 0] | | | Branch (411:26): [True: 0, False: 80] | | | Branch (411:26): [True: 80, False: 0] | | | Branch (411:40): [True: 0, False: 0] | | | Branch (411:40): [True: 0, False: 0] | | | Branch (411:40): [True: 0, False: 0] | | | Branch (411:40): [True: 0, False: 0] | | ------------------ ------------------ 421| 340| lua_unlock(L); ------------------ | | 265| 340|#define lua_unlock(L) ((void) 0) ------------------ 422| 340| return getstr(tsvalue(o)); ------------------ | | 404| 2.72k|#define getstr(ts) ((ts)->contents) | | ------------------ | | | Branch (404:22): [True: 0, False: 340] | | | Branch (404:22): [True: 340, False: 0] | | | Branch (404:22): [True: 0, False: 340] | | | Branch (404:22): [True: 340, False: 0] | | ------------------ ------------------ 423| 340|} lua_touserdata: 456| 260|LUA_API void *lua_touserdata (lua_State *L, int idx) { 457| 260| const TValue *o = index2value(L, idx); 458| 260| return touserdata(o); 459| 260|} lua_pushlstring: 526| 40|LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) { 527| 40| TString *ts; 528| 40| lua_lock(L); ------------------ | | 264| 40|#define lua_lock(L) ((void) 0) ------------------ 529| 40| ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len); ------------------ | Branch (529:8): [True: 0, False: 40] ------------------ 530| 40| setsvalue2s(L, L->top.p, ts); ------------------ | | 377| 40|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 40| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 40| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 40|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 40|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 40|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 40|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 40|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 40| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 40| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 640|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 40|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 40| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 531| 40| api_incr_top(L); ------------------ | | 16| 40|#define api_incr_top(L) {L->top.p++; \ | | 17| 40| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 40|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 40|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 40| "stack overflow");} ------------------ 532| 40| luaC_checkGC(L); ------------------ | | 172| 40|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 40| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 40|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 1, False: 39] | | | | ------------------ | | | | 169| 40| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 40|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 533| 40| lua_unlock(L); ------------------ | | 265| 40|#define lua_unlock(L) ((void) 0) ------------------ 534| 40| return getstr(ts); ------------------ | | 404| 40|#define getstr(ts) ((ts)->contents) ------------------ 535| 40|} lua_pushstring: 538| 52|LUA_API const char *lua_pushstring (lua_State *L, const char *s) { 539| 52| lua_lock(L); ------------------ | | 264| 52|#define lua_lock(L) ((void) 0) ------------------ 540| 52| if (s == NULL) ------------------ | Branch (540:7): [True: 0, False: 52] ------------------ 541| 52| setnilvalue(s2v(L->top.p)); ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 542| 52| else { 543| 52| TString *ts; 544| 52| ts = luaS_new(L, s); 545| 52| setsvalue2s(L, L->top.p, ts); ------------------ | | 377| 52|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 52| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 52| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 52|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 52|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 52|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 52|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 52|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 52| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 52| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 832|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 52|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 52] | | | | | | | | | Branch (112:29): [True: 52, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 52] | | | | | | | | | Branch (112:29): [True: 52, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 52] | | | | | | | | | Branch (112:29): [True: 52, False: 0] | | | | | | | | | Branch (112:29): [True: 52, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 52] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 52| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 546| 52| s = getstr(ts); /* internal copy's address */ ------------------ | | 404| 52|#define getstr(ts) ((ts)->contents) ------------------ 547| 52| } 548| 52| api_incr_top(L); ------------------ | | 16| 52|#define api_incr_top(L) {L->top.p++; \ | | 17| 52| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 52|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 52|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 52| "stack overflow");} ------------------ 549| 52| luaC_checkGC(L); ------------------ | | 172| 52|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 52| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 52|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 1, False: 51] | | | | ------------------ | | | | 169| 52| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 52|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 550| 52| lua_unlock(L); ------------------ | | 265| 52|#define lua_unlock(L) ((void) 0) ------------------ 551| 52| return s; 552| 52|} lua_pushfstring: 566| 40|LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) { 567| 40| const char *ret; 568| 40| va_list argp; 569| 40| lua_lock(L); ------------------ | | 264| 40|#define lua_lock(L) ((void) 0) ------------------ 570| 40| va_start(argp, fmt); 571| 40| ret = luaO_pushvfstring(L, fmt, argp); 572| 40| va_end(argp); 573| 40| luaC_checkGC(L); ------------------ | | 172| 40|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 40| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 40|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 40] | | | | ------------------ | | | | 169| 40| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 40|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 574| 40| lua_unlock(L); ------------------ | | 265| 40|#define lua_unlock(L) ((void) 0) ------------------ 575| 40| return ret; 576| 40|} lua_pushcclosure: 579| 69|LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) { 580| 69| lua_lock(L); ------------------ | | 264| 69|#define lua_lock(L) ((void) 0) ------------------ 581| 69| if (n == 0) { ------------------ | Branch (581:7): [True: 69, False: 0] ------------------ 582| 69| setfvalue(s2v(L->top.p), fn); ------------------ | | 616| 69| { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_VLCF); } | | ------------------ | | | | 72| 69|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_VLCF); } | | ------------------ | | | | 114| 69|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 583| 69| api_incr_top(L); ------------------ | | 16| 69|#define api_incr_top(L) {L->top.p++; \ | | 17| 69| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 69|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 69|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 69| "stack overflow");} ------------------ 584| 69| } 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) | | | | ------------------ | | | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 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) | | ------------------ | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 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) || \ | | | | | | ------------------ | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 594| | /* does not need barrier because closure is white */ 595| 0| lua_assert(iswhite(cl)); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ 596| 0| } 597| 0| setclCvalue(L, s2v(L->top.p), cl); ------------------ | | 619| 0| { TValue *io = (obj); CClosure *x_ = (x); \ | | 620| 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VCCL)); \ | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 621| 0| checkliveness(L,io); } | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 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) | | | | ------------------ | | | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 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| 69| lua_unlock(L); ------------------ | | 265| 69|#define lua_unlock(L) ((void) 0) ------------------ 602| 69|} lua_pushlightuserdata: 616| 40|LUA_API void lua_pushlightuserdata (lua_State *L, void *p) { 617| 40| lua_lock(L); ------------------ | | 264| 40|#define lua_lock(L) ((void) 0) ------------------ 618| 40| setpvalue(s2v(L->top.p), p); ------------------ | | 440| 40| { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_VLIGHTUSERDATA); } | | ------------------ | | | | 72| 40|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_VLIGHTUSERDATA); } | | ------------------ | | | | 114| 40|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 619| 40| api_incr_top(L); ------------------ | | 16| 40|#define api_incr_top(L) {L->top.p++; \ | | 17| 40| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 40|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 40|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 40| "stack overflow");} ------------------ 620| 40| lua_unlock(L); ------------------ | | 265| 40|#define lua_unlock(L) ((void) 0) ------------------ 621| 40|} lua_getfield: 689| 52|LUA_API int lua_getfield (lua_State *L, int idx, const char *k) { 690| 52| lua_lock(L); ------------------ | | 264| 52|#define lua_lock(L) ((void) 0) ------------------ 691| 52| return auxgetstr(L, index2value(L, idx), k); 692| 52|} lua_createtable: 762| 12|LUA_API void lua_createtable (lua_State *L, int narray, int nrec) { 763| 12| Table *t; 764| 12| lua_lock(L); ------------------ | | 264| 12|#define lua_lock(L) ((void) 0) ------------------ 765| 12| t = luaH_new(L); 766| 12| sethvalue2s(L, L->top.p, t); ------------------ | | 689| 12|#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) | | ------------------ | | | | 685| 12| { TValue *io = (obj); Table *x_ = (x); \ | | | | 686| 12| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 72| 12|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 390| 12|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 12|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 687| 12| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 12| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 192|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 12| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 767| 12| api_incr_top(L); ------------------ | | 16| 12|#define api_incr_top(L) {L->top.p++; \ | | 17| 12| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 12|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 12|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 12| "stack overflow");} ------------------ 768| 12| if (narray > 0 || nrec > 0) ------------------ | Branch (768:7): [True: 0, False: 12] | Branch (768:21): [True: 12, False: 0] ------------------ 769| 12| luaH_resize(L, t, narray, nrec); 770| 12| luaC_checkGC(L); ------------------ | | 172| 12|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 12| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 12|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 12] | | | | ------------------ | | | | 169| 12| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 12|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 771| 12| lua_unlock(L); ------------------ | | 265| 12|#define lua_unlock(L) ((void) 0) ------------------ 772| 12|} lua_setfield: 871| 48|LUA_API void lua_setfield (lua_State *L, int idx, const char *k) { 872| 48| lua_lock(L); /* unlock done in 'auxsetstr' */ ------------------ | | 264| 48|#define lua_lock(L) ((void) 0) ------------------ 873| 48| auxsetstr(L, index2value(L, idx), k); 874| 48|} lua_setmetatable: 933| 12|LUA_API int lua_setmetatable (lua_State *L, int objindex) { 934| 12| TValue *obj; 935| 12| Table *mt; 936| 12| lua_lock(L); ------------------ | | 264| 12|#define lua_lock(L) ((void) 0) ------------------ 937| 12| api_checknelems(L, 1); ------------------ | | 33| 12| api_check(L, (n) < (L->top.p - L->ci->func.p), \ | | ------------------ | | | | 126| 12|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 12|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 34| 12| "not enough elements in the stack") ------------------ 938| 12| obj = index2value(L, objindex); 939| 12| if (ttisnil(s2v(L->top.p - 1))) ------------------ | | 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: 0, False: 12] | | | | ------------------ | | ------------------ ------------------ 940| 0| mt = NULL; 941| 12| else { 942| 12| api_check(L, ttistable(s2v(L->top.p - 1)), "table expected"); ------------------ | | 126| 12|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 12|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 943| 24| mt = hvalue(s2v(L->top.p - 1)); ------------------ | | 682| 12|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 110| 48|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 12] | | | | | Branch (110:42): [True: 12, False: 0] | | | | ------------------ | | ------------------ ------------------ 944| 24| } 945| 12| switch (ttype(obj)) { ------------------ | | 87| 12|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 12|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 946| 0| case LUA_TTABLE: { ------------------ | | 69| 0|#define LUA_TTABLE 5 ------------------ | Branch (946:5): [True: 0, False: 12] ------------------ 947| 0| hvalue(obj)->metatable = mt; ------------------ | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 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] | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | Branch (62:26): [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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | Branch (110:42): [True: 0, False: 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 951| 0| } 952| 0| break; 953| 0| } 954| 12| case LUA_TUSERDATA: { ------------------ | | 71| 12|#define LUA_TUSERDATA 7 ------------------ | Branch (954:5): [True: 12, False: 0] ------------------ 955| 24| uvalue(obj)->metatable = mt; ------------------ | | 435| 12|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 110| 48|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 12] | | | | | Branch (110:42): [True: 12, False: 0] | | | | ------------------ | | ------------------ ------------------ 956| 12| if (mt) { ------------------ | Branch (956:11): [True: 12, False: 0] ------------------ 957| 12| luaC_objbarrier(L, uvalue(obj), mt); ------------------ | | 175| 12|#define luaC_objbarrier(L,p,o) ( \ | | 176| 12| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 12|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 12|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 96|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 12] | | | | | | | | | Branch (62:26): [True: 0, False: 12] | | | | | | | | | Branch (62:26): [True: 12, False: 0] | | | | | | | | | Branch (62:26): [True: 0, False: 12] | | | | | | | | | Branch (62:26): [True: 12, 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| 12| 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | Branch (110:42): [True: 0, False: 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 12|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 958| 12| luaC_checkfinalizer(L, gcvalue(obj), mt); ------------------ | | 305| 12|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 110| 12|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 959| 12| } 960| 12| break; 961| 24| } 962| 12| default: { ------------------ | Branch (962:5): [True: 0, False: 12] ------------------ 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| 24| } 966| 12| } 967| 12| L->top.p--; 968| 12| lua_unlock(L); ------------------ | | 265| 12|#define lua_unlock(L) ((void) 0) ------------------ 969| 12| return 1; 970| 12|} lua_pcallk: 1044| 45| lua_KContext ctx, lua_KFunction k) { 1045| 45| struct CallS c; 1046| 45| int status; 1047| 45| ptrdiff_t func; 1048| 45| lua_lock(L); ------------------ | | 264| 45|#define lua_lock(L) ((void) 0) ------------------ 1049| 45| api_check(L, k == NULL || !isLua(L->ci), ------------------ | | 126| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1050| 45| "cannot use continuations inside hooks"); 1051| 45| api_checknelems(L, nargs+1); ------------------ | | 33| 45| api_check(L, (n) < (L->top.p - L->ci->func.p), \ | | ------------------ | | | | 126| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 34| 45| "not enough elements in the stack") ------------------ 1052| 45| api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread"); ------------------ | | 126| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1053| 45| checkresults(L, nargs, nresults); ------------------ | | 999| 45| api_check(L, (nr) == LUA_MULTRET \ | | ------------------ | | | | 126| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 1000| 45| || (L->ci->top.p - L->top.p >= (nr) - (na)), \ | | 1001| 45| "results from function overflow current stack size") ------------------ 1054| 45| if (errfunc == 0) ------------------ | Branch (1054:7): [True: 0, False: 45] ------------------ 1055| 0| func = 0; 1056| 45| else { 1057| 45| StkId o = index2stack(L, errfunc); 1058| 45| api_check(L, ttisfunction(s2v(o)), "error handler must be a function"); ------------------ | | 126| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1059| 45| func = savestack(L, o); ------------------ | | 36| 45|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 45|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 45|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 45|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 45|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1060| 45| } 1061| 45| c.func = L->top.p - (nargs+1); /* function to be called */ 1062| 45| if (k == NULL || !yieldable(L)) { /* no continuation or no yieldable? */ ------------------ | | 104| 0|#define yieldable(L) (((L)->nCcalls & 0xffff0000) == 0) ------------------ | Branch (1062:7): [True: 45, False: 0] | Branch (1062:20): [True: 0, False: 0] ------------------ 1063| 45| c.nresults = nresults; /* do a 'conventional' protected call */ 1064| 45| status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func); ------------------ | | 36| 45|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 45|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 45|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 45|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 45|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1065| 45| } 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 */ ------------------ | | 48| 0|#define LUA_OK 0 ------------------ 1080| 0| } 1081| 45| adjustresults(L, nresults); ------------------ | | 27| 45| { if ((nres) <= LUA_MULTRET && L->ci->top.p < L->top.p) \ | | ------------------ | | | | 35| 90|#define LUA_MULTRET (-1) | | ------------------ | | | Branch (27:11): [True: 0, False: 45] | | | Branch (27:36): [True: 0, False: 0] | | ------------------ | | 28| 45| L->ci->top.p = L->top.p; } ------------------ 1082| 45| lua_unlock(L); ------------------ | | 265| 45|#define lua_unlock(L) ((void) 0) ------------------ 1083| 45| return status; 1084| 45|} lua_load: 1088| 225| const char *chunkname, const char *mode) { 1089| 225| ZIO z; 1090| 225| int status; 1091| 225| lua_lock(L); ------------------ | | 264| 225|#define lua_lock(L) ((void) 0) ------------------ 1092| 225| if (!chunkname) chunkname = "?"; ------------------ | Branch (1092:7): [True: 0, False: 225] ------------------ 1093| 225| luaZ_init(L, &z, reader, data); 1094| 225| status = luaD_protectedparser(L, &z, chunkname, mode); 1095| 225| if (status == LUA_OK) { /* no errors? */ ------------------ | | 48| 225|#define LUA_OK 0 ------------------ | Branch (1095:7): [True: 45, False: 180] ------------------ 1096| 90| LClosure *f = clLvalue(s2v(L->top.p - 1)); /* get new function */ ------------------ | | 602| 45|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | ------------------ | | | | 110| 180|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 45] | | | | | Branch (110:42): [True: 45, False: 0] | | | | ------------------ | | ------------------ ------------------ 1097| 45| if (f->nupvalues >= 1) { /* does it have an upvalue? */ ------------------ | Branch (1097:9): [True: 45, False: 0] ------------------ 1098| | /* get global table from registry */ 1099| 90| const TValue *gt = getGtable(L); ------------------ | | 663| 45| (&hvalue(&G(L)->l_registry)->array[LUA_RIDX_GLOBALS - 1]) | | ------------------ | | | | 682| 45|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 180|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 45|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 45] | | | | | | | Branch (110:42): [True: 45, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (&hvalue(&G(L)->l_registry)->array[LUA_RIDX_GLOBALS - 1]) | | ------------------ | | | | 84| 45|#define LUA_RIDX_GLOBALS 2 | | ------------------ ------------------ 1100| | /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */ 1101| 45| setobj(L, f->upvals[0]->v.p, gt); ------------------ | | 119| 45| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 45| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 45| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 45| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 720|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 45|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 45] | | | | | | | Branch (112:29): [True: 45, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 45] | | | | | | | Branch (112:29): [True: 45, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 45] | | | | | | | Branch (112:29): [True: 45, False: 0] | | | | | | | Branch (112:29): [True: 45, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 45] | | | | | | ------------------ | | | | ------------------ | | | | 108| 45| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 106| 45|#define lua_assert(c) assert(c) | | ------------------ ------------------ 1102| 45| luaC_barrier(L, f->upvals[0], gt); ------------------ | | 179| 45|#define luaC_barrier(L,p,v) ( \ | | 180| 45| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 45|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 45|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 45|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 45, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 45|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 45| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 45|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 45|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 90|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 45] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (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] | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 177| 45| 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)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 45|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 45|#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| 45| } 1104| 90| } 1105| 225| lua_unlock(L); ------------------ | | 265| 225|#define lua_unlock(L) ((void) 0) ------------------ 1106| 225| return status; 1107| 225|} lua_toclose: 1270| 12|LUA_API void lua_toclose (lua_State *L, int idx) { 1271| 12| int nresults; 1272| 12| StkId o; 1273| 12| lua_lock(L); ------------------ | | 264| 12|#define lua_lock(L) ((void) 0) ------------------ 1274| 12| o = index2stack(L, idx); 1275| 12| nresults = L->ci->nresults; 1276| 12| api_check(L, L->tbclist.p < o, "given index below or equal a marked one"); ------------------ | | 126| 12|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 12|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1277| 12| luaF_newtbcupval(L, o); /* create new to-be-closed upvalue */ 1278| 12| if (!hastocloseCfunc(nresults)) /* function not marked yet? */ ------------------ | | 46| 12|#define hastocloseCfunc(n) ((n) < LUA_MULTRET) | | ------------------ | | | | 35| 12|#define LUA_MULTRET (-1) | | ------------------ ------------------ | Branch (1278:7): [True: 12, False: 0] ------------------ 1279| 12| L->ci->nresults = codeNresults(nresults); /* mark it */ ------------------ | | 49| 12|#define codeNresults(n) (-(n) - 3) ------------------ 1280| 12| lua_assert(hastocloseCfunc(L->ci->nresults)); ------------------ | | 106| 12|#define lua_assert(c) assert(c) ------------------ 1281| 12| lua_unlock(L); ------------------ | | 265| 12|#define lua_unlock(L) ((void) 0) ------------------ 1282| 12|} lua_getallocf: 1309| 48|LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) { 1310| 48| lua_Alloc f; 1311| 48| lua_lock(L); ------------------ | | 264| 48|#define lua_lock(L) ((void) 0) ------------------ 1312| 48| if (ud) *ud = G(L)->ud; ------------------ | | 335| 48|#define G(L) (L->l_G) ------------------ | Branch (1312:7): [True: 48, False: 0] ------------------ 1313| 48| f = G(L)->frealloc; ------------------ | | 335| 48|#define G(L) (L->l_G) ------------------ 1314| 48| lua_unlock(L); ------------------ | | 265| 48|#define lua_unlock(L) ((void) 0) ------------------ 1315| 48| return f; 1316| 48|} lua_setwarnf: 1327| 225|void lua_setwarnf (lua_State *L, lua_WarnFunction f, void *ud) { 1328| 225| lua_lock(L); ------------------ | | 264| 225|#define lua_lock(L) ((void) 0) ------------------ 1329| 225| G(L)->ud_warn = ud; ------------------ | | 335| 225|#define G(L) (L->l_G) ------------------ 1330| 225| G(L)->warnf = f; ------------------ | | 335| 225|#define G(L) (L->l_G) ------------------ 1331| 225| lua_unlock(L); ------------------ | | 265| 225|#define lua_unlock(L) ((void) 0) ------------------ 1332| 225|} lua_newuserdatauv: 1343| 12|LUA_API void *lua_newuserdatauv (lua_State *L, size_t size, int nuvalue) { 1344| 12| Udata *u; 1345| 12| lua_lock(L); ------------------ | | 264| 12|#define lua_lock(L) ((void) 0) ------------------ 1346| 12| api_check(L, 0 <= nuvalue && nuvalue < USHRT_MAX, "invalid value"); ------------------ | | 126| 12|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 12|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1347| 12| u = luaS_newudata(L, size, nuvalue); 1348| 12| setuvalue(L, s2v(L->top.p), u); ------------------ | | 443| 12| { TValue *io = (obj); Udata *x_ = (x); \ | | 444| 12| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \ | | ------------------ | | | | 72| 12|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \ | | ------------------ | | | | 390| 12|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 12|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \ | | ------------------ | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 445| 12| checkliveness(L,io); } | | ------------------ | | | | 107| 12| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 192|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | ------------------ | | | | ------------------ | | | | 108| 12| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 1349| 12| api_incr_top(L); ------------------ | | 16| 12|#define api_incr_top(L) {L->top.p++; \ | | 17| 12| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 12|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 12|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 12| "stack overflow");} ------------------ 1350| 12| luaC_checkGC(L); ------------------ | | 172| 12|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 12| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 12|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 8, False: 4] | | | | ------------------ | | | | 169| 12| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 12|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1351| 12| lua_unlock(L); ------------------ | | 265| 12|#define lua_unlock(L) ((void) 0) ------------------ 1352| 12| return getudatamem(u); ------------------ | | 493| 12|#define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 146| 12|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 489| 12| ((nuv) == 0 ? offsetof(Udata0, bindata) \ | | | | ------------------ | | | | | Branch (489:3): [True: 12, False: 0] | | | | ------------------ | | | | 490| 12| : offsetof(Udata, uv) + (sizeof(UValue) * (nuv))) | | ------------------ ------------------ 1353| 12|} lapi.c:index2stack: 95| 223|l_sinline StkId index2stack (lua_State *L, int idx) { 96| 223| CallInfo *ci = L->ci; 97| 223| if (idx > 0) { ------------------ | Branch (97:7): [True: 135, False: 88] ------------------ 98| 135| StkId o = ci->func.p + idx; 99| 135| api_check(L, o < L->top.p, "invalid index"); ------------------ | | 126| 135|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 135|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 100| 135| return o; 101| 135| } 102| 88| else { /* non-positive index */ 103| 88| api_check(L, idx != 0 && -idx <= L->top.p - (ci->func.p + 1), ------------------ | | 126| 88|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 88|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 104| 88| "invalid index"); 105| 88| api_check(L, !ispseudo(idx), "invalid index"); ------------------ | | 126| 88|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 88|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 106| 88| return L->top.p + idx; 107| 88| } 108| 223|} lapi.c:reverse: 227| 462|l_sinline void reverse (lua_State *L, StkId from, StkId to) { 228| 587| for (; from < to; from++, to--) { ------------------ | Branch (228:10): [True: 125, False: 462] ------------------ 229| 125| TValue temp; 230| 125| setobj(L, &temp, s2v(from)); ------------------ | | 119| 125| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 125| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 125|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 125| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 125| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 800|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 125|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 45] | | | | | | | Branch (112:29): [True: 45, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 45] | | | | | | | Branch (112:29): [True: 45, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 45] | | | | | | | Branch (112:29): [True: 45, False: 0] | | | | | | | Branch (112:29): [True: 45, False: 0] | | | | | | | Branch (112:29): [True: 80, False: 45] | | | | | | ------------------ | | | | ------------------ | | | | 108| 125| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 106| 125|#define lua_assert(c) assert(c) | | ------------------ ------------------ 231| 125| setobjs2s(L, from, to); ------------------ | | 129| 125|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 125| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 125| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 125|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 125| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 125| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 1.32k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 125|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 80] | | | | | | | | | Branch (112:29): [True: 80, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 80] | | | | | | | | | Branch (112:29): [True: 80, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 80] | | | | | | | | | Branch (112:29): [True: 80, False: 0] | | | | | | | | | Branch (112:29): [True: 80, False: 0] | | | | | | | | | Branch (112:29): [True: 45, False: 80] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 125| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 125|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 232| 125| setobj2s(L, to, &temp); ------------------ | | 131| 125|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 125| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 125| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 125|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 125| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 125| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 800|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 125|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 45] | | | | | | | | | Branch (112:29): [True: 45, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 45] | | | | | | | | | Branch (112:29): [True: 45, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 45] | | | | | | | | | Branch (112:29): [True: 45, False: 0] | | | | | | | | | Branch (112:29): [True: 45, False: 0] | | | | | | | | | Branch (112:29): [True: 80, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 125| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 125|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 233| 125| } 234| 462|} lapi.c:index2value: 60| 764|static TValue *index2value (lua_State *L, int idx) { 61| 764| CallInfo *ci = L->ci; 62| 764| if (idx > 0) { ------------------ | Branch (62:7): [True: 64, False: 700] ------------------ 63| 64| StkId o = ci->func.p + idx; 64| 64| api_check(L, idx <= ci->top.p - (ci->func.p + 1), "unacceptable index"); ------------------ | | 126| 64|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 64|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 65| 64| if (o >= L->top.p) return &G(L)->nilvalue; ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ | Branch (65:9): [True: 0, False: 64] ------------------ 66| 64| else return s2v(o); ------------------ | | 172| 64|#define s2v(o) (&(o)->val) ------------------ 67| 64| } 68| 700| else if (!ispseudo(idx)) { /* negative index */ ------------------ | | 50| 700|#define ispseudo(i) ((i) <= LUA_REGISTRYINDEX) | | ------------------ | | | | 43| 700|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | | | ------------------ | | | | | | 749| 700|#define LUAI_MAXSTACK 1000000 | | | | ------------------ | | ------------------ ------------------ | Branch (68:12): [True: 636, False: 64] ------------------ 69| 636| api_check(L, idx != 0 && -idx <= L->top.p - (ci->func.p + 1), ------------------ | | 126| 636|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 636|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 70| 636| "invalid index"); 71| 636| return s2v(L->top.p + idx); ------------------ | | 172| 636|#define s2v(o) (&(o)->val) ------------------ 72| 636| } 73| 64| else if (idx == LUA_REGISTRYINDEX) ------------------ | | 43| 64|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 749| 64|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ | Branch (73:12): [True: 64, False: 0] ------------------ 74| 64| return &G(L)->l_registry; ------------------ | | 335| 64|#define G(L) (L->l_G) ------------------ 75| 0| else { /* upvalues */ 76| 0| idx = LUA_REGISTRYINDEX - idx; ------------------ | | 43| 0|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 749| 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) | | ------------------ | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 78| 0| if (ttisCclosure(s2v(ci->func.p))) { /* C closure? */ ------------------ | | 595| 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)); ------------------ | | 604| 0|#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 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) | | ------------------ | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 85| 0| return &G(L)->nilvalue; /* no upvalues */ ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ 86| 0| } 87| 0| } 88| 764|} lapi.c:touserdata: 447| 260|l_sinline void *touserdata (const TValue *o) { 448| 260| switch (ttype(o)) { ------------------ | | 87| 260|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 260|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 449| 108| case LUA_TUSERDATA: return getudatamem(uvalue(o)); ------------------ | | 71| 108|#define LUA_TUSERDATA 7 ------------------ case LUA_TUSERDATA: return getudatamem(uvalue(o)); ------------------ | | 493| 108|#define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 146| 108|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 864|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (136:27): [True: 0, False: 108] | | | | | | | Branch (136:27): [True: 108, False: 0] | | | | | | | Branch (136:27): [True: 0, False: 108] | | | | | | | Branch (136:27): [True: 108, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 489| 864| ((nuv) == 0 ? offsetof(Udata0, bindata) \ | | | | ------------------ | | | | | Branch (489:3): [True: 108, False: 0] | | | | | Branch (489:4): [True: 0, False: 108] | | | | | Branch (489:4): [True: 108, False: 0] | | | | | Branch (489:4): [True: 0, False: 108] | | | | | Branch (489:4): [True: 108, False: 0] | | | | ------------------ | | | | 490| 108| : offsetof(Udata, uv) + (sizeof(UValue) * (nuv))) | | | | ------------------ | | | | | Branch (490:64): [True: 0, False: 0] | | | | | Branch (490:64): [True: 0, False: 0] | | | | | Branch (490:64): [True: 0, False: 0] | | | | | Branch (490:64): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (449:5): [True: 108, False: 152] ------------------ 450| 152| case LUA_TLIGHTUSERDATA: return pvalue(o); ------------------ | | 66| 152|#define LUA_TLIGHTUSERDATA 2 ------------------ case LUA_TLIGHTUSERDATA: return pvalue(o); ------------------ | | 434| 152|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 110| 152|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 152|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (450:5): [True: 152, False: 108] ------------------ 451| 0| default: return NULL; ------------------ | Branch (451:5): [True: 0, False: 260] ------------------ 452| 260| } 453| 260|} lapi.c:auxgetstr: 639| 52|l_sinline int auxgetstr (lua_State *L, const TValue *t, const char *k) { 640| 52| const TValue *slot; 641| 52| TString *str = luaS_new(L, k); 642| 52| if (luaV_fastget(L, t, str, slot, luaH_getstr)) { ------------------ | | 86| 52| (!ttistable(t) \ | | ------------------ | | | | 680| 52|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 52|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 52|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 52] | | | Branch (86:4): [True: 0, False: 52] | | ------------------ | | 87| 52| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 104| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 52|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 208|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 52|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 52] | | | | | | | Branch (110:42): [True: 52, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 89| 104| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 52|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 52|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 52|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 52|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 52|#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) || \ | | | | | | ------------------ | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 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) | | | | ------------------ | | | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 0| "stack overflow");} ------------------ 645| 0| } 646| 52| else { 647| 52| setsvalue2s(L, L->top.p, str); ------------------ | | 377| 52|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 52| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 52| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 52|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 52|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 52|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 52|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 52|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 52| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 52| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 832|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 52|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 52] | | | | | | | | | Branch (112:29): [True: 52, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 52] | | | | | | | | | Branch (112:29): [True: 52, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 52] | | | | | | | | | Branch (112:29): [True: 52, False: 0] | | | | | | | | | Branch (112:29): [True: 52, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 52] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 52| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 648| 52| api_incr_top(L); ------------------ | | 16| 52|#define api_incr_top(L) {L->top.p++; \ | | 17| 52| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 52|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 52|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 52| "stack overflow");} ------------------ 649| 52| luaV_finishget(L, t, s2v(L->top.p - 1), L->top.p - 1, slot); ------------------ | | 172| 52|#define s2v(o) (&(o)->val) ------------------ 650| 52| } 651| 52| lua_unlock(L); ------------------ | | 265| 52|#define lua_unlock(L) ((void) 0) ------------------ 652| 52| return ttype(s2v(L->top.p - 1)); ------------------ | | 87| 52|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 52|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 653| 52|} lapi.c:auxsetstr: 829| 48|static void auxsetstr (lua_State *L, const TValue *t, const char *k) { 830| 48| const TValue *slot; 831| 48| TString *str = luaS_new(L, k); 832| 48| api_checknelems(L, 1); ------------------ | | 33| 48| api_check(L, (n) < (L->top.p - L->ci->func.p), \ | | ------------------ | | | | 126| 48|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 48|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 34| 48| "not enough elements in the stack") ------------------ 833| 48| if (luaV_fastget(L, t, str, slot, luaH_getstr)) { ------------------ | | 86| 48| (!ttistable(t) \ | | ------------------ | | | | 680| 48|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 48|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 48|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 48] | | | Branch (86:4): [True: 0, False: 48] | | ------------------ | | 87| 48| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 96| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 48|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 192|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 48|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 48] | | | | | | | Branch (110:42): [True: 48, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 89| 96| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 48|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 48|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 48|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 48|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 48|#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) || \ | | | | | | | | ------------------ | | | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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] | | | | | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | | | | | Branch (62:26): [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] | | | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | | | Branch (62:26): [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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (183:51): [True: 0, False: 0] | | | | | | | Branch (183:51): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 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| 48| else { 838| 48| setsvalue2s(L, L->top.p, str); /* push 'str' (to make it a TValue) */ ------------------ | | 377| 48|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 48| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 48| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 48|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 48|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 48|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 48|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 48|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 48| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 48| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 768|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 48|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 48] | | | | | | | | | Branch (112:29): [True: 48, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 48] | | | | | | | | | Branch (112:29): [True: 48, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 48] | | | | | | | | | Branch (112:29): [True: 48, False: 0] | | | | | | | | | Branch (112:29): [True: 48, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 48] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 48| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 839| 48| api_incr_top(L); ------------------ | | 16| 48|#define api_incr_top(L) {L->top.p++; \ | | 17| 48| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 48|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 48|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 48| "stack overflow");} ------------------ 840| 48| luaV_finishset(L, t, s2v(L->top.p - 1), s2v(L->top.p - 2), slot); ------------------ | | 172| 48|#define s2v(o) (&(o)->val) ------------------ luaV_finishset(L, t, s2v(L->top.p - 1), s2v(L->top.p - 2), slot); ------------------ | | 172| 48|#define s2v(o) (&(o)->val) ------------------ 841| 48| L->top.p -= 2; /* pop value and key */ 842| 48| } 843| 48| lua_unlock(L); /* lock done by caller */ ------------------ | | 265| 48|#define lua_unlock(L) ((void) 0) ------------------ 844| 48|} lapi.c:f_call: 1036| 45|static void f_call (lua_State *L, void *ud) { 1037| 45| struct CallS *c = cast(struct CallS *, ud); ------------------ | | 136| 45|#define cast(t, exp) ((t)(exp)) ------------------ 1038| 45| luaD_callnoyield(L, c->func, c->nresults); 1039| 45|} luaL_traceback: 132| 40| const char *msg, int level) { 133| 40| luaL_Buffer b; 134| 40| lua_Debug ar; 135| 40| int last = lastlevel(L1); 136| 40| int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1; ------------------ | | 43| 40|#define LEVELS1 10 /* size of the first part of the stack */ ------------------ int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1; ------------------ | | 44| 40|#define LEVELS2 11 /* size of the second part of the stack */ ------------------ int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1; ------------------ | | 43| 0|#define LEVELS1 10 /* size of the first part of the stack */ ------------------ | Branch (136:20): [True: 0, False: 40] ------------------ 137| 40| luaL_buffinit(L, &b); 138| 40| if (msg) { ------------------ | Branch (138:7): [True: 40, False: 0] ------------------ 139| 40| luaL_addstring(&b, msg); 140| 40| luaL_addchar(&b, '\n'); ------------------ | | 208| 40| ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \ | | ------------------ | | | Branch (208:11): [True: 28, False: 12] | | | Branch (208:33): [True: 12, False: 0] | | ------------------ | | 209| 40| ((B)->b[(B)->n++] = (c))) ------------------ 141| 40| } 142| 40| luaL_addstring(&b, "stack traceback:"); 143| 80| while (lua_getstack(L1, level++, &ar)) { ------------------ | Branch (143:10): [True: 40, False: 40] ------------------ 144| 40| if (limit2show-- == 0) { /* too many levels? */ ------------------ | Branch (144:9): [True: 0, False: 40] ------------------ 145| 0| int n = last - level - LEVELS2 + 1; /* number of levels to skip */ ------------------ | | 44| 0|#define LEVELS2 11 /* size of the second part of the stack */ ------------------ 146| 0| lua_pushfstring(L, "\n\t...\t(skipping %d levels)", n); 147| 0| luaL_addvalue(&b); /* add warning about skip */ 148| 0| level += n; /* and skip to last levels */ 149| 0| } 150| 40| else { 151| 40| lua_getinfo(L1, "Slnt", &ar); 152| 40| if (ar.currentline <= 0) ------------------ | Branch (152:11): [True: 0, False: 40] ------------------ 153| 0| lua_pushfstring(L, "\n\t%s: in ", ar.short_src); 154| 40| else 155| 40| lua_pushfstring(L, "\n\t%s:%d: in ", ar.short_src, ar.currentline); 156| 40| luaL_addvalue(&b); 157| 40| pushfuncname(L, &ar); 158| 40| luaL_addvalue(&b); 159| 40| if (ar.istailcall) ------------------ | Branch (159:11): [True: 0, False: 40] ------------------ 160| 0| luaL_addstring(&b, "\n\t(...tail calls...)"); 161| 40| } 162| 40| } 163| 40| luaL_pushresult(&b); 164| 40|} luaL_newmetatable: 311| 12|LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) { 312| 12| if (luaL_getmetatable(L, tname) != LUA_TNIL) /* name already in use? */ ------------------ | | 150| 12|#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) | | ------------------ | | | | 43| 12|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | | | ------------------ | | | | | | 749| 12|#define LUAI_MAXSTACK 1000000 | | | | ------------------ | | ------------------ ------------------ if (luaL_getmetatable(L, tname) != LUA_TNIL) /* name already in use? */ ------------------ | | 64| 12|#define LUA_TNIL 0 ------------------ | Branch (312:7): [True: 0, False: 12] ------------------ 313| 0| return 0; /* leave previous value on top, but return 0 */ 314| 12| lua_pop(L, 1); ------------------ | | 375| 12|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 315| 12| lua_createtable(L, 0, 2); /* create metatable */ 316| 12| lua_pushstring(L, tname); 317| 12| lua_setfield(L, -2, "__name"); /* metatable.__name = tname */ 318| 12| lua_pushvalue(L, -1); 319| 12| lua_setfield(L, LUA_REGISTRYINDEX, tname); /* registry.name = metatable */ ------------------ | | 43| 12|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 749| 12|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ 320| 12| return 1; 321| 12|} luaL_checkstack: 380| 12|LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) { 381| 12| if (l_unlikely(!lua_checkstack(L, space))) { ------------------ | | 697| 12|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 12|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 12] | | | | ------------------ | | ------------------ ------------------ 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| 12|} luaL_prepbuffsize: 575| 12|LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) { 576| 12| return prepbuffsize(B, sz, -1); 577| 12|} luaL_addlstring: 580| 80|LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) { 581| 80| if (l > 0) { /* avoid 'memcpy' when 's' can be NULL */ ------------------ | Branch (581:7): [True: 80, False: 0] ------------------ 582| 80| char *b = prepbuffsize(B, l, -1); 583| 80| memcpy(b, s, l * sizeof(char)); 584| 80| luaL_addsize(B, l); ------------------ | | 211| 80|#define luaL_addsize(B,s) ((B)->n += (s)) ------------------ 585| 80| } 586| 80|} luaL_addstring: 589| 80|LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) { 590| 80| luaL_addlstring(B, s, strlen(s)); 591| 80|} luaL_pushresult: 594| 40|LUALIB_API void luaL_pushresult (luaL_Buffer *B) { 595| 40| lua_State *L = B->L; 596| 40| checkbufferlevel(B, -1); ------------------ | | 523| 40| lua_assert(buffonstack(B) ? lua_touserdata(B->L, idx) != NULL \ | | ------------------ | | | | 176| 40| #define lua_assert(c) assert(c) | | ------------------ | | 524| 40| : lua_touserdata(B->L, idx) == (void*)B) ------------------ 597| 40| lua_pushlstring(L, B->b, B->n); 598| 40| if (buffonstack(B)) ------------------ | | 515| 40|#define buffonstack(B) ((B)->b != (B)->init.b) | | ------------------ | | | Branch (515:24): [True: 12, False: 28] | | ------------------ ------------------ 599| 12| lua_closeslot(L, -2); /* close the box */ 600| 40| lua_remove(L, -2); /* remove box or placeholder 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) | | ------------------ ------------------ 601| 40|} luaL_addvalue: 619| 80|LUALIB_API void luaL_addvalue (luaL_Buffer *B) { 620| 80| lua_State *L = B->L; 621| 80| size_t len; 622| 80| const char *s = lua_tolstring(L, -1, &len); 623| 80| char *b = prepbuffsize(B, len, -2); 624| 80| memcpy(b, s, len * sizeof(char)); 625| 80| luaL_addsize(B, len); ------------------ | | 211| 80|#define luaL_addsize(B,s) ((B)->n += (s)) ------------------ 626| 80| lua_pop(L, 1); /* pop string */ ------------------ | | 375| 80|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 627| 80|} luaL_buffinit: 630| 40|LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) { 631| 40| B->L = L; 632| 40| B->b = B->init.b; 633| 40| B->n = 0; 634| 40| B->size = LUAL_BUFFERSIZE; ------------------ | | 775| 40|#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number))) ------------------ 635| 40| lua_pushlightuserdata(L, (void*)B); /* push placeholder */ 636| 40|} luaL_loadbufferx: 835| 225| const char *name, const char *mode) { 836| 225| LoadS ls; 837| 225| ls.s = buff; 838| 225| ls.size = size; 839| 225| return lua_load(L, getS, &ls, name, mode); 840| 225|} luaL_setfuncs: 933| 12|LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) { 934| 12| luaL_checkstack(L, nup, "too many upvalues"); 935| 36| for (; l->name != NULL; l++) { /* fill the table with given functions */ ------------------ | Branch (935:10): [True: 24, False: 12] ------------------ 936| 24| if (l->func == NULL) /* place holder? */ ------------------ | Branch (936:9): [True: 0, False: 24] ------------------ 937| 0| lua_pushboolean(L, 0); 938| 24| else { 939| 24| int i; 940| 24| for (i = 0; i < nup; i++) /* copy upvalues to the top */ ------------------ | Branch (940:19): [True: 0, False: 24] ------------------ 941| 0| lua_pushvalue(L, -nup); 942| 24| lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */ 943| 24| } 944| 24| lua_setfield(L, -(nup + 2), l->name); 945| 24| } 946| 12| lua_pop(L, nup); /* remove upvalues */ ------------------ | | 375| 12|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 947| 12|} luaL_newstate: 1094| 225|LUALIB_API lua_State *luaL_newstate (void) { 1095| 225| lua_State *L = lua_newstate(l_alloc, NULL); 1096| 225| if (l_likely(L)) { ------------------ | | 696| 225|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 684| 225|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (684:25): [True: 225, False: 0] | | | | ------------------ | | ------------------ ------------------ 1097| 225| lua_atpanic(L, &panic); 1098| 225| lua_setwarnf(L, warnfoff, L); /* default is warnings off */ 1099| 225| } 1100| 225| return L; 1101| 225|} lauxlib.c:lastlevel: 116| 40|static int lastlevel (lua_State *L) { 117| 40| lua_Debug ar; 118| 40| int li = 1, le = 1; 119| | /* find an upper bound */ 120| 80| while (lua_getstack(L, le, &ar)) { li = le; le *= 2; } ------------------ | Branch (120:10): [True: 40, False: 40] ------------------ 121| | /* do a binary search */ 122| 80| while (li < le) { ------------------ | Branch (122:10): [True: 40, False: 40] ------------------ 123| 40| int m = (li + le)/2; 124| 40| if (lua_getstack(L, m, &ar)) li = m + 1; ------------------ | Branch (124:9): [True: 40, False: 0] ------------------ 125| 0| else le = m; 126| 40| } 127| 40| return le - 1; 128| 40|} lauxlib.c:pushfuncname: 100| 40|static void pushfuncname (lua_State *L, lua_Debug *ar) { 101| 40| if (pushglobalfuncname(L, ar)) { /* try first a global name */ ------------------ | Branch (101:7): [True: 0, False: 40] ------------------ 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| 40| else if (*ar->namewhat != '\0') /* is there a name from code? */ ------------------ | Branch (105:12): [True: 0, False: 40] ------------------ 106| 0| lua_pushfstring(L, "%s '%s'", ar->namewhat, ar->name); /* use it */ 107| 40| else if (*ar->what == 'm') /* main? */ ------------------ | Branch (107:12): [True: 40, False: 0] ------------------ 108| 40| lua_pushliteral(L, "main chunk"); ------------------ | | 392| 40|#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| 40|} lauxlib.c:pushglobalfuncname: 79| 40|static int pushglobalfuncname (lua_State *L, lua_Debug *ar) { 80| 40| int top = lua_gettop(L); 81| 40| lua_getinfo(L, "f", ar); /* push function */ 82| 40| lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); ------------------ | | 43| 40|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 749| 40|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); ------------------ | | 31| 40|#define LUA_LOADED_TABLE "_LOADED" ------------------ 83| 40| if (findfield(L, top + 1, 2)) { ------------------ | Branch (83:7): [True: 0, False: 40] ------------------ 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| 40| else { 94| 40| lua_settop(L, top); /* remove function and global table */ 95| 40| return 0; 96| 40| } 97| 40|} lauxlib.c:findfield: 52| 40|static int findfield (lua_State *L, int objidx, int level) { 53| 40| if (level == 0 || !lua_istable(L, -1)) ------------------ | | 384| 40|#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE) | | ------------------ | | | | 69| 40|#define LUA_TTABLE 5 | | ------------------ ------------------ | Branch (53:7): [True: 0, False: 40] | Branch (53:21): [True: 40, False: 0] ------------------ 54| 40| 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 */ ------------------ | | 68| 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| 172|static char *prepbuffsize (luaL_Buffer *B, size_t sz, int boxidx) { 548| 172| checkbufferlevel(B, boxidx); ------------------ | | 523| 172| lua_assert(buffonstack(B) ? lua_touserdata(B->L, idx) != NULL \ | | ------------------ | | | | 176| 172| #define lua_assert(c) assert(c) | | ------------------ | | 524| 172| : lua_touserdata(B->L, idx) == (void*)B) ------------------ 549| 172| if (B->size - B->n >= sz) /* enough space? */ ------------------ | Branch (549:7): [True: 148, False: 24] ------------------ 550| 148| return B->b + B->n; 551| 24| else { 552| 24| lua_State *L = B->L; 553| 24| char *newbuff; 554| 24| size_t newsize = newbuffsize(B, sz); 555| | /* create larger buffer */ 556| 24| if (buffonstack(B)) /* buffer already has a box? */ ------------------ | | 515| 24|#define buffonstack(B) ((B)->b != (B)->init.b) | | ------------------ | | | Branch (515:24): [True: 12, False: 12] | | ------------------ ------------------ 557| 12| newbuff = (char *)resizebox(L, boxidx, newsize); /* resize it */ 558| 12| else { /* no box yet */ 559| 12| lua_remove(L, boxidx); /* remove placeholder */ ------------------ | | 402| 12|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 375| 12|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 560| 12| newbox(L); /* create a new box */ 561| 12| lua_insert(L, boxidx); /* move box to its intended position */ ------------------ | | 400| 12|#define lua_insert(L,idx) lua_rotate(L, (idx), 1) ------------------ 562| 12| lua_toclose(L, boxidx); 563| 12| newbuff = (char *)resizebox(L, boxidx, newsize); 564| 12| memcpy(newbuff, B->b, B->n * sizeof(char)); /* copy original content */ 565| 12| } 566| 24| B->b = newbuff; 567| 24| B->size = newsize; 568| 24| return newbuff + B->n; 569| 24| } 570| 172|} lauxlib.c:newbuffsize: 532| 24|static size_t newbuffsize (luaL_Buffer *B, size_t sz) { 533| 24| size_t newsize = (B->size / 2) * 3; /* buffer size * 1.5 */ 534| 24| if (l_unlikely(MAX_SIZET - sz < B->n)) /* overflow in (B->n + sz)? */ ------------------ | | 697| 24|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 24|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 24] | | | | ------------------ | | ------------------ ------------------ 535| 0| return luaL_error(B->L, "buffer too large"); 536| 24| if (newsize < B->n + sz) /* not big enough? */ ------------------ | Branch (536:7): [True: 12, False: 12] ------------------ 537| 12| newsize = B->n + sz; 538| 24| return newsize; 539| 24|} lauxlib.c:resizebox: 473| 48|static void *resizebox (lua_State *L, int idx, size_t newsize) { 474| 48| void *ud; 475| 48| lua_Alloc allocf = lua_getallocf(L, &ud); 476| 48| UBox *box = (UBox *)lua_touserdata(L, idx); 477| 48| void *temp = allocf(ud, box->box, box->bsize, newsize); 478| 48| if (l_unlikely(temp == NULL && newsize > 0)) { /* allocation error? */ ------------------ | | 697| 48|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 72|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 48] | | | | | Branch (685:46): [True: 24, False: 24] | | | | | Branch (685:46): [True: 0, False: 24] | | | | ------------------ | | ------------------ ------------------ 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| 48| box->box = temp; 483| 48| box->bsize = newsize; 484| 48| return temp; 485| 48|} lauxlib.c:newbox: 501| 12|static void newbox (lua_State *L) { 502| 12| UBox *box = (UBox *)lua_newuserdatauv(L, sizeof(UBox), 0); 503| 12| box->box = NULL; 504| 12| box->bsize = 0; 505| 12| if (luaL_newmetatable(L, "_UBOX*")) /* creating metatable? */ ------------------ | Branch (505:7): [True: 12, False: 0] ------------------ 506| 12| luaL_setfuncs(L, boxmt, 0); /* set its metamethods */ 507| 12| lua_setmetatable(L, -2); 508| 12|} lauxlib.c:boxgc: 488| 24|static int boxgc (lua_State *L) { 489| 24| resizebox(L, 1, 0); 490| 24| return 0; 491| 24|} lauxlib.c:getS: 824| 301|static const char *getS (lua_State *L, void *ud, size_t *size) { 825| 301| LoadS *ls = (LoadS *)ud; 826| 301| (void)L; /* not used */ 827| 301| if (ls->size == 0) return NULL; ------------------ | Branch (827:7): [True: 76, False: 225] ------------------ 828| 225| *size = ls->size; 829| 225| ls->size = 0; 830| 225| return ls->s; 831| 301|} lauxlib.c:l_alloc: 1017| 2.91M|static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) { 1018| 2.91M| (void)ud; (void)osize; /* not used */ 1019| 2.91M| if (nsize == 0) { ------------------ | Branch (1019:7): [True: 1.44M, False: 1.47M] ------------------ 1020| 1.44M| free(ptr); 1021| 1.44M| return NULL; 1022| 1.44M| } 1023| 1.47M| else 1024| 1.47M| return realloc(ptr, nsize); 1025| 2.91M|} luaK_semerror: 46| 3|l_noret luaK_semerror (LexState *ls, const char *msg) { 47| 3| ls->t.token = 0; /* remove "near " from final message */ 48| 3| luaX_syntaxerror(ls, msg); 49| 3|} luaK_exp2const: 84| 516|int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v) { 85| 516| if (hasjumps(e)) ------------------ | | 38| 516|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 8, False: 508] | | ------------------ ------------------ 86| 8| return 0; /* not a constant */ 87| 508| switch (e->k) { 88| 6| case VFALSE: ------------------ | Branch (88:5): [True: 6, False: 502] ------------------ 89| 6| setbfvalue(v); ------------------ | | 250| 6|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 6|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 90| 6| return 1; 91| 69| case VTRUE: ------------------ | Branch (91:5): [True: 69, False: 439] ------------------ 92| 69| setbtvalue(v); ------------------ | | 251| 69|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 69|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 93| 69| return 1; 94| 196| case VNIL: ------------------ | Branch (94:5): [True: 196, False: 312] ------------------ 95| 196| setnilvalue(v); ------------------ | | 200| 196|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 196|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 96| 196| return 1; 97| 145| case VKSTR: { ------------------ | Branch (97:5): [True: 145, False: 363] ------------------ 98| 145| setsvalue(fs->ls->L, v, e->u.strval); ------------------ | | 372| 145| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 145| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 145|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 145|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 145|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 145|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 145|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 145| checkliveness(L,io); } | | ------------------ | | | | 107| 145| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 2.32k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 145|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 145] | | | | | | | Branch (112:29): [True: 145, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 145] | | | | | | | Branch (112:29): [True: 145, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 145] | | | | | | | Branch (112:29): [True: 145, False: 0] | | | | | | | Branch (112:29): [True: 145, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 145] | | | | | | ------------------ | | | | ------------------ | | | | 108| 145| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 99| 145| return 1; 100| 145| } 101| 0| case VCONST: { ------------------ | Branch (101:5): [True: 0, False: 508] ------------------ 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) || \ | | | | ------------------ | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 106| 0|#define lua_assert(c) assert(c) | | ------------------ ------------------ 103| 0| return 1; 104| 0| } 105| 92| default: return tonumeral(e, v); ------------------ | Branch (105:5): [True: 92, False: 416] ------------------ 106| 508| } 107| 508|} luaK_nil: 131| 168k|void luaK_nil (FuncState *fs, int from, int n) { 132| 168k| int l = from + n - 1; /* last register to set nil */ 133| 168k| Instruction *previous = previousinstruction(fs); 134| 168k| if (GET_OPCODE(*previous) == OP_LOADNIL) { /* previous is LOADNIL? */ ------------------ | | 114| 168k|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 168k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (134:7): [True: 1.01k, False: 167k] ------------------ 135| 1.01k| int pfrom = GETARG_A(*previous); /* get previous range */ ------------------ | | 125| 1.01k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 1.01k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 1.01k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 1.01k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 136| 1.01k| int pl = pfrom + GETARG_B(*previous); ------------------ | | 128| 1.01k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 1.01k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 1.01k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 137| 1.01k| if ((pfrom <= from && from <= pl + 1) || ------------------ | Branch (137:10): [True: 881, False: 136] | Branch (137:27): [True: 745, False: 136] ------------------ 138| 1.01k| (from <= pfrom && pfrom <= l + 1)) { /* can connect both? */ ------------------ | Branch (138:10): [True: 136, False: 136] | Branch (138:27): [True: 0, False: 136] ------------------ 139| 745| if (pfrom < from) from = pfrom; /* from = min(from, pfrom) */ ------------------ | Branch (139:11): [True: 745, False: 0] ------------------ 140| 745| if (pl > l) l = pl; /* l = max(l, pl) */ ------------------ | Branch (140:11): [True: 65, False: 680] ------------------ 141| 745| SETARG_A(*previous, from); ------------------ | | 126| 745|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 745|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 745|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 745|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 745| ((cast(Instruction, v)<lasttarget = fs->pc; 234| 8.19M| return fs->pc; 235| 8.19M|} luaK_patchlist: 306| 2.10M|void luaK_patchlist (FuncState *fs, int list, int target) { 307| 2.10M| lua_assert(target <= fs->pc); ------------------ | | 106| 2.10M|#define lua_assert(c) assert(c) ------------------ 308| 2.10M| patchlistaux(fs, list, target, NO_REG, target); ------------------ | | 182| 2.10M|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 2.10M|#define MAXARG_A ((1<f; 384| | /* put new instruction in code array */ 385| 23.6M| luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction, ------------------ | | 67| 23.6M| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 47.2M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 23.6M| luaM_limitN(limit,t),e))) ------------------ 386| 23.6M| MAX_INT, "opcodes"); 387| 23.6M| f->code[fs->pc++] = i; 388| 23.6M| savelineinfo(fs, f, fs->ls->lastline); 389| 23.6M| return fs->pc - 1; /* index of new instruction */ 390| 23.6M|} luaK_codeABCk: 397| 19.3M|int luaK_codeABCk (FuncState *fs, OpCode o, int a, int b, int c, int k) { 398| 19.3M| lua_assert(getOpMode(o) == iABC); ------------------ | | 106| 19.3M|#define lua_assert(c) assert(c) ------------------ 399| 19.3M| lua_assert(a <= MAXARG_A && b <= MAXARG_B && ------------------ | | 106| 19.3M|#define lua_assert(c) assert(c) ------------------ 400| 19.3M| c <= MAXARG_C && (k & ~1) == 0); 401| 19.3M| return luaK_code(fs, CREATE_ABCk(o, a, b, c, k)); ------------------ | | 156| 19.3M|#define CREATE_ABCk(o,a,b,c,k) ((cast(Instruction, o)<freereg + n; 468| 14.3M| if (newstack > fs->f->maxstacksize) { ------------------ | Branch (468:7): [True: 22.6k, False: 14.3M] ------------------ 469| 22.6k| if (newstack >= MAXREGS) ------------------ | | 35| 22.6k|#define MAXREGS 255 ------------------ | Branch (469:9): [True: 0, False: 22.6k] ------------------ 470| 0| luaX_syntaxerror(fs->ls, 471| 0| "function or expression needs too many registers"); 472| 22.6k| fs->f->maxstacksize = cast_byte(newstack); ------------------ | | 143| 22.6k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 22.6k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 473| 22.6k| } 474| 14.3M|} luaK_reserveregs: 480| 14.3M|void luaK_reserveregs (FuncState *fs, int n) { 481| 14.3M| luaK_checkstack(fs, n); 482| 14.3M| fs->freereg += n; 483| 14.3M|} luaK_int: 672| 23.2k|void luaK_int (FuncState *fs, int reg, lua_Integer i) { 673| 23.2k| if (fitsBx(i)) ------------------ | Branch (673:7): [True: 21.1k, False: 2.10k] ------------------ 674| 21.1k| codeAsBx(fs, OP_LOADI, reg, cast_int(i)); ------------------ | | 141| 21.1k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 21.1k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 675| 2.10k| else 676| 2.10k| luaK_codek(fs, reg, luaK_intK(fs, i)); 677| 23.2k|} luaK_setreturns: 721| 1.79k|void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) { 722| 1.79k| Instruction *pc = &getinstruction(fs, e); ------------------ | | 55| 1.79k|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 723| 1.79k| if (e->k == VCALL) /* expression is an open function call? */ ------------------ | Branch (723:7): [True: 1.74k, False: 54] ------------------ 724| 1.79k| SETARG_C(*pc, nresults + 1); ------------------ | | 134| 1.74k|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 1.74k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 1.74k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 1.74k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 1.74k| ((cast(Instruction, v)<k == VVARARG); ------------------ | | 106| 54|#define lua_assert(c) assert(c) ------------------ 727| 54| SETARG_C(*pc, nresults + 1); ------------------ | | 134| 54|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 54|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 54|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 54|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 54| ((cast(Instruction, v)<freereg); ------------------ | | 126| 54|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 54|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 54|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 54|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 54| ((cast(Instruction, v)<k == VCALL) { /* expression is an open function call? */ ------------------ | Branch (755:7): [True: 161k, False: 18.3k] ------------------ 756| | /* already returns 1 value */ 757| 161k| lua_assert(GETARG_C(getinstruction(fs, e)) == 2); ------------------ | | 106| 161k|#define lua_assert(c) assert(c) ------------------ 758| 161k| e->k = VNONRELOC; /* result has fixed position */ 759| 161k| e->u.info = GETARG_A(getinstruction(fs, e)); ------------------ | | 125| 161k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 161k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 161k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 161k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 760| 161k| } 761| 18.3k| else if (e->k == VVARARG) { ------------------ | Branch (761:12): [True: 817, False: 17.5k] ------------------ 762| 817| SETARG_C(getinstruction(fs, e), 2); ------------------ | | 134| 817|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 817|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 817|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 817|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 817| ((cast(Instruction, v)<k = VRELOC; /* can relocate its simple result */ 764| 817| } 765| 179k|} luaK_dischargevars: 772| 58.3M|void luaK_dischargevars (FuncState *fs, expdesc *e) { 773| 58.3M| switch (e->k) { 774| 183k| case VCONST: { ------------------ | Branch (774:5): [True: 183k, False: 58.1M] ------------------ 775| 183k| const2exp(const2val(fs, e), e); 776| 183k| break; 777| 0| } 778| 137k| case VLOCAL: { /* already in a register */ ------------------ | Branch (778:5): [True: 137k, False: 58.1M] ------------------ 779| 137k| e->u.info = e->u.var.ridx; 780| 137k| e->k = VNONRELOC; /* becomes a non-relocatable value */ 781| 137k| break; 782| 0| } 783| 1.93M| case VUPVAL: { /* move value to some (pending) register */ ------------------ | Branch (783:5): [True: 1.93M, False: 56.3M] ------------------ 784| 1.93M| e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0); ------------------ | | 48| 1.93M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 785| 1.93M| e->k = VRELOC; 786| 1.93M| break; 787| 0| } 788| 2.75M| case VINDEXUP: { ------------------ | Branch (788:5): [True: 2.75M, False: 55.5M] ------------------ 789| 2.75M| e->u.info = luaK_codeABC(fs, OP_GETTABUP, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 2.75M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 790| 2.75M| e->k = VRELOC; 791| 2.75M| break; 792| 0| } 793| 229| case VINDEXI: { ------------------ | Branch (793:5): [True: 229, False: 58.3M] ------------------ 794| 229| freereg(fs, e->u.ind.t); 795| 229| e->u.info = luaK_codeABC(fs, OP_GETI, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 229|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 796| 229| e->k = VRELOC; 797| 229| break; 798| 0| } 799| 280k| case VINDEXSTR: { ------------------ | Branch (799:5): [True: 280k, False: 58.0M] ------------------ 800| 280k| freereg(fs, e->u.ind.t); 801| 280k| e->u.info = luaK_codeABC(fs, OP_GETFIELD, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 280k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 802| 280k| e->k = VRELOC; 803| 280k| break; 804| 0| } 805| 1.93M| case VINDEXED: { ------------------ | Branch (805:5): [True: 1.93M, False: 56.3M] ------------------ 806| 1.93M| freeregs(fs, e->u.ind.t, e->u.ind.idx); 807| 1.93M| e->u.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 1.93M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 808| 1.93M| e->k = VRELOC; 809| 1.93M| break; 810| 0| } 811| 162k| case VVARARG: case VCALL: { ------------------ | Branch (811:5): [True: 817, False: 58.3M] | Branch (811:19): [True: 161k, False: 58.1M] ------------------ 812| 162k| luaK_setoneret(fs, e); 813| 162k| break; 814| 817| } 815| 50.9M| default: break; /* there is one value available (somewhere) */ ------------------ | Branch (815:5): [True: 50.9M, False: 7.39M] ------------------ 816| 58.3M| } 817| 58.3M|} luaK_exp2nextreg: 942| 14.3M|void luaK_exp2nextreg (FuncState *fs, expdesc *e) { 943| 14.3M| luaK_dischargevars(fs, e); 944| 14.3M| freeexp(fs, e); 945| 14.3M| luaK_reserveregs(fs, 1); 946| 14.3M| exp2reg(fs, e, fs->freereg - 1); 947| 14.3M|} luaK_exp2anyreg: 954| 19.1M|int luaK_exp2anyreg (FuncState *fs, expdesc *e) { 955| 19.1M| luaK_dischargevars(fs, e); 956| 19.1M| if (e->k == VNONRELOC) { /* expression already has a register? */ ------------------ | Branch (956:7): [True: 5.15M, False: 13.9M] ------------------ 957| 5.15M| if (!hasjumps(e)) /* no jumps? */ ------------------ | | 38| 5.15M|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (957:9): [True: 5.14M, False: 7.52k] ------------------ 958| 5.14M| return e->u.info; /* result is already in a register */ 959| 7.52k| if (e->u.info >= luaY_nvarstack(fs)) { /* reg. is not a local? */ ------------------ | Branch (959:9): [True: 5.87k, False: 1.64k] ------------------ 960| 5.87k| exp2reg(fs, e, e->u.info); /* put final result in it */ 961| 5.87k| return e->u.info; 962| 5.87k| } 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| 7.52k| } 967| 13.9M| luaK_exp2nextreg(fs, e); /* default: use next available register */ 968| 13.9M| return e->u.info; 969| 19.1M|} luaK_exp2anyregup: 976| 4.99M|void luaK_exp2anyregup (FuncState *fs, expdesc *e) { 977| 4.99M| if (e->k != VUPVAL || hasjumps(e)) ------------------ | | 38| 4.69M|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 0, False: 4.69M] | | ------------------ ------------------ | Branch (977:7): [True: 295k, False: 4.69M] ------------------ 978| 295k| luaK_exp2anyreg(fs, e); 979| 4.99M|} luaK_exp2val: 986| 12.6k|void luaK_exp2val (FuncState *fs, expdesc *e) { 987| 12.6k| if (hasjumps(e)) ------------------ | | 38| 12.6k|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 611, False: 12.0k] | | ------------------ ------------------ 988| 611| luaK_exp2anyreg(fs, e); 989| 12.0k| else 990| 12.0k| luaK_dischargevars(fs, e); 991| 12.6k|} luaK_storevar: 1048| 27.5k|void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) { 1049| 27.5k| switch (var->k) { 1050| 4.44k| case VLOCAL: { ------------------ | Branch (1050:5): [True: 4.44k, False: 23.1k] ------------------ 1051| 4.44k| freeexp(fs, ex); 1052| 4.44k| exp2reg(fs, ex, var->u.var.ridx); /* compute 'ex' into proper place */ 1053| 4.44k| return; 1054| 0| } 1055| 1.75k| case VUPVAL: { ------------------ | Branch (1055:5): [True: 1.75k, False: 25.8k] ------------------ 1056| 1.75k| int e = luaK_exp2anyreg(fs, ex); 1057| 1.75k| luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0); ------------------ | | 48| 1.75k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1058| 1.75k| break; 1059| 0| } 1060| 14.0k| case VINDEXUP: { ------------------ | Branch (1060:5): [True: 14.0k, False: 13.5k] ------------------ 1061| 14.0k| codeABRK(fs, OP_SETTABUP, var->u.ind.t, var->u.ind.idx, ex); 1062| 14.0k| break; 1063| 0| } 1064| 165| case VINDEXI: { ------------------ | Branch (1064:5): [True: 165, False: 27.3k] ------------------ 1065| 165| codeABRK(fs, OP_SETI, var->u.ind.t, var->u.ind.idx, ex); 1066| 165| break; 1067| 0| } 1068| 4.63k| case VINDEXSTR: { ------------------ | Branch (1068:5): [True: 4.63k, False: 22.9k] ------------------ 1069| 4.63k| codeABRK(fs, OP_SETFIELD, var->u.ind.t, var->u.ind.idx, ex); 1070| 4.63k| break; 1071| 0| } 1072| 2.53k| case VINDEXED: { ------------------ | Branch (1072:5): [True: 2.53k, False: 25.0k] ------------------ 1073| 2.53k| codeABRK(fs, OP_SETTABLE, var->u.ind.t, var->u.ind.idx, ex); 1074| 2.53k| break; 1075| 0| } 1076| 0| default: lua_assert(0); /* invalid var kind to store */ ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ | Branch (1076:5): [True: 0, False: 27.5k] ------------------ 1077| 27.5k| } 1078| 23.1k| freeexp(fs, ex); 1079| 23.1k|} luaK_self: 1085| 542|void luaK_self (FuncState *fs, expdesc *e, expdesc *key) { 1086| 542| int ereg; 1087| 542| luaK_exp2anyreg(fs, e); 1088| 542| ereg = e->u.info; /* register where 'e' was placed */ 1089| 542| freeexp(fs, e); 1090| 542| e->u.info = fs->freereg; /* base register for op_self */ 1091| 542| e->k = VNONRELOC; /* self expression has a fixed register */ 1092| 542| luaK_reserveregs(fs, 2); /* function and 'self' produced by op_self */ 1093| 542| codeABRK(fs, OP_SELF, e->u.info, ereg, key); 1094| 542| freeexp(fs, key); 1095| 542|} luaK_goiftrue: 1133| 13.1k|void luaK_goiftrue (FuncState *fs, expdesc *e) { 1134| 13.1k| int pc; /* pc of new jump */ 1135| 13.1k| luaK_dischargevars(fs, e); 1136| 13.1k| switch (e->k) { 1137| 2.45k| case VJMP: { /* condition? */ ------------------ | Branch (1137:5): [True: 2.45k, False: 10.7k] ------------------ 1138| 2.45k| negatecondition(fs, e); /* jump when it is false */ 1139| 2.45k| pc = e->u.info; /* save jump position */ 1140| 2.45k| break; 1141| 0| } 1142| 2.18k| case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: { ------------------ | Branch (1142:5): [True: 0, False: 13.1k] | Branch (1142:14): [True: 17, False: 13.1k] | Branch (1142:26): [True: 886, False: 12.2k] | Branch (1142:38): [True: 1.03k, False: 12.1k] | Branch (1142:50): [True: 242, False: 12.9k] ------------------ 1143| 2.18k| pc = NO_JUMP; /* always true; do nothing */ ------------------ | | 20| 2.18k|#define NO_JUMP (-1) ------------------ 1144| 2.18k| break; 1145| 1.94k| } 1146| 8.52k| default: { ------------------ | Branch (1146:5): [True: 8.52k, False: 4.63k] ------------------ 1147| 8.52k| pc = jumponcond(fs, e, 0); /* jump when false */ 1148| 8.52k| break; 1149| 1.94k| } 1150| 13.1k| } 1151| 13.1k| luaK_concat(fs, &e->f, pc); /* insert new jump in false list */ 1152| 13.1k| luaK_patchtohere(fs, e->t); /* true list jumps to here (to go through) */ 1153| 13.1k| e->t = NO_JUMP; ------------------ | | 20| 13.1k|#define NO_JUMP (-1) ------------------ 1154| 13.1k|} luaK_goiffalse: 1160| 67.4k|void luaK_goiffalse (FuncState *fs, expdesc *e) { 1161| 67.4k| int pc; /* pc of new jump */ 1162| 67.4k| luaK_dischargevars(fs, e); 1163| 67.4k| switch (e->k) { 1164| 57.3k| case VJMP: { ------------------ | Branch (1164:5): [True: 57.3k, False: 10.0k] ------------------ 1165| 57.3k| pc = e->u.info; /* already jump if true */ 1166| 57.3k| break; 1167| 0| } 1168| 0| case VNIL: case VFALSE: { ------------------ | Branch (1168:5): [True: 0, False: 67.4k] | Branch (1168:16): [True: 0, False: 67.4k] ------------------ 1169| 0| pc = NO_JUMP; /* always false; do nothing */ ------------------ | | 20| 0|#define NO_JUMP (-1) ------------------ 1170| 0| break; 1171| 0| } 1172| 10.0k| default: { ------------------ | Branch (1172:5): [True: 10.0k, False: 57.3k] ------------------ 1173| 10.0k| pc = jumponcond(fs, e, 1); /* jump if true */ 1174| 10.0k| break; 1175| 0| } 1176| 67.4k| } 1177| 67.4k| luaK_concat(fs, &e->t, pc); /* insert new jump in 't' list */ 1178| 67.4k| luaK_patchtohere(fs, e->f); /* false list jumps to here (to go through) */ 1179| 67.4k| e->f = NO_JUMP; ------------------ | | 20| 67.4k|#define NO_JUMP (-1) ------------------ 1180| 67.4k|} luaK_indexed: 1278| 4.99M|void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) { 1279| 4.99M| if (k->k == VKSTR) ------------------ | Branch (1279:7): [True: 4.98M, False: 12.6k] ------------------ 1280| 4.98M| str2K(fs, k); 1281| 4.99M| lua_assert(!hasjumps(t) && ------------------ | | 106| 4.99M|#define lua_assert(c) assert(c) ------------------ 1282| 4.99M| (t->k == VLOCAL || t->k == VNONRELOC || t->k == VUPVAL)); 1283| 4.99M| if (t->k == VUPVAL && !isKstr(fs, k)) /* upvalue indexed by non 'Kstr'? */ ------------------ | Branch (1283:7): [True: 4.69M, False: 295k] | Branch (1283:25): [True: 1.93M, False: 2.76M] ------------------ 1284| 1.93M| luaK_exp2anyreg(fs, t); /* put it in a register */ 1285| 4.99M| if (t->k == VUPVAL) { ------------------ | Branch (1285:7): [True: 2.76M, False: 2.22M] ------------------ 1286| 2.76M| lua_assert(isKstr(fs, k)); ------------------ | | 106| 2.76M|#define lua_assert(c) assert(c) ------------------ 1287| 2.76M| t->u.ind.t = t->u.info; /* upvalue index */ 1288| 2.76M| t->u.ind.idx = k->u.info; /* literal short string */ 1289| 2.76M| t->k = VINDEXUP; 1290| 2.76M| } 1291| 2.22M| else { 1292| | /* register index of the table */ 1293| 2.22M| t->u.ind.t = (t->k == VLOCAL) ? t->u.var.ridx: t->u.info; ------------------ | Branch (1293:18): [True: 0, False: 2.22M] ------------------ 1294| 2.22M| if (isKstr(fs, k)) { ------------------ | Branch (1294:9): [True: 285k, False: 1.94M] ------------------ 1295| 285k| t->u.ind.idx = k->u.info; /* literal short string */ 1296| 285k| t->k = VINDEXSTR; 1297| 285k| } 1298| 1.94M| else if (isCint(k)) { ------------------ | Branch (1298:14): [True: 395, False: 1.94M] ------------------ 1299| 395| t->u.ind.idx = cast_int(k->u.ival); /* int. constant in proper range */ ------------------ | | 141| 395|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 395|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1300| 395| t->k = VINDEXI; 1301| 395| } 1302| 1.94M| else { 1303| 1.94M| t->u.ind.idx = luaK_exp2anyreg(fs, k); /* register */ 1304| 1.94M| t->k = VINDEXED; 1305| 1.94M| } 1306| 2.22M| } 1307| 4.99M|} luaK_prefix: 1613| 119k|void luaK_prefix (FuncState *fs, UnOpr opr, expdesc *e, int line) { 1614| 119k| static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP}; ------------------ | | 20| 119k|#define NO_JUMP (-1) ------------------ static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP}; ------------------ | | 20| 119k|#define NO_JUMP (-1) ------------------ 1615| 119k| luaK_dischargevars(fs, e); 1616| 119k| switch (opr) { 1617| 107k| case OPR_MINUS: case OPR_BNOT: /* use 'ef' as fake 2nd operand */ ------------------ | Branch (1617:5): [True: 61.7k, False: 58.1k] | Branch (1617:21): [True: 45.3k, False: 74.5k] ------------------ 1618| 107k| if (constfolding(fs, opr + LUA_OPUNM, e, &ef)) ------------------ | | 227| 107k|#define LUA_OPUNM 12 ------------------ | Branch (1618:11): [True: 28.6k, False: 78.3k] ------------------ 1619| 28.6k| break; 1620| | /* else */ /* FALLTHROUGH */ 1621| 89.1k| case OPR_LEN: ------------------ | Branch (1621:5): [True: 10.7k, False: 109k] ------------------ 1622| 89.1k| codeunexpval(fs, unopr2op(opr), e, line); 1623| 89.1k| break; 1624| 2.01k| case OPR_NOT: codenot(fs, e); break; ------------------ | Branch (1624:5): [True: 2.01k, False: 117k] ------------------ 1625| 0| default: lua_assert(0); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ | Branch (1625:5): [True: 0, False: 119k] ------------------ 1626| 119k| } 1627| 119k|} luaK_infix: 1634| 5.11M|void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) { 1635| 5.11M| luaK_dischargevars(fs, v); 1636| 5.11M| switch (op) { 1637| 12.1k| case OPR_AND: { ------------------ | Branch (1637:5): [True: 12.1k, False: 5.10M] ------------------ 1638| 12.1k| luaK_goiftrue(fs, v); /* go ahead only if 'v' is true */ 1639| 12.1k| break; 1640| 0| } 1641| 67.4k| case OPR_OR: { ------------------ | Branch (1641:5): [True: 67.4k, False: 5.04M] ------------------ 1642| 67.4k| luaK_goiffalse(fs, v); /* go ahead only if 'v' is false */ 1643| 67.4k| break; 1644| 0| } 1645| 13.6k| case OPR_CONCAT: { ------------------ | Branch (1645:5): [True: 13.6k, False: 5.10M] ------------------ 1646| 13.6k| luaK_exp2nextreg(fs, v); /* operand must be on the stack */ 1647| 13.6k| break; 1648| 0| } 1649| 19.0k| case OPR_ADD: case OPR_SUB: ------------------ | Branch (1649:5): [True: 3.28k, False: 5.11M] | Branch (1649:19): [True: 15.8k, False: 5.10M] ------------------ 1650| 2.59M| case OPR_MUL: case OPR_DIV: case OPR_IDIV: ------------------ | Branch (1650:5): [True: 17.3k, False: 5.09M] | Branch (1650:19): [True: 2.54M, False: 2.56M] | Branch (1650:33): [True: 13.6k, False: 5.10M] ------------------ 1651| 2.79M| case OPR_MOD: case OPR_POW: ------------------ | Branch (1651:5): [True: 11.2k, False: 5.10M] | Branch (1651:19): [True: 185k, False: 4.93M] ------------------ 1652| 2.82M| case OPR_BAND: case OPR_BOR: case OPR_BXOR: ------------------ | Branch (1652:5): [True: 8.79k, False: 5.10M] | Branch (1652:20): [True: 3.22k, False: 5.11M] | Branch (1652:34): [True: 21.0k, False: 5.09M] ------------------ 1653| 2.94M| case OPR_SHL: case OPR_SHR: { ------------------ | Branch (1653:5): [True: 113k, False: 5.00M] | Branch (1653:19): [True: 454, False: 5.11M] ------------------ 1654| 2.94M| if (!tonumeral(v, NULL)) ------------------ | Branch (1654:11): [True: 2.87M, False: 68.8k] ------------------ 1655| 2.87M| luaK_exp2anyreg(fs, v); 1656| | /* else keep numeral, which may be folded or used as an immediate 1657| | operand */ 1658| 2.94M| break; 1659| 2.94M| } 1660| 3.55k| case OPR_EQ: case OPR_NE: { ------------------ | Branch (1660:5): [True: 1.77k, False: 5.11M] | Branch (1660:18): [True: 1.78k, False: 5.11M] ------------------ 1661| 3.55k| if (!tonumeral(v, NULL)) ------------------ | Branch (1661:11): [True: 1.96k, False: 1.58k] ------------------ 1662| 1.96k| exp2RK(fs, v); 1663| | /* else keep numeral, which may be an immediate operand */ 1664| 3.55k| break; 1665| 1.77k| } 1666| 2.06M| case OPR_LT: case OPR_LE: ------------------ | Branch (1666:5): [True: 2.05M, False: 3.05M] | Branch (1666:18): [True: 2.24k, False: 5.11M] ------------------ 1667| 2.07M| case OPR_GT: case OPR_GE: { ------------------ | Branch (1667:5): [True: 15.5k, False: 5.10M] | Branch (1667:18): [True: 632, False: 5.11M] ------------------ 1668| 2.07M| int dummy, dummy2; 1669| 2.07M| if (!isSCnumber(v, &dummy, &dummy2)) ------------------ | Branch (1669:11): [True: 2.07M, False: 3.38k] ------------------ 1670| 2.07M| luaK_exp2anyreg(fs, v); 1671| | /* else keep numeral, which may be an immediate operand */ 1672| 2.07M| break; 1673| 2.07M| } 1674| 0| default: lua_assert(0); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ | Branch (1674:5): [True: 0, False: 5.11M] ------------------ 1675| 5.11M| } 1676| 5.11M|} luaK_posfix: 1704| 5.11M| expdesc *e1, expdesc *e2, int line) { 1705| 5.11M| luaK_dischargevars(fs, e2); 1706| 5.11M| if (foldbinop(opr) && constfolding(fs, opr + LUA_OPADD, e1, e2)) ------------------ | | 45| 10.2M|#define foldbinop(op) ((op) <= OPR_SHR) | | ------------------ | | | Branch (45:23): [True: 2.94M, False: 2.17M] | | ------------------ ------------------ if (foldbinop(opr) && constfolding(fs, opr + LUA_OPADD, e1, e2)) ------------------ | | 215| 2.94M|#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ ------------------ | Branch (1706:25): [True: 51.4k, False: 2.88M] ------------------ 1707| 51.4k| return; /* done by folding */ 1708| 5.06M| switch (opr) { 1709| 11.5k| case OPR_AND: { ------------------ | Branch (1709:5): [True: 11.5k, False: 5.05M] ------------------ 1710| 11.5k| lua_assert(e1->t == NO_JUMP); /* list closed by 'luaK_infix' */ ------------------ | | 106| 11.5k|#define lua_assert(c) assert(c) ------------------ 1711| 11.5k| luaK_concat(fs, &e2->f, e1->f); 1712| 11.5k| *e1 = *e2; 1713| 11.5k| break; 1714| 11.5k| } 1715| 67.1k| case OPR_OR: { ------------------ | Branch (1715:5): [True: 67.1k, False: 4.99M] ------------------ 1716| 67.1k| lua_assert(e1->f == NO_JUMP); /* list closed by 'luaK_infix' */ ------------------ | | 106| 67.1k|#define lua_assert(c) assert(c) ------------------ 1717| 67.1k| luaK_concat(fs, &e2->t, e1->t); 1718| 67.1k| *e1 = *e2; 1719| 67.1k| break; 1720| 67.1k| } 1721| 13.5k| case OPR_CONCAT: { /* e1 .. e2 */ ------------------ | Branch (1721:5): [True: 13.5k, False: 5.04M] ------------------ 1722| 13.5k| luaK_exp2nextreg(fs, e2); 1723| 13.5k| codeconcat(fs, e1, e2, line); 1724| 13.5k| break; 1725| 67.1k| } 1726| 17.0k| case OPR_ADD: case OPR_MUL: { ------------------ | Branch (1726:5): [True: 2.21k, False: 5.06M] | Branch (1726:19): [True: 14.8k, False: 5.04M] ------------------ 1727| 17.0k| codecommutative(fs, opr, e1, e2, line); 1728| 17.0k| break; 1729| 2.21k| } 1730| 13.0k| case OPR_SUB: { ------------------ | Branch (1730:5): [True: 13.0k, False: 5.04M] ------------------ 1731| 13.0k| if (finishbinexpneg(fs, e1, e2, OP_ADDI, line, TM_SUB)) ------------------ | Branch (1731:11): [True: 6.94k, False: 6.12k] ------------------ 1732| 6.94k| break; /* coded as (r1 + -I) */ 1733| | /* ELSE */ 1734| 13.0k| } /* FALLTHROUGH */ 1735| 2.72M| case OPR_DIV: case OPR_IDIV: case OPR_MOD: case OPR_POW: { ------------------ | Branch (1735:5): [True: 2.54M, False: 2.51M] | Branch (1735:19): [True: 13.6k, False: 5.04M] | Branch (1735:34): [True: 7.81k, False: 5.05M] | Branch (1735:48): [True: 146k, False: 4.91M] ------------------ 1736| 2.72M| codearith(fs, opr, e1, e2, 0, line); 1737| 2.72M| break; 1738| 2.57M| } 1739| 30.4k| case OPR_BAND: case OPR_BOR: case OPR_BXOR: { ------------------ | Branch (1739:5): [True: 7.43k, False: 5.05M] | Branch (1739:20): [True: 3.19k, False: 5.05M] | Branch (1739:34): [True: 19.7k, False: 5.04M] ------------------ 1740| 30.4k| codebitwise(fs, opr, e1, e2, line); 1741| 30.4k| break; 1742| 10.6k| } 1743| 113k| case OPR_SHL: { ------------------ | Branch (1743:5): [True: 113k, False: 4.94M] ------------------ 1744| 113k| if (isSCint(e1)) { ------------------ | Branch (1744:11): [True: 2.43k, False: 110k] ------------------ 1745| 2.43k| swapexps(e1, e2); 1746| 2.43k| codebini(fs, OP_SHLI, e1, e2, 1, line, TM_SHL); /* I << r2 */ 1747| 2.43k| } 1748| 110k| else if (finishbinexpneg(fs, e1, e2, OP_SHRI, line, TM_SHL)) { ------------------ | Branch (1748:16): [True: 562, False: 110k] ------------------ 1749| 562| /* coded as (r1 >> -I) */; 1750| 562| } 1751| 110k| else /* regular case (two registers) */ 1752| 110k| codebinexpval(fs, opr, e1, e2, line); 1753| 113k| break; 1754| 10.6k| } 1755| 318| case OPR_SHR: { ------------------ | Branch (1755:5): [True: 318, False: 5.06M] ------------------ 1756| 318| if (isSCint(e2)) ------------------ | Branch (1756:11): [True: 29, False: 289] ------------------ 1757| 29| codebini(fs, OP_SHRI, e1, e2, 0, line, TM_SHR); /* r1 >> I */ 1758| 289| else /* regular case (two registers) */ 1759| 289| codebinexpval(fs, opr, e1, e2, line); 1760| 318| break; 1761| 10.6k| } 1762| 3.47k| case OPR_EQ: case OPR_NE: { ------------------ | Branch (1762:5): [True: 1.74k, False: 5.06M] | Branch (1762:18): [True: 1.72k, False: 5.06M] ------------------ 1763| 3.47k| codeeq(fs, opr, e1, e2); 1764| 3.47k| break; 1765| 1.74k| } 1766| 15.6k| case OPR_GT: case OPR_GE: { ------------------ | Branch (1766:5): [True: 15.0k, False: 5.04M] | Branch (1766:18): [True: 630, False: 5.06M] ------------------ 1767| | /* '(a > b)' <=> '(b < a)'; '(a >= b)' <=> '(b <= a)' */ 1768| 15.6k| swapexps(e1, e2); 1769| 15.6k| opr = cast(BinOpr, (opr - OPR_GT) + OPR_LT); ------------------ | | 136| 15.6k|#define cast(t, exp) ((t)(exp)) ------------------ 1770| 15.6k| } /* FALLTHROUGH */ 1771| 2.07M| case OPR_LT: case OPR_LE: { ------------------ | Branch (1771:5): [True: 2.05M, False: 3.00M] | Branch (1771:18): [True: 2.04k, False: 5.06M] ------------------ 1772| 2.07M| codeorder(fs, opr, e1, e2); 1773| 2.07M| break; 1774| 2.07M| } 1775| 0| default: lua_assert(0); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ | Branch (1775:5): [True: 0, False: 5.06M] ------------------ 1776| 5.06M| } 1777| 5.06M|} luaK_fixline: 1784| 6.04M|void luaK_fixline (FuncState *fs, int line) { 1785| 6.04M| removelastlineinfo(fs); 1786| 6.04M| savelineinfo(fs, fs->f, line); 1787| 6.04M|} luaK_settablesize: 1790| 82|void luaK_settablesize (FuncState *fs, int pc, int ra, int asize, int hsize) { 1791| 82| Instruction *inst = &fs->f->code[pc]; 1792| 82| int rb = (hsize != 0) ? luaO_ceillog2(hsize) + 1 : 0; /* hash size */ ------------------ | Branch (1792:12): [True: 0, False: 82] ------------------ 1793| 82| int extra = asize / (MAXARG_C + 1); /* higher bits of array size */ ------------------ | | 97| 82|#define MAXARG_C ((1< 0); /* true iff needs extra argument */ 1796| 82| *inst = CREATE_ABCk(OP_NEWTABLE, ra, rb, rc, k); ------------------ | | 156| 82|#define CREATE_ABCk(o,a,b,c,k) ((cast(Instruction, o)<freereg = base + 1; /* free registers with list values */ 1821| 54|} luaK_finish: 1844| 2.73k|void luaK_finish (FuncState *fs) { 1845| 2.73k| int i; 1846| 2.73k| Proto *p = fs->f; 1847| 2.58M| for (i = 0; i < fs->pc; i++) { ------------------ | Branch (1847:15): [True: 2.57M, False: 2.73k] ------------------ 1848| 2.57M| Instruction *pc = &p->code[i]; 1849| 2.57M| lua_assert(i == 0 || isOT(*(pc - 1)) == isIT(*pc)); ------------------ | | 106| 2.57M|#define lua_assert(c) assert(c) ------------------ 1850| 2.57M| switch (GET_OPCODE(*pc)) { ------------------ | | 114| 2.57M|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 2.57M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1851| 3.50k| case OP_RETURN0: case OP_RETURN1: { ------------------ | Branch (1851:7): [True: 2.73k, False: 2.57M] | Branch (1851:24): [True: 772, False: 2.57M] ------------------ 1852| 3.50k| if (!(fs->needclose || p->is_vararg)) ------------------ | Branch (1852:15): [True: 820, False: 2.68k] | Branch (1852:32): [True: 41, False: 2.64k] ------------------ 1853| 2.64k| break; /* no extra work */ 1854| | /* else use OP_RETURN to do the extra work */ 1855| 861| SET_OPCODE(*pc, OP_RETURN); ------------------ | | 115| 861|#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ | | ------------------ | | | | 108| 861|#define MASK0(n,p) (~MASK1(n,p)) | | | | ------------------ | | | | | | 105| 861|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | ------------------ | | ------------------ | | 116| 861| ((cast(Instruction, o)<needclose) ------------------ | Branch (1858:13): [True: 2.10k, False: 1.04k] ------------------ 1859| 3.14k| SETARG_k(*pc, 1); /* signal that it needs to close */ ------------------ | | 138| 2.10k|#define SETARG_k(i,v) setarg(i, v, POS_k, 1) | | ------------------ | | | | 122| 2.10k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 2.10k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 2.10k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 2.10k| ((cast(Instruction, v)<is_vararg) ------------------ | Branch (1860:13): [True: 351, False: 2.79k] ------------------ 1861| 3.14k| SETARG_C(*pc, p->numparams + 1); /* signal that it is vararg */ ------------------ | | 134| 351|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 351|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 351|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 351|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 351| ((cast(Instruction, v)<code, i); 1866| 441k| fixjump(fs, i, target); 1867| 441k| break; 1868| 2.47k| } 1869| 2.13M| default: break; ------------------ | Branch (1869:7): [True: 2.13M, False: 447k] ------------------ 1870| 2.57M| } 1871| 2.57M| } 1872| 2.73k|} lcode.c:const2val: 74| 183k|static TValue *const2val (FuncState *fs, const expdesc *e) { 75| 183k| lua_assert(e->k == VCONST); ------------------ | | 106| 183k|#define lua_assert(c) assert(c) ------------------ 76| 183k| return &fs->ls->dyd->actvar.arr[e->u.info].k; 77| 183k|} lcode.c:tonumeral: 56| 8.85M|static int tonumeral (const expdesc *e, TValue *v) { 57| 8.85M| if (hasjumps(e)) ------------------ | | 38| 8.85M|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 4.09k, False: 8.84M] | | ------------------ ------------------ 58| 4.09k| return 0; /* not a numeral */ 59| 8.84M| switch (e->k) { 60| 229k| case VKINT: ------------------ | Branch (60:5): [True: 229k, False: 8.61M] ------------------ 61| 229k| if (v) setivalue(v, e->u.ival); ------------------ | | 345| 157k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 157k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 157k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ | Branch (61:11): [True: 157k, False: 72.0k] ------------------ 62| 229k| return 1; 63| 70.8k| case VKFLT: ------------------ | Branch (63:5): [True: 70.8k, False: 8.77M] ------------------ 64| 70.8k| if (v) setfltvalue(v, e->u.nval); ------------------ | | 339| 37.4k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 37.4k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 37.4k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ | Branch (64:11): [True: 37.4k, False: 33.3k] ------------------ 65| 70.8k| return 1; 66| 8.54M| default: return 0; ------------------ | Branch (66:5): [True: 8.54M, False: 300k] ------------------ 67| 8.84M| } 68| 8.84M|} lcode.c:previousinstruction: 116| 182k|static Instruction *previousinstruction (FuncState *fs) { 117| 182k| static const Instruction invalidinstruction = ~(Instruction)0; 118| 182k| if (fs->pc > fs->lasttarget) ------------------ | Branch (118:7): [True: 92.0k, False: 90.2k] ------------------ 119| 92.0k| return &fs->f->code[fs->pc - 1]; /* previous instruction */ 120| 90.2k| else 121| 90.2k| return cast(Instruction*, &invalidinstruction); ------------------ | | 136| 90.2k|#define cast(t, exp) ((t)(exp)) ------------------ 122| 182k|} lcode.c:getjump: 154| 36.2M|static int getjump (FuncState *fs, int pc) { 155| 36.2M| int offset = GETARG_sJ(fs->f->code[pc]); ------------------ | | 151| 36.2M| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | ------------------ | | | | 110| 36.2M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 36.2M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 156| 36.2M| if (offset == NO_JUMP) /* point to itself represents end of list */ ------------------ | | 20| 36.2M|#define NO_JUMP (-1) ------------------ | Branch (156:7): [True: 2.11M, False: 34.1M] ------------------ 157| 2.11M| return NO_JUMP; /* end of list */ ------------------ | | 20| 2.11M|#define NO_JUMP (-1) ------------------ 158| 34.1M| else 159| 34.1M| return (pc+1)+offset; /* turn offset into absolute position */ 160| 36.2M|} lcode.c:fixjump: 167| 2.59M|static void fixjump (FuncState *fs, int pc, int dest) { 168| 2.59M| Instruction *jmp = &fs->f->code[pc]; 169| 2.59M| int offset = dest - (pc + 1); 170| 2.59M| lua_assert(dest != NO_JUMP); ------------------ | | 106| 2.59M|#define lua_assert(c) assert(c) ------------------ 171| 2.59M| if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) ------------------ | | 92| 2.59M|#define OFFSET_sJ (MAXARG_sJ >> 1) | | ------------------ | | | | 87| 2.59M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | | | ------------------ | | | | | | 43| 2.59M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 40| 2.59M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 38| 2.59M|#define SIZE_C 8 | | | | | | | | ------------------ | | | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 39| 2.59M|#define SIZE_B 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 41| 2.59M|#define SIZE_A 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) ------------------ | | 87| 2.59M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | ------------------ | | | | 43| 2.59M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | ------------------ | | | | | | 40| 2.59M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | ------------------ | | | | | | | | 38| 2.59M|#define SIZE_C 8 | | | | | | ------------------ | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | ------------------ | | | | | | | | 39| 2.59M|#define SIZE_B 8 | | | | | | ------------------ | | | | ------------------ | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | ------------------ | | | | | | 41| 2.59M|#define SIZE_A 8 | | | | ------------------ | | ------------------ ------------------ if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) ------------------ | | 92| 2.59M|#define OFFSET_sJ (MAXARG_sJ >> 1) | | ------------------ | | | | 87| 2.59M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | | | ------------------ | | | | | | 43| 2.59M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 40| 2.59M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 38| 2.59M|#define SIZE_C 8 | | | | | | | | ------------------ | | | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 39| 2.59M|#define SIZE_B 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 41| 2.59M|#define SIZE_A 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (171:9): [True: 2.59M, False: 0] | Branch (171:33): [True: 2.59M, False: 0] ------------------ 172| 0| luaX_syntaxerror(fs->ls, "control structure too long"); 173| 2.59M| lua_assert(GET_OPCODE(*jmp) == OP_JMP); ------------------ | | 106| 2.59M|#define lua_assert(c) assert(c) ------------------ 174| 2.59M| SETARG_sJ(*jmp, offset); ------------------ | | 153| 2.59M| setarg(i, cast_uint((j)+OFFSET_sJ), POS_sJ, SIZE_sJ) | | ------------------ | | | | 122| 2.59M|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 2.59M|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 2.59M|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 2.59M| ((cast(Instruction, v)<>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 2.12M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (261:7): [True: 2.10M, False: 17.5k] ------------------ 262| 2.10M| return 0; /* cannot patch other instructions */ 263| 17.5k| if (reg != NO_REG && reg != GETARG_B(*i)) ------------------ | | 182| 17.5k|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 35.1k|#define MAXARG_A ((1<f->code[pc]; 245| 4.16M| if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1)))) ------------------ | | 385| 4.16M|#define testTMode(m) (luaP_opmodes[m] & (1 << 4)) | | ------------------ | | | Branch (385:22): [True: 4.15M, False: 7.09k] | | ------------------ ------------------ | Branch (245:7): [True: 4.16M, False: 2] ------------------ 246| 4.15M| return pi-1; 247| 7.09k| else 248| 7.09k| return pi; 249| 4.16M|} lcode.c:savelineinfo: 329| 29.6M|static void savelineinfo (FuncState *fs, Proto *f, int line) { 330| 29.6M| int linedif = line - fs->previousline; 331| 29.6M| int pc = fs->pc - 1; /* last instruction coded */ 332| 29.6M| if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) { ------------------ | | 319| 59.3M|#define LIMLINEDIFF 0x80 ------------------ if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) { ------------------ | | 35| 29.6M|#define MAXIWTHABS 128 ------------------ | Branch (332:7): [True: 142, False: 29.6M] | Branch (332:38): [True: 230k, False: 29.4M] ------------------ 333| 230k| luaM_growvector(fs->ls->L, f->abslineinfo, fs->nabslineinfo, ------------------ | | 67| 230k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 461k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 230k| luaM_limitN(limit,t),e))) ------------------ 334| 230k| f->sizeabslineinfo, AbsLineInfo, MAX_INT, "lines"); 335| 230k| f->abslineinfo[fs->nabslineinfo].pc = pc; 336| 230k| f->abslineinfo[fs->nabslineinfo++].line = line; 337| 230k| linedif = ABSLINEINFO; /* signal that there is absolute information */ ------------------ | | 27| 230k|#define ABSLINEINFO (-0x80) ------------------ 338| 230k| fs->iwthabs = 1; /* restart counter */ 339| 230k| } 340| 29.6M| luaM_growvector(fs->ls->L, f->lineinfo, pc, f->sizelineinfo, ls_byte, ------------------ | | 67| 29.6M| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 59.3M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 29.6M| luaM_limitN(limit,t),e))) ------------------ 341| 29.6M| MAX_INT, "opcodes"); 342| 29.6M| f->lineinfo[pc] = linedif; 343| 29.6M| fs->previousline = line; /* last line saved */ 344| 29.6M|} lcode.c:codesJ: 429| 2.10M|static int codesJ (FuncState *fs, OpCode o, int sj, int k) { 430| 2.10M| unsigned int j = sj + OFFSET_sJ; ------------------ | | 92| 2.10M|#define OFFSET_sJ (MAXARG_sJ >> 1) | | ------------------ | | | | 87| 2.10M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | | | ------------------ | | | | | | 43| 2.10M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 40| 2.10M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 38| 2.10M|#define SIZE_C 8 | | | | | | | | ------------------ | | | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 39| 2.10M|#define SIZE_B 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 41| 2.10M|#define SIZE_A 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 431| 2.10M| lua_assert(getOpMode(o) == isJ); ------------------ | | 106| 2.10M|#define lua_assert(c) assert(c) ------------------ 432| 2.10M| lua_assert(j <= MAXARG_sJ && (k & ~1) == 0); ------------------ | | 106| 2.10M|#define lua_assert(c) assert(c) ------------------ 433| 2.10M| return luaK_code(fs, CREATE_sJ(o, j, k)); ------------------ | | 169| 2.10M|#define CREATE_sJ(o,j,k) ((cast(Instruction, o) << POS_OP) \ | | ------------------ | | | | 136| 2.10M|#define cast(t, exp) ((t)(exp)) | | ------------------ | | #define CREATE_sJ(o,j,k) ((cast(Instruction, o) << POS_OP) \ | | ------------------ | | | | 47| 2.10M|#define POS_OP 0 | | ------------------ | | 170| 2.10M| | (cast(Instruction, j) << POS_sJ) \ | | ------------------ | | | | 136| 2.10M|#define cast(t, exp) ((t)(exp)) | | ------------------ | | | (cast(Instruction, j) << POS_sJ) \ | | ------------------ | | | | 58| 2.10M|#define POS_sJ POS_A | | | | ------------------ | | | | | | 49| 2.10M|#define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 47| 2.10M|#define POS_OP 0 | | | | | | ------------------ | | | | | | #define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 45| 2.10M|#define SIZE_OP 7 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 171| 2.10M| | (cast(Instruction, k) << POS_k)) | | ------------------ | | | | 136| 2.10M|#define cast(t, exp) ((t)(exp)) | | ------------------ | | | (cast(Instruction, k) << POS_k)) | | ------------------ | | | | 50| 2.10M|#define POS_k (POS_A + SIZE_A) | | | | ------------------ | | | | | | 49| 2.10M|#define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 47| 2.10M|#define POS_OP 0 | | | | | | ------------------ | | | | | | #define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 45| 2.10M|#define SIZE_OP 7 | | | | | | ------------------ | | | | ------------------ | | | | #define POS_k (POS_A + SIZE_A) | | | | ------------------ | | | | | | 41| 2.10M|#define SIZE_A 8 | | | | ------------------ | | ------------------ ------------------ 434| 2.10M|} lcode.c:fitsBx: 667| 36.1k|static int fitsBx (lua_Integer i) { 668| 36.1k| return (-OFFSET_sBx <= i && i <= MAXARG_Bx - OFFSET_sBx); ------------------ | | 77| 36.1k|#define OFFSET_sBx (MAXARG_Bx>>1) /* 'sBx' is signed */ | | ------------------ | | | | 72| 36.1k|#define MAXARG_Bx ((1<>1) /* 'sBx' is signed */ | | ------------------ | | | | 72| 35.8k|#define MAXARG_Bx ((1<>1) /* 'sBx' is signed */ | | ------------------ | | | | 72| 32.0k|#define MAXARG_Bx ((1<value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 26.9k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 588| 26.9k| return addk(fs, &o, &o); /* use integer itself as key */ 589| 26.9k|} lcode.c:addk: 543| 5.20M|static int addk (FuncState *fs, TValue *key, TValue *v) { 544| 5.20M| TValue val; 545| 5.20M| lua_State *L = fs->ls->L; 546| 5.20M| Proto *f = fs->f; 547| 5.20M| const TValue *idx = luaH_get(fs->ls->h, key); /* query scanner table */ 548| 5.20M| int k, oldsize; 549| 5.20M| if (ttisinteger(idx)) { /* is there an index there? */ ------------------ | | 328| 5.20M|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 5.20M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 5.20M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 5.18M, False: 12.3k] | | | | ------------------ | | ------------------ ------------------ 550| 5.18M| k = cast_int(ivalue(idx)); ------------------ | | 141| 5.18M|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 20.7M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 0, False: 5.18M] | | | | | Branch (136:27): [True: 5.18M, False: 0] | | | | ------------------ | | ------------------ ------------------ 551| | /* correct value? (warning: must distinguish floats from integers!) */ 552| 5.18M| if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) && ------------------ | | 84| 5.16M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 5.16M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) && ------------------ | | 84| 5.16M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 10.3M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ | Branch (552:9): [True: 5.16M, False: 20.0k] | Branch (552:23): [True: 5.16M, False: 426] ------------------ 553| 5.18M| luaV_rawequalobj(&f->k[k], v)) ------------------ | | 75| 5.16M|#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2) | | ------------------ | | | Branch (75:34): [True: 5.14M, False: 20.3k] | | ------------------ ------------------ 554| 5.14M| return k; /* reuse index */ 555| 5.18M| } 556| | /* constant not found; create a new entry */ 557| 53.2k| oldsize = f->sizek; 558| 53.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| 53.2k| setivalue(&val, k); ------------------ | | 345| 53.2k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 53.2k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 53.2k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 562| 53.2k| luaH_finishset(L, fs->ls->h, key, idx, &val); 563| 53.2k| luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants"); ------------------ | | 67| 53.2k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 106k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 53.2k| luaM_limitN(limit,t),e))) ------------------ 564| 129k| while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]); ------------------ | | 200| 76.0k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 129k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ | Branch (564:10): [True: 76.0k, False: 53.2k] ------------------ 565| 53.2k| setobj(L, &f->k[k], v); ------------------ | | 119| 53.2k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 53.2k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 53.2k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 53.2k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 53.2k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 505k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 53.2k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 30.1k] | | | | | | | Branch (112:29): [True: 30.1k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 30.1k] | | | | | | | Branch (112:29): [True: 30.1k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 30.1k] | | | | | | | Branch (112:29): [True: 30.1k, False: 0] | | | | | | | Branch (112:29): [True: 30.1k, False: 0] | | | | | | | Branch (112:29): [True: 23.0k, False: 30.1k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 53.2k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 106| 53.2k|#define lua_assert(c) assert(c) | | ------------------ ------------------ 566| 53.2k| fs->nk++; 567| 53.2k| luaC_barrier(L, f, v); ------------------ | | 179| 53.2k|#define luaC_barrier(L,p,v) ( \ | | 180| 53.2k| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 53.2k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 53.2k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 53.2k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 30.1k, False: 23.0k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 30.1k|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 30.1k| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 30.1k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 30.1k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 60.3k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 30.1k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (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] | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 177| 30.1k| 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)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 30.1k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 30.1k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 23.0k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 23.0k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 568| 0| return k; 569| 53.2k|} lcode.c:const2exp: 692| 183k|static void const2exp (TValue *v, expdesc *e) { 693| 183k| switch (ttypetag(v)) { ------------------ | | 84| 183k|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 183k|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 694| 2.37k| case LUA_VNUMINT: ------------------ | | 323| 2.37k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 2.37k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (694:5): [True: 2.37k, False: 181k] ------------------ 695| 2.37k| e->k = VKINT; e->u.ival = ivalue(v); ------------------ | | 333| 2.37k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 2.37k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.37k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 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: 183k] ------------------ 698| 0| e->k = VKFLT; e->u.nval = fltvalue(v); ------------------ | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 699| 0| break; 700| 43.5k| case LUA_VFALSE: ------------------ | | 239| 43.5k|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 43.5k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (700:5): [True: 43.5k, False: 140k] ------------------ 701| 43.5k| e->k = VFALSE; 702| 43.5k| break; 703| 164| case LUA_VTRUE: ------------------ | | 240| 164|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 164|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (703:5): [True: 164, False: 183k] ------------------ 704| 164| e->k = VTRUE; 705| 164| break; 706| 137k| case LUA_VNIL: ------------------ | | 183| 137k|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 137k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (706:5): [True: 137k, False: 46.2k] ------------------ 707| 137k| e->k = VNIL; 708| 137k| break; 709| 200| case LUA_VSHRSTR: case LUA_VLNGSTR: ------------------ | | 360| 116|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 116|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VSHRSTR: case LUA_VLNGSTR: ------------------ | | 361| 200|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 200|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (709:5): [True: 116, False: 183k] | Branch (709:24): [True: 84, False: 183k] ------------------ 710| 200| e->k = VKSTR; e->u.strval = tsvalue(v); ------------------ | | 369| 200|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 800|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 200|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 200] | | | | | Branch (110:42): [True: 200, False: 0] | | | | ------------------ | | ------------------ ------------------ 711| 0| break; 712| 0| default: lua_assert(0); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ | Branch (712:5): [True: 0, False: 183k] ------------------ 713| 183k| } 714| 183k|} lcode.c:freereg: 491| 14.3M|static void freereg (FuncState *fs, int reg) { 492| 14.3M| if (reg >= luaY_nvarstack(fs)) { ------------------ | Branch (492:7): [True: 14.1M, False: 184k] ------------------ 493| 14.1M| fs->freereg--; 494| 14.1M| lua_assert(reg == fs->freereg); ------------------ | | 106| 14.1M|#define lua_assert(c) assert(c) ------------------ 495| 14.1M| } 496| 14.3M|} lcode.c:freeregs: 502| 6.90M|static void freeregs (FuncState *fs, int r1, int r2) { 503| 6.90M| if (r1 > r2) { ------------------ | Branch (503:7): [True: 72.8k, False: 6.83M] ------------------ 504| 72.8k| freereg(fs, r1); 505| 72.8k| freereg(fs, r2); 506| 72.8k| } 507| 6.83M| else { 508| 6.83M| freereg(fs, r2); 509| 6.83M| freereg(fs, r1); 510| 6.83M| } 511| 6.90M|} lcode.c:freeexp: 517| 14.5M|static void freeexp (FuncState *fs, expdesc *e) { 518| 14.5M| if (e->k == VNONRELOC) ------------------ | Branch (518:7): [True: 257k, False: 14.2M] ------------------ 519| 257k| freereg(fs, e->u.info); 520| 14.5M|} lcode.c:exp2reg: 914| 14.3M|static void exp2reg (FuncState *fs, expdesc *e, int reg) { 915| 14.3M| discharge2reg(fs, e, reg); 916| 14.3M| if (e->k == VJMP) /* expression itself is a test? */ ------------------ | Branch (916:7): [True: 2.02M, False: 12.3M] ------------------ 917| 2.02M| luaK_concat(fs, &e->t, e->u.info); /* put this jump in 't' list */ 918| 14.3M| if (hasjumps(e)) { ------------------ | | 38| 14.3M|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 2.03M, False: 12.3M] | | ------------------ ------------------ 919| 2.03M| int final; /* position after whole expression */ 920| 2.03M| int p_f = NO_JUMP; /* position of an eventual LOAD false */ ------------------ | | 20| 2.03M|#define NO_JUMP (-1) ------------------ 921| 2.03M| int p_t = NO_JUMP; /* position of an eventual LOAD true */ ------------------ | | 20| 2.03M|#define NO_JUMP (-1) ------------------ 922| 2.03M| if (need_value(fs, e->t) || need_value(fs, e->f)) { ------------------ | Branch (922:9): [True: 2.02M, False: 10.3k] | Branch (922:33): [True: 2.16k, False: 8.16k] ------------------ 923| 2.02M| int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs); ------------------ | | 20| 2.02M|#define NO_JUMP (-1) ------------------ | Branch (923:16): [True: 2.02M, False: 5.56k] ------------------ 924| 2.02M| p_f = code_loadbool(fs, reg, OP_LFALSESKIP); /* skip next inst. */ 925| 2.02M| p_t = code_loadbool(fs, reg, OP_LOADTRUE); 926| | /* jump around these booleans if 'e' is not a test */ 927| 2.02M| luaK_patchtohere(fs, fj); 928| 2.02M| } 929| 2.03M| final = luaK_getlabel(fs); 930| 2.03M| patchlistaux(fs, e->f, final, reg, p_f); 931| 2.03M| patchlistaux(fs, e->t, final, reg, p_t); 932| 2.03M| } 933| 14.3M| e->f = e->t = NO_JUMP; ------------------ | | 20| 14.3M|#define NO_JUMP (-1) ------------------ 934| 14.3M| e->u.info = reg; 935| 14.3M| e->k = VNONRELOC; 936| 14.3M|} lcode.c:discharge2reg: 825| 14.3M|static void discharge2reg (FuncState *fs, expdesc *e, int reg) { 826| 14.3M| luaK_dischargevars(fs, e); 827| 14.3M| switch (e->k) { 828| 166k| case VNIL: { ------------------ | Branch (828:5): [True: 166k, False: 14.2M] ------------------ 829| 166k| luaK_nil(fs, reg, 1); 830| 166k| break; 831| 0| } 832| 43.8k| case VFALSE: { ------------------ | Branch (832:5): [True: 43.8k, False: 14.3M] ------------------ 833| 43.8k| luaK_codeABC(fs, OP_LOADFALSE, reg, 0, 0); ------------------ | | 48| 43.8k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 834| 43.8k| break; 835| 0| } 836| 681| case VTRUE: { ------------------ | Branch (836:5): [True: 681, False: 14.3M] ------------------ 837| 681| luaK_codeABC(fs, OP_LOADTRUE, reg, 0, 0); ------------------ | | 48| 681|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 838| 681| break; 839| 0| } 840| 154k| case VKSTR: { ------------------ | Branch (840:5): [True: 154k, False: 14.2M] ------------------ 841| 154k| str2K(fs, e); 842| 154k| } /* FALLTHROUGH */ 843| 2.08M| case VK: { ------------------ | Branch (843:5): [True: 1.93M, False: 12.4M] ------------------ 844| 2.08M| luaK_codek(fs, reg, e->u.info); 845| 2.08M| break; 846| 154k| } 847| 22.4k| case VKFLT: { ------------------ | Branch (847:5): [True: 22.4k, False: 14.3M] ------------------ 848| 22.4k| luaK_float(fs, reg, e->u.nval); 849| 22.4k| break; 850| 154k| } 851| 21.3k| case VKINT: { ------------------ | Branch (851:5): [True: 21.3k, False: 14.3M] ------------------ 852| 21.3k| luaK_int(fs, reg, e->u.ival); 853| 21.3k| break; 854| 154k| } 855| 9.89M| case VRELOC: { ------------------ | Branch (855:5): [True: 9.89M, False: 4.48M] ------------------ 856| 9.89M| Instruction *pc = &getinstruction(fs, e); ------------------ | | 55| 9.89M|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 857| 9.89M| SETARG_A(*pc, reg); /* instruction will put result in 'reg' */ ------------------ | | 126| 9.89M|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 9.89M|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 9.89M|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 9.89M|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 9.89M| ((cast(Instruction, v)<u.info) ------------------ | Branch (861:11): [True: 18.6k, False: 103k] ------------------ 862| 18.6k| luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0); ------------------ | | 48| 18.6k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 863| 122k| break; 864| 154k| } 865| 2.02M| default: { ------------------ | Branch (865:5): [True: 2.02M, False: 12.3M] ------------------ 866| 2.02M| lua_assert(e->k == VJMP); ------------------ | | 106| 2.02M|#define lua_assert(c) assert(c) ------------------ 867| 2.02M| return; /* nothing to do... */ 868| 2.02M| } 869| 14.3M| } 870| 12.3M| e->u.info = reg; 871| 12.3M| e->k = VNONRELOC; 872| 12.3M|} lcode.c:luaK_float: 680| 22.4k|static void luaK_float (FuncState *fs, int reg, lua_Number f) { 681| 22.4k| lua_Integer fi; 682| 22.4k| if (luaV_flttointeger(f, &fi, F2Ieq) && fitsBx(fi)) ------------------ | Branch (682:7): [True: 12.8k, False: 9.64k] | Branch (682:43): [True: 10.8k, False: 1.99k] ------------------ 683| 10.8k| codeAsBx(fs, OP_LOADF, reg, cast_int(fi)); ------------------ | | 141| 10.8k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 10.8k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 684| 11.6k| else 685| 11.6k| luaK_codek(fs, reg, luaK_numberK(fs, f)); 686| 22.4k|} lcode.c:luaK_numberK: 602| 32.7k|static int luaK_numberK (FuncState *fs, lua_Number r) { 603| 32.7k| TValue o; 604| 32.7k| lua_Integer ik; 605| 32.7k| setfltvalue(&o, r); ------------------ | | 339| 32.7k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 32.7k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 32.7k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 606| 32.7k| if (!luaV_flttointeger(r, &ik, F2Ieq)) /* not an integral value? */ ------------------ | Branch (606:7): [True: 14.9k, False: 17.7k] ------------------ 607| 14.9k| return addk(fs, &o, &o); /* use number itself as key */ 608| 17.7k| else { /* must build an alternative key */ 609| 17.7k| const int nbm = l_floatatt(MANT_DIG); ------------------ | | 475| 17.7k|#define l_floatatt(n) (DBL_##n) ------------------ 610| 17.7k| const lua_Number q = l_mathop(ldexp)(l_mathop(1.0), -nbm + 1); ------------------ | | 482| 17.7k|#define l_mathop(op) op ------------------ const lua_Number q = l_mathop(ldexp)(l_mathop(1.0), -nbm + 1); ------------------ | | 482| 17.7k|#define l_mathop(op) op ------------------ 611| 17.7k| const lua_Number k = (ik == 0) ? q : r + r*q; /* new key */ ------------------ | Branch (611:26): [True: 1.32k, False: 16.4k] ------------------ 612| 17.7k| TValue kv; 613| 17.7k| setfltvalue(&kv, k); ------------------ | | 339| 17.7k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 17.7k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 17.7k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 614| | /* result is not an integral value, unless value is too large */ 615| 17.7k| lua_assert(!luaV_flttointeger(k, &ik, F2Ieq) || ------------------ | | 106| 17.7k|#define lua_assert(c) assert(c) ------------------ 616| 17.7k| l_mathop(fabs)(r) >= l_mathop(1e6)); 617| 17.7k| return addk(fs, &kv, &o); 618| 17.7k| } 619| 32.7k|} lcode.c:need_value: 898| 2.04M|static int need_value (FuncState *fs, int list) { 899| 2.05M| for (; list != NO_JUMP; list = getjump(fs, list)) { ------------------ | | 20| 2.05M|#define NO_JUMP (-1) ------------------ | Branch (899:10): [True: 2.03M, False: 18.5k] ------------------ 900| 2.03M| Instruction i = *getjumpcontrol(fs, list); 901| 2.03M| if (GET_OPCODE(i) != OP_TESTSET) return 1; ------------------ | | 114| 2.03M|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 2.03M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (901:9): [True: 2.02M, False: 11.6k] ------------------ 902| 2.03M| } 903| 18.5k| return 0; /* not found */ 904| 2.04M|} lcode.c:code_loadbool: 888| 4.05M|static int code_loadbool (FuncState *fs, int A, OpCode op) { 889| 4.05M| luaK_getlabel(fs); /* those instructions may be jump targets */ 890| 4.05M| return luaK_codeABC(fs, op, A, 0, 0); ------------------ | | 48| 4.05M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 891| 4.05M|} lcode.c:codeABRK: 1039| 21.8k| expdesc *ec) { 1040| 21.8k| int k = exp2RK(fs, ec); 1041| 21.8k| luaK_codeABCk(fs, o, a, b, ec->u.info, k); 1042| 21.8k|} lcode.c:negatecondition: 1101| 2.72k|static void negatecondition (FuncState *fs, expdesc *e) { 1102| 2.72k| Instruction *pc = getjumpcontrol(fs, e->u.info); 1103| 2.72k| lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET && ------------------ | | 106| 2.72k|#define lua_assert(c) assert(c) ------------------ 1104| 2.72k| GET_OPCODE(*pc) != OP_TEST); 1105| 5.44k| SETARG_k(*pc, (GETARG_k(*pc) ^ 1)); ------------------ | | 138| 2.72k|#define SETARG_k(i,v) setarg(i, v, POS_k, 1) | | ------------------ | | | | 122| 2.72k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 2.72k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 2.72k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 2.72k| ((cast(Instruction, v)<k == VRELOC) { ------------------ | Branch (1116:7): [True: 13.0k, False: 5.53k] ------------------ 1117| 13.0k| Instruction ie = getinstruction(fs, e); ------------------ | | 55| 13.0k|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 1118| 13.0k| if (GET_OPCODE(ie) == OP_NOT) { ------------------ | | 114| 13.0k|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 13.0k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (1118:9): [True: 182, False: 12.9k] ------------------ 1119| 182| removelastinstruction(fs); /* remove previous OP_NOT */ 1120| 182| return condjump(fs, OP_TEST, GETARG_B(ie), 0, 0, !cond); ------------------ | | 128| 182|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 182|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 182|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1121| 182| } 1122| | /* else go through */ 1123| 13.0k| } 1124| 18.4k| discharge2anyreg(fs, e); 1125| 18.4k| freeexp(fs, e); 1126| 18.4k| return condjump(fs, OP_TESTSET, NO_REG, e->u.info, 0, cond); ------------------ | | 182| 18.4k|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 18.4k|#define MAXARG_A ((1<pc--; 375| 182|} lcode.c:condjump: 222| 2.09M|static int condjump (FuncState *fs, OpCode op, int A, int B, int C, int k) { 223| 2.09M| luaK_codeABCk(fs, op, A, B, C, k); 224| 2.09M| return luaK_jump(fs); 225| 2.09M|} lcode.c:discharge2anyreg: 880| 19.9k|static void discharge2anyreg (FuncState *fs, expdesc *e) { 881| 19.9k| if (e->k != VNONRELOC) { /* no fixed register yet? */ ------------------ | Branch (881:7): [True: 14.3k, False: 5.69k] ------------------ 882| 14.3k| luaK_reserveregs(fs, 1); /* get a register */ 883| 14.3k| discharge2reg(fs, e, fs->freereg-1); /* put value there */ 884| 14.3k| } 885| 19.9k|} lcode.c:str2K: 737| 5.13M|static void str2K (FuncState *fs, expdesc *e) { 738| 5.13M| lua_assert(e->k == VKSTR); ------------------ | | 106| 5.13M|#define lua_assert(c) assert(c) ------------------ 739| 5.13M| e->u.info = stringK(fs, e->u.strval); 740| 5.13M| e->k = VK; 741| 5.13M|} lcode.c:stringK: 575| 5.14M|static int stringK (FuncState *fs, TString *s) { 576| 5.14M| TValue o; 577| 5.14M| setsvalue(fs->ls->L, &o, s); ------------------ | | 372| 5.14M| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 5.14M| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 5.14M|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 5.14M|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 5.14M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 5.14M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 5.14M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 5.14M| checkliveness(L,io); } | | ------------------ | | | | 107| 5.14M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 82.2M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 5.14M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 5.14M] | | | | | | | Branch (112:29): [True: 5.14M, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 5.14M] | | | | | | | Branch (112:29): [True: 5.14M, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 5.14M] | | | | | | | Branch (112:29): [True: 5.14M, False: 0] | | | | | | | Branch (112:29): [True: 5.14M, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 5.14M] | | | | | | ------------------ | | | | ------------------ | | | | 108| 5.14M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 578| 5.14M| return addk(fs, &o, &o); /* use string itself as key */ 579| 5.14M|} lcode.c:isKstr: 1220| 9.69M|static int isKstr (FuncState *fs, expdesc *e) { 1221| 9.69M| return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B && ------------------ | | 38| 19.3M|#define hasjumps(e) ((e)->t != (e)->f) ------------------ return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B && ------------------ | | 96| 19.3M|#define MAXARG_B ((1<f->k[e->u.info])); ------------------ | | 364| 5.82M|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | ------------------ | | | | 91| 5.82M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 5.82M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 5.82M, False: 4.83k] | | | | ------------------ | | ------------------ ------------------ 1223| 9.69M|} lcode.c:isCint: 1237| 1.94M|static int isCint (expdesc *e) { 1238| 1.94M| return isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C)); ------------------ | | 152| 435|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ return isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C)); ------------------ | | 152| 435|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (1238:10): [True: 435, False: 1.94M] | Branch (1238:23): [True: 395, False: 40] ------------------ 1239| 1.94M|} lcode.c:isKint: 1228| 2.18M|static int isKint (expdesc *e) { 1229| 2.18M| return (e->k == VKINT && !hasjumps(e)); ------------------ | | 38| 11.9k|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (1229:11): [True: 11.9k, False: 2.17M] | Branch (1229:28): [True: 11.8k, False: 117] ------------------ 1230| 2.18M|} lcode.c:constfolding: 1335| 3.04M| const expdesc *e2) { 1336| 3.04M| TValue v1, v2, res; 1337| 3.04M| if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2)) ------------------ | Branch (1337:7): [True: 2.94M, False: 103k] | Branch (1337:30): [True: 12.5k, False: 91.2k] | Branch (1337:53): [True: 6.53k, False: 84.7k] ------------------ 1338| 2.96M| return 0; /* non-numeric operands or not safe to fold */ 1339| 84.7k| luaO_rawarith(fs->ls->L, op, &v1, &v2, &res); /* does operation */ 1340| 84.7k| if (ttisinteger(&res)) { ------------------ | | 328| 84.7k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 84.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 84.7k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 35.2k, False: 49.4k] | | | | ------------------ | | ------------------ ------------------ 1341| 35.2k| e1->k = VKINT; 1342| 35.2k| e1->u.ival = ivalue(&res); ------------------ | | 333| 35.2k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 35.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 35.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1343| 35.2k| } 1344| 49.4k| else { /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */ 1345| 49.4k| lua_Number n = fltvalue(&res); ------------------ | | 332| 49.4k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 110| 49.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 49.4k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1346| 49.4k| if (luai_numisnan(n) || n == 0) ------------------ | | 355| 98.8k|#define luai_numisnan(a) (!luai_numeq((a), (a))) | | ------------------ | | | | 350| 49.4k|#define luai_numeq(a,b) ((a)==(b)) | | ------------------ | | | Branch (355:33): [True: 101, False: 49.3k] | | ------------------ ------------------ | Branch (1346:29): [True: 4.50k, False: 44.8k] ------------------ 1347| 4.60k| return 0; 1348| 44.8k| e1->k = VKFLT; 1349| 44.8k| e1->u.nval = n; 1350| 44.8k| } 1351| 80.1k| return 1; 1352| 84.7k|} lcode.c:validop: 1315| 91.2k|static int validop (int op, TValue *v1, TValue *v2) { 1316| 91.2k| switch (op) { 1317| 2.50k| case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 222| 1.32k|#define LUA_OPBAND 7 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 223| 1.34k|#define LUA_OPBOR 8 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 224| 2.50k|#define LUA_OPBXOR 9 ------------------ | Branch (1317:5): [True: 1.32k, False: 89.9k] | Branch (1317:22): [True: 18, False: 91.2k] | Branch (1317:38): [True: 1.15k, False: 90.1k] ------------------ 1318| 31.8k| case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ ------------------ | | 225| 2.57k|#define LUA_OPSHL 10 ------------------ case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ ------------------ | | 226| 2.66k|#define LUA_OPSHR 11 ------------------ case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ ------------------ | | 228| 31.8k|#define LUA_OPBNOT 13 ------------------ | Branch (1318:5): [True: 70, False: 91.2k] | Branch (1318:21): [True: 87, False: 91.1k] | Branch (1318:37): [True: 29.2k, False: 62.0k] ------------------ 1319| 31.8k| lua_Integer i; 1320| 31.8k| return (luaV_tointegerns(v1, &i, LUA_FLOORN2I) && ------------------ | | 36| 31.8k|#define LUA_FLOORN2I F2Ieq ------------------ | Branch (1320:15): [True: 25.4k, False: 6.41k] ------------------ 1321| 31.8k| luaV_tointegerns(v2, &i, LUA_FLOORN2I)); ------------------ | | 36| 25.4k|#define LUA_FLOORN2I F2Ieq ------------------ | Branch (1321:15): [True: 25.3k, False: 90] ------------------ 1322| 2.66k| } 1323| 3.86k| case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ ------------------ | | 220| 158|#define LUA_OPDIV 5 ------------------ case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ ------------------ | | 221| 201|#define LUA_OPIDIV 6 ------------------ case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ ------------------ | | 218| 3.86k|#define LUA_OPMOD 3 ------------------ | Branch (1323:5): [True: 158, False: 91.1k] | Branch (1323:21): [True: 43, False: 91.2k] | Branch (1323:38): [True: 3.66k, False: 87.6k] ------------------ 1324| 3.86k| return (nvalue(v2) != 0); ------------------ | | 330| 3.86k|#define nvalue(o) check_exp(ttisnumber(o), \ | | ------------------ | | | | 110| 27.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 3.86k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 2.99k] | | | | | Branch (110:42): [True: 2.99k, False: 0] | | | | | Branch (110:42): [True: 0, False: 874] | | | | | Branch (110:42): [True: 874, False: 0] | | | | | Branch (110:42): [True: 2.99k, False: 874] | | | | ------------------ | | ------------------ | | 331| 3.86k| (ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o))) ------------------ 1325| 55.5k| default: return 1; /* everything else is valid */ ------------------ | Branch (1325:5): [True: 55.5k, False: 35.7k] ------------------ 1326| 91.2k| } 1327| 91.2k|} lcode.c:codeunexpval: 1389| 89.1k|static void codeunexpval (FuncState *fs, OpCode op, expdesc *e, int line) { 1390| 89.1k| int r = luaK_exp2anyreg(fs, e); /* opcodes operate only on registers */ 1391| 89.1k| freeexp(fs, e); 1392| 89.1k| e->u.info = luaK_codeABC(fs, op, 0, r, 0); /* generate opcode */ ------------------ | | 48| 89.1k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1393| 89.1k| e->k = VRELOC; /* all those operations are relocatable */ 1394| 89.1k| luaK_fixline(fs, line); 1395| 89.1k|} lcode.c:unopr2op: 1369| 89.1k|l_sinline OpCode unopr2op (UnOpr opr) { 1370| 89.1k| return cast(OpCode, (cast_int(opr) - cast_int(OPR_MINUS)) + ------------------ | | 136| 89.1k|#define cast(t, exp) ((t)(exp)) ------------------ 1371| 89.1k| cast_int(OP_UNM)); 1372| 89.1k|} lcode.c:codenot: 1186| 2.01k|static void codenot (FuncState *fs, expdesc *e) { 1187| 2.01k| switch (e->k) { 1188| 70| case VNIL: case VFALSE: { ------------------ | Branch (1188:5): [True: 0, False: 2.01k] | Branch (1188:16): [True: 70, False: 1.94k] ------------------ 1189| 70| e->k = VTRUE; /* true == not nil == not false */ 1190| 70| break; 1191| 0| } 1192| 124| case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: { ------------------ | Branch (1192:5): [True: 0, False: 2.01k] | Branch (1192:14): [True: 12, False: 2.00k] | Branch (1192:26): [True: 21, False: 1.99k] | Branch (1192:38): [True: 15, False: 2.00k] | Branch (1192:50): [True: 76, False: 1.94k] ------------------ 1193| 124| e->k = VFALSE; /* false == not "x" == not 0.5 == not 1 == not true */ 1194| 124| break; 1195| 48| } 1196| 271| case VJMP: { ------------------ | Branch (1196:5): [True: 271, False: 1.74k] ------------------ 1197| 271| negatecondition(fs, e); 1198| 271| break; 1199| 48| } 1200| 983| case VRELOC: ------------------ | Branch (1200:5): [True: 983, False: 1.03k] ------------------ 1201| 1.55k| case VNONRELOC: { ------------------ | Branch (1201:5): [True: 569, False: 1.44k] ------------------ 1202| 1.55k| discharge2anyreg(fs, e); 1203| 1.55k| freeexp(fs, e); 1204| 1.55k| e->u.info = luaK_codeABC(fs, OP_NOT, 0, e->u.info, 0); ------------------ | | 48| 1.55k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1205| 1.55k| e->k = VRELOC; 1206| 1.55k| break; 1207| 983| } 1208| 0| default: lua_assert(0); /* cannot happen */ ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ | Branch (1208:5): [True: 0, False: 2.01k] ------------------ 1209| 2.01k| } 1210| | /* interchange true and false lists */ 1211| 2.01k| { int temp = e->f; e->f = e->t; e->t = temp; } 1212| 2.01k| removevalues(fs, e->f); /* values are useless when negated */ 1213| 2.01k| removevalues(fs, e->t); 1214| 2.01k|} lcode.c:removevalues: 277| 4.03k|static void removevalues (FuncState *fs, int list) { 278| 26.8k| for (; list != NO_JUMP; list = getjump(fs, list)) ------------------ | | 20| 26.8k|#define NO_JUMP (-1) ------------------ | Branch (278:10): [True: 22.7k, False: 4.03k] ------------------ 279| 22.7k| patchtestreg(fs, list, NO_REG); ------------------ | | 182| 22.7k|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 22.7k|#define MAXARG_A ((1<t != (e)->f) ------------------ | Branch (999:7): [True: 67.5k, False: 1.83k] ------------------ 1000| 67.5k| int info; 1001| 67.5k| switch (e->k) { /* move constants to 'k' */ 1002| 462| case VTRUE: info = boolT(fs); break; ------------------ | Branch (1002:7): [True: 462, False: 67.0k] ------------------ 1003| 15| case VFALSE: info = boolF(fs); break; ------------------ | Branch (1003:7): [True: 15, False: 67.4k] ------------------ 1004| 541| case VNIL: info = nilK(fs); break; ------------------ | Branch (1004:7): [True: 541, False: 66.9k] ------------------ 1005| 24.8k| case VKINT: info = luaK_intK(fs, e->u.ival); break; ------------------ | Branch (1005:7): [True: 24.8k, False: 42.6k] ------------------ 1006| 21.1k| case VKFLT: info = luaK_numberK(fs, e->u.nval); break; ------------------ | Branch (1006:7): [True: 21.1k, False: 46.3k] ------------------ 1007| 2.96k| case VKSTR: info = stringK(fs, e->u.strval); break; ------------------ | Branch (1007:7): [True: 2.96k, False: 64.5k] ------------------ 1008| 330| case VK: info = e->u.info; break; ------------------ | Branch (1008:7): [True: 330, False: 67.1k] ------------------ 1009| 17.2k| default: return 0; /* not a constant */ ------------------ | Branch (1009:7): [True: 17.2k, False: 50.3k] ------------------ 1010| 67.5k| } 1011| 50.3k| if (info <= MAXINDEXRK) { /* does constant fit in 'argC'? */ ------------------ | | 175| 50.3k|#define MAXINDEXRK MAXARG_B | | ------------------ | | | | 96| 50.3k|#define MAXARG_B ((1<k = VK; /* make expression a 'K' expression */ 1013| 37.9k| e->u.info = info; 1014| 37.9k| return 1; 1015| 37.9k| } 1016| 50.3k| } 1017| | /* else, expression doesn't fit; leave it unchanged */ 1018| 14.1k| return 0; 1019| 69.3k|} lcode.c:boolT: 635| 462|static int boolT (FuncState *fs) { 636| 462| TValue o; 637| 462| setbtvalue(&o); ------------------ | | 251| 462|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 462|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 638| 462| return addk(fs, &o, &o); /* use boolean itself as key */ 639| 462|} lcode.c:boolF: 625| 15|static int boolF (FuncState *fs) { 626| 15| TValue o; 627| 15| setbfvalue(&o); ------------------ | | 250| 15|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 15|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 628| 15| return addk(fs, &o, &o); /* use boolean itself as key */ 629| 15|} lcode.c:nilK: 645| 541|static int nilK (FuncState *fs) { 646| 541| TValue k, v; 647| 541| setnilvalue(&v); ------------------ | | 200| 541|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 541|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 648| | /* cannot use nil as key; instead use table itself to represent nil */ 649| 541| sethvalue(fs->ls->L, &k, fs->ls->h); ------------------ | | 685| 541| { TValue *io = (obj); Table *x_ = (x); \ | | 686| 541| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 541|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 390| 541|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 541|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 541|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 541|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 687| 541| checkliveness(L,io); } | | ------------------ | | | | 107| 541| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 8.65k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 541|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 541] | | | | | | | Branch (112:29): [True: 541, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 541] | | | | | | | Branch (112:29): [True: 541, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 541] | | | | | | | Branch (112:29): [True: 541, False: 0] | | | | | | | Branch (112:29): [True: 541, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 541] | | | | | | ------------------ | | | | ------------------ | | | | 108| 541| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 650| 541| return addk(fs, &k, &v); 651| 541|} lcode.c:isSCnumber: 1255| 6.22M|static int isSCnumber (expdesc *e, int *pi, int *isfloat) { 1256| 6.22M| lua_Integer i; 1257| 6.22M| if (e->k == VKINT) ------------------ | Branch (1257:7): [True: 12.3k, False: 6.21M] ------------------ 1258| 12.3k| i = e->u.ival; 1259| 6.21M| else if (e->k == VKFLT && luaV_flttointeger(e->u.nval, &i, F2Ieq)) ------------------ | Branch (1259:12): [True: 2.72k, False: 6.21M] | Branch (1259:29): [True: 1.75k, False: 969] ------------------ 1260| 1.75k| *isfloat = 1; 1261| 6.21M| else 1262| 6.21M| return 0; /* not a number */ 1263| 14.0k| if (!hasjumps(e) && fitsC(i)) { ------------------ | | 38| 28.1k|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (1263:7): [True: 12.5k, False: 1.48k] | Branch (1263:23): [True: 11.6k, False: 930] ------------------ 1264| 11.6k| *pi = int2sC(cast_int(i)); ------------------ | | 100| 11.6k|#define int2sC(i) ((i) + OFFSET_sC) | | ------------------ | | | | 98| 11.6k|#define OFFSET_sC (MAXARG_C >> 1) | | | | ------------------ | | | | | | 97| 11.6k|#define MAXARG_C ((1<> 1) | | ------------------ | | | | 97| 31.5k|#define MAXARG_C ((1<>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 13.5k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (1685:7): [True: 5.46k, False: 8.08k] ------------------ 1686| 5.46k| int n = GETARG_B(*ie2); /* # of elements concatenated in 'e2' */ ------------------ | | 128| 5.46k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 5.46k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 5.46k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1687| 5.46k| lua_assert(e1->u.info + 1 == GETARG_A(*ie2)); ------------------ | | 106| 5.46k|#define lua_assert(c) assert(c) ------------------ 1688| 5.46k| freeexp(fs, e2); 1689| 5.46k| SETARG_A(*ie2, e1->u.info); /* correct first element ('e1') */ ------------------ | | 126| 5.46k|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 5.46k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 5.46k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 5.46k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 5.46k| ((cast(Instruction, v)<u.info, 2, 0); /* new concat opcode */ ------------------ | | 48| 8.08k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1694| 8.08k| freeexp(fs, e2); 1695| 8.08k| luaK_fixline(fs, line); 1696| 8.08k| } 1697| 13.5k|} lcode.c:codecommutative: 1515| 17.0k| expdesc *e1, expdesc *e2, int line) { 1516| 17.0k| int flip = 0; 1517| 17.0k| if (tonumeral(e1, NULL)) { /* is first operand a numeric constant? */ ------------------ | Branch (1517:7): [True: 2.96k, False: 14.1k] ------------------ 1518| 2.96k| swapexps(e1, e2); /* change order */ 1519| 2.96k| flip = 1; 1520| 2.96k| } 1521| 17.0k| if (op == OPR_ADD && isSCint(e2)) /* immediate operand? */ ------------------ | Branch (1521:7): [True: 2.21k, False: 14.8k] | Branch (1521:24): [True: 227, False: 1.98k] ------------------ 1522| 227| codebini(fs, OP_ADDI, e1, e2, flip, line, TM_ADD); 1523| 16.8k| else 1524| 16.8k| codearith(fs, op, e1, e2, flip, line); 1525| 17.0k|} lcode.c:finishbinexpneg: 1462| 124k| OpCode op, int line, TMS event) { 1463| 124k| if (!isKint(e2)) ------------------ | Branch (1463:7): [True: 116k, False: 7.64k] ------------------ 1464| 116k| return 0; /* not an integer constant */ 1465| 7.64k| else { 1466| 7.64k| lua_Integer i2 = e2->u.ival; 1467| 7.64k| if (!(fitsC(i2) && fitsC(-i2))) ------------------ | Branch (1467:11): [True: 7.50k, False: 141] | Branch (1467:24): [True: 7.50k, False: 0] ------------------ 1468| 141| return 0; /* not in the proper range */ 1469| 7.50k| else { /* operating a small integer constant */ 1470| 7.50k| int v2 = cast_int(i2); ------------------ | | 141| 7.50k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 7.50k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1471| 7.50k| finishbinexpval(fs, e1, e2, op, int2sC(-v2), 0, line, OP_MMBINI, event); ------------------ | | 100| 7.50k|#define int2sC(i) ((i) + OFFSET_sC) | | ------------------ | | | | 98| 7.50k|#define OFFSET_sC (MAXARG_C >> 1) | | | | ------------------ | | | | | | 97| 7.50k|#define MAXARG_C ((1<f->code[fs->pc - 1], int2sC(v2)); ------------------ | | 130| 7.50k|#define SETARG_B(i,v) setarg(i, v, POS_B, SIZE_B) | | ------------------ | | | | 122| 7.50k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 7.50k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 7.50k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 7.50k| ((cast(Instruction, v)<u.info = pc; 1411| 2.88M| e1->k = VRELOC; /* all those operations are relocatable */ 1412| 2.88M| luaK_fixline(fs, line); 1413| 2.88M| luaK_codeABCk(fs, mmop, v1, v2, event, flip); /* to call metamethod */ 1414| 2.88M| luaK_fixline(fs, line); 1415| 2.88M|} lcode.c:freeexps: 527| 4.96M|static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) { 528| 4.96M| int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1; ------------------ | Branch (528:12): [True: 4.96M, False: 2.14k] ------------------ 529| 4.96M| int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1; ------------------ | Branch (529:12): [True: 4.92M, False: 48.1k] ------------------ 530| 4.96M| freeregs(fs, r1, r2); 531| 4.96M|} lcode.c:codearith: 1501| 2.73M| expdesc *e1, expdesc *e2, int flip, int line) { 1502| 2.73M| if (tonumeral(e2, NULL) && luaK_exp2K(fs, e2)) /* K operand? */ ------------------ | Branch (1502:7): [True: 32.0k, False: 2.70M] | Branch (1502:30): [True: 21.1k, False: 10.8k] ------------------ 1503| 21.1k| codebinK(fs, opr, e1, e2, flip, line); 1504| 2.71M| else /* 'e2' is neither an immediate nor a K operand */ 1505| 2.71M| codebinNoK(fs, opr, e1, e2, flip, line); 1506| 2.73M|} lcode.c:codebinK: 1450| 30.4k| expdesc *e1, expdesc *e2, int flip, int line) { 1451| 30.4k| TMS event = binopr2TM(opr); 1452| 30.4k| int v2 = e2->u.info; /* K index */ 1453| 30.4k| OpCode op = binopr2op(opr, OPR_ADD, OP_ADDK); 1454| 30.4k| finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINK, event); 1455| 30.4k|} lcode.c:binopr2TM: 1378| 2.87M|l_sinline TMS binopr2TM (BinOpr opr) { 1379| 2.87M| lua_assert(OPR_ADD <= opr && opr <= OPR_SHR); ------------------ | | 106| 2.87M|#define lua_assert(c) assert(c) ------------------ 1380| 2.87M| return cast(TMS, (cast_int(opr) - cast_int(OPR_ADD)) + cast_int(TM_ADD)); ------------------ | | 136| 2.87M|#define cast(t, exp) ((t)(exp)) ------------------ 1381| 2.87M|} lcode.c:binopr2op: 1358| 4.95M|l_sinline OpCode binopr2op (BinOpr opr, BinOpr baser, OpCode base) { 1359| 4.95M| lua_assert(baser <= opr && ------------------ | | 106| 4.95M|#define lua_assert(c) assert(c) ------------------ 1360| 4.95M| ((baser == OPR_ADD && opr <= OPR_SHR) || 1361| 4.95M| (baser == OPR_LT && opr <= OPR_LE))); 1362| 4.95M| return cast(OpCode, (cast_int(opr) - cast_int(baser)) + cast_int(base)); ------------------ | | 136| 4.95M|#define cast(t, exp) ((t)(exp)) ------------------ 1363| 4.95M|} lcode.c:codebinNoK: 1489| 2.73M| expdesc *e1, expdesc *e2, int flip, int line) { 1490| 2.73M| if (flip) ------------------ | Branch (1490:7): [True: 617, False: 2.73M] ------------------ 1491| 617| swapexps(e1, e2); /* back to original order */ 1492| 2.73M| codebinexpval(fs, opr, e1, e2, line); /* use standard operators */ 1493| 2.73M|} lcode.c:codebitwise: 1533| 30.4k| expdesc *e1, expdesc *e2, int line) { 1534| 30.4k| int flip = 0; 1535| 30.4k| if (e1->k == VKINT) { ------------------ | Branch (1535:7): [True: 1.05k, False: 29.3k] ------------------ 1536| 1.05k| swapexps(e1, e2); /* 'e2' will be the constant operand */ 1537| 1.05k| flip = 1; 1538| 1.05k| } 1539| 30.4k| if (e2->k == VKINT && luaK_exp2K(fs, e2)) /* K operand? */ ------------------ | Branch (1539:7): [True: 10.6k, False: 19.7k] | Branch (1539:25): [True: 9.30k, False: 1.35k] ------------------ 1540| 9.30k| codebinK(fs, opr, e1, e2, flip, line); 1541| 21.1k| else /* no constants */ 1542| 21.1k| codebinNoK(fs, opr, e1, e2, flip, line); 1543| 30.4k|} lcode.c:isSCint: 1246| 115k|static int isSCint (expdesc *e) { 1247| 115k| return isKint(e) && fitsC(e->u.ival); ------------------ | Branch (1247:10): [True: 3.79k, False: 112k] | Branch (1247:23): [True: 2.69k, False: 1.09k] ------------------ 1248| 115k|} lcode.c:swapexps: 1480| 24.6k|static void swapexps (expdesc *e1, expdesc *e2) { 1481| 24.6k| expdesc temp = *e1; *e1 = *e2; *e2 = temp; /* swap 'e1' and 'e2' */ 1482| 24.6k|} lcode.c:codebini: 1439| 2.69k| TMS event) { 1440| 2.69k| int v2 = int2sC(cast_int(e2->u.ival)); /* immediate operand */ ------------------ | | 100| 2.69k|#define int2sC(i) ((i) + OFFSET_sC) | | ------------------ | | | | 98| 2.69k|#define OFFSET_sC (MAXARG_C >> 1) | | | | ------------------ | | | | | | 97| 2.69k|#define MAXARG_C ((1<k == VKINT); ------------------ | | 106| 2.69k|#define lua_assert(c) assert(c) ------------------ 1442| 2.69k| finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINI, event); 1443| 2.69k|} lcode.c:codebinexpval: 1423| 2.84M| expdesc *e1, expdesc *e2, int line) { 1424| 2.84M| OpCode op = binopr2op(opr, OPR_ADD, OP_ADD); 1425| 2.84M| int v2 = luaK_exp2anyreg(fs, e2); /* make sure 'e2' is in a register */ 1426| | /* 'e1' must be already in a register or it is a constant */ 1427| 2.84M| lua_assert((VNIL <= e1->k && e1->k <= VKSTR) || ------------------ | | 106| 2.84M|#define lua_assert(c) assert(c) ------------------ 1428| 2.84M| e1->k == VNONRELOC || e1->k == VRELOC); 1429| 2.84M| lua_assert(OP_ADD <= op && op <= OP_SHR); ------------------ | | 106| 2.84M|#define lua_assert(c) assert(c) ------------------ 1430| 2.84M| finishbinexpval(fs, e1, e2, op, v2, 0, line, OP_MMBIN, binopr2TM(opr)); 1431| 2.84M|} lcode.c:codeeq: 1582| 3.47k|static void codeeq (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) { 1583| 3.47k| int r1, r2; 1584| 3.47k| int im; 1585| 3.47k| int isfloat = 0; /* not needed here, but kept for symmetry */ 1586| 3.47k| OpCode op; 1587| 3.47k| if (e1->k != VNONRELOC) { ------------------ | Branch (1587:7): [True: 1.90k, False: 1.56k] ------------------ 1588| 1.90k| lua_assert(e1->k == VK || e1->k == VKINT || e1->k == VKFLT); ------------------ | | 106| 1.90k|#define lua_assert(c) assert(c) ------------------ 1589| 1.90k| swapexps(e1, e2); 1590| 1.90k| } 1591| 3.47k| r1 = luaK_exp2anyreg(fs, e1); /* 1st expression must be in register */ 1592| 3.47k| if (isSCnumber(e2, &im, &isfloat)) { ------------------ | Branch (1592:7): [True: 702, False: 2.76k] ------------------ 1593| 702| op = OP_EQI; 1594| 702| r2 = im; /* immediate operand */ 1595| 702| } 1596| 2.76k| else if (exp2RK(fs, e2)) { /* 2nd expression is constant? */ ------------------ | Branch (1596:12): [True: 1.38k, False: 1.37k] ------------------ 1597| 1.38k| op = OP_EQK; 1598| 1.38k| r2 = e2->u.info; /* constant index */ 1599| 1.38k| } 1600| 1.37k| else { 1601| 1.37k| op = OP_EQ; /* will compare two registers */ 1602| 1.37k| r2 = luaK_exp2anyreg(fs, e2); 1603| 1.37k| } 1604| 3.47k| freeexps(fs, e1, e2); 1605| 3.47k| e1->u.info = condjump(fs, op, r1, r2, isfloat, (opr == OPR_EQ)); 1606| 3.47k| e1->k = VJMP; 1607| 3.47k|} lcode.c:codeorder: 1550| 2.07M|static void codeorder (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) { 1551| 2.07M| int r1, r2; 1552| 2.07M| int im; 1553| 2.07M| int isfloat = 0; 1554| 2.07M| OpCode op; 1555| 2.07M| if (isSCnumber(e2, &im, &isfloat)) { ------------------ | Branch (1555:7): [True: 5.43k, False: 2.07M] ------------------ 1556| | /* use immediate operand */ 1557| 5.43k| r1 = luaK_exp2anyreg(fs, e1); 1558| 5.43k| r2 = im; 1559| 5.43k| op = binopr2op(opr, OPR_LT, OP_LTI); 1560| 5.43k| } 1561| 2.07M| else if (isSCnumber(e1, &im, &isfloat)) { ------------------ | Branch (1561:12): [True: 2.14k, False: 2.06M] ------------------ 1562| | /* transform (A < B) to (B > A) and (A <= B) to (B >= A) */ 1563| 2.14k| r1 = luaK_exp2anyreg(fs, e2); 1564| 2.14k| r2 = im; 1565| 2.14k| op = binopr2op(opr, OPR_LT, OP_GTI); 1566| 2.14k| } 1567| 2.06M| else { /* regular case, compare two registers */ 1568| 2.06M| r1 = luaK_exp2anyreg(fs, e1); 1569| 2.06M| r2 = luaK_exp2anyreg(fs, e2); 1570| 2.06M| op = binopr2op(opr, OPR_LT, OP_LT); 1571| 2.06M| } 1572| 2.07M| freeexps(fs, e1, e2); 1573| 2.07M| e1->u.info = condjump(fs, op, r1, r2, isfloat, 1); 1574| 2.07M| e1->k = VJMP; 1575| 2.07M|} lcode.c:removelastlineinfo: 353| 6.04M|static void removelastlineinfo (FuncState *fs) { 354| 6.04M| Proto *f = fs->f; 355| 6.04M| int pc = fs->pc - 1; /* last instruction coded */ 356| 6.04M| if (f->lineinfo[pc] != ABSLINEINFO) { /* relative line info? */ ------------------ | | 27| 6.04M|#define ABSLINEINFO (-0x80) ------------------ | Branch (356:7): [True: 5.99M, False: 46.9k] ------------------ 357| 5.99M| fs->previousline -= f->lineinfo[pc]; /* correct last line saved */ 358| 5.99M| fs->iwthabs--; /* undo previous increment */ 359| 5.99M| } 360| 46.9k| else { /* absolute line information */ 361| 46.9k| lua_assert(f->abslineinfo[fs->nabslineinfo - 1].pc == pc); ------------------ | | 106| 46.9k|#define lua_assert(c) assert(c) ------------------ 362| 46.9k| fs->nabslineinfo--; /* remove it */ 363| 46.9k| fs->iwthabs = MAXIWTHABS + 1; /* force next line info to be absolute */ ------------------ | | 35| 46.9k|#define MAXIWTHABS 128 ------------------ 364| 46.9k| } 365| 6.04M|} lcode.c:finaltarget: 1827| 441k|static int finaltarget (Instruction *code, int i) { 1828| 441k| int count; 1829| 883k| for (count = 0; count < 100; count++) { /* avoid infinite loops */ ------------------ | Branch (1829:19): [True: 883k, False: 9] ------------------ 1830| 883k| Instruction pc = code[i]; 1831| 883k| if (GET_OPCODE(pc) != OP_JMP) ------------------ | | 114| 883k|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 883k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (1831:9): [True: 441k, False: 442k] ------------------ 1832| 441k| break; 1833| 442k| else 1834| 442k| i += GETARG_sJ(pc) + 1; ------------------ | | 151| 442k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | ------------------ | | | | 110| 442k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 442k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1835| 883k| } 1836| 441k| return i; 1837| 441k|} luaG_getfuncline: 83| 80|int luaG_getfuncline (const Proto *f, int pc) { 84| 80| if (f->lineinfo == NULL) /* no debug information? */ ------------------ | Branch (84:7): [True: 0, False: 80] ------------------ 85| 0| return -1; 86| 80| else { 87| 80| int basepc; 88| 80| int baseline = getbaseline(f, pc, &basepc); 89| 2.91k| while (basepc++ < pc) { /* walk until given instruction */ ------------------ | Branch (89:12): [True: 2.83k, False: 80] ------------------ 90| 2.83k| lua_assert(f->lineinfo[basepc] != ABSLINEINFO); ------------------ | | 106| 2.83k|#define lua_assert(c) assert(c) ------------------ 91| 2.83k| baseline += f->lineinfo[basepc]; /* correct line */ 92| 2.83k| } 93| 80| return baseline; 94| 80| } 95| 80|} lua_getstack: 160| 200|LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) { 161| 200| int status; 162| 200| CallInfo *ci; 163| 200| if (level < 0) return 0; /* invalid (negative) level */ ------------------ | Branch (163:7): [True: 0, False: 200] ------------------ 164| 200| lua_lock(L); ------------------ | | 264| 200|#define lua_lock(L) ((void) 0) ------------------ 165| 480| for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous) ------------------ | Branch (165:20): [True: 280, False: 200] | Branch (165:33): [True: 280, False: 0] ------------------ 166| 280| level--; 167| 200| if (level == 0 && ci != &L->base_ci) { /* level found? */ ------------------ | Branch (167:7): [True: 200, False: 0] | Branch (167:21): [True: 120, False: 80] ------------------ 168| 120| status = 1; 169| 120| ar->i_ci = ci; 170| 120| } 171| 80| else status = 0; /* no such level */ 172| 200| lua_unlock(L); ------------------ | | 265| 200|#define lua_unlock(L) ((void) 0) ------------------ 173| 200| return status; 174| 200|} lua_getinfo: 383| 80|LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) { 384| 80| int status; 385| 80| Closure *cl; 386| 80| CallInfo *ci; 387| 80| TValue *func; 388| 80| lua_lock(L); ------------------ | | 264| 80|#define lua_lock(L) ((void) 0) ------------------ 389| 80| if (*what == '>') { ------------------ | Branch (389:7): [True: 0, False: 80] ------------------ 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) | | ------------------ | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 393| 0| what++; /* skip the '>' */ 394| 0| L->top.p--; /* pop function */ 395| 0| } 396| 80| else { 397| 80| ci = ar->i_ci; 398| 80| func = s2v(ci->func.p); ------------------ | | 172| 80|#define s2v(o) (&(o)->val) ------------------ 399| 80| lua_assert(ttisfunction(func)); ------------------ | | 106| 80|#define lua_assert(c) assert(c) ------------------ 400| 80| } 401| 80| cl = ttisclosure(func) ? clvalue(func) : NULL; ------------------ | | 596| 80|#define ttisclosure(o) (ttisLclosure(o) || ttisCclosure(o)) | | ------------------ | | | | 593| 80|#define ttisLclosure(o) checktag((o), ctb(LUA_VLCL)) | | | | ------------------ | | | | | | 91| 160|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 80|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 80, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define ttisclosure(o) (ttisLclosure(o) || ttisCclosure(o)) | | ------------------ | | | | 595| 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; ------------------ | | 601| 80|#define clvalue(o) check_exp(ttisclosure(o), gco2cl(val_(o).gc)) | | ------------------ | | | | 110| 320|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 80|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 80] | | | | | Branch (110:42): [True: 80, False: 0] | | | | ------------------ | | ------------------ ------------------ 402| 0| status = auxgetinfo(L, what, ar, cl, ci); 403| 80| if (strchr(what, 'f')) { ------------------ | Branch (403:7): [True: 40, False: 40] ------------------ 404| 40| setobj2s(L, L->top.p, func); ------------------ | | 131| 40|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 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) || \ | | | | | | ------------------ | | | | | | | | 112| 640|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 40|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 40| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 40|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 405| 40| api_incr_top(L); ------------------ | | 16| 40|#define api_incr_top(L) {L->top.p++; \ | | 17| 40| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 40|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 40|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 40| "stack overflow");} ------------------ 406| 40| } 407| 80| if (strchr(what, 'L')) ------------------ | Branch (407:7): [True: 0, False: 80] ------------------ 408| 0| collectvalidlines(L, cl); 409| 80| lua_unlock(L); ------------------ | | 265| 80|#define lua_unlock(L) ((void) 0) ------------------ 410| 80| return status; 411| 80|} luaG_typeerror: 736| 31|l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) { 737| 31| typeerror(L, o, op, varinfo(L, o)); 738| 31|} luaG_forerror: 755| 3|l_noret luaG_forerror (lua_State *L, const TValue *o, const char *what) { 756| 3| luaG_runerror(L, "bad 'for' %s (number expected, got %s)", 757| 3| what, luaT_objtypename(L, o)); 758| 3|} luaG_concaterror: 761| 1|l_noret luaG_concaterror (lua_State *L, const TValue *p1, const TValue *p2) { 762| 1| if (ttisstring(p1) || cvt2str(p1)) p1 = p2; ------------------ | | 363| 1|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 2|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 1|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 1|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 1] | | | | ------------------ | | ------------------ ------------------ if (ttisstring(p1) || cvt2str(p1)) p1 = p2; ------------------ | | 17| 1|#define cvt2str(o) ttisnumber(o) | | ------------------ | | | | 326| 1|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 1|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 1|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 1|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 763| 1| luaG_typeerror(L, p1, "concatenate"); 764| 1|} luaG_opinterror: 768| 27| const TValue *p2, const char *msg) { 769| 27| if (!ttisnumber(p1)) /* first operand is wrong? */ ------------------ | | 326| 27|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | ------------------ | | | | 92| 27|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 27|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 27|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (769:7): [True: 25, False: 2] ------------------ 770| 25| p2 = p1; /* now second is wrong */ 771| 27| luaG_typeerror(L, p2, msg); 772| 27|} luaG_tointerror: 778| 2|l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) { 779| 2| lua_Integer temp; 780| 2| if (!luaV_tointegerns(p1, &temp, LUA_FLOORN2I)) ------------------ | | 36| 2|#define LUA_FLOORN2I F2Ieq ------------------ | Branch (780:7): [True: 2, False: 0] ------------------ 781| 2| p2 = p1; 782| 2| luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2)); 783| 2|} luaG_ordererror: 786| 3|l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) { 787| 3| const char *t1 = luaT_objtypename(L, p1); 788| 3| const char *t2 = luaT_objtypename(L, p2); 789| 3| if (strcmp(t1, t2) == 0) ------------------ | Branch (789:7): [True: 1, False: 2] ------------------ 790| 1| luaG_runerror(L, "attempt to compare two %s values", t1); 791| 2| else 792| 2| luaG_runerror(L, "attempt to compare %s with %s", t1, t2); 793| 3|} luaG_addinfo: 798| 218| int line) { 799| 218| char buff[LUA_IDSIZE]; 800| 218| if (src) ------------------ | Branch (800:7): [True: 218, False: 0] ------------------ 801| 218| luaO_chunkid(buff, getstr(src), tsslen(src)); ------------------ | | 404| 218|#define getstr(ts) ((ts)->contents) ------------------ luaO_chunkid(buff, getstr(src), tsslen(src)); ------------------ | | 411| 218| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 218, False: 0] | | ------------------ ------------------ 802| 0| else { /* no source available; use "?" instead */ 803| 0| buff[0] = '?'; buff[1] = '\0'; 804| 0| } 805| 218| return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg); 806| 218|} luaG_errormsg: 809| 42|l_noret luaG_errormsg (lua_State *L) { 810| 42| if (L->errfunc != 0) { /* is there an error handling function? */ ------------------ | Branch (810:7): [True: 40, False: 2] ------------------ 811| 40| StkId errfunc = restorestack(L, L->errfunc); ------------------ | | 37| 40|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 40|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 812| 40| lua_assert(ttisfunction(s2v(errfunc))); ------------------ | | 106| 40|#define lua_assert(c) assert(c) ------------------ 813| 40| setobjs2s(L, L->top.p, L->top.p - 1); /* move argument */ ------------------ | | 129| 40|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 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) || \ | | | | | | ------------------ | | | | | | | | 112| 640|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 40|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 40| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 40|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 814| 40| setobjs2s(L, L->top.p - 1, errfunc); /* push function */ ------------------ | | 129| 40|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 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) || \ | | | | | | ------------------ | | | | | | | | 112| 40|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 40|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 40| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 40|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 815| 40| L->top.p++; /* assume EXTRA_STACK */ 816| 40| luaD_callnoyield(L, L->top.p - 2, 1); /* call it */ 817| 40| } 818| 42| luaD_throw(L, LUA_ERRRUN); ------------------ | | 50| 42|#define LUA_ERRRUN 2 ------------------ 819| 42|} luaG_runerror: 822| 42|l_noret luaG_runerror (lua_State *L, const char *fmt, ...) { 823| 42| CallInfo *ci = L->ci; 824| 42| const char *msg; 825| 42| va_list argp; 826| 42| luaC_checkGC(L); /* error message uses memory */ ------------------ | | 172| 42|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 42| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 42|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 1, False: 41] | | | | ------------------ | | | | 169| 42| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 42|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 827| 42| va_start(argp, fmt); 828| 42| msg = luaO_pushvfstring(L, fmt, argp); /* format message */ 829| 42| va_end(argp); 830| 42| if (isLua(ci)) { /* if Lua function, add source:line information */ ------------------ | | 241| 42|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 42|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 40, False: 2] | | ------------------ ------------------ 831| 80| luaG_addinfo(L, msg, ci_func(ci)->p->source, getcurrentline(ci)); ------------------ | | 18| 40|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 40|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 110| 160|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 40|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 40] | | | | | | | Branch (110:42): [True: 40, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 832| 40| setobjs2s(L, L->top.p - 2, L->top.p - 1); /* remove 'msg' */ ------------------ | | 129| 40|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 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) || \ | | | | | | ------------------ | | | | | | | | 112| 640|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 40|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 40, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 40] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 40| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 40|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 833| 40| L->top.p--; 834| 40| } 835| 42| luaG_errormsg(L); 836| 42|} luaG_tracecall: 876| 9|int luaG_tracecall (lua_State *L) { 877| 9| CallInfo *ci = L->ci; 878| 18| Proto *p = ci_func(ci)->p; ------------------ | | 18| 9|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 9|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 110| 36|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 9|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 9] | | | | | | | Branch (110:42): [True: 9, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 879| 0| ci->u.l.trap = 1; /* ensure hooks will be checked */ 880| 18| if (ci->u.l.savedpc == p->code) { /* first instruction (not resuming)? */ ------------------ | Branch (880:7): [True: 0, False: 9] ------------------ 881| 0| if (p->is_vararg) ------------------ | Branch (881:9): [True: 0, False: 0] ------------------ 882| 0| return 0; /* hooks will start at VARARGPREP instruction */ 883| 0| else if (!(ci->callstatus & CIST_HOOKYIELD)) /* not yieded? */ ------------------ | | 216| 0|#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */ ------------------ | Branch (883:14): [True: 0, False: 0] ------------------ 884| 0| luaD_hookcall(L, ci); /* check 'call' hook */ 885| 0| } 886| 9| return 1; /* keep 'trap' on */ 887| 18|} luaG_traceexec: 902| 278|int luaG_traceexec (lua_State *L, const Instruction *pc) { 903| 278| CallInfo *ci = L->ci; 904| 278| lu_byte mask = L->hookmask; 905| 556| const Proto *p = ci_func(ci)->p; ------------------ | | 18| 278|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 278|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 110| 1.11k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 278|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 278] | | | | | | | Branch (110:42): [True: 278, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 906| 0| int counthook; 907| 556| if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) { /* no hooks? */ ------------------ | | 452| 278|#define LUA_MASKLINE (1 << LUA_HOOKLINE) | | ------------------ | | | | 442| 278|#define LUA_HOOKLINE 2 | | ------------------ ------------------ if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) { /* no hooks? */ ------------------ | | 453| 278|#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) | | ------------------ | | | | 443| 278|#define LUA_HOOKCOUNT 3 | | ------------------ ------------------ | Branch (907:7): [True: 278, False: 0] ------------------ 908| 278| ci->u.l.trap = 0; /* don't need to stop again */ 909| 278| return 0; /* turn off 'trap' */ 910| 278| } 911| 0| pc++; /* reference is always next instruction */ 912| 0| ci->u.l.savedpc = pc; /* save 'pc' */ 913| 0| counthook = (--L->hookcount == 0 && (mask & LUA_MASKCOUNT)); ------------------ | | 453| 0|#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) | | ------------------ | | | | 443| 0|#define LUA_HOOKCOUNT 3 | | ------------------ ------------------ | Branch (913:16): [True: 0, False: 0] | Branch (913:39): [True: 0, False: 0] ------------------ 914| 0| if (counthook) ------------------ | Branch (914:7): [True: 0, False: 0] ------------------ 915| 0| resethookcount(L); /* reset count */ ------------------ | | 21| 0|#define resethookcount(L) (L->hookcount = L->basehookcount) ------------------ 916| 0| else if (!(mask & LUA_MASKLINE)) ------------------ | | 452| 0|#define LUA_MASKLINE (1 << LUA_HOOKLINE) | | ------------------ | | | | 442| 0|#define LUA_HOOKLINE 2 | | ------------------ ------------------ | Branch (916:12): [True: 0, False: 0] ------------------ 917| 0| return 1; /* no line hook and count != 0; nothing to be done now */ 918| 0| if (ci->callstatus & CIST_HOOKYIELD) { /* called hook last time? */ ------------------ | | 216| 0|#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */ ------------------ | Branch (918:7): [True: 0, False: 0] ------------------ 919| 0| ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */ ------------------ | | 216| 0|#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */ ------------------ 920| 0| return 1; /* do not call hook again (VM yielded, so it did not move) */ 921| 0| } 922| 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (396:48): [True: 0, False: 0] | | ------------------ ------------------ 923| 0| L->top.p = ci->top.p; /* correct top */ 924| 0| if (counthook) ------------------ | Branch (924:7): [True: 0, False: 0] ------------------ 925| 0| luaD_hook(L, LUA_HOOKCOUNT, -1, 0, 0); /* call count hook */ ------------------ | | 443| 0|#define LUA_HOOKCOUNT 3 ------------------ 926| 0| if (mask & LUA_MASKLINE) { ------------------ | | 452| 0|#define LUA_MASKLINE (1 << LUA_HOOKLINE) | | ------------------ | | | | 442| 0|#define LUA_HOOKLINE 2 | | ------------------ ------------------ | Branch (926:7): [True: 0, False: 0] ------------------ 927| | /* 'L->oldpc' may be invalid; use zero in this case */ 928| 0| int oldpc = (L->oldpc < p->sizecode) ? L->oldpc : 0; ------------------ | Branch (928:17): [True: 0, False: 0] ------------------ 929| 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)) | | | | ------------------ | | ------------------ ------------------ 930| 0| if (npci <= oldpc || /* call hook when jump back (loop), */ ------------------ | Branch (930:9): [True: 0, False: 0] ------------------ 931| 0| changedline(p, oldpc, npci)) { /* or when enter new line */ ------------------ | Branch (931:9): [True: 0, False: 0] ------------------ 932| 0| int newline = luaG_getfuncline(p, npci); 933| 0| luaD_hook(L, LUA_HOOKLINE, newline, 0, 0); /* call line hook */ ------------------ | | 442| 0|#define LUA_HOOKLINE 2 ------------------ 934| 0| } 935| 0| L->oldpc = npci; /* 'pc' of last call to line hook */ 936| 0| } 937| 0| if (L->status == LUA_YIELD) { /* did hook yield? */ ------------------ | | 49| 0|#define LUA_YIELD 1 ------------------ | Branch (937:7): [True: 0, False: 0] ------------------ 938| 0| if (counthook) ------------------ | Branch (938:9): [True: 0, False: 0] ------------------ 939| 0| L->hookcount = 1; /* undo decrement to zero */ 940| 0| ci->u.l.savedpc--; /* undo increment (resume will increment it again) */ 941| 0| ci->callstatus |= CIST_HOOKYIELD; /* mark that it yielded */ ------------------ | | 216| 0|#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */ ------------------ 942| 0| luaD_throw(L, LUA_YIELD); ------------------ | | 49| 0|#define LUA_YIELD 1 ------------------ 943| 0| } 944| 0| return 1; /* keep 'trap' on */ 945| 0|} ldebug.c:getbaseline: 60| 80|static int getbaseline (const Proto *f, int pc, int *basepc) { 61| 80| if (f->sizeabslineinfo == 0 || pc < f->abslineinfo[0].pc) { ------------------ | Branch (61:7): [True: 32, False: 48] | Branch (61:34): [True: 8, False: 40] ------------------ 62| 40| *basepc = -1; /* start from the beginning */ 63| 40| return f->linedefined; 64| 40| } 65| 40| else { 66| 40| int i = cast_uint(pc) / MAXIWTHABS - 1; /* get an estimate */ ------------------ | | 142| 40|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 40|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ int i = cast_uint(pc) / MAXIWTHABS - 1; /* get an estimate */ ------------------ | | 35| 40|#define MAXIWTHABS 128 ------------------ 67| | /* estimate must be a lower bound of the correct base */ 68| 40| lua_assert(i < 0 || ------------------ | | 106| 40|#define lua_assert(c) assert(c) ------------------ 69| 40| (i < f->sizeabslineinfo && f->abslineinfo[i].pc <= pc)); 70| 48| while (i + 1 < f->sizeabslineinfo && pc >= f->abslineinfo[i + 1].pc) ------------------ | Branch (70:12): [True: 30, False: 18] | Branch (70:42): [True: 8, False: 22] ------------------ 71| 8| i++; /* low estimate; adjust it */ 72| 40| *basepc = f->abslineinfo[i].pc; 73| 40| return f->abslineinfo[i].line; 74| 40| } 75| 80|} ldebug.c:currentpc: 41| 113|static int currentpc (CallInfo *ci) { 42| 113| lua_assert(isLua(ci)); ------------------ | | 106| 113|#define lua_assert(c) assert(c) ------------------ 43| 113| return pcRel(ci->u.l.savedpc, ci_func(ci)->p); ------------------ | | 14| 113|#define pcRel(pc, p) (cast_int((pc) - (p)->code) - 1) | | ------------------ | | | | 141| 113|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 904|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (136:27): [True: 0, False: 113] | | | | | | | Branch (136:27): [True: 113, False: 0] | | | | | | | Branch (136:27): [True: 0, False: 113] | | | | | | | Branch (136:27): [True: 113, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 44| 113|} ldebug.c:auxgetinfo: 328| 80| Closure *f, CallInfo *ci) { 329| 80| int status = 1; 330| 280| for (; *what; what++) { ------------------ | Branch (330:10): [True: 200, False: 80] ------------------ 331| 200| switch (*what) { 332| 40| case 'S': { ------------------ | Branch (332:7): [True: 40, False: 160] ------------------ 333| 40| funcinfo(ar, f); 334| 40| break; 335| 0| } 336| 40| case 'l': { ------------------ | Branch (336:7): [True: 40, False: 160] ------------------ 337| 40| ar->currentline = (ci && isLua(ci)) ? getcurrentline(ci) : -1; ------------------ | | 241| 40|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 40|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 40, False: 0] | | ------------------ ------------------ | Branch (337:28): [True: 40, False: 0] ------------------ 338| 40| break; 339| 0| } 340| 0| case 'u': { ------------------ | Branch (340:7): [True: 0, False: 200] ------------------ 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) | | ------------------ | | | | 590| 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| 40| case 't': { ------------------ | Branch (352:7): [True: 40, False: 160] ------------------ 353| 40| ar->istailcall = (ci) ? ci->callstatus & CIST_TAIL : 0; ------------------ | | 215| 40|#define CIST_TAIL (1<<5) /* call was tail called */ ------------------ | Branch (353:26): [True: 40, False: 0] ------------------ 354| 40| break; 355| 0| } 356| 40| case 'n': { ------------------ | Branch (356:7): [True: 40, False: 160] ------------------ 357| 40| ar->namewhat = getfuncname(L, ci, &ar->name); 358| 40| if (ar->namewhat == NULL) { ------------------ | Branch (358:13): [True: 40, False: 0] ------------------ 359| 40| ar->namewhat = ""; /* not found */ 360| 40| ar->name = NULL; 361| 40| } 362| 40| break; 363| 0| } 364| 0| case 'r': { ------------------ | Branch (364:7): [True: 0, False: 200] ------------------ 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: 200] ------------------ 374| 40| case 'f': /* handled by lua_getinfo */ ------------------ | Branch (374:7): [True: 40, False: 160] ------------------ 375| 40| break; 376| 0| default: status = 0; /* invalid option */ ------------------ | Branch (376:7): [True: 0, False: 200] ------------------ 377| 200| } 378| 200| } 379| 80| return status; 380| 80|} ldebug.c:funcinfo: 256| 40|static void funcinfo (lua_Debug *ar, Closure *cl) { 257| 40| if (noLuaClosure(cl)) { ------------------ | | 34| 40|#define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_VCCL) | | ------------------ | | | | 590| 40|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | | | ------------------ | | | | | | 42| 40|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (34:27): [True: 0, False: 40] | | | Branch (34:42): [True: 0, False: 40] | | ------------------ ------------------ 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| 40| else { 265| 40| const Proto *p = cl->l.p; 266| 40| if (p->source) { ------------------ | Branch (266:9): [True: 40, False: 0] ------------------ 267| 40| ar->source = getstr(p->source); ------------------ | | 404| 40|#define getstr(ts) ((ts)->contents) ------------------ 268| 40| ar->srclen = tsslen(p->source); ------------------ | | 411| 40| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 40, False: 0] | | ------------------ ------------------ 269| 40| } 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| 40| ar->linedefined = p->linedefined; 275| 40| ar->lastlinedefined = p->lastlinedefined; 276| 40| ar->what = (ar->linedefined == 0) ? "main" : "Lua"; ------------------ | Branch (276:16): [True: 40, False: 0] ------------------ 277| 40| } 278| 40| luaO_chunkid(ar->short_src, ar->source, ar->srclen); 279| 40|} ldebug.c:getfuncname: 319| 40|static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) { 320| | /* calling function is a known function? */ 321| 40| if (ci != NULL && !(ci->callstatus & CIST_TAIL)) ------------------ | | 215| 40|#define CIST_TAIL (1<<5) /* call was tail called */ ------------------ | Branch (321:7): [True: 40, False: 0] | Branch (321:21): [True: 40, False: 0] ------------------ 322| 40| return funcnamefromcall(L, ci->previous, name); 323| 0| else return NULL; /* no way to find a name */ 324| 40|} 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| 33|static const char *varinfo (lua_State *L, const TValue *o) { 707| 33| CallInfo *ci = L->ci; 708| 33| const char *name = NULL; /* to avoid warnings */ 709| 33| const char *kind = NULL; 710| 33| if (isLua(ci)) { ------------------ | | 241| 33|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 33|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 33, False: 0] | | ------------------ ------------------ 711| 33| kind = getupvalname(ci, o, &name); /* check whether 'o' is an upvalue */ 712| 33| if (!kind) { /* not an upvalue? */ ------------------ | Branch (712:9): [True: 33, False: 0] ------------------ 713| 33| int reg = instack(ci, o); /* try a register */ 714| 33| if (reg >= 0) /* is 'o' a register? */ ------------------ | Branch (714:11): [True: 33, False: 0] ------------------ 715| 66| kind = getobjname(ci_func(ci)->p, currentpc(ci), reg, &name); ------------------ | | 18| 33|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 33|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 110| 132|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 33|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 33] | | | | | | | Branch (110:42): [True: 33, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 716| 33| } 717| 33| } 718| 33| return formatvarinfo(L, kind, name); 719| 33|} ldebug.c:getupvalname: 681| 33| const char **name) { 682| 66| LClosure *c = ci_func(ci); ------------------ | | 18| 33|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 33|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 110| 132|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 33|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 33] | | | | | | | Branch (110:42): [True: 33, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 683| 0| int i; 684| 66| for (i = 0; i < c->nupvalues; i++) { ------------------ | Branch (684:15): [True: 33, False: 33] ------------------ 685| 33| if (c->upvals[i]->v.p == o) { ------------------ | Branch (685:9): [True: 0, False: 33] ------------------ 686| 0| *name = upvalname(c->p, i); 687| 0| return "upvalue"; 688| 0| } 689| 33| } 690| 33| return NULL; 691| 66|} ldebug.c:upvalname: 177| 13|static const char *upvalname (const Proto *p, int uv) { 178| 13| TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name); ------------------ | | 110| 13|#define check_exp(c,e) (lua_assert(c), (e)) | | ------------------ | | | | 106| 13|#define lua_assert(c) assert(c) | | ------------------ ------------------ 179| 13| if (s == NULL) return "?"; ------------------ | Branch (179:7): [True: 0, False: 13] ------------------ 180| 13| else return getstr(s); ------------------ | | 404| 13|#define getstr(ts) ((ts)->contents) ------------------ 181| 13|} ldebug.c:instack: 664| 33|static int instack (CallInfo *ci, const TValue *o) { 665| 33| int pos; 666| 33| StkId base = ci->func.p + 1; 667| 71| for (pos = 0; base + pos < ci->top.p; pos++) { ------------------ | Branch (667:17): [True: 71, False: 0] ------------------ 668| 71| if (o == s2v(base + pos)) ------------------ | | 172| 71|#define s2v(o) (&(o)->val) ------------------ | Branch (668:9): [True: 33, False: 38] ------------------ 669| 33| return pos; 670| 71| } 671| 0| return -1; /* not found */ 672| 33|} ldebug.c:getobjname: 527| 39| const char **name) { 528| 39| int pc; 529| 39| *name = luaF_getlocalname(p, reg + 1, lastpc); 530| 39| if (*name) /* is a local? */ ------------------ | Branch (530:7): [True: 0, False: 39] ------------------ 531| 0| return "local"; 532| | /* else try symbolic execution */ 533| 39| pc = findsetreg(p, lastpc, reg); 534| 39| if (pc != -1) { /* could find instruction? */ ------------------ | Branch (534:7): [True: 39, False: 0] ------------------ 535| 39| Instruction i = p->code[pc]; 536| 39| OpCode op = GET_OPCODE(i); ------------------ | | 114| 39|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 39|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 537| 39| switch (op) { 538| 0| case OP_MOVE: { ------------------ | Branch (538:7): [True: 0, False: 39] ------------------ 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)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 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| 10| case OP_GETTABUP: { ------------------ | Branch (544:7): [True: 10, False: 29] ------------------ 545| 10| int k = GETARG_C(i); /* key index */ ------------------ | | 132| 10|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 110| 10|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 10|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 546| 0| kname(p, k, name); 547| 10| return gxf(p, pc, i, 1); 548| 10| } 549| 3| case OP_GETTABLE: { ------------------ | Branch (549:7): [True: 3, False: 36] ------------------ 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)) | | ------------------ | | | | 110| 3|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 3|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 551| 0| rname(p, pc, k, name); 552| 3| return gxf(p, pc, i, 0); 553| 3| } 554| 0| case OP_GETI: { ------------------ | Branch (554:7): [True: 0, False: 39] ------------------ 555| 0| *name = "integer index"; 556| 0| return "field"; 557| 3| } 558| 0| case OP_GETFIELD: { ------------------ | Branch (558:7): [True: 0, False: 39] ------------------ 559| 0| int k = GETARG_C(i); /* key index */ ------------------ | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 560| 0| kname(p, k, name); 561| 0| return gxf(p, pc, i, 0); 562| 0| } 563| 3| case OP_GETUPVAL: { ------------------ | Branch (563:7): [True: 3, False: 36] ------------------ 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)) | | ------------------ | | | | 110| 3|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 3|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 565| 0| return "upvalue"; 566| 3| } 567| 20| case OP_LOADK: ------------------ | Branch (567:7): [True: 20, False: 19] ------------------ 568| 20| case OP_LOADKX: { ------------------ | Branch (568:7): [True: 0, False: 39] ------------------ 569| 20| int b = (op == OP_LOADK) ? GETARG_Bx(i) ------------------ | | 140| 20|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 110| 20|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 20|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (569:17): [True: 20, False: 0] ------------------ 570| 20| : GETARG_Ax(p->code[pc + 1]); ------------------ | | 143| 0|#define GETARG_Ax(i) check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 571| 20| if (ttisstring(&p->k[b])) { ------------------ | | 363| 20|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 20|#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: 20, False: 0] | | | | ------------------ | | ------------------ ------------------ 572| 20| *name = getstr(tsvalue(&p->k[b])); ------------------ | | 404| 160|#define getstr(ts) ((ts)->contents) | | ------------------ | | | Branch (404:22): [True: 0, False: 20] | | | Branch (404:22): [True: 20, False: 0] | | | Branch (404:22): [True: 0, False: 20] | | | Branch (404:22): [True: 20, False: 0] | | ------------------ ------------------ 573| 0| return "constant"; 574| 20| } 575| 0| break; 576| 20| } 577| 0| case OP_SELF: { ------------------ | Branch (577:7): [True: 0, False: 39] ------------------ 578| 0| rkname(p, pc, i, name); 579| 0| return "method"; 580| 20| } 581| 3| default: break; /* go through to return NULL */ ------------------ | Branch (581:7): [True: 3, False: 36] ------------------ 582| 39| } 583| 39| } 584| 3| return NULL; /* could not find reasonable name */ 585| 39|} ldebug.c:findsetreg: 465| 39|static int findsetreg (const Proto *p, int lastpc, int reg) { 466| 39| int pc; 467| 39| int setreg = -1; /* keep last instruction that changed 'reg' */ 468| 39| int jmptarget = 0; /* any code before this address is conditional */ 469| 39| if (testMMMode(GET_OPCODE(p->code[lastpc]))) ------------------ | | 388| 39|#define testMMMode(m) (luaP_opmodes[m] & (1 << 7)) | | ------------------ | | | Branch (388:23): [True: 17, False: 22] | | ------------------ ------------------ 470| 17| lastpc--; /* previous instruction was not actually executed */ 471| 2.29M| for (pc = 0; pc < lastpc; pc++) { ------------------ | Branch (471:16): [True: 2.29M, False: 39] ------------------ 472| 2.29M| Instruction i = p->code[pc]; 473| 2.29M| OpCode op = GET_OPCODE(i); ------------------ | | 114| 2.29M|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 2.29M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 474| 2.29M| int a = GETARG_A(i); ------------------ | | 125| 2.29M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 2.29M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 2.29M|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 2.29M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 475| 2.29M| int change; /* true if current instruction changed 'reg' */ 476| 2.29M| switch (op) { 477| 5.54k| case OP_LOADNIL: { /* set registers from 'a' to 'a+b' */ ------------------ | Branch (477:7): [True: 5.54k, False: 2.29M] ------------------ 478| 5.54k| int b = GETARG_B(i); ------------------ | | 128| 5.54k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 5.54k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 5.54k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 479| 5.54k| change = (a <= reg && reg <= a + b); ------------------ | Branch (479:19): [True: 5.51k, False: 36] | Branch (479:31): [True: 5.49k, False: 15] ------------------ 480| 5.54k| break; 481| 5.54k| } 482| 0| case OP_TFORCALL: { /* affect all regs above its base */ ------------------ | Branch (482:7): [True: 0, False: 2.29M] ------------------ 483| 0| change = (reg >= a + 2); 484| 0| break; 485| 5.54k| } 486| 62.8k| case OP_CALL: ------------------ | Branch (486:7): [True: 62.8k, False: 2.23M] ------------------ 487| 62.8k| case OP_TAILCALL: { /* affect all registers above base */ ------------------ | Branch (487:7): [True: 0, False: 2.29M] ------------------ 488| 62.8k| change = (reg >= a); 489| 62.8k| break; 490| 62.8k| } 491| 399k| case OP_JMP: { /* doesn't change registers, but changes 'jmptarget' */ ------------------ | Branch (491:7): [True: 399k, False: 1.89M] ------------------ 492| 399k| int b = GETARG_sJ(i); ------------------ | | 151| 399k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | ------------------ | | | | 110| 399k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 399k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 493| 0| int dest = pc + 1 + b; 494| | /* jump does not skip 'lastpc' and is larger than current one? */ 495| 399k| if (dest <= lastpc && dest > jmptarget) ------------------ | Branch (495:13): [True: 399k, False: 0] | Branch (495:31): [True: 850, False: 398k] ------------------ 496| 850| jmptarget = dest; /* update 'jmptarget' */ 497| 399k| change = 0; 498| 399k| break; 499| 399k| } 500| 1.82M| default: /* any instruction that sets A */ ------------------ | Branch (500:7): [True: 1.82M, False: 467k] ------------------ 501| 1.82M| change = (testAMode(op) && reg == a); ------------------ | | 384| 3.65M|#define testAMode(m) (luaP_opmodes[m] & (1 << 3)) | | ------------------ | | | Branch (384:22): [True: 1.37M, False: 452k] | | ------------------ ------------------ | Branch (501:36): [True: 439k, False: 936k] ------------------ 502| 1.82M| break; 503| 2.29M| } 504| 2.29M| if (change) ------------------ | Branch (504:9): [True: 463k, False: 1.83M] ------------------ 505| 463k| setreg = filterpc(pc, jmptarget); 506| 2.29M| } 507| 39| return setreg; 508| 39|} ldebug.c:filterpc: 455| 463k|static int filterpc (int pc, int jmptarget) { 456| 463k| if (pc < jmptarget) /* is code conditional (inside a jump)? */ ------------------ | Branch (456:7): [True: 461k, False: 2.31k] ------------------ 457| 461k| return -1; /* cannot know who sets that register */ 458| 2.31k| else return pc; /* current position sets that register */ 459| 463k|} ldebug.c:kname: 427| 10|static void kname (const Proto *p, int c, const char **name) { 428| 10| TValue *kvalue = &p->k[c]; 429| 10| *name = (ttisstring(kvalue)) ? getstr(tsvalue(kvalue)) : "?"; ------------------ | | 363| 10|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 10|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 10|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 10|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ *name = (ttisstring(kvalue)) ? getstr(tsvalue(kvalue)) : "?"; ------------------ | | 404| 80|#define getstr(ts) ((ts)->contents) | | ------------------ | | | Branch (404:22): [True: 0, False: 10] | | | Branch (404:22): [True: 10, False: 0] | | | Branch (404:22): [True: 0, False: 10] | | | Branch (404:22): [True: 10, False: 0] | | ------------------ ------------------ | Branch (429:11): [True: 10, False: 0] ------------------ 430| 10|} ldebug.c:gxf: 515| 13|static const char *gxf (const Proto *p, int pc, Instruction i, int isup) { 516| 13| int t = GETARG_B(i); /* table index */ ------------------ | | 128| 13|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 13|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 13|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 517| 0| const char *name; /* name of indexed variable */ 518| 13| if (isup) /* is an upvalue? */ ------------------ | Branch (518:7): [True: 10, False: 3] ------------------ 519| 10| name = upvalname(p, t); 520| 3| else 521| 3| getobjname(p, pc, t, &name); 522| 13| return (name && strcmp(name, LUA_ENV) == 0) ? "global" : "field"; ------------------ | | 24| 13|#define LUA_ENV "_ENV" ------------------ | Branch (522:11): [True: 13, False: 0] | Branch (522:19): [True: 13, False: 0] ------------------ 523| 13|} 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| 40| const char **name) { 640| 40| if (ci->callstatus & CIST_HOOKED) { /* was it called inside a hook? */ ------------------ | | 213| 40|#define CIST_HOOKED (1<<3) /* call is running a debug hook */ ------------------ | Branch (640:7): [True: 0, False: 40] ------------------ 641| 0| *name = "?"; 642| 0| return "hook"; 643| 0| } 644| 40| else if (ci->callstatus & CIST_FIN) { /* was it called as a finalizer? */ ------------------ | | 217| 40|#define CIST_FIN (1<<7) /* function "called" a finalizer */ ------------------ | Branch (644:12): [True: 0, False: 40] ------------------ 645| 0| *name = "__gc"; 646| 0| return "metamethod"; /* report it as such */ 647| 0| } 648| 40| else if (isLua(ci)) ------------------ | | 241| 40|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 40|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 0, False: 40] | | ------------------ ------------------ 649| 0| return funcnamefromcode(L, ci_func(ci)->p, currentpc(ci), name); ------------------ | | 18| 0|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 0|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 650| 40| else 651| 40| return NULL; 652| 40|} ldebug.c:formatvarinfo: 695| 33| const char *name) { 696| 33| if (kind == NULL) ------------------ | Branch (696:7): [True: 3, False: 30] ------------------ 697| 3| return ""; /* no information */ 698| 30| else 699| 30| return luaO_pushfstring(L, " (%s '%s')", kind, name); 700| 33|} ldebug.c:getcurrentline: 98| 80|static int getcurrentline (CallInfo *ci) { 99| 80| return luaG_getfuncline(ci_func(ci)->p, currentpc(ci)); ------------------ | | 18| 80|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 80|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 110| 320|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 80|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 80] | | | | | | | Branch (110:42): [True: 80, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 100| 80|} luaD_seterrorobj: 91| 220|void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) { 92| 220| switch (errcode) { 93| 0| case LUA_ERRMEM: { /* memory error? */ ------------------ | | 52| 0|#define LUA_ERRMEM 4 ------------------ | Branch (93:5): [True: 0, False: 220] ------------------ 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)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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) || \ | | | | | | ------------------ | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 95| 0| break; 96| 0| } 97| 0| case LUA_ERRERR: { ------------------ | | 53| 0|#define LUA_ERRERR 5 ------------------ | Branch (97:5): [True: 0, False: 220] ------------------ 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)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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) || \ | | | | | | ------------------ | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 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 */ ------------------ | | 48| 0|#define LUA_OK 0 ------------------ | Branch (101:5): [True: 0, False: 220] ------------------ 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| 220| default: { ------------------ | Branch (105:5): [True: 220, False: 0] ------------------ 106| 220| lua_assert(errorstatus(errcode)); /* real error */ ------------------ | | 106| 220|#define lua_assert(c) assert(c) ------------------ 107| 220| setobjs2s(L, oldtop, L->top.p - 1); /* error message on current top */ ------------------ | | 129| 220|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 220| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 220| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 220|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 220| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 220| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 3.52k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 220|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 220] | | | | | | | | | Branch (112:29): [True: 220, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 220] | | | | | | | | | Branch (112:29): [True: 220, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 220] | | | | | | | | | Branch (112:29): [True: 220, False: 0] | | | | | | | | | Branch (112:29): [True: 220, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 220] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 220| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 220|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 108| 220| break; 109| 220| } 110| 220| } 111| 220| L->top.p = oldtop + 1; 112| 220|} luaD_throw: 115| 220|l_noret luaD_throw (lua_State *L, int errcode) { 116| 220| if (L->errorJmp) { /* thread has an error handler? */ ------------------ | Branch (116:7): [True: 220, False: 0] ------------------ 117| 220| L->errorJmp->status = errcode; /* set status */ 118| 220| LUAI_THROW(L, L->errorJmp); /* jump to it */ ------------------ | | 73| 220|#define LUAI_THROW(L,c) longjmp((c)->b, 1) ------------------ 119| 220| } 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) || \ | | | | | | ------------------ | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 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| 220|} luaD_rawrunprotected: 138| 952|int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) { 139| 952| l_uint32 oldnCcalls = L->nCcalls; 140| 952| struct lua_longjmp lj; 141| 952| lj.status = LUA_OK; ------------------ | | 48| 952|#define LUA_OK 0 ------------------ 142| 952| lj.previous = L->errorJmp; /* chain new error handler */ 143| 952| L->errorJmp = &lj; 144| 952| LUAI_TRY(L, &lj, ------------------ | | 74| 952|#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a } | | ------------------ | | | Branch (74:30): [True: 952, False: 0] | | ------------------ ------------------ 145| 952| (*f)(L, ud); 146| 952| ); 147| 952| L->errorJmp = lj.previous; /* restore old error handler */ 148| 952| L->nCcalls = oldnCcalls; 149| 952| return lj.status; 150| 952|} luaD_reallocstack: 212| 273|int luaD_reallocstack (lua_State *L, int newsize, int raiseerror) { 213| 273| int oldsize = stacksize(L); ------------------ | | 147| 273|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 273|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 273|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 214| 273| int i; 215| 273| StkId newstack; 216| 273| int oldgcstop = G(L)->gcstopem; ------------------ | | 335| 273|#define G(L) (L->l_G) ------------------ 217| 273| lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE); ------------------ | | 106| 273|#define lua_assert(c) assert(c) ------------------ 218| 273| relstack(L); /* change pointers to offsets */ 219| 273| G(L)->gcstopem = 1; /* stop emergency collection */ ------------------ | | 335| 273|#define G(L) (L->l_G) ------------------ 220| 273| newstack = luaM_reallocvector(L, L->stack.p, oldsize + EXTRA_STACK, ------------------ | | 71| 273| (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \ | | ------------------ | | | | 136| 273|#define cast(t, exp) ((t)(exp)) | | ------------------ | | 72| 273| cast_sizet(n) * sizeof(t)))) ------------------ 221| 273| newsize + EXTRA_STACK, StackValue); 222| 273| G(L)->gcstopem = oldgcstop; /* restore emergency collection */ ------------------ | | 335| 273|#define G(L) (L->l_G) ------------------ 223| 273| if (l_unlikely(newstack == NULL)) { /* reallocation failed? */ ------------------ | | 697| 273|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 273|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 273] | | | | ------------------ | | ------------------ ------------------ 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) | | ------------------ | | | | 52| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 227| 0| else return 0; /* do not raise an error */ 228| 0| } 229| 273| L->stack.p = newstack; 230| 273| correctstack(L); /* change offsets back to pointers */ 231| 273| L->stack_last.p = L->stack.p + newsize; 232| 7.58k| for (i = oldsize + EXTRA_STACK; i < newsize + EXTRA_STACK; i++) ------------------ | | 142| 273|#define EXTRA_STACK 5 ------------------ for (i = oldsize + EXTRA_STACK; i < newsize + EXTRA_STACK; i++) ------------------ | | 142| 7.58k|#define EXTRA_STACK 5 ------------------ | Branch (232:35): [True: 7.31k, False: 273] ------------------ 233| 7.31k| setnilvalue(s2v(newstack + i)); /* erase new segment */ ------------------ | | 200| 7.31k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 7.58k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 234| 273| return 1; 235| 273|} luaD_growstack: 242| 140|int luaD_growstack (lua_State *L, int n, int raiseerror) { 243| 140| int size = stacksize(L); ------------------ | | 147| 140|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 140|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 140|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 244| 140| if (l_unlikely(size > LUAI_MAXSTACK)) { ------------------ | | 697| 140|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 140|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 140] | | | | ------------------ | | ------------------ ------------------ 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); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ 249| 0| if (raiseerror) ------------------ | Branch (249:9): [True: 0, False: 0] ------------------ 250| 0| luaD_throw(L, LUA_ERRERR); /* error inside message handler */ ------------------ | | 53| 0|#define LUA_ERRERR 5 ------------------ 251| 0| return 0; /* if not 'raiseerror', just signal it */ 252| 0| } 253| 140| else if (n < LUAI_MAXSTACK) { /* avoids arithmetic overflows */ ------------------ | | 749| 140|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (253:12): [True: 140, False: 0] ------------------ 254| 140| int newsize = 2 * size; /* tentative new size */ 255| 140| int needed = cast_int(L->top.p - L->stack.p) + n; ------------------ | | 141| 140|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 140|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 256| 140| if (newsize > LUAI_MAXSTACK) /* cannot cross the limit */ ------------------ | | 749| 140|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (256:9): [True: 0, False: 140] ------------------ 257| 0| newsize = LUAI_MAXSTACK; ------------------ | | 749| 0|#define LUAI_MAXSTACK 1000000 ------------------ 258| 140| if (newsize < needed) /* but must respect what was asked for */ ------------------ | Branch (258:9): [True: 3, False: 137] ------------------ 259| 3| newsize = needed; 260| 140| if (l_likely(newsize <= LUAI_MAXSTACK)) ------------------ | | 696| 140|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 684| 140|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (684:25): [True: 140, False: 0] | | | | ------------------ | | ------------------ ------------------ 261| 140| return luaD_reallocstack(L, newsize, raiseerror); 262| 140| } 263| | /* else stack overflow */ 264| | /* add extra size to be able to handle the error message */ 265| 0| luaD_reallocstack(L, ERRORSTACKSIZE, raiseerror); ------------------ | | 199| 0|#define ERRORSTACKSIZE (LUAI_MAXSTACK + 200) | | ------------------ | | | | 749| 0|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ 266| 0| if (raiseerror) ------------------ | Branch (266:7): [True: 0, False: 0] ------------------ 267| 0| luaG_runerror(L, "stack overflow"); 268| 0| return 0; 269| 0|} luaD_shrinkstack: 300| 1.32k|void luaD_shrinkstack (lua_State *L) { 301| 1.32k| int inuse = stackinuse(L); 302| 1.32k| int max = (inuse > LUAI_MAXSTACK / 3) ? LUAI_MAXSTACK : inuse * 3; ------------------ | | 749| 1.32k|#define LUAI_MAXSTACK 1000000 ------------------ int max = (inuse > LUAI_MAXSTACK / 3) ? LUAI_MAXSTACK : inuse * 3; ------------------ | | 749| 0|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (302:13): [True: 0, False: 1.32k] ------------------ 303| | /* if thread is currently not handling a stack overflow and its 304| | size is larger than maximum "reasonable" size, shrink it */ 305| 1.32k| if (inuse <= LUAI_MAXSTACK && stacksize(L) > max) { ------------------ | | 749| 2.64k|#define LUAI_MAXSTACK 1000000 ------------------ if (inuse <= LUAI_MAXSTACK && stacksize(L) > max) { ------------------ | | 147| 1.32k|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 1.32k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 1.32k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (305:7): [True: 1.32k, False: 0] | Branch (305:33): [True: 133, False: 1.18k] ------------------ 306| 133| int nsize = (inuse > LUAI_MAXSTACK / 2) ? LUAI_MAXSTACK : inuse * 2; ------------------ | | 749| 133|#define LUAI_MAXSTACK 1000000 ------------------ int nsize = (inuse > LUAI_MAXSTACK / 2) ? LUAI_MAXSTACK : inuse * 2; ------------------ | | 749| 0|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (306:17): [True: 0, False: 133] ------------------ 307| 133| luaD_reallocstack(L, nsize, 0); /* ok if that fails */ 308| 133| } 309| 1.18k| else /* don't change stack */ 310| 1.18k| condmovestack(L,{},{}); /* (change only for debugging) */ ------------------ | | 366| 1.18k|#define condmovestack(L,pre,pos) ((void)0) ------------------ 311| 1.32k| luaE_shrinkCI(L); /* shrink CI list */ 312| 1.32k|} luaD_inctop: 315| 450|void luaD_inctop (lua_State *L) { 316| 450| luaD_checkstack(L, 1); ------------------ | | 32| 450|#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0) | | ------------------ | | | | 27| 450| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 450|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 450|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 450] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 450| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 450| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 450|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 317| 450| L->top.p++; 318| 450|} luaD_hookcall: 369| 3|void luaD_hookcall (lua_State *L, CallInfo *ci) { 370| 3| L->oldpc = 0; /* set 'oldpc' for new function */ 371| 3| if (L->hookmask & LUA_MASKCALL) { /* is call hook on? */ ------------------ | | 450| 3|#define LUA_MASKCALL (1 << LUA_HOOKCALL) | | ------------------ | | | | 440| 3|#define LUA_HOOKCALL 0 | | ------------------ ------------------ | Branch (371:7): [True: 0, False: 3] ------------------ 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))) | | ------------------ | | | | 602| 0|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 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| 3|} luaD_poscall: 485| 809k|void luaD_poscall (lua_State *L, CallInfo *ci, int nres) { 486| 809k| int wanted = ci->nresults; 487| 809k| if (l_unlikely(L->hookmask && !hastocloseCfunc(wanted))) ------------------ | | 697| 809k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 809k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 809k] | | | | | Branch (685:46): [True: 0, False: 809k] | | | | | Branch (685:46): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 488| 0| rethook(L, ci, nres); 489| | /* move results to proper place */ 490| 809k| moveresults(L, ci->func.p, nres, wanted); 491| | /* function cannot be in any of these cases when returning */ 492| 809k| lua_assert(!(ci->callstatus & ------------------ | | 106| 809k|#define lua_assert(c) assert(c) ------------------ 493| 809k| (CIST_HOOKED | CIST_YPCALL | CIST_FIN | CIST_TRAN | CIST_CLSRET))); 494| 809k| L->ci = ci->previous; /* back to caller (after closing variables) */ 495| 809k|} luaD_pretailcall: 544| 72.4k| int narg1, int delta) { 545| 72.4k| retry: 546| 72.4k| switch (ttypetag(s2v(func))) { ------------------ | | 84| 72.4k|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 72.4k|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 547| 0| case LUA_VCCL: /* C closure */ ------------------ | | 590| 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: 72.4k] ------------------ 548| 0| return precallC(L, func, LUA_MULTRET, clCvalue(s2v(func))->f); ------------------ | | 35| 0|#define LUA_MULTRET (-1) ------------------ return precallC(L, func, LUA_MULTRET, clCvalue(s2v(func))->f); ------------------ | | 604| 0|#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 549| 0| case LUA_VLCF: /* light C function */ ------------------ | | 589| 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: 72.4k] ------------------ 550| 0| return precallC(L, func, LUA_MULTRET, fvalue(s2v(func))); ------------------ | | 35| 0|#define LUA_MULTRET (-1) ------------------ return precallC(L, func, LUA_MULTRET, fvalue(s2v(func))); ------------------ | | 603| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 551| 72.4k| case LUA_VLCL: { /* Lua function */ ------------------ | | 588| 72.4k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 72.4k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (551:5): [True: 72.4k, False: 0] ------------------ 552| 144k| Proto *p = clLvalue(s2v(func))->p; ------------------ | | 602| 72.4k|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | ------------------ | | | | 110| 289k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 72.4k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 72.4k] | | | | | Branch (110:42): [True: 72.4k, False: 0] | | | | ------------------ | | ------------------ ------------------ 553| 0| int fsize = p->maxstacksize; /* frame size */ 554| 144k| int nfixparams = p->numparams; 555| 144k| int i; 556| 144k| checkstackGCp(L, fsize - delta, func); ------------------ | | 49| 72.4k| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 72.4k| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 72.4k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 72.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 72.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 72.4k| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | ------------------ | | | | | Branch (28:6): [True: 0, False: 0] | | | | ------------------ | | | | 29| 72.4k| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 72.4k|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 50| 72.4k| ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ | | 51| 72.4k| luaC_checkGC(L), /* stack grow uses memory */ \ | | 52| 72.4k| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 557| 144k| ci->func.p -= delta; /* restore 'func' (if vararg) */ 558| 217k| for (i = 0; i < narg1; i++) /* move down function and arguments */ ------------------ | Branch (558:19): [True: 144k, False: 72.4k] ------------------ 559| 144k| setobjs2s(L, ci->func.p + i, func + i); ------------------ | | 129| 144k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 217k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 217k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 144k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 217k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 144k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 2.31M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 144k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 144k] | | | | | | | | | Branch (112:29): [True: 144k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 144k] | | | | | | | | | Branch (112:29): [True: 144k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 144k] | | | | | | | | | Branch (112:29): [True: 144k, False: 0] | | | | | | | | | Branch (112:29): [True: 144k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 144k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 144k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 144k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 560| 72.4k| func = ci->func.p; /* moved-down function */ 561| 72.4k| for (; narg1 <= nfixparams; narg1++) ------------------ | Branch (561:14): [True: 0, False: 72.4k] ------------------ 562| 72.4k| setnilvalue(s2v(func + narg1)); /* complete missing arguments */ ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 72.4k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 563| 72.4k| ci->top.p = func + 1 + fsize; /* top for new function */ 564| 72.4k| lua_assert(ci->top.p <= L->stack_last.p); ------------------ | | 106| 72.4k|#define lua_assert(c) assert(c) ------------------ 565| 72.4k| ci->u.l.savedpc = p->code; /* starting point */ 566| 72.4k| ci->callstatus |= CIST_TAIL; ------------------ | | 215| 72.4k|#define CIST_TAIL (1<<5) /* call was tail called */ ------------------ 567| 72.4k| L->top.p = func + narg1; /* set top */ 568| 72.4k| return -1; 569| 72.4k| } 570| 0| default: { /* not a function */ ------------------ | Branch (570:5): [True: 0, False: 72.4k] ------------------ 571| 0| func = 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| 72.4k| } 576| 72.4k| } 577| 72.4k|} luaD_precall: 588| 1.00M|CallInfo *luaD_precall (lua_State *L, StkId func, int nresults) { 589| 1.00M| retry: 590| 1.00M| switch (ttypetag(s2v(func))) { ------------------ | | 84| 1.00M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 1.00M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 591| 0| case LUA_VCCL: /* C closure */ ------------------ | | 590| 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: 1.00M] ------------------ 592| 0| precallC(L, func, nresults, clCvalue(s2v(func))->f); ------------------ | | 604| 0|#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 593| 0| return NULL; 594| 64| case LUA_VLCF: /* light C function */ ------------------ | | 589| 64|#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */ | | ------------------ | | | | 42| 64|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (594:5): [True: 64, False: 1.00M] ------------------ 595| 64| precallC(L, func, nresults, fvalue(s2v(func))); ------------------ | | 603| 64|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 110| 64|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 64|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 596| 0| return NULL; 597| 1.00M| case LUA_VLCL: { /* Lua function */ ------------------ | | 588| 1.00M|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 1.00M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (597:5): [True: 1.00M, False: 64] ------------------ 598| 1.00M| CallInfo *ci; 599| 2.01M| Proto *p = clLvalue(s2v(func))->p; ------------------ | | 602| 1.00M|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | ------------------ | | | | 110| 4.02M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 1.00M|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 1.00M] | | | | | Branch (110:42): [True: 1.00M, False: 0] | | | | ------------------ | | ------------------ ------------------ 600| 1.00M| int narg = cast_int(L->top.p - func) - 1; /* number of real arguments */ ------------------ | | 141| 1.00M|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 1.00M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 601| 2.01M| int nfixparams = p->numparams; 602| 2.01M| int fsize = p->maxstacksize; /* frame size */ 603| 2.01M| checkstackGCp(L, fsize, func); ------------------ | | 49| 1.00M| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 1.00M| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 1.00M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.00M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 133, False: 1.00M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 1.00M| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | ------------------ | | | | | Branch (28:6): [True: 0, False: 133] | | | | ------------------ | | | | 29| 1.00M| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 1.00M|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 50| 1.00M| ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ | | 51| 1.00M| luaC_checkGC(L), /* stack grow uses memory */ \ | | 52| 1.00M| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 604| 2.01M| L->ci = ci = prepCallInfo(L, func, nresults, 0, func + 1 + fsize); 605| 2.01M| ci->u.l.savedpc = p->code; /* starting point */ 606| 2.01M| for (; narg < nfixparams; narg++) ------------------ | Branch (606:14): [True: 652k, False: 1.00M] ------------------ 607| 1.00M| setnilvalue(s2v(L->top.p++)); /* complete missing arguments */ ------------------ | | 200| 652k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 1.65M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 608| 2.01M| lua_assert(ci->top.p <= L->stack_last.p); ------------------ | | 106| 1.00M|#define lua_assert(c) assert(c) ------------------ 609| 1.00M| return ci; 610| 2.01M| } 611| 0| default: { /* not a function */ ------------------ | Branch (611:5): [True: 0, False: 1.00M] ------------------ 612| 0| func = tryfuncTM(L, func); /* try to get '__call' metamethod */ 613| | /* return luaD_precall(L, func, nresults); */ 614| 0| goto retry; /* try again with metamethod */ 615| 2.01M| } 616| 1.00M| } 617| 1.00M|} luaD_callnoyield: 654| 109|void luaD_callnoyield (lua_State *L, StkId func, int nResults) { 655| 109| ccall(L, func, nResults, nyci); ------------------ | | 117| 109|#define nyci (0x10000 | 1) ------------------ 656| 109|} luaD_closeprotected: 924| 445|int luaD_closeprotected (lua_State *L, ptrdiff_t level, int status) { 925| 445| CallInfo *old_ci = L->ci; 926| 445| lu_byte old_allowhooks = L->allowhook; 927| 445| for (;;) { /* keep closing upvalues until no more errors */ 928| 445| struct CloseP pcl; 929| 445| pcl.level = restorestack(L, level); pcl.status = status; ------------------ | | 37| 445|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 445|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 930| 445| status = luaD_rawrunprotected(L, &closepaux, &pcl); 931| 445| if (l_likely(status == LUA_OK)) /* no more errors? */ ------------------ | | 696| 445|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 684| 445|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (684:25): [True: 445, False: 0] | | | | ------------------ | | ------------------ ------------------ 932| 445| 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| 445| } 938| 445|} luaD_pcall: 947| 282| ptrdiff_t old_top, ptrdiff_t ef) { 948| 282| int status; 949| 282| CallInfo *old_ci = L->ci; 950| 282| lu_byte old_allowhooks = L->allowhook; 951| 282| ptrdiff_t old_errfunc = L->errfunc; 952| 282| L->errfunc = ef; 953| 282| status = luaD_rawrunprotected(L, func, u); 954| 282| if (l_unlikely(status != LUA_OK)) { /* an error occurred? */ ------------------ | | 697| 282|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 282|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 220, False: 62] | | | | ------------------ | | ------------------ ------------------ 955| 220| L->ci = old_ci; 956| 220| L->allowhook = old_allowhooks; 957| 220| status = luaD_closeprotected(L, old_top, status); 958| 220| luaD_seterrorobj(L, status, restorestack(L, old_top)); ------------------ | | 37| 220|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 220|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 959| 220| luaD_shrinkstack(L); /* restore stack size in case of overflow */ 960| 220| } 961| 282| L->errfunc = old_errfunc; 962| 282| return status; 963| 282|} luaD_protectedparser: 1006| 225| const char *mode) { 1007| 225| struct SParser p; 1008| 225| int status; 1009| 225| incnny(L); /* cannot yield during parsing */ ------------------ | | 111| 225|#define incnny(L) ((L)->nCcalls += 0x10000) ------------------ 1010| 225| p.z = z; p.name = name; p.mode = mode; 1011| 225| p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0; 1012| 225| p.dyd.gt.arr = NULL; p.dyd.gt.size = 0; 1013| 225| p.dyd.label.arr = NULL; p.dyd.label.size = 0; 1014| 225| luaZ_initbuffer(L, &p.buff); ------------------ | | 29| 225|#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0) ------------------ 1015| 225| status = luaD_pcall(L, f_parser, &p, savestack(L, L->top.p), L->errfunc); ------------------ | | 36| 225|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 225|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 225|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1016| 225| luaZ_freebuffer(L, &p.buff); ------------------ | | 44| 225|#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) | | ------------------ | | | | 40| 225| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | | | ------------------ | | | | | | 53| 225| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | | | ------------------ | | | | | | | | 146| 225|#define cast_charp(i) cast(char *, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 41| 225| (buff)->buffsize, size), \ | | | | 42| 225| (buff)->buffsize = size) | | ------------------ ------------------ 1017| 225| luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size); ------------------ | | 57| 225|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1018| 225| luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size); ------------------ | | 57| 225|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1019| 225| luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size); ------------------ | | 57| 225|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1020| 225| decnny(L); ------------------ | | 114| 225|#define decnny(L) ((L)->nCcalls -= 0x10000) ------------------ 1021| 225| return status; 1022| 225|} ldo.c:relstack: 165| 273|static void relstack (lua_State *L) { 166| 273| CallInfo *ci; 167| 273| UpVal *up; 168| 273| L->top.offset = savestack(L, L->top.p); ------------------ | | 36| 273|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 273|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 273|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 273|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 273|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 169| 273| L->tbclist.offset = savestack(L, L->tbclist.p); ------------------ | | 36| 273|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 273|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 273|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 273|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 273|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 170| 1.23k| for (up = L->openupval; up != NULL; up = up->u.open.next) ------------------ | Branch (170:27): [True: 965, False: 273] ------------------ 171| 965| up->v.offset = savestack(L, uplevel(up)); ------------------ | | 36| 965|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 965|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 3.86k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (136:27): [True: 0, False: 965] | | | | | | | Branch (136:27): [True: 965, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 965|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 965|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 172| 828| for (ci = L->ci; ci != NULL; ci = ci->previous) { ------------------ | Branch (172:20): [True: 555, False: 273] ------------------ 173| 555| ci->top.offset = savestack(L, ci->top.p); ------------------ | | 36| 555|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 555|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 555|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 555|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 555|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 174| 555| ci->func.offset = savestack(L, ci->func.p); ------------------ | | 36| 555|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 555|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 555|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 555|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 555|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 175| 555| } 176| 273|} ldo.c:correctstack: 182| 273|static void correctstack (lua_State *L) { 183| 273| CallInfo *ci; 184| 273| UpVal *up; 185| 273| L->top.p = restorestack(L, L->top.offset); ------------------ | | 37| 273|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 273|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 186| 273| L->tbclist.p = restorestack(L, L->tbclist.offset); ------------------ | | 37| 273|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 273|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 187| 1.23k| for (up = L->openupval; up != NULL; up = up->u.open.next) ------------------ | Branch (187:27): [True: 965, False: 273] ------------------ 188| 965| up->v.p = s2v(restorestack(L, up->v.offset)); ------------------ | | 172| 965|#define s2v(o) (&(o)->val) ------------------ 189| 828| for (ci = L->ci; ci != NULL; ci = ci->previous) { ------------------ | Branch (189:20): [True: 555, False: 273] ------------------ 190| 555| ci->top.p = restorestack(L, ci->top.offset); ------------------ | | 37| 555|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 555|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 191| 555| ci->func.p = restorestack(L, ci->func.offset); ------------------ | | 37| 555|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 555|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 192| 555| if (isLua(ci)) ------------------ | | 241| 555|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 555|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 282, False: 273] | | ------------------ ------------------ 193| 282| ci->u.l.trap = 1; /* signal to update 'trap' in 'luaV_execute' */ 194| 555| } 195| 273|} ldo.c:stackinuse: 276| 1.32k|static int stackinuse (lua_State *L) { 277| 1.32k| CallInfo *ci; 278| 1.32k| int res; 279| 1.32k| StkId lim = L->top.p; 280| 3.06k| for (ci = L->ci; ci != NULL; ci = ci->previous) { ------------------ | Branch (280:20): [True: 1.74k, False: 1.32k] ------------------ 281| 1.74k| if (lim < ci->top.p) lim = ci->top.p; ------------------ | Branch (281:9): [True: 1.41k, False: 323] ------------------ 282| 1.74k| } 283| 1.32k| lua_assert(lim <= L->stack_last.p + EXTRA_STACK); ------------------ | | 106| 1.32k|#define lua_assert(c) assert(c) ------------------ 284| 1.32k| res = cast_int(lim - L->stack.p) + 1; /* part of stack in use */ ------------------ | | 141| 1.32k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 1.32k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 285| 1.32k| if (res < LUA_MINSTACK) ------------------ | | 79| 1.32k|#define LUA_MINSTACK 20 ------------------ | Branch (285:7): [True: 0, False: 1.32k] ------------------ 286| 0| res = LUA_MINSTACK; /* ensure a minimum size */ ------------------ | | 79| 0|#define LUA_MINSTACK 20 ------------------ 287| 1.32k| return res; 288| 1.32k|} ldo.c:moveresults: 433| 809k|l_sinline void moveresults (lua_State *L, StkId res, int nres, int wanted) { 434| 809k| StkId firstresult; 435| 809k| int i; 436| 809k| switch (wanted) { /* handle typical cases separately */ 437| 12.2k| case 0: /* no values needed */ ------------------ | Branch (437:5): [True: 12.2k, False: 797k] ------------------ 438| 12.2k| L->top.p = res; 439| 12.2k| return; 440| 396k| case 1: /* one value needed */ ------------------ | Branch (440:5): [True: 396k, False: 413k] ------------------ 441| 396k| if (nres == 0) /* no results? */ ------------------ | Branch (441:11): [True: 0, False: 396k] ------------------ 442| 396k| setnilvalue(s2v(res)); /* adjust with nil */ ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 443| 396k| else /* at least one result */ 444| 396k| setobjs2s(L, res, L->top.p - nres); /* move it to proper place */ ------------------ | | 129| 396k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 396k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 396k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 396k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 396k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 396k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 396k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 396k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 28] | | | | | | | | | Branch (112:29): [True: 28, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 28] | | | | | | | | | Branch (112:29): [True: 28, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 28] | | | | | | | | | Branch (112:29): [True: 28, False: 0] | | | | | | | | | Branch (112:29): [True: 28, False: 0] | | | | | | | | | Branch (112:29): [True: 396k, False: 28] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 396k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 396k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 445| 396k| L->top.p = res + 1; 446| 396k| return; 447| 0| case LUA_MULTRET: ------------------ | | 35| 0|#define LUA_MULTRET (-1) ------------------ | Branch (447:5): [True: 0, False: 809k] ------------------ 448| 0| wanted = nres; /* we want all results */ 449| 0| break; 450| 401k| default: /* two/more results and/or to-be-closed variables */ ------------------ | Branch (450:5): [True: 401k, False: 408k] ------------------ 451| 401k| if (hastocloseCfunc(wanted)) { /* to-be-closed variables? */ ------------------ | | 46| 401k|#define hastocloseCfunc(n) ((n) < LUA_MULTRET) | | ------------------ | | | | 35| 401k|#define LUA_MULTRET (-1) | | ------------------ | | | Branch (46:28): [True: 12, False: 401k] | | ------------------ ------------------ 452| 12| L->ci->callstatus |= CIST_CLSRET; /* in case of yields */ ------------------ | | 219| 12|#define CIST_CLSRET (1<<9) /* function is closing tbc variables */ ------------------ 453| 12| L->ci->u2.nres = nres; 454| 12| res = luaF_close(L, res, CLOSEKTOP, 1); ------------------ | | 47| 12|#define CLOSEKTOP (-1) ------------------ 455| 12| L->ci->callstatus &= ~CIST_CLSRET; ------------------ | | 219| 12|#define CIST_CLSRET (1<<9) /* function is closing tbc variables */ ------------------ 456| 12| if (L->hookmask) { /* if needed, call hook after '__close's */ ------------------ | Branch (456:13): [True: 0, False: 12] ------------------ 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| 12| wanted = decodeNresults(wanted); ------------------ | | 50| 12|#define decodeNresults(n) (-(n) - 3) ------------------ 462| 12| if (wanted == LUA_MULTRET) ------------------ | | 35| 12|#define LUA_MULTRET (-1) ------------------ | Branch (462:13): [True: 0, False: 12] ------------------ 463| 0| wanted = nres; /* we want all results */ 464| 12| } 465| 401k| break; 466| 809k| } 467| | /* generic case */ 468| 401k| firstresult = L->top.p - nres; /* index of first result */ 469| 401k| if (nres > wanted) /* extra results? */ ------------------ | Branch (469:7): [True: 401k, False: 12] ------------------ 470| 401k| nres = wanted; /* don't need them */ 471| 1.20M| for (i = 0; i < nres; i++) /* move all results to correct place */ ------------------ | Branch (471:15): [True: 802k, False: 401k] ------------------ 472| 802k| setobjs2s(L, res + i, firstresult + i); ------------------ | | 129| 802k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 1.20M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 1.20M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 802k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 1.20M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 802k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 802k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 802k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 802k, False: 12] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 802k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 802k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 473| 401k| for (; i < wanted; i++) /* complete wanted number of results */ ------------------ | Branch (473:10): [True: 0, False: 401k] ------------------ 474| 401k| setnilvalue(s2v(res + i)); ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 401k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 475| 401k| L->top.p = res + wanted; /* top points after the last result */ 476| 401k|} ldo.c:precallC: 517| 64| lua_CFunction f) { 518| 64| int n; /* number of returns */ 519| 64| CallInfo *ci; 520| 64| checkstackGCp(L, LUA_MINSTACK, func); /* ensure minimum stack size */ ------------------ | | 49| 64| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 64| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 64|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 64|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 4, False: 60] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 64| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | ------------------ | | | | | Branch (28:6): [True: 0, False: 4] | | | | ------------------ | | | | 29| 64| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 60|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 50| 64| ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ | | 51| 64| luaC_checkGC(L), /* stack grow uses memory */ \ | | 52| 64| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 521| 64| L->ci = ci = prepCallInfo(L, func, nresults, CIST_C, ------------------ | | 211| 64|#define CIST_C (1<<1) /* call is running a C function */ ------------------ 522| 64| L->top.p + LUA_MINSTACK); ------------------ | | 79| 64|#define LUA_MINSTACK 20 ------------------ 523| 64| lua_assert(ci->top.p <= L->stack_last.p); ------------------ | | 106| 64|#define lua_assert(c) assert(c) ------------------ 524| 64| if (l_unlikely(L->hookmask & LUA_MASKCALL)) { ------------------ | | 697| 64|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 64|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 64] | | | | ------------------ | | ------------------ ------------------ 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| 64| lua_unlock(L); ------------------ | | 265| 64|#define lua_unlock(L) ((void) 0) ------------------ 529| 64| n = (*f)(L); /* do the actual call */ 530| 64| lua_lock(L); ------------------ | | 264| 64|#define lua_lock(L) ((void) 0) ------------------ 531| 64| api_checknelems(L, n); ------------------ | | 33| 64| api_check(L, (n) < (L->top.p - L->ci->func.p), \ | | ------------------ | | | | 126| 64|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 64|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 34| 64| "not enough elements in the stack") ------------------ 532| 64| luaD_poscall(L, ci, n); 533| 64| return n; 534| 64|} ldo.c:prepCallInfo: 503| 1.00M| int mask, StkId top) { 504| 1.00M| CallInfo *ci = L->ci = next_ci(L); /* new frame */ ------------------ | | 499| 1.00M|#define next_ci(L) (L->ci->next ? L->ci->next : luaE_extendCI(L)) | | ------------------ | | | Branch (499:22): [True: 1.00M, False: 108] | | ------------------ ------------------ 505| 1.00M| ci->func.p = func; 506| 1.00M| ci->nresults = nret; 507| 1.00M| ci->callstatus = mask; 508| 1.00M| ci->top.p = top; 509| 1.00M| return ci; 510| 1.00M|} ldo.c:ccall: 628| 109|l_sinline void ccall (lua_State *L, StkId func, int nResults, l_uint32 inc) { 629| 109| CallInfo *ci; 630| 109| L->nCcalls += inc; 631| 109| if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) { ------------------ | | 697| 109|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 109|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 109] | | | | ------------------ | | ------------------ ------------------ 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))) \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685: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| 109| if ((ci = luaD_precall(L, func, nResults)) != NULL) { /* Lua function? */ ------------------ | Branch (635:7): [True: 45, False: 64] ------------------ 636| 45| ci->callstatus = CIST_FRESH; /* mark that it is a "fresh" execute */ ------------------ | | 212| 45|#define CIST_FRESH (1<<2) /* call is on a fresh "luaV_execute" frame */ ------------------ 637| 45| luaV_execute(L, ci); /* call it */ 638| 45| } 639| 109| L->nCcalls -= inc; 640| 109|} ldo.c:closepaux: 914| 445|static void closepaux (lua_State *L, void *ud) { 915| 445| struct CloseP *pcl = cast(struct CloseP *, ud); ------------------ | | 136| 445|#define cast(t, exp) ((t)(exp)) ------------------ 916| 445| luaF_close(L, pcl->level, pcl->status, 0); 917| 445|} ldo.c:f_parser: 988| 225|static void f_parser (lua_State *L, void *ud) { 989| 225| LClosure *cl; 990| 225| struct SParser *p = cast(struct SParser *, ud); ------------------ | | 136| 225|#define cast(t, exp) ((t)(exp)) ------------------ 991| 225| int c = zgetc(p->z); /* read first character */ ------------------ | | 20| 225|#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: 225] | | ------------------ ------------------ 992| 225| if (c == LUA_SIGNATURE[0]) { ------------------ | | 32| 225|#define LUA_SIGNATURE "\x1bLua" ------------------ | Branch (992:7): [True: 0, False: 225] ------------------ 993| 0| checkmode(L, p->mode, "binary"); 994| 0| cl = luaU_undump(L, p->z, p->name); 995| 0| } 996| 225| else { 997| 225| checkmode(L, p->mode, "text"); 998| 225| cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c); 999| 225| } 1000| 225| lua_assert(cl->nupvalues == cl->p->sizeupvalues); ------------------ | | 106| 225|#define lua_assert(c) assert(c) ------------------ 1001| 45| luaF_initupvals(L, cl); 1002| 45|} ldo.c:checkmode: 979| 225|static void checkmode (lua_State *L, const char *mode, const char *x) { 980| 225| if (mode && strchr(mode, x[0]) == NULL) { ------------------ | Branch (980:7): [True: 225, False: 0] | Branch (980:15): [True: 0, False: 225] ------------------ 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); ------------------ | | 51| 0|#define LUA_ERRSYNTAX 3 ------------------ 984| 0| } 985| 225|} luaF_newLclosure: 35| 1.11M|LClosure *luaF_newLclosure (lua_State *L, int nupvals) { 36| 1.11M| GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals)); ------------------ | | 588| 1.11M|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 1.11M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals)); ------------------ | | 17| 1.11M|#define sizeLclosure(n) (cast_int(offsetof(LClosure, upvals)) + \ | | ------------------ | | | | 141| 1.11M|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 1.11M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 18| 1.11M| cast_int(sizeof(TValue *)) * (n)) | | ------------------ | | | | 141| 1.11M|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 1.11M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 37| 1.11M| LClosure *c = gco2lcl(o); ------------------ | | 376| 1.11M|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 110| 1.11M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 1.11M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 38| 0| c->p = NULL; 39| 1.11M| c->nupvalues = cast_byte(nupvals); ------------------ | | 143| 1.11M|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 1.11M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 40| 2.52M| while (nupvals--) c->upvals[nupvals] = NULL; ------------------ | Branch (40:10): [True: 1.40M, False: 1.11M] ------------------ 41| 1.11M| return c; 42| 1.11M|} luaF_initupvals: 48| 45|void luaF_initupvals (lua_State *L, LClosure *cl) { 49| 45| int i; 50| 90| for (i = 0; i < cl->nupvalues; i++) { ------------------ | Branch (50:15): [True: 45, False: 45] ------------------ 51| 45| GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal)); ------------------ | | 584| 45|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 45|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 52| 45| UpVal *uv = gco2upv(o); ------------------ | | 383| 45|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 110| 45|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 53| 0| uv->v.p = &uv->u.value; /* make it closed */ 54| 45| setnilvalue(uv->v.p); ------------------ | | 200| 45|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 55| 45| cl->upvals[i] = uv; 56| 45| luaC_objbarrier(L, cl, uv); ------------------ | | 175| 45|#define luaC_objbarrier(L,p,o) ( \ | | 176| 45| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 45|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 45|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 90|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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| 45| 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 45|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 45|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 57| 45| } 58| 45|} luaF_findupval: 87| 239k|UpVal *luaF_findupval (lua_State *L, StkId level) { 88| 239k| UpVal **pp = &L->openupval; 89| 239k| UpVal *p; 90| 239k| lua_assert(isintwups(L) || L->openupval == NULL); ------------------ | | 106| 239k|#define lua_assert(c) assert(c) ------------------ 91| 1.66M| while ((p = *pp) != NULL && uplevel(p) >= level) { /* search for it */ ------------------ | | 35| 834k|#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p)) | | ------------------ | | | | 110| 834k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 834k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (91:10): [True: 834k, False: 13.4k] | Branch (91:31): [True: 683k, False: 151k] ------------------ 92| 683k| lua_assert(!isdead(G(L), p)); ------------------ | | 106| 683k|#define lua_assert(c) assert(c) ------------------ 93| 1.36M| if (uplevel(p) == level) /* corresponding upvalue? */ ------------------ | | 35| 683k|#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p)) | | ------------------ | | | | 110| 683k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 683k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (93:9): [True: 74.9k, False: 608k] ------------------ 94| 74.9k| return p; /* return it */ 95| 608k| pp = &p->u.open.next; 96| 608k| } 97| | /* not found: create a new upvalue after 'pp' */ 98| 164k| return newupval(L, level, pp); 99| 239k|} luaF_newtbcupval: 168| 12|void luaF_newtbcupval (lua_State *L, StkId level) { 169| 12| lua_assert(level > L->tbclist.p); ------------------ | | 106| 12|#define lua_assert(c) assert(c) ------------------ 170| 12| if (l_isfalse(s2v(level))) ------------------ | | 247| 12|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 12|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 24|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 12|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 12] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 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: 0, False: 12] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 171| 0| 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| 164k|void luaF_unlinkupval (UpVal *uv) { 183| 164k| lua_assert(upisopen(uv)); ------------------ | | 106| 164k|#define lua_assert(c) assert(c) ------------------ 184| 164k| *uv->u.open.previous = uv->u.open.next; 185| 164k| if (uv->u.open.next) ------------------ | Branch (185:7): [True: 156k, False: 8.30k] ------------------ 186| 156k| uv->u.open.next->u.open.previous = uv->u.open.previous; 187| 164k|} luaF_closeupval: 193| 96.6k|void luaF_closeupval (lua_State *L, StkId level) { 194| 96.6k| UpVal *uv; 195| 96.6k| StkId upl; /* stack index pointed by 'uv' */ 196| 261k| while ((uv = L->openupval) != NULL && (upl = uplevel(uv)) >= level) { ------------------ | | 35| 252k|#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p)) | | ------------------ | | | | 110| 252k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 252k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (196:10): [True: 252k, False: 8.77k] | Branch (196:41): [True: 164k, False: 87.8k] ------------------ 197| 164k| TValue *slot = &uv->u.value; /* new position for value */ 198| 164k| lua_assert(uplevel(uv) < L->top.p); ------------------ | | 106| 164k|#define lua_assert(c) assert(c) ------------------ 199| 164k| luaF_unlinkupval(uv); /* remove upvalue from 'openupval' list */ 200| 164k| setobj(L, slot, uv->v.p); /* move value to upvalue slot */ ------------------ | | 119| 164k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 164k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 164k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 164k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 164k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 1.28M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 164k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 74.5k] | | | | | | | Branch (112:29): [True: 74.5k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 74.5k] | | | | | | | Branch (112:29): [True: 74.5k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 74.5k] | | | | | | | Branch (112:29): [True: 74.5k, False: 0] | | | | | | | Branch (112:29): [True: 74.5k, False: 0] | | | | | | | Branch (112:29): [True: 90.4k, False: 74.5k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 164k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 106| 164k|#define lua_assert(c) assert(c) | | ------------------ ------------------ 201| 164k| uv->v.p = slot; /* now current value lives here */ 202| 164k| if (!iswhite(uv)) { /* neither white nor dead? */ ------------------ | | 87| 164k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 164k|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (202:9): [True: 25, False: 164k] ------------------ 203| 25| nw2black(uv); /* closed upvalues cannot be gray */ ------------------ | | 100| 25| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 110| 25|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 25|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 204| 25| luaC_barrier(L, uv, slot); ------------------ | | 179| 25|#define luaC_barrier(L,p,v) ( \ | | 180| 25| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 25|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 25|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 25|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 21, False: 4] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 21|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 21| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 21|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 21|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 42|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 21, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 87| 21|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 84|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 21] | | | | | | | | | Branch (62:26): [True: 0, False: 21] | | | | | | | | | Branch (62:26): [True: 21, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 177| 21| 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)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 21|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 21|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 4|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 4|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 205| 25| } 206| 164k| } 207| 96.6k|} luaF_close: 227| 24.1k|StkId luaF_close (lua_State *L, StkId level, int status, int yy) { 228| 24.1k| ptrdiff_t levelrel = savestack(L, level); ------------------ | | 36| 24.1k|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 24.1k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 24.1k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 24.1k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 24.1k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 229| 24.1k| luaF_closeupval(L, level); /* first, close the upvalues */ 230| 24.1k| while (L->tbclist.p >= level) { /* traverse tbc's down to that level */ ------------------ | Branch (230:10): [True: 12, False: 24.1k] ------------------ 231| 12| StkId tbc = L->tbclist.p; /* get variable index */ 232| 12| poptbclist(L); /* remove it from list */ 233| 12| prepcallclosemth(L, tbc, status, yy); /* close variable */ 234| 12| level = restorestack(L, levelrel); ------------------ | | 37| 12|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 235| 12| } 236| 24.1k| return level; 237| 24.1k|} luaF_newproto: 240| 3.17k|Proto *luaF_newproto (lua_State *L) { 241| 3.17k| GCObject *o = luaC_newobj(L, LUA_VPROTO, sizeof(Proto)); ------------------ | | 507| 3.17k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 3.17k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 242| 3.17k| Proto *f = gco2p(o); ------------------ | | 381| 3.17k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 110| 3.17k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 3.17k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 243| 0| f->k = NULL; 244| 3.17k| f->sizek = 0; 245| 3.17k| f->p = NULL; 246| 3.17k| f->sizep = 0; 247| 3.17k| f->code = NULL; 248| 3.17k| f->sizecode = 0; 249| 3.17k| f->lineinfo = NULL; 250| 3.17k| f->sizelineinfo = 0; 251| 3.17k| f->abslineinfo = NULL; 252| 3.17k| f->sizeabslineinfo = 0; 253| 3.17k| f->upvalues = NULL; 254| 3.17k| f->sizeupvalues = 0; 255| 3.17k| f->numparams = 0; 256| 3.17k| f->is_vararg = 0; 257| 3.17k| f->maxstacksize = 0; 258| 3.17k| f->locvars = NULL; 259| 3.17k| f->sizelocvars = 0; 260| 3.17k| f->linedefined = 0; 261| 3.17k| f->lastlinedefined = 0; 262| 3.17k| f->source = NULL; 263| 3.17k| return f; 264| 3.17k|} luaF_freeproto: 267| 3.17k|void luaF_freeproto (lua_State *L, Proto *f) { 268| 3.17k| luaM_freearray(L, f->code, f->sizecode); ------------------ | | 57| 3.17k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 269| 3.17k| luaM_freearray(L, f->p, f->sizep); ------------------ | | 57| 3.17k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 270| 3.17k| luaM_freearray(L, f->k, f->sizek); ------------------ | | 57| 3.17k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 271| 3.17k| luaM_freearray(L, f->lineinfo, f->sizelineinfo); ------------------ | | 57| 3.17k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 272| 3.17k| luaM_freearray(L, f->abslineinfo, f->sizeabslineinfo); ------------------ | | 57| 3.17k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 273| 3.17k| luaM_freearray(L, f->locvars, f->sizelocvars); ------------------ | | 57| 3.17k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 274| 3.17k| luaM_freearray(L, f->upvalues, f->sizeupvalues); ------------------ | | 57| 3.17k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 275| 3.17k| luaM_free(L, f); ------------------ | | 56| 3.17k|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 276| 3.17k|} luaF_getlocalname: 283| 39|const char *luaF_getlocalname (const Proto *f, int local_number, int pc) { 284| 39| int i; 285| 3.25k| for (i = 0; isizelocvars && f->locvars[i].startpc <= pc; i++) { ------------------ | Branch (285:15): [True: 3.22k, False: 35] | Branch (285:35): [True: 3.21k, False: 4] ------------------ 286| 3.21k| if (pc < f->locvars[i].endpc) { /* is variable active? */ ------------------ | Branch (286:9): [True: 23, False: 3.19k] ------------------ 287| 23| local_number--; 288| 23| if (local_number == 0) ------------------ | Branch (288:11): [True: 0, False: 23] ------------------ 289| 0| return getstr(f->locvars[i].varname); ------------------ | | 404| 0|#define getstr(ts) ((ts)->contents) ------------------ 290| 23| } 291| 3.21k| } 292| 39| return NULL; /* not found */ 293| 39|} lfunc.c:newupval: 65| 164k|static UpVal *newupval (lua_State *L, StkId level, UpVal **prev) { 66| 164k| GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal)); ------------------ | | 584| 164k|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 164k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 67| 164k| UpVal *uv = gco2upv(o); ------------------ | | 383| 164k|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 110| 164k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 164k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 68| 0| UpVal *next = *prev; 69| 164k| uv->v.p = s2v(level); /* current value lives in the stack */ ------------------ | | 172| 164k|#define s2v(o) (&(o)->val) ------------------ 70| 164k| uv->u.open.next = next; /* link it to list of open upvalues */ 71| 164k| uv->u.open.previous = prev; 72| 164k| if (next) ------------------ | Branch (72:7): [True: 151k, False: 13.4k] ------------------ 73| 151k| next->u.open.previous = &uv->u.open.next; 74| 164k| *prev = uv; 75| 164k| if (!isintwups(L)) { /* thread not in list of threads with upvalues? */ ------------------ | | 22| 164k|#define isintwups(L) (L->twups != L) ------------------ | Branch (75:7): [True: 6, False: 164k] ------------------ 76| 6| L->twups = G(L)->twups; /* link it to the list */ ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 77| 6| G(L)->twups = L; ------------------ | | 335| 6|#define G(L) (L->l_G) ------------------ 78| 6| } 79| 164k| return uv; 80| 164k|} 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: 0, False: 12] | | | | ------------------ | | ------------------ ------------------ 128| 0| int idx = cast_int(level - L->ci->func.p); /* variable index */ ------------------ | | 141| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 129| 0| const char *vname = luaG_findlocal(L, L->ci, idx, NULL); 130| 0| if (vname == NULL) vname = "?"; ------------------ | Branch (130:9): [True: 0, False: 0] ------------------ 131| 0| luaG_runerror(L, "variable '%s' got a non-closable value", vname); 132| 0| } 133| 12|} lfunc.c:poptbclist: 213| 12|static void poptbclist (lua_State *L) { 214| 12| StkId tbc = L->tbclist.p; 215| 12| lua_assert(tbc->tbclist.delta > 0); /* first element cannot be dummy */ ------------------ | | 106| 12|#define lua_assert(c) assert(c) ------------------ 216| 12| tbc -= tbc->tbclist.delta; 217| 12| while (tbc > L->stack.p && tbc->tbclist.delta == 0) ------------------ | Branch (217:10): [True: 0, False: 12] | Branch (217:30): [True: 0, False: 0] ------------------ 218| 0| tbc -= MAXDELTA; /* remove dummy nodes */ ------------------ | | 162| 12| ((256ul << ((sizeof(L->stack.p->tbclist.delta) - 1) * 8)) - 1) ------------------ 219| 12| L->tbclist.p = tbc; 220| 12|} lfunc.c:prepcallclosemth: 143| 12|static void prepcallclosemth (lua_State *L, StkId level, int status, int yy) { 144| 12| TValue *uv = s2v(level); /* value being closed */ ------------------ | | 172| 12|#define s2v(o) (&(o)->val) ------------------ 145| 12| TValue *errobj; 146| 12| if (status == CLOSEKTOP) ------------------ | | 47| 12|#define CLOSEKTOP (-1) ------------------ | Branch (146:7): [True: 12, False: 0] ------------------ 147| 12| errobj = &G(L)->nilvalue; /* error object is nil */ ------------------ | | 335| 12|#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| 12| callclosemethod(L, uv, errobj, yy); 153| 12|} lfunc.c:callclosemethod: 107| 12|static void callclosemethod (lua_State *L, TValue *obj, TValue *err, int yy) { 108| 12| StkId top = L->top.p; 109| 12| const TValue *tm = luaT_gettmbyobj(L, obj, TM_CLOSE); 110| 12| setobj2s(L, top, tm); /* will call metamethod... */ ------------------ | | 131| 12|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 12| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 12| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 12| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 12| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 12|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 12| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 111| 12| setobj2s(L, top + 1, obj); /* with 'self' as the 1st argument */ ------------------ | | 131| 12|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 12| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 12| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 12| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 12| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 192|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 12| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 112| 12| setobj2s(L, top + 2, err); /* and error msg. as 2nd argument */ ------------------ | | 131| 12|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 12| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 12| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 12| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 12| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 12|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 12| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 113| 12| L->top.p = top + 3; /* add function and arguments */ 114| 12| if (yy) ------------------ | Branch (114:7): [True: 0, False: 12] ------------------ 115| 0| luaD_call(L, top, 0); 116| 12| else 117| 12| luaD_callnoyield(L, top, 0); 118| 12|} luaC_barrierback_: 230| 10|void luaC_barrierback_ (lua_State *L, GCObject *o) { 231| 10| global_State *g = G(L); ------------------ | | 335| 10|#define G(L) (L->l_G) ------------------ 232| 10| lua_assert(isblack(o) && !isdead(g, o)); ------------------ | | 106| 10|#define lua_assert(c) assert(c) ------------------ 233| 10| lua_assert((g->gckind == KGC_GEN) == (isold(o) && getage(o) != G_TOUCHED1)); ------------------ | | 106| 10|#define lua_assert(c) assert(c) ------------------ 234| 10| if (getage(o) == G_TOUCHED2) /* already in gray list? */ ------------------ | | 116| 10|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 114| 10|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ if (getage(o) == G_TOUCHED2) /* already in gray list? */ ------------------ | | 112| 10|#define G_TOUCHED2 6 /* old object touched in previous cycle */ ------------------ | Branch (234:7): [True: 0, False: 10] ------------------ 235| 10| 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| 10| else /* link it in 'grayagain' and paint it gray */ 237| 10| linkobjgclist(o, g->grayagain); ------------------ | | 159| 10|#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p)) | | ------------------ | | | | 390| 10|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 10|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 10|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 238| 10| if (isold(o)) /* generational mode? */ ------------------ | | 118| 10|#define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 116| 10|#define getage(o) ((o)->marked & AGEBITS) | | | | ------------------ | | | | | | 114| 10|#define AGEBITS 7 /* all age bits (111) */ | | | | ------------------ | | ------------------ | | #define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 107| 10|#define G_SURVIVAL 1 /* created in previous cycle */ | | ------------------ | | | Branch (118:18): [True: 0, False: 10] | | ------------------ ------------------ 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| 10|} luaC_fix: 243| 11.0k|void luaC_fix (lua_State *L, GCObject *o) { 244| 11.0k| global_State *g = G(L); ------------------ | | 335| 11.0k|#define G(L) (L->l_G) ------------------ 245| 11.0k| lua_assert(g->allgc == o); /* object must be 1st in 'allgc' list! */ ------------------ | | 106| 11.0k|#define lua_assert(c) assert(c) ------------------ 246| 11.0k| set2gray(o); /* they will be gray forever */ ------------------ | | 75| 11.0k|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 60| 11.0k|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 11.0k|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 11.0k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 247| 11.0k| setage(o, G_OLD); /* and old forever */ ------------------ | | 117| 11.0k|#define setage(o,a) ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a)) | | ------------------ | | | | 143| 11.0k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 11.0k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 248| 11.0k| g->allgc = o->next; /* remove object from 'allgc' list */ 249| 11.0k| o->next = g->fixedgc; /* link it to 'fixedgc' list */ 250| 11.0k| g->fixedgc = o; 251| 11.0k|} luaC_newobjdt: 258| 1.41M|GCObject *luaC_newobjdt (lua_State *L, int tt, size_t sz, size_t offset) { 259| 1.41M| global_State *g = G(L); ------------------ | | 335| 1.41M|#define G(L) (L->l_G) ------------------ 260| 1.41M| char *p = cast_charp(luaM_newobject(L, novariant(tt), sz)); ------------------ | | 146| 1.41M|#define cast_charp(i) cast(char *, (i)) | | ------------------ | | | | 136| 1.41M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 261| 1.41M| GCObject *o = cast(GCObject *, p + offset); ------------------ | | 136| 1.41M|#define cast(t, exp) ((t)(exp)) ------------------ 262| 1.41M| o->marked = luaC_white(g); ------------------ | | 102| 1.41M|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 143| 1.41M|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 1.41M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 263| 1.41M| o->tt = tt; 264| 1.41M| o->next = g->allgc; 265| 1.41M| g->allgc = o; 266| 1.41M| return o; 267| 1.41M|} luaC_newobj: 270| 1.41M|GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) { 271| 1.41M| return luaC_newobjdt(L, tt, sz, 0); 272| 1.41M|} luaC_checkfinalizer: 1019| 12|void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) { 1020| 12| global_State *g = G(L); ------------------ | | 335| 12|#define G(L) (L->l_G) ------------------ 1021| 12| if (tofinalize(o) || /* obj. is already marked... */ ------------------ | | 92| 12|#define tofinalize(x) testbit((x)->marked, FINALIZEDBIT) | | ------------------ | | | | 67| 12|#define testbit(x,b) testbits(x, bitmask(b)) | | | | ------------------ | | | | | | 62| 24|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 12] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1022| 12| gfasttm(g, mt, TM_GC) == NULL || /* or has no finalizer... */ ------------------ | | 64| 12|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | ------------------ | | | Branch (64:26): [True: 0, False: 12] | | ------------------ | | 65| 12| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | ------------------ | | | Branch (65:3): [True: 0, False: 12] | | ------------------ ------------------ | Branch (1022:7): [True: 0, False: 12] ------------------ 1023| 12| (g->gcstp & GCSTPCLS)) /* or closing state? */ ------------------ | | 157| 12|#define GCSTPCLS 4 /* bit true when closing Lua state */ ------------------ | Branch (1023:7): [True: 0, False: 12] ------------------ 1024| 0| return; /* nothing to be done */ 1025| 12| else { /* move 'o' to 'finobj' list */ 1026| 12| GCObject **p; 1027| 12| if (issweepphase(g)) { ------------------ | | 43| 12| (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 34| 12|#define GCSswpallgc 3 | | ------------------ | | (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 37| 12|#define GCSswpend 6 | | ------------------ | | | Branch (43:3): [True: 12, False: 0] | | | Branch (43:34): [True: 0, False: 12] | | ------------------ ------------------ 1028| 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)) | | | | ------------------ | | ------------------ ------------------ 1029| 0| if (g->sweepgc == &o->next) /* should not remove 'sweepgc' object */ ------------------ | Branch (1029:11): [True: 0, False: 0] ------------------ 1030| 0| g->sweepgc = sweeptolive(L, g->sweepgc); /* change 'sweepgc' */ 1031| 0| } 1032| 12| else 1033| 12| correctpointers(g, o); 1034| | /* search for pointer pointing to 'o' */ 1035| 48| for (p = &g->allgc; *p != o; p = &(*p)->next) { /* empty */ } ------------------ | Branch (1035:25): [True: 36, False: 12] ------------------ 1036| 12| *p = o->next; /* remove 'o' from 'allgc' list */ 1037| 12| o->next = g->finobj; /* link it in 'finobj' list */ 1038| 12| g->finobj = o; 1039| 12| l_setbit(o->marked, FINALIZEDBIT); /* mark it as such */ ------------------ | | 65| 12|#define l_setbit(x,b) setbits(x, bitmask(b)) | | ------------------ | | | | 61| 12|#define setbits(x,m) ((x) |= (m)) | | ------------------ ------------------ 1040| 12| } 1041| 12|} luaC_changemode: 1360| 225|void luaC_changemode (lua_State *L, int newmode) { 1361| 225| global_State *g = G(L); ------------------ | | 335| 225|#define G(L) (L->l_G) ------------------ 1362| 225| if (newmode != g->gckind) { ------------------ | Branch (1362:7): [True: 0, False: 225] ------------------ 1363| 0| if (newmode == KGC_GEN) /* entering generational mode? */ ------------------ | | 152| 0|#define KGC_GEN 1 /* generational gc */ ------------------ | Branch (1363:9): [True: 0, False: 0] ------------------ 1364| 0| entergen(L, g); 1365| 0| else 1366| 0| enterinc(g); /* entering incremental mode */ 1367| 0| } 1368| 225| g->lastatomic = 0; 1369| 225|} luaC_freeallobjects: 1511| 225|void luaC_freeallobjects (lua_State *L) { 1512| 225| global_State *g = G(L); ------------------ | | 335| 225|#define G(L) (L->l_G) ------------------ 1513| 225| g->gcstp = GCSTPCLS; /* no extra finalizers after here */ ------------------ | | 157| 225|#define GCSTPCLS 4 /* bit true when closing Lua state */ ------------------ 1514| 225| luaC_changemode(L, KGC_INC); ------------------ | | 151| 225|#define KGC_INC 0 /* incremental gc */ ------------------ 1515| 225| separatetobefnz(g, 1); /* separate all objects with finalizers */ 1516| 225| lua_assert(g->finobj == NULL); ------------------ | | 106| 225|#define lua_assert(c) assert(c) ------------------ 1517| 225| callallpendingfinalizers(L); 1518| 225| deletelist(L, g->allgc, obj2gco(g->mainthread)); ------------------ | | 390| 225|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 110| 225|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1519| 225| lua_assert(g->finobj == NULL); /* no new finalizers */ ------------------ | | 106| 225|#define lua_assert(c) assert(c) ------------------ 1520| 225| deletelist(L, g->fixedgc, NULL); /* collect fixed objects */ 1521| 225| lua_assert(g->strt.nuse == 0); ------------------ | | 106| 225|#define lua_assert(c) assert(c) ------------------ 1522| 225|} luaC_step: 1690| 1.11k|void luaC_step (lua_State *L) { 1691| 1.11k| global_State *g = G(L); ------------------ | | 335| 1.11k|#define G(L) (L->l_G) ------------------ 1692| 1.11k| if (!gcrunning(g)) /* not running? */ ------------------ | | 158| 1.11k|#define gcrunning(g) ((g)->gcstp == 0) ------------------ | Branch (1692:7): [True: 0, False: 1.11k] ------------------ 1693| 0| luaE_setdebt(g, -2000); 1694| 1.11k| else { 1695| 1.11k| if(isdecGCmodegen(g)) ------------------ | | 149| 1.11k|#define isdecGCmodegen(g) (g->gckind == KGC_GEN || g->lastatomic != 0) | | ------------------ | | | | 152| 2.22k|#define KGC_GEN 1 /* generational gc */ | | ------------------ | | | Branch (149:28): [True: 0, False: 1.11k] | | | Branch (149:52): [True: 0, False: 1.11k] | | ------------------ ------------------ 1696| 0| genstep(L, g); 1697| 1.11k| else 1698| 1.11k| incstep(L, g); 1699| 1.11k| } 1700| 1.11k|} lgc.c:linkgclist_: 148| 34.8k|static void linkgclist_ (GCObject *o, GCObject **pnext, GCObject **list) { 149| 34.8k| lua_assert(!isgray(o)); /* cannot be in a gray list */ ------------------ | | 106| 34.8k|#define lua_assert(c) assert(c) ------------------ 150| 34.8k| *pnext = *list; 151| 34.8k| *list = o; 152| 34.8k| set2gray(o); /* now it is */ ------------------ | | 75| 34.8k|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 60| 34.8k|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 34.8k|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 34.8k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 153| 34.8k|} lgc.c:getgclist: 125| 68.5k|static GCObject **getgclist (GCObject *o) { 126| 68.5k| switch (o->tt) { 127| 5.95k| case LUA_VTABLE: return &gco2t(o)->gclist; ------------------ | | 678| 5.95k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 5.95k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTABLE: return &gco2t(o)->gclist; ------------------ | | 380| 5.95k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 110| 5.95k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 5.95k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (127:5): [True: 5.95k, False: 62.6k] ------------------ 128| 4.75k| case LUA_VLCL: return &gco2lcl(o)->gclist; ------------------ | | 588| 4.75k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 4.75k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: return &gco2lcl(o)->gclist; ------------------ | | 376| 4.75k|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 110| 4.75k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 4.75k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (128:5): [True: 4.75k, False: 63.8k] ------------------ 129| 0| case LUA_VCCL: return &gco2ccl(o)->gclist; ------------------ | | 590| 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)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (129:5): [True: 0, False: 68.5k] ------------------ 130| 3.30k| case LUA_VTHREAD: return &gco2th(o)->gclist; ------------------ | | 262| 3.30k|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 3.30k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: return &gco2th(o)->gclist; ------------------ | | 382| 3.30k|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 110| 3.30k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 3.30k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (130:5): [True: 3.30k, False: 65.2k] ------------------ 131| 54.5k| case LUA_VPROTO: return &gco2p(o)->gclist; ------------------ | | 507| 54.5k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 54.5k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VPROTO: return &gco2p(o)->gclist; ------------------ | | 381| 54.5k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 110| 54.5k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 54.5k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (131:5): [True: 54.5k, False: 14.0k] ------------------ 132| 0| case LUA_VUSERDATA: { ------------------ | | 429| 0|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (132:5): [True: 0, False: 68.5k] ------------------ 133| 0| Udata *u = gco2u(o); ------------------ | | 375| 0|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 134| 0| lua_assert(u->nuvalue > 0); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ 135| 0| return &u->gclist; 136| 0| } 137| 0| default: lua_assert(0); return 0; ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ | Branch (137:5): [True: 0, False: 68.5k] ------------------ 138| 68.5k| } 139| 68.5k|} lgc.c:reallymarkobject: 297| 77.5k|static void reallymarkobject (global_State *g, GCObject *o) { 298| 77.5k| switch (o->tt) { 299| 37.5k| case LUA_VSHRSTR: ------------------ | | 360| 37.5k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 37.5k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (299:5): [True: 37.5k, False: 40.0k] ------------------ 300| 41.6k| case LUA_VLNGSTR: { ------------------ | | 361| 41.6k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 41.6k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (300:5): [True: 4.08k, False: 73.5k] ------------------ 301| 41.6k| set2black(o); /* nothing to visit */ ------------------ | | 80| 41.6k| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 143| 41.6k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 41.6k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 302| 41.6k| break; 303| 37.5k| } 304| 2.16k| case LUA_VUPVAL: { ------------------ | | 584| 2.16k|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 2.16k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (304:5): [True: 2.16k, False: 75.4k] ------------------ 305| 2.16k| UpVal *uv = gco2upv(o); ------------------ | | 383| 2.16k|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 110| 2.16k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.16k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 306| 2.16k| if (upisopen(uv)) ------------------ | | 32| 2.16k|#define upisopen(up) ((up)->v.p != &(up)->u.value) | | ------------------ | | | Branch (32:22): [True: 1.36k, False: 798] | | ------------------ ------------------ 307| 2.16k| set2gray(uv); /* open upvalues are kept gray */ ------------------ | | 75| 1.36k|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 60| 1.36k|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 1.36k|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 1.36k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 308| 798| else 309| 798| set2black(uv); /* closed upvalues are visited here */ ------------------ | | 80| 798| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 143| 798|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 798|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 310| 2.16k| markvalue(g, uv->v.p); /* mark its content */ ------------------ | | 94| 2.16k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 2.16k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 22.9k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 2.16k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 1.38k] | | | | | | | Branch (112:29): [True: 1.38k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 1.38k] | | | | | | | Branch (112:29): [True: 1.38k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 1.38k] | | | | | | | Branch (112:29): [True: 1.38k, False: 0] | | | | | | | Branch (112:29): [True: 1.38k, False: 0] | | | | | | | Branch (112:29): [True: 776, False: 1.38k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 2.16k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 2.16k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 2.16k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 4.32k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 2.16k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 2.16k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 1.38k, False: 776] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 1.38k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 5.54k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 1.38k] | | | | | | | | | Branch (62:26): [True: 0, False: 1.38k] | | | | | | | | | Branch (62:26): [True: 1.38k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 311| 2.16k| break; 312| 2.16k| } 313| 9| case LUA_VUSERDATA: { ------------------ | | 429| 9|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 9|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (313:5): [True: 9, False: 77.5k] ------------------ 314| 9| Udata *u = gco2u(o); ------------------ | | 375| 9|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 110| 9|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 9|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 315| 9| if (u->nuvalue == 0) { /* no user values? */ ------------------ | Branch (315:11): [True: 9, False: 0] ------------------ 316| 9| markobjectN(g, u->metatable); /* mark its metatable */ ------------------ | | 105| 9|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 1|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 1|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 1|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #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)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 1, False: 8] | | ------------------ ------------------ 317| 9| set2black(u); /* nothing else to mark */ ------------------ | | 80| 9| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 143| 9|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 9|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 318| 9| break; 319| 9| } 320| | /* else... */ 321| 9| } /* FALLTHROUGH */ 322| 5.34k| case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 588| 2.37k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 2.37k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 590| 2.37k|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 2.37k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 678| 5.34k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 5.34k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (322:5): [True: 2.37k, False: 75.2k] | Branch (322:20): [True: 0, False: 77.5k] | Branch (322:35): [True: 2.97k, False: 74.6k] ------------------ 323| 33.7k| case LUA_VTHREAD: case LUA_VPROTO: { ------------------ | | 262| 6.44k|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 6.44k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: case LUA_VPROTO: { ------------------ | | 507| 33.7k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 33.7k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (323:5): [True: 1.10k, False: 76.4k] | Branch (323:23): [True: 27.2k, False: 50.3k] ------------------ 324| 33.7k| linkobjgclist(o, g->gray); /* to be visited later */ ------------------ | | 159| 33.7k|#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p)) | | ------------------ | | | | 390| 33.7k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 33.7k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 33.7k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 325| 0| break; 326| 33.7k| } 327| 0| default: lua_assert(0); break; ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ | Branch (327:5): [True: 0, False: 77.5k] ------------------ 328| 77.5k| } 329| 77.5k|} lgc.c:sweeptolive: 851| 1.10k|static GCObject **sweeptolive (lua_State *L, GCObject **p) { 852| 1.10k| GCObject **old = p; 853| 1.13k| do { 854| 1.13k| p = sweeplist(L, p, 1, NULL); 855| 1.13k| } while (p == old); ------------------ | Branch (855:12): [True: 29, False: 1.10k] ------------------ 856| 1.10k| return p; 857| 1.10k|} lgc.c:sweeplist: 825| 18.2k| int *countout) { 826| 18.2k| global_State *g = G(L); ------------------ | | 335| 18.2k|#define G(L) (L->l_G) ------------------ 827| 18.2k| int ow = otherwhite(g); ------------------ | | 94| 18.2k|#define otherwhite(g) ((g)->currentwhite ^ WHITEBITS) | | ------------------ | | | | 84| 18.2k|#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) | | | | ------------------ | | | | | | 64| 18.2k|#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 18.2k|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | | | #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 18.2k|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 828| 18.2k| int i; 829| 18.2k| int white = luaC_white(g); /* current white */ ------------------ | | 102| 18.2k|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 143| 18.2k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 18.2k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 830| 1.44M| for (i = 0; *p != NULL && i < countin; i++) { ------------------ | Branch (830:15): [True: 1.43M, False: 3.30k] | Branch (830:29): [True: 1.42M, False: 14.9k] ------------------ 831| 1.42M| GCObject *curr = *p; 832| 1.42M| int marked = curr->marked; 833| 1.42M| if (isdeadm(ow, marked)) { /* is 'curr' dead? */ ------------------ | | 95| 1.42M|#define isdeadm(ow,m) ((m) & (ow)) | | ------------------ | | | Branch (95:23): [True: 1.34M, False: 77.5k] | | ------------------ ------------------ 834| 1.34M| *p = curr->next; /* remove 'curr' from list */ 835| 1.34M| freeobj(L, curr); /* erase 'curr' */ 836| 1.34M| } 837| 77.5k| else { /* change mark to 'white' */ 838| 77.5k| curr->marked = cast_byte((marked & ~maskgcbits) | white); ------------------ | | 143| 77.5k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 77.5k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 839| 77.5k| p = &curr->next; /* go to next element */ 840| 77.5k| } 841| 1.42M| } 842| 18.2k| if (countout) ------------------ | Branch (842:7): [True: 17.1k, False: 1.13k] ------------------ 843| 17.1k| *countout = i; /* number of elements traversed */ 844| 18.2k| return (*p == NULL) ? NULL : p; ------------------ | Branch (844:10): [True: 3.30k, False: 14.9k] ------------------ 845| 18.2k|} lgc.c:freeobj: 772| 1.41M|static void freeobj (lua_State *L, GCObject *o) { 773| 1.41M| switch (o->tt) { 774| 3.17k| case LUA_VPROTO: ------------------ | | 507| 3.17k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 3.17k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (774:5): [True: 3.17k, False: 1.40M] ------------------ 775| 3.17k| luaF_freeproto(L, gco2p(o)); ------------------ | | 381| 3.17k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 110| 3.17k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 3.17k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 776| 0| break; 777| 164k| case LUA_VUPVAL: ------------------ | | 584| 164k|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 164k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (777:5): [True: 164k, False: 1.24M] ------------------ 778| 164k| freeupval(L, gco2upv(o)); ------------------ | | 383| 164k|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 110| 164k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 164k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 779| 0| break; 780| 1.11M| case LUA_VLCL: { ------------------ | | 588| 1.11M|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 1.11M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (780:5): [True: 1.11M, False: 291k] ------------------ 781| 1.11M| LClosure *cl = gco2lcl(o); ------------------ | | 376| 1.11M|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 110| 1.11M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 1.11M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 782| 1.11M| luaM_freemem(L, cl, sizeLclosure(cl->nupvalues)); ------------------ | | 55| 1.11M|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 783| 1.11M| break; 784| 1.11M| } 785| 0| case LUA_VCCL: { ------------------ | | 590| 0|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (785:5): [True: 0, False: 1.41M] ------------------ 786| 0| CClosure *cl = gco2ccl(o); ------------------ | | 377| 0|#define gco2ccl(o) check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 787| 0| luaM_freemem(L, cl, sizeCclosure(cl->nupvalues)); ------------------ | | 55| 0|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 788| 0| break; 789| 0| } 790| 2.68k| case LUA_VTABLE: ------------------ | | 678| 2.68k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 2.68k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (790:5): [True: 2.68k, False: 1.40M] ------------------ 791| 2.68k| luaH_free(L, gco2t(o)); ------------------ | | 380| 2.68k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 110| 2.68k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.68k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 792| 0| break; 793| 0| case LUA_VTHREAD: ------------------ | | 262| 0|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (793:5): [True: 0, False: 1.41M] ------------------ 794| 0| luaE_freethread(L, gco2th(o)); ------------------ | | 382| 0|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 795| 0| break; 796| 12| case LUA_VUSERDATA: { ------------------ | | 429| 12|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 12|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (796:5): [True: 12, False: 1.41M] ------------------ 797| 12| Udata *u = gco2u(o); ------------------ | | 375| 12|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 110| 12|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 798| 12| luaM_freemem(L, o, sizeudata(u->nuvalue, u->len)); ------------------ | | 55| 24|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) | | ------------------ | | | Branch (55:51): [True: 12, False: 0] | | ------------------ ------------------ 799| 12| break; 800| 12| } 801| 87.9k| case LUA_VSHRSTR: { ------------------ | | 360| 87.9k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 87.9k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (801:5): [True: 87.9k, False: 1.32M] ------------------ 802| 87.9k| TString *ts = gco2ts(o); ------------------ | | 374| 87.9k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 110| 87.9k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 87.9k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 803| 0| luaS_remove(L, ts); /* remove it from hash table */ 804| 87.9k| luaM_freemem(L, ts, sizelstring(ts->shrlen)); ------------------ | | 55| 87.9k|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 805| 87.9k| break; 806| 87.9k| } 807| 32.8k| case LUA_VLNGSTR: { ------------------ | | 361| 32.8k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 32.8k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (807:5): [True: 32.8k, False: 1.37M] ------------------ 808| 32.8k| TString *ts = gco2ts(o); ------------------ | | 374| 32.8k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 110| 32.8k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 32.8k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 809| 32.8k| luaM_freemem(L, ts, sizelstring(ts->u.lnglen)); ------------------ | | 55| 32.8k|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 810| 32.8k| break; 811| 32.8k| } 812| 0| default: lua_assert(0); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ | Branch (812:5): [True: 0, False: 1.41M] ------------------ 813| 1.41M| } 814| 1.41M|} lgc.c:freeupval: 765| 164k|static void freeupval (lua_State *L, UpVal *uv) { 766| 164k| if (upisopen(uv)) ------------------ | | 32| 164k|#define upisopen(up) ((up)->v.p != &(up)->u.value) | | ------------------ | | | Branch (32:22): [True: 0, False: 164k] | | ------------------ ------------------ 767| 0| luaF_unlinkupval(uv); 768| 164k| luaM_free(L, uv); ------------------ | | 56| 164k|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 769| 164k|} lgc.c:correctpointers: 1007| 12|static void correctpointers (global_State *g, GCObject *o) { 1008| 12| checkpointer(&g->survival, o); 1009| 12| checkpointer(&g->old1, o); 1010| 12| checkpointer(&g->reallyold, o); 1011| 12| checkpointer(&g->firstold1, o); 1012| 12|} lgc.c:checkpointer: 997| 48|static void checkpointer (GCObject **p, GCObject *o) { 998| 48| if (o == *p) ------------------ | Branch (998:7): [True: 0, False: 48] ------------------ 999| 0| *p = o->next; 1000| 48|} lgc.c:atomic: 1525| 1.10k|static lu_mem atomic (lua_State *L) { 1526| 1.10k| global_State *g = G(L); ------------------ | | 335| 1.10k|#define G(L) (L->l_G) ------------------ 1527| 1.10k| lu_mem work = 0; 1528| 1.10k| GCObject *origweak, *origall; 1529| 1.10k| GCObject *grayagain = g->grayagain; /* save original list */ 1530| 1.10k| g->grayagain = NULL; 1531| 1.10k| lua_assert(g->ephemeron == NULL && g->weak == NULL); ------------------ | | 106| 1.10k|#define lua_assert(c) assert(c) ------------------ 1532| 1.10k| lua_assert(!iswhite(g->mainthread)); ------------------ | | 106| 1.10k|#define lua_assert(c) assert(c) ------------------ 1533| 1.10k| g->gcstate = GCSatomic; ------------------ | | 33| 1.10k|#define GCSatomic 2 ------------------ 1534| 1.10k| markobject(g, L); /* mark running thread */ ------------------ | | 99| 1.10k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 1.10k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 1.10k|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 1.10k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1535| | /* registry and global metatables may be changed by API */ 1536| 1.10k| markvalue(g, &g->l_registry); ------------------ | | 94| 1.10k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 1.10k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 17.6k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 1.10k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 1.10k] | | | | | | | Branch (112:29): [True: 1.10k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 1.10k] | | | | | | | Branch (112:29): [True: 1.10k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 1.10k] | | | | | | | Branch (112:29): [True: 1.10k, False: 0] | | | | | | | Branch (112:29): [True: 1.10k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 1.10k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 1.10k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 1.10k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 1.10k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 2.20k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 1.10k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 1.10k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 1.10k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 1.10k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 4.40k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 1.10k] | | | | | | | | | Branch (62:26): [True: 0, False: 1.10k] | | | | | | | | | Branch (62:26): [True: 1.10k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1537| 1.10k| markmt(g); /* mark global metatables */ 1538| 1.10k| work += propagateall(g); /* empties 'gray' list */ 1539| | /* remark occasional upvalues of (maybe) dead threads */ 1540| 1.10k| work += remarkupvals(g); 1541| 1.10k| work += propagateall(g); /* propagate changes */ 1542| 1.10k| g->gray = grayagain; 1543| 1.10k| work += propagateall(g); /* traverse 'grayagain' list */ 1544| 1.10k| convergeephemerons(g); 1545| | /* at this point, all strongly accessible objects are marked. */ 1546| | /* Clear values from weak tables, before checking finalizers */ 1547| 1.10k| clearbyvalues(g, g->weak, NULL); 1548| 1.10k| clearbyvalues(g, g->allweak, NULL); 1549| 1.10k| origweak = g->weak; origall = g->allweak; 1550| 1.10k| separatetobefnz(g, 0); /* separate objects to be finalized */ 1551| 1.10k| work += markbeingfnz(g); /* mark objects that will be finalized */ 1552| 1.10k| work += propagateall(g); /* remark, to propagate 'resurrection' */ 1553| 1.10k| convergeephemerons(g); 1554| | /* at this point, all resurrected objects are marked. */ 1555| | /* remove dead objects from weak tables */ 1556| 1.10k| clearbykeys(g, g->ephemeron); /* clear keys from all ephemeron tables */ 1557| 1.10k| clearbykeys(g, g->allweak); /* clear keys from all 'allweak' tables */ 1558| | /* clear values from resurrected weak tables */ 1559| 1.10k| clearbyvalues(g, g->weak, origweak); 1560| 1.10k| clearbyvalues(g, g->allweak, origall); 1561| 1.10k| luaS_clearcache(g); 1562| 1.10k| g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */ ------------------ | | 143| 1.10k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 1.10k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1563| 1.10k| lua_assert(g->gray == NULL); ------------------ | | 106| 1.10k|#define lua_assert(c) assert(c) ------------------ 1564| 1.10k| return work; /* estimate of slots marked by 'atomic' */ 1565| 1.10k|} lgc.c:markmt: 335| 2.20k|static void markmt (global_State *g) { 336| 2.20k| int i; 337| 22.0k| for (i=0; i < LUA_NUMTAGS; i++) ------------------ | | 426| 22.0k|#define LUA_NUMTAGS LUA_NUMTYPES | | ------------------ | | | | 74| 22.0k|#define LUA_NUMTYPES 9 | | ------------------ ------------------ | Branch (337:13): [True: 19.8k, False: 2.20k] ------------------ 338| 19.8k| markobjectN(g, g->mt[i]); ------------------ | | 105| 19.8k|#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)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 19.8k] | | ------------------ ------------------ 339| 2.20k|} lgc.c:propagateall: 676| 4.40k|static lu_mem propagateall (global_State *g) { 677| 4.40k| lu_mem tot = 0; 678| 5.51k| while (g->gray) ------------------ | Branch (678:10): [True: 1.10k, False: 4.40k] ------------------ 679| 1.10k| tot += propagatemark(g); 680| 4.40k| return tot; 681| 4.40k|} lgc.c:propagatemark: 660| 34.8k|static lu_mem propagatemark (global_State *g) { 661| 34.8k| GCObject *o = g->gray; 662| 34.8k| nw2black(o); ------------------ | | 100| 34.8k| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 110| 34.8k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 34.8k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 663| 0| g->gray = *getgclist(o); /* remove from 'gray' list */ 664| 34.8k| switch (o->tt) { 665| 2.97k| case LUA_VTABLE: return traversetable(g, gco2t(o)); ------------------ | | 678| 2.97k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 2.97k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTABLE: return traversetable(g, gco2t(o)); ------------------ | | 380| 2.97k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 110| 2.97k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.97k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (665:5): [True: 2.97k, False: 31.8k] ------------------ 666| 0| case LUA_VUSERDATA: return traverseudata(g, gco2u(o)); ------------------ | | 429| 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)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (666:5): [True: 0, False: 34.8k] ------------------ 667| 2.37k| case LUA_VLCL: return traverseLclosure(g, gco2lcl(o)); ------------------ | | 588| 2.37k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 2.37k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: return traverseLclosure(g, gco2lcl(o)); ------------------ | | 376| 2.37k|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 110| 2.37k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.37k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (667:5): [True: 2.37k, False: 32.4k] ------------------ 668| 0| case LUA_VCCL: return traverseCclosure(g, gco2ccl(o)); ------------------ | | 590| 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)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (668:5): [True: 0, False: 34.8k] ------------------ 669| 27.2k| case LUA_VPROTO: return traverseproto(g, gco2p(o)); ------------------ | | 507| 27.2k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 27.2k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VPROTO: return traverseproto(g, gco2p(o)); ------------------ | | 381| 27.2k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 110| 27.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 27.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (669:5): [True: 27.2k, False: 7.55k] ------------------ 670| 2.20k| case LUA_VTHREAD: return traversethread(g, gco2th(o)); ------------------ | | 262| 2.20k|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 2.20k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: return traversethread(g, gco2th(o)); ------------------ | | 382| 2.20k|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 110| 2.20k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.20k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (670:5): [True: 2.20k, False: 32.6k] ------------------ 671| 0| default: lua_assert(0); return 0; ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ | Branch (671:5): [True: 0, False: 34.8k] ------------------ 672| 34.8k| } 673| 34.8k|} lgc.c:traversetable: 542| 2.97k|static lu_mem traversetable (global_State *g, Table *h) { 543| 2.97k| const char *weakkey, *weakvalue; 544| 2.97k| const TValue *mode = gfasttm(g, h->metatable, TM_MODE); ------------------ | | 64| 2.97k|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | ------------------ | | | Branch (64:26): [True: 2.97k, False: 0] | | ------------------ | | 65| 2.97k| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | ------------------ | | | Branch (65:3): [True: 0, False: 0] | | ------------------ ------------------ 545| 2.97k| TString *smode; 546| 2.97k| markobjectN(g, h->metatable); ------------------ | | 105| 2.97k|#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)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 2.97k] | | ------------------ ------------------ 547| 2.97k| if (mode && ttisshrstring(mode) && /* is there a weak mode? */ ------------------ | | 364| 0|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | ------------------ | | | | 91| 2.97k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (547:7): [True: 0, False: 2.97k] ------------------ 548| 2.97k| (cast_void(smode = tsvalue(mode)), ------------------ | | 138| 0|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 0, False: 0] | | | | | Branch (136:27): [True: 0, False: 0] | | | | | Branch (136:27): [True: 0, False: 0] | | | | | Branch (136:27): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (548:7): [True: 0, False: 0] ------------------ 549| 0| cast_void(weakkey = strchr(getshrstr(smode), 'k')), ------------------ | | 138| 0|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 0, False: 0] | | | | | Branch (136:27): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 550| 0| cast_void(weakvalue = strchr(getshrstr(smode), 'v')), ------------------ | | 138| 0|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 0, False: 0] | | | | | Branch (136:27): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 551| 0| (weakkey || weakvalue))) { /* is really weak? */ ------------------ | Branch (551:9): [True: 0, False: 0] | Branch (551:20): [True: 0, False: 0] ------------------ 552| 0| if (!weakkey) /* strong keys? */ ------------------ | Branch (552:9): [True: 0, False: 0] ------------------ 553| 0| traverseweakvalue(g, h); 554| 0| else if (!weakvalue) /* strong values? */ ------------------ | Branch (554:14): [True: 0, False: 0] ------------------ 555| 0| traverseephemeron(g, h, 0); 556| 0| else /* all weak */ 557| 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 558| 0| } 559| 2.97k| else /* not weak */ 560| 2.97k| traversestrongtable(g, h); 561| 2.97k| return 1 + h->alimit + 2 * allocsizenode(h); ------------------ | | 31| 2.97k|#define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 27| 2.97k|#define isdummy(t) ((t)->lastfree == NULL) | | | | ------------------ | | | | | Branch (27:21): [True: 1.87k, False: 1.10k] | | | | ------------------ | | ------------------ | | #define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 791| 1.10k|#define sizenode(t) (twoto((t)->lsizenode)) | | | | ------------------ | | | | | | 790| 1.10k|#define twoto(x) (1<<(x)) | | | | ------------------ | | ------------------ ------------------ 562| 2.97k|} lgc.c:clearkey: 171| 609k|static void clearkey (Node *n) { 172| 609k| lua_assert(isempty(gval(n))); ------------------ | | 106| 609k|#define lua_assert(c) assert(c) ------------------ 173| 609k| if (keyiscollectable(n)) ------------------ | | 764| 609k|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 753| 609k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 298| 609k|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ | | | Branch (764:29): [True: 519, False: 609k] | | ------------------ ------------------ 174| 519| setdeadkey(n); /* unused key; remove it */ ------------------ | | 776| 519|#define setdeadkey(node) (keytt(node) = LUA_TDEADKEY) | | ------------------ | | | | 753| 519|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define setdeadkey(node) (keytt(node) = LUA_TDEADKEY) | | ------------------ | | | | 24| 519|#define LUA_TDEADKEY (LUA_NUMTYPES+2) /* removed keys in tables */ | | | | ------------------ | | | | | | 74| 519|#define LUA_NUMTYPES 9 | | | | ------------------ | | ------------------ ------------------ 175| 609k|} lgc.c:genlink: 430| 2.97k|static void genlink (global_State *g, GCObject *o) { 431| 2.97k| lua_assert(isblack(o)); ------------------ | | 106| 2.97k|#define lua_assert(c) assert(c) ------------------ 432| 2.97k| if (getage(o) == G_TOUCHED1) { /* touched in this cycle? */ ------------------ | | 116| 2.97k|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 114| 2.97k|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ if (getage(o) == G_TOUCHED1) { /* touched in this cycle? */ ------------------ | | 111| 2.97k|#define G_TOUCHED1 5 /* old object touched this cycle */ ------------------ | Branch (432:7): [True: 0, False: 2.97k] ------------------ 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 434| 0| } /* everything else do not need to be linked back */ 435| 2.97k| else if (getage(o) == G_TOUCHED2) ------------------ | | 116| 2.97k|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 114| 2.97k|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ else if (getage(o) == G_TOUCHED2) ------------------ | | 112| 2.97k|#define G_TOUCHED2 6 /* old object touched in previous cycle */ ------------------ | Branch (435:12): [True: 0, False: 2.97k] ------------------ 436| 0| changeage(o, G_TOUCHED2, G_OLD); /* advance age */ ------------------ | | 121| 0| check_exp(getage(o) == (f), (o)->marked ^= ((f)^(t))) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 437| 2.97k|} lgc.c:traversestrongtable: 523| 2.97k|static void traversestrongtable (global_State *g, Table *h) { 524| 2.97k| Node *n, *limit = gnodelast(h); ------------------ | | 122| 2.97k|#define gnodelast(h) gnode(h, cast_sizet(sizenode(h))) | | ------------------ | | | | 13| 2.97k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 525| 2.97k| unsigned int i; 526| 2.97k| unsigned int asize = luaH_realasize(h); 527| 269k| for (i = 0; i < asize; i++) /* traverse array part */ ------------------ | Branch (527:15): [True: 266k, False: 2.97k] ------------------ 528| 266k| markvalue(g, &h->array[i]); ------------------ | | 94| 266k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 266k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 299k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 266k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 2.20k] | | | | | | | Branch (112:29): [True: 2.20k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 2.20k] | | | | | | | Branch (112:29): [True: 2.20k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 2.20k] | | | | | | | Branch (112:29): [True: 2.20k, False: 0] | | | | | | | Branch (112:29): [True: 2.20k, False: 0] | | | | | | | Branch (112:29): [True: 264k, False: 2.20k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 266k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 266k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 266k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 533k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 266k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 266k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 2.20k, False: 264k] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 2.20k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 8.82k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 1.10k, False: 1.10k] | | | | | | | | | Branch (62:26): [True: 0, False: 2.20k] | | | | | | | | | Branch (62:26): [True: 2.20k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 1.10k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 110| 1.10k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 1.10k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 529| 2.03M| for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */ ------------------ | | 13| 2.97k|#define gnode(t,i) (&(t)->node[i]) ------------------ | Branch (529:25): [True: 2.03M, False: 2.97k] ------------------ 530| 2.03M| if (isempty(gval(n))) /* entry is empty? */ ------------------ | | 217| 2.03M|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 2.03M|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 2.03M|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 2.03M|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 2.03M|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 609k, False: 1.42M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 531| 609k| clearkey(n); /* clear its key */ 532| 1.42M| else { 533| 1.42M| lua_assert(!keyisnil(n)); ------------------ | | 106| 1.42M|#define lua_assert(c) assert(c) ------------------ 534| 1.42M| markkey(g, n); ------------------ | | 97| 1.42M|#define markkey(g, n) { if keyiswhite(n) reallymarkobject(g,gckey(n)); } | | ------------------ | | | | 85| 1.42M|#define keyiswhite(n) (keyiscollectable(n) && iswhite(gckey(n))) | | | | ------------------ | | | | | | 764| 2.84M|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 753| 1.42M|#define keytt(node) ((node)->u.key_tt) | | | | | | ------------------ | | | | | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 1.42M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (764:29): [True: 30.0k, False: 1.39M] | | | | | | ------------------ | | | | ------------------ | | | | #define keyiswhite(n) (keyiscollectable(n) && iswhite(gckey(n))) | | | | ------------------ | | | | | | 87| 30.0k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 30.0k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 26.3k, False: 3.71k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markkey(g, n) { if keyiswhite(n) reallymarkobject(g,gckey(n)); } | | ------------------ | | | | 766| 26.3k|#define gckey(n) (keyval(n).gc) | | | | ------------------ | | | | | | 754| 26.3k|#define keyval(node) ((node)->u.key_val) | | | | ------------------ | | ------------------ ------------------ 535| 1.42M| markvalue(g, gval(n)); ------------------ | | 94| 1.42M|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 1.42M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 1.52M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 1.42M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 6.71k] | | | | | | | Branch (112:29): [True: 6.71k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 6.71k] | | | | | | | Branch (112:29): [True: 6.71k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 6.71k] | | | | | | | Branch (112:29): [True: 6.71k, False: 0] | | | | | | | Branch (112:29): [True: 6.71k, False: 0] | | | | | | | Branch (112:29): [True: 1.41M, False: 6.71k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 1.42M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 1.42M| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 1.42M|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 2.84M|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 1.42M|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 1.42M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 6.71k, False: 1.41M] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 6.71k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 26.8k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 937, False: 5.77k] | | | | | | | | | Branch (62:26): [True: 0, False: 6.71k] | | | | | | | | | Branch (62:26): [True: 6.71k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 937|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 110| 937|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 937|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 536| 1.42M| } 537| 2.03M| } 538| 2.97k| genlink(g, obj2gco(h)); ------------------ | | 390| 2.97k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 110| 2.97k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.97k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 539| 2.97k|} lgc.c:traverseLclosure: 606| 2.37k|static int traverseLclosure (global_State *g, LClosure *cl) { 607| 2.37k| int i; 608| 2.37k| markobjectN(g, cl->p); /* mark its prototype */ ------------------ | | 105| 2.37k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 2.37k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 2.37k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 2.37k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 2.37k, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 2.37k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 2.37k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 2.37k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 2.37k, False: 0] | | ------------------ ------------------ 609| 5.88k| for (i = 0; i < cl->nupvalues; i++) { /* visit its upvalues */ ------------------ | Branch (609:15): [True: 3.51k, False: 2.37k] ------------------ 610| 3.51k| UpVal *uv = cl->upvals[i]; 611| 3.51k| markobjectN(g, uv); /* mark upvalue */ ------------------ | | 105| 3.51k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 2.74k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 2.74k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 2.74k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 819, False: 1.92k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 819|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 819|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 819|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 2.74k, False: 765] | | ------------------ ------------------ 612| 3.51k| } 613| 2.37k| return 1 + cl->nupvalues; 614| 2.37k|} lgc.c:traverseproto: 580| 27.2k|static int traverseproto (global_State *g, Proto *f) { 581| 27.2k| int i; 582| 27.2k| markobjectN(g, f->source); ------------------ | | 105| 27.2k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 27.2k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 27.2k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 27.2k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 1.10k, False: 26.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 1.10k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 1.10k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 1.10k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 27.2k, False: 0] | | ------------------ ------------------ 583| 327k| for (i = 0; i < f->sizek; i++) /* mark literals */ ------------------ | Branch (583:15): [True: 300k, False: 27.2k] ------------------ 584| 300k| markvalue(g, &f->k[i]); ------------------ | | 94| 327k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 300k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 3.45M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 300k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 210k] | | | | | | | Branch (112:29): [True: 210k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 210k] | | | | | | | Branch (112:29): [True: 210k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 210k] | | | | | | | Branch (112:29): [True: 210k, False: 0] | | | | | | | Branch (112:29): [True: 210k, False: 0] | | | | | | | Branch (112:29): [True: 90.1k, False: 210k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 300k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 327k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 300k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 601k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 300k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 300k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 210k, False: 90.1k] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 210k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 841k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 10.0k, False: 200k] | | | | | | | | | Branch (62:26): [True: 0, False: 210k] | | | | | | | | | Branch (62:26): [True: 210k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 10.0k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 110| 10.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 10.0k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 585| 77.9k| for (i = 0; i < f->sizeupvalues; i++) /* mark upvalue names */ ------------------ | Branch (585:15): [True: 50.6k, False: 27.2k] ------------------ 586| 50.6k| markobjectN(g, f->upvalues[i].name); ------------------ | | 105| 77.9k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 47.7k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 47.7k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 47.7k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 311, False: 47.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 311|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 311|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 311|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 47.7k, False: 2.87k] | | ------------------ ------------------ 587| 55.3k| for (i = 0; i < f->sizep; i++) /* mark nested protos */ ------------------ | Branch (587:15): [True: 28.0k, False: 27.2k] ------------------ 588| 28.0k| markobjectN(g, f->p[i]); ------------------ | | 105| 55.3k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 26.1k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 26.1k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 26.1k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 24.9k, False: 1.27k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 24.9k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 24.9k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 24.9k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 26.1k, False: 1.82k] | | ------------------ ------------------ 589| 144k| for (i = 0; i < f->sizelocvars; i++) /* mark local-variable names */ ------------------ | Branch (589:15): [True: 117k, False: 27.2k] ------------------ 590| 117k| markobjectN(g, f->locvars[i].varname); ------------------ | | 105| 144k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 109k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 109k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 109k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 2.12k, False: 106k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 2.12k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 2.12k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 2.12k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 109k, False: 8.53k] | | ------------------ ------------------ 591| 27.2k| return 1 + f->sizek + f->sizeupvalues + f->sizep + f->sizelocvars; 592| 27.2k|} lgc.c:traversethread: 629| 2.20k|static int traversethread (global_State *g, lua_State *th) { 630| 2.20k| UpVal *uv; 631| 2.20k| StkId o = th->stack.p; 632| 2.20k| if (isold(th) || g->gcstate == GCSpropagate) ------------------ | | 118| 4.40k|#define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 116| 2.20k|#define getage(o) ((o)->marked & AGEBITS) | | | | ------------------ | | | | | | 114| 2.20k|#define AGEBITS 7 /* all age bits (111) */ | | | | ------------------ | | ------------------ | | #define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 107| 2.20k|#define G_SURVIVAL 1 /* created in previous cycle */ | | ------------------ | | | Branch (118:18): [True: 0, False: 2.20k] | | ------------------ ------------------ if (isold(th) || g->gcstate == GCSpropagate) ------------------ | | 31| 2.20k|#define GCSpropagate 0 ------------------ | Branch (632:20): [True: 1.10k, False: 1.10k] ------------------ 633| 1.10k| linkgclist(th, g->grayagain); /* insert into 'grayagain' list */ ------------------ | | 146| 1.10k|#define linkgclist(o,p) linkgclist_(obj2gco(o), &(o)->gclist, &(p)) | | ------------------ | | | | 390| 1.10k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 1.10k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 1.10k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 634| 2.20k| if (o == NULL) ------------------ | Branch (634:7): [True: 0, False: 2.20k] ------------------ 635| 0| return 1; /* stack not completely built yet */ 636| 2.20k| lua_assert(g->gcstate == GCSatomic || ------------------ | | 106| 2.20k|#define lua_assert(c) assert(c) ------------------ 637| 2.20k| th->openupval == NULL || isintwups(th)); 638| 20.0k| for (; o < th->top.p; o++) /* mark live elements in the stack */ ------------------ | Branch (638:10): [True: 17.8k, False: 2.20k] ------------------ 639| 17.8k| markvalue(g, s2v(o)); ------------------ | | 94| 20.0k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 17.8k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 153k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 17.8k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 9.07k] | | | | | | | Branch (112:29): [True: 9.07k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 9.07k] | | | | | | | Branch (112:29): [True: 9.07k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 9.07k] | | | | | | | Branch (112:29): [True: 9.07k, False: 0] | | | | | | | Branch (112:29): [True: 9.07k, False: 0] | | | | | | | Branch (112:29): [True: 8.78k, False: 9.07k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 17.8k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 20.0k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 17.8k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 35.7k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 17.8k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 17.8k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 9.07k, False: 8.78k] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 9.07k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 36.2k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 3.96k, False: 5.10k] | | | | | | | | | Branch (62:26): [True: 0, False: 9.07k] | | | | | | | | | Branch (62:26): [True: 9.07k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 3.96k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 110| 3.96k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 3.96k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 640| 4.93k| for (uv = th->openupval; uv != NULL; uv = uv->u.open.next) ------------------ | Branch (640:28): [True: 2.73k, False: 2.20k] ------------------ 641| 2.73k| markobject(g, uv); /* open upvalues cannot be collected */ ------------------ | | 99| 4.93k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 2.73k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 2.73k|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 1.34k, False: 1.38k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 1.34k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 1.34k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 1.34k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 642| 2.20k| if (g->gcstate == GCSatomic) { /* final traversal? */ ------------------ | | 33| 2.20k|#define GCSatomic 2 ------------------ | Branch (642:7): [True: 1.10k, False: 1.10k] ------------------ 643| 1.10k| if (!g->gcemergency) ------------------ | Branch (643:9): [True: 1.10k, False: 0] ------------------ 644| 1.10k| luaD_shrinkstack(th); /* do not change stack in emergency cycle */ 645| 50.7k| for (o = th->top.p; o < th->stack_last.p + EXTRA_STACK; o++) ------------------ | | 142| 50.7k|#define EXTRA_STACK 5 ------------------ | Branch (645:25): [True: 49.6k, False: 1.10k] ------------------ 646| 49.6k| setnilvalue(s2v(o)); /* clear dead stack slice */ ------------------ | | 200| 49.6k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 49.6k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 647| | /* 'remarkupvals' may have removed thread from 'twups' list */ 648| 1.10k| if (!isintwups(th) && th->openupval != NULL) { ------------------ | | 22| 2.20k|#define isintwups(L) (L->twups != L) ------------------ | Branch (648:9): [True: 824, False: 278] | Branch (648:27): [True: 0, False: 824] ------------------ 649| 0| th->twups = g->twups; /* link it back to the list */ 650| 0| g->twups = th; 651| 0| } 652| 1.10k| } 653| 2.20k| return 1 + stacksize(th); ------------------ | | 147| 2.20k|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 2.20k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 2.20k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 654| 2.20k|} lgc.c:remarkupvals: 367| 1.10k|static int remarkupvals (global_State *g) { 368| 1.10k| lua_State *thread; 369| 1.10k| lua_State **p = &g->twups; 370| 1.10k| int work = 0; /* estimate of how much work was done here */ 371| 1.38k| while ((thread = *p) != NULL) { ------------------ | Branch (371:10): [True: 279, False: 1.10k] ------------------ 372| 279| work++; 373| 279| if (!iswhite(thread) && thread->openupval != NULL) ------------------ | | 87| 279|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 558|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (373:9): [True: 279, False: 0] | Branch (373:29): [True: 278, False: 1] ------------------ 374| 278| p = &thread->twups; /* keep marked thread with upvalues in the list */ 375| 1| else { /* thread is not marked or without upvalues */ 376| 1| UpVal *uv; 377| 1| lua_assert(!isold(thread) || thread->openupval == NULL); ------------------ | | 106| 1|#define lua_assert(c) assert(c) ------------------ 378| 1| *p = thread->twups; /* remove thread from the list */ 379| 1| thread->twups = thread; /* mark that it is out of list */ 380| 1| for (uv = thread->openupval; uv != NULL; uv = uv->u.open.next) { ------------------ | Branch (380:36): [True: 0, False: 1] ------------------ 381| 0| lua_assert(getage(uv) <= getage(thread)); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ 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)); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ 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) || \ | | | | ------------------ | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 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] | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 386| 0| } 387| 0| } 388| 1| } 389| 279| } 390| 1.10k| return work; 391| 1.10k|} lgc.c:convergeephemerons: 691| 2.20k|static void convergeephemerons (global_State *g) { 692| 2.20k| int changed; 693| 2.20k| int dir = 0; 694| 2.20k| do { 695| 2.20k| GCObject *w; 696| 2.20k| GCObject *next = g->ephemeron; /* get ephemeron list */ 697| 2.20k| g->ephemeron = NULL; /* tables may return to this list when traversed */ 698| 2.20k| changed = 0; 699| 2.20k| while ((w = next) != NULL) { /* for each ephemeron table */ ------------------ | Branch (699:12): [True: 0, False: 2.20k] ------------------ 700| 0| Table *h = gco2t(w); ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 701| 0| next = h->gclist; /* list is rebuilt during loop */ 702| 0| nw2black(h); /* out of the list (for now) */ ------------------ | | 100| 0| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 703| 0| if (traverseephemeron(g, h, dir)) { /* marked some value? */ ------------------ | Branch (703:11): [True: 0, False: 0] ------------------ 704| 0| propagateall(g); /* propagate changes */ 705| 0| changed = 1; /* will have to revisit all ephemeron tables */ 706| 0| } 707| 0| } 708| 2.20k| dir = !dir; /* invert direction next time */ 709| 2.20k| } while (changed); /* repeat until no more changes */ ------------------ | Branch (709:12): [True: 0, False: 2.20k] ------------------ 710| 2.20k|} lgc.c:clearbyvalues: 744| 4.40k|static void clearbyvalues (global_State *g, GCObject *l, GCObject *f) { 745| 4.40k| for (; l != f; l = gco2t(l)->gclist) { ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (745:10): [True: 0, False: 4.40k] ------------------ 746| 0| Table *h = gco2t(l); ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 747| 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]) | | ------------------ ------------------ 748| 0| unsigned int i; 749| 0| unsigned int asize = luaH_realasize(h); 750| 0| for (i = 0; i < asize; i++) { ------------------ | Branch (750:17): [True: 0, False: 0] ------------------ 751| 0| TValue *o = &h->array[i]; 752| 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) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (752:11): [True: 0, False: 0] ------------------ 753| 0| setempty(o); /* remove entry */ ------------------ | | 225| 0|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 754| 0| } 755| 0| for (n = gnode(h, 0); n < limit; n++) { ------------------ | | 13| 0|#define gnode(t,i) (&(t)->node[i]) ------------------ | Branch (755:27): [True: 0, False: 0] ------------------ 756| 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) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (756:11): [True: 0, False: 0] ------------------ 757| 0| setempty(gval(n)); /* remove entry */ ------------------ | | 225| 0|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 758| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 759| 0| clearkey(n); /* clear its key */ 760| 0| } 761| 0| } 762| 4.40k|} lgc.c:markbeingfnz: 345| 2.20k|static lu_mem markbeingfnz (global_State *g) { 346| 2.20k| GCObject *o; 347| 2.20k| lu_mem count = 0; 348| 2.20k| for (o = g->tobefnz; o != NULL; o = o->next) { ------------------ | Branch (348:24): [True: 0, False: 2.20k] ------------------ 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 351| 0| } 352| 2.20k| return count; 353| 2.20k|} lgc.c:clearbykeys: 725| 2.20k|static void clearbykeys (global_State *g, GCObject *l) { 726| 2.20k| for (; l; l = gco2t(l)->gclist) { ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (726:10): [True: 0, False: 2.20k] ------------------ 727| 0| Table *h = gco2t(l); ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 728| 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]) | | ------------------ ------------------ 729| 0| Node *n; 730| 0| for (n = gnode(h, 0); n < limit; n++) { ------------------ | | 13| 0|#define gnode(t,i) (&(t)->node[i]) ------------------ | Branch (730:27): [True: 0, False: 0] ------------------ 731| 0| if (iscleared(g, gckeyN(n))) /* unmarked key? */ ------------------ | | 767| 0|#define gckeyN(n) (keyiscollectable(n) ? gckey(n) : NULL) | | ------------------ | | | | 764| 0|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 753| 0|#define keytt(node) ((node)->u.key_tt) | | | | ------------------ | | | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (764:29): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define gckeyN(n) (keyiscollectable(n) ? gckey(n) : NULL) | | ------------------ | | | | 766| 0|#define gckey(n) (keyval(n).gc) | | | | ------------------ | | | | | | 754| 0|#define keyval(node) ((node)->u.key_val) | | | | ------------------ | | ------------------ ------------------ | Branch (731:11): [True: 0, False: 0] ------------------ 732| 0| setempty(gval(n)); /* remove entry */ ------------------ | | 225| 0|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 733| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 734| 0| clearkey(n); /* clear its key */ 735| 0| } 736| 0| } 737| 2.20k|} lgc.c:cleargraylists: 394| 1.10k|static void cleargraylists (global_State *g) { 395| 1.10k| g->gray = g->grayagain = NULL; 396| 1.10k| g->weak = g->allweak = g->ephemeron = NULL; 397| 1.10k|} lgc.c:checkSizes: 871| 1.10k|static void checkSizes (lua_State *L, global_State *g) { 872| 1.10k| if (!g->gcemergency) { ------------------ | Branch (872:7): [True: 1.10k, False: 0] ------------------ 873| 1.10k| if (g->strt.nuse < g->strt.size / 4) { /* string table too big? */ ------------------ | Branch (873:9): [True: 162, False: 940] ------------------ 874| 162| l_mem olddebt = g->GCdebt; 875| 162| luaS_resize(L, g->strt.size / 2); 876| 162| g->GCestimate += g->GCdebt - olddebt; /* correct estimate */ 877| 162| } 878| 1.10k| } 879| 1.10k|} lgc.c:separatetobefnz: 974| 1.32k|static void separatetobefnz (global_State *g, int all) { 975| 1.32k| GCObject *curr; 976| 1.32k| GCObject **p = &g->finobj; 977| 1.32k| GCObject **lastnext = findlast(&g->tobefnz); 978| 1.34k| while ((curr = *p) != g->finobjold1) { /* traverse all finalizable objects */ ------------------ | Branch (978:10): [True: 13, False: 1.32k] ------------------ 979| 13| lua_assert(tofinalize(curr)); ------------------ | | 106| 13|#define lua_assert(c) assert(c) ------------------ 980| 13| if (!(iswhite(curr) || all)) /* not being collected? */ ------------------ | | 87| 13|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 26|#define testbits(x,m) ((x) & (m)) | | | | ------------------ | | | | | Branch (62:24): [True: 12, False: 1] | | | | ------------------ | | ------------------ ------------------ | Branch (980:28): [True: 0, False: 1] ------------------ 981| 1| p = &curr->next; /* don't bother with it */ 982| 12| else { 983| 12| if (curr == g->finobjsur) /* removing 'finobjsur'? */ ------------------ | Branch (983:11): [True: 0, False: 12] ------------------ 984| 0| g->finobjsur = curr->next; /* correct it */ 985| 12| *p = curr->next; /* remove 'curr' from 'finobj' list */ 986| 12| curr->next = *lastnext; /* link at the end of 'tobefnz' list */ 987| 12| *lastnext = curr; 988| 12| lastnext = &curr->next; 989| 12| } 990| 13| } 991| 1.32k|} lgc.c:findlast: 960| 1.32k|static GCObject **findlast (GCObject **p) { 961| 1.32k| while (*p != NULL) ------------------ | Branch (961:10): [True: 0, False: 1.32k] ------------------ 962| 0| p = &(*p)->next; 963| 1.32k| return p; 964| 1.32k|} lgc.c:callallpendingfinalizers: 950| 225|static void callallpendingfinalizers (lua_State *L) { 951| 225| global_State *g = G(L); ------------------ | | 335| 225|#define G(L) (L->l_G) ------------------ 952| 237| while (g->tobefnz) ------------------ | Branch (952:10): [True: 12, False: 225] ------------------ 953| 12| GCTM(L); 954| 225|} lgc.c:GCTM: 907| 12|static void GCTM (lua_State *L) { 908| 12| global_State *g = G(L); ------------------ | | 335| 12|#define G(L) (L->l_G) ------------------ 909| 12| const TValue *tm; 910| 12| TValue v; 911| 12| lua_assert(!g->gcemergency); ------------------ | | 106| 12|#define lua_assert(c) assert(c) ------------------ 912| 12| setgcovalue(L, &v, udata2finalize(g)); ------------------ | | 310| 12| { TValue *io = (obj); GCObject *i_g=(x); \ | | 311| 12| val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); } | | ------------------ | | | | 72| 12|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); } | | ------------------ | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 913| 12| tm = luaT_gettmbyobj(L, &v, TM_GC); 914| 12| if (!notm(tm)) { /* is there a finalizer? */ ------------------ | | 61| 12|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 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 (914:7): [True: 12, False: 0] ------------------ 915| 12| int status; 916| 12| lu_byte oldah = L->allowhook; 917| 12| int oldgcstp = g->gcstp; 918| 12| g->gcstp |= GCSTPGC; /* avoid GC steps */ ------------------ | | 156| 12|#define GCSTPGC 2 /* bit true when GC stopped by itself */ ------------------ 919| 12| L->allowhook = 0; /* stop debug hooks during GC metamethod */ 920| 12| setobj2s(L, L->top.p++, tm); /* push finalizer... */ ------------------ | | 131| 12|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 12| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 12| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 12| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 12| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 12|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 12| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 921| 12| setobj2s(L, L->top.p++, &v); /* ... and its argument */ ------------------ | | 131| 12|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 12| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 12| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 12| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 12| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 192|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 12, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 12] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 12| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 922| 12| L->ci->callstatus |= CIST_FIN; /* will run a finalizer */ ------------------ | | 217| 12|#define CIST_FIN (1<<7) /* function "called" a finalizer */ ------------------ 923| 12| status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top.p - 2), 0); ------------------ | | 36| 12|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 12|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 12|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 924| 12| L->ci->callstatus &= ~CIST_FIN; /* not running a finalizer anymore */ ------------------ | | 217| 12|#define CIST_FIN (1<<7) /* function "called" a finalizer */ ------------------ 925| 12| L->allowhook = oldah; /* restore hooks */ 926| 12| g->gcstp = oldgcstp; /* restore state */ 927| 12| if (l_unlikely(status != LUA_OK)) { /* error while running __gc? */ ------------------ | | 697| 12|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 12|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 12] | | | | ------------------ | | ------------------ ------------------ 928| 0| luaE_warnerror(L, "__gc"); 929| 0| L->top.p--; /* pops error object */ 930| 0| } 931| 12| } 932| 12|} lgc.c:udata2finalize: 886| 12|static GCObject *udata2finalize (global_State *g) { 887| 12| GCObject *o = g->tobefnz; /* get first element */ 888| 12| lua_assert(tofinalize(o)); ------------------ | | 106| 12|#define lua_assert(c) assert(c) ------------------ 889| 12| g->tobefnz = o->next; /* remove it from 'tobefnz' list */ 890| 12| o->next = g->allgc; /* return it to 'allgc' list */ 891| 12| g->allgc = o; 892| 12| resetbit(o->marked, FINALIZEDBIT); /* object is "normal" again */ ------------------ | | 66| 12|#define resetbit(x,b) resetbits(x, bitmask(b)) | | ------------------ | | | | 60| 12|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 12|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 893| 12| if (issweepphase(g)) ------------------ | | 43| 12| (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 34| 12|#define GCSswpallgc 3 | | ------------------ | | (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 37| 12|#define GCSswpend 6 | | ------------------ | | | Branch (43:3): [True: 12, False: 0] | | | Branch (43:34): [True: 0, False: 12] | | ------------------ ------------------ 894| 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)) | | | | ------------------ | | ------------------ ------------------ 895| 12| else if (getage(o) == G_OLD1) ------------------ | | 116| 12|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 114| 12|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ else if (getage(o) == G_OLD1) ------------------ | | 109| 12|#define G_OLD1 3 /* first full cycle as old */ ------------------ | Branch (895:12): [True: 0, False: 12] ------------------ 896| 0| g->firstold1 = o; /* it is the first OLD1 object in the list */ 897| 12| return o; 898| 12|} lgc.c:dothecall: 901| 12|static void dothecall (lua_State *L, void *ud) { 902| 12| UNUSED(ud); ------------------ | | 131| 12|#define UNUSED(x) ((void)(x)) ------------------ 903| 12| luaD_callnoyield(L, L->top.p - 2, 0); 904| 12|} lgc.c:deletelist: 1498| 450|static void deletelist (lua_State *L, GCObject *p, GCObject *limit) { 1499| 63.9k| while (p != limit) { ------------------ | Branch (1499:10): [True: 63.5k, False: 450] ------------------ 1500| 63.5k| GCObject *next = p->next; 1501| 63.5k| freeobj(L, p); 1502| 63.5k| p = next; 1503| 63.5k| } 1504| 450|} lgc.c:singlestep: 1585| 59.6k|static lu_mem singlestep (lua_State *L) { 1586| 59.6k| global_State *g = G(L); ------------------ | | 335| 59.6k|#define G(L) (L->l_G) ------------------ 1587| 59.6k| lu_mem work; 1588| 59.6k| lua_assert(!g->gcstopem); /* collector is not reentrant */ ------------------ | | 106| 59.6k|#define lua_assert(c) assert(c) ------------------ 1589| 59.6k| g->gcstopem = 1; /* no emergency collections while collecting */ 1590| 59.6k| switch (g->gcstate) { 1591| 1.10k| case GCSpause: { ------------------ | | 39| 1.10k|#define GCSpause 8 ------------------ | Branch (1591:5): [True: 1.10k, False: 58.5k] ------------------ 1592| 1.10k| restartcollection(g); 1593| 1.10k| g->gcstate = GCSpropagate; ------------------ | | 31| 1.10k|#define GCSpropagate 0 ------------------ 1594| 1.10k| work = 1; 1595| 1.10k| break; 1596| 0| } 1597| 34.8k| case GCSpropagate: { ------------------ | | 31| 34.8k|#define GCSpropagate 0 ------------------ | Branch (1597:5): [True: 34.8k, False: 24.8k] ------------------ 1598| 34.8k| if (g->gray == NULL) { /* no more gray objects? */ ------------------ | Branch (1598:11): [True: 1.10k, False: 33.7k] ------------------ 1599| 1.10k| g->gcstate = GCSenteratomic; /* finish propagate phase */ ------------------ | | 32| 1.10k|#define GCSenteratomic 1 ------------------ 1600| 1.10k| work = 0; 1601| 1.10k| } 1602| 33.7k| else 1603| 33.7k| work = propagatemark(g); /* traverse one gray object */ 1604| 34.8k| break; 1605| 0| } 1606| 1.10k| case GCSenteratomic: { ------------------ | | 32| 1.10k|#define GCSenteratomic 1 ------------------ | Branch (1606:5): [True: 1.10k, False: 58.5k] ------------------ 1607| 1.10k| work = atomic(L); /* work is what was traversed by 'atomic' */ 1608| 1.10k| entersweep(L); 1609| 1.10k| g->GCestimate = gettotalbytes(g); /* first estimate */ ------------------ | | 394| 1.10k|#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) | | ------------------ | | | | 136| 1.10k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1610| 1.10k| break; 1611| 0| } 1612| 16.0k| case GCSswpallgc: { /* sweep "regular" objects */ ------------------ | | 34| 16.0k|#define GCSswpallgc 3 ------------------ | Branch (1612:5): [True: 16.0k, False: 43.6k] ------------------ 1613| 16.0k| work = sweepstep(L, g, GCSswpfinobj, &g->finobj); ------------------ | | 35| 16.0k|#define GCSswpfinobj 4 ------------------ 1614| 16.0k| break; 1615| 0| } 1616| 2.20k| case GCSswpfinobj: { /* sweep objects with finalizers */ ------------------ | | 35| 2.20k|#define GCSswpfinobj 4 ------------------ | Branch (1616:5): [True: 2.20k, False: 57.4k] ------------------ 1617| 2.20k| work = sweepstep(L, g, GCSswptobefnz, &g->tobefnz); ------------------ | | 36| 2.20k|#define GCSswptobefnz 5 ------------------ 1618| 2.20k| break; 1619| 0| } 1620| 2.20k| case GCSswptobefnz: { /* sweep objects to be finalized */ ------------------ | | 36| 2.20k|#define GCSswptobefnz 5 ------------------ | Branch (1620:5): [True: 2.20k, False: 57.4k] ------------------ 1621| 2.20k| work = sweepstep(L, g, GCSswpend, NULL); ------------------ | | 37| 2.20k|#define GCSswpend 6 ------------------ 1622| 2.20k| break; 1623| 0| } 1624| 1.10k| case GCSswpend: { /* finish sweeps */ ------------------ | | 37| 1.10k|#define GCSswpend 6 ------------------ | Branch (1624:5): [True: 1.10k, False: 58.5k] ------------------ 1625| 1.10k| checkSizes(L, g); 1626| 1.10k| g->gcstate = GCScallfin; ------------------ | | 38| 1.10k|#define GCScallfin 7 ------------------ 1627| 1.10k| work = 0; 1628| 1.10k| break; 1629| 0| } 1630| 1.10k| case GCScallfin: { /* call remaining finalizers */ ------------------ | | 38| 1.10k|#define GCScallfin 7 ------------------ | Branch (1630:5): [True: 1.10k, False: 58.5k] ------------------ 1631| 1.10k| if (g->tobefnz && !g->gcemergency) { ------------------ | Branch (1631:11): [True: 0, False: 1.10k] | Branch (1631:25): [True: 0, False: 0] ------------------ 1632| 0| g->gcstopem = 0; /* ok collections during finalizers */ 1633| 0| work = runafewfinalizers(L, GCFINMAX) * GCFINALIZECOST; ------------------ | | 40| 0|#define GCFINMAX 10 ------------------ work = runafewfinalizers(L, GCFINMAX) * GCFINALIZECOST; ------------------ | | 46| 0|#define GCFINALIZECOST 50 ------------------ 1634| 0| } 1635| 1.10k| else { /* emergency mode or no more finalizers */ 1636| 1.10k| g->gcstate = GCSpause; /* finish collection */ ------------------ | | 39| 1.10k|#define GCSpause 8 ------------------ 1637| 1.10k| work = 0; 1638| 1.10k| } 1639| 1.10k| break; 1640| 0| } 1641| 0| default: lua_assert(0); return 0; ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ | Branch (1641:5): [True: 0, False: 59.6k] ------------------ 1642| 59.6k| } 1643| 59.6k| g->gcstopem = 0; 1644| 59.6k| return work; 1645| 59.6k|} lgc.c:restartcollection: 403| 1.10k|static void restartcollection (global_State *g) { 404| 1.10k| cleargraylists(g); 405| 1.10k| markobject(g, g->mainthread); ------------------ | | 99| 1.10k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 1.10k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 1.10k|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 1.10k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 1.10k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 1.10k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 1.10k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 406| 1.10k| markvalue(g, &g->l_registry); ------------------ | | 94| 1.10k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 1.10k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 17.6k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 1.10k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 1.10k] | | | | | | | Branch (112:29): [True: 1.10k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 1.10k] | | | | | | | Branch (112:29): [True: 1.10k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 1.10k] | | | | | | | Branch (112:29): [True: 1.10k, False: 0] | | | | | | | Branch (112:29): [True: 1.10k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 1.10k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 1.10k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 1.10k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 1.10k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 2.20k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 1.10k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 1.10k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 1.10k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 1.10k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 4.40k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 1.10k, False: 0] | | | | | | | | | Branch (62:26): [True: 0, False: 1.10k] | | | | | | | | | Branch (62:26): [True: 1.10k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 1.10k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 110| 1.10k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 1.10k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 407| 1.10k| markmt(g); 408| 1.10k| markbeingfnz(g); /* mark any finalizing object left from previous cycle */ 409| 1.10k|} lgc.c:entersweep: 1486| 1.10k|static void entersweep (lua_State *L) { 1487| 1.10k| global_State *g = G(L); ------------------ | | 335| 1.10k|#define G(L) (L->l_G) ------------------ 1488| 1.10k| g->gcstate = GCSswpallgc; ------------------ | | 34| 1.10k|#define GCSswpallgc 3 ------------------ 1489| 1.10k| lua_assert(g->sweepgc == NULL); ------------------ | | 106| 1.10k|#define lua_assert(c) assert(c) ------------------ 1490| 1.10k| g->sweepgc = sweeptolive(L, &g->allgc); 1491| 1.10k|} lgc.c:sweepstep: 1569| 20.4k| int nextstate, GCObject **nextlist) { 1570| 20.4k| if (g->sweepgc) { ------------------ | Branch (1570:7): [True: 17.1k, False: 3.30k] ------------------ 1571| 17.1k| l_mem olddebt = g->GCdebt; 1572| 17.1k| int count; 1573| 17.1k| g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX, &count); ------------------ | | 35| 17.1k|#define GCSWEEPMAX 100 ------------------ 1574| 17.1k| g->GCestimate += g->GCdebt - olddebt; /* update estimate */ 1575| 17.1k| return count; 1576| 17.1k| } 1577| 3.30k| else { /* enter next state */ 1578| 3.30k| g->gcstate = nextstate; 1579| 3.30k| g->sweepgc = nextlist; 1580| 3.30k| return 0; /* no work done */ 1581| 3.30k| } 1582| 20.4k|} lgc.c:setpause: 1059| 1.10k|static void setpause (global_State *g) { 1060| 1.10k| l_mem threshold, debt; 1061| 1.10k| int pause = getgcparam(g->gcpause); ------------------ | | 135| 1.10k|#define getgcparam(p) ((p) * 4) ------------------ 1062| 1.10k| l_mem estimate = g->GCestimate / PAUSEADJ; /* adjust 'estimate' */ ------------------ | | 60| 1.10k|#define PAUSEADJ 100 ------------------ 1063| 1.10k| lua_assert(estimate > 0); ------------------ | | 106| 1.10k|#define lua_assert(c) assert(c) ------------------ 1064| 1.10k| threshold = (pause < MAX_LMEM / estimate) /* overflow? */ ------------------ | | 50| 1.10k|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 1.10k|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ | Branch (1064:15): [True: 1.10k, False: 0] ------------------ 1065| 1.10k| ? estimate * pause /* no overflow */ 1066| 1.10k| : MAX_LMEM; /* overflow; truncate to maximum */ ------------------ | | 50| 1.10k|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 0|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ 1067| 1.10k| debt = gettotalbytes(g) - threshold; ------------------ | | 394| 1.10k|#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) | | ------------------ | | | | 136| 1.10k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1068| 1.10k| if (debt > 0) debt = 0; ------------------ | Branch (1068:7): [True: 0, False: 1.10k] ------------------ 1069| 1.10k| luaE_setdebt(g, debt); 1070| 1.10k|} lgc.c:incstep: 1667| 1.11k|static void incstep (lua_State *L, global_State *g) { 1668| 1.11k| int stepmul = (getgcparam(g->gcstepmul) | 1); /* avoid division by 0 */ ------------------ | | 135| 1.11k|#define getgcparam(p) ((p) * 4) ------------------ 1669| 1.11k| l_mem debt = (g->GCdebt / WORK2MEM) * stepmul; ------------------ | | 53| 1.11k|#define WORK2MEM sizeof(TValue) ------------------ 1670| 1.11k| l_mem stepsize = (g->gcstepsize <= log2maxs(l_mem)) ------------------ | | 60| 1.11k|#define log2maxs(t) (sizeof(t) * 8 - 2) ------------------ | Branch (1670:20): [True: 1.11k, False: 0] ------------------ 1671| 1.11k| ? ((cast(l_mem, 1) << g->gcstepsize) / WORK2MEM) * stepmul ------------------ | | 136| 1.11k|#define cast(t, exp) ((t)(exp)) ------------------ ? ((cast(l_mem, 1) << g->gcstepsize) / WORK2MEM) * stepmul ------------------ | | 53| 1.11k|#define WORK2MEM sizeof(TValue) ------------------ 1672| 1.11k| : MAX_LMEM; /* overflow; keep maximum value */ ------------------ | | 50| 1.11k|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 0|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ 1673| 59.6k| do { /* repeat until pause or enough "credit" (negative debt) */ 1674| 59.6k| lu_mem work = singlestep(L); /* perform one single step */ 1675| 59.6k| debt -= work; 1676| 59.6k| } while (debt > -stepsize && g->gcstate != GCSpause); ------------------ | | 39| 59.6k|#define GCSpause 8 ------------------ | Branch (1676:12): [True: 59.6k, False: 10] | Branch (1676:32): [True: 58.5k, False: 1.10k] ------------------ 1677| 1.11k| if (g->gcstate == GCSpause) ------------------ | | 39| 1.11k|#define GCSpause 8 ------------------ | Branch (1677:7): [True: 1.10k, False: 10] ------------------ 1678| 1.10k| setpause(g); /* pause until next cycle */ 1679| 10| else { 1680| 10| debt = (debt / stepmul) * WORK2MEM; /* convert 'work units' to bytes */ ------------------ | | 53| 10|#define WORK2MEM sizeof(TValue) ------------------ 1681| 10| luaE_setdebt(g, debt); 1682| 10| } 1683| 1.11k|} luaX_init: 70| 225|void luaX_init (lua_State *L) { 71| 225| int i; 72| 225| TString *e = luaS_newliteral(L, LUA_ENV); /* create env name */ ------------------ | | 28| 225|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 225| (sizeof(s)/sizeof(char))-1)) ------------------ 73| 225| luaC_fix(L, obj2gco(e)); /* never collect this name */ ------------------ | | 390| 225|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 110| 225|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 74| 5.17k| for (i=0; itt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 110| 4.95k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 4.95k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 77| 4.95k| ts->extra = cast_byte(i+1); /* reserved word */ ------------------ | | 143| 4.95k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 4.95k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 78| 4.95k| } 79| 225|} luaX_token2str: 82| 141|const char *luaX_token2str (LexState *ls, int token) { 83| 141| if (token < FIRST_RESERVED) { /* single-byte symbols? */ ------------------ | | 20| 141|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ | Branch (83:7): [True: 89, False: 52] ------------------ 84| 89| if (lisprint(token)) ------------------ | | 61| 89|#define lisprint(c) testprop(c, MASK(PRINTBIT)) | | ------------------ | | | | 52| 89|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 65, False: 24] | | | | ------------------ | | ------------------ ------------------ 85| 65| return luaO_pushfstring(ls->L, "'%c'", token); 86| 24| else /* control character */ 87| 24| return luaO_pushfstring(ls->L, "'<\\%d>'", token); 88| 89| } 89| 52| else { 90| 52| const char *s = luaX_tokens[token - FIRST_RESERVED]; ------------------ | | 20| 52|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ 91| 52| if (token < TK_EOS) /* fixed format (symbols and reserved words)? */ ------------------ | Branch (91:9): [True: 21, False: 31] ------------------ 92| 21| return luaO_pushfstring(ls->L, "'%s'", s); 93| 31| else /* names, strings, and numerals */ 94| 31| return s; 95| 52| } 96| 141|} luaX_syntaxerror: 119| 101|l_noret luaX_syntaxerror (LexState *ls, const char *msg) { 120| 101| lexerror(ls, msg, ls->t.token); 121| 101|} luaX_newstring: 134| 5.34M|TString *luaX_newstring (LexState *ls, const char *str, size_t l) { 135| 5.34M| lua_State *L = ls->L; 136| 5.34M| TString *ts = luaS_newlstr(L, str, l); /* create new string */ 137| 5.34M| const TValue *o = luaH_getstr(ls->h, ts); 138| 5.34M| if (!ttisnil(o)) /* string already present? */ ------------------ | | 193| 5.34M|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 5.34M|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 5.34M|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 5.34M|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (138:7): [True: 5.33M, False: 11.1k] ------------------ 139| 5.33M| ts = keystrval(nodefromval(o)); /* get saved copy */ ------------------ | | 760| 5.33M|#define keystrval(node) (gco2ts(keyval(node).gc)) | | ------------------ | | | | 374| 5.33M| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | | | ------------------ | | | | | | 110| 5.33M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 5.33M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 140| 11.1k| else { /* not in use yet */ 141| 11.1k| TValue *stv = s2v(L->top.p++); /* reserve stack space for string */ ------------------ | | 172| 11.1k|#define s2v(o) (&(o)->val) ------------------ 142| 11.1k| setsvalue(L, stv, ts); /* temporarily anchor the string */ ------------------ | | 372| 11.1k| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 11.1k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 11.1k|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 11.1k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 11.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 11.1k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 11.1k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 11.1k| checkliveness(L,io); } | | ------------------ | | | | 107| 11.1k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 177k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 11.1k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 11.1k] | | | | | | | Branch (112:29): [True: 11.1k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 11.1k] | | | | | | | Branch (112:29): [True: 11.1k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 11.1k] | | | | | | | Branch (112:29): [True: 11.1k, False: 0] | | | | | | | Branch (112:29): [True: 11.1k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 11.1k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 11.1k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 143| 11.1k| 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| 11.1k| luaC_checkGC(L); ------------------ | | 172| 11.1k|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 11.1k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 11.1k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 718, False: 10.3k] | | | | ------------------ | | | | 169| 11.1k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 11.1k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 146| 11.1k| L->top.p--; /* remove string from stack */ 147| 11.1k| } 148| 5.34M| return ts; 149| 5.34M|} luaX_setinput: 168| 225| int firstchar) { 169| 225| ls->t.token = 0; 170| 225| ls->L = L; 171| 225| ls->current = firstchar; 172| 225| ls->lookahead.token = TK_EOS; /* no look-ahead token */ 173| 225| ls->z = z; 174| 225| ls->fs = NULL; 175| 225| ls->linenumber = 1; 176| 225| ls->lastline = 1; 177| 225| ls->source = source; 178| 225| ls->envn = luaS_newliteral(L, LUA_ENV); /* get env name */ ------------------ | | 28| 225|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 225| (sizeof(s)/sizeof(char))-1)) ------------------ 179| 225| luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */ ------------------ | | 40| 225| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | ------------------ | | | | 53| 225| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | ------------------ | | | | | | 146| 225|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 41| 225| (buff)->buffsize, size), \ | | 42| 225| (buff)->buffsize = size) ------------------ 180| 225|} luaX_next: 565| 10.8M|void luaX_next (LexState *ls) { 566| 10.8M| ls->lastline = ls->linenumber; 567| 10.8M| if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */ ------------------ | Branch (567:7): [True: 109, False: 10.8M] ------------------ 568| 109| ls->t = ls->lookahead; /* use this one */ 569| 109| ls->lookahead.token = TK_EOS; /* and discharge it */ 570| 109| } 571| 10.8M| else 572| 10.8M| ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */ 573| 10.8M|} luaX_lookahead: 576| 109|int luaX_lookahead (LexState *ls) { 577| 109| lua_assert(ls->lookahead.token == TK_EOS); ------------------ | | 106| 109|#define lua_assert(c) assert(c) ------------------ 578| 109| ls->lookahead.token = llex(ls, &ls->lookahead.seminfo); 579| 109| return ls->lookahead.token; 580| 109|} llex.c:lexerror: 111| 178|static l_noret lexerror (LexState *ls, const char *msg, int token) { 112| 178| msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber); 113| 178| if (token) ------------------ | Branch (113:7): [True: 163, False: 15] ------------------ 114| 163| luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token)); 115| 178| luaD_throw(ls->L, LUA_ERRSYNTAX); ------------------ | | 51| 178|#define LUA_ERRSYNTAX 3 ------------------ 116| 178|} llex.c:txtToken: 99| 163|static const char *txtToken (LexState *ls, int token) { 100| 163| switch (token) { 101| 44| case TK_NAME: case TK_STRING: ------------------ | Branch (101:5): [True: 5, False: 158] | Branch (101:19): [True: 39, False: 124] ------------------ 102| 73| case TK_FLT: case TK_INT: ------------------ | Branch (102:5): [True: 26, False: 137] | Branch (102:18): [True: 3, False: 160] ------------------ 103| 73| save(ls, '\0'); 104| 73| return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff)); ------------------ | | 31| 73|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 105| 90| default: ------------------ | Branch (105:5): [True: 90, False: 73] ------------------ 106| 90| return luaX_token2str(ls, token); 107| 163| } 108| 163|} llex.c:save: 57| 25.7M|static void save (LexState *ls, int c) { 58| 25.7M| Mbuffer *b = ls->buff; 59| 25.7M| if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { ------------------ | | 33| 25.7M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { ------------------ | | 32| 25.7M|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ | Branch (59:7): [True: 1.13k, False: 25.7M] ------------------ 60| 1.13k| size_t newsize; 61| 1.13k| if (luaZ_sizebuffer(b) >= MAX_SIZE/2) ------------------ | | 32| 1.13k|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ if (luaZ_sizebuffer(b) >= MAX_SIZE/2) ------------------ | | 44| 1.13k|#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.13k| : (size_t)(LUA_MAXINTEGER)) | | ------------------ | | | | 554| 1.13k|#define LUA_MAXINTEGER LLONG_MAX | | ------------------ ------------------ | Branch (61:9): [True: 0, False: 1.13k] ------------------ 62| 0| lexerror(ls, "lexical element too long", 0); 63| 1.13k| newsize = luaZ_sizebuffer(b) * 2; ------------------ | | 32| 1.13k|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ 64| 1.13k| luaZ_resizebuffer(ls->L, b, newsize); ------------------ | | 40| 1.13k| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | ------------------ | | | | 53| 1.13k| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | ------------------ | | | | | | 146| 1.13k|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 136| 1.13k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 41| 1.13k| (buff)->buffsize, size), \ | | 42| 1.13k| (buff)->buffsize = size) ------------------ 65| 1.13k| } 66| 25.7M| b->buffer[luaZ_bufflen(b)++] = cast_char(c); ------------------ | | 33| 25.7M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ b->buffer[luaZ_bufflen(b)++] = cast_char(c); ------------------ | | 145| 25.7M|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 136| 25.7M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 67| 25.7M|} llex.c:llex: 445| 10.8M|static int llex (LexState *ls, SemInfo *seminfo) { 446| 10.8M| luaZ_resetbuffer(ls->buff); ------------------ | | 36| 10.8M|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 447| 10.9M| for (;;) { 448| 10.9M| switch (ls->current) { 449| 69.3k| case '\n': case '\r': { /* line breaks */ ------------------ | Branch (449:7): [True: 44.2k, False: 10.9M] | Branch (449:18): [True: 25.1k, False: 10.9M] ------------------ 450| 69.3k| inclinenumber(ls); 451| 69.3k| break; 452| 44.2k| } 453| 59.1k| case ' ': case '\f': case '\t': case '\v': { /* spaces */ ------------------ | Branch (453:7): [True: 11.3k, False: 10.9M] | Branch (453:17): [True: 7.04k, False: 10.9M] | Branch (453:28): [True: 30.5k, False: 10.9M] | Branch (453:39): [True: 10.2k, False: 10.9M] ------------------ 454| 59.1k| next(ls); ------------------ | | 32| 59.1k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 59.1k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 59.1k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 59.1k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 59.1k, False: 0] | | | | ------------------ | | ------------------ ------------------ 455| 59.1k| break; 456| 48.8k| } 457| 98.9k| case '-': { /* '-' or '--' (comment) */ ------------------ | Branch (457:7): [True: 98.9k, False: 10.8M] ------------------ 458| 98.9k| next(ls); ------------------ | | 32| 98.9k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 98.9k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 98.9k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 98.9k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 98.9k, False: 0] | | | | ------------------ | | ------------------ ------------------ 459| 98.9k| if (ls->current != '-') return '-'; ------------------ | Branch (459:13): [True: 77.6k, False: 21.3k] ------------------ 460| | /* else is a comment */ 461| 21.3k| next(ls); ------------------ | | 32| 21.3k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 21.3k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 21.3k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 21.3k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 21.3k, False: 0] | | | | ------------------ | | ------------------ ------------------ 462| 21.3k| if (ls->current == '[') { /* long comment? */ ------------------ | Branch (462:13): [True: 24, False: 21.2k] ------------------ 463| 24| size_t sep = skip_sep(ls); 464| 24| luaZ_resetbuffer(ls->buff); /* 'skip_sep' may dirty the buffer */ ------------------ | | 36| 24|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 465| 24| if (sep >= 2) { ------------------ | Branch (465:15): [True: 3, False: 21] ------------------ 466| 3| read_long_string(ls, NULL, sep); /* skip long comment */ 467| 3| luaZ_resetbuffer(ls->buff); /* previous call may dirty the buff. */ ------------------ | | 36| 3|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 468| 3| break; 469| 3| } 470| 24| } 471| | /* else short comment */ 472| 2.98M| while (!currIsNewline(ls) && ls->current != EOZ) ------------------ | | 36| 5.96M|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 8.79k, False: 2.97M] | | | Branch (36:51): [True: 12.5k, False: 2.95M] | | ------------------ ------------------ while (!currIsNewline(ls) && ls->current != EOZ) ------------------ | | 16| 2.95M|#define EOZ (-1) /* end of stream */ ------------------ | Branch (472:38): [True: 2.95M, False: 7] ------------------ 473| 2.95M| next(ls); /* skip until end of line (or end of file) */ ------------------ | | 32| 2.98M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 2.95M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 2.95M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 2.95M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 2.95M, False: 7] | | | | ------------------ | | ------------------ ------------------ 474| 21.3k| break; 475| 21.3k| } 476| 102k| case '[': { /* long string or simply '[' */ ------------------ | Branch (476:7): [True: 102k, False: 10.8M] ------------------ 477| 102k| size_t sep = skip_sep(ls); 478| 102k| if (sep >= 2) { ------------------ | Branch (478:13): [True: 89.7k, False: 12.8k] ------------------ 479| 89.7k| read_long_string(ls, seminfo, sep); 480| 89.7k| return TK_STRING; 481| 89.7k| } 482| 12.8k| else if (sep == 0) /* '[=...' missing second bracket? */ ------------------ | Branch (482:18): [True: 0, False: 12.8k] ------------------ 483| 0| lexerror(ls, "invalid long string delimiter", TK_STRING); 484| 12.8k| return '['; 485| 102k| } 486| 25.9k| case '=': { ------------------ | Branch (486:7): [True: 25.9k, False: 10.9M] ------------------ 487| 25.9k| next(ls); ------------------ | | 32| 25.9k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 25.9k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 25.9k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 25.9k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 25.9k, False: 0] | | | | ------------------ | | ------------------ ------------------ 488| 25.9k| if (check_next1(ls, '=')) return TK_EQ; /* '==' */ ------------------ | Branch (488:13): [True: 1.77k, False: 24.1k] ------------------ 489| 24.1k| else return '='; 490| 25.9k| } 491| 2.17M| case '<': { ------------------ | Branch (491:7): [True: 2.17M, False: 8.80M] ------------------ 492| 2.17M| next(ls); ------------------ | | 32| 2.17M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 2.17M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 2.17M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 2.17M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 2.17M, False: 0] | | | | ------------------ | | ------------------ ------------------ 493| 2.17M| if (check_next1(ls, '=')) return TK_LE; /* '<=' */ ------------------ | Branch (493:13): [True: 2.24k, False: 2.17M] ------------------ 494| 2.17M| else if (check_next1(ls, '<')) return TK_SHL; /* '<<' */ ------------------ | Branch (494:18): [True: 113k, False: 2.05M] ------------------ 495| 2.05M| else return '<'; 496| 2.17M| } 497| 17.2k| case '>': { ------------------ | Branch (497:7): [True: 17.2k, False: 10.9M] ------------------ 498| 17.2k| 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] | | | | ------------------ | | ------------------ ------------------ 499| 17.2k| if (check_next1(ls, '=')) return TK_GE; /* '>=' */ ------------------ | Branch (499:13): [True: 632, False: 16.6k] ------------------ 500| 16.6k| else if (check_next1(ls, '>')) return TK_SHR; /* '>>' */ ------------------ | Branch (500:18): [True: 456, False: 16.1k] ------------------ 501| 16.1k| else return '>'; 502| 17.2k| } 503| 2.56M| case '/': { ------------------ | Branch (503:7): [True: 2.56M, False: 8.41M] ------------------ 504| 2.56M| next(ls); ------------------ | | 32| 2.56M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 2.56M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 2.56M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 2.56M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 2.56M, False: 0] | | | | ------------------ | | ------------------ ------------------ 505| 2.56M| if (check_next1(ls, '/')) return TK_IDIV; /* '//' */ ------------------ | Branch (505:13): [True: 13.6k, False: 2.54M] ------------------ 506| 2.54M| else return '/'; 507| 2.56M| } 508| 68.1k| case '~': { ------------------ | Branch (508:7): [True: 68.1k, False: 10.9M] ------------------ 509| 68.1k| next(ls); ------------------ | | 32| 68.1k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 68.1k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 68.1k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 68.1k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 68.1k, False: 0] | | | | ------------------ | | ------------------ ------------------ 510| 68.1k| if (check_next1(ls, '=')) return TK_NE; /* '~=' */ ------------------ | Branch (510:13): [True: 1.78k, False: 66.3k] ------------------ 511| 66.3k| else return '~'; 512| 68.1k| } 513| 600| case ':': { ------------------ | Branch (513:7): [True: 600, False: 10.9M] ------------------ 514| 600| next(ls); ------------------ | | 32| 600|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 600|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 600|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 600|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 600, False: 0] | | | | ------------------ | | ------------------ ------------------ 515| 600| if (check_next1(ls, ':')) return TK_DBCOLON; /* '::' */ ------------------ | Branch (515:13): [True: 49, False: 551] ------------------ 516| 551| else return ':'; 517| 600| } 518| 68.4k| case '"': case '\'': { /* short literal strings */ ------------------ | Branch (518:7): [True: 60.3k, False: 10.9M] | Branch (518:17): [True: 8.08k, False: 10.9M] ------------------ 519| 68.4k| read_string(ls, ls->current, seminfo); 520| 68.4k| return TK_STRING; 521| 60.3k| } 522| 18.1k| case '.': { /* '.', '..', '...', or number */ ------------------ | Branch (522:7): [True: 18.1k, False: 10.9M] ------------------ 523| 18.1k| save_and_next(ls); ------------------ | | 51| 18.1k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 18.1k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 18.1k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 18.1k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 18.1k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 18.1k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 524| 18.1k| if (check_next1(ls, '.')) { ------------------ | Branch (524:13): [True: 14.5k, False: 3.55k] ------------------ 525| 14.5k| if (check_next1(ls, '.')) ------------------ | Branch (525:15): [True: 901, False: 13.6k] ------------------ 526| 901| return TK_DOTS; /* '...' */ 527| 13.6k| else return TK_CONCAT; /* '..' */ 528| 14.5k| } 529| 3.55k| else if (!lisdigit(ls->current)) return '.'; ------------------ | | 59| 3.55k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 3.55k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ | Branch (529:18): [True: 2.52k, False: 1.03k] ------------------ 530| 1.03k| else return read_numeral(ls, seminfo); 531| 18.1k| } 532| 108k| case '0': case '1': case '2': case '3': case '4': ------------------ | Branch (532:7): [True: 24.9k, False: 10.9M] | Branch (532:17): [True: 47.1k, False: 10.9M] | Branch (532:27): [True: 24.7k, False: 10.9M] | Branch (532:37): [True: 7.24k, False: 10.9M] | Branch (532:47): [True: 4.78k, False: 10.9M] ------------------ 533| 145k| case '5': case '6': case '7': case '8': case '9': { ------------------ | Branch (533:7): [True: 15.9k, False: 10.9M] | Branch (533:17): [True: 3.27k, False: 10.9M] | Branch (533:27): [True: 1.84k, False: 10.9M] | Branch (533:37): [True: 5.80k, False: 10.9M] | Branch (533:47): [True: 10.2k, False: 10.9M] ------------------ 534| 145k| return read_numeral(ls, seminfo); 535| 135k| } 536| 58| case EOZ: { ------------------ | | 16| 58|#define EOZ (-1) /* end of stream */ ------------------ | Branch (536:7): [True: 58, False: 10.9M] ------------------ 537| 58| return TK_EOS; 538| 135k| } 539| 5.56M| default: { ------------------ | Branch (539:7): [True: 5.56M, False: 5.41M] ------------------ 540| 5.56M| if (lislalpha(ls->current)) { /* identifier or reserved word? */ ------------------ | | 57| 5.56M|#define lislalpha(c) testprop(c, MASK(ALPHABIT)) | | ------------------ | | | | 52| 5.56M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 5.18M, False: 385k] | | | | ------------------ | | ------------------ ------------------ 541| 5.18M| TString *ts; 542| 9.47M| do { 543| 9.47M| save_and_next(ls); ------------------ | | 51| 9.47M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 9.47M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 9.47M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 9.47M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 9.47M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 9.47M, False: 35] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 544| 9.47M| } while (lislalnum(ls->current)); ------------------ | | 58| 9.47M|#define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT))) | | ------------------ | | | | 52| 9.47M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 4.29M, False: 5.18M] | | | | ------------------ | | ------------------ ------------------ 545| 5.18M| ts = luaX_newstring(ls, luaZ_buffer(ls->buff), ------------------ | | 31| 5.18M|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 546| 5.18M| luaZ_bufflen(ls->buff)); ------------------ | | 33| 5.18M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ 547| 5.18M| seminfo->ts = ts; 548| 5.18M| if (isreserved(ts)) /* reserved word? */ ------------------ | | 35| 5.18M|#define isreserved(s) ((s)->tt == LUA_VSHRSTR && (s)->extra > 0) | | ------------------ | | | | 360| 5.18M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | ------------------ | | | | | | 42| 10.3M|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (35:24): [True: 5.18M, False: 2.50k] | | | Branch (35:50): [True: 136k, False: 5.04M] | | ------------------ ------------------ 549| 136k| return ts->extra - 1 + FIRST_RESERVED; ------------------ | | 20| 136k|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ 550| 5.04M| else { 551| 5.04M| return TK_NAME; 552| 5.04M| } 553| 5.18M| } 554| 385k| else { /* single-char tokens ('+', '*', '%', '{', '}', ...) */ 555| 385k| int c = ls->current; 556| 385k| next(ls); ------------------ | | 32| 385k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 385k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 385k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 385k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 385k, False: 0] | | | | ------------------ | | ------------------ ------------------ 557| 385k| return c; 558| 385k| } 559| 5.56M| } 560| 10.9M| } 561| 10.9M| } 562| 10.8M|} llex.c:inclinenumber: 156| 521k|static void inclinenumber (LexState *ls) { 157| 521k| int old = ls->current; 158| 521k| lua_assert(currIsNewline(ls)); ------------------ | | 106| 521k|#define lua_assert(c) assert(c) ------------------ 159| 521k| next(ls); /* skip '\n' or '\r' */ ------------------ | | 32| 521k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 521k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 521k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 521k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 521k, False: 0] | | | | ------------------ | | ------------------ ------------------ 160| 521k| if (currIsNewline(ls) && ls->current != old) ------------------ | | 36| 1.04M|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 47.2k, False: 473k] | | | Branch (36:51): [True: 321k, False: 152k] | | ------------------ ------------------ | Branch (160:28): [True: 34.3k, False: 333k] ------------------ 161| 34.3k| next(ls); /* skip '\n\r' or '\r\n' */ ------------------ | | 32| 34.3k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 34.3k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 34.3k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 34.3k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 34.3k, False: 0] | | | | ------------------ | | ------------------ ------------------ 162| 521k| if (++ls->linenumber >= MAX_INT) ------------------ | | 53| 521k|#define MAX_INT INT_MAX /* maximum value of an int */ ------------------ | Branch (162:7): [True: 0, False: 521k] ------------------ 163| 0| lexerror(ls, "chunk has too many lines", 0); 164| 521k|} llex.c:skip_sep: 265| 197k|static size_t skip_sep (LexState *ls) { 266| 197k| size_t count = 0; 267| 197k| int s = ls->current; 268| 197k| lua_assert(s == '[' || s == ']'); ------------------ | | 106| 197k|#define lua_assert(c) assert(c) ------------------ 269| 197k| save_and_next(ls); ------------------ | | 51| 197k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 197k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 197k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 197k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 197k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 197k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 270| 198k| while (ls->current == '=') { ------------------ | Branch (270:10): [True: 722, False: 197k] ------------------ 271| 722| save_and_next(ls); ------------------ | | 51| 722|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 722|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 722|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 722|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 722|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 722, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 272| 722| count++; 273| 722| } 274| 197k| return (ls->current == s) ? count + 2 ------------------ | Branch (274:10): [True: 179k, False: 18.0k] ------------------ 275| 197k| : (count == 0) ? 1 ------------------ | Branch (275:12): [True: 17.3k, False: 722] ------------------ 276| 18.0k| : 0; 277| 197k|} llex.c:read_long_string: 280| 89.7k|static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) { 281| 89.7k| int line = ls->linenumber; /* initial line (for error message) */ 282| 89.7k| save_and_next(ls); /* skip 2nd '[' */ ------------------ | | 51| 89.7k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 89.7k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 89.7k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 89.7k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 89.7k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 89.7k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 283| 89.7k| if (currIsNewline(ls)) /* string starts with a newline? */ ------------------ | | 36| 89.7k|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 78.8k, False: 10.9k] | | | Branch (36:51): [True: 7.46k, False: 3.50k] | | ------------------ ------------------ 284| 86.2k| inclinenumber(ls); /* skip it */ 285| 4.73M| for (;;) { 286| 4.73M| switch (ls->current) { 287| 9| case EOZ: { /* error */ ------------------ | | 16| 9|#define EOZ (-1) /* end of stream */ ------------------ | Branch (287:7): [True: 9, False: 4.73M] ------------------ 288| 9| const char *what = (seminfo ? "string" : "comment"); ------------------ | Branch (288:29): [True: 8, False: 1] ------------------ 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| 94.9k| case ']': { ------------------ | Branch (294:7): [True: 94.9k, False: 4.63M] ------------------ 295| 94.9k| if (skip_sep(ls) == sep) { ------------------ | Branch (295:13): [True: 89.7k, False: 5.16k] ------------------ 296| 89.7k| save_and_next(ls); /* skip 2nd ']' */ ------------------ | | 51| 89.7k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 89.7k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 89.7k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 89.7k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 89.7k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 89.7k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 297| 89.7k| goto endloop; 298| 89.7k| } 299| 5.16k| break; 300| 94.9k| } 301| 365k| case '\n': case '\r': { ------------------ | Branch (301:7): [True: 55.3k, False: 4.67M] | Branch (301:18): [True: 310k, False: 4.42M] ------------------ 302| 365k| save(ls, '\n'); 303| 365k| inclinenumber(ls); 304| 365k| if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */ ------------------ | | 36| 1.20k|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ | Branch (304:13): [True: 1.20k, False: 364k] ------------------ 305| 365k| break; 306| 55.3k| } 307| 4.27M| default: { ------------------ | Branch (307:7): [True: 4.27M, False: 460k] ------------------ 308| 4.27M| if (seminfo) save_and_next(ls); ------------------ | | 51| 4.01M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 4.01M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 4.01M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 4.01M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 4.01M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 4.01M, False: 8] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (308:13): [True: 4.01M, False: 261k] ------------------ 309| 261k| else next(ls); ------------------ | | 32| 261k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 261k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 261k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 261k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 261k, False: 1] | | | | ------------------ | | ------------------ ------------------ 310| 4.27M| } 311| 4.73M| } 312| 4.73M| } endloop: 313| 89.7k| if (seminfo) ------------------ | Branch (313:7): [True: 89.7k, False: 2] ------------------ 314| 89.7k| seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep, ------------------ | | 31| 89.7k|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 315| 89.7k| luaZ_bufflen(ls->buff) - 2 * sep); ------------------ | | 33| 89.7k|#define luaZ_bufflen(buff) ((buff)->n) ------------------ 316| 89.7k|} llex.c:check_next1: 191| 7.07M|static int check_next1 (LexState *ls, int c) { 192| 7.07M| if (ls->current == c) { ------------------ | Branch (192:7): [True: 149k, False: 6.92M] ------------------ 193| 149k| next(ls); ------------------ | | 32| 149k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 149k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 149k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 149k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 149k, False: 0] | | | | ------------------ | | ------------------ ------------------ 194| 149k| return 1; 195| 149k| } 196| 6.92M| else return 0; 197| 7.07M|} llex.c:read_string: 382| 68.4k|static void read_string (LexState *ls, int del, SemInfo *seminfo) { 383| 68.4k| save_and_next(ls); /* keep delimiter (for error messages) */ ------------------ | | 51| 68.4k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 68.4k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 68.4k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 68.4k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 68.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 68.4k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 384| 9.79M| while (ls->current != del) { ------------------ | Branch (384:10): [True: 9.72M, False: 68.3k] ------------------ 385| 9.72M| switch (ls->current) { 386| 7| case EOZ: ------------------ | | 16| 7|#define EOZ (-1) /* end of stream */ ------------------ | Branch (386:7): [True: 7, False: 9.72M] ------------------ 387| 7| lexerror(ls, "unfinished string", TK_EOS); 388| 0| break; /* to avoid warnings */ 389| 2| case '\n': ------------------ | Branch (389:7): [True: 2, False: 9.72M] ------------------ 390| 7| case '\r': ------------------ | Branch (390:7): [True: 5, False: 9.72M] ------------------ 391| 7| lexerror(ls, "unfinished string", TK_STRING); 392| 0| break; /* to avoid warnings */ 393| 25.8k| case '\\': { /* escape sequences */ ------------------ | Branch (393:7): [True: 25.8k, False: 9.69M] ------------------ 394| 25.8k| int c; /* final character to be saved */ 395| 25.8k| save_and_next(ls); /* keep '\\' for error messages */ ------------------ | | 51| 25.8k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 25.8k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 25.8k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 25.8k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 25.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 25.8k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 396| 25.8k| switch (ls->current) { 397| 20| case 'a': c = '\a'; goto read_save; ------------------ | Branch (397:11): [True: 20, False: 25.8k] ------------------ 398| 31| case 'b': c = '\b'; goto read_save; ------------------ | Branch (398:11): [True: 31, False: 25.8k] ------------------ 399| 4.39k| case 'f': c = '\f'; goto read_save; ------------------ | Branch (399:11): [True: 4.39k, False: 21.4k] ------------------ 400| 1| case 'n': c = '\n'; goto read_save; ------------------ | Branch (400:11): [True: 1, False: 25.8k] ------------------ 401| 2.22k| case 'r': c = '\r'; goto read_save; ------------------ | Branch (401:11): [True: 2.22k, False: 23.6k] ------------------ 402| 38| case 't': c = '\t'; goto read_save; ------------------ | Branch (402:11): [True: 38, False: 25.8k] ------------------ 403| 8| case 'v': c = '\v'; goto read_save; ------------------ | Branch (403:11): [True: 8, False: 25.8k] ------------------ 404| 960| case 'x': c = readhexaesc(ls); goto read_save; ------------------ | Branch (404:11): [True: 960, False: 24.8k] ------------------ 405| 6.49k| case 'u': utf8esc(ls); goto no_save; ------------------ | Branch (405:11): [True: 6.49k, False: 19.3k] ------------------ 406| 0| case '\n': case '\r': ------------------ | Branch (406:11): [True: 0, False: 25.8k] | Branch (406:22): [True: 0, False: 25.8k] ------------------ 407| 0| inclinenumber(ls); c = '\n'; goto only_save; 408| 1.97k| case '\\': case '\"': case '\'': ------------------ | Branch (408:11): [True: 921, False: 24.9k] | Branch (408:22): [True: 955, False: 24.8k] | Branch (408:33): [True: 98, False: 25.7k] ------------------ 409| 1.97k| 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: 25.8k] ------------------ 411| 39| case 'z': { /* zap following span of spaces */ ------------------ | Branch (411:11): [True: 39, False: 25.8k] ------------------ 412| 39| luaZ_buffremove(ls->buff, 1); /* remove '\\' */ ------------------ | | 35| 39|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 413| 39| next(ls); /* skip the 'z' */ ------------------ | | 32| 39|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 39|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 39|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 39|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 39, False: 0] | | | | ------------------ | | ------------------ ------------------ 414| 48| while (lisspace(ls->current)) { 415| 48| if (currIsNewline(ls)) inclinenumber(ls); ------------------ | | 36| 48|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 0, False: 48] | | | Branch (36:51): [True: 36, False: 12] | | ------------------ ------------------ 416| 12| else next(ls); ------------------ | | 32| 12|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 12|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 12|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 12, False: 0] | | | | ------------------ | | ------------------ ------------------ 417| 48| } 418| 39| goto no_save; 419| 1.87k| } 420| 9.66k| default: { ------------------ | Branch (420:11): [True: 9.66k, False: 16.1k] ------------------ 421| 9.66k| esccheck(ls, lisdigit(ls->current), "invalid escape sequence"); ------------------ | | 59| 9.66k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 9.66k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ 422| 9.66k| c = readdecesc(ls); /* digital escape '\ddd' */ 423| 9.66k| goto only_save; 424| 1.87k| } 425| 25.8k| } 426| 9.64k| read_save: 427| 9.64k| next(ls); ------------------ | | 32| 9.64k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 9.64k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 9.64k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 9.64k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 9.64k, False: 0] | | | | ------------------ | | ------------------ ------------------ 428| | /* go through */ 429| 19.3k| only_save: 430| 19.3k| luaZ_buffremove(ls->buff, 1); /* remove '\\' */ ------------------ | | 35| 19.3k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 431| 19.3k| save(ls, c); 432| | /* go through */ 433| 25.8k| no_save: break; 434| 19.3k| } 435| 9.69M| default: ------------------ | Branch (435:7): [True: 9.69M, False: 25.8k] ------------------ 436| 9.69M| save_and_next(ls); ------------------ | | 51| 9.69M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 9.69M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 9.69M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 9.69M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 9.69M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 9.69M, False: 7] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 437| 9.72M| } 438| 9.72M| } 439| 68.3k| save_and_next(ls); /* skip delimiter */ ------------------ | | 51| 68.3k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 68.3k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 68.3k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 68.3k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 68.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 68.3k, False: 15] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 440| 68.3k| seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1, ------------------ | | 31| 68.3k|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 441| 68.3k| luaZ_bufflen(ls->buff) - 2); ------------------ | | 33| 68.3k|#define luaZ_bufflen(buff) ((buff)->n) ------------------ 442| 68.3k|} llex.c:readhexaesc: 335| 960|static int readhexaesc (LexState *ls) { 336| 960| int r = gethexa(ls); 337| 960| r = (r << 4) + gethexa(ls); 338| 960| luaZ_buffremove(ls->buff, 2); /* remove saved chars from buffer */ ------------------ | | 35| 960|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 339| 960| return r; 340| 960|} llex.c:gethexa: 328| 8.40k|static int gethexa (LexState *ls) { 329| 8.40k| save_and_next(ls); ------------------ | | 51| 8.40k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 8.40k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 8.40k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 8.40k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 8.40k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 8.40k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 330| 8.40k| esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected"); ------------------ | | 62| 8.40k|#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) | | ------------------ | | | | 52| 8.40k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ 331| 8.40k| return luaO_hexavalue(ls->current); 332| 8.40k|} llex.c:utf8esc: 361| 6.49k|static void utf8esc (LexState *ls) { 362| 6.49k| char buff[UTF8BUFFSZ]; 363| 6.49k| int n = luaO_utf8esc(buff, readutf8esc(ls)); 364| 37.2k| for (; n > 0; n--) /* add 'buff' to string */ ------------------ | Branch (364:10): [True: 30.7k, False: 6.49k] ------------------ 365| 30.7k| save(ls, buff[UTF8BUFFSZ - n]); ------------------ | | 795| 30.7k|#define UTF8BUFFSZ 8 ------------------ 366| 6.49k|} llex.c:readutf8esc: 343| 6.49k|static unsigned long readutf8esc (LexState *ls) { 344| 6.49k| unsigned long r; 345| 6.49k| int i = 4; /* chars to be removed: '\', 'u', '{', and first digit */ 346| 6.49k| save_and_next(ls); /* skip 'u' */ ------------------ | | 51| 6.49k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 6.49k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 6.49k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 6.49k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 6.49k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 6.49k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 347| 6.49k| esccheck(ls, ls->current == '{', "missing '{'"); 348| 6.49k| r = gethexa(ls); /* must have at least one digit */ 349| 37.0k| while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) { ------------------ | | 138| 37.0k|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 74.0k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 37.0k, False: 11] | | | | ------------------ | | ------------------ ------------------ while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) { ------------------ | | 62| 37.0k|#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) | | ------------------ | | | | 52| 37.0k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ | Branch (349:10): [True: 30.5k, False: 6.49k] ------------------ 350| 30.5k| i++; 351| 30.5k| esccheck(ls, r <= (0x7FFFFFFFu >> 4), "UTF-8 value too large"); 352| 30.5k| r = (r << 4) + luaO_hexavalue(ls->current); 353| 30.5k| } 354| 6.49k| esccheck(ls, ls->current == '}', "missing '}'"); 355| 6.49k| next(ls); /* skip '}' */ ------------------ | | 32| 6.49k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 6.49k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 6.47k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 6.47k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 6.47k, False: 23] | | | | ------------------ | | ------------------ ------------------ 356| 6.49k| luaZ_buffremove(ls->buff, i); /* remove saved chars from buffer */ ------------------ | | 35| 6.49k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 357| 6.49k| return r; 358| 6.49k|} llex.c:esccheck: 319| 71.2k|static void esccheck (LexState *ls, int c, const char *msg) { 320| 71.2k| if (!c) { ------------------ | Branch (320:7): [True: 30, False: 71.2k] ------------------ 321| 30| if (ls->current != EOZ) ------------------ | | 16| 30|#define EOZ (-1) /* end of stream */ ------------------ | Branch (321:9): [True: 30, False: 0] ------------------ 322| 30| save_and_next(ls); /* add current to buffer for error message */ ------------------ | | 51| 30|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 30|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 30|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 30|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 30|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 30, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 323| 30| lexerror(ls, msg, TK_STRING); 324| 30| } 325| 71.2k|} llex.c:readdecesc: 369| 9.65k|static int readdecesc (LexState *ls) { 370| 9.65k| int i; 371| 9.65k| int r = 0; /* result accumulator */ 372| 34.3k| for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */ ------------------ | | 59| 26.9k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 26.9k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 24.7k, False: 2.17k] | | | | ------------------ | | ------------------ ------------------ | Branch (372:15): [True: 26.9k, False: 7.48k] ------------------ 373| 24.7k| r = 10*r + ls->current - '0'; 374| 24.7k| save_and_next(ls); ------------------ | | 51| 24.7k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 24.7k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 24.7k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 24.7k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 24.7k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 24.7k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 375| 24.7k| } 376| 9.65k| esccheck(ls, r <= UCHAR_MAX, "decimal escape too large"); 377| 9.65k| luaZ_buffremove(ls->buff, i); /* remove read digits from buffer */ ------------------ | | 35| 9.65k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 378| 9.65k| return r; 379| 9.65k|} llex.c:read_numeral: 227| 146k|static int read_numeral (LexState *ls, SemInfo *seminfo) { 228| 146k| TValue obj; 229| 146k| const char *expo = "Ee"; 230| 146k| int first = ls->current; 231| 146k| lua_assert(lisdigit(ls->current)); ------------------ | | 106| 146k|#define lua_assert(c) assert(c) ------------------ 232| 146k| save_and_next(ls); ------------------ | | 51| 146k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 146k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 146k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 146k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 146k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 146k, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 233| 146k| if (first == '0' && check_next2(ls, "xX")) /* hexadecimal? */ ------------------ | Branch (233:7): [True: 25.1k, False: 121k] | Branch (233:23): [True: 3, False: 25.0k] ------------------ 234| 3| expo = "Pp"; 235| 1.38M| for (;;) { 236| 1.38M| if (check_next2(ls, expo)) /* exponent mark? */ ------------------ | Branch (236:9): [True: 772, False: 1.38M] ------------------ 237| 772| check_next2(ls, "-+"); /* optional exponent sign */ 238| 1.38M| else if (lisxdigit(ls->current) || ls->current == '.') /* '%x|%.' */ ------------------ | | 62| 1.38M|#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) | | ------------------ | | | | 52| 2.76M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 1.22M, False: 161k] | | | | ------------------ | | ------------------ ------------------ | Branch (238:40): [True: 14.7k, False: 146k] ------------------ 239| 1.23M| save_and_next(ls); ------------------ | | 51| 1.23M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 1.23M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 1.23M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 1.23M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1.23M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 1.23M, False: 2] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 240| 146k| else break; 241| 1.38M| } 242| 146k| if (lislalpha(ls->current)) /* is numeral touching a letter? */ ------------------ | | 57| 146k|#define lislalpha(c) testprop(c, MASK(ALPHABIT)) | | ------------------ | | | | 52| 146k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 20, False: 146k] | | | | ------------------ | | ------------------ ------------------ 243| 20| save_and_next(ls); /* force an error */ ------------------ | | 51| 20|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 20|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 20|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 20|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 20|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 20, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 244| 146k| save(ls, '\0'); 245| 146k| if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0) /* format error? */ ------------------ | | 31| 146k|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ | Branch (245:7): [True: 24, False: 146k] ------------------ 246| 24| lexerror(ls, "malformed number", TK_FLT); 247| 146k| if (ttisinteger(&obj)) { ------------------ | | 328| 146k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 146k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 146k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 129k, False: 17.2k] | | | | ------------------ | | ------------------ ------------------ 248| 129k| seminfo->i = ivalue(&obj); ------------------ | | 333| 129k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 129k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 129k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 249| 0| return TK_INT; 250| 129k| } 251| 17.2k| else { 252| 17.2k| lua_assert(ttisfloat(&obj)); ------------------ | | 106| 17.2k|#define lua_assert(c) assert(c) ------------------ 253| 17.2k| seminfo->r = fltvalue(&obj); ------------------ | | 332| 17.2k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 110| 17.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 17.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 254| 0| return TK_FLT; 255| 17.2k| } 256| 146k|} llex.c:check_next2: 204| 1.40M|static int check_next2 (LexState *ls, const char *set) { 205| 1.40M| lua_assert(set[2] == '\0'); ------------------ | | 106| 1.40M|#define lua_assert(c) assert(c) ------------------ 206| 1.40M| if (ls->current == set[0] || ls->current == set[1]) { ------------------ | Branch (206:7): [True: 108, False: 1.40M] | Branch (206:32): [True: 667, False: 1.40M] ------------------ 207| 775| save_and_next(ls); ------------------ | | 51| 775|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 775|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 775|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 775|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 775|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 775, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 208| 775| return 1; 209| 775| } 210| 1.40M| else return 0; 211| 1.40M|} luaM_growaux_: 98| 53.5M| int size_elems, int limit, const char *what) { 99| 53.5M| void *newblock; 100| 53.5M| int size = *psize; 101| 53.5M| if (nelems + 1 <= size) /* does one extra element still fit? */ ------------------ | Branch (101:7): [True: 53.5M, False: 37.6k] ------------------ 102| 53.5M| return block; /* nothing to be done */ 103| 37.6k| if (size >= limit / 2) { /* cannot double it? */ ------------------ | Branch (103:7): [True: 0, False: 37.6k] ------------------ 104| 0| if (l_unlikely(size >= limit)) /* cannot grow even a little? */ ------------------ | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685: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| 37.6k| else { 109| 37.6k| size *= 2; 110| 37.6k| if (size < MINSIZEARRAY) ------------------ | | 94| 37.6k|#define MINSIZEARRAY 4 ------------------ | Branch (110:9): [True: 15.2k, False: 22.3k] ------------------ 111| 15.2k| size = MINSIZEARRAY; /* minimum size */ ------------------ | | 94| 15.2k|#define MINSIZEARRAY 4 ------------------ 112| 37.6k| } 113| 37.6k| lua_assert(nelems + 1 <= size && size <= limit); ------------------ | | 106| 37.6k|#define lua_assert(c) assert(c) ------------------ 114| | /* 'limit' ensures that multiplication will not overflow */ 115| 37.6k| newblock = luaM_saferealloc_(L, block, cast_sizet(*psize) * size_elems, ------------------ | | 147| 37.6k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 37.6k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 116| 37.6k| cast_sizet(size) * size_elems); ------------------ | | 147| 37.6k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 37.6k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 117| 37.6k| *psize = size; /* update only when everything else is OK */ 118| 37.6k| return newblock; 119| 37.6k|} luaM_shrinkvector_: 129| 19.1k| int final_n, int size_elem) { 130| 19.1k| void *newblock; 131| 19.1k| size_t oldsize = cast_sizet((*size) * size_elem); ------------------ | | 147| 19.1k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 19.1k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 132| 19.1k| size_t newsize = cast_sizet(final_n * size_elem); ------------------ | | 147| 19.1k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 19.1k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 133| 19.1k| lua_assert(newsize <= oldsize); ------------------ | | 106| 19.1k|#define lua_assert(c) assert(c) ------------------ 134| 19.1k| newblock = luaM_saferealloc_(L, block, oldsize, newsize); 135| 19.1k| *size = final_n; 136| 19.1k| return newblock; 137| 19.1k|} luaM_free_: 150| 1.43M|void luaM_free_ (lua_State *L, void *block, size_t osize) { 151| 1.43M| global_State *g = G(L); ------------------ | | 335| 1.43M|#define G(L) (L->l_G) ------------------ 152| 1.43M| lua_assert((osize == 0) == (block == NULL)); ------------------ | | 106| 1.43M|#define lua_assert(c) assert(c) ------------------ 153| 1.43M| callfrealloc(g, block, osize, 0); ------------------ | | 47| 1.43M|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) ------------------ 154| 1.43M| g->GCdebt -= osize; 155| 1.43M|} luaM_realloc_: 176| 65.0k|void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) { 177| 65.0k| void *newblock; 178| 65.0k| global_State *g = G(L); ------------------ | | 335| 65.0k|#define G(L) (L->l_G) ------------------ 179| 65.0k| lua_assert((osize == 0) == (block == NULL)); ------------------ | | 106| 65.0k|#define lua_assert(c) assert(c) ------------------ 180| 65.0k| newblock = firsttry(g, block, osize, nsize); ------------------ | | 76| 65.0k|#define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns) | | ------------------ | | | | 47| 65.0k|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) | | ------------------ ------------------ 181| 65.0k| if (l_unlikely(newblock == NULL && nsize > 0)) { ------------------ | | 697| 65.0k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 72.9k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 65.0k] | | | | | Branch (685:46): [True: 7.93k, False: 57.0k] | | | | | Branch (685:46): [True: 0, False: 7.93k] | | | | ------------------ | | ------------------ ------------------ 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| 65.0k| lua_assert((nsize == 0) == (newblock == NULL)); ------------------ | | 106| 65.0k|#define lua_assert(c) assert(c) ------------------ 187| 65.0k| g->GCdebt = (g->GCdebt + nsize) - osize; 188| 65.0k| return newblock; 189| 65.0k|} luaM_saferealloc_: 193| 58.3k| size_t nsize) { 194| 58.3k| void *newblock = luaM_realloc_(L, block, osize, nsize); 195| 58.3k| if (l_unlikely(newblock == NULL && nsize > 0)) /* allocation failed? */ ------------------ | | 697| 58.3k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 65.0k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 58.3k] | | | | | Branch (685:46): [True: 6.70k, False: 51.6k] | | | | | Branch (685:46): [True: 0, False: 6.70k] | | | | ------------------ | | ------------------ ------------------ 196| 0| luaM_error(L); ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 52| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 197| 58.3k| return newblock; 198| 58.3k|} luaM_malloc_: 201| 1.41M|void *luaM_malloc_ (lua_State *L, size_t size, int tag) { 202| 1.41M| if (size == 0) ------------------ | Branch (202:7): [True: 0, False: 1.41M] ------------------ 203| 0| return NULL; /* that's all */ 204| 1.41M| else { 205| 1.41M| global_State *g = G(L); ------------------ | | 335| 1.41M|#define G(L) (L->l_G) ------------------ 206| 1.41M| void *newblock = firsttry(g, NULL, tag, size); ------------------ | | 76| 1.41M|#define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns) | | ------------------ | | | | 47| 1.41M|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) | | ------------------ ------------------ 207| 1.41M| if (l_unlikely(newblock == NULL)) { ------------------ | | 697| 1.41M|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 1.41M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 1.41M] | | | | ------------------ | | ------------------ ------------------ 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) | | ------------------ | | | | 52| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 211| 0| } 212| 1.41M| g->GCdebt += size; 213| 1.41M| return newblock; 214| 1.41M| } 215| 1.41M|} luaO_ceillog2: 35| 58.3k|int luaO_ceillog2 (unsigned int x) { 36| 58.3k| static const lu_byte log_2[256] = { /* log_2[i] = ceil(log2(i - 1)) */ 37| 58.3k| 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| 58.3k| 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| 58.3k| 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| 58.3k| 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| 58.3k| 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| 58.3k| 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| 58.3k| 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| 58.3k| 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| 58.3k| }; 46| 58.3k| int l = 0; 47| 58.3k| x--; 48| 164k| while (x >= 256) { l += 8; x >>= 8; } ------------------ | Branch (48:10): [True: 106k, False: 58.3k] ------------------ 49| 58.3k| return l + log_2[x]; 50| 58.3k|} luaO_rawarith: 90| 84.7k| TValue *res) { 91| 84.7k| switch (op) { 92| 2.47k| case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 222| 1.32k|#define LUA_OPBAND 7 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 223| 1.34k|#define LUA_OPBOR 8 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 224| 2.47k|#define LUA_OPBXOR 9 ------------------ | Branch (92:5): [True: 1.32k, False: 83.4k] | Branch (92:22): [True: 18, False: 84.7k] | Branch (92:38): [True: 1.13k, False: 83.6k] ------------------ 93| 2.56k| case LUA_OPSHL: case LUA_OPSHR: ------------------ | | 225| 2.48k|#define LUA_OPSHL 10 ------------------ case LUA_OPSHL: case LUA_OPSHR: ------------------ | | 226| 2.56k|#define LUA_OPSHR 11 ------------------ | Branch (93:5): [True: 6, False: 84.7k] | Branch (93:21): [True: 79, False: 84.6k] ------------------ 94| 25.3k| case LUA_OPBNOT: { /* operate only on integers */ ------------------ | | 228| 25.3k|#define LUA_OPBNOT 13 ------------------ | Branch (94:5): [True: 22.8k, False: 61.9k] ------------------ 95| 25.3k| lua_Integer i1; lua_Integer i2; 96| 25.3k| if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) { ------------------ | | 69| 50.7k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 696| 25.3k|#define l_likely(x) luai_likely(x) | | | | ------------------ | | | | | | 684| 25.3k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | ------------------ | | | | | | | Branch (684:25): [True: 22.2k, False: 3.07k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 333| 22.2k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 110| 22.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 22.2k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (69:3): [True: 25.3k, False: 0] | | ------------------ | | 70| 50.7k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | ------------------ | | | | 36| 3.07k|#define LUA_FLOORN2I F2Ieq | | ------------------ ------------------ if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) { ------------------ | | 69| 25.3k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 696| 25.3k|#define l_likely(x) luai_likely(x) | | | | ------------------ | | | | | | 684| 25.3k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | ------------------ | | | | | | | Branch (684:25): [True: 25.1k, False: 186] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 333| 25.1k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 110| 25.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 25.1k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (69:3): [True: 25.3k, False: 0] | | ------------------ | | 70| 25.3k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | ------------------ | | | | 36| 186|#define LUA_FLOORN2I F2Ieq | | ------------------ ------------------ 97| 25.3k| setivalue(res, intarith(L, op, i1, i2)); ------------------ | | 345| 25.3k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 25.3k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 25.3k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 98| 25.3k| return 1; 99| 25.3k| } 100| 0| else return 0; /* fail */ 101| 25.3k| } 102| 43.6k| case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */ ------------------ | | 220| 140|#define LUA_OPDIV 5 ------------------ case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */ ------------------ | | 219| 43.6k|#define LUA_OPPOW 4 ------------------ | Branch (102:5): [True: 140, False: 84.6k] | Branch (102:21): [True: 43.5k, False: 41.1k] ------------------ 103| 43.6k| lua_Number n1; lua_Number n2; 104| 43.6k| if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 87.3k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 43.6k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 43.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 43.6k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 6.69k, False: 36.9k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 6.69k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 110| 6.69k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 6.69k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 43.6k, False: 0] | | ------------------ | | 58| 87.3k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 36.9k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 36.9k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 36.9k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 36.9k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 140| 36.9k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 147k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (136:27): [True: 0, False: 36.9k] | | | | | | | Branch (136:27): [True: 36.9k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 43.6k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 43.6k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 43.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 43.6k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 12.4k, False: 31.2k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 12.4k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 110| 12.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 12.4k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 43.6k, False: 0] | | ------------------ | | 58| 43.6k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 31.2k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 31.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 31.2k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 31.2k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 140| 31.2k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 125k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (136:27): [True: 0, False: 31.2k] | | | | | | | Branch (136:27): [True: 31.2k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 105| 43.6k| setfltvalue(res, numarith(L, op, n1, n2)); ------------------ | | 339| 43.6k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 43.6k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 43.6k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 106| 43.6k| return 1; 107| 43.6k| } 108| 0| else return 0; /* fail */ 109| 43.6k| } 110| 15.6k| default: { /* other operations */ ------------------ | Branch (110:5): [True: 15.6k, False: 69.0k] ------------------ 111| 15.6k| lua_Number n1; lua_Number n2; 112| 15.6k| if (ttisinteger(p1) && ttisinteger(p2)) { ------------------ | | 328| 15.6k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 31.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 15.6k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 11.2k, False: 4.44k] | | | | ------------------ | | ------------------ ------------------ if (ttisinteger(p1) && ttisinteger(p2)) { ------------------ | | 328| 11.2k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 11.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 11.2k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 9.92k, False: 1.31k] | | | | ------------------ | | ------------------ ------------------ 113| 9.92k| setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2))); ------------------ | | 345| 79.3k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 9.92k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 9.92k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | | Branch (345:35): [True: 0, False: 9.92k] | | | Branch (345:35): [True: 9.92k, False: 0] | | | Branch (345:35): [True: 0, False: 9.92k] | | | Branch (345:35): [True: 9.92k, False: 0] | | ------------------ ------------------ 114| 9.92k| return 1; 115| 9.92k| } 116| 5.75k| else if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 11.5k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 5.75k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 5.75k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 5.75k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 4.44k, False: 1.31k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 4.44k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 110| 4.44k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 4.44k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 5.75k, False: 0] | | ------------------ | | 58| 11.5k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 1.31k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 1.31k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 1.31k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 1.31k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 140| 1.31k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 5.24k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (136:27): [True: 0, False: 1.31k] | | | | | | | Branch (136:27): [True: 1.31k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ else if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 5.75k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 5.75k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 5.75k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 5.75k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 2.19k, False: 3.55k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 2.19k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 110| 2.19k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 2.19k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 5.75k, False: 0] | | ------------------ | | 58| 5.75k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 3.55k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 3.55k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 3.55k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 3.55k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 140| 3.55k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 14.2k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (136:27): [True: 0, False: 3.55k] | | | | | | | Branch (136:27): [True: 3.55k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 117| 5.75k| setfltvalue(res, numarith(L, op, n1, n2)); ------------------ | | 339| 5.75k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 5.75k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 5.75k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 118| 5.75k| return 1; 119| 5.75k| } 120| 0| else return 0; /* fail */ 121| 15.6k| } 122| 84.7k| } 123| 84.7k|} luaO_hexavalue: 135| 38.9k|int luaO_hexavalue (int c) { 136| 38.9k| if (lisdigit(c)) return c - '0'; ------------------ | | 59| 38.9k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 38.9k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 30.4k, False: 8.47k] | | | | ------------------ | | ------------------ ------------------ 137| 8.47k| else return (ltolower(c) - 'a') + 10; ------------------ | | 72| 8.47k| check_exp(('A' <= (c) && (c) <= 'Z') || (c) == ((c) | ('A' ^ 'a')), \ | | ------------------ | | | | 110| 8.47k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 8.47k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ | | 73| 8.47k| (c) | ('A' ^ 'a')) ------------------ 138| 38.9k|} luaO_str2num: 308| 146k|size_t luaO_str2num (const char *s, TValue *o) { 309| 146k| lua_Integer i; lua_Number n; 310| 146k| const char *e; 311| 146k| if ((e = l_str2int(s, &i)) != NULL) { /* try as an integer */ ------------------ | Branch (311:7): [True: 129k, False: 17.2k] ------------------ 312| 129k| setivalue(o, i); ------------------ | | 345| 129k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 129k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 129k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 313| 129k| } 314| 17.2k| else if ((e = l_str2d(s, &n)) != NULL) { /* else try as a float */ ------------------ | Branch (314:12): [True: 17.2k, False: 28] ------------------ 315| 17.2k| setfltvalue(o, n); ------------------ | | 339| 17.2k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 17.2k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 17.2k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 316| 17.2k| } 317| 28| else 318| 28| return 0; /* conversion failed */ 319| 146k| return (e - s) + 1; /* success; return string size */ 320| 146k|} luaO_utf8esc: 323| 6.47k|int luaO_utf8esc (char *buff, unsigned long x) { 324| 6.47k| int n = 1; /* number of bytes put in buffer (backwards) */ 325| 6.47k| lua_assert(x <= 0x7FFFFFFFu); ------------------ | | 106| 6.47k|#define lua_assert(c) assert(c) ------------------ 326| 6.47k| if (x < 0x80) /* ascii? */ ------------------ | Branch (326:7): [True: 272, False: 6.20k] ------------------ 327| 272| buff[UTF8BUFFSZ - 1] = cast_char(x); ------------------ | | 795| 272|#define UTF8BUFFSZ 8 ------------------ buff[UTF8BUFFSZ - 1] = cast_char(x); ------------------ | | 145| 272|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 136| 272|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 328| 6.20k| else { /* need continuation bytes */ 329| 6.20k| unsigned int mfb = 0x3f; /* maximum that fits in first byte */ 330| 24.2k| do { /* add continuation bytes */ 331| 24.2k| buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f)); ------------------ | | 795| 24.2k|#define UTF8BUFFSZ 8 ------------------ buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f)); ------------------ | | 145| 24.2k|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 136| 24.2k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 332| 24.2k| x >>= 6; /* remove added bits */ 333| 24.2k| mfb >>= 1; /* now there is one less bit available in first byte */ 334| 24.2k| } while (x > mfb); /* still needs continuation byte? */ ------------------ | Branch (334:14): [True: 18.0k, False: 6.20k] ------------------ 335| 6.20k| buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x); /* add first byte */ ------------------ | | 795| 6.20k|#define UTF8BUFFSZ 8 ------------------ buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x); /* add first byte */ ------------------ | | 145| 6.20k|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 136| 6.20k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 336| 6.20k| } 337| 6.47k| return n; 338| 6.47k|} luaO_tostring: 374| 113k|void luaO_tostring (lua_State *L, TValue *obj) { 375| 113k| char buff[MAXNUMBER2STR]; 376| 113k| int len = tostringbuff(obj, buff); 377| 113k| setsvalue(L, obj, luaS_newlstr(L, buff, len)); ------------------ | | 372| 113k| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 113k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 113k|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 113k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 113k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 113k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 113k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 113k| checkliveness(L,io); } | | ------------------ | | | | 107| 113k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 1.81M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 113k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 113k] | | | | | | | Branch (112:29): [True: 113k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 113k] | | | | | | | Branch (112:29): [True: 113k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 113k] | | | | | | | Branch (112:29): [True: 113k, False: 0] | | | | | | | Branch (112:29): [True: 113k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 113k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 113k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 378| 113k|} luaO_pushvfstring: 480| 728|const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) { 481| 728| BuffFS buff; /* holds last part of the result */ 482| 728| const char *e; /* points to next '%' */ 483| 728| buff.pushed = buff.blen = 0; 484| 728| buff.L = L; 485| 2.22k| while ((e = strchr(fmt, '%')) != NULL) { ------------------ | Branch (485:10): [True: 1.50k, False: 728] ------------------ 486| 1.50k| addstr2buff(&buff, fmt, e - fmt); /* add 'fmt' up to '%' */ 487| 1.50k| switch (*(e + 1)) { /* conversion specifier */ 488| 1.12k| case 's': { /* zero-terminated string */ ------------------ | Branch (488:7): [True: 1.12k, False: 372] ------------------ 489| 1.12k| const char *s = va_arg(argp, char *); 490| 1.12k| if (s == NULL) s = "(null)"; ------------------ | Branch (490:13): [True: 0, False: 1.12k] ------------------ 491| 1.12k| addstr2buff(&buff, s, strlen(s)); 492| 1.12k| break; 493| 0| } 494| 65| case 'c': { /* an 'int' as a character */ ------------------ | Branch (494:7): [True: 65, False: 1.43k] ------------------ 495| 65| char c = cast_uchar(va_arg(argp, int)); ------------------ | | 144| 65|#define cast_uchar(i) cast(unsigned char, (i)) | | ------------------ | | | | 136| 65|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 496| 65| addstr2buff(&buff, &c, sizeof(char)); 497| 65| break; 498| 0| } 499| 306| case 'd': { /* an 'int' */ ------------------ | Branch (499:7): [True: 306, False: 1.19k] ------------------ 500| 306| TValue num; 501| 306| setivalue(&num, va_arg(argp, int)); ------------------ | | 345| 306| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 306|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 306|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 502| 306| addnum2buff(&buff, &num); 503| 306| break; 504| 0| } 505| 0| case 'I': { /* a 'lua_Integer' */ ------------------ | Branch (505:7): [True: 0, False: 1.50k] ------------------ 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.50k] ------------------ 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.50k] ------------------ 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); ------------------ | | 618| 0|#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p) | | ------------------ | | | | 597| 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.50k] ------------------ 526| 0| char bf[UTF8BUFFSZ]; 527| 0| int len = luaO_utf8esc(bf, va_arg(argp, long)); 528| 0| addstr2buff(&buff, bf + UTF8BUFFSZ - len, len); ------------------ | | 795| 0|#define UTF8BUFFSZ 8 ------------------ 529| 0| break; 530| 0| } 531| 1| case '%': { ------------------ | Branch (531:7): [True: 1, False: 1.50k] ------------------ 532| 1| addstr2buff(&buff, "%", 1); 533| 1| break; 534| 0| } 535| 0| default: { ------------------ | Branch (535:7): [True: 0, False: 1.50k] ------------------ 536| 0| luaG_runerror(L, "invalid option '%%%c' to 'lua_pushfstring'", 537| 0| *(e + 1)); 538| 0| } 539| 1.50k| } 540| 1.50k| fmt = e + 2; /* skip '%' and the specifier */ 541| 1.50k| } 542| 728| addstr2buff(&buff, fmt, strlen(fmt)); /* rest of 'fmt' */ 543| 728| clearbuff(&buff); /* empty buffer into the stack */ 544| 728| lua_assert(buff.pushed == 1); ------------------ | | 106| 728|#define lua_assert(c) assert(c) ------------------ 545| 728| return getstr(tsvalue(s2v(L->top.p - 1))); ------------------ | | 404| 5.82k|#define getstr(ts) ((ts)->contents) | | ------------------ | | | Branch (404:22): [True: 0, False: 728] | | | Branch (404:22): [True: 728, False: 0] | | | Branch (404:22): [True: 0, False: 728] | | | Branch (404:22): [True: 728, False: 0] | | ------------------ ------------------ 546| 728|} luaO_pushfstring: 549| 646|const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) { 550| 646| const char *msg; 551| 646| va_list argp; 552| 646| va_start(argp, fmt); 553| 646| msg = luaO_pushvfstring(L, fmt, argp); 554| 646| va_end(argp); 555| 646| return msg; 556| 646|} luaO_chunkid: 567| 258|void luaO_chunkid (char *out, const char *source, size_t srclen) { 568| 258| size_t bufflen = LUA_IDSIZE; /* free space in buffer */ ------------------ | | 768| 258|#define LUA_IDSIZE 60 ------------------ 569| 258| if (*source == '=') { /* 'literal' source */ ------------------ | Branch (569:7): [True: 0, False: 258] ------------------ 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| 258| else if (*source == '@') { /* file name */ ------------------ | Branch (577:12): [True: 0, False: 258] ------------------ 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| 258| else { /* string; format as [string "source"] */ 587| 258| const char *nl = strchr(source, '\n'); /* find first new line (if any) */ 588| 258| addstr(out, PRE, LL(PRE)); /* add prefix */ ------------------ | | 565| 258|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 589| 258| bufflen -= LL(PRE RETS POS) + 1; /* save space for prefix+suffix+'\0' */ ------------------ | | 70| 258|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 590| 258| if (srclen < bufflen && nl == NULL) { /* small one-line source? */ ------------------ | Branch (590:9): [True: 258, False: 0] | Branch (590:29): [True: 258, False: 0] ------------------ 591| 258| addstr(out, source, srclen); /* keep it */ ------------------ | | 565| 258|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 592| 258| } 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| 258| memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); ------------------ | | 563| 258|#define POS "\"]" ------------------ memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); ------------------ | | 70| 258|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 600| 258| } 601| 258|} lobject.c:intarith: 54| 35.2k| lua_Integer v2) { 55| 35.2k| switch (op) { 56| 678| case LUA_OPADD: return intop(+, v1, v2); ------------------ | | 215| 678|#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ ------------------ case LUA_OPADD: return intop(+, v1, v2); ------------------ | | 73| 678|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 678|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (56:5): [True: 678, False: 34.6k] ------------------ 57| 1.61k| case LUA_OPSUB:return intop(-, v1, v2); ------------------ | | 216| 1.61k|#define LUA_OPSUB 1 ------------------ case LUA_OPSUB:return intop(-, v1, v2); ------------------ | | 73| 1.61k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 1.61k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (57:5): [True: 1.61k, False: 33.6k] ------------------ 58| 1.15k| case LUA_OPMUL:return intop(*, v1, v2); ------------------ | | 217| 1.15k|#define LUA_OPMUL 2 ------------------ case LUA_OPMUL: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 (58:5): [True: 1.15k, False: 34.1k] ------------------ 59| 2.60k| case LUA_OPMOD: return luaV_mod(L, v1, v2); ------------------ | | 218| 2.60k|#define LUA_OPMOD 3 ------------------ | Branch (59:5): [True: 2.60k, False: 32.6k] ------------------ 60| 33| case LUA_OPIDIV: return luaV_idiv(L, v1, v2); ------------------ | | 221| 33|#define LUA_OPIDIV 6 ------------------ | Branch (60:5): [True: 33, False: 35.2k] ------------------ 61| 1.32k| case LUA_OPBAND: return intop(&, v1, v2); ------------------ | | 222| 1.32k|#define LUA_OPBAND 7 ------------------ case LUA_OPBAND: return intop(&, v1, v2); ------------------ | | 73| 1.32k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 1.32k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (61:5): [True: 1.32k, False: 33.9k] ------------------ 62| 18| case LUA_OPBOR: return intop(|, v1, v2); ------------------ | | 223| 18|#define LUA_OPBOR 8 ------------------ case LUA_OPBOR: return intop(|, v1, v2); ------------------ | | 73| 18|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 18|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (62:5): [True: 18, False: 35.2k] ------------------ 63| 1.13k| case LUA_OPBXOR: return intop(^, v1, v2); ------------------ | | 224| 1.13k|#define LUA_OPBXOR 9 ------------------ case LUA_OPBXOR: return intop(^, v1, v2); ------------------ | | 73| 1.13k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 1.13k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (63:5): [True: 1.13k, False: 34.1k] ------------------ 64| 6| case LUA_OPSHL: return luaV_shiftl(v1, v2); ------------------ | | 225| 6|#define LUA_OPSHL 10 ------------------ | Branch (64:5): [True: 6, False: 35.2k] ------------------ 65| 79| case LUA_OPSHR: return luaV_shiftr(v1, v2); ------------------ | | 226| 79|#define LUA_OPSHR 11 ------------------ case LUA_OPSHR: return luaV_shiftr(v1, v2); ------------------ | | 116| 79|#define luaV_shiftr(x,y) luaV_shiftl(x,intop(-, 0, y)) | | ------------------ | | | | 73| 79|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | | | ------------------ | | | | | | 161| 79|#define l_castU2S(i) ((lua_Integer)(i)) | | | | ------------------ | | ------------------ ------------------ | Branch (65:5): [True: 79, False: 35.2k] ------------------ 66| 3.83k| case LUA_OPUNM: return intop(-, 0, v1); ------------------ | | 227| 3.83k|#define LUA_OPUNM 12 ------------------ case LUA_OPUNM: return intop(-, 0, v1); ------------------ | | 73| 3.83k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 3.83k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (66:5): [True: 3.83k, False: 31.4k] ------------------ 67| 22.8k| case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1); ------------------ | | 228| 22.8k|#define LUA_OPBNOT 13 ------------------ case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1); ------------------ | | 73| 22.8k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 22.8k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (67:5): [True: 22.8k, False: 12.4k] ------------------ 68| 0| default: lua_assert(0); return 0; ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ | Branch (68:5): [True: 0, False: 35.2k] ------------------ 69| 35.2k| } 70| 35.2k|} lobject.c:numarith: 74| 49.4k| lua_Number v2) { 75| 49.4k| switch (op) { 76| 364| case LUA_OPADD: return luai_numadd(L, v1, v2); ------------------ | | 215| 364|#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ ------------------ case LUA_OPADD: return luai_numadd(L, v1, v2); ------------------ | | 346| 364|#define luai_numadd(L,a,b) ((a)+(b)) ------------------ | Branch (76:5): [True: 364, False: 49.0k] ------------------ 77| 978| case LUA_OPSUB: return luai_numsub(L, v1, v2); ------------------ | | 216| 978|#define LUA_OPSUB 1 ------------------ case LUA_OPSUB: return luai_numsub(L, v1, v2); ------------------ | | 347| 978|#define luai_numsub(L,a,b) ((a)-(b)) ------------------ | Branch (77:5): [True: 978, False: 48.4k] ------------------ 78| 1.28k| case LUA_OPMUL: return luai_nummul(L, v1, v2); ------------------ | | 217| 1.28k|#define LUA_OPMUL 2 ------------------ case LUA_OPMUL: return luai_nummul(L, v1, v2); ------------------ | | 348| 1.28k|#define luai_nummul(L,a,b) ((a)*(b)) ------------------ | Branch (78:5): [True: 1.28k, False: 48.1k] ------------------ 79| 140| case LUA_OPDIV: return luai_numdiv(L, v1, v2); ------------------ | | 220| 140|#define LUA_OPDIV 5 ------------------ case LUA_OPDIV: return luai_numdiv(L, v1, v2); ------------------ | | 318| 140|#define luai_numdiv(L,a,b) ((a)/(b)) ------------------ | Branch (79:5): [True: 140, False: 49.3k] ------------------ 80| 43.5k| case LUA_OPPOW: return luai_numpow(L, v1, v2); ------------------ | | 219| 43.5k|#define LUA_OPPOW 4 ------------------ case LUA_OPPOW: return luai_numpow(L, v1, v2); ------------------ | | 341| 43.5k| ((void)L, (b == 2) ? (a)*(a) : l_mathop(pow)(a,b)) | | ------------------ | | | | 482| 35.0k|#define l_mathop(op) op | | ------------------ | | | Branch (341:13): [True: 8.54k, False: 35.0k] | | ------------------ ------------------ | Branch (80:5): [True: 43.5k, False: 5.89k] ------------------ 81| 10| case LUA_OPIDIV: return luai_numidiv(L, v1, v2); ------------------ | | 221| 10|#define LUA_OPIDIV 6 ------------------ case LUA_OPIDIV: return luai_numidiv(L, v1, v2); ------------------ | | 313| 10|#define luai_numidiv(L,a,b) ((void)L, l_floor(luai_numdiv(L,a,b))) | | ------------------ | | | | 418| 10|#define l_floor(x) (l_mathop(floor)(x)) | | | | ------------------ | | | | | | 482| 10|#define l_mathop(op) op | | | | ------------------ | | ------------------ ------------------ | Branch (81:5): [True: 10, False: 49.4k] ------------------ 82| 2.06k| case LUA_OPUNM: return luai_numunm(L, v1); ------------------ | | 227| 2.06k|#define LUA_OPUNM 12 ------------------ case LUA_OPUNM: return luai_numunm(L, v1); ------------------ | | 349| 2.06k|#define luai_numunm(L,a) (-(a)) ------------------ | Branch (82:5): [True: 2.06k, False: 47.3k] ------------------ 83| 1.05k| case LUA_OPMOD: return luaV_modf(L, v1, v2); ------------------ | | 218| 1.05k|#define LUA_OPMOD 3 ------------------ | Branch (83:5): [True: 1.05k, False: 48.3k] ------------------ 84| 0| default: lua_assert(0); return 0; ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ | Branch (84:5): [True: 0, False: 49.4k] ------------------ 85| 49.4k| } 86| 49.4k|} lobject.c:l_str2int: 276| 146k|static const char *l_str2int (const char *s, lua_Integer *result) { 277| 146k| lua_Unsigned a = 0; 278| 146k| int empty = 1; 279| 146k| int neg; 280| 146k| while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */ 281| 146k| neg = isneg(&s); 282| 146k| if (s[0] == '0' && ------------------ | Branch (282:7): [True: 24.9k, False: 122k] ------------------ 283| 146k| (s[1] == 'x' || s[1] == 'X')) { /* hex? */ ------------------ | Branch (283:8): [True: 3, False: 24.9k] | Branch (283:23): [True: 0, False: 24.9k] ------------------ 284| 3| s += 2; /* skip '0x' */ 285| 25| for (; lisxdigit(cast_uchar(*s)); s++) { 286| 25| a = a * 16 + luaO_hexavalue(*s); 287| 25| empty = 0; 288| 25| } 289| 3| } 290| 146k| else { /* decimal */ 291| 287k| for (; lisdigit(cast_uchar(*s)); s++) { 292| 287k| int d = *s - '0'; 293| 287k| if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 273| 287k|#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) | | ------------------ | | | | 136| 575k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 273| 2.15k|#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) | | ------------------ | | | | 136| 4.31k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 274| 1.51k|#define MAXLASTD cast_int(LUA_MAXINTEGER % 10) | | ------------------ | | | | 141| 1.51k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 1.51k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (293:11): [True: 2.15k, False: 285k] | Branch (293:28): [True: 638, False: 1.51k] | Branch (293:43): [True: 5, False: 1.51k] ------------------ 294| 643| return NULL; /* do not accept it (as integer) */ 295| 287k| a = a * 10 + d; 296| 287k| empty = 0; 297| 287k| } 298| 146k| } 299| 146k| while (lisspace(cast_uchar(*s))) s++; /* skip trailing spaces */ 300| 146k| if (empty || *s != '\0') return NULL; /* something wrong in the numeral */ ------------------ | Branch (300:7): [True: 1.03k, False: 145k] | Branch (300:16): [True: 15.5k, False: 129k] ------------------ 301| 129k| else { 302| 129k| *result = l_castU2S((neg) ? 0u - a : a); ------------------ | | 161| 259k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ | | | Branch (161:37): [True: 0, False: 129k] | | ------------------ ------------------ 303| 129k| return s; 304| 129k| } 305| 146k|} lobject.c:isneg: 141| 146k|static int isneg (const char **s) { 142| 146k| if (**s == '-') { (*s)++; return 1; } ------------------ | Branch (142:7): [True: 0, False: 146k] ------------------ 143| 146k| else if (**s == '+') (*s)++; ------------------ | Branch (143:12): [True: 0, False: 146k] ------------------ 144| 146k| return 0; 145| 146k|} lobject.c:l_str2d: 251| 17.2k|static const char *l_str2d (const char *s, lua_Number *result) { 252| 17.2k| const char *endptr; 253| 17.2k| const char *pmode = strpbrk(s, ".xXnN"); /* look for special chars */ 254| 17.2k| int mode = pmode ? ltolower(cast_uchar(*pmode)) : 0; ------------------ | | 72| 15.8k| check_exp(('A' <= (c) && (c) <= 'Z') || (c) == ((c) | ('A' ^ 'a')), \ | | ------------------ | | | | 110| 15.8k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 15.8k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ | | 73| 17.2k| (c) | ('A' ^ 'a')) ------------------ | Branch (254:14): [True: 15.8k, False: 1.42k] ------------------ 255| 17.2k| if (mode == 'n') /* reject 'inf' and 'nan' */ ------------------ | Branch (255:7): [True: 15, False: 17.2k] ------------------ 256| 15| return NULL; 257| 17.2k| endptr = l_str2dloc(s, result, mode); /* try to convert */ 258| 17.2k| if (endptr == NULL) { /* failed? may be a different locale */ ------------------ | Branch (258:7): [True: 13, False: 17.2k] ------------------ 259| 13| char buff[L_MAXLENNUM + 1]; 260| 13| const char *pdot = strchr(s, '.'); 261| 13| if (pdot == NULL || strlen(s) > L_MAXLENNUM) ------------------ | | 220| 5|#define L_MAXLENNUM 200 ------------------ | Branch (261:9): [True: 8, False: 5] | Branch (261:25): [True: 5, False: 0] ------------------ 262| 13| return NULL; /* string too long or no dot; fail */ 263| 0| strcpy(buff, s); /* copy string to buffer */ 264| 0| buff[pdot - s] = lua_getlocaledecpoint(); /* correct decimal point */ ------------------ | | 671| 0|#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) ------------------ 265| 0| endptr = l_str2dloc(buff, result, mode); /* try again */ 266| 0| if (endptr != NULL) ------------------ | Branch (266:9): [True: 0, False: 0] ------------------ 267| 0| endptr = s + (endptr - buff); /* make relative to 's' */ 268| 0| } 269| 17.2k| return endptr; 270| 17.2k|} lobject.c:l_str2dloc: 228| 17.2k|static const char *l_str2dloc (const char *s, lua_Number *result, int mode) { 229| 17.2k| char *endptr; 230| | *result = (mode == 'x') ? lua_strx2number(s, &endptr) /* try to convert */ ------------------ | | 610| 0|#define lua_strx2number(s,p) lua_str2number(s,p) | | ------------------ | | | | 484| 0|#define lua_str2number(s,p) strtod((s), (p)) | | ------------------ ------------------ | Branch (230:13): [True: 0, False: 17.2k] ------------------ 231| 17.2k| : lua_str2number(s, &endptr); ------------------ | | 484| 34.4k|#define lua_str2number(s,p) strtod((s), (p)) ------------------ 232| 17.2k| if (endptr == s) return NULL; /* nothing recognized? */ ------------------ | Branch (232:7): [True: 4, False: 17.2k] ------------------ 233| 17.2k| while (lisspace(cast_uchar(*endptr))) endptr++; /* skip trailing spaces */ 234| 17.2k| return (*endptr == '\0') ? endptr : NULL; /* OK iff no trailing chars */ ------------------ | Branch (234:10): [True: 17.2k, False: 9] ------------------ 235| 17.2k|} lobject.c:tostringbuff: 355| 113k|static int tostringbuff (TValue *obj, char *buff) { 356| 113k| int len; 357| 113k| lua_assert(ttisnumber(obj)); ------------------ | | 106| 113k|#define lua_assert(c) assert(c) ------------------ 358| 113k| if (ttisinteger(obj)) ------------------ | | 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: 112k, False: 869] | | | | ------------------ | | ------------------ ------------------ 359| 112k| len = lua_integer2str(buff, MAXNUMBER2STR, ivalue(obj)); ------------------ | | 514| 112k| l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) | | ------------------ | | | | 597| 451k|#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) | | | | ------------------ | | | | | Branch (597:45): [True: 0, False: 112k] | | | | | Branch (597:45): [True: 112k, False: 0] | | | | ------------------ | | ------------------ ------------------ 360| 869| else { 361| 869| len = lua_number2str(buff, MAXNUMBER2STR, fltvalue(obj)); ------------------ | | 421| 869| l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) | | ------------------ | | | | 597| 3.47k|#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) | | | | ------------------ | | | | | Branch (597:45): [True: 0, False: 869] | | | | | Branch (597:45): [True: 869, False: 0] | | | | ------------------ | | ------------------ ------------------ 362| 869| if (buff[strspn(buff, "-0123456789")] == '\0') { /* looks like an int? */ ------------------ | Branch (362:9): [True: 579, False: 290] ------------------ 363| 579| buff[len++] = lua_getlocaledecpoint(); ------------------ | | 671| 579|#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) ------------------ 364| 579| buff[len++] = '0'; /* adds '.0' to result */ 365| 579| } 366| 869| } 367| 113k| return len; 368| 113k|} lobject.c:addstr2buff: 453| 3.42k|static void addstr2buff (BuffFS *buff, const char *str, size_t slen) { 454| 3.42k| if (slen <= BUFVFS) { /* does string fit into buffer? */ ------------------ | | 394| 3.42k|#define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 768| 3.42k|#define LUA_IDSIZE 60 | | ------------------ | | #define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 349| 3.42k|#define MAXNUMBER2STR 44 | | ------------------ ------------------ | Branch (454:7): [True: 3.35k, False: 66] ------------------ 455| 3.35k| char *bf = getbuff(buff, cast_int(slen)); ------------------ | | 141| 3.35k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 3.35k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 456| 3.35k| memcpy(bf, str, slen); /* add string to buffer */ 457| 3.35k| addsize(buff, cast_int(slen)); ------------------ | | 446| 3.35k|#define addsize(b,sz) ((b)->blen += (sz)) ------------------ 458| 3.35k| } 459| 66| else { /* string larger than buffer */ 460| 66| clearbuff(buff); /* string comes after buffer's content */ 461| 66| pushstr(buff, str, slen); /* push string */ 462| 66| } 463| 3.42k|} lobject.c:pushstr: 414| 862|static void pushstr (BuffFS *buff, const char *str, size_t lstr) { 415| 862| lua_State *L = buff->L; 416| 862| setsvalue2s(L, L->top.p, luaS_newlstr(L, str, lstr)); ------------------ | | 377| 862|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 862| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 862| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 862|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 862|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 862|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 862|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 862|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 862| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 862| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 13.7k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 862|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 862] | | | | | | | | | Branch (112:29): [True: 862, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 862] | | | | | | | | | Branch (112:29): [True: 862, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 862] | | | | | | | | | Branch (112:29): [True: 862, False: 0] | | | | | | | | | Branch (112:29): [True: 862, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 862] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 862| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 417| 862| L->top.p++; /* may use one slot from EXTRA_STACK */ 418| 862| if (!buff->pushed) /* no previous string on the stack? */ ------------------ | Branch (418:7): [True: 728, False: 134] ------------------ 419| 728| buff->pushed = 1; /* now there is one */ 420| 134| else /* join previous string with new one */ 421| 134| luaV_concat(L, 2); 422| 862|} lobject.c:addnum2buff: 469| 306|static void addnum2buff (BuffFS *buff, TValue *num) { 470| 306| char *numbuff = getbuff(buff, MAXNUMBER2STR); ------------------ | | 349| 306|#define MAXNUMBER2STR 44 ------------------ 471| 306| int len = tostringbuff(num, numbuff); /* format number into 'numbuff' */ 472| 306| addsize(buff, len); ------------------ | | 446| 306|#define addsize(b,sz) ((b)->blen += (sz)) ------------------ 473| 306|} lobject.c:getbuff: 438| 3.66k|static char *getbuff (BuffFS *buff, int sz) { 439| 3.66k| lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS); ------------------ | | 106| 3.66k|#define lua_assert(c) assert(c) ------------------ lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS); ------------------ | | 106| 3.66k|#define lua_assert(c) assert(c) ------------------ 440| 3.66k| if (sz > BUFVFS - buff->blen) /* not enough space? */ ------------------ | | 394| 3.66k|#define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 768| 3.66k|#define LUA_IDSIZE 60 | | ------------------ | | #define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 349| 3.66k|#define MAXNUMBER2STR 44 | | ------------------ ------------------ | Branch (440:7): [True: 2, False: 3.66k] ------------------ 441| 2| clearbuff(buff); 442| 3.66k| return buff->space + buff->blen; 443| 3.66k|} lobject.c:clearbuff: 428| 796|static void clearbuff (BuffFS *buff) { 429| 796| pushstr(buff, buff->space, buff->blen); /* push buffer contents */ 430| 796| buff->blen = 0; /* space now is empty */ 431| 796|} luaY_nvarstack: 243| 14.4M|int luaY_nvarstack (FuncState *fs) { 244| 14.4M| return reglevel(fs, fs->nactvar); 245| 14.4M|} luaY_parser: 1943| 225| Dyndata *dyd, const char *name, int firstchar) { 1944| 225| LexState lexstate; 1945| 225| FuncState funcstate; 1946| 225| LClosure *cl = luaF_newLclosure(L, 1); /* create main closure */ 1947| 225| setclLvalue2s(L, L->top.p, cl); /* anchor it (to avoid being collected) */ ------------------ | | 613| 225|#define setclLvalue2s(L,o,cl) setclLvalue(L,s2v(o),cl) | | ------------------ | | | | 609| 225| { TValue *io = (obj); LClosure *x_ = (x); \ | | | | 610| 225| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 72| 225|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 390| 225|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 225|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 114| 225|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 611| 225| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 225| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 3.60k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 225| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1948| 225| luaD_inctop(L); 1949| 225| lexstate.h = luaH_new(L); /* create table for scanner */ 1950| 225| sethvalue2s(L, L->top.p, lexstate.h); /* anchor it */ ------------------ | | 689| 225|#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) | | ------------------ | | | | 685| 225| { TValue *io = (obj); Table *x_ = (x); \ | | | | 686| 225| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 72| 225|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 390| 225|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 225|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 114| 225|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 687| 225| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 225| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 3.60k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 225| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1951| 225| luaD_inctop(L); 1952| 225| funcstate.f = cl->p = luaF_newproto(L); 1953| 225| luaC_objbarrier(L, cl, cl->p); ------------------ | | 175| 225|#define luaC_objbarrier(L,p,o) ( \ | | 176| 225| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 225|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 225|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 450|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 225] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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| 225| 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 225|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1954| 0| funcstate.f->source = luaS_new(L, name); /* create and anchor TString */ 1955| 225| luaC_objbarrier(L, funcstate.f, funcstate.f->source); ------------------ | | 175| 225|#define luaC_objbarrier(L,p,o) ( \ | | 176| 225| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 225|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 225|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 450|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 225] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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| 225| 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 225|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1956| 0| lexstate.buff = buff; 1957| 225| lexstate.dyd = dyd; 1958| 225| dyd->actvar.n = dyd->gt.n = dyd->label.n = 0; 1959| 225| luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar); 1960| 225| mainfunc(&lexstate, &funcstate); 1961| 225| lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs); ------------------ | | 106| 225|#define lua_assert(c) assert(c) ------------------ 1962| | /* all scopes should be correctly finished */ 1963| 45| lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0); ------------------ | | 106| 45|#define lua_assert(c) assert(c) ------------------ 1964| 45| L->top.p--; /* remove scanner's table */ 1965| 45| return cl; /* closure is on the stack, too */ 1966| 45|} lparser.c:reglevel: 229| 14.5M|static int reglevel (FuncState *fs, int nvar) { 230| 15.1M| while (nvar-- > 0) { ------------------ | Branch (230:10): [True: 5.63M, False: 9.54M] ------------------ 231| 5.63M| Vardesc *vd = getlocalvardesc(fs, nvar); /* get previous variable */ 232| 5.63M| if (vd->vd.kind != RDKCTC) /* is in a register? */ ------------------ | | 93| 5.63M|#define RDKCTC 3 /* compile-time constant */ ------------------ | Branch (232:9): [True: 4.95M, False: 673k] ------------------ 233| 4.95M| return vd->vd.ridx + 1; 234| 5.63M| } 235| 9.54M| return 0; /* no variables in registers */ 236| 14.5M|} lparser.c:getlocalvardesc: 219| 34.4M|static Vardesc *getlocalvardesc (FuncState *fs, int vidx) { 220| 34.4M| return &fs->ls->dyd->actvar.arr[fs->firstlocal + vidx]; 221| 34.4M|} lparser.c:mainfunc: 1924| 225|static void mainfunc (LexState *ls, FuncState *fs) { 1925| 225| BlockCnt bl; 1926| 225| Upvaldesc *env; 1927| 225| open_func(ls, fs, &bl); 1928| 225| setvararg(fs, 0); /* main function is always declared vararg */ 1929| 225| env = allocupvalue(fs); /* ...set environment upvalue */ 1930| 225| env->instack = 1; 1931| 225| env->idx = 0; 1932| 225| env->kind = VDKREG; ------------------ | | 90| 225|#define VDKREG 0 /* regular */ ------------------ 1933| 225| env->name = ls->envn; 1934| 225| luaC_objbarrier(ls->L, fs->f, env->name); ------------------ | | 175| 225|#define luaC_objbarrier(L,p,o) ( \ | | 176| 225| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 225|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 225|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 450|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 225] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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| 225| 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 225|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1935| 0| luaX_next(ls); /* read first token */ 1936| 225| statlist(ls); /* parse main body */ 1937| 225| check(ls, TK_EOS); 1938| 225| close_func(ls); 1939| 225|} lparser.c:open_func: 729| 3.17k|static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) { 730| 3.17k| Proto *f = fs->f; 731| 3.17k| fs->prev = ls->fs; /* linked list of funcstates */ 732| 3.17k| fs->ls = ls; 733| 3.17k| ls->fs = fs; 734| 3.17k| fs->pc = 0; 735| 3.17k| fs->previousline = f->linedefined; 736| 3.17k| fs->iwthabs = 0; 737| 3.17k| fs->lasttarget = 0; 738| 3.17k| fs->freereg = 0; 739| 3.17k| fs->nk = 0; 740| 3.17k| fs->nabslineinfo = 0; 741| 3.17k| fs->np = 0; 742| 3.17k| fs->nups = 0; 743| 3.17k| fs->ndebugvars = 0; 744| 3.17k| fs->nactvar = 0; 745| 3.17k| fs->needclose = 0; 746| 3.17k| fs->firstlocal = ls->dyd->actvar.n; 747| 3.17k| fs->firstlabel = ls->dyd->label.n; 748| 3.17k| fs->bl = NULL; 749| 3.17k| f->source = ls->source; 750| 3.17k| luaC_objbarrier(ls->L, f, f->source); ------------------ | | 175| 3.17k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 3.17k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 3.17k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 3.17k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 6.34k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 3.17k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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| 3.17k| 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 3.17k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 3.17k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 751| 0| f->maxstacksize = 2; /* registers 0/1 are always valid */ 752| 3.17k| enterblock(fs, bl, 0); 753| 3.17k|} lparser.c:enterblock: 642| 12.4k|static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) { 643| 12.4k| bl->isloop = isloop; 644| 12.4k| bl->nactvar = fs->nactvar; 645| 12.4k| bl->firstlabel = fs->ls->dyd->label.n; 646| 12.4k| bl->firstgoto = fs->ls->dyd->gt.n; 647| 12.4k| bl->upval = 0; 648| 12.4k| bl->insidetbc = (fs->bl != NULL && fs->bl->insidetbc); ------------------ | Branch (648:20): [True: 9.28k, False: 3.17k] | Branch (648:38): [True: 74, False: 9.20k] ------------------ 649| 12.4k| bl->previous = fs->bl; 650| 12.4k| fs->bl = bl; 651| 12.4k| lua_assert(fs->freereg == luaY_nvarstack(fs)); ------------------ | | 106| 12.4k|#define lua_assert(c) assert(c) ------------------ 652| 12.4k|} lparser.c:setvararg: 953| 255|static void setvararg (FuncState *fs, int nparams) { 954| 255| fs->f->is_vararg = 1; 955| 255| luaK_codeABC(fs, OP_VARARGPREP, nparams, 0, 0); ------------------ | | 48| 255|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 956| 255|} lparser.c:allocupvalue: 352| 5.93k|static Upvaldesc *allocupvalue (FuncState *fs) { 353| 5.93k| Proto *f = fs->f; 354| 5.93k| int oldsize = f->sizeupvalues; 355| 5.93k| checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues"); ------------------ | | 29| 5.93k|#define MAXUPVAL 255 ------------------ 356| 5.93k| luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues, ------------------ | | 67| 5.93k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 11.8k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 5.93k| luaM_limitN(limit,t),e))) ------------------ 357| 5.93k| Upvaldesc, MAXUPVAL, "upvalues"); 358| 17.8k| while (oldsize < f->sizeupvalues) ------------------ | Branch (358:10): [True: 11.9k, False: 5.93k] ------------------ 359| 11.9k| f->upvalues[oldsize++].name = NULL; 360| 5.93k| return &f->upvalues[fs->nups++]; 361| 5.93k|} lparser.c:checklimit: 87| 21.9k|static void checklimit (FuncState *fs, int v, int l, const char *what) { 88| 21.9k| if (v > l) errorlimit(fs, l, what); ------------------ | Branch (88:7): [True: 2, False: 21.9k] ------------------ 89| 21.9k|} 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: 2, False: 0] ------------------ 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| 7.62k|static void statlist (LexState *ls) { 800| | /* statlist -> { stat [';'] } */ 801| 53.9k| while (!block_follow(ls, 1)) { ------------------ | Branch (801:10): [True: 49.2k, False: 4.66k] ------------------ 802| 49.2k| if (ls->t.token == TK_RETURN) { ------------------ | Branch (802:9): [True: 2.95k, False: 46.3k] ------------------ 803| 2.95k| statement(ls); 804| 2.95k| return; /* 'return' must be last statement */ 805| 2.95k| } 806| 46.3k| statement(ls); 807| 46.3k| } 808| 7.62k|} lparser.c:block_follow: 788| 55.6k|static int block_follow (LexState *ls, int withuntil) { 789| 55.6k| switch (ls->t.token) { 790| 0| case TK_ELSE: case TK_ELSEIF: ------------------ | Branch (790:5): [True: 0, False: 55.6k] | Branch (790:19): [True: 0, False: 55.6k] ------------------ 791| 2.86k| case TK_END: case TK_EOS: ------------------ | Branch (791:5): [True: 2.81k, False: 52.8k] | Branch (791:18): [True: 52, False: 55.6k] ------------------ 792| 2.86k| return 1; 793| 551| case TK_UNTIL: return withuntil; ------------------ | Branch (793:5): [True: 551, False: 55.1k] ------------------ 794| 52.2k| default: return 0; ------------------ | Branch (794:5): [True: 52.2k, False: 3.41k] ------------------ 795| 55.6k| } 796| 55.6k|} lparser.c:statement: 1845| 49.2k|static void statement (LexState *ls) { 1846| 49.2k| int line = ls->linenumber; /* may be needed for error messages */ 1847| 49.2k| enterlevel(ls); ------------------ | | 504| 49.2k|#define enterlevel(ls) luaE_incCstack(ls->L) ------------------ 1848| 49.2k| switch (ls->t.token) { 1849| 13.1k| case ';': { /* stat -> ';' (empty statement) */ ------------------ | Branch (1849:5): [True: 13.1k, False: 36.1k] ------------------ 1850| 13.1k| luaX_next(ls); /* skip ';' */ 1851| 13.1k| break; 1852| 0| } 1853| 0| case TK_IF: { /* stat -> ifstat */ ------------------ | Branch (1853:5): [True: 0, False: 49.2k] ------------------ 1854| 0| ifstat(ls, line); 1855| 0| break; 1856| 0| } 1857| 456| case TK_WHILE: { /* stat -> whilestat */ ------------------ | Branch (1857:5): [True: 456, False: 48.8k] ------------------ 1858| 456| whilestat(ls, line); 1859| 456| break; 1860| 0| } 1861| 1.54k| case TK_DO: { /* stat -> DO block END */ ------------------ | Branch (1861:5): [True: 1.54k, False: 47.7k] ------------------ 1862| 1.54k| luaX_next(ls); /* skip DO */ 1863| 1.54k| block(ls); 1864| 1.54k| check_match(ls, TK_END, TK_DO, line); 1865| 1.54k| break; 1866| 0| } 1867| 1.90k| case TK_FOR: { /* stat -> forstat */ ------------------ | Branch (1867:5): [True: 1.90k, False: 47.3k] ------------------ 1868| 1.90k| forstat(ls, line); 1869| 1.90k| break; 1870| 0| } 1871| 564| case TK_REPEAT: { /* stat -> repeatstat */ ------------------ | Branch (1871:5): [True: 564, False: 48.7k] ------------------ 1872| 564| repeatstat(ls, line); 1873| 564| break; 1874| 0| } 1875| 2.05k| case TK_FUNCTION: { /* stat -> funcstat */ ------------------ | Branch (1875:5): [True: 2.05k, False: 47.2k] ------------------ 1876| 2.05k| funcstat(ls, line); 1877| 2.05k| break; 1878| 0| } 1879| 2.71k| case TK_LOCAL: { /* stat -> localstat */ ------------------ | Branch (1879:5): [True: 2.71k, False: 46.5k] ------------------ 1880| 2.71k| luaX_next(ls); /* skip LOCAL */ 1881| 2.71k| if (testnext(ls, TK_FUNCTION)) /* local function? */ ------------------ | Branch (1881:11): [True: 765, False: 1.94k] ------------------ 1882| 765| localfunc(ls); 1883| 1.94k| else 1884| 1.94k| localstat(ls); 1885| 2.71k| break; 1886| 0| } 1887| 24| case TK_DBCOLON: { /* stat -> label */ ------------------ | Branch (1887:5): [True: 24, False: 49.2k] ------------------ 1888| 24| luaX_next(ls); /* skip double colon */ 1889| 24| labelstat(ls, str_checkname(ls), line); 1890| 24| break; 1891| 0| } 1892| 2.95k| case TK_RETURN: { /* stat -> retstat */ ------------------ | Branch (1892:5): [True: 2.95k, False: 46.3k] ------------------ 1893| 2.95k| luaX_next(ls); /* skip RETURN */ 1894| 2.95k| retstat(ls); 1895| 2.95k| break; 1896| 0| } 1897| 569| case TK_BREAK: { /* stat -> breakstat */ ------------------ | Branch (1897:5): [True: 569, False: 48.7k] ------------------ 1898| 569| breakstat(ls); 1899| 569| break; 1900| 0| } 1901| 627| case TK_GOTO: { /* stat -> 'goto' NAME */ ------------------ | Branch (1901:5): [True: 627, False: 48.6k] ------------------ 1902| 627| luaX_next(ls); /* skip 'goto' */ 1903| 627| gotostat(ls); 1904| 627| break; 1905| 0| } 1906| 22.6k| default: { /* stat -> func | assignment */ ------------------ | Branch (1906:5): [True: 22.6k, False: 26.5k] ------------------ 1907| 22.6k| exprstat(ls); 1908| 22.6k| break; 1909| 0| } 1910| 49.2k| } 1911| 48.0k| lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg && ------------------ | | 106| 48.0k|#define lua_assert(c) assert(c) ------------------ 1912| 48.0k| ls->fs->freereg >= luaY_nvarstack(ls->fs)); 1913| 48.0k| ls->fs->freereg = luaY_nvarstack(ls->fs); /* free registers */ 1914| 48.0k| leavelevel(ls); ------------------ | | 507| 48.0k|#define leavelevel(ls) ((ls)->L->nCcalls--) ------------------ 1915| 48.0k|} lparser.c:expr: 1290| 102k|static void expr (LexState *ls, expdesc *v) { 1291| 102k| subexpr(ls, v, 0); 1292| 102k|} lparser.c:subexpr: 1260| 5.33M|static BinOpr subexpr (LexState *ls, expdesc *v, int limit) { 1261| 5.33M| BinOpr op; 1262| 5.33M| UnOpr uop; 1263| 5.33M| enterlevel(ls); ------------------ | | 504| 5.33M|#define enterlevel(ls) luaE_incCstack(ls->L) ------------------ 1264| 5.33M| uop = getunopr(ls->t.token); 1265| 5.33M| if (uop != OPR_NOUNOPR) { /* prefix (unary) operator? */ ------------------ | Branch (1265:7): [True: 120k, False: 5.21M] ------------------ 1266| 120k| int line = ls->linenumber; 1267| 120k| luaX_next(ls); /* skip operator */ 1268| 120k| subexpr(ls, v, UNARY_PRIORITY); ------------------ | | 1253| 120k|#define UNARY_PRIORITY 12 /* priority for unary operators */ ------------------ 1269| 120k| luaK_prefix(ls->fs, uop, v, line); 1270| 120k| } 1271| 5.21M| else simpleexp(ls, v); 1272| | /* expand while operators have priorities higher than 'limit' */ 1273| 5.33M| op = getbinopr(ls->t.token); 1274| 10.4M| while (op != OPR_NOBINOPR && priority[op].left > limit) { ------------------ | Branch (1274:10): [True: 10.2M, False: 163k] | Branch (1274:32): [True: 5.11M, False: 5.17M] ------------------ 1275| 5.11M| expdesc v2; 1276| 5.11M| BinOpr nextop; 1277| 5.11M| int line = ls->linenumber; 1278| 5.11M| luaX_next(ls); /* skip operator */ 1279| 5.11M| luaK_infix(ls->fs, op, v); 1280| | /* read sub-expression with higher priority */ 1281| 5.11M| nextop = subexpr(ls, &v2, priority[op].right); 1282| 5.11M| luaK_posfix(ls->fs, op, v, &v2, line); 1283| 5.11M| op = nextop; 1284| 5.11M| } 1285| 5.33M| leavelevel(ls); ------------------ | | 507| 5.33M|#define leavelevel(ls) ((ls)->L->nCcalls--) ------------------ 1286| 5.33M| return op; /* return first untreated operator */ 1287| 5.33M|} lparser.c:getunopr: 1195| 5.33M|static UnOpr getunopr (int op) { 1196| 5.33M| switch (op) { 1197| 2.32k| case TK_NOT: return OPR_NOT; ------------------ | Branch (1197:5): [True: 2.32k, False: 5.33M] ------------------ 1198| 61.8k| case '-': return OPR_MINUS; ------------------ | Branch (1198:5): [True: 61.8k, False: 5.27M] ------------------ 1199| 45.3k| case '~': return OPR_BNOT; ------------------ | Branch (1199:5): [True: 45.3k, False: 5.29M] ------------------ 1200| 10.7k| case '#': return OPR_LEN; ------------------ | Branch (1200:5): [True: 10.7k, False: 5.32M] ------------------ 1201| 5.21M| default: return OPR_NOUNOPR; ------------------ | Branch (1201:5): [True: 5.21M, False: 120k] ------------------ 1202| 5.33M| } 1203| 5.33M|} lparser.c:simpleexp: 1140| 5.21M|static void simpleexp (LexState *ls, expdesc *v) { 1141| | /* simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... | 1142| | constructor | FUNCTION body | suffixedexp */ 1143| 5.21M| switch (ls->t.token) { 1144| 17.2k| case TK_FLT: { ------------------ | Branch (1144:5): [True: 17.2k, False: 5.20M] ------------------ 1145| 17.2k| init_exp(v, VKFLT, 0); 1146| 17.2k| v->u.nval = ls->t.seminfo.r; 1147| 17.2k| break; 1148| 0| } 1149| 129k| case TK_INT: { ------------------ | Branch (1149:5): [True: 129k, False: 5.08M] ------------------ 1150| 129k| init_exp(v, VKINT, 0); 1151| 129k| v->u.ival = ls->t.seminfo.i; 1152| 129k| break; 1153| 0| } 1154| 9.06k| case TK_STRING: { ------------------ | Branch (1154:5): [True: 9.06k, False: 5.20M] ------------------ 1155| 9.06k| codestring(v, ls->t.seminfo.ts); 1156| 9.06k| break; 1157| 0| } 1158| 30.0k| case TK_NIL: { ------------------ | Branch (1158:5): [True: 30.0k, False: 5.18M] ------------------ 1159| 30.0k| init_exp(v, VNIL, 0); 1160| 30.0k| break; 1161| 0| } 1162| 1.19k| case TK_TRUE: { ------------------ | Branch (1162:5): [True: 1.19k, False: 5.21M] ------------------ 1163| 1.19k| init_exp(v, VTRUE, 0); 1164| 1.19k| break; 1165| 0| } 1166| 0| case TK_FALSE: { ------------------ | Branch (1166:5): [True: 0, False: 5.21M] ------------------ 1167| 0| init_exp(v, VFALSE, 0); 1168| 0| break; 1169| 0| } 1170| 871| case TK_DOTS: { /* vararg */ ------------------ | Branch (1170:5): [True: 871, False: 5.21M] ------------------ 1171| 871| FuncState *fs = ls->fs; 1172| 871| check_condition(ls, fs->f->is_vararg, ------------------ | | 122| 871|#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } | | ------------------ | | | Branch (122:41): [True: 0, False: 871] | | ------------------ ------------------ 1173| 871| "cannot use '...' outside a vararg function"); 1174| 871| init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 0, 1)); ------------------ | | 48| 871|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1175| 871| break; 1176| 871| } 1177| 109| case '{': { /* constructor */ ------------------ | Branch (1177:5): [True: 109, False: 5.21M] ------------------ 1178| 109| constructor(ls, v); 1179| 109| return; 1180| 871| } 1181| 128| case TK_FUNCTION: { ------------------ | Branch (1181:5): [True: 128, False: 5.21M] ------------------ 1182| 128| luaX_next(ls); 1183| 128| body(ls, v, 0, ls->linenumber); 1184| 128| return; 1185| 871| } 1186| 5.02M| default: { ------------------ | Branch (1186:5): [True: 5.02M, False: 188k] ------------------ 1187| 5.02M| suffixedexp(ls, v); 1188| 5.02M| return; 1189| 871| } 1190| 5.21M| } 1191| 188k| luaX_next(ls); 1192| 188k|} lparser.c:init_exp: 152| 10.2M|static void init_exp (expdesc *e, expkind k, int i) { 153| 10.2M| e->f = e->t = NO_JUMP; ------------------ | | 20| 10.2M|#define NO_JUMP (-1) ------------------ 154| 10.2M| e->k = k; 155| 10.2M| e->u.info = i; 156| 10.2M|} lparser.c:codestring: 159| 5.14M|static void codestring (expdesc *e, TString *s) { 160| 5.14M| e->f = e->t = NO_JUMP; ------------------ | | 20| 5.14M|#define NO_JUMP (-1) ------------------ 161| 5.14M| e->k = VKSTR; 162| 5.14M| e->u.strval = s; 163| 5.14M|} lparser.c:constructor: 925| 121|static void constructor (LexState *ls, expdesc *t) { 926| | /* constructor -> '{' [ field { sep field } [sep] ] '}' 927| | sep -> ',' | ';' */ 928| 121| FuncState *fs = ls->fs; 929| 121| int line = ls->linenumber; 930| 121| int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0); ------------------ | | 48| 121|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 931| 121| ConsControl cc; 932| 121| luaK_code(fs, 0); /* space for extra arg. */ 933| 121| cc.na = cc.nh = cc.tostore = 0; 934| 121| cc.t = t; 935| 121| init_exp(t, VNONRELOC, fs->freereg); /* table will be at stack top */ 936| 121| luaK_reserveregs(fs, 1); 937| 121| init_exp(&cc.v, VVOID, 0); /* no value (yet) */ 938| 121| checknext(ls, '{'); 939| 172| do { 940| 172| lua_assert(cc.v.k == VVOID || cc.tostore > 0); ------------------ | | 106| 172|#define lua_assert(c) assert(c) ------------------ 941| 171| if (ls->t.token == '}') break; ------------------ | Branch (941:9): [True: 28, False: 143] ------------------ 942| 143| closelistfield(fs, &cc); 943| 143| field(ls, &cc); 944| 143| } while (testnext(ls, ',') || testnext(ls, ';')); ------------------ | Branch (944:12): [True: 87, False: 56] | Branch (944:33): [True: 2, False: 54] ------------------ 945| 120| check_match(ls, '}', '{', line); 946| 120| lastlistfield(fs, &cc); 947| 120| luaK_settablesize(fs, pc, t->u.info, cc.na, cc.nh); 948| 120|} lparser.c:closelistfield: 868| 143|static void closelistfield (FuncState *fs, ConsControl *cc) { 869| 143| if (cc->v.k == VVOID) return; /* there is no list item */ ------------------ | Branch (869:7): [True: 92, False: 51] ------------------ 870| 51| luaK_exp2nextreg(fs, &cc->v); 871| 51| cc->v.k = VVOID; 872| 51| if (cc->tostore == LFIELDS_PER_FLUSH) { ------------------ | | 403| 51|#define LFIELDS_PER_FLUSH 50 ------------------ | Branch (872:7): [True: 0, False: 51] ------------------ 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| 51|} lparser.c:field: 903| 143|static void field (LexState *ls, ConsControl *cc) { 904| | /* field -> listfield | recfield */ 905| 143| switch(ls->t.token) { 906| 109| case TK_NAME: { /* may be 'listfield' or 'recfield' */ ------------------ | Branch (906:5): [True: 109, False: 34] ------------------ 907| 109| if (luaX_lookahead(ls) != '=') /* expression? */ ------------------ | Branch (907:11): [True: 108, False: 1] ------------------ 908| 108| listfield(ls, cc); 909| 1| else 910| 1| recfield(ls, cc); 911| 109| break; 912| 0| } 913| 2| case '[': { ------------------ | Branch (913:5): [True: 2, False: 141] ------------------ 914| 2| recfield(ls, cc); 915| 2| break; 916| 0| } 917| 32| default: { ------------------ | Branch (917:5): [True: 32, False: 111] ------------------ 918| 32| listfield(ls, cc); 919| 32| break; 920| 0| } 921| 143| } 922| 143|} lparser.c:listfield: 896| 140|static void listfield (LexState *ls, ConsControl *cc) { 897| | /* listfield -> exp */ 898| 140| expr(ls, &cc->v); 899| 140| cc->tostore++; 900| 140|} lparser.c:recfield: 847| 3|static void recfield (LexState *ls, ConsControl *cc) { 848| | /* recfield -> (NAME | '['exp']') = exp */ 849| 3| FuncState *fs = ls->fs; 850| 3| int reg = ls->fs->freereg; 851| 3| expdesc tab, key, val; 852| 3| if (ls->t.token == TK_NAME) { ------------------ | Branch (852:7): [True: 1, False: 2] ------------------ 853| 1| checklimit(fs, cc->nh, MAX_INT, "items in a constructor"); ------------------ | | 53| 1|#define MAX_INT INT_MAX /* maximum value of an int */ ------------------ 854| 1| codename(ls, &key); 855| 1| } 856| 2| else /* ls->t.token == '[' */ 857| 2| yindex(ls, &key); 858| 3| cc->nh++; 859| 3| checknext(ls, '='); 860| 3| tab = *cc->t; 861| 3| luaK_indexed(fs, &tab, &key); 862| 3| expr(ls, &val); 863| 3| luaK_storevar(fs, &tab, &val); 864| 3| fs->freereg = reg; /* free registers */ 865| 3|} lparser.c:codename: 166| 3.07k|static void codename (LexState *ls, expdesc *e) { 167| 3.07k| codestring(e, str_checkname(ls)); 168| 3.07k|} lparser.c:yindex: 822| 12.8k|static void yindex (LexState *ls, expdesc *v) { 823| | /* index -> '[' expr ']' */ 824| 12.8k| luaX_next(ls); /* skip the '[' */ 825| 12.8k| expr(ls, v); 826| 12.8k| luaK_exp2val(ls->fs, v); 827| 12.8k| checknext(ls, ']'); 828| 12.8k|} lparser.c:lastlistfield: 880| 82|static void lastlistfield (FuncState *fs, ConsControl *cc) { 881| 82| if (cc->tostore == 0) return; ------------------ | Branch (881:7): [True: 28, False: 54] ------------------ 882| 54| if (hasmultret(cc->v.k)) { ------------------ | | 38| 54|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 0, False: 54] | | | Branch (38:41): [True: 2, False: 52] | | ------------------ ------------------ 883| 2| luaK_setmultret(fs, &cc->v); ------------------ | | 58| 2|#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) | | ------------------ | | | | 35| 2|#define LUA_MULTRET (-1) | | ------------------ ------------------ 884| 2| luaK_setlist(fs, cc->t->u.info, cc->na, LUA_MULTRET); ------------------ | | 35| 2|#define LUA_MULTRET (-1) ------------------ 885| 2| cc->na--; /* do not count last expression (unknown number of elements) */ 886| 2| } 887| 52| else { 888| 52| if (cc->v.k != VVOID) ------------------ | Branch (888:9): [True: 52, False: 0] ------------------ 889| 52| luaK_exp2nextreg(fs, &cc->v); 890| 52| luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); 891| 52| } 892| 54| cc->na += cc->tostore; 893| 54|} lparser.c:body: 990| 2.94k|static void body (LexState *ls, expdesc *e, int ismethod, int line) { 991| | /* body -> '(' parlist ')' block END */ 992| 2.94k| FuncState new_fs; 993| 2.94k| BlockCnt bl; 994| 2.94k| new_fs.f = addprototype(ls); 995| 2.94k| new_fs.f->linedefined = line; 996| 2.94k| open_func(ls, &new_fs, &bl); 997| 2.94k| checknext(ls, '('); 998| 2.94k| if (ismethod) { ------------------ | Branch (998:7): [True: 9, False: 2.94k] ------------------ 999| 9| new_localvarliteral(ls, "self"); /* create 'self' parameter */ ------------------ | | 209| 9| new_localvar(ls, \ | | 210| 9| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1000| 9| adjustlocalvars(ls, 1); 1001| 9| } 1002| 2.94k| parlist(ls); 1003| 2.94k| checknext(ls, ')'); 1004| 2.94k| statlist(ls); 1005| 2.94k| new_fs.f->lastlinedefined = ls->linenumber; 1006| 2.94k| check_match(ls, TK_END, TK_FUNCTION, line); 1007| 2.94k| codeclosure(ls, e); 1008| 2.94k| close_func(ls); 1009| 2.94k|} lparser.c:addprototype: 698| 2.94k|static Proto *addprototype (LexState *ls) { 699| 2.94k| Proto *clp; 700| 2.94k| lua_State *L = ls->L; 701| 2.94k| FuncState *fs = ls->fs; 702| 2.94k| Proto *f = fs->f; /* prototype of current function */ 703| 2.94k| if (fs->np >= f->sizep) { ------------------ | Branch (703:7): [True: 1.15k, False: 1.79k] ------------------ 704| 1.15k| int oldsize = f->sizep; 705| 1.15k| luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions"); ------------------ | | 67| 1.15k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 2.31k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 1.15k| luaM_limitN(limit,t),e))) ------------------ 706| 8.24k| while (oldsize < f->sizep) ------------------ | Branch (706:12): [True: 7.08k, False: 1.15k] ------------------ 707| 7.08k| f->p[oldsize++] = NULL; 708| 1.15k| } 709| 2.94k| f->p[fs->np++] = clp = luaF_newproto(L); 710| 2.94k| luaC_objbarrier(L, f, clp); ------------------ | | 175| 2.94k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 2.94k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 2.94k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 2.94k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 5.89k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 2.94k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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| 2.94k| 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 2.94k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 2.94k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 711| 0| return clp; 712| 2.94k|} lparser.c:new_localvar: 193| 16.0k|static int new_localvar (LexState *ls, TString *name) { 194| 16.0k| lua_State *L = ls->L; 195| 16.0k| FuncState *fs = ls->fs; 196| 16.0k| Dyndata *dyd = ls->dyd; 197| 16.0k| Vardesc *var; 198| 16.0k| checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal, 199| 16.0k| MAXVARS, "local variables"); ------------------ | | 35| 16.0k|#define MAXVARS 200 ------------------ 200| 16.0k| luaM_growvector(L, dyd->actvar.arr, dyd->actvar.n + 1, ------------------ | | 67| 16.0k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 32.0k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 16.0k| luaM_limitN(limit,t),e))) ------------------ 201| 16.0k| dyd->actvar.size, Vardesc, USHRT_MAX, "local variables"); 202| 16.0k| var = &dyd->actvar.arr[dyd->actvar.n++]; 203| 16.0k| var->vd.kind = VDKREG; /* default */ ------------------ | | 90| 16.0k|#define VDKREG 0 /* regular */ ------------------ 204| 16.0k| var->vd.name = name; 205| 16.0k| return dyd->actvar.n - 1 - fs->firstlocal; 206| 16.0k|} lparser.c:adjustlocalvars: 311| 9.46k|static void adjustlocalvars (LexState *ls, int nvars) { 312| 9.46k| FuncState *fs = ls->fs; 313| 9.46k| int reglevel = luaY_nvarstack(fs); 314| 9.46k| int i; 315| 25.0k| for (i = 0; i < nvars; i++) { ------------------ | Branch (315:15): [True: 15.5k, False: 9.46k] ------------------ 316| 15.5k| int vidx = fs->nactvar++; 317| 15.5k| Vardesc *var = getlocalvardesc(fs, vidx); 318| 15.5k| var->vd.ridx = reglevel++; 319| 15.5k| var->vd.pidx = registerlocalvar(ls, fs, var->vd.name); 320| 15.5k| } 321| 9.46k|} lparser.c:registerlocalvar: 175| 15.5k|static int registerlocalvar (LexState *ls, FuncState *fs, TString *varname) { 176| 15.5k| Proto *f = fs->f; 177| 15.5k| int oldsize = f->sizelocvars; 178| 15.5k| luaM_growvector(ls->L, f->locvars, fs->ndebugvars, f->sizelocvars, ------------------ | | 67| 15.5k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 31.1k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 15.5k| luaM_limitN(limit,t),e))) ------------------ 179| 15.5k| LocVar, SHRT_MAX, "local variables"); 180| 39.0k| while (oldsize < f->sizelocvars) ------------------ | Branch (180:10): [True: 23.4k, False: 15.5k] ------------------ 181| 23.4k| f->locvars[oldsize++].varname = NULL; 182| 15.5k| f->locvars[fs->ndebugvars].varname = varname; 183| 15.5k| f->locvars[fs->ndebugvars].startpc = fs->pc; 184| 15.5k| luaC_objbarrier(ls->L, f, varname); ------------------ | | 175| 15.5k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 15.5k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 15.5k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 15.5k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 31.1k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 15.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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| 15.5k| 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 15.5k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 15.5k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 185| 0| return fs->ndebugvars++; 186| 15.5k|} lparser.c:parlist: 959| 2.94k|static void parlist (LexState *ls) { 960| | /* parlist -> [ {NAME ','} (NAME | '...') ] */ 961| 2.94k| FuncState *fs = ls->fs; 962| 2.94k| Proto *f = fs->f; 963| 2.94k| int nparams = 0; 964| 2.94k| int isvararg = 0; 965| 2.94k| if (ls->t.token != ')') { /* is 'parlist' not empty? */ ------------------ | Branch (965:7): [True: 1.12k, False: 1.82k] ------------------ 966| 3.45k| do { 967| 3.45k| switch (ls->t.token) { 968| 3.42k| case TK_NAME: { ------------------ | Branch (968:9): [True: 3.42k, False: 30] ------------------ 969| 3.42k| new_localvar(ls, str_checkname(ls)); 970| 3.42k| nparams++; 971| 3.42k| break; 972| 0| } 973| 30| case TK_DOTS: { ------------------ | Branch (973:9): [True: 30, False: 3.42k] ------------------ 974| 30| luaX_next(ls); 975| 30| isvararg = 1; 976| 30| break; 977| 0| } 978| 0| default: luaX_syntaxerror(ls, " or '...' expected"); ------------------ | Branch (978:9): [True: 0, False: 3.45k] ------------------ 979| 3.45k| } 980| 3.45k| } while (!isvararg && testnext(ls, ',')); ------------------ | Branch (980:14): [True: 3.42k, False: 30] | Branch (980:27): [True: 2.33k, False: 1.09k] ------------------ 981| 1.12k| } 982| 2.94k| adjustlocalvars(ls, nparams); 983| 2.94k| f->numparams = cast_byte(fs->nactvar); ------------------ | | 143| 2.94k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 2.94k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 984| 2.94k| if (isvararg) ------------------ | Branch (984:7): [True: 30, False: 2.91k] ------------------ 985| 30| setvararg(fs, f->numparams); /* declared vararg */ 986| 2.94k| luaK_reserveregs(fs, fs->nactvar); /* reserve registers for parameters */ 987| 2.94k|} lparser.c:codeclosure: 722| 2.69k|static void codeclosure (LexState *ls, expdesc *v) { 723| 2.69k| FuncState *fs = ls->fs->prev; 724| 2.69k| init_exp(v, VRELOC, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1)); 725| 2.69k| luaK_exp2nextreg(fs, v); /* fix it at the last register */ 726| 2.69k|} lparser.c:suffixedexp: 1103| 5.05M|static void suffixedexp (LexState *ls, expdesc *v) { 1104| | /* suffixedexp -> 1105| | primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */ 1106| 5.05M| FuncState *fs = ls->fs; 1107| 5.05M| primaryexp(ls, v); 1108| 5.23M| for (;;) { 1109| 5.23M| switch (ls->t.token) { 1110| 2.52k| case '.': { /* fieldsel */ ------------------ | Branch (1110:7): [True: 2.52k, False: 5.23M] ------------------ 1111| 2.52k| fieldsel(ls, v); 1112| 2.52k| break; 1113| 0| } 1114| 12.8k| case '[': { /* '[' exp ']' */ ------------------ | Branch (1114:7): [True: 12.8k, False: 5.22M] ------------------ 1115| 12.8k| expdesc key; 1116| 12.8k| luaK_exp2anyregup(fs, v); 1117| 12.8k| yindex(ls, &key); 1118| 12.8k| luaK_indexed(fs, v, &key); 1119| 12.8k| break; 1120| 0| } 1121| 542| case ':': { /* ':' NAME funcargs */ ------------------ | Branch (1121:7): [True: 542, False: 5.23M] ------------------ 1122| 542| expdesc key; 1123| 542| luaX_next(ls); 1124| 542| codename(ls, &key); 1125| 542| luaK_self(fs, v, &key); 1126| 542| funcargs(ls, v); 1127| 542| break; 1128| 0| } 1129| 164k| case '(': case TK_STRING: case '{': { /* funcargs */ ------------------ | Branch (1129:7): [True: 15.0k, False: 5.21M] | Branch (1129:17): [True: 149k, False: 5.08M] | Branch (1129:33): [True: 12, False: 5.23M] ------------------ 1130| 164k| luaK_exp2nextreg(fs, v); 1131| 164k| funcargs(ls, v); 1132| 164k| break; 1133| 164k| } 1134| 5.05M| default: return; ------------------ | Branch (1134:7): [True: 5.05M, False: 180k] ------------------ 1135| 5.23M| } 1136| 5.23M| } 1137| 5.05M|} lparser.c:primaryexp: 1081| 5.05M|static void primaryexp (LexState *ls, expdesc *v) { 1082| | /* primaryexp -> NAME | '(' expr ')' */ 1083| 5.05M| switch (ls->t.token) { 1084| 26.5k| case '(': { ------------------ | Branch (1084:5): [True: 26.5k, False: 5.03M] ------------------ 1085| 26.5k| int line = ls->linenumber; 1086| 26.5k| luaX_next(ls); 1087| 26.5k| expr(ls, v); 1088| 26.5k| check_match(ls, ')', '(', line); 1089| 26.5k| luaK_dischargevars(ls->fs, v); 1090| 26.5k| return; 1091| 0| } 1092| 5.03M| case TK_NAME: { ------------------ | Branch (1092:5): [True: 5.03M, False: 26.5k] ------------------ 1093| 5.03M| singlevar(ls, v); 1094| 5.03M| return; 1095| 0| } 1096| 45| default: { ------------------ | Branch (1096:5): [True: 45, False: 5.05M] ------------------ 1097| 45| luaX_syntaxerror(ls, "unexpected symbol"); 1098| 0| } 1099| 5.05M| } 1100| 5.05M|} lparser.c:singlevar: 463| 5.03M|static void singlevar (LexState *ls, expdesc *var) { 464| 5.03M| TString *varname = str_checkname(ls); 465| 5.03M| FuncState *fs = ls->fs; 466| 5.03M| singlevaraux(fs, varname, var, 1); 467| 5.03M| if (var->k == VVOID) { /* global name? */ ------------------ | Branch (467:7): [True: 4.98M, False: 52.1k] ------------------ 468| 4.98M| expdesc key; 469| 4.98M| singlevaraux(fs, ls->envn, var, 1); /* get environment variable */ 470| 4.98M| lua_assert(var->k != VVOID); /* this one must exist */ ------------------ | | 106| 4.98M|#define lua_assert(c) assert(c) ------------------ 471| 4.98M| luaK_exp2anyregup(fs, var); /* but could be a constant */ 472| 4.98M| codestring(&key, varname); /* key is variable name */ 473| 4.98M| luaK_indexed(fs, var, &key); /* env[varname] */ 474| 4.98M| } 475| 5.03M|} lparser.c:singlevaraux: 435| 15.3M|static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { 436| 15.3M| if (fs == NULL) /* no more levels? */ ------------------ | Branch (436:7): [True: 4.98M, False: 10.3M] ------------------ 437| 4.98M| init_exp(var, VVOID, 0); /* default is global */ 438| 10.3M| else { 439| 10.3M| int v = searchvar(fs, n, var); /* look up locals at current level */ 440| 10.3M| if (v >= 0) { /* found? */ ------------------ | Branch (440:9): [True: 328k, False: 10.0M] ------------------ 441| 328k| if (v == VLOCAL && !base) ------------------ | Branch (441:11): [True: 144k, False: 183k] | Branch (441:26): [True: 2.24k, False: 142k] ------------------ 442| 2.24k| markupval(fs, var->u.var.vidx); /* local will be used as an upval */ 443| 328k| } 444| 10.0M| else { /* not found as local at current level; try upvalues */ 445| 10.0M| int idx = searchupvalue(fs, n); /* try existing upvalues */ 446| 10.0M| if (idx < 0) { /* not found? */ ------------------ | Branch (446:11): [True: 5.31M, False: 4.70M] ------------------ 447| 5.31M| singlevaraux(fs->prev, n, var, 0); /* try upper levels */ 448| 5.31M| if (var->k == VLOCAL || var->k == VUPVAL) /* local or upvalue? */ ------------------ | Branch (448:13): [True: 2.24k, False: 5.31M] | Branch (448:33): [True: 3.47k, False: 5.30M] ------------------ 449| 5.71k| idx = newupvalue(fs, n, var); /* will be a new upvalue */ 450| 5.30M| else /* it is a global or a constant */ 451| 5.30M| return; /* don't need to do anything at this level */ 452| 5.31M| } 453| 4.70M| init_exp(var, VUPVAL, idx); /* new or old upvalue */ 454| 4.70M| } 455| 10.3M| } 456| 15.3M|} lparser.c:searchvar: 390| 10.3M|static int searchvar (FuncState *fs, TString *n, expdesc *var) { 391| 10.3M| int i; 392| 38.6M| for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) { ------------------ | | 141| 10.3M|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 10.3M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (392:39): [True: 28.6M, False: 10.0M] ------------------ 393| 28.6M| Vardesc *vd = getlocalvardesc(fs, i); 394| 28.6M| if (eqstr(n, vd->vd.name)) { /* found? */ ------------------ | | 43| 28.6M|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 328k, False: 28.3M] | | ------------------ ------------------ 395| 328k| if (vd->vd.kind == RDKCTC) /* compile-time constant? */ ------------------ | | 93| 328k|#define RDKCTC 3 /* compile-time constant */ ------------------ | Branch (395:11): [True: 183k, False: 144k] ------------------ 396| 183k| init_exp(var, VCONST, fs->firstlocal + i); 397| 144k| else /* real variable */ 398| 144k| init_var(fs, var, i); 399| 328k| return var->k; 400| 328k| } 401| 28.6M| } 402| 10.0M| return -1; /* not found */ 403| 10.3M|} lparser.c:init_var: 266| 144k|static void init_var (FuncState *fs, expdesc *e, int vidx) { 267| 144k| e->f = e->t = NO_JUMP; ------------------ | | 20| 144k|#define NO_JUMP (-1) ------------------ 268| 144k| e->k = VLOCAL; 269| 144k| e->u.var.vidx = vidx; 270| 144k| e->u.var.ridx = getlocalvardesc(fs, vidx)->vd.ridx; 271| 144k|} lparser.c:markupval: 410| 2.24k|static void markupval (FuncState *fs, int level) { 411| 2.24k| BlockCnt *bl = fs->bl; 412| 4.45k| while (bl->nactvar > level) ------------------ | Branch (412:10): [True: 2.21k, False: 2.24k] ------------------ 413| 2.21k| bl = bl->previous; 414| 2.24k| bl->upval = 1; 415| 2.24k| fs->needclose = 1; 416| 2.24k|} lparser.c:searchupvalue: 342| 10.0M|static int searchupvalue (FuncState *fs, TString *name) { 343| 10.0M| int i; 344| 10.0M| Upvaldesc *up = fs->f->upvalues; 345| 15.3M| for (i = 0; i < fs->nups; i++) { ------------------ | Branch (345:15): [True: 10.0M, False: 5.31M] ------------------ 346| 10.0M| if (eqstr(up[i].name, name)) return i; ------------------ | | 43| 10.0M|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 4.70M, False: 5.37M] | | ------------------ ------------------ 347| 10.0M| } 348| 5.31M| return -1; /* not found */ 349| 10.0M|} lparser.c:newupvalue: 364| 5.71k|static int newupvalue (FuncState *fs, TString *name, expdesc *v) { 365| 5.71k| Upvaldesc *up = allocupvalue(fs); 366| 5.71k| FuncState *prev = fs->prev; 367| 5.71k| if (v->k == VLOCAL) { ------------------ | Branch (367:7): [True: 2.24k, False: 3.47k] ------------------ 368| 2.24k| up->instack = 1; 369| 2.24k| up->idx = v->u.var.ridx; 370| 2.24k| up->kind = getlocalvardesc(prev, v->u.var.vidx)->vd.kind; 371| 2.24k| lua_assert(eqstr(name, getlocalvardesc(prev, v->u.var.vidx)->vd.name)); ------------------ | | 106| 2.24k|#define lua_assert(c) assert(c) ------------------ 372| 2.24k| } 373| 3.47k| else { 374| 3.47k| up->instack = 0; 375| 3.47k| up->idx = cast_byte(v->u.info); ------------------ | | 143| 3.47k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 3.47k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 376| 3.47k| up->kind = prev->f->upvalues[v->u.info].kind; 377| 3.47k| lua_assert(eqstr(name, prev->f->upvalues[v->u.info].name)); ------------------ | | 106| 3.47k|#define lua_assert(c) assert(c) ------------------ 378| 3.47k| } 379| 5.71k| up->name = name; 380| 5.71k| luaC_objbarrier(fs->ls->L, fs->f, name); ------------------ | | 175| 5.71k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 5.71k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 5.71k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 5.71k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 11.4k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 5.71k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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.71k| 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 5.71k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 5.71k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 381| 0| return fs->nups - 1; 382| 5.71k|} lparser.c:fieldsel: 811| 2.53k|static void fieldsel (LexState *ls, expdesc *v) { 812| | /* fieldsel -> ['.' | ':'] NAME */ 813| 2.53k| FuncState *fs = ls->fs; 814| 2.53k| expdesc key; 815| 2.53k| luaK_exp2anyregup(fs, v); 816| 2.53k| luaX_next(ls); /* skip the dot or colon */ 817| 2.53k| codename(ls, &key); 818| 2.53k| luaK_indexed(fs, v, &key); 819| 2.53k|} lparser.c:funcargs: 1025| 164k|static void funcargs (LexState *ls, expdesc *f) { 1026| 164k| FuncState *fs = ls->fs; 1027| 164k| expdesc args; 1028| 164k| int base, nparams; 1029| 164k| int line = ls->linenumber; 1030| 164k| switch (ls->t.token) { 1031| 15.5k| case '(': { /* funcargs -> '(' [ explist ] ')' */ ------------------ | Branch (1031:5): [True: 15.5k, False: 149k] ------------------ 1032| 15.5k| luaX_next(ls); 1033| 15.5k| if (ls->t.token == ')') /* arg list is empty? */ ------------------ | Branch (1033:11): [True: 1.18k, False: 14.3k] ------------------ 1034| 1.18k| args.k = VVOID; 1035| 14.3k| else { 1036| 14.3k| explist(ls, &args); 1037| 14.3k| if (hasmultret(args.k)) ------------------ | | 38| 14.3k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 269, False: 14.1k] | | | Branch (38:41): [True: 10, False: 14.0k] | | ------------------ ------------------ 1038| 148| luaK_setmultret(fs, &args); ------------------ | | 58| 148|#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) | | ------------------ | | | | 35| 148|#define LUA_MULTRET (-1) | | ------------------ ------------------ 1039| 14.3k| } 1040| 15.5k| check_match(ls, ')', '(', line); 1041| 15.5k| break; 1042| 0| } 1043| 12| case '{': { /* funcargs -> constructor */ ------------------ | Branch (1043:5): [True: 12, False: 164k] ------------------ 1044| 12| constructor(ls, &args); 1045| 12| break; 1046| 0| } 1047| 149k| case TK_STRING: { /* funcargs -> STRING */ ------------------ | Branch (1047:5): [True: 149k, False: 15.5k] ------------------ 1048| 149k| codestring(&args, ls->t.seminfo.ts); 1049| 149k| luaX_next(ls); /* must use 'seminfo' before 'next' */ 1050| 149k| break; 1051| 0| } 1052| 0| default: { ------------------ | Branch (1052:5): [True: 0, False: 164k] ------------------ 1053| 0| luaX_syntaxerror(ls, "function arguments expected"); 1054| 0| } 1055| 164k| } 1056| 164k| lua_assert(f->k == VNONRELOC); ------------------ | | 106| 164k|#define lua_assert(c) assert(c) ------------------ 1057| 164k| base = f->u.info; /* base register for call */ 1058| 164k| if (hasmultret(args.k)) ------------------ | | 38| 164k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 138, False: 164k] | | | Branch (38:41): [True: 10, False: 164k] | | ------------------ ------------------ 1059| 148| nparams = LUA_MULTRET; /* open call */ ------------------ | | 35| 148|#define LUA_MULTRET (-1) ------------------ 1060| 164k| else { 1061| 164k| if (args.k != VVOID) ------------------ | Branch (1061:9): [True: 163k, False: 1.18k] ------------------ 1062| 163k| luaK_exp2nextreg(fs, &args); /* close last argument */ 1063| 164k| nparams = fs->freereg - (base+1); 1064| 164k| } 1065| 164k| init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2)); ------------------ | | 48| 164k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1066| 164k| luaK_fixline(fs, line); 1067| 164k| fs->freereg = base+1; /* call removes function and arguments and leaves 1068| | one result (unless changed later) */ 1069| 164k|} lparser.c:explist: 1012| 39.6k|static int explist (LexState *ls, expdesc *v) { 1013| | /* explist -> expr { ',' expr } */ 1014| 39.6k| int n = 1; /* at least one expression */ 1015| 39.6k| expr(ls, v); 1016| 57.6k| while (testnext(ls, ',')) { ------------------ | Branch (1016:10): [True: 18.0k, False: 39.6k] ------------------ 1017| 18.0k| luaK_exp2nextreg(ls->fs, v); 1018| 18.0k| expr(ls, v); 1019| 18.0k| n++; 1020| 18.0k| } 1021| 39.6k| return n; 1022| 39.6k|} lparser.c:getbinopr: 1206| 5.33M|static BinOpr getbinopr (int op) { 1207| 5.33M| switch (op) { 1208| 4.81k| case '+': return OPR_ADD; ------------------ | Branch (1208:5): [True: 4.81k, False: 5.33M] ------------------ 1209| 20.6k| case '-': return OPR_SUB; ------------------ | Branch (1209:5): [True: 20.6k, False: 5.31M] ------------------ 1210| 36.8k| case '*': return OPR_MUL; ------------------ | Branch (1210:5): [True: 36.8k, False: 5.29M] ------------------ 1211| 12.8k| case '%': return OPR_MOD; ------------------ | Branch (1211:5): [True: 12.8k, False: 5.32M] ------------------ 1212| 185k| case '^': return OPR_POW; ------------------ | Branch (1212:5): [True: 185k, False: 5.15M] ------------------ 1213| 2.55M| case '/': return OPR_DIV; ------------------ | Branch (1213:5): [True: 2.55M, False: 2.78M] ------------------ 1214| 14.3k| case TK_IDIV: return OPR_IDIV; ------------------ | Branch (1214:5): [True: 14.3k, False: 5.32M] ------------------ 1215| 8.99k| case '&': return OPR_BAND; ------------------ | Branch (1215:5): [True: 8.99k, False: 5.32M] ------------------ 1216| 3.36k| case '|': return OPR_BOR; ------------------ | Branch (1216:5): [True: 3.36k, False: 5.33M] ------------------ 1217| 23.1k| case '~': return OPR_BXOR; ------------------ | Branch (1217:5): [True: 23.1k, False: 5.31M] ------------------ 1218| 143k| case TK_SHL: return OPR_SHL; ------------------ | Branch (1218:5): [True: 143k, False: 5.19M] ------------------ 1219| 471| case TK_SHR: return OPR_SHR; ------------------ | Branch (1219:5): [True: 471, False: 5.33M] ------------------ 1220| 18.7k| case TK_CONCAT: return OPR_CONCAT; ------------------ | Branch (1220:5): [True: 18.7k, False: 5.31M] ------------------ 1221| 2.00k| case TK_NE: return OPR_NE; ------------------ | Branch (1221:5): [True: 2.00k, False: 5.33M] ------------------ 1222| 2.17k| case TK_EQ: return OPR_EQ; ------------------ | Branch (1222:5): [True: 2.17k, False: 5.33M] ------------------ 1223| 2.09M| case '<': return OPR_LT; ------------------ | Branch (1223:5): [True: 2.09M, False: 3.24M] ------------------ 1224| 2.26k| case TK_LE: return OPR_LE; ------------------ | Branch (1224:5): [True: 2.26k, False: 5.33M] ------------------ 1225| 17.8k| case '>': return OPR_GT; ------------------ | Branch (1225:5): [True: 17.8k, False: 5.31M] ------------------ 1226| 899| case TK_GE: return OPR_GE; ------------------ | Branch (1226:5): [True: 899, False: 5.33M] ------------------ 1227| 15.1k| case TK_AND: return OPR_AND; ------------------ | Branch (1227:5): [True: 15.1k, False: 5.32M] ------------------ 1228| 69.0k| case TK_OR: return OPR_OR; ------------------ | Branch (1228:5): [True: 69.0k, False: 5.26M] ------------------ 1229| 107k| default: return OPR_NOBINOPR; ------------------ | Branch (1229:5): [True: 107k, False: 5.22M] ------------------ 1230| 5.33M| } 1231| 5.33M|} lparser.c:checknext: 116| 46.8k|static void checknext (LexState *ls, int c) { 117| 46.8k| check(ls, c); 118| 46.8k| luaX_next(ls); 119| 46.8k|} lparser.c:newgotoentry: 575| 687|static int newgotoentry (LexState *ls, TString *name, int line, int pc) { 576| 687| return newlabelentry(ls, &ls->dyd->gt, name, line, pc); 577| 687|} lparser.c:newlabelentry: 561| 3.26k| int line, int pc) { 562| 3.26k| int n = l->n; 563| 3.26k| luaM_growvector(ls->L, l->arr, n, l->size, ------------------ | | 67| 3.26k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 6.53k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 3.26k| luaM_limitN(limit,t),e))) ------------------ 564| 3.26k| Labeldesc, SHRT_MAX, "labels/gotos"); 565| 3.26k| l->arr[n].name = name; 566| 3.26k| l->arr[n].line = line; 567| 3.26k| l->arr[n].nactvar = ls->fs->nactvar; 568| 3.26k| l->arr[n].close = 0; 569| 3.26k| l->arr[n].pc = pc; 570| 3.26k| l->n = n + 1; 571| 3.26k| return n; 572| 3.26k|} lparser.c:leaveblock: 672| 10.4k|static void leaveblock (FuncState *fs) { 673| 10.4k| BlockCnt *bl = fs->bl; 674| 10.4k| LexState *ls = fs->ls; 675| 10.4k| int hasclose = 0; 676| 10.4k| int stklevel = reglevel(fs, bl->nactvar); /* level outside the block */ 677| 10.4k| removevars(fs, bl->nactvar); /* remove block locals */ 678| 10.4k| lua_assert(bl->nactvar == fs->nactvar); /* back to level on entry */ ------------------ | | 106| 10.4k|#define lua_assert(c) assert(c) ------------------ 679| 10.4k| if (bl->isloop) /* has to fix pending breaks? */ ------------------ | Branch (679:7): [True: 2.55k, False: 7.92k] ------------------ 680| 2.55k| hasclose = createlabel(ls, luaS_newliteral(ls->L, "break"), 0, 0); ------------------ | | 28| 2.55k|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 2.55k| (sizeof(s)/sizeof(char))-1)) ------------------ 681| 10.4k| if (!hasclose && bl->previous && bl->upval) /* still need a 'close'? */ ------------------ | Branch (681:7): [True: 10.4k, False: 0] | Branch (681:20): [True: 7.74k, False: 2.73k] | Branch (681:36): [True: 57, False: 7.69k] ------------------ 682| 57| luaK_codeABC(fs, OP_CLOSE, stklevel, 0, 0); ------------------ | | 48| 57|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 683| 10.4k| fs->freereg = stklevel; /* free registers */ 684| 10.4k| ls->dyd->label.n = bl->firstlabel; /* remove local labels */ 685| 10.4k| fs->bl = bl->previous; /* current block now is previous one */ 686| 10.4k| if (bl->previous) /* was it a nested block? */ ------------------ | Branch (686:7): [True: 7.74k, False: 2.73k] ------------------ 687| 7.74k| movegotosout(fs, bl); /* update pending gotos to enclosing block */ 688| 2.73k| else { 689| 2.73k| if (bl->firstgoto < ls->dyd->gt.n) /* still pending gotos? */ ------------------ | Branch (689:9): [True: 0, False: 2.73k] ------------------ 690| 0| undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */ 691| 2.73k| } 692| 10.4k|} lparser.c:removevars: 328| 10.4k|static void removevars (FuncState *fs, int tolevel) { 329| 10.4k| fs->ls->dyd->actvar.n -= (fs->nactvar - tolevel); 330| 21.2k| while (fs->nactvar > tolevel) { ------------------ | Branch (330:10): [True: 10.7k, False: 10.4k] ------------------ 331| 10.7k| LocVar *var = localdebuginfo(fs, --fs->nactvar); 332| 10.7k| if (var) /* does it have debug information? */ ------------------ | Branch (332:9): [True: 10.7k, False: 37] ------------------ 333| 10.7k| var->endpc = fs->pc; 334| 10.7k| } 335| 10.4k|} lparser.c:localdebuginfo: 251| 11.4k|static LocVar *localdebuginfo (FuncState *fs, int vidx) { 252| 11.4k| Vardesc *vd = getlocalvardesc(fs, vidx); 253| 11.4k| if (vd->vd.kind == RDKCTC) ------------------ | | 93| 11.4k|#define RDKCTC 3 /* compile-time constant */ ------------------ | Branch (253:7): [True: 37, False: 11.4k] ------------------ 254| 37| return NULL; /* no debug info. for constants */ 255| 11.4k| else { 256| 11.4k| int idx = vd->vd.pidx; 257| 11.4k| lua_assert(idx < fs->ndebugvars); ------------------ | | 106| 11.4k|#define lua_assert(c) assert(c) ------------------ 258| 11.4k| return &fs->f->locvars[idx]; 259| 11.4k| } 260| 11.4k|} lparser.c:createlabel: 609| 2.58k| int last) { 610| 2.58k| FuncState *fs = ls->fs; 611| 2.58k| Labellist *ll = &ls->dyd->label; 612| 2.58k| int l = newlabelentry(ls, ll, name, line, luaK_getlabel(fs)); 613| 2.58k| if (last) { /* label is last no-op statement in the block? */ ------------------ | Branch (613:7): [True: 0, False: 2.58k] ------------------ 614| | /* assume that locals are already out of scope */ 615| 0| ll->arr[l].nactvar = fs->bl->nactvar; 616| 0| } 617| 2.58k| if (solvegotos(ls, &ll->arr[l])) { /* need close? */ ------------------ | Branch (617:7): [True: 0, False: 2.58k] ------------------ 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| 2.58k| return 0; 622| 2.58k|} lparser.c:solvegotos: 585| 2.58k|static int solvegotos (LexState *ls, Labeldesc *lb) { 586| 2.58k| Labellist *gl = &ls->dyd->gt; 587| 2.58k| int i = ls->fs->bl->firstgoto; 588| 2.58k| int needsclose = 0; 589| 3.15k| while (i < gl->n) { ------------------ | Branch (589:10): [True: 569, False: 2.58k] ------------------ 590| 569| if (eqstr(gl->arr[i].name, lb->name)) { ------------------ | | 43| 569|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 569, False: 0] | | ------------------ ------------------ 591| 569| needsclose |= gl->arr[i].close; 592| 569| solvegoto(ls, i, lb); /* will remove 'i' from the list */ 593| 569| } 594| 0| else 595| 0| i++; 596| 569| } 597| 2.58k| return needsclose; 598| 2.58k|} lparser.c:solvegoto: 527| 569|static void solvegoto (LexState *ls, int g, Labeldesc *label) { 528| 569| int i; 529| 569| Labellist *gl = &ls->dyd->gt; /* list of gotos */ 530| 569| Labeldesc *gt = &gl->arr[g]; /* goto to be resolved */ 531| 569| lua_assert(eqstr(gt->name, label->name)); ------------------ | | 106| 569|#define lua_assert(c) assert(c) ------------------ 532| 569| if (l_unlikely(gt->nactvar < label->nactvar)) /* enter some scope? */ ------------------ | | 697| 569|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 569|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 569] | | | | ------------------ | | ------------------ ------------------ 533| 0| jumpscopeerror(ls, gt); 534| 569| luaK_patchlist(ls->fs, gt->pc, label->pc); 535| 578| for (i = g; i < gl->n - 1; i++) /* remove goto from pending list */ ------------------ | Branch (535:15): [True: 9, False: 569] ------------------ 536| 9| gl->arr[i] = gl->arr[i + 1]; 537| 569| gl->n--; 538| 569|} lparser.c:movegotosout: 628| 7.74k|static void movegotosout (FuncState *fs, BlockCnt *bl) { 629| 7.74k| int i; 630| 7.74k| Labellist *gl = &fs->ls->dyd->gt; 631| | /* correct pending gotos to current block */ 632| 8.31k| for (i = bl->firstgoto; i < gl->n; i++) { /* for each pending goto */ ------------------ | Branch (632:27): [True: 571, False: 7.74k] ------------------ 633| 571| Labeldesc *gt = &gl->arr[i]; 634| | /* leaving a variable scope? */ 635| 571| if (reglevel(fs, gt->nactvar) > reglevel(fs, bl->nactvar)) ------------------ | Branch (635:9): [True: 1, False: 570] ------------------ 636| 1| gt->close |= bl->upval; /* jump may need a close */ 637| 571| gt->nactvar = bl->nactvar; /* update goto level */ 638| 571| } 639| 7.74k|} lparser.c:whilestat: 1468| 456|static void whilestat (LexState *ls, int line) { 1469| | /* whilestat -> WHILE cond DO block END */ 1470| 456| FuncState *fs = ls->fs; 1471| 456| int whileinit; 1472| 456| int condexit; 1473| 456| BlockCnt bl; 1474| 456| luaX_next(ls); /* skip WHILE */ 1475| 456| whileinit = luaK_getlabel(fs); 1476| 456| condexit = cond(ls); 1477| 456| enterblock(fs, &bl, 1); 1478| 456| checknext(ls, TK_DO); 1479| 456| block(ls); 1480| 456| luaK_jumpto(fs, whileinit); ------------------ | | 60| 456|#define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t) ------------------ 1481| 456| check_match(ls, TK_END, TK_WHILE, line); 1482| 456| leaveblock(fs); 1483| 456| luaK_patchtohere(fs, condexit); /* false conditions finish the loop */ 1484| 456|} lparser.c:cond: 1406| 1.01k|static int cond (LexState *ls) { 1407| | /* cond -> exp */ 1408| 1.01k| expdesc v; 1409| 1.01k| expr(ls, &v); /* read condition */ 1410| 1.01k| if (v.k == VNIL) v.k = VFALSE; /* 'falses' are all equal here */ ------------------ | Branch (1410:7): [True: 263, False: 753] ------------------ 1411| 1.01k| luaK_goiftrue(ls->fs, &v); 1412| 1.01k| return v.f; 1413| 1.01k|} lparser.c:block: 1305| 3.89k|static void block (LexState *ls) { 1306| | /* block -> statlist */ 1307| 3.89k| FuncState *fs = ls->fs; 1308| 3.89k| BlockCnt bl; 1309| 3.89k| enterblock(fs, &bl, 0); 1310| 3.89k| statlist(ls); 1311| 3.89k| leaveblock(fs); 1312| 3.89k|} lparser.c:check_match: 130| 46.9k|static void check_match (LexState *ls, int what, int who, int where) { 131| 46.9k| if (l_unlikely(!testnext(ls, what))) { ------------------ | | 697| 46.9k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 46.9k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 31, False: 46.8k] | | | | ------------------ | | ------------------ ------------------ 132| 31| if (where == ls->linenumber) /* all in the same line? */ ------------------ | Branch (132:9): [True: 18, False: 13] ------------------ 133| 18| error_expected(ls, what); /* do not need a complex message */ 134| 13| else { 135| 13| luaX_syntaxerror(ls, luaO_pushfstring(ls->L, 136| 13| "%s expected (to close %s at line %d)", 137| 13| luaX_token2str(ls, what), luaX_token2str(ls, who), where)); 138| 13| } 139| 31| } 140| 46.9k|} lparser.c:error_expected: 68| 25|static l_noret error_expected (LexState *ls, int token) { 69| 25| luaX_syntaxerror(ls, 70| 25| luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token))); 71| 25|} lparser.c:forstat: 1620| 1.90k|static void forstat (LexState *ls, int line) { 1621| | /* forstat -> FOR (fornum | forlist) END */ 1622| 1.90k| FuncState *fs = ls->fs; 1623| 1.90k| TString *varname; 1624| 1.90k| BlockCnt bl; 1625| 1.90k| enterblock(fs, &bl, 1); /* scope for loop and control variables */ 1626| 1.90k| luaX_next(ls); /* skip 'for' */ 1627| 1.90k| varname = str_checkname(ls); /* first variable name */ 1628| 1.90k| switch (ls->t.token) { 1629| 1.90k| case '=': fornum(ls, varname, line); break; ------------------ | Branch (1629:5): [True: 1.90k, False: 0] ------------------ 1630| 0| case ',': case TK_IN: forlist(ls, varname); break; ------------------ | Branch (1630:5): [True: 0, False: 1.90k] | Branch (1630:15): [True: 0, False: 1.90k] ------------------ 1631| 0| default: luaX_syntaxerror(ls, "'=' or 'in' expected"); ------------------ | Branch (1631:5): [True: 0, False: 1.90k] ------------------ 1632| 1.90k| } 1633| 1.55k| check_match(ls, TK_END, TK_FOR, line); 1634| 1.55k| leaveblock(fs); /* loop scope ('break' jumps to this point) */ 1635| 1.55k|} lparser.c:fornum: 1569| 1.90k|static void fornum (LexState *ls, TString *varname, int line) { 1570| | /* fornum -> NAME = exp,exp[,exp] forbody */ 1571| 1.90k| FuncState *fs = ls->fs; 1572| 1.90k| int base = fs->freereg; 1573| 1.90k| new_localvarliteral(ls, "(for state)"); ------------------ | | 209| 1.90k| new_localvar(ls, \ | | 210| 1.90k| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1574| 1.90k| new_localvarliteral(ls, "(for state)"); ------------------ | | 209| 1.90k| new_localvar(ls, \ | | 210| 1.90k| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1575| 1.90k| new_localvarliteral(ls, "(for state)"); ------------------ | | 209| 1.90k| new_localvar(ls, \ | | 210| 1.90k| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1576| 1.90k| new_localvar(ls, varname); 1577| 1.90k| checknext(ls, '='); 1578| 1.90k| exp1(ls); /* initial value */ 1579| 1.90k| checknext(ls, ','); 1580| 1.90k| exp1(ls); /* limit */ 1581| 1.90k| if (testnext(ls, ',')) ------------------ | Branch (1581:7): [True: 0, False: 1.90k] ------------------ 1582| 0| exp1(ls); /* optional step */ 1583| 1.90k| else { /* default step = 1 */ 1584| 1.90k| luaK_int(fs, fs->freereg, 1); 1585| 1.90k| luaK_reserveregs(fs, 1); 1586| 1.90k| } 1587| 1.90k| adjustlocalvars(ls, 3); /* control variables */ 1588| 1.90k| forbody(ls, base, line, 1, 0); 1589| 1.90k|} lparser.c:exp1: 1517| 3.80k|static void exp1 (LexState *ls) { 1518| 3.80k| expdesc e; 1519| 3.80k| expr(ls, &e); 1520| 3.80k| luaK_exp2nextreg(ls->fs, &e); 1521| 3.80k| lua_assert(e.k == VNONRELOC); ------------------ | | 106| 3.80k|#define lua_assert(c) assert(c) ------------------ 1522| 3.80k|} lparser.c:forbody: 1544| 1.90k|static void forbody (LexState *ls, int base, int line, int nvars, int isgen) { 1545| | /* forbody -> DO block */ 1546| 1.90k| static const OpCode forprep[2] = {OP_FORPREP, OP_TFORPREP}; 1547| 1.90k| static const OpCode forloop[2] = {OP_FORLOOP, OP_TFORLOOP}; 1548| 1.90k| BlockCnt bl; 1549| 1.90k| FuncState *fs = ls->fs; 1550| 1.90k| int prep, endfor; 1551| 1.90k| checknext(ls, TK_DO); 1552| 1.90k| prep = luaK_codeABx(fs, forprep[isgen], base, 0); 1553| 1.90k| enterblock(fs, &bl, 0); /* scope for declared variables */ 1554| 1.90k| adjustlocalvars(ls, nvars); 1555| 1.90k| luaK_reserveregs(fs, nvars); 1556| 1.90k| block(ls); 1557| 1.90k| leaveblock(fs); /* end of scope for declared variables */ 1558| 1.90k| fixforjump(fs, prep, luaK_getlabel(fs), 0); 1559| 1.90k| if (isgen) { /* generic for? */ ------------------ | Branch (1559:7): [True: 0, False: 1.90k] ------------------ 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| 1.90k| endfor = luaK_codeABx(fs, forloop[isgen], base, 0); 1564| 1.90k| fixforjump(fs, endfor, prep + 1, 1); 1565| 1.90k| luaK_fixline(fs, line); 1566| 1.90k|} lparser.c:fixforjump: 1530| 3.10k|static void fixforjump (FuncState *fs, int pc, int dest, int back) { 1531| 3.10k| Instruction *jmp = &fs->f->code[pc]; 1532| 3.10k| int offset = dest - (pc + 1); 1533| 3.10k| if (back) ------------------ | Branch (1533:7): [True: 1.55k, False: 1.55k] ------------------ 1534| 1.55k| offset = -offset; 1535| 3.10k| if (l_unlikely(offset > MAXARG_Bx)) ------------------ | | 697| 3.10k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 3.10k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 2, False: 3.10k] | | | | ------------------ | | ------------------ ------------------ 1536| 2| luaX_syntaxerror(fs->ls, "control structure too long"); 1537| 3.10k| SETARG_Bx(*jmp, offset); ------------------ | | 141| 3.10k|#define SETARG_Bx(i,v) setarg(i, v, POS_Bx, SIZE_Bx) | | ------------------ | | | | 122| 3.10k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 3.10k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 3.10k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 3.10k| ((cast(Instruction, v)<fs; 484| 5.22k| int needed = nvars - nexps; /* extra values needed */ 485| 5.22k| if (hasmultret(e->k)) { /* last expression has multiple returns? */ ------------------ | | 38| 5.22k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 358, False: 4.86k] | | | Branch (38:41): [True: 33, False: 4.83k] | | ------------------ ------------------ 486| 391| int extra = needed + 1; /* discount last expression itself */ 487| 391| if (extra < 0) ------------------ | Branch (487:9): [True: 30, False: 361] ------------------ 488| 30| extra = 0; 489| 391| luaK_setreturns(fs, e, extra); /* last exp. provides the difference */ 490| 391| } 491| 4.83k| else { 492| 4.83k| if (e->k != VVOID) /* at least one expression? */ ------------------ | Branch (492:9): [True: 3.83k, False: 1.00k] ------------------ 493| 3.83k| luaK_exp2nextreg(fs, e); /* close last expression */ 494| 4.83k| if (needed > 0) /* missing values? */ ------------------ | Branch (494:9): [True: 2.08k, False: 2.74k] ------------------ 495| 2.08k| luaK_nil(fs, fs->freereg, needed); /* complete with nils */ 496| 4.83k| } 497| 5.22k| if (needed > 0) ------------------ | Branch (497:7): [True: 2.41k, False: 2.80k] ------------------ 498| 2.41k| luaK_reserveregs(fs, needed); /* registers for extra values */ 499| 2.80k| else /* adding 'needed' is actually a subtraction */ 500| 2.80k| fs->freereg += needed; /* remove extra values */ 501| 5.22k|} lparser.c:marktobeclosed: 422| 151|static void marktobeclosed (FuncState *fs) { 423| 151| BlockCnt *bl = fs->bl; 424| 151| bl->upval = 1; 425| 151| bl->insidetbc = 1; 426| 151| fs->needclose = 1; 427| 151|} lparser.c:repeatstat: 1487| 564|static void repeatstat (LexState *ls, int line) { 1488| | /* repeatstat -> REPEAT block UNTIL cond */ 1489| 564| int condexit; 1490| 564| FuncState *fs = ls->fs; 1491| 564| int repeat_init = luaK_getlabel(fs); 1492| 564| BlockCnt bl1, bl2; 1493| 564| enterblock(fs, &bl1, 1); /* loop block */ 1494| 564| enterblock(fs, &bl2, 0); /* scope block */ 1495| 564| luaX_next(ls); /* skip REPEAT */ 1496| 564| statlist(ls); 1497| 564| check_match(ls, TK_UNTIL, TK_REPEAT, line); 1498| 564| condexit = cond(ls); /* read condition (inside scope block) */ 1499| 564| leaveblock(fs); /* finish scope */ 1500| 564| if (bl2.upval) { /* upvalues? */ ------------------ | Branch (1500:7): [True: 0, False: 564] ------------------ 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| 564| luaK_patchlist(fs, condexit, repeat_init); /* close the loop */ 1508| 564| leaveblock(fs); /* finish loop */ 1509| 564|} lparser.c:funcstat: 1782| 2.05k|static void funcstat (LexState *ls, int line) { 1783| | /* funcstat -> FUNCTION funcname body */ 1784| 2.05k| int ismethod; 1785| 2.05k| expdesc v, b; 1786| 2.05k| luaX_next(ls); /* skip FUNCTION */ 1787| 2.05k| ismethod = funcname(ls, &v); 1788| 2.05k| body(ls, &b, ismethod, line); 1789| 2.05k| check_readonly(ls, &v); 1790| 2.05k| luaK_storevar(ls->fs, &v, &b); 1791| 2.05k| luaK_fixline(ls->fs, line); /* definition "happens" in the first line */ 1792| 2.05k|} lparser.c:funcname: 1768| 2.05k|static int funcname (LexState *ls, expdesc *v) { 1769| | /* funcname -> NAME {fieldsel} [':' NAME] */ 1770| 2.05k| int ismethod = 0; 1771| 2.05k| singlevar(ls, v); 1772| 2.05k| while (ls->t.token == '.') ------------------ | Branch (1772:10): [True: 0, False: 2.05k] ------------------ 1773| 0| fieldsel(ls, v); 1774| 2.05k| if (ls->t.token == ':') { ------------------ | Branch (1774:7): [True: 9, False: 2.04k] ------------------ 1775| 9| ismethod = 1; 1776| 9| fieldsel(ls, v); 1777| 9| } 1778| 2.05k| return ismethod; 1779| 2.05k|} lparser.c:check_readonly: 277| 27.6k|static void check_readonly (LexState *ls, expdesc *e) { 278| 27.6k| FuncState *fs = ls->fs; 279| 27.6k| TString *varname = NULL; /* to be set if variable is const */ 280| 27.6k| switch (e->k) { 281| 1| case VCONST: { ------------------ | Branch (281:5): [True: 1, False: 27.6k] ------------------ 282| 1| varname = ls->dyd->actvar.arr[e->u.info].vd.name; 283| 1| break; 284| 0| } 285| 4.45k| case VLOCAL: { ------------------ | Branch (285:5): [True: 4.45k, False: 23.2k] ------------------ 286| 4.45k| Vardesc *vardesc = getlocalvardesc(fs, e->u.var.vidx); 287| 4.45k| if (vardesc->vd.kind != VDKREG) /* not a regular variable? */ ------------------ | | 90| 4.45k|#define VDKREG 0 /* regular */ ------------------ | Branch (287:11): [True: 1, False: 4.44k] ------------------ 288| 1| varname = vardesc->vd.name; 289| 4.45k| break; 290| 0| } 291| 1.75k| case VUPVAL: { ------------------ | Branch (291:5): [True: 1.75k, False: 25.9k] ------------------ 292| 1.75k| Upvaldesc *up = &fs->f->upvalues[e->u.info]; 293| 1.75k| if (up->kind != VDKREG) ------------------ | | 90| 1.75k|#define VDKREG 0 /* regular */ ------------------ | Branch (293:11): [True: 1, False: 1.75k] ------------------ 294| 1| varname = up->name; 295| 1.75k| break; 296| 0| } 297| 21.4k| default: ------------------ | Branch (297:5): [True: 21.4k, False: 6.20k] ------------------ 298| 21.4k| return; /* other cases cannot be read-only */ 299| 27.6k| } 300| 6.20k| if (varname) { ------------------ | Branch (300:7): [True: 3, False: 6.20k] ------------------ 301| 3| const char *msg = luaO_pushfstring(ls->L, 302| 3| "attempt to assign to const variable '%s'", getstr(varname)); ------------------ | | 404| 3|#define getstr(ts) ((ts)->contents) ------------------ 303| 3| luaK_semerror(ls, msg); /* error */ 304| 3| } 305| 6.20k|} lparser.c:testnext: 95| 151k|static int testnext (LexState *ls, int c) { 96| 151k| if (ls->t.token == c) { ------------------ | Branch (96:7): [True: 77.9k, False: 73.8k] ------------------ 97| 77.9k| luaX_next(ls); 98| 77.9k| return 1; 99| 77.9k| } 100| 73.8k| else return 0; 101| 151k|} lparser.c:localfunc: 1689| 765|static void localfunc (LexState *ls) { 1690| 765| expdesc b; 1691| 765| FuncState *fs = ls->fs; 1692| 765| int fvar = fs->nactvar; /* function's variable index */ 1693| 765| new_localvar(ls, str_checkname(ls)); /* new local variable */ 1694| 765| adjustlocalvars(ls, 1); /* enter its scope */ 1695| 765| body(ls, &b, 0, ls->linenumber); /* function created in next register */ 1696| | /* debug information will only see the variable after this point! */ 1697| 765| localdebuginfo(fs, fvar)->startpc = fs->pc; 1698| 765|} lparser.c:localstat: 1726| 1.94k|static void localstat (LexState *ls) { 1727| | /* stat -> LOCAL NAME ATTRIB { ',' NAME ATTRIB } ['=' explist] */ 1728| 1.94k| FuncState *fs = ls->fs; 1729| 1.94k| int toclose = -1; /* index of to-be-closed variable (if any) */ 1730| 1.94k| Vardesc *var; /* last variable */ 1731| 1.94k| int vidx, kind; /* index and kind of last variable */ 1732| 1.94k| int nvars = 0; 1733| 1.94k| int nexps; 1734| 1.94k| expdesc e; 1735| 4.23k| do { 1736| 4.23k| vidx = new_localvar(ls, str_checkname(ls)); 1737| 4.23k| kind = getlocalattribute(ls); 1738| 4.23k| getlocalvardesc(fs, vidx)->vd.kind = kind; 1739| 4.23k| if (kind == RDKTOCLOSE) { /* to-be-closed? */ ------------------ | | 92| 4.23k|#define RDKTOCLOSE 2 /* to-be-closed */ ------------------ | Branch (1739:9): [True: 151, False: 4.08k] ------------------ 1740| 151| if (toclose != -1) /* one already present? */ ------------------ | Branch (1740:11): [True: 0, False: 151] ------------------ 1741| 0| luaK_semerror(ls, "multiple to-be-closed variables in local list"); 1742| 151| toclose = fs->nactvar + nvars; 1743| 151| } 1744| 4.23k| nvars++; 1745| 4.23k| } while (testnext(ls, ',')); ------------------ | Branch (1745:12): [True: 2.28k, False: 1.94k] ------------------ 1746| 1.94k| if (testnext(ls, '=')) ------------------ | Branch (1746:7): [True: 942, False: 1.00k] ------------------ 1747| 942| nexps = explist(ls, &e); 1748| 1.00k| else { 1749| 1.00k| e.k = VVOID; 1750| 1.00k| nexps = 0; 1751| 1.00k| } 1752| 1.94k| var = getlocalvardesc(fs, vidx); /* get last variable */ 1753| 1.94k| if (nvars == nexps && /* no adjustments? */ ------------------ | Branch (1753:7): [True: 715, False: 1.23k] ------------------ 1754| 1.94k| var->vd.kind == RDKCONST && /* last variable is const? */ ------------------ | | 91| 2.66k|#define RDKCONST 1 /* constant */ ------------------ | Branch (1754:7): [True: 516, False: 199] ------------------ 1755| 1.94k| luaK_exp2const(fs, &e, &var->k)) { /* compile-time constant? */ ------------------ | Branch (1755:7): [True: 463, False: 53] ------------------ 1756| 463| var->vd.kind = RDKCTC; /* variable is a compile-time constant */ ------------------ | | 93| 463|#define RDKCTC 3 /* compile-time constant */ ------------------ 1757| 463| adjustlocalvars(ls, nvars - 1); /* exclude last variable */ 1758| 463| fs->nactvar++; /* but count it */ 1759| 463| } 1760| 1.48k| else { 1761| 1.48k| adjust_assign(ls, nvars, nexps, &e); 1762| 1.48k| adjustlocalvars(ls, nvars); 1763| 1.48k| } 1764| 1.94k| checktoclose(fs, toclose); 1765| 1.94k|} lparser.c:getlocalattribute: 1701| 4.23k|static int getlocalattribute (LexState *ls) { 1702| | /* ATTRIB -> ['<' Name '>'] */ 1703| 4.23k| if (testnext(ls, '<')) { ------------------ | Branch (1703:7): [True: 674, False: 3.55k] ------------------ 1704| 674| const char *attr = getstr(str_checkname(ls)); ------------------ | | 404| 674|#define getstr(ts) ((ts)->contents) ------------------ 1705| 674| checknext(ls, '>'); 1706| 674| if (strcmp(attr, "const") == 0) ------------------ | Branch (1706:9): [True: 523, False: 151] ------------------ 1707| 523| return RDKCONST; /* read-only variable */ ------------------ | | 91| 523|#define RDKCONST 1 /* constant */ ------------------ 1708| 151| else if (strcmp(attr, "close") == 0) ------------------ | Branch (1708:14): [True: 151, False: 0] ------------------ 1709| 151| return RDKTOCLOSE; /* to-be-closed variable */ ------------------ | | 92| 151|#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| 674| } 1714| 3.55k| return VDKREG; /* regular variable */ ------------------ | | 90| 3.55k|#define VDKREG 0 /* regular */ ------------------ 1715| 4.23k|} lparser.c:checktoclose: 1718| 1.94k|static void checktoclose (FuncState *fs, int level) { 1719| 1.94k| if (level != -1) { /* is there a to-be-closed variable? */ ------------------ | Branch (1719:7): [True: 151, False: 1.79k] ------------------ 1720| 151| marktobeclosed(fs); 1721| 151| luaK_codeABC(fs, OP_TBC, reglevel(fs, level), 0, 0); ------------------ | | 48| 151|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1722| 151| } 1723| 1.94k|} lparser.c:labelstat: 1458| 24|static void labelstat (LexState *ls, TString *name, int line) { 1459| | /* label -> '::' NAME '::' */ 1460| 24| checknext(ls, TK_DBCOLON); /* skip double colon */ 1461| 26| while (ls->t.token == ';' || ls->t.token == TK_DBCOLON) ------------------ | Branch (1461:10): [True: 2, False: 24] | Branch (1461:32): [True: 0, False: 24] ------------------ 1462| 2| statement(ls); /* skip other no-op statements */ 1463| 24| checkrepeated(ls, name); /* check for repeated labels */ 1464| 24| createlabel(ls, name, line, block_follow(ls, 0)); 1465| 24|} lparser.c:checkrepeated: 1448| 24|static void checkrepeated (LexState *ls, TString *name) { 1449| 24| Labeldesc *lb = findlabel(ls, name); 1450| 24| if (l_unlikely(lb != NULL)) { /* already defined? */ ------------------ | | 697| 24|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 24|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 24] | | | | ------------------ | | ------------------ ------------------ 1451| 0| const char *msg = "label '%s' already defined on line %d"; 1452| 0| msg = luaO_pushfstring(ls->L, msg, getstr(name), lb->line); ------------------ | | 404| 0|#define getstr(ts) ((ts)->contents) ------------------ 1453| 0| luaK_semerror(ls, msg); /* error */ 1454| 0| } 1455| 24|} lparser.c:findlabel: 544| 651|static Labeldesc *findlabel (LexState *ls, TString *name) { 545| 651| int i; 546| 651| Dyndata *dyd = ls->dyd; 547| | /* check labels in current function for a match */ 548| 722| for (i = ls->fs->firstlabel; i < dyd->label.n; i++) { ------------------ | Branch (548:32): [True: 580, False: 142] ------------------ 549| 580| Labeldesc *lb = &dyd->label.arr[i]; 550| 580| if (eqstr(lb->name, name)) /* correct label? */ ------------------ | | 43| 580|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 509, False: 71] | | ------------------ ------------------ 551| 509| return lb; 552| 580| } 553| 142| return NULL; /* label not found */ 554| 651|} lparser.c:str_checkname: 143| 5.04M|static TString *str_checkname (LexState *ls) { 144| 5.04M| TString *ts; 145| 5.04M| check(ls, TK_NAME); 146| 5.04M| ts = ls->t.seminfo.ts; 147| 5.04M| luaX_next(ls); 148| 5.04M| return ts; 149| 5.04M|} lparser.c:retstat: 1813| 2.95k|static void retstat (LexState *ls) { 1814| | /* stat -> RETURN [explist] [';'] */ 1815| 2.95k| FuncState *fs = ls->fs; 1816| 2.95k| expdesc e; 1817| 2.95k| int nret; /* number of values being returned */ 1818| 2.95k| int first = luaY_nvarstack(fs); /* first slot to be returned */ 1819| 2.95k| if (block_follow(ls, 1) || ls->t.token == ';') ------------------ | Branch (1819:7): [True: 0, False: 2.95k] | Branch (1819:30): [True: 0, False: 2.95k] ------------------ 1820| 0| nret = 0; /* return no values */ 1821| 2.95k| else { 1822| 2.95k| nret = explist(ls, &e); /* optional return values */ 1823| 2.95k| if (hasmultret(e.k)) { ------------------ | | 38| 2.95k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 1.24k, False: 1.71k] | | | Branch (38:41): [True: 9, False: 1.70k] | | ------------------ ------------------ 1824| 1.25k| luaK_setmultret(fs, &e); ------------------ | | 58| 1.25k|#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) | | ------------------ | | | | 35| 1.25k|#define LUA_MULTRET (-1) | | ------------------ ------------------ 1825| 1.25k| if (e.k == VCALL && nret == 1 && !fs->bl->insidetbc) { /* tail call? */ ------------------ | Branch (1825:11): [True: 1.24k, False: 9] | Branch (1825:27): [True: 1.13k, False: 116] | Branch (1825:40): [True: 1.11k, False: 16] ------------------ 1826| 1.11k| SET_OPCODE(getinstruction(fs,&e), OP_TAILCALL); ------------------ | | 115| 1.11k|#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ | | ------------------ | | | | 108| 1.11k|#define MASK0(n,p) (~MASK1(n,p)) | | | | ------------------ | | | | | | 105| 1.11k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | ------------------ | | ------------------ | | 116| 1.11k| ((cast(Instruction, o)<freereg - first); ------------------ | | 106| 840|#define lua_assert(c) assert(c) ------------------ 1837| 840| } 1838| 1.70k| } 1839| 2.95k| } 1840| 2.95k| luaK_ret(fs, first, nret); 1841| 2.95k| testnext(ls, ';'); /* skip optional semicolon */ 1842| 2.95k|} lparser.c:breakstat: 1438| 569|static void breakstat (LexState *ls) { 1439| 569| int line = ls->linenumber; 1440| 569| luaX_next(ls); /* skip break */ 1441| 569| newgotoentry(ls, luaS_newliteral(ls->L, "break"), line, luaK_jump(ls->fs)); ------------------ | | 28| 569|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 569| (sizeof(s)/sizeof(char))-1)) ------------------ 1442| 569|} lparser.c:gotostat: 1416| 627|static void gotostat (LexState *ls) { 1417| 627| FuncState *fs = ls->fs; 1418| 627| int line = ls->linenumber; 1419| 627| TString *name = str_checkname(ls); /* label's name */ 1420| 627| Labeldesc *lb = findlabel(ls, name); 1421| 627| if (lb == NULL) /* no label? */ ------------------ | Branch (1421:7): [True: 118, False: 509] ------------------ 1422| | /* forward jump; will be resolved when the label is declared */ 1423| 118| newgotoentry(ls, name, line, luaK_jump(fs)); 1424| 509| else { /* found a label */ 1425| | /* backward jump; will be resolved here */ 1426| 509| int lblevel = reglevel(fs, lb->nactvar); /* label level */ 1427| 509| if (luaY_nvarstack(fs) > lblevel) /* leaving the scope of a variable? */ ------------------ | Branch (1427:9): [True: 308, False: 201] ------------------ 1428| 308| luaK_codeABC(fs, OP_CLOSE, lblevel, 0, 0); ------------------ | | 48| 308|#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| 509| luaK_patchlist(fs, luaK_jump(fs), lb->pc); 1431| 509| } 1432| 627|} lparser.c:exprstat: 1795| 22.6k|static void exprstat (LexState *ls) { 1796| | /* stat -> func | assignment */ 1797| 22.6k| FuncState *fs = ls->fs; 1798| 22.6k| struct LHS_assign v; 1799| 22.6k| suffixedexp(ls, &v.v); 1800| 22.6k| if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */ ------------------ | Branch (1800:7): [True: 19.6k, False: 3.05k] | Branch (1800:29): [True: 1.75k, False: 1.30k] ------------------ 1801| 21.3k| v.prev = NULL; 1802| 21.3k| restassign(ls, &v, 1); 1803| 21.3k| } 1804| 1.34k| else { /* stat -> func */ 1805| 1.34k| Instruction *inst; 1806| 1.34k| check_condition(ls, v.v.k == VCALL, "syntax error"); ------------------ | | 122| 1.34k|#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } | | ------------------ | | | Branch (122:41): [True: 11, False: 1.33k] | | ------------------ ------------------ 1807| 1.33k| inst = &getinstruction(fs, &v.v); ------------------ | | 55| 1.33k|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 1808| 1.33k| SETARG_C(*inst, 1); /* call statement uses no results */ ------------------ | | 134| 1.33k|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 1.33k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 1.33k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 1.33k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 1.33k| ((cast(Instruction, v)<v.k), "syntax error"); ------------------ | | 122| 51.6k|#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } | | ------------------ | | | Branch (122:43): [True: 25.8k, False: 0] | | | Branch (122:43): [True: 25.8k, False: 0] | | ------------------ ------------------ 1378| 25.8k| check_readonly(ls, &lh->v); 1379| 25.8k| if (testnext(ls, ',')) { /* restassign -> ',' suffixedexp restassign */ ------------------ | Branch (1379:7): [True: 4.45k, False: 21.3k] ------------------ 1380| 4.45k| struct LHS_assign nv; 1381| 4.45k| nv.prev = lh; 1382| 4.45k| suffixedexp(ls, &nv.v); 1383| 4.45k| if (!vkisindexed(nv.v.k)) ------------------ | | 65| 4.45k|#define vkisindexed(k) (VINDEXED <= (k) && (k) <= VINDEXSTR) | | ------------------ | | | Branch (65:25): [True: 3.32k, False: 1.13k] | | | Branch (65:44): [True: 3.32k, False: 0] | | ------------------ ------------------ 1384| 1.13k| check_conflict(ls, lh, &nv.v); 1385| 4.45k| enterlevel(ls); /* control recursion depth */ ------------------ | | 504| 4.45k|#define enterlevel(ls) luaE_incCstack(ls->L) ------------------ 1386| 4.45k| restassign(ls, &nv, nvars+1); 1387| 4.45k| leavelevel(ls); ------------------ | | 507| 4.45k|#define leavelevel(ls) ((ls)->L->nCcalls--) ------------------ 1388| 4.45k| } 1389| 21.3k| else { /* restassign -> '=' explist */ 1390| 21.3k| int nexps; 1391| 21.3k| checknext(ls, '='); 1392| 21.3k| nexps = explist(ls, &e); 1393| 21.3k| if (nexps != nvars) ------------------ | Branch (1393:9): [True: 3.74k, False: 17.6k] ------------------ 1394| 3.74k| adjust_assign(ls, nvars, nexps, &e); 1395| 17.6k| else { 1396| 17.6k| luaK_setoneret(ls->fs, &e); /* close last expression */ 1397| 17.6k| luaK_storevar(ls->fs, &lh->v, &e); 1398| 17.6k| return; /* avoid default */ 1399| 17.6k| } 1400| 21.3k| } 1401| 8.19k| init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */ 1402| 8.19k| luaK_storevar(ls->fs, &lh->v, &e); 1403| 8.19k|} lparser.c:check_conflict: 1331| 1.13k|static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) { 1332| 1.13k| FuncState *fs = ls->fs; 1333| 1.13k| int extra = fs->freereg; /* eventual position to save local variable */ 1334| 1.13k| int conflict = 0; 1335| 4.48k| for (; lh; lh = lh->prev) { /* check all previous assignments */ ------------------ | Branch (1335:10): [True: 3.35k, False: 1.13k] ------------------ 1336| 3.35k| if (vkisindexed(lh->v.k)) { /* assignment to table field? */ ------------------ | | 65| 3.35k|#define vkisindexed(k) (VINDEXED <= (k) && (k) <= VINDEXSTR) | | ------------------ | | | Branch (65:25): [True: 1.91k, False: 1.44k] | | | Branch (65:44): [True: 1.91k, False: 0] | | ------------------ ------------------ 1337| 1.91k| if (lh->v.k == VINDEXUP) { /* is table an upvalue? */ ------------------ | Branch (1337:11): [True: 1.90k, False: 8] ------------------ 1338| 1.90k| if (v->k == VUPVAL && lh->v.u.ind.t == v->u.info) { ------------------ | Branch (1338:13): [True: 1.78k, False: 123] | Branch (1338:31): [True: 141, False: 1.63k] ------------------ 1339| 141| conflict = 1; /* table is the upvalue being assigned now */ 1340| 141| lh->v.k = VINDEXSTR; 1341| 141| lh->v.u.ind.t = extra; /* assignment will use safe copy */ 1342| 141| } 1343| 1.90k| } 1344| 8| else { /* table is a register */ 1345| 8| if (v->k == VLOCAL && lh->v.u.ind.t == v->u.var.ridx) { ------------------ | Branch (1345:13): [True: 3, False: 5] | Branch (1345:31): [True: 0, False: 3] ------------------ 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| 8| if (lh->v.k == VINDEXED && v->k == VLOCAL && ------------------ | Branch (1350:13): [True: 0, False: 8] | Branch (1350:36): [True: 0, False: 0] ------------------ 1351| 8| 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| 8| } 1356| 1.91k| } 1357| 3.35k| } 1358| 1.13k| if (conflict) { ------------------ | Branch (1358:7): [True: 141, False: 989] ------------------ 1359| | /* copy upvalue/local value to a temporary (in position 'extra') */ 1360| 141| if (v->k == VLOCAL) ------------------ | Branch (1360:9): [True: 0, False: 141] ------------------ 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| 141| else 1363| 141| luaK_codeABC(fs, OP_GETUPVAL, extra, v->u.info, 0); ------------------ | | 48| 141|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1364| 141| luaK_reserveregs(fs, 1); 1365| 141| } 1366| 1.13k|} lparser.c:check: 107| 5.09M|static void check (LexState *ls, int c) { 108| 5.09M| if (ls->t.token != c) ------------------ | Branch (108:7): [True: 7, False: 5.09M] ------------------ 109| 7| error_expected(ls, c); 110| 5.09M|} lparser.c:close_func: 756| 2.73k|static void close_func (LexState *ls) { 757| 2.73k| lua_State *L = ls->L; 758| 2.73k| FuncState *fs = ls->fs; 759| 2.73k| Proto *f = fs->f; 760| 2.73k| luaK_ret(fs, luaY_nvarstack(fs), 0); /* final return */ 761| 2.73k| leaveblock(fs); 762| 2.73k| lua_assert(fs->bl == NULL); ------------------ | | 106| 2.73k|#define lua_assert(c) assert(c) ------------------ 763| 2.73k| luaK_finish(fs); 764| 2.73k| luaM_shrinkvector(L, f->code, f->sizecode, fs->pc, Instruction); ------------------ | | 75| 2.73k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.73k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 765| 2.73k| luaM_shrinkvector(L, f->lineinfo, f->sizelineinfo, fs->pc, ls_byte); ------------------ | | 75| 2.73k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.73k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 766| 2.73k| luaM_shrinkvector(L, f->abslineinfo, f->sizeabslineinfo, ------------------ | | 75| 2.73k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.73k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 767| 2.73k| fs->nabslineinfo, AbsLineInfo); 768| 2.73k| luaM_shrinkvector(L, f->k, f->sizek, fs->nk, TValue); ------------------ | | 75| 2.73k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.73k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 769| 2.73k| luaM_shrinkvector(L, f->p, f->sizep, fs->np, Proto *); ------------------ | | 75| 2.73k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.73k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 770| 2.73k| luaM_shrinkvector(L, f->locvars, f->sizelocvars, fs->ndebugvars, LocVar); ------------------ | | 75| 2.73k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.73k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 771| 2.73k| luaM_shrinkvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc); ------------------ | | 75| 2.73k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.73k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 772| 2.73k| ls->fs = fs->prev; 773| 2.73k| luaC_checkGC(L); ------------------ | | 172| 2.73k|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 2.73k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 2.73k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 46, False: 2.68k] | | | | ------------------ | | | | 169| 2.73k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 2.73k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 774| 2.73k|} luaE_setdebt: 89| 1.11k|void luaE_setdebt (global_State *g, l_mem debt) { 90| 1.11k| l_mem tb = gettotalbytes(g); ------------------ | | 394| 1.11k|#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) | | ------------------ | | | | 136| 1.11k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 91| 1.11k| lua_assert(tb > 0); ------------------ | | 106| 1.11k|#define lua_assert(c) assert(c) ------------------ 92| 1.11k| if (debt < tb - MAX_LMEM) ------------------ | | 50| 1.11k|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 1.11k|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ | Branch (92:7): [True: 0, False: 1.11k] ------------------ 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.11k| g->totalbytes = tb - debt; 95| 1.11k| g->GCdebt = debt; 96| 1.11k|} luaE_extendCI: 105| 108|CallInfo *luaE_extendCI (lua_State *L) { 106| 108| CallInfo *ci; 107| 108| lua_assert(L->ci->next == NULL); ------------------ | | 106| 108|#define lua_assert(c) assert(c) ------------------ 108| 108| ci = luaM_new(L, CallInfo); ------------------ | | 59| 108|#define luaM_new(L,t) cast(t*, luaM_malloc_(L, sizeof(t), 0)) | | ------------------ | | | | 136| 108|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 109| 108| lua_assert(L->ci->next == NULL); ------------------ | | 106| 108|#define lua_assert(c) assert(c) ------------------ 110| 108| L->ci->next = ci; 111| 108| ci->previous = L->ci; 112| 108| ci->next = NULL; 113| 108| ci->u.l.trap = 0; 114| 108| L->nci++; 115| 108| return ci; 116| 108|} luaE_shrinkCI: 138| 1.32k|void luaE_shrinkCI (lua_State *L) { 139| 1.32k| CallInfo *ci = L->ci->next; /* first free CallInfo */ 140| 1.32k| CallInfo *next; 141| 1.32k| if (ci == NULL) ------------------ | Branch (141:7): [True: 1.07k, False: 251] ------------------ 142| 1.07k| return; /* no extra elements */ 143| 263| while ((next = ci->next) != NULL) { /* two extra elements? */ ------------------ | Branch (143:10): [True: 48, False: 215] ------------------ 144| 48| CallInfo *next2 = next->next; /* next's next */ 145| 48| ci->next = next2; /* remove next from the list */ 146| 48| L->nci--; 147| 48| luaM_free(L, next); /* free next */ ------------------ | | 56| 48|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 148| 48| if (next2 == NULL) ------------------ | Branch (148:9): [True: 36, False: 12] ------------------ 149| 36| break; /* no more elements */ 150| 12| else { 151| 12| next2->previous = ci; 152| 12| ci = next2; /* continue */ 153| 12| } 154| 48| } 155| 251|} 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 */ ------------------ | | 53| 0|#define LUA_ERRERR 5 ------------------ 170| 2|} luaE_incCstack: 173| 5.39M|LUAI_FUNC void luaE_incCstack (lua_State *L) { 174| 5.39M| L->nCcalls++; 175| 5.39M| if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) ------------------ | | 697| 5.39M|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 5.39M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 2, False: 5.39M] | | | | ------------------ | | ------------------ ------------------ 176| 2| luaE_checkcstack(L); 177| 5.39M|} lua_newstate: 360| 225|LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) { 361| 225| int i; 362| 225| lua_State *L; 363| 225| global_State *g; 364| 225| LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG))); ------------------ | | 136| 225|#define cast(t, exp) ((t)(exp)) ------------------ 365| 225| if (l == NULL) return NULL; ------------------ | Branch (365:7): [True: 0, False: 225] ------------------ 366| 225| L = &l->l.l; 367| 225| g = &l->g; 368| 225| L->tt = LUA_VTHREAD; ------------------ | | 262| 225|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 225|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 369| 225| g->currentwhite = bitmask(WHITE0BIT); ------------------ | | 63| 225|#define bitmask(b) (1<<(b)) ------------------ 370| 225| L->marked = luaC_white(g); ------------------ | | 102| 225|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 143| 225|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 371| 225| preinit_thread(L, g); 372| 225| g->allgc = obj2gco(L); /* by now, only object is the main thread */ ------------------ | | 390| 225|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 110| 225|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 373| 0| L->next = NULL; 374| 225| incnny(L); /* main thread is always non yieldable */ ------------------ | | 111| 225|#define incnny(L) ((L)->nCcalls += 0x10000) ------------------ 375| 225| g->frealloc = f; 376| 225| g->ud = ud; 377| 225| g->warnf = NULL; 378| 225| g->ud_warn = NULL; 379| 225| g->mainthread = L; 380| 225| g->seed = luai_makeseed(L); 381| 225| g->gcstp = GCSTPGC; /* no GC while building state */ ------------------ | | 156| 225|#define GCSTPGC 2 /* bit true when GC stopped by itself */ ------------------ 382| 225| g->strt.size = g->strt.nuse = 0; 383| 225| g->strt.hash = NULL; 384| 225| setnilvalue(&g->l_registry); ------------------ | | 200| 225|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 225|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 385| 225| g->panic = NULL; 386| 225| g->gcstate = GCSpause; ------------------ | | 39| 225|#define GCSpause 8 ------------------ 387| 225| g->gckind = KGC_INC; ------------------ | | 151| 225|#define KGC_INC 0 /* incremental gc */ ------------------ 388| 225| g->gcstopem = 0; 389| 225| g->gcemergency = 0; 390| 225| g->finobj = g->tobefnz = g->fixedgc = NULL; 391| 225| g->firstold1 = g->survival = g->old1 = g->reallyold = NULL; 392| 225| g->finobjsur = g->finobjold1 = g->finobjrold = NULL; 393| 225| g->sweepgc = NULL; 394| 225| g->gray = g->grayagain = NULL; 395| 225| g->weak = g->ephemeron = g->allweak = NULL; 396| 225| g->twups = NULL; 397| 225| g->totalbytes = sizeof(LG); 398| 225| g->GCdebt = 0; 399| 225| g->lastatomic = 0; 400| 225| setivalue(&g->nilvalue, 0); /* to signal that state is not yet built */ ------------------ | | 345| 225| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 225|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 225|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 401| 225| setgcparam(g->gcpause, LUAI_GCPAUSE); ------------------ | | 136| 225|#define setgcparam(p,v) ((p) = (v) / 4) ------------------ 402| 225| setgcparam(g->gcstepmul, LUAI_GCMUL); ------------------ | | 136| 225|#define setgcparam(p,v) ((p) = (v) / 4) ------------------ 403| 225| g->gcstepsize = LUAI_GCSTEPSIZE; ------------------ | | 141| 225|#define LUAI_GCSTEPSIZE 13 /* 8 KB */ ------------------ 404| 225| setgcparam(g->genmajormul, LUAI_GENMAJORMUL); ------------------ | | 136| 225|#define setgcparam(p,v) ((p) = (v) / 4) ------------------ 405| 225| g->genminormul = LUAI_GENMINORMUL; ------------------ | | 126| 225|#define LUAI_GENMINORMUL 20 ------------------ 406| 2.25k| for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL; ------------------ | | 426| 2.25k|#define LUA_NUMTAGS LUA_NUMTYPES | | ------------------ | | | | 74| 2.25k|#define LUA_NUMTYPES 9 | | ------------------ ------------------ | Branch (406:13): [True: 2.02k, False: 225] ------------------ 407| 225| if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) { ------------------ | | 48| 225|#define LUA_OK 0 ------------------ | Branch (407:7): [True: 0, False: 225] ------------------ 408| | /* memory allocation error: free partial state */ 409| 0| close_state(L); 410| 0| L = NULL; 411| 0| } 412| 225| return L; 413| 225|} lua_close: 416| 225|LUA_API void lua_close (lua_State *L) { 417| 225| lua_lock(L); ------------------ | | 264| 225|#define lua_lock(L) ((void) 0) ------------------ 418| 225| L = G(L)->mainthread; /* only the main thread can be closed */ ------------------ | | 335| 225|#define G(L) (L->l_G) ------------------ 419| 225| close_state(L); 420| 225|} lstate.c:preinit_thread: 249| 225|static void preinit_thread (lua_State *L, global_State *g) { 250| 225| G(L) = g; ------------------ | | 335| 225|#define G(L) (L->l_G) ------------------ 251| 225| L->stack.p = NULL; 252| 225| L->ci = NULL; 253| 225| L->nci = 0; 254| 225| L->twups = L; /* thread has no upvalues */ 255| 225| L->nCcalls = 0; 256| 225| L->errorJmp = NULL; 257| 225| L->hook = NULL; 258| 225| L->hookmask = 0; 259| 225| L->basehookcount = 0; 260| 225| L->allowhook = 1; 261| 225| resethookcount(L); ------------------ | | 21| 225|#define resethookcount(L) (L->hookcount = L->basehookcount) ------------------ 262| 225| L->openupval = NULL; 263| 225| L->status = LUA_OK; ------------------ | | 48| 225|#define LUA_OK 0 ------------------ 264| 225| L->errfunc = 0; 265| 225| L->oldpc = 0; 266| 225|} lstate.c:stack_init: 180| 225|static void stack_init (lua_State *L1, lua_State *L) { 181| 225| int i; CallInfo *ci; 182| | /* initialize stack array */ 183| 225| L1->stack.p = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, StackValue); ------------------ | | 60| 225|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 184| 225| L1->tbclist.p = L1->stack.p; 185| 10.3k| for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++) ------------------ | | 145| 10.3k|#define BASIC_STACK_SIZE (2*LUA_MINSTACK) | | ------------------ | | | | 79| 10.3k|#define LUA_MINSTACK 20 | | ------------------ ------------------ for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++) ------------------ | | 142| 10.3k|#define EXTRA_STACK 5 ------------------ | Branch (185:15): [True: 10.1k, False: 225] ------------------ 186| 10.1k| setnilvalue(s2v(L1->stack.p + i)); /* erase new stack */ ------------------ | | 200| 10.1k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 10.1k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 187| 225| L1->top.p = L1->stack.p; 188| 225| L1->stack_last.p = L1->stack.p + BASIC_STACK_SIZE; ------------------ | | 145| 225|#define BASIC_STACK_SIZE (2*LUA_MINSTACK) | | ------------------ | | | | 79| 225|#define LUA_MINSTACK 20 | | ------------------ ------------------ 189| | /* initialize first ci */ 190| 225| ci = &L1->base_ci; 191| 225| ci->next = ci->previous = NULL; 192| 225| ci->callstatus = CIST_C; ------------------ | | 211| 225|#define CIST_C (1<<1) /* call is running a C function */ ------------------ 193| 225| ci->func.p = L1->top.p; 194| 225| ci->u.c.k = NULL; 195| 225| ci->nresults = 0; 196| 225| setnilvalue(s2v(L1->top.p)); /* 'function' entry for this 'ci' */ ------------------ | | 200| 225|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 225|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 197| 225| L1->top.p++; 198| 225| ci->top.p = L1->top.p + LUA_MINSTACK; ------------------ | | 79| 225|#define LUA_MINSTACK 20 ------------------ 199| 225| L1->ci = ci; 200| 225|} lstate.c:freestack: 203| 225|static void freestack (lua_State *L) { 204| 225| if (L->stack.p == NULL) ------------------ | Branch (204:7): [True: 0, False: 225] ------------------ 205| 0| return; /* stack not completely built yet */ 206| 225| L->ci = &L->base_ci; /* free the entire 'ci' list */ 207| 225| freeCI(L); 208| 225| lua_assert(L->nci == 0); ------------------ | | 106| 225|#define lua_assert(c) assert(c) ------------------ 209| 225| luaM_freearray(L, L->stack.p, stacksize(L) + EXTRA_STACK); /* free stack */ ------------------ | | 57| 225|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 210| 225|} lstate.c:freeCI: 122| 225|static void freeCI (lua_State *L) { 123| 225| CallInfo *ci = L->ci; 124| 225| CallInfo *next = ci->next; 125| 225| ci->next = NULL; 126| 285| while ((ci = next) != NULL) { ------------------ | Branch (126:10): [True: 60, False: 225] ------------------ 127| 60| next = ci->next; 128| 60| luaM_free(L, ci); ------------------ | | 56| 60|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 129| 60| L->nci--; 130| 60| } 131| 225|} lstate.c:luai_makeseed: 71| 225|static unsigned int luai_makeseed (lua_State *L) { 72| 225| char buff[3 * sizeof(size_t)]; 73| 225| unsigned int h = cast_uint(time(NULL)); ------------------ | | 142| 225|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 74| 225| int p = 0; 75| 225| addbuff(buff, p, L); /* heap variable */ ------------------ | | 68| 225| { size_t t = cast_sizet(e); \ | | ------------------ | | | | 147| 225|#define cast_sizet(i) cast(size_t, (i)) | | | | ------------------ | | | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 69| 225| memcpy(b + p, &t, sizeof(t)); p += sizeof(t); } ------------------ 76| 225| addbuff(buff, p, &h); /* local variable */ ------------------ | | 68| 225| { size_t t = cast_sizet(e); \ | | ------------------ | | | | 147| 225|#define cast_sizet(i) cast(size_t, (i)) | | | | ------------------ | | | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 69| 225| memcpy(b + p, &t, sizeof(t)); p += sizeof(t); } ------------------ 77| 225| addbuff(buff, p, &lua_newstate); /* public function */ ------------------ | | 68| 225| { size_t t = cast_sizet(e); \ | | ------------------ | | | | 147| 225|#define cast_sizet(i) cast(size_t, (i)) | | | | ------------------ | | | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 69| 225| memcpy(b + p, &t, sizeof(t)); p += sizeof(t); } ------------------ 78| 225| lua_assert(p == sizeof(buff)); ------------------ | | 106| 225|#define lua_assert(c) assert(c) ------------------ 79| 225| return luaS_hash(buff, p, h); 80| 225|} lstate.c:f_luaopen: 231| 225|static void f_luaopen (lua_State *L, void *ud) { 232| 225| global_State *g = G(L); ------------------ | | 335| 225|#define G(L) (L->l_G) ------------------ 233| 225| UNUSED(ud); ------------------ | | 131| 225|#define UNUSED(x) ((void)(x)) ------------------ 234| 225| stack_init(L, L); /* init stack */ 235| 225| init_registry(L, g); 236| 225| luaS_init(L); 237| 225| luaT_init(L); 238| 225| luaX_init(L); 239| 225| g->gcstp = 0; /* allow gc */ 240| 225| setnilvalue(&g->nilvalue); /* now state is complete */ ------------------ | | 200| 225|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 225|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 241| 225| luai_userstateopen(L); ------------------ | | 282| 225|#define luai_userstateopen(L) ((void)L) ------------------ 242| 225|} lstate.c:init_registry: 216| 225|static void init_registry (lua_State *L, global_State *g) { 217| | /* create registry */ 218| 225| Table *registry = luaH_new(L); 219| 225| sethvalue(L, &g->l_registry, registry); ------------------ | | 685| 225| { TValue *io = (obj); Table *x_ = (x); \ | | 686| 225| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 225|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 390| 225|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 225|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 225|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 687| 225| checkliveness(L,io); } | | ------------------ | | | | 107| 225| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 3.60k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | ------------------ | | | | ------------------ | | | | 108| 225| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 220| 225| luaH_resize(L, registry, LUA_RIDX_LAST, 0); ------------------ | | 85| 225|#define LUA_RIDX_LAST LUA_RIDX_GLOBALS | | ------------------ | | | | 84| 225|#define LUA_RIDX_GLOBALS 2 | | ------------------ ------------------ 221| | /* registry[LUA_RIDX_MAINTHREAD] = L */ 222| 225| setthvalue(L, ®istry->array[LUA_RIDX_MAINTHREAD - 1], L); ------------------ | | 269| 225| { TValue *io = (obj); lua_State *x_ = (x); \ | | 270| 225| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 72| 225|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 390| 225|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 225|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 114| 225|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 271| 225| checkliveness(L,io); } | | ------------------ | | | | 107| 225| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 3.60k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | ------------------ | | | | ------------------ | | | | 108| 225| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 223| | /* registry[LUA_RIDX_GLOBALS] = new table (table of globals) */ 224| 225| sethvalue(L, ®istry->array[LUA_RIDX_GLOBALS - 1], luaH_new(L)); ------------------ | | 685| 225| { TValue *io = (obj); Table *x_ = (x); \ | | 686| 225| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 225|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 390| 225|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 225|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 225|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 687| 225| checkliveness(L,io); } | | ------------------ | | | | 107| 225| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 3.60k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | Branch (112:29): [True: 225, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 225] | | | | | | ------------------ | | | | ------------------ | | | | 108| 225| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 225| 225|} lstate.c:close_state: 269| 225|static void close_state (lua_State *L) { 270| 225| global_State *g = G(L); ------------------ | | 335| 225|#define G(L) (L->l_G) ------------------ 271| 225| if (!completestate(g)) /* closing a partially built state? */ ------------------ | | 341| 225|#define completestate(g) ttisnil(&g->nilvalue) | | ------------------ | | | | 193| 225|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 225|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 225|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 225|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (271:7): [True: 0, False: 225] ------------------ 272| 0| luaC_freeallobjects(L); /* just collect its objects */ 273| 225| else { /* closing a fully built state */ 274| 225| L->ci = &L->base_ci; /* unwind CallInfo list */ 275| 225| luaD_closeprotected(L, 1, LUA_OK); /* close all upvalues */ ------------------ | | 48| 225|#define LUA_OK 0 ------------------ 276| 225| luaC_freeallobjects(L); /* collect all objects */ 277| 225| luai_userstateclose(L); ------------------ | | 286| 225|#define luai_userstateclose(L) ((void)L) ------------------ 278| 225| } 279| 225| luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size); ------------------ | | 57| 225|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 280| 225| freestack(L); 281| 225| lua_assert(gettotalbytes(g) == sizeof(LG)); ------------------ | | 106| 225|#define lua_assert(c) assert(c) ------------------ 282| 225| (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0); /* free main block */ ------------------ | | 51| 225|#define fromstate(L) (cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l))) | | ------------------ | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 283| 225|} luaS_eqlngstr: 34| 55.1k|int luaS_eqlngstr (TString *a, TString *b) { 35| 55.1k| size_t len = a->u.lnglen; 36| 55.1k| lua_assert(a->tt == LUA_VLNGSTR && b->tt == LUA_VLNGSTR); ------------------ | | 106| 55.1k|#define lua_assert(c) assert(c) ------------------ 37| 55.1k| return (a == b) || /* same instance or... */ ------------------ | Branch (37:10): [True: 32.8k, False: 22.2k] ------------------ 38| 55.1k| ((len == b->u.lnglen) && /* equal length and ... */ ------------------ | Branch (38:6): [True: 17.1k, False: 5.18k] ------------------ 39| 22.2k| (memcmp(getlngstr(a), getlngstr(b), len) == 0)); /* equal contents */ ------------------ | | 405| 17.1k|#define getlngstr(ts) check_exp((ts)->shrlen == 0xFF, (ts)->contents) | | ------------------ | | | | 110| 17.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 17.1k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ (memcmp(getlngstr(a), getlngstr(b), len) == 0)); /* equal contents */ ------------------ | | 405| 17.1k|#define getlngstr(ts) check_exp((ts)->shrlen == 0xFF, (ts)->contents) | | ------------------ | | | | 110| 17.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 17.1k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (39:6): [True: 16.9k, False: 144] ------------------ 40| 55.1k|} luaS_hash: 43| 5.49M|unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) { 44| 5.49M| unsigned int h = seed ^ cast_uint(l); ------------------ | | 142| 5.49M|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 5.49M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 45| 23.4M| for (; l > 0; l--) ------------------ | Branch (45:10): [True: 17.9M, False: 5.49M] ------------------ 46| 17.9M| h ^= ((h<<5) + (h>>2) + cast_byte(str[l - 1])); ------------------ | | 143| 17.9M|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 17.9M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 47| 5.49M| return h; 48| 5.49M|} luaS_hashlongstr: 51| 58.6k|unsigned int luaS_hashlongstr (TString *ts) { 52| 58.6k| lua_assert(ts->tt == LUA_VLNGSTR); ------------------ | | 106| 58.6k|#define lua_assert(c) assert(c) ------------------ 53| 58.6k| if (ts->extra == 0) { /* no hash? */ ------------------ | Branch (53:7): [True: 18.0k, False: 40.6k] ------------------ 54| 18.0k| size_t len = ts->u.lnglen; 55| 18.0k| ts->hash = luaS_hash(getlngstr(ts), len, ts->hash); ------------------ | | 405| 18.0k|#define getlngstr(ts) check_exp((ts)->shrlen == 0xFF, (ts)->contents) | | ------------------ | | | | 110| 18.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 18.0k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 56| 0| ts->extra = 1; /* now it has its hash */ 57| 18.0k| } 58| 58.6k| return ts->hash; 59| 58.6k|} luaS_resize: 85| 379|void luaS_resize (lua_State *L, int nsize) { 86| 379| stringtable *tb = &G(L)->strt; ------------------ | | 335| 379|#define G(L) (L->l_G) ------------------ 87| 379| int osize = tb->size; 88| 379| TString **newvect; 89| 379| if (nsize < osize) /* shrinking table? */ ------------------ | Branch (89:7): [True: 162, False: 217] ------------------ 90| 162| tablerehash(tb->hash, osize, nsize); /* depopulate shrinking part */ 91| 379| newvect = luaM_reallocvector(L, tb->hash, osize, nsize, TString*); ------------------ | | 71| 379| (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \ | | ------------------ | | | | 136| 379|#define cast(t, exp) ((t)(exp)) | | ------------------ | | 72| 379| cast_sizet(n) * sizeof(t)))) ------------------ 92| 379| if (l_unlikely(newvect == NULL)) { /* reallocation failed? */ ------------------ | | 697| 379|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 379|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 379] | | | | ------------------ | | ------------------ ------------------ 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| 379| else { /* allocation succeeded */ 98| 379| tb->hash = newvect; 99| 379| tb->size = nsize; 100| 379| if (nsize > osize) ------------------ | Branch (100:9): [True: 217, False: 162] ------------------ 101| 217| tablerehash(newvect, osize, nsize); /* rehash for new size */ 102| 379| } 103| 379|} luaS_clearcache: 110| 1.10k|void luaS_clearcache (global_State *g) { 111| 1.10k| int i, j; 112| 59.5k| for (i = 0; i < STRCACHE_N; i++) ------------------ | | 237| 59.5k|#define STRCACHE_N 53 ------------------ | Branch (112:15): [True: 58.4k, False: 1.10k] ------------------ 113| 175k| for (j = 0; j < STRCACHE_M; j++) { ------------------ | | 238| 175k|#define STRCACHE_M 2 ------------------ | Branch (113:17): [True: 116k, False: 58.4k] ------------------ 114| 116k| if (iswhite(g->strcache[i][j])) /* will entry be collected? */ ------------------ | | 87| 116k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 116k|#define testbits(x,m) ((x) & (m)) | | | | ------------------ | | | | | Branch (62:24): [True: 3, False: 116k] | | | | ------------------ | | ------------------ ------------------ 115| 3| g->strcache[i][j] = g->memerrmsg; /* replace it with something fixed */ 116| 116k| } 117| 1.10k|} luaS_init: 123| 225|void luaS_init (lua_State *L) { 124| 225| global_State *g = G(L); ------------------ | | 335| 225|#define G(L) (L->l_G) ------------------ 125| 225| int i, j; 126| 225| stringtable *tb = &G(L)->strt; ------------------ | | 335| 225|#define G(L) (L->l_G) ------------------ 127| 225| tb->hash = luaM_newvector(L, MINSTRTABSIZE, TString*); ------------------ | | 60| 225|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 128| 225| tablerehash(tb->hash, 0, MINSTRTABSIZE); /* clear array */ ------------------ | | 227| 225|#define MINSTRTABSIZE 128 ------------------ 129| 225| tb->size = MINSTRTABSIZE; ------------------ | | 227| 225|#define MINSTRTABSIZE 128 ------------------ 130| | /* pre-create memory-error message */ 131| 225| g->memerrmsg = luaS_newliteral(L, MEMERRMSG); ------------------ | | 28| 225|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 225| (sizeof(s)/sizeof(char))-1)) ------------------ 132| 225| luaC_fix(L, obj2gco(g->memerrmsg)); /* it should never be collected */ ------------------ | | 390| 225|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 110| 225|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 225|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 133| 12.1k| for (i = 0; i < STRCACHE_N; i++) /* fill cache with valid strings */ ------------------ | | 237| 12.1k|#define STRCACHE_N 53 ------------------ | Branch (133:15): [True: 11.9k, False: 225] ------------------ 134| 35.7k| for (j = 0; j < STRCACHE_M; j++) ------------------ | | 238| 35.7k|#define STRCACHE_M 2 ------------------ | Branch (134:17): [True: 23.8k, False: 11.9k] ------------------ 135| 23.8k| g->strcache[i][j] = g->memerrmsg; 136| 225|} luaS_createlngstrobj: 157| 32.8k|TString *luaS_createlngstrobj (lua_State *L, size_t l) { 158| 32.8k| TString *ts = createstrobj(L, l, LUA_VLNGSTR, G(L)->seed); ------------------ | | 361| 32.8k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 32.8k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ TString *ts = createstrobj(L, l, LUA_VLNGSTR, G(L)->seed); ------------------ | | 335| 32.8k|#define G(L) (L->l_G) ------------------ 159| 32.8k| ts->u.lnglen = l; 160| 32.8k| ts->shrlen = 0xFF; /* signals that it is a long string */ 161| 32.8k| return ts; 162| 32.8k|} luaS_remove: 165| 87.9k|void luaS_remove (lua_State *L, TString *ts) { 166| 87.9k| stringtable *tb = &G(L)->strt; ------------------ | | 335| 87.9k|#define G(L) (L->l_G) ------------------ 167| 87.9k| TString **p = &tb->hash[lmod(ts->hash, tb->size)]; ------------------ | | 787| 87.9k| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 110| 87.9k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 87.9k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 168| 101k| while (*p != ts) /* find previous element */ ------------------ | Branch (168:10): [True: 13.9k, False: 87.9k] ------------------ 169| 13.9k| p = &(*p)->u.hnext; 170| 87.9k| *p = (*p)->u.hnext; /* remove element from its list */ 171| 87.9k| tb->nuse--; 172| 87.9k|} luaS_newlstr: 222| 5.49M|TString *luaS_newlstr (lua_State *L, const char *str, size_t l) { 223| 5.49M| if (l <= LUAI_MAXSHORTLEN) /* short string? */ ------------------ | | 216| 5.49M|#define LUAI_MAXSHORTLEN 40 ------------------ | Branch (223:7): [True: 5.47M, False: 18.3k] ------------------ 224| 5.47M| return internshrstr(L, str, l); 225| 18.3k| else { 226| 18.3k| TString *ts; 227| 18.3k| if (l_unlikely(l >= (MAX_SIZE - sizeof(TString))/sizeof(char))) ------------------ | | 697| 18.3k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 36.7k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 18.3k] | | | | | Branch (685:46): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 228| 0| luaM_toobig(L); 229| 18.3k| ts = luaS_createlngstrobj(L, l); 230| 18.3k| memcpy(getlngstr(ts), str, l * sizeof(char)); ------------------ | | 405| 18.3k|#define getlngstr(ts) check_exp((ts)->shrlen == 0xFF, (ts)->contents) | | ------------------ | | | | 110| 18.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 18.3k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 231| 0| return ts; 232| 18.3k| } 233| 5.49M|} luaS_new: 242| 10.9k|TString *luaS_new (lua_State *L, const char *str) { 243| 10.9k| unsigned int i = point2uint(str) % STRCACHE_N; /* hash */ ------------------ | | 91| 10.9k|#define point2uint(p) ((unsigned int)((L_P2I)(p) & UINT_MAX)) ------------------ unsigned int i = point2uint(str) % STRCACHE_N; /* hash */ ------------------ | | 237| 10.9k|#define STRCACHE_N 53 ------------------ 244| 10.9k| int j; 245| 10.9k| TString **p = G(L)->strcache[i]; ------------------ | | 335| 10.9k|#define G(L) (L->l_G) ------------------ 246| 32.7k| for (j = 0; j < STRCACHE_M; j++) { ------------------ | | 238| 32.7k|#define STRCACHE_M 2 ------------------ | Branch (246:15): [True: 21.8k, False: 10.9k] ------------------ 247| 21.8k| if (strcmp(str, getstr(p[j])) == 0) /* hit? */ ------------------ | | 404| 21.8k|#define getstr(ts) ((ts)->contents) ------------------ | Branch (247:9): [True: 48, False: 21.8k] ------------------ 248| 48| return p[j]; /* that is it */ 249| 21.8k| } 250| | /* normal route */ 251| 21.8k| for (j = STRCACHE_M - 1; j > 0; j--) ------------------ | | 238| 10.9k|#define STRCACHE_M 2 ------------------ | Branch (251:28): [True: 10.9k, False: 10.9k] ------------------ 252| 10.9k| p[j] = p[j - 1]; /* move out last element */ 253| | /* new element is first in the list */ 254| 10.9k| p[0] = luaS_newlstr(L, str, strlen(str)); 255| 10.9k| return p[0]; 256| 10.9k|} luaS_newudata: 259| 12|Udata *luaS_newudata (lua_State *L, size_t s, int nuvalue) { 260| 12| Udata *u; 261| 12| int i; 262| 12| GCObject *o; 263| 12| if (l_unlikely(s > MAX_SIZE - udatamemoffset(nuvalue))) ------------------ | | 697| 12|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 48|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 12] | | | | | Branch (685:46): [Folded - Ignored] | | | | | Branch (685:46): [True: 12, False: 0] | | | | ------------------ | | ------------------ ------------------ 264| 0| luaM_toobig(L); 265| 12| o = luaC_newobj(L, LUA_VUSERDATA, sizeudata(nuvalue, s)); ------------------ | | 429| 12|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 12|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ o = luaC_newobj(L, LUA_VUSERDATA, sizeudata(nuvalue, s)); ------------------ | | 496| 12|#define sizeudata(nuv,nb) (udatamemoffset(nuv) + (nb)) | | ------------------ | | | | 489| 12| ((nuv) == 0 ? offsetof(Udata0, bindata) \ | | | | ------------------ | | | | | Branch (489:3): [True: 12, False: 0] | | | | ------------------ | | | | 490| 12| : offsetof(Udata, uv) + (sizeof(UValue) * (nuv))) | | ------------------ ------------------ 266| 12| u = gco2u(o); ------------------ | | 375| 12|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 110| 12|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 12|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 267| 0| u->len = s; 268| 12| u->nuvalue = nuvalue; 269| 12| u->metatable = NULL; 270| 12| for (i = 0; i < nuvalue; i++) ------------------ | Branch (270:15): [True: 0, False: 12] ------------------ 271| 12| setnilvalue(&u->uv[i].uv); ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 272| 12| return u; 273| 12|} lstring.c:tablerehash: 62| 604|static void tablerehash (TString **vect, int osize, int nsize) { 63| 604| int i; 64| 94.1k| for (i = osize; i < nsize; i++) /* clear new elements */ ------------------ | Branch (64:19): [True: 93.5k, False: 604] ------------------ 65| 93.5k| vect[i] = NULL; 66| 177k| for (i = 0; i < osize; i++) { /* rehash old part of the array */ ------------------ | Branch (66:15): [True: 176k, False: 604] ------------------ 67| 176k| TString *p = vect[i]; 68| 176k| vect[i] = NULL; 69| 258k| while (p) { /* for each string in the list */ ------------------ | Branch (69:12): [True: 81.8k, False: 176k] ------------------ 70| 81.8k| TString *hnext = p->u.hnext; /* save next */ 71| 81.8k| unsigned int h = lmod(p->hash, nsize); /* new position */ ------------------ | | 787| 81.8k| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 110| 81.8k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 81.8k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 72| 0| p->u.hnext = vect[h]; /* chain it into array */ 73| 81.8k| vect[h] = p; 74| 81.8k| p = hnext; 75| 81.8k| } 76| 176k| } 77| 604|} lstring.c:createstrobj: 143| 120k|static TString *createstrobj (lua_State *L, size_t l, int tag, unsigned int h) { 144| 120k| TString *ts; 145| 120k| GCObject *o; 146| 120k| size_t totalsize; /* total size of TString object */ 147| 120k| totalsize = sizelstring(l); ------------------ | | 26| 120k|#define sizelstring(l) (offsetof(TString, contents) + ((l) + 1) * sizeof(char)) ------------------ 148| 120k| o = luaC_newobj(L, tag, totalsize); 149| 120k| ts = gco2ts(o); ------------------ | | 374| 120k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 110| 120k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 120k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 150| 0| ts->hash = h; 151| 120k| ts->extra = 0; 152| 120k| getstr(ts)[l] = '\0'; /* ending 0 */ ------------------ | | 404| 120k|#define getstr(ts) ((ts)->contents) ------------------ 153| 120k| return ts; 154| 120k|} lstring.c:internshrstr: 189| 5.47M|static TString *internshrstr (lua_State *L, const char *str, size_t l) { 190| 5.47M| TString *ts; 191| 5.47M| global_State *g = G(L); ------------------ | | 335| 5.47M|#define G(L) (L->l_G) ------------------ 192| 5.47M| stringtable *tb = &g->strt; 193| 5.47M| unsigned int h = luaS_hash(str, l, g->seed); 194| 5.47M| TString **list = &tb->hash[lmod(h, tb->size)]; ------------------ | | 787| 5.47M| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 110| 5.47M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 5.47M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 195| 5.47M| lua_assert(str != NULL); /* otherwise 'memcmp'/'memcpy' are undefined */ ------------------ | | 106| 5.47M|#define lua_assert(c) assert(c) ------------------ 196| 6.85M| for (ts = *list; ts != NULL; ts = ts->u.hnext) { ------------------ | Branch (196:20): [True: 6.76M, False: 87.9k] ------------------ 197| 6.76M| if (l == ts->shrlen && (memcmp(str, getshrstr(ts), l * sizeof(char)) == 0)) { ------------------ | | 406| 5.43M|#define getshrstr(ts) check_exp((ts)->shrlen != 0xFF, (ts)->contents) | | ------------------ | | | | 110| 5.43M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 5.43M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (197:9): [True: 5.43M, False: 1.32M] | Branch (197:28): [True: 5.38M, False: 50.8k] ------------------ 198| | /* found! */ 199| 5.38M| if (isdead(g, ts)) /* dead (but not collected yet)? */ ------------------ | | 96| 5.38M|#define isdead(g,v) isdeadm(otherwhite(g), (v)->marked) | | ------------------ | | | | 95| 5.38M|#define isdeadm(ow,m) ((m) & (ow)) | | | | ------------------ | | | | | Branch (95:23): [True: 1, False: 5.38M] | | | | ------------------ | | ------------------ ------------------ 200| 1| changewhite(ts); /* resurrect it */ ------------------ | | 98| 1|#define changewhite(x) ((x)->marked ^= WHITEBITS) | | ------------------ | | | | 84| 1|#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) | | | | ------------------ | | | | | | 64| 1|#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 1|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | | | #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 1|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 201| 5.38M| return ts; 202| 5.38M| } 203| 6.76M| } 204| | /* else must create a new string */ 205| 87.9k| if (tb->nuse >= tb->size) { /* need to grow string table? */ ------------------ | Branch (205:7): [True: 217, False: 87.7k] ------------------ 206| 217| growstrtab(L, tb); 207| 217| list = &tb->hash[lmod(h, tb->size)]; /* rehash with new size */ ------------------ | | 787| 217| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 110| 217|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 217|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 208| 217| } 209| 87.9k| ts = createstrobj(L, l, LUA_VSHRSTR, h); ------------------ | | 360| 87.9k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 87.9k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 210| 87.9k| ts->shrlen = cast_byte(l); ------------------ | | 143| 87.9k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 87.9k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 211| 87.9k| memcpy(getshrstr(ts), str, l * sizeof(char)); ------------------ | | 406| 87.9k|#define getshrstr(ts) check_exp((ts)->shrlen != 0xFF, (ts)->contents) | | ------------------ | | | | 110| 87.9k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 87.9k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 212| 0| ts->u.hnext = *list; 213| 87.9k| *list = ts; 214| 87.9k| tb->nuse++; 215| 87.9k| return ts; 216| 87.9k|} lstring.c:growstrtab: 175| 217|static void growstrtab (lua_State *L, stringtable *tb) { 176| 217| if (l_unlikely(tb->nuse == MAX_INT)) { /* too many strings? */ ------------------ | | 697| 217|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 217|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 217] | | | | ------------------ | | ------------------ ------------------ 177| 0| luaC_fullgc(L, 1); /* try to free some... */ 178| 0| if (tb->nuse == MAX_INT) /* still too many? */ ------------------ | | 53| 0|#define MAX_INT INT_MAX /* maximum value of an int */ ------------------ | Branch (178:9): [True: 0, False: 0] ------------------ 179| 0| luaM_error(L); /* cannot even create a message... */ ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 52| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 180| 0| } 181| 217| if (tb->size <= MAXSTRTB / 2) /* can grow string table? */ ------------------ | | 28| 217|#define MAXSTRTB cast_int(luaM_limitN(MAX_INT, TString*)) | | ------------------ | | | | 141| 217|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 434|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (136:27): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (181:7): [True: 217, False: 0] ------------------ 182| 217| luaS_resize(L, tb->size * 2); 183| 217|} luaH_realasize: 250| 450k|LUAI_FUNC unsigned int luaH_realasize (const Table *t) { 251| 450k| if (limitequalsasize(t)) ------------------ | | 244| 450k|#define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 732| 901k|#define isrealasize(t) (!((t)->flags & BITRAS)) | | | | ------------------ | | | | | | 731| 450k|#define BITRAS (1 << 7) | | | | ------------------ | | | | | Branch (732:25): [True: 62.3k, False: 388k] | | | | ------------------ | | ------------------ | | #define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 66| 388k|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | | | ------------------ | | | | | Branch (66:19): [True: 6.87k, False: 381k] | | | | ------------------ | | ------------------ ------------------ 252| 69.1k| return t->alimit; /* this is the size */ 253| 381k| else { 254| 381k| unsigned int size = t->alimit; 255| | /* compute the smallest power of 2 not smaller than 'n' */ 256| 381k| size |= (size >> 1); 257| 381k| size |= (size >> 2); 258| 381k| size |= (size >> 4); 259| 381k| size |= (size >> 8); 260| 381k|#if (UINT_MAX >> 14) > 3 /* unsigned int has more than 16 bits */ 261| 381k| size |= (size >> 16); 262| |#if (UINT_MAX >> 30) > 3 263| | size |= (size >> 32); /* unsigned int has more than 32 bits */ 264| |#endif 265| 381k|#endif 266| 381k| size++; 267| 381k| lua_assert(ispow2(size) && size/2 < t->alimit && t->alimit < size); ------------------ | | 106| 381k|#define lua_assert(c) assert(c) ------------------ 268| 381k| return size; 269| 381k| } 270| 450k|} luaH_resize: 554| 5.99k| unsigned int nhsize) { 555| 5.99k| unsigned int i; 556| 5.99k| Table newt; /* to keep the new hash part */ 557| 5.99k| unsigned int oldasize = setlimittosize(t); 558| 5.99k| TValue *newarray; 559| | /* create new hash part with appropriate size into 'newt' */ 560| 5.99k| setnodevector(L, &newt, nhsize); 561| 5.99k| if (newasize < oldasize) { /* will array shrink? */ ------------------ | Branch (561:7): [True: 0, False: 5.99k] ------------------ 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| 5.99k| newarray = luaM_reallocvector(L, t->array, oldasize, newasize, TValue); ------------------ | | 71| 5.99k| (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \ | | ------------------ | | | | 136| 5.99k|#define cast(t, exp) ((t)(exp)) | | ------------------ | | 72| 5.99k| cast_sizet(n) * sizeof(t)))) ------------------ 574| 5.99k| if (l_unlikely(newarray == NULL && newasize > 0)) { /* allocation failed? */ ------------------ | | 697| 5.99k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 7.23k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 5.99k] | | | | | Branch (685:46): [True: 1.23k, False: 4.75k] | | | | | Branch (685:46): [True: 0, False: 1.23k] | | | | ------------------ | | ------------------ ------------------ 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) | | ------------------ | | | | 52| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 577| 0| } 578| | /* allocation ok; initialize new part of the array */ 579| 5.99k| exchangehashpart(t, &newt); /* 't' has the new hash ('newt' has the old) */ 580| 5.99k| t->array = newarray; /* set new array part */ 581| 5.99k| t->alimit = newasize; 582| 59.7k| for (i = oldasize; i < newasize; i++) /* clear new slice of the array */ ------------------ | Branch (582:22): [True: 53.7k, False: 5.99k] ------------------ 583| 53.7k| setempty(&t->array[i]); ------------------ | | 225| 53.7k|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 59.7k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 584| | /* re-insert elements from old hash part into new parts */ 585| 5.99k| reinsert(L, &newt, t); /* 'newt' now has the old hash */ 586| 5.99k| freehash(L, &newt); /* free old hash part */ 587| 5.99k|} luaH_resizearray: 590| 2.00k|void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize) { 591| 2.00k| int nsize = allocsizenode(t); ------------------ | | 31| 2.00k|#define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 27| 2.00k|#define isdummy(t) ((t)->lastfree == NULL) | | | | ------------------ | | | | | Branch (27:21): [True: 2.00k, False: 0] | | | | ------------------ | | ------------------ | | #define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 791| 0|#define sizenode(t) (twoto((t)->lsizenode)) | | | | ------------------ | | | | | | 790| 0|#define twoto(x) (1<<(x)) | | | | ------------------ | | ------------------ ------------------ 592| 2.00k| luaH_resize(L, t, nasize, nsize); 593| 2.00k|} luaH_new: 626| 2.68k|Table *luaH_new (lua_State *L) { 627| 2.68k| GCObject *o = luaC_newobj(L, LUA_VTABLE, sizeof(Table)); ------------------ | | 678| 2.68k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 2.68k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 628| 2.68k| Table *t = gco2t(o); ------------------ | | 380| 2.68k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 110| 2.68k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.68k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 629| 0| t->metatable = NULL; 630| 2.68k| t->flags = cast_byte(maskflags); /* table has no metamethod fields */ ------------------ | | 143| 2.68k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 2.68k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 631| 2.68k| t->array = NULL; 632| 2.68k| t->alimit = 0; 633| 2.68k| setnodevector(L, t, 0); 634| 2.68k| return t; 635| 2.68k|} luaH_free: 638| 2.68k|void luaH_free (lua_State *L, Table *t) { 639| 2.68k| freehash(L, t); 640| 2.68k| luaM_freearray(L, t->array, luaH_realasize(t)); ------------------ | | 57| 2.68k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 641| 2.68k| luaM_free(L, t); ------------------ | | 56| 2.68k|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 642| 2.68k|} luaH_getint: 731| 1.27M|const TValue *luaH_getint (Table *t, lua_Integer key) { 732| 1.27M| if (l_castS2U(key) - 1u < t->alimit) /* 'key' in [1, t->alimit]? */ ------------------ | | 152| 1.27M|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (732:7): [True: 13.3k, False: 1.26M] ------------------ 733| 13.3k| return &t->array[key - 1]; 734| 1.26M| else if (!limitequalsasize(t) && /* key still may be in the array part? */ ------------------ | | 244| 2.53M|#define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 732| 2.53M|#define isrealasize(t) (!((t)->flags & BITRAS)) | | | | ------------------ | | | | | | 731| 1.26M|#define BITRAS (1 << 7) | | | | ------------------ | | | | | Branch (732:25): [True: 658k, False: 607k] | | | | ------------------ | | ------------------ | | #define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 66| 607k|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | | | ------------------ | | | | | Branch (66:19): [True: 222k, False: 384k] | | | | ------------------ | | ------------------ ------------------ 735| 1.26M| (l_castS2U(key) == t->alimit + 1 || ------------------ | | 152| 384k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (735:13): [True: 3.31k, False: 381k] ------------------ 736| 384k| l_castS2U(key) - 1u < luaH_realasize(t))) { ------------------ | | 152| 381k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (736:13): [True: 0, False: 381k] ------------------ 737| 3.31k| t->alimit = cast_uint(key); /* probably '#t' is here now */ ------------------ | | 142| 3.31k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 3.31k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 738| 3.31k| return &t->array[key - 1]; 739| 3.31k| } 740| 1.26M| else { 741| 1.26M| Node *n = hashint(t, key); 742| 1.75M| for (;;) { /* check whether 'key' is somewhere in the chain */ 743| 1.75M| if (keyisinteger(n) && keyival(n) == key) ------------------ | | 757| 3.51M|#define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 753| 1.75M|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 323| 1.75M|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | | | ------------------ | | | | | | 42| 1.75M|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (757:28): [True: 1.32M, False: 430k] | | ------------------ ------------------ if (keyisinteger(n) && keyival(n) == key) ------------------ | | 758| 1.32M|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 754| 1.32M|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ | Branch (743:30): [True: 657k, False: 670k] ------------------ 744| 657k| return gval(n); /* that's it */ ------------------ | | 14| 657k|#define gval(n) (&(n)->i_val) ------------------ 745| 1.10M| else { 746| 1.10M| int nx = gnext(n); ------------------ | | 15| 1.10M|#define gnext(n) ((n)->u.next) ------------------ 747| 1.10M| if (nx == 0) break; ------------------ | Branch (747:13): [True: 606k, False: 495k] ------------------ 748| 495k| n += nx; 749| 495k| } 750| 1.75M| } 751| 606k| return &absentkey; 752| 1.26M| } 753| 1.27M|} luaH_getshortstr: 759| 19.0M|const TValue *luaH_getshortstr (Table *t, TString *key) { 760| 19.0M| Node *n = hashstr(t, key); ------------------ | | 84| 19.0M|#define hashstr(t,str) hashpow2(t, (str)->hash) | | ------------------ | | | | 75| 19.0M|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 76.0M|#define gnode(t,i) (&(t)->node[i]) | | | | | | ------------------ | | | | | | | Branch (13:32): [True: 0, False: 19.0M] | | | | | | | Branch (13:32): [True: 19.0M, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 761| 19.0M| lua_assert(key->tt == LUA_VSHRSTR); ------------------ | | 106| 19.0M|#define lua_assert(c) assert(c) ------------------ 762| 23.4M| for (;;) { /* check whether 'key' is somewhere in the chain */ 763| 23.4M| if (keyisshrstr(n) && eqshrstr(keystrval(n), key)) ------------------ | | 759| 46.8M|#define keyisshrstr(node) (keytt(node) == ctb(LUA_VSHRSTR)) | | ------------------ | | | | 753| 23.4M|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisshrstr(node) (keytt(node) == ctb(LUA_VSHRSTR)) | | ------------------ | | | | 303| 23.4M|#define ctb(t) ((t) | BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 23.4M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | ------------------ | | | Branch (759:27): [True: 14.8M, False: 8.58M] | | ------------------ ------------------ if (keyisshrstr(n) && eqshrstr(keystrval(n), key)) ------------------ | | 41| 14.8M|#define eqshrstr(a,b) check_exp((a)->tt == LUA_VSHRSTR, (a) == (b)) | | ------------------ | | | | 110| 59.2M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 14.8M|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:25): [True: 13.2M, False: 1.60M] | | | | | Branch (110:42): [True: 0, False: 14.8M] | | | | | Branch (110:42): [True: 14.8M, False: 0] | | | | ------------------ | | ------------------ ------------------ 764| 13.2M| return gval(n); /* that's it */ ------------------ | | 14| 13.2M|#define gval(n) (&(n)->i_val) ------------------ 765| 10.1M| else { 766| 10.1M| int nx = gnext(n); ------------------ | | 15| 10.1M|#define gnext(n) ((n)->u.next) ------------------ 767| 10.1M| if (nx == 0) ------------------ | Branch (767:11): [True: 5.78M, False: 4.40M] ------------------ 768| 5.78M| return &absentkey; /* not found */ 769| 4.40M| n += nx; 770| 4.40M| } 771| 23.4M| } 772| 19.0M|} luaH_getstr: 775| 5.34M|const TValue *luaH_getstr (Table *t, TString *key) { 776| 5.34M| if (key->tt == LUA_VSHRSTR) ------------------ | | 360| 5.34M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 5.34M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (776:7): [True: 5.32M, False: 18.0k] ------------------ 777| 5.32M| return luaH_getshortstr(t, key); 778| 18.0k| else { /* for long strings, use generic case */ 779| 18.0k| TValue ko; 780| 18.0k| setsvalue(cast(lua_State *, NULL), &ko, key); ------------------ | | 372| 18.0k| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 18.0k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 18.0k|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 18.0k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 110| 18.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 18.0k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 18.0k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 18.0k| checkliveness(L,io); } | | ------------------ | | | | 107| 18.0k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 180k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 18.0k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 18.0k] | | | | | | | Branch (112:29): [True: 18.0k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [Folded - Ignored] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 18.0k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 18.0k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 18.0k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 781| 18.0k| return getgeneric(t, &ko, 0); 782| 18.0k| } 783| 5.34M|} luaH_get: 789| 5.86M|const TValue *luaH_get (Table *t, const TValue *key) { 790| 5.86M| switch (ttypetag(key)) { ------------------ | | 84| 5.86M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 5.86M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 791| 5.14M| case LUA_VSHRSTR: return luaH_getshortstr(t, tsvalue(key)); ------------------ | | 360| 5.14M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 5.14M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VSHRSTR: return luaH_getshortstr(t, tsvalue(key)); ------------------ | | 369| 5.14M|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 20.5M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 5.14M|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 5.14M] | | | | | Branch (110:42): [True: 5.14M, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (791:5): [True: 5.14M, False: 715k] ------------------ 792| 510k| case LUA_VNUMINT: return luaH_getint(t, ivalue(key)); ------------------ | | 323| 510k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 510k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNUMINT: return luaH_getint(t, ivalue(key)); ------------------ | | 333| 510k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 510k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 510k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (792:5): [True: 510k, False: 5.34M] ------------------ 793| 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 (793:5): [True: 0, False: 5.86M] ------------------ 794| 35.9k| case LUA_VNUMFLT: { ------------------ | | 324| 35.9k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 35.9k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (794:5): [True: 35.9k, False: 5.82M] ------------------ 795| 35.9k| lua_Integer k; 796| 35.9k| if (luaV_flttointeger(fltvalue(key), &k, F2Ieq)) /* integral index? */ ------------------ | | 332| 35.9k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 110| 35.9k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 35.9k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (796:11): [True: 1.87k, False: 34.0k] ------------------ 797| 1.87k| return luaH_getint(t, k); /* use specialized version */ 798| | /* else... */ 799| 35.9k| } /* FALLTHROUGH */ 800| 203k| default: ------------------ | Branch (800:5): [True: 169k, False: 5.69M] ------------------ 801| 203k| return getgeneric(t, key, 0); 802| 5.86M| } 803| 5.86M|} luaH_finishset: 813| 2.34M| const TValue *slot, TValue *value) { 814| 2.34M| if (isabstkey(slot)) ------------------ | | 203| 2.34M|#define isabstkey(v) checktag((v), LUA_VABSTKEY) | | ------------------ | | | | 91| 2.34M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 2.34M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 1.83M, False: 514k] | | | | ------------------ | | ------------------ ------------------ 815| 1.83M| luaH_newkey(L, t, key, value); 816| 514k| else 817| 2.34M| setobj2t(L, cast(TValue *, slot), value); ------------------ | | 137| 514k|#define setobj2t setobj | | ------------------ | | | | 119| 514k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 514k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 514k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 514k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 514k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 547k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 514k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 2.22k] | | | | | | | | | Branch (112:29): [True: 2.22k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 2.22k] | | | | | | | | | Branch (112:29): [True: 2.22k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 2.22k] | | | | | | | | | Branch (112:29): [True: 2.22k, False: 0] | | | | | | | | | Branch (112:29): [True: 2.22k, False: 0] | | | | | | | | | Branch (112:29): [True: 511k, False: 2.22k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 514k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 514k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 818| 2.34M|} luaH_set: 825| 509k|void luaH_set (lua_State *L, Table *t, const TValue *key, TValue *value) { 826| 509k| const TValue *slot = luaH_get(t, key); 827| 509k| luaH_finishset(L, t, key, slot, value); 828| 509k|} luaH_getn: 924| 138k|lua_Unsigned luaH_getn (Table *t) { 925| 138k| unsigned int limit = t->alimit; 926| 138k| if (limit > 0 && isempty(&t->array[limit - 1])) { /* (1)? */ ------------------ | | 217| 137k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 137k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 137k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 137k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 137k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 44.0k, False: 93.7k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (926:7): [True: 137k, False: 556] ------------------ 927| | /* there must be a boundary before 'limit' */ 928| 44.0k| if (limit >= 2 && !isempty(&t->array[limit - 2])) { ------------------ | | 217| 44.0k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 44.0k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 44.0k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 44.0k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 44.0k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (928:9): [True: 44.0k, False: 0] | Branch (928:23): [True: 153, False: 43.9k] ------------------ 929| | /* 'limit - 1' is a boundary; can it be a new limit? */ 930| 153| if (ispow2realasize(t) && !ispow2(limit - 1)) { ------------------ | | 66| 153|#define ispow2(x) (((x) & ((x) - 1)) == 0) ------------------ | Branch (930:11): [True: 153, False: 0] | Branch (930:33): [True: 150, False: 3] ------------------ 931| 150| t->alimit = limit - 1; 932| 150| setnorealasize(t); /* now 'alimit' is not the real size */ ------------------ | | 734| 150|#define setnorealasize(t) ((t)->flags |= BITRAS) | | ------------------ | | | | 731| 150|#define BITRAS (1 << 7) | | ------------------ ------------------ 933| 150| } 934| 153| return limit - 1; 935| 153| } 936| 43.9k| else { /* must search for a boundary in [0, limit] */ 937| 43.9k| unsigned int boundary = binsearch(t->array, 0, limit); 938| | /* can this boundary represent the real size of the array? */ 939| 43.9k| if (ispow2realasize(t) && boundary > luaH_realasize(t) / 2) { ------------------ | Branch (939:11): [True: 43.9k, False: 0] | Branch (939:33): [True: 79, False: 43.8k] ------------------ 940| 79| t->alimit = boundary; /* use it as the new limit */ 941| 79| setnorealasize(t); ------------------ | | 734| 79|#define setnorealasize(t) ((t)->flags |= BITRAS) | | ------------------ | | | | 731| 79|#define BITRAS (1 << 7) | | ------------------ ------------------ 942| 79| } 943| 43.9k| return boundary; 944| 43.9k| } 945| 44.0k| } 946| | /* 'limit' is zero or present in table */ 947| 94.3k| if (!limitequalsasize(t)) { /* (2)? */ ------------------ | | 244| 94.3k|#define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 732| 188k|#define isrealasize(t) (!((t)->flags & BITRAS)) | | | | ------------------ | | | | | | 731| 94.3k|#define BITRAS (1 << 7) | | | | ------------------ | | | | | Branch (732:25): [True: 3.30k, False: 91.0k] | | | | ------------------ | | ------------------ | | #define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 66| 91.0k|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | | | ------------------ | | | | | Branch (66:19): [True: 6.72k, False: 84.2k] | | | | ------------------ | | ------------------ ------------------ 948| | /* 'limit' > 0 and array has more elements after 'limit' */ 949| 84.2k| if (isempty(&t->array[limit])) /* 'limit + 1' is empty? */ ------------------ | | 217| 84.2k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 84.2k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 84.2k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 84.2k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 84.2k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 84.2k, False: 17] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 950| 84.2k| return limit; /* this is the boundary */ 951| | /* else, try last element in the array */ 952| 17| limit = luaH_realasize(t); 953| 17| if (isempty(&t->array[limit - 1])) { /* empty? */ ------------------ | | 217| 17|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 17|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 17|#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: 17, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 954| | /* there must be a boundary in the array after old limit, 955| | and it must be a valid new limit */ 956| 17| unsigned int boundary = binsearch(t->array, t->alimit, limit); 957| 17| t->alimit = boundary; 958| 17| return boundary; 959| 17| } 960| | /* else, new limit is present in the table; check the hash part */ 961| 17| } 962| | /* (3) 'limit' is the last element and either is zero or present in table */ 963| 10.0k| lua_assert(limit == luaH_realasize(t) && ------------------ | | 106| 10.0k|#define lua_assert(c) assert(c) ------------------ 964| 10.0k| (limit == 0 || !isempty(&t->array[limit - 1]))); 965| 10.0k| if (isdummy(t) || isempty(luaH_getint(t, cast(lua_Integer, limit + 1)))) ------------------ | | 27| 20.0k|#define isdummy(t) ((t)->lastfree == NULL) | | ------------------ | | | Branch (27:21): [True: 2.00k, False: 8.02k] | | ------------------ ------------------ if (isdummy(t) || isempty(luaH_getint(t, cast(lua_Integer, limit + 1)))) ------------------ | | 217| 8.02k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 8.02k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 8.02k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 8.02k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 8.02k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 892, False: 7.13k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 966| 2.89k| return limit; /* 'limit + 1' is absent */ 967| 7.13k| else /* 'limit + 1' is also present */ 968| 7.13k| return hash_search(t, limit); 969| 10.0k|} ltable.c:arrayindex: 318| 483k|static unsigned int arrayindex (lua_Integer k) { 319| 483k| if (l_castS2U(k) - 1u < MAXASIZE) /* 'k' in [1, MAXASIZE]? */ ------------------ | | 152| 483k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ if (l_castS2U(k) - 1u < MAXASIZE) /* 'k' in [1, MAXASIZE]? */ ------------------ | | 54| 483k|#define MAXASIZE luaM_limitN(1u << MAXABITS, TValue) | | ------------------ | | | | 45| 483k| ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 147| 483k|#define cast_sizet(i) cast(size_t, (i)) | | | | | | ------------------ | | | | | | | | 136| 483k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 41| 483k|#define MAX_SIZET ((size_t)(~(size_t)0)) | | | | ------------------ | | | | | Branch (45:4): [Folded - Ignored] | | | | ------------------ | | | | 46| 483k| 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: 56.5k, False: 427k] ------------------ 320| 56.5k| return cast_uint(k); /* 'key' is an appropriate array index */ ------------------ | | 142| 56.5k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 56.5k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 321| 427k| else 322| 427k| return 0; 323| 483k|} ltable.c:setlimittosize: 283| 7.74k|static unsigned int setlimittosize (Table *t) { 284| 7.74k| t->alimit = luaH_realasize(t); 285| 7.74k| setrealasize(t); ------------------ | | 733| 7.74k|#define setrealasize(t) ((t)->flags &= cast_byte(~BITRAS)) | | ------------------ | | | | 143| 7.74k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 7.74k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 286| 7.74k| return t->alimit; 287| 7.74k|} ltable.c:setnodevector: 480| 8.68k|static void setnodevector (lua_State *L, Table *t, unsigned int size) { 481| 8.68k| if (size == 0) { /* no elements to hash part? */ ------------------ | Branch (481:7): [True: 6.91k, False: 1.76k] ------------------ 482| 6.91k| t->node = cast(Node *, dummynode); /* use common 'dummynode' */ ------------------ | | 136| 6.91k|#define cast(t, exp) ((t)(exp)) ------------------ 483| 6.91k| t->lsizenode = 0; 484| 6.91k| t->lastfree = NULL; /* signal that it is using dummy node */ 485| 6.91k| } 486| 1.76k| else { 487| 1.76k| int i; 488| 1.76k| int lsize = luaO_ceillog2(size); 489| 1.76k| if (lsize > MAXHBITS || (1u << lsize) > MAXHSIZE) ------------------ | | 60| 3.53k|#define MAXHBITS (MAXABITS - 1) | | ------------------ | | | | 46| 1.76k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | | | ------------------ | | | | | | 141| 1.76k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 1.76k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (lsize > MAXHBITS || (1u << lsize) > MAXHSIZE) ------------------ | | 68| 1.76k|#define MAXHSIZE luaM_limitN(1u << MAXHBITS, Node) | | ------------------ | | | | 45| 1.76k| ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 147| 1.76k|#define cast_sizet(i) cast(size_t, (i)) | | | | | | ------------------ | | | | | | | | 136| 1.76k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 41| 1.76k|#define MAX_SIZET ((size_t)(~(size_t)0)) | | | | ------------------ | | | | | Branch (45:4): [Folded - Ignored] | | | | ------------------ | | | | 46| 1.76k| 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.76k] | Branch (489:29): [True: 0, False: 1.76k] ------------------ 490| 0| luaG_runerror(L, "table overflow"); 491| 1.76k| size = twoto(lsize); ------------------ | | 790| 1.76k|#define twoto(x) (1<<(x)) ------------------ 492| 1.76k| t->node = luaM_newvector(L, size, Node); ------------------ | | 60| 1.76k|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 136| 1.76k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 493| 615k| for (i = 0; i < cast_int(size); i++) { ------------------ | | 141| 615k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 615k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (493:17): [True: 614k, False: 1.76k] ------------------ 494| 614k| Node *n = gnode(t, i); ------------------ | | 13| 614k|#define gnode(t,i) (&(t)->node[i]) ------------------ 495| 614k| gnext(n) = 0; ------------------ | | 15| 614k|#define gnext(n) ((n)->u.next) ------------------ 496| 614k| setnilkey(n); ------------------ | | 762| 614k|#define setnilkey(node) (keytt(node) = LUA_TNIL) | | ------------------ | | | | 753| 614k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define setnilkey(node) (keytt(node) = LUA_TNIL) | | ------------------ | | | | 64| 614k|#define LUA_TNIL 0 | | ------------------ ------------------ 497| 614k| setempty(gval(n)); ------------------ | | 225| 614k|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 614k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 498| 614k| } 499| 1.76k| t->lsizenode = cast_byte(lsize); ------------------ | | 143| 1.76k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 1.76k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 500| 1.76k| t->lastfree = gnode(t, size); /* all positions are free */ ------------------ | | 13| 1.76k|#define gnode(t,i) (&(t)->node[i]) ------------------ 501| 1.76k| } 502| 8.68k|} ltable.c:exchangehashpart: 527| 5.99k|static void exchangehashpart (Table *t1, Table *t2) { 528| 5.99k| lu_byte lsizenode = t1->lsizenode; 529| 5.99k| Node *node = t1->node; 530| 5.99k| Node *lastfree = t1->lastfree; 531| 5.99k| t1->lsizenode = t2->lsizenode; 532| 5.99k| t1->node = t2->node; 533| 5.99k| t1->lastfree = t2->lastfree; 534| 5.99k| t2->lsizenode = lsizenode; 535| 5.99k| t2->node = node; 536| 5.99k| t2->lastfree = lastfree; 537| 5.99k|} ltable.c:freehash: 371| 8.68k|static void freehash (lua_State *L, Table *t) { 372| 8.68k| if (!isdummy(t)) ------------------ | | 27| 8.68k|#define isdummy(t) ((t)->lastfree == NULL) ------------------ | Branch (372:7): [True: 1.76k, False: 6.91k] ------------------ 373| 1.76k| luaM_freearray(L, t->node, cast_sizet(sizenode(t))); ------------------ | | 57| 1.76k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 374| 8.68k|} ltable.c:reinsert: 508| 5.99k|static void reinsert (lua_State *L, Table *ot, Table *t) { 509| 5.99k| int j; 510| 5.99k| int size = sizenode(ot); ------------------ | | 791| 5.99k|#define sizenode(t) (twoto((t)->lsizenode)) | | ------------------ | | | | 790| 5.99k|#define twoto(x) (1<<(x)) | | ------------------ ------------------ 511| 518k| for (j = 0; j < size; j++) { ------------------ | Branch (511:15): [True: 512k, False: 5.99k] ------------------ 512| 512k| Node *old = gnode(ot, j); ------------------ | | 13| 512k|#define gnode(t,i) (&(t)->node[i]) ------------------ 513| 512k| if (!isempty(gval(old))) { ------------------ | | 217| 512k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 512k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 512k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 512k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 512k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (513:9): [True: 507k, False: 4.99k] ------------------ 514| | /* doesn't need barrier/invalidate cache, as entry was 515| | already present in the table */ 516| 507k| TValue k; 517| 507k| getnodekey(L, &k, old); ------------------ | | 719| 507k| { TValue *io_=(obj); const Node *n_=(node); \ | | 720| 507k| io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \ | | 721| 507k| checkliveness(L,io_); } | | ------------------ | | | | 107| 507k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 824k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 507k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 21.0k] | | | | | | | Branch (112:29): [True: 21.0k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 21.0k] | | | | | | | Branch (112:29): [True: 21.0k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 21.0k] | | | | | | | Branch (112:29): [True: 21.0k, False: 0] | | | | | | | Branch (112:29): [True: 21.0k, False: 0] | | | | | | | Branch (112:29): [True: 486k, False: 21.0k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 507k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 518| 507k| luaH_set(L, t, &k, gval(old)); ------------------ | | 14| 507k|#define gval(n) (&(n)->i_val) ------------------ 519| 507k| } 520| 512k| } 521| 5.99k|} ltable.c:hashint: 108| 2.04M|static Node *hashint (const Table *t, lua_Integer i) { 109| 2.04M| lua_Unsigned ui = l_castS2U(i); ------------------ | | 152| 2.04M|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 110| 2.04M| if (ui <= cast_uint(INT_MAX)) ------------------ | | 142| 2.04M|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 2.04M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (110:7): [True: 702k, False: 1.33M] ------------------ 111| 702k| return hashmod(t, cast_int(ui)); ------------------ | | 81| 702k|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | ------------------ | | | | 13| 702k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 112| 1.33M| else 113| 1.33M| return hashmod(t, ui); ------------------ | | 81| 1.33M|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | ------------------ | | | | 13| 1.33M|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 114| 2.04M|} ltable.c:getgeneric: 299| 221k|static const TValue *getgeneric (Table *t, const TValue *key, int deadok) { 300| 221k| Node *n = mainpositionTV(t, key); 301| 260k| for (;;) { /* check whether 'key' is somewhere in the chain */ 302| 260k| if (equalkey(key, n, deadok)) ------------------ | Branch (302:9): [True: 194k, False: 65.5k] ------------------ 303| 194k| return gval(n); /* that's it */ ------------------ | | 14| 194k|#define gval(n) (&(n)->i_val) ------------------ 304| 65.5k| else { 305| 65.5k| int nx = gnext(n); ------------------ | | 15| 65.5k|#define gnext(n) ((n)->u.next) ------------------ 306| 65.5k| if (nx == 0) ------------------ | Branch (306:11): [True: 26.5k, False: 39.0k] ------------------ 307| 26.5k| return &absentkey; /* not found */ 308| 39.0k| n += nx; 309| 39.0k| } 310| 260k| } 311| 221k|} 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| 777k| case LUA_VNUMINT: { ------------------ | | 323| 777k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 777k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (153:5): [True: 777k, False: 277k] ------------------ 154| 777k| lua_Integer i = ivalue(key); ------------------ | | 333| 777k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 777k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 777k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 155| 0| return hashint(t, i); 156| 777k| } 157| 40.3k| case LUA_VNUMFLT: { ------------------ | | 324| 40.3k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 40.3k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (157:5): [True: 40.3k, False: 1.01M] ------------------ 158| 40.3k| lua_Number n = fltvalue(key); ------------------ | | 332| 40.3k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 110| 40.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 40.3k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 159| 40.3k| return hashmod(t, l_hashfloat(n)); ------------------ | | 81| 40.3k|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | ------------------ | | | | 13| 40.3k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 160| 40.3k| } 161| 45.5k| case LUA_VSHRSTR: { ------------------ | | 360| 45.5k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 45.5k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (161:5): [True: 45.5k, False: 1.00M] ------------------ 162| 91.0k| TString *ts = tsvalue(key); ------------------ | | 369| 45.5k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 182k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 45.5k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 45.5k] | | | | | Branch (110:42): [True: 45.5k, False: 0] | | | | ------------------ | | ------------------ ------------------ 163| 91.0k| return hashstr(t, ts); ------------------ | | 84| 45.5k|#define hashstr(t,str) hashpow2(t, (str)->hash) | | ------------------ | | | | 75| 45.5k|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 182k|#define gnode(t,i) (&(t)->node[i]) | | | | | | ------------------ | | | | | | | Branch (13:32): [True: 0, False: 45.5k] | | | | | | | Branch (13:32): [True: 45.5k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 164| 91.0k| } 165| 58.6k| case LUA_VLNGSTR: { ------------------ | | 361| 58.6k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 58.6k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (165:5): [True: 58.6k, False: 995k] ------------------ 166| 117k| TString *ts = tsvalue(key); ------------------ | | 369| 58.6k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 234k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 58.6k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 58.6k] | | | | | Branch (110:42): [True: 58.6k, False: 0] | | | | ------------------ | | ------------------ ------------------ 167| 117k| return hashpow2(t, luaS_hashlongstr(ts)); ------------------ | | 75| 58.6k|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | ------------------ | | | | 13| 234k|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | | | | Branch (13:32): [True: 0, False: 58.6k] | | | | | Branch (13:32): [True: 58.6k, False: 0] | | | | ------------------ | | ------------------ ------------------ 168| 117k| } 169| 113k| case LUA_VFALSE: ------------------ | | 239| 113k|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 113k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (169:5): [True: 113k, False: 941k] ------------------ 170| 113k| return hashboolean(t, 0); ------------------ | | 85| 113k|#define hashboolean(t,p) hashpow2(t, p) | | ------------------ | | | | 75| 113k|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 452k|#define gnode(t,i) (&(t)->node[i]) | | | | | | ------------------ | | | | | | | Branch (13:32): [True: 0, False: 113k] | | | | | | | Branch (13:32): [True: 113k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 171| 18.6k| case LUA_VTRUE: ------------------ | | 240| 18.6k|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 18.6k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (171:5): [True: 18.6k, False: 1.03M] ------------------ 172| 18.6k| return hashboolean(t, 1); ------------------ | | 85| 18.6k|#define hashboolean(t,p) hashpow2(t, p) | | ------------------ | | | | 75| 18.6k|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 74.7k|#define gnode(t,i) (&(t)->node[i]) | | | | | | ------------------ | | | | | | | Branch (13:32): [True: 0, False: 18.6k] | | | | | | | Branch (13:32): [True: 18.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 173| 0| case LUA_VLIGHTUSERDATA: { ------------------ | | 427| 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); ------------------ | | 434| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 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: { ------------------ | | 589| 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); ------------------ | | 603| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 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| 668| default: { ------------------ | Branch (181:5): [True: 668, False: 1.05M] ------------------ 182| 668| GCObject *o = gcvalue(key); ------------------ | | 305| 668|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 110| 668|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 668|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 183| 668| return hashpointer(t, o); ------------------ | | 88| 668|#define hashpointer(t,p) hashmod(t, point2uint(p)) | | ------------------ | | | | 81| 668|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | | | ------------------ | | | | | | 13| 668|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 184| 668| } 185| 1.05M| } 186| 1.05M|} ltable.c:l_hashfloat: 131| 40.3k|static int l_hashfloat (lua_Number n) { 132| 40.3k| int i; 133| 40.3k| lua_Integer ni; 134| 40.3k| n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN); ------------------ | | 482| 40.3k|#define l_mathop(op) op ------------------ n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN); ------------------ | | 140| 40.3k|#define cast_num(i) cast(lua_Number, (i)) | | ------------------ | | | | 136| 40.3k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 135| 40.3k| if (!lua_numbertointeger(n, &ni)) { /* is 'n' inf/-inf/NaN? */ ------------------ | | 433| 40.3k| ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 555| 40.3k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (433:4): [True: 40.2k, False: 61] | | ------------------ | | 434| 40.3k| (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 555| 40.2k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (434:4): [True: 39.5k, False: 695] | | ------------------ | | 435| 40.3k| (*(p) = (LUA_INTEGER)(n), 1)) | | ------------------ | | | Branch (435:7): [True: 39.5k, False: 0] | | ------------------ ------------------ 136| 756| lua_assert(luai_numisnan(n) || l_mathop(fabs)(n) == cast_num(HUGE_VAL)); ------------------ | | 106| 756|#define lua_assert(c) assert(c) ------------------ 137| 756| return 0; 138| 756| } 139| 39.5k| else { /* normal case */ 140| 39.5k| unsigned int u = cast_uint(i) + cast_uint(ni); ------------------ | | 142| 39.5k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 39.5k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ unsigned int u = cast_uint(i) + cast_uint(ni); ------------------ | | 142| 39.5k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 39.5k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 141| 39.5k| return cast_int(u <= cast_uint(INT_MAX) ? u : ~u); ------------------ | | 141| 39.5k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 79.1k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 36.8k, False: 2.71k] | | | | ------------------ | | ------------------ ------------------ 142| 39.5k| } 143| 40.3k|} ltable.c:equalkey: 216| 260k|static int equalkey (const TValue *k1, const Node *n2, int deadok) { 217| 260k| if ((rawtt(k1) != keytt(n2)) && /* not the same variants? */ ------------------ | | 77| 260k|#define rawtt(o) ((o)->tt_) ------------------ if ((rawtt(k1) != keytt(n2)) && /* not the same variants? */ ------------------ | | 753| 260k|#define keytt(node) ((node)->u.key_tt) ------------------ | Branch (217:7): [True: 57.7k, False: 202k] ------------------ 218| 260k| !(deadok && keyisdead(n2) && iscollectable(k1))) ------------------ | | 777| 57.7k|#define keyisdead(node) (keytt(node) == LUA_TDEADKEY) | | ------------------ | | | | 753| 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 */ | | | | ------------------ | | | | | | 74| 0|#define LUA_NUMTYPES 9 | | | | ------------------ | | ------------------ | | | Branch (777: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: 57.7k] ------------------ 219| 57.7k| return 0; /* cannot be same key */ 220| 202k| switch (keytt(n2)) { ------------------ | | 753| 202k|#define keytt(node) ((node)->u.key_tt) ------------------ 221| 130k| 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| 112k|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 112k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: ------------------ | | 240| 130k|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 130k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (221:5): [True: 0, False: 202k] | Branch (221:20): [True: 112k, False: 90.4k] | Branch (221:37): [True: 18.2k, False: 184k] ------------------ 222| 130k| 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: 202k] ------------------ 224| 0| return (ivalue(k1) == keyival(n2)); ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ return (ivalue(k1) == keyival(n2)); ------------------ | | 758| 0|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 754| 0|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ 225| 32.3k| case LUA_VNUMFLT: ------------------ | | 324| 32.3k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 32.3k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (225:5): [True: 32.3k, False: 170k] ------------------ 226| 32.3k| return luai_numeq(fltvalue(k1), fltvalueraw(keyval(n2))); ------------------ | | 350| 129k|#define luai_numeq(a,b) ((a)==(b)) | | ------------------ | | | Branch (350:35): [True: 0, False: 32.3k] | | | Branch (350:35): [True: 32.3k, False: 0] | | ------------------ ------------------ 227| 0| case LUA_VLIGHTUSERDATA: ------------------ | | 427| 0|#define LUA_VLIGHTUSERDATA makevariant(LUA_TLIGHTUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (227:5): [True: 0, False: 202k] ------------------ 228| 0| return pvalue(k1) == pvalueraw(keyval(n2)); ------------------ | | 434| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ return pvalue(k1) == pvalueraw(keyval(n2)); ------------------ | | 437| 0|#define pvalueraw(v) ((v).p) ------------------ 229| 0| case LUA_VLCF: ------------------ | | 589| 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: 202k] ------------------ 230| 0| return fvalue(k1) == fvalueraw(keyval(n2)); ------------------ | | 603| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ return fvalue(k1) == fvalueraw(keyval(n2)); ------------------ | | 606| 0|#define fvalueraw(v) ((v).f) ------------------ 231| 39.2k| case ctb(LUA_VLNGSTR): ------------------ | | 303| 39.2k|#define ctb(t) ((t) | BIT_ISCOLLECTABLE) | | ------------------ | | | | 298| 39.2k|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ ------------------ | Branch (231:5): [True: 39.2k, False: 163k] ------------------ 232| 78.5k| return luaS_eqlngstr(tsvalue(k1), keystrval(n2)); ------------------ | | 369| 39.2k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 157k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 39.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 39.2k] | | | | | Branch (110:42): [True: 39.2k, False: 0] | | | | ------------------ | | ------------------ ------------------ return luaS_eqlngstr(tsvalue(k1), keystrval(n2)); ------------------ | | 760| 39.2k|#define keystrval(node) (gco2ts(keyval(node).gc)) | | ------------------ | | | | 374| 39.2k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | | | ------------------ | | | | | | 110| 39.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 39.2k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 233| 526| default: ------------------ | Branch (233:5): [True: 526, False: 202k] ------------------ 234| 526| return gcvalue(k1) == gcvalueraw(keyval(n2)); ------------------ | | 305| 526|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 110| 526|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 526|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ return gcvalue(k1) == gcvalueraw(keyval(n2)); ------------------ | | 307| 526|#define gcvalueraw(v) ((v).gc) ------------------ 235| 202k| } 236| 202k|} ltable.c:luaH_newkey: 666| 1.83M| TValue *value) { 667| 1.83M| Node *mp; 668| 1.83M| TValue aux; 669| 1.83M| if (l_unlikely(ttisnil(key))) ------------------ | | 697| 1.83M|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 1.83M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 1.83M] | | | | ------------------ | | ------------------ ------------------ 670| 0| luaG_runerror(L, "table index is nil"); 671| 1.83M| else if (ttisfloat(key)) { ------------------ | | 327| 1.83M|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 1.83M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 1.83M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 4.29k, False: 1.82M] | | | | ------------------ | | ------------------ ------------------ 672| 4.29k| lua_Number f = fltvalue(key); ------------------ | | 332| 4.29k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 110| 4.29k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 4.29k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 673| 0| lua_Integer k; 674| 4.29k| if (luaV_flttointeger(f, &k, F2Ieq)) { /* does key fit in an integer? */ ------------------ | Branch (674:9): [True: 39, False: 4.25k] ------------------ 675| 39| setivalue(&aux, k); ------------------ | | 345| 39| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 39|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 39|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 676| 39| key = &aux; /* insert it as an integer */ 677| 39| } 678| 4.25k| else if (l_unlikely(luai_numisnan(f))) ------------------ | | 697| 4.25k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 4.25k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 4.25k] | | | | ------------------ | | ------------------ ------------------ 679| 0| luaG_runerror(L, "table index is NaN"); 680| 4.29k| } 681| 1.83M| if (ttisnil(value)) ------------------ | | 193| 1.83M|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 1.83M|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 1.83M|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 1.83M|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 1.24M, False: 582k] | | | | ------------------ | | ------------------ ------------------ 682| 1.24M| return; /* do not insert nil values */ 683| 582k| mp = mainpositionTV(t, key); 684| 582k| if (!isempty(gval(mp)) || isdummy(t)) { /* main position is taken? */ ------------------ | | 217| 582k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 582k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 1.16M|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 582k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 582k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!isempty(gval(mp)) || isdummy(t)) { /* main position is taken? */ ------------------ | | 27| 330k|#define isdummy(t) ((t)->lastfree == NULL) | | ------------------ | | | Branch (27:21): [True: 238, False: 329k] | | ------------------ ------------------ | Branch (684:7): [True: 252k, False: 330k] ------------------ 685| 252k| Node *othern; 686| 252k| Node *f = getfreepos(t); /* get a free place */ 687| 252k| if (f == NULL) { /* cannot find a free place? */ ------------------ | Branch (687:9): [True: 1.75k, False: 250k] ------------------ 688| 1.75k| rehash(L, t, key); /* grow table */ 689| | /* whatever called 'newkey' takes care of TM cache */ 690| 1.75k| luaH_set(L, t, key, value); /* insert key into grown table */ 691| 1.75k| return; 692| 1.75k| } 693| 250k| lua_assert(!isdummy(t)); ------------------ | | 106| 250k|#define lua_assert(c) assert(c) ------------------ 694| 250k| othern = mainpositionfromnode(t, mp); 695| 250k| if (othern != mp) { /* is colliding node out of its main position? */ ------------------ | Branch (695:9): [True: 59.7k, False: 191k] ------------------ 696| | /* yes; move colliding node into free position */ 697| 71.6k| while (othern + gnext(othern) != mp) /* find previous */ ------------------ | | 15| 71.6k|#define gnext(n) ((n)->u.next) ------------------ | Branch (697:14): [True: 11.8k, False: 59.7k] ------------------ 698| 11.8k| othern += gnext(othern); ------------------ | | 15| 11.8k|#define gnext(n) ((n)->u.next) ------------------ 699| 59.7k| gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */ ------------------ | | 15| 59.7k|#define gnext(n) ((n)->u.next) ------------------ gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */ ------------------ | | 141| 59.7k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 59.7k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 700| 59.7k| *f = *mp; /* copy colliding node into free pos. (mp->next also goes) */ 701| 59.7k| if (gnext(mp) != 0) { ------------------ | | 15| 59.7k|#define gnext(n) ((n)->u.next) ------------------ | Branch (701:11): [True: 8.34k, False: 51.3k] ------------------ 702| 8.34k| gnext(f) += cast_int(mp - f); /* correct 'next' */ ------------------ | | 15| 8.34k|#define gnext(n) ((n)->u.next) ------------------ gnext(f) += cast_int(mp - f); /* correct 'next' */ ------------------ | | 141| 8.34k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 8.34k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 703| 8.34k| gnext(mp) = 0; /* now 'mp' is free */ ------------------ | | 15| 8.34k|#define gnext(n) ((n)->u.next) ------------------ 704| 8.34k| } 705| 59.7k| setempty(gval(mp)); ------------------ | | 225| 59.7k|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 59.7k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 706| 59.7k| } 707| 191k| else { /* colliding node is in its own main position */ 708| | /* new node will go into free position */ 709| 191k| if (gnext(mp) != 0) ------------------ | | 15| 191k|#define gnext(n) ((n)->u.next) ------------------ | Branch (709:11): [True: 38.8k, False: 152k] ------------------ 710| 38.8k| gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */ ------------------ | | 15| 38.8k|#define gnext(n) ((n)->u.next) ------------------ gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */ ------------------ | | 141| 38.8k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 38.8k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 711| 191k| else lua_assert(gnext(f) == 0); ------------------ | | 106| 191k|#define lua_assert(c) assert(c) ------------------ 712| 191k| gnext(mp) = cast_int(f - mp); ------------------ | | 15| 191k|#define gnext(n) ((n)->u.next) ------------------ gnext(mp) = cast_int(f - mp); ------------------ | | 141| 191k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 191k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 713| 191k| mp = f; 714| 191k| } 715| 250k| } 716| 580k| setnodekey(L, mp, key); ------------------ | | 712| 580k| { Node *n_=(node); const TValue *io_=(obj); \ | | 713| 580k| n_->u.key_val = io_->value_; n_->u.key_tt = io_->tt_; \ | | 714| 580k| checkliveness(L,io_); } | | ------------------ | | | | 107| 580k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 1.07M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 580k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 33.1k] | | | | | | | Branch (112:29): [True: 33.1k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 33.1k] | | | | | | | Branch (112:29): [True: 33.1k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 33.1k] | | | | | | | Branch (112:29): [True: 33.1k, False: 0] | | | | | | | Branch (112:29): [True: 33.1k, False: 0] | | | | | | | Branch (112:29): [True: 547k, False: 33.1k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 580k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 717| 580k| luaC_barrierback(L, obj2gco(t), key); ------------------ | | 185| 580k|#define luaC_barrierback(L,p,v) ( \ | | 186| 580k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 580k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 580k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 580k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 33.1k, False: 547k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 182| 33.1k|#define luaC_objbarrierback(L,p,o) ( \ | | | | 183| 33.1k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 88| 33.1k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 33.1k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 132k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 4, False: 33.1k] | | | | | | | | | | | Branch (62:26): [True: 0, False: 33.1k] | | | | | | | | | | | Branch (62:26): [True: 33.1k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 87| 4|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 16|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 2, False: 2] | | | | | | | | | Branch (62:26): [True: 0, False: 4] | | | | | | | | | Branch (62:26): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 138| 33.1k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 33.1k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (183:51): [True: 0, False: 2] | | | | | Branch (183:51): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 547k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 547k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 718| 580k| lua_assert(isempty(gval(mp))); ------------------ | | 106| 580k|#define lua_assert(c) assert(c) ------------------ 719| 580k| setobj2t(L, gval(mp), value); ------------------ | | 137| 580k|#define setobj2t setobj | | ------------------ | | | | 119| 580k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 580k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 580k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 580k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 580k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 845k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 580k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 17.6k] | | | | | | | | | Branch (112:29): [True: 17.6k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 17.6k] | | | | | | | | | Branch (112:29): [True: 17.6k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 17.6k] | | | | | | | | | Branch (112:29): [True: 17.6k, False: 0] | | | | | | | | | Branch (112:29): [True: 17.6k, False: 0] | | | | | | | | | Branch (112:29): [True: 563k, False: 17.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 580k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 580k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 720| 580k|} ltable.c:getfreepos: 645| 252k|static Node *getfreepos (Table *t) { 646| 252k| if (!isdummy(t)) { ------------------ | | 27| 252k|#define isdummy(t) ((t)->lastfree == NULL) ------------------ | Branch (646:7): [True: 252k, False: 238] ------------------ 647| 545k| while (t->lastfree > t->node) { ------------------ | Branch (647:12): [True: 544k, False: 1.51k] ------------------ 648| 544k| t->lastfree--; 649| 544k| if (keyisnil(t->lastfree)) ------------------ | | 756| 544k|#define keyisnil(node) (keytt(node) == LUA_TNIL) | | ------------------ | | | | 753| 544k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisnil(node) (keytt(node) == LUA_TNIL) | | ------------------ | | | | 64| 544k|#define LUA_TNIL 0 | | ------------------ | | | Branch (756:25): [True: 250k, False: 293k] | | ------------------ ------------------ 650| 250k| return t->lastfree; 651| 544k| } 652| 252k| } 653| 1.75k| return NULL; /* could not find a free place */ 654| 252k|} ltable.c:rehash: 598| 1.75k|static void rehash (lua_State *L, Table *t, const TValue *ek) { 599| 1.75k| unsigned int asize; /* optimal size for array part */ 600| 1.75k| unsigned int na; /* number of keys in the array part */ 601| 1.75k| unsigned int nums[MAXABITS + 1]; 602| 1.75k| int i; 603| 1.75k| int totaluse; 604| 57.8k| for (i = 0; i <= MAXABITS; i++) nums[i] = 0; /* reset counts */ ------------------ | | 46| 57.8k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | ------------------ | | | | 141| 57.8k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 57.8k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (604:15): [True: 56.1k, False: 1.75k] ------------------ 605| 1.75k| setlimittosize(t); 606| 1.75k| na = numusearray(t, nums); /* count keys in array part */ 607| 1.75k| totaluse = na; /* all those keys are integer keys */ 608| 1.75k| totaluse += numusehash(t, nums, &na); /* count keys in hash part */ 609| | /* count extra key */ 610| 1.75k| if (ttisinteger(ek)) ------------------ | | 328| 1.75k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 1.75k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 1.75k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 320, False: 1.43k] | | | | ------------------ | | ------------------ ------------------ 611| 320| na += countint(ivalue(ek), nums); ------------------ | | 333| 320|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 320|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 320|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 612| 1.75k| totaluse++; 613| | /* compute new size for array part */ 614| 1.75k| asize = computesizes(nums, &na); 615| | /* resize the table to new computed sizes */ 616| 1.75k| luaH_resize(L, t, asize, totaluse - na); 617| 1.75k|} ltable.c:numusearray: 429| 1.75k|static unsigned int numusearray (const Table *t, unsigned int *nums) { 430| 1.75k| int lg; 431| 1.75k| unsigned int ttlg; /* 2^lg */ 432| 1.75k| unsigned int ause = 0; /* summation of 'nums' */ 433| 1.75k| unsigned int i = 1; /* count to traverse all array keys */ 434| 1.75k| unsigned int asize = limitasasize(t); /* real array size */ ------------------ | | 290| 1.75k|#define limitasasize(t) check_exp(isrealasize(t), t->alimit) | | ------------------ | | | | 110| 1.75k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 1.75k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 435| | /* traverse each slice */ 436| 3.95k| for (lg = 0, ttlg = 1; lg <= MAXABITS; lg++, ttlg *= 2) { ------------------ | | 46| 3.95k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | ------------------ | | | | 141| 3.95k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 3.95k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (436:26): [True: 3.95k, False: 0] ------------------ 437| 3.95k| unsigned int lc = 0; /* counter */ 438| 3.95k| unsigned int lim = ttlg; 439| 3.95k| if (lim > asize) { ------------------ | Branch (439:9): [True: 1.75k, False: 2.19k] ------------------ 440| 1.75k| lim = asize; /* adjust upper limit */ 441| 1.75k| if (i > lim) ------------------ | Branch (441:11): [True: 1.75k, False: 0] ------------------ 442| 1.75k| break; /* no more elements to count */ 443| 1.75k| } 444| | /* count elements in range (2^(lg - 1), 2^lg] */ 445| 113k| for (; i <= lim; i++) { ------------------ | Branch (445:12): [True: 111k, False: 2.19k] ------------------ 446| 111k| if (!isempty(&t->array[i-1])) ------------------ | | 217| 111k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 111k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 111k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 111k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 111k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (446:11): [True: 76.8k, False: 34.1k] ------------------ 447| 76.8k| lc++; 448| 111k| } 449| 2.19k| nums[lg] += lc; 450| 2.19k| ause += lc; 451| 2.19k| } 452| 1.75k| return ause; 453| 1.75k|} ltable.c:numusehash: 456| 1.75k|static int numusehash (const Table *t, unsigned int *nums, unsigned int *pna) { 457| 1.75k| int totaluse = 0; /* total number of elements */ 458| 1.75k| int ause = 0; /* elements added to 'nums' (can go to array part) */ 459| 1.75k| int i = sizenode(t); ------------------ | | 791| 1.75k|#define sizenode(t) (twoto((t)->lsizenode)) | | ------------------ | | | | 790| 1.75k|#define twoto(x) (1<<(x)) | | ------------------ ------------------ 460| 510k| while (i--) { ------------------ | Branch (460:10): [True: 508k, False: 1.75k] ------------------ 461| 508k| Node *n = &t->node[i]; 462| 508k| if (!isempty(gval(n))) { ------------------ | | 217| 508k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 508k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 508k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 508k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 508k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (462:9): [True: 507k, False: 754] ------------------ 463| 507k| if (keyisinteger(n)) ------------------ | | 757| 507k|#define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 753| 507k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 323| 507k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | | | ------------------ | | | | | | 42| 507k|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (757:28): [True: 483k, False: 24.4k] | | ------------------ ------------------ 464| 483k| ause += countint(keyival(n), nums); ------------------ | | 758| 483k|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 754| 483k|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ 465| 507k| totaluse++; 466| 507k| } 467| 508k| } 468| 1.75k| *pna += ause; 469| 1.75k| return totaluse; 470| 1.75k|} ltable.c:countint: 413| 483k|static int countint (lua_Integer key, unsigned int *nums) { 414| 483k| unsigned int k = arrayindex(key); 415| 483k| if (k != 0) { /* is 'key' an appropriate array index? */ ------------------ | Branch (415:7): [True: 56.5k, False: 427k] ------------------ 416| 56.5k| nums[luaO_ceillog2(k)]++; /* count as such */ 417| 56.5k| return 1; 418| 56.5k| } 419| 427k| else 420| 427k| return 0; 421| 483k|} ltable.c:computesizes: 391| 1.75k|static unsigned int computesizes (unsigned int nums[], unsigned int *pna) { 392| 1.75k| int i; 393| 1.75k| unsigned int twotoi; /* 2^i (candidate for optimal size) */ 394| 1.75k| unsigned int a = 0; /* number of elements smaller than 2^i */ 395| 1.75k| unsigned int na = 0; /* number of elements to go to array part */ 396| 1.75k| unsigned int optimal = 0; /* optimal size for array part */ 397| | /* loop while keys can fill more than half of total size */ 398| 1.75k| for (i = 0, twotoi = 1; 399| 5.40k| twotoi > 0 && *pna > twotoi / 2; ------------------ | Branch (399:8): [True: 5.40k, False: 0] | Branch (399:22): [True: 3.65k, False: 1.75k] ------------------ 400| 3.65k| i++, twotoi *= 2) { 401| 3.65k| a += nums[i]; 402| 3.65k| if (a > twotoi/2) { /* more than half elements present? */ ------------------ | Branch (402:9): [True: 2.46k, False: 1.19k] ------------------ 403| 2.46k| optimal = twotoi; /* optimal size (till now) */ 404| 2.46k| na = a; /* all elements up to 'optimal' will go to array part */ 405| 2.46k| } 406| 3.65k| } 407| 1.75k| lua_assert((optimal == 0 || optimal / 2 < na) && na <= optimal); ------------------ | | 106| 1.75k|#define lua_assert(c) assert(c) ------------------ 408| 1.75k| *pna = na; 409| 1.75k| return optimal; 410| 1.75k|} ltable.c:mainpositionfromnode: 189| 250k|l_sinline Node *mainpositionfromnode (const Table *t, Node *nd) { 190| 250k| TValue key; 191| 250k| getnodekey(cast(lua_State *, NULL), &key, nd); ------------------ | | 719| 250k| { TValue *io_=(obj); const Node *n_=(node); \ | | 720| 250k| io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \ | | 721| 250k| checkliveness(L,io_); } | | ------------------ | | | | 107| 250k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 375k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 250k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 13.8k] | | | | | | | Branch (112:29): [True: 13.8k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [Folded - Ignored] | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | Branch (112:29): [True: 13.8k, False: 0] | | | | | | | Branch (112:29): [True: 236k, False: 13.8k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 250k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 192| 250k| return mainpositionTV(t, &key); 193| 250k|} ltable.c:ispow2realasize: 278| 44.0k|static int ispow2realasize (const Table *t) { 279| 44.0k| return (!isrealasize(t) || ispow2(t->alimit)); ------------------ | | 732| 88.1k|#define isrealasize(t) (!((t)->flags & BITRAS)) | | ------------------ | | | | 731| 44.0k|#define BITRAS (1 << 7) | | ------------------ ------------------ return (!isrealasize(t) || ispow2(t->alimit)); ------------------ | | 66| 43.9k|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | ------------------ | | | Branch (66:19): [True: 43.9k, False: 0] | | ------------------ ------------------ | Branch (279:11): [True: 143, False: 43.9k] ------------------ 280| 44.0k|} ltable.c:binsearch: 882| 43.9k| unsigned int j) { 883| 538k| while (j - i > 1u) { /* binary search */ ------------------ | Branch (883:10): [True: 494k, False: 43.9k] ------------------ 884| 494k| unsigned int m = (i + j) / 2; 885| 494k| if (isempty(&array[m - 1])) j = m; ------------------ | | 217| 494k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 494k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 494k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 494k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 494k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 237k, False: 257k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 886| 257k| else i = m; 887| 494k| } 888| 43.9k| return i; 889| 43.9k|} ltable.c:hash_search: 856| 7.13k|static lua_Unsigned hash_search (Table *t, lua_Unsigned j) { 857| 7.13k| lua_Unsigned i; 858| 7.13k| if (j == 0) j++; /* the caller ensures 'j + 1' is present */ ------------------ | Branch (858:7): [True: 21, False: 7.11k] ------------------ 859| 9.96k| do { 860| 9.96k| i = j; /* 'i' is a present index */ 861| 9.96k| if (j <= l_castS2U(LUA_MAXINTEGER) / 2) ------------------ | | 152| 9.96k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (861:9): [True: 9.95k, False: 2] ------------------ 862| 9.95k| j *= 2; 863| 2| else { 864| 2| j = LUA_MAXINTEGER; ------------------ | | 554| 2|#define LUA_MAXINTEGER LLONG_MAX ------------------ 865| 2| if (isempty(luaH_getint(t, j))) /* t[j] not present? */ ------------------ | | 217| 2|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 2|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 2|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 2|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 2|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 2, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 866| 2| break; /* 'j' now is an absent index */ 867| 0| else /* weird case */ 868| 0| return j; /* well, max integer is a boundary... */ 869| 2| } 870| 9.96k| } while (!isempty(luaH_getint(t, j))); /* repeat until an absent t[j] */ ------------------ | | 217| 9.95k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 9.95k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 9.95k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 9.95k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 9.95k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (870:12): [True: 2.82k, False: 7.13k] ------------------ 871| | /* i < j && t[i] present && t[j] absent */ 872| 58.0k| while (j - i > 1u) { /* do a binary search between them */ ------------------ | Branch (872:10): [True: 50.9k, False: 7.13k] ------------------ 873| 50.9k| lua_Unsigned m = (i + j) / 2; 874| 50.9k| if (isempty(luaH_getint(t, m))) j = m; ------------------ | | 217| 50.9k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 50.9k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 50.9k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 50.9k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 50.9k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 30.4k, False: 20.5k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 875| 20.5k| else i = m; 876| 50.9k| } 877| 7.13k| return i; 878| 7.13k|} luaT_init: 38| 225|void luaT_init (lua_State *L) { 39| 225| static const char *const luaT_eventname[] = { /* ORDER TM */ 40| 225| "__index", "__newindex", 41| 225| "__gc", "__mode", "__len", "__eq", 42| 225| "__add", "__sub", "__mul", "__mod", "__pow", 43| 225| "__div", "__idiv", 44| 225| "__band", "__bor", "__bxor", "__shl", "__shr", 45| 225| "__unm", "__bnot", "__lt", "__le", 46| 225| "__concat", "__call", "__close" 47| 225| }; 48| 225| int i; 49| 5.85k| for (i=0; itmname[i] = luaS_new(L, luaT_eventname[i]); ------------------ | | 335| 5.62k|#define G(L) (L->l_G) ------------------ 51| 5.62k| luaC_fix(L, obj2gco(G(L)->tmname[i])); /* never collect these names */ ------------------ | | 390| 5.62k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 110| 5.62k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 5.62k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 52| 5.62k| } 53| 225|} luaT_gettm: 60| 12|const TValue *luaT_gettm (Table *events, TMS event, TString *ename) { 61| 12| const TValue *tm = luaH_getshortstr(events, ename); 62| 12| lua_assert(event <= TM_EQ); ------------------ | | 106| 12|#define lua_assert(c) assert(c) ------------------ 63| 12| if (notm(tm)) { /* no tag method? */ ------------------ | | 61| 12|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 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: 0, False: 12] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 64| 0| events->flags |= cast_byte(1u<metatable; ------------------ | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 76| 0| break; 77| 36| case LUA_TUSERDATA: ------------------ | | 71| 36|#define LUA_TUSERDATA 7 ------------------ | Branch (77:5): [True: 36, False: 69] ------------------ 78| 36| mt = uvalue(o)->metatable; ------------------ | | 435| 36|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 110| 144|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 36|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 36] | | | | | Branch (110:42): [True: 36, False: 0] | | | | ------------------ | | ------------------ ------------------ 79| 0| break; 80| 69| default: ------------------ | Branch (80:5): [True: 69, False: 36] ------------------ 81| 69| mt = G(L)->mt[ttype(o)]; ------------------ | | 335| 69|#define G(L) (L->l_G) ------------------ mt = G(L)->mt[ttype(o)]; ------------------ | | 87| 69|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 69|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 82| 105| } 83| 105| return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : &G(L)->nilvalue); ------------------ | | 335| 36|#define G(L) (L->l_G) ------------------ return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : &G(L)->nilvalue); ------------------ | | 335| 69|#define G(L) (L->l_G) ------------------ | Branch (83:11): [True: 36, False: 69] ------------------ 84| 105|} luaT_objtypename: 91| 40|const char *luaT_objtypename (lua_State *L, const TValue *o) { 92| 40| Table *mt; 93| 40| if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) || ------------------ | | 680| 40|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | ------------------ | | | | 91| 80|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 40|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 40] | | | | ------------------ | | ------------------ ------------------ if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) || ------------------ | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (93:24): [True: 0, False: 0] ------------------ 94| 40| (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) { ------------------ | | 432| 40|#define ttisfulluserdata(o) checktag((o), ctb(LUA_VUSERDATA)) | | ------------------ | | | | 91| 80|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 40|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 40] | | | | ------------------ | | ------------------ ------------------ (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) { ------------------ | | 435| 0|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | 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 */ ------------------ | | 404| 0|#define getstr(ts) ((ts)->contents) | | ------------------ | | | Branch (404:22): [True: 0, False: 0] | | | Branch (404:22): [True: 0, False: 0] | | | Branch (404:22): [True: 0, False: 0] | | | Branch (404:22): [True: 0, False: 0] | | ------------------ ------------------ 98| 0| } 99| 40| return ttypename(ttype(o)); /* else use standard type name */ ------------------ | | 69| 40|#define ttypename(x) luaT_typenames_[(x) + 1] ------------------ 100| 40|} luaT_trybinTM: 149| 29| StkId res, TMS event) { 150| 29| if (l_unlikely(!callbinTM(L, p1, p2, res, event))) { ------------------ | | 697| 29|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 29|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 29, False: 0] | | | | ------------------ | | ------------------ ------------------ 151| 29| switch (event) { 152| 8| case TM_BAND: case TM_BOR: case TM_BXOR: ------------------ | Branch (152:7): [True: 6, False: 23] | Branch (152:21): [True: 2, False: 27] | Branch (152:34): [True: 0, False: 29] ------------------ 153| 21| case TM_SHL: case TM_SHR: case TM_BNOT: { ------------------ | Branch (153:7): [True: 5, False: 24] | Branch (153:20): [True: 0, False: 29] | Branch (153:33): [True: 8, False: 21] ------------------ 154| 21| if (ttisnumber(p1) && ttisnumber(p2)) ------------------ | | 326| 21|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | ------------------ | | | | 92| 42|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 21|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 21|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 3, False: 18] | | | | ------------------ | | ------------------ ------------------ if (ttisnumber(p1) && ttisnumber(p2)) ------------------ | | 326| 3|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | ------------------ | | | | 92| 3|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 3|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 3|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 2, False: 1] | | | | ------------------ | | ------------------ ------------------ 155| 2| luaG_tointerror(L, p1, p2); 156| 19| else 157| 19| luaG_opinterror(L, p1, p2, "perform bitwise operation on"); 158| 21| } 159| | /* calls never return, but to avoid warnings: *//* FALLTHROUGH */ 160| 8| default: ------------------ | Branch (160:7): [True: 8, False: 21] ------------------ 161| 8| luaG_opinterror(L, p1, p2, "perform arithmetic on"); 162| 29| } 163| 29| } 164| 29|} luaT_tryconcatTM: 167| 1|void luaT_tryconcatTM (lua_State *L) { 168| 1| StkId top = L->top.p; 169| 1| if (l_unlikely(!callbinTM(L, s2v(top - 2), s2v(top - 1), top - 2, ------------------ | | 697| 1|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 1|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 1, False: 0] | | | | ------------------ | | ------------------ ------------------ 170| 1| TM_CONCAT))) 171| 1| luaG_concaterror(L, s2v(top - 2), s2v(top - 1)); ------------------ | | 172| 1|#define s2v(o) (&(o)->val) ------------------ luaG_concaterror(L, s2v(top - 2), s2v(top - 1)); ------------------ | | 172| 1|#define s2v(o) (&(o)->val) ------------------ 172| 1|} luaT_trybinassocTM: 176| 1| int flip, StkId res, TMS event) { 177| 1| if (flip) ------------------ | Branch (177:7): [True: 1, False: 0] ------------------ 178| 1| luaT_trybinTM(L, p2, p1, res, event); 179| 0| else 180| 0| luaT_trybinTM(L, p1, p2, res, event); 181| 1|} luaT_callorderTM: 202| 3| TMS event) { 203| 3| if (callbinTM(L, p1, p2, L->top.p, event)) /* try original event */ ------------------ | Branch (203:7): [True: 0, False: 3] ------------------ 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| 3| luaG_ordererror(L, p1, p2); /* no metamethod found */ 217| 0| return 0; /* to avoid warnings */ 218| 3|} luaT_callorderiTM: 222| 2| int flip, int isfloat, TMS event) { 223| 2| TValue aux; const TValue *p2; 224| 2| if (isfloat) { ------------------ | Branch (224:7): [True: 2, False: 0] ------------------ 225| 2| setfltvalue(&aux, cast_num(v2)); ------------------ | | 339| 2| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 2|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 2|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 226| 2| } 227| 0| else 228| 0| setivalue(&aux, v2); ------------------ | | 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)) | | ------------------ ------------------ 229| 2| if (flip) { /* arguments were exchanged? */ ------------------ | Branch (229:7): [True: 2, False: 0] ------------------ 230| 2| p2 = p1; p1 = &aux; /* correct them */ 231| 2| } 232| 0| else 233| 0| p2 = &aux; 234| 2| return luaT_callorderTM(L, p1, p2, event); 235| 2|} luaT_adjustvarargs: 239| 2.04k| const Proto *p) { 240| 2.04k| int i; 241| 2.04k| int actual = cast_int(L->top.p - ci->func.p) - 1; /* number of arguments */ ------------------ | | 141| 2.04k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 2.04k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 242| 2.04k| int nextra = actual - nfixparams; /* number of extra arguments */ 243| 2.04k| ci->u.l.nextraargs = nextra; 244| 2.04k| luaD_checkstack(L, p->maxstacksize + 1); ------------------ | | 32| 2.04k|#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0) | | ------------------ | | | | 27| 2.04k| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 2.04k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 2.04k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 3, False: 2.04k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 2.04k| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 2.04k| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 2.04k|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 245| | /* copy function to the top of the stack */ 246| 2.04k| setobjs2s(L, L->top.p++, ci->func.p); ------------------ | | 129| 2.04k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 2.04k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 2.04k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 2.04k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 2.04k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 2.04k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 32.7k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 2.04k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 2.04k] | | | | | | | | | Branch (112:29): [True: 2.04k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 2.04k] | | | | | | | | | Branch (112:29): [True: 2.04k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 2.04k] | | | | | | | | | Branch (112:29): [True: 2.04k, False: 0] | | | | | | | | | Branch (112:29): [True: 2.04k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 2.04k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 2.04k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 2.04k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 247| | /* move fixed parameters to the top of the stack */ 248| 2.04k| for (i = 1; i <= nfixparams; i++) { ------------------ | Branch (248:15): [True: 0, False: 2.04k] ------------------ 249| 0| setobjs2s(L, L->top.p++, ci->func.p + i); ------------------ | | 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) || \ | | | | | | ------------------ | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 250| 0| setnilvalue(s2v(ci->func.p + i)); /* erase original parameter (for GC) */ ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 251| 0| } 252| 2.04k| ci->func.p += actual + 1; 253| 2.04k| ci->top.p += actual + 1; 254| 2.04k| lua_assert(L->top.p <= ci->top.p && ci->top.p <= L->stack_last.p); ------------------ | | 106| 2.04k|#define lua_assert(c) assert(c) ------------------ 255| 2.04k|} luaT_getvarargs: 258| 87.6k|void luaT_getvarargs (lua_State *L, CallInfo *ci, StkId where, int wanted) { 259| 87.6k| int i; 260| 87.6k| int nextra = ci->u.l.nextraargs; 261| 87.6k| if (wanted < 0) { ------------------ | Branch (261:7): [True: 2.00k, False: 85.6k] ------------------ 262| 2.00k| wanted = nextra; /* get all extra arguments available */ 263| 2.00k| checkstackGCp(L, nextra, where); /* ensure stack space */ ------------------ | | 49| 2.00k| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 2.00k| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 2.00k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 2.00k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 2.00k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 2.00k| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | ------------------ | | | | | Branch (28:6): [True: 0, False: 0] | | | | ------------------ | | | | 29| 2.00k| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 2.00k|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 50| 2.00k| ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ | | 51| 2.00k| luaC_checkGC(L), /* stack grow uses memory */ \ | | 52| 2.00k| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 264| 2.00k| L->top.p = where + nextra; /* next instruction will need top */ 265| 2.00k| } 266| 89.6k| for (i = 0; i < wanted && i < nextra; i++) ------------------ | Branch (266:15): [True: 84.8k, False: 4.89k] | Branch (266:29): [True: 2.00k, False: 82.7k] ------------------ 267| 87.6k| setobjs2s(L, where + i, ci->func.p - nextra + i); ------------------ | | 129| 2.00k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 2.00k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 2.00k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 2.00k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 2.00k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 2.00k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 32.0k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 2.00k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 2.00k] | | | | | | | | | Branch (112:29): [True: 2.00k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 2.00k] | | | | | | | | | Branch (112:29): [True: 2.00k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 2.00k] | | | | | | | | | Branch (112:29): [True: 2.00k, False: 0] | | | | | | | | | Branch (112:29): [True: 2.00k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 2.00k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 2.00k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 2.00k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 268| 170k| for (; i < wanted; i++) /* complete required results with nil */ ------------------ | Branch (268:10): [True: 82.7k, False: 87.6k] ------------------ 269| 87.6k| setnilvalue(s2v(where + i)); ------------------ | | 200| 82.7k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 170k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 270| 87.6k|} ltm.c:callbinTM: 138| 33| StkId res, TMS event) { 139| 33| const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */ 140| 33| if (notm(tm)) ------------------ | | 61| 33|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 193| 33|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 33|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 33|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 33|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 33, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 141| 33| tm = luaT_gettmbyobj(L, p2, event); /* try second operand */ 142| 33| if (notm(tm)) return 0; ------------------ | | 61| 33|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 193| 33|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 33|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 33|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 33|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 33, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 143| 0| luaT_callTMres(L, tm, p1, p2, res); 144| 0| return 1; 145| 33|} luaV_tonumber_: 105| 3|int luaV_tonumber_ (const TValue *obj, lua_Number *n) { 106| 3| TValue v; 107| 3| if (ttisinteger(obj)) { ------------------ | | 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: 0, False: 3] | | | | ------------------ | | ------------------ ------------------ 108| 0| *n = cast_num(ivalue(obj)); ------------------ | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 0, False: 0] | | | | | Branch (136:27): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 109| 0| return 1; 110| 0| } 111| 3| else if (l_strton(obj, &v)) { /* string coercible to number? */ ------------------ | Branch (111:12): [True: 0, False: 3] ------------------ 112| 0| *n = nvalue(&v); /* convert result of 'luaO_str2num' to a float */ ------------------ | | 330| 0|#define nvalue(o) check_exp(ttisnumber(o), \ | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 331| 0| (ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o))) ------------------ 113| 0| return 1; 114| 0| } 115| 3| else 116| 3| return 0; /* conversion failed */ 117| 3|} luaV_flttointeger: 123| 207k|int luaV_flttointeger (lua_Number n, lua_Integer *p, F2Imod mode) { 124| 207k| lua_Number f = l_floor(n); ------------------ | | 418| 207k|#define l_floor(x) (l_mathop(floor)(x)) | | ------------------ | | | | 482| 207k|#define l_mathop(op) op | | ------------------ ------------------ 125| 207k| if (n != f) { /* not an integral value? */ ------------------ | Branch (125:7): [True: 105k, False: 101k] ------------------ 126| 105k| if (mode == F2Ieq) return 0; /* fails if mode demands integral value */ ------------------ | Branch (126:9): [True: 105k, False: 24] ------------------ 127| 24| else if (mode == F2Iceil) /* needs ceil? */ ------------------ | Branch (127:14): [True: 23, False: 1] ------------------ 128| 23| f += 1; /* convert floor to ceil (remember: n != f) */ 129| 105k| } 130| 101k| return lua_numbertointeger(f, p); ------------------ | | 433| 101k| ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 555| 101k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (433:4): [True: 100k, False: 1.66k] | | ------------------ | | 434| 101k| (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 555| 100k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (434:4): [True: 94.6k, False: 5.56k] | | ------------------ | | 435| 101k| (*(p) = (LUA_INTEGER)(n), 1)) | | ------------------ | | | Branch (435:7): [True: 94.6k, False: 0] | | ------------------ ------------------ 131| 207k|} luaV_tointegerns: 139| 223k|int luaV_tointegerns (const TValue *obj, lua_Integer *p, F2Imod mode) { 140| 223k| if (ttisfloat(obj)) ------------------ | | 327| 223k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 223k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 223k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 90.6k, False: 133k] | | | | ------------------ | | ------------------ ------------------ 141| 90.6k| return luaV_flttointeger(fltvalue(obj), p, mode); ------------------ | | 332| 90.6k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 110| 90.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 90.6k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 142| 133k| else if (ttisinteger(obj)) { ------------------ | | 328| 133k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 133k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 133k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 133k, False: 20] | | | | ------------------ | | ------------------ ------------------ 143| 133k| *p = ivalue(obj); ------------------ | | 333| 133k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 133k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 133k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 144| 0| return 1; 145| 133k| } 146| 20| else 147| 20| return 0; 148| 223k|} luaV_tointeger: 154| 60.1k|int luaV_tointeger (const TValue *obj, lua_Integer *p, F2Imod mode) { 155| 60.1k| TValue v; 156| 60.1k| if (l_strton(obj, &v)) /* does 'obj' point to a numerical string? */ ------------------ | Branch (156:7): [True: 0, False: 60.1k] ------------------ 157| 0| obj = &v; /* change it to point to its corresponding number */ 158| 60.1k| return luaV_tointegerns(obj, p, mode); 159| 60.1k|} luaV_finishget: 290| 4.56M| const TValue *slot) { 291| 4.56M| int loop; /* counter to avoid infinite loops */ 292| 4.56M| const TValue *tm; /* metamethod */ 293| 4.56M| for (loop = 0; loop < MAXTAGLOOP; loop++) { ------------------ | | 49| 4.56M|#define MAXTAGLOOP 2000 ------------------ | Branch (293:18): [True: 4.56M, False: 0] ------------------ 294| 4.56M| if (slot == NULL) { /* 't' is not a table? */ ------------------ | Branch (294:9): [True: 2, False: 4.56M] ------------------ 295| 2| lua_assert(!ttistable(t)); ------------------ | | 106| 2|#define lua_assert(c) assert(c) ------------------ 296| 2| tm = luaT_gettmbyobj(L, t, TM_INDEX); 297| 2| if (l_unlikely(notm(tm))) ------------------ | | 697| 2|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 2|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 2, False: 0] | | | | ------------------ | | ------------------ ------------------ 298| 2| luaG_typeerror(L, t, "index"); /* no metamethod */ 299| | /* else will try the metamethod */ 300| 2| } 301| 4.56M| else { /* 't' is a table */ 302| 4.56M| lua_assert(isempty(slot)); ------------------ | | 106| 4.56M|#define lua_assert(c) assert(c) ------------------ 303| 4.56M| tm = fasttm(L, hvalue(t)->metatable, TM_INDEX); /* table's metamethod */ ------------------ | | 67| 4.56M|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 64| 36.5M|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (64:26): [True: 4.56M, False: 0] | | | | | Branch (64:27): [True: 0, False: 4.56M] | | | | | Branch (64:27): [True: 4.56M, False: 0] | | | | | Branch (64:27): [True: 0, False: 4.56M] | | | | | Branch (64:27): [True: 4.56M, False: 0] | | | | ------------------ | | | | 65| 4.56M| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 304| 4.56M| if (tm == NULL) { /* no metamethod? */ ------------------ | Branch (304:11): [True: 4.56M, False: 0] ------------------ 305| 4.56M| setnilvalue(s2v(val)); /* result is nil */ ------------------ | | 200| 4.56M|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 4.56M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 306| 4.56M| return; 307| 4.56M| } 308| | /* else will try the metamethod */ 309| 4.56M| } 310| 0| if (ttisfunction(tm)) { /* is metamethod a function? */ ------------------ | | 592| 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] | | | | ------------------ | | ------------------ ------------------ 311| 0| luaT_callTMres(L, tm, t, key, val); /* call it */ 312| 0| return; 313| 0| } 314| 0| t = tm; /* else try to access 'tm[key]' */ 315| 0| if (luaV_fastget(L, t, key, slot, luaH_get)) { /* fast track? */ ------------------ | | 86| 0| (!ttistable(t) \ | | ------------------ | | | | 680| 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 */ \ | | ------------------ | | | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 316| 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) || \ | | | | | | ------------------ | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 317| 0| return; 318| 0| } 319| | /* else repeat (tail call 'luaV_finishget') */ 320| 0| } 321| 0| luaG_runerror(L, "'__index' chain too long; possible loop"); 322| 4.56M|} luaV_finishset: 333| 1.77M| TValue *val, const TValue *slot) { 334| 1.77M| int loop; /* counter to avoid infinite loops */ 335| 1.77M| for (loop = 0; loop < MAXTAGLOOP; loop++) { ------------------ | | 49| 1.77M|#define MAXTAGLOOP 2000 ------------------ | Branch (335:18): [True: 1.77M, False: 0] ------------------ 336| 1.77M| const TValue *tm; /* '__newindex' metamethod */ 337| 1.77M| if (slot != NULL) { /* is 't' a table? */ ------------------ | Branch (337:9): [True: 1.77M, False: 1] ------------------ 338| 3.54M| Table *h = hvalue(t); /* save 't' table */ ------------------ | | 682| 1.77M|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 110| 7.08M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 1.77M|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 1.77M] | | | | | Branch (110:42): [True: 1.77M, False: 0] | | | | ------------------ | | ------------------ ------------------ 339| 1.77M| lua_assert(isempty(slot)); /* slot must be empty */ ------------------ | | 106| 1.77M|#define lua_assert(c) assert(c) ------------------ 340| 1.77M| tm = fasttm(L, h->metatable, TM_NEWINDEX); /* get metamethod */ ------------------ | | 67| 1.77M|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 64| 1.77M|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (64:26): [True: 1.77M, False: 0] | | | | ------------------ | | | | 65| 1.77M| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 341| 1.77M| if (tm == NULL) { /* no metamethod? */ ------------------ | Branch (341:11): [True: 1.77M, False: 0] ------------------ 342| 1.77M| luaH_finishset(L, h, key, slot, val); /* set new value */ 343| 1.77M| invalidateTMcache(h); ------------------ | | 23| 1.77M|#define invalidateTMcache(t) ((t)->flags &= ~maskflags) | | ------------------ | | | | 54| 1.77M|#define maskflags (~(~0u << (TM_EQ + 1))) | | ------------------ ------------------ 344| 1.77M| luaC_barrierback(L, obj2gco(h), val); ------------------ | | 185| 1.77M|#define luaC_barrierback(L,p,v) ( \ | | 186| 1.77M| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 1.77M|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 1.77M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 1.77M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 2.71k, False: 1.76M] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 182| 2.71k|#define luaC_objbarrierback(L,p,o) ( \ | | | | 183| 2.71k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 88| 2.71k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 2.71k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 10.8k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 2.71k] | | | | | | | | | | | Branch (62:26): [True: 0, False: 2.71k] | | | | | | | | | | | Branch (62:26): [True: 2.71k, 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] | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 138| 2.71k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 2.71k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (183:51): [True: 0, False: 0] | | | | | Branch (183:51): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 1.76M|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 1.76M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 345| 0| return; 346| 1.77M| } 347| | /* else will try the metamethod */ 348| 1.77M| } 349| 1| else { /* not a table; check metamethod */ 350| 1| tm = luaT_gettmbyobj(L, t, TM_NEWINDEX); 351| 1| if (l_unlikely(notm(tm))) ------------------ | | 697| 1|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 1|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 1, False: 0] | | | | ------------------ | | ------------------ ------------------ 352| 1| luaG_typeerror(L, t, "index"); 353| 1| } 354| | /* try the metamethod */ 355| 0| if (ttisfunction(tm)) { ------------------ | | 592| 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] | | | | ------------------ | | ------------------ ------------------ 356| 0| luaT_callTM(L, tm, t, key, val); 357| 0| return; 358| 0| } 359| 0| t = tm; /* else repeat assignment over 'tm' */ 360| 0| if (luaV_fastget(L, t, key, slot, luaH_get)) { ------------------ | | 86| 0| (!ttistable(t) \ | | ------------------ | | | | 680| 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 */ \ | | ------------------ | | | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 361| 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) || \ | | | | | | | | ------------------ | | | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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] | | | | | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | | | | | Branch (62:26): [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] | | | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | | | Branch (62:26): [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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (183:51): [True: 0, False: 0] | | | | | | | Branch (183:51): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 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)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 362| 0| return; /* done */ 363| 0| } 364| | /* else 'return luaV_finishset(L, t, key, val, slot)' (loop) */ 365| 0| } 366| 0| luaG_runerror(L, "'__newindex' chain too long; possible loop"); 367| 1.77M|} luaV_equalobj: 569| 5.23M|int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) { 570| 5.23M| const TValue *tm; 571| 5.23M| if (ttypetag(t1) != ttypetag(t2)) { /* not the same variant? */ ------------------ | | 84| 5.23M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 5.23M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ if (ttypetag(t1) != ttypetag(t2)) { /* not the same variant? */ ------------------ | | 84| 5.23M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 5.23M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ | Branch (571:7): [True: 67.4k, False: 5.16M] ------------------ 572| 67.4k| if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 87| 67.4k|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 67.4k|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 87| 134k|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 67.4k|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 87| 26.6k|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 26.6k|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 67| 26.6k|#define LUA_TNUMBER 3 ------------------ | Branch (572:9): [True: 40.7k, False: 26.6k] | Branch (572:35): [True: 0, False: 26.6k] ------------------ 573| 40.7k| return 0; /* only numbers can be equal with different variants */ 574| 26.6k| else { /* two numbers with different variants */ 575| | /* One of them is an integer. If the other does not have an 576| | integer value, they cannot be equal; otherwise, compare their 577| | integer values. */ 578| 26.6k| lua_Integer i1, i2; 579| 26.6k| return (luaV_tointegerns(t1, &i1, F2Ieq) && ------------------ | Branch (579:15): [True: 25.4k, False: 1.13k] ------------------ 580| 26.6k| luaV_tointegerns(t2, &i2, F2Ieq) && ------------------ | Branch (580:15): [True: 25, False: 25.4k] ------------------ 581| 26.6k| i1 == i2); ------------------ | Branch (581:15): [True: 0, False: 25] ------------------ 582| 26.6k| } 583| 67.4k| } 584| | /* values have same type and same variant */ 585| 5.16M| switch (ttypetag(t1)) { ------------------ | | 84| 5.16M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 5.16M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 586| 890| case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1; ------------------ | | 183| 443|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 443|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1; ------------------ | | 239| 457|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 457|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1; ------------------ | | 240| 890|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 890|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (586:5): [True: 443, False: 5.16M] | Branch (586:20): [True: 14, False: 5.16M] | Branch (586:37): [True: 433, False: 5.16M] ------------------ 587| 24.1k| case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2)); ------------------ | | 323| 24.1k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 24.1k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2)); ------------------ | | 333| 24.1k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 24.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 24.1k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2)); ------------------ | | 333| 24.1k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 24.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 24.1k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (587:5): [True: 24.1k, False: 5.14M] ------------------ 588| 31.5k| case LUA_VNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2)); ------------------ | | 324| 31.5k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 31.5k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2)); ------------------ | | 350| 126k|#define luai_numeq(a,b) ((a)==(b)) | | ------------------ | | | Branch (350:35): [True: 0, False: 31.5k] | | | Branch (350:35): [True: 31.5k, False: 0] | | | Branch (350:40): [True: 0, False: 31.5k] | | | Branch (350:40): [True: 31.5k, False: 0] | | ------------------ ------------------ | Branch (588:5): [True: 31.5k, False: 5.13M] ------------------ 589| 0| case LUA_VLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); ------------------ | | 427| 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); ------------------ | | 434| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ case LUA_VLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); ------------------ | | 434| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (589:5): [True: 0, False: 5.16M] ------------------ 590| 0| case LUA_VLCF: return fvalue(t1) == fvalue(t2); ------------------ | | 589| 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); ------------------ | | 603| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ case LUA_VLCF: return fvalue(t1) == fvalue(t2); ------------------ | | 603| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (590:5): [True: 0, False: 5.16M] ------------------ 591| 20.3M| case LUA_VSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 360| 5.09M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 5.09M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 41| 5.09M|#define eqshrstr(a,b) check_exp((a)->tt == LUA_VSHRSTR, (a) == (b)) | | ------------------ | | | | 110| 81.5M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 5.09M|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 5.09M] | | | | | Branch (110:42): [True: 5.09M, False: 0] | | | | | Branch (110:42): [True: 0, False: 5.09M] | | | | | Branch (110:42): [True: 5.09M, False: 0] | | | | | Branch (110:42): [True: 0, False: 5.09M] | | | | | Branch (110:42): [True: 5.09M, False: 0] | | | | | Branch (110:42): [True: 0, False: 5.09M] | | | | | Branch (110:42): [True: 5.09M, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (591:5): [True: 5.09M, False: 72.5k] ------------------ 592| 31.7k| case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 361| 15.8k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 15.8k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 369| 15.8k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 63.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 15.8k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 15.8k] | | | | | Branch (110:42): [True: 15.8k, False: 0] | | | | ------------------ | | ------------------ ------------------ case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 369| 15.8k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 63.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 15.8k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 15.8k] | | | | | Branch (110:42): [True: 15.8k, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (592:5): [True: 15.8k, False: 5.15M] ------------------ 593| 0| case LUA_VUSERDATA: { ------------------ | | 429| 0|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (593:5): [True: 0, False: 5.16M] ------------------ 594| 0| if (uvalue(t1) == uvalue(t2)) return 1; ------------------ | | 435| 0|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ if (uvalue(t1) == uvalue(t2)) return 1; ------------------ | | 435| 0|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (594:11): [True: 0, False: 0] ------------------ 595| 0| else if (L == NULL) return 0; ------------------ | Branch (595:16): [True: 0, False: 0] ------------------ 596| 0| tm = fasttm(L, uvalue(t1)->metatable, TM_EQ); ------------------ | | 67| 0|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 64| 0|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (64:26): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | ------------------ | | | | 65| 0| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 597| 0| if (tm == NULL) ------------------ | Branch (597:11): [True: 0, False: 0] ------------------ 598| 0| tm = fasttm(L, uvalue(t2)->metatable, TM_EQ); ------------------ | | 67| 0|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 64| 0|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (64:26): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | ------------------ | | | | 65| 0| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 599| 0| break; /* will try TM */ 600| 0| } 601| 0| case LUA_VTABLE: { ------------------ | | 678| 0|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (601:5): [True: 0, False: 5.16M] ------------------ 602| 0| if (hvalue(t1) == hvalue(t2)) return 1; ------------------ | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ if (hvalue(t1) == hvalue(t2)) return 1; ------------------ | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (602:11): [True: 0, False: 0] ------------------ 603| 0| else if (L == NULL) return 0; ------------------ | Branch (603:16): [True: 0, False: 0] ------------------ 604| 0| tm = fasttm(L, hvalue(t1)->metatable, TM_EQ); ------------------ | | 67| 0|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 64| 0|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (64:26): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | ------------------ | | | | 65| 0| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 605| 0| if (tm == NULL) ------------------ | Branch (605:11): [True: 0, False: 0] ------------------ 606| 0| tm = fasttm(L, hvalue(t2)->metatable, TM_EQ); ------------------ | | 67| 0|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 64| 0|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (64:26): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | | Branch (64:27): [True: 0, False: 0] | | | | ------------------ | | | | 65| 0| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:5): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | | Branch (65:49): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 607| 0| break; /* will try TM */ 608| 0| } 609| 0| default: ------------------ | Branch (609:5): [True: 0, False: 5.16M] ------------------ 610| 5.16M| return gcvalue(t1) == gcvalue(t2); ------------------ | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ return gcvalue(t1) == gcvalue(t2); ------------------ | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 611| 5.16M| } 612| 0| if (tm == NULL) /* no TM? */ ------------------ | Branch (612:7): [True: 0, False: 0] ------------------ 613| 0| return 0; /* objects are different */ 614| 0| else { 615| 0| luaT_callTMres(L, tm, t1, t2, L->top.p); /* call TM */ 616| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 617| 0| } 618| 0|} luaV_concat: 643| 103k|void luaV_concat (lua_State *L, int total) { 644| 103k| if (total == 1) ------------------ | Branch (644:7): [True: 0, False: 103k] ------------------ 645| 0| return; /* "all" values already concatenated */ 646| 103k| do { 647| 103k| StkId top = L->top.p; 648| 103k| int n = 2; /* number of elements handled in this pass (at least 2) */ 649| 103k| if (!(ttisstring(s2v(top - 2)) || cvt2str(s2v(top - 2))) || ------------------ | | 363| 103k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 206k|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 103k|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 103k|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 6.31k, False: 97.0k] | | | | ------------------ | | ------------------ ------------------ if (!(ttisstring(s2v(top - 2)) || cvt2str(s2v(top - 2))) || ------------------ | | 17| 103k|#define cvt2str(o) ttisnumber(o) | | ------------------ | | | | 326| 97.0k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 97.0k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 97.0k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 97.0k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 97.0k, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 650| 103k| !tostring(L, s2v(top - 1))) ------------------ | | 623| 103k| (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 363| 103k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | | | ------------------ | | | | | | 92| 206k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 103k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 103k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 86.9k, False: 16.4k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 17| 16.4k|#define cvt2str(o) ttisnumber(o) | | | | ------------------ | | | | | | 326| 16.4k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | | | ------------------ | | | | | | | | 92| 32.9k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 16.4k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 16.4k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (92:25): [True: 16.4k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (623:35): [True: 16.4k, False: 0] | | ------------------ ------------------ 651| 1| luaT_tryconcatTM(L); /* may invalidate 'top' */ 652| 103k| else if (isemptystr(s2v(top - 1))) /* second operand is empty? */ ------------------ | | 625| 267k|#define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 364| 103k|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | | | ------------------ | | | | | | 91| 206k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 103k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 89.0k, False: 14.3k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 369| 89.0k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | | | ------------------ | | | | | | 110| 356k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 89.0k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 89.0k] | | | | | | | Branch (110:42): [True: 89.0k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (625:44): [True: 72.5k, False: 16.5k] | | ------------------ ------------------ 653| 103k| cast_void(tostring(L, s2v(top - 2))); /* result is first operand */ ------------------ | | 138| 72.5k|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 290k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 72.4k, False: 0] | | | | | Branch (136:27): [True: 72.4k, False: 0] | | | | | Branch (136:27): [True: 40, False: 72.4k] | | | | ------------------ | | ------------------ ------------------ 654| 30.8k| else if (isemptystr(s2v(top - 2))) { /* first operand is empty string? */ ------------------ | | 625| 30.8k|#define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 364| 30.8k|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | | | ------------------ | | | | | | 91| 61.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 30.8k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 2.04k, False: 28.7k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 369| 2.04k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | | | ------------------ | | | | | | 110| 8.19k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 2.04k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 2.04k] | | | | | | | Branch (110:42): [True: 2.04k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (625:44): [True: 0, False: 2.04k] | | ------------------ ------------------ 655| 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) || \ | | | | | | ------------------ | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 656| 0| } 657| 30.8k| else { 658| | /* at least two non-empty string values; get as many as possible */ 659| 30.8k| size_t tl = tsslen(tsvalue(s2v(top - 1))); ------------------ | | 411| 246k| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 16.5k, False: 14.3k] | | | Branch (411:4): [True: 0, False: 30.8k] | | | Branch (411:4): [True: 30.8k, False: 0] | | | Branch (411:4): [True: 0, False: 30.8k] | | | Branch (411:4): [True: 30.8k, False: 0] | | | Branch (411:26): [True: 0, False: 16.5k] | | | Branch (411:26): [True: 16.5k, False: 0] | | | Branch (411:26): [True: 0, False: 16.5k] | | | Branch (411:26): [True: 16.5k, False: 0] | | | Branch (411:40): [True: 0, False: 14.3k] | | | Branch (411:40): [True: 14.3k, False: 0] | | | Branch (411:40): [True: 0, False: 14.3k] | | | Branch (411:40): [True: 14.3k, False: 0] | | ------------------ ------------------ 660| 0| TString *ts; 661| | /* collect total length and number of strings */ 662| 62.2k| for (n = 1; n < total && tostring(L, s2v(top - n - 1)); n++) { ------------------ | | 623| 31.4k| (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 363| 31.4k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | | | ------------------ | | | | | | 92| 62.8k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 31.4k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 31.4k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 6.86k, False: 24.5k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 17| 24.5k|#define cvt2str(o) ttisnumber(o) | | | | ------------------ | | | | | | 326| 24.5k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | | | ------------------ | | | | | | | | 92| 49.1k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 24.5k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 24.5k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (92:25): [True: 24.5k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (623:35): [True: 24.5k, False: 0] | | ------------------ ------------------ | Branch (662:19): [True: 31.4k, False: 30.8k] ------------------ 663| 31.4k| size_t l = tsslen(tsvalue(s2v(top - n - 1))); ------------------ | | 411| 251k| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 26.6k, False: 4.81k] | | | Branch (411:4): [True: 0, False: 31.4k] | | | Branch (411:4): [True: 31.4k, False: 0] | | | Branch (411:4): [True: 0, False: 31.4k] | | | Branch (411:4): [True: 31.4k, False: 0] | | | Branch (411:26): [True: 0, False: 26.6k] | | | Branch (411:26): [True: 26.6k, False: 0] | | | Branch (411:26): [True: 0, False: 26.6k] | | | Branch (411:26): [True: 26.6k, False: 0] | | | Branch (411:40): [True: 0, False: 4.81k] | | | Branch (411:40): [True: 4.81k, False: 0] | | | Branch (411:40): [True: 0, False: 4.81k] | | | Branch (411:40): [True: 4.81k, False: 0] | | ------------------ ------------------ 664| 31.4k| if (l_unlikely(l >= (MAX_SIZE/sizeof(char)) - tl)) { ------------------ | | 697| 31.4k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 62.8k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 31.4k] | | | | | Branch (685:46): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 665| 0| L->top.p = top - total; /* pop strings to avoid wasting stack */ 666| 0| luaG_runerror(L, "string length overflow"); 667| 0| } 668| 31.4k| tl += l; 669| 31.4k| } 670| 30.8k| if (tl <= LUAI_MAXSHORTLEN) { /* is result a short string? */ ------------------ | | 216| 30.8k|#define LUAI_MAXSHORTLEN 40 ------------------ | Branch (670:11): [True: 16.3k, False: 14.4k] ------------------ 671| 16.3k| char buff[LUAI_MAXSHORTLEN]; 672| 16.3k| copy2buff(top, n, buff); /* copy strings to buffer */ 673| 16.3k| ts = luaS_newlstr(L, buff, tl); 674| 16.3k| } 675| 14.4k| else { /* long string; copy strings directly to final result */ 676| 14.4k| ts = luaS_createlngstrobj(L, tl); 677| 14.4k| copy2buff(top, n, getlngstr(ts)); ------------------ | | 405| 14.4k|#define getlngstr(ts) check_exp((ts)->shrlen == 0xFF, (ts)->contents) | | ------------------ | | | | 110| 14.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 14.4k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 678| 14.4k| } 679| 61.6k| setsvalue2s(L, top - n, ts); /* create result */ ------------------ | | 377| 30.8k|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 30.8k| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 30.8k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 30.8k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 30.8k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 30.8k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 30.8k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 30.8k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 30.8k| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 30.8k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 493k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 30.8k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 30.8k] | | | | | | | | | Branch (112:29): [True: 30.8k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 30.8k] | | | | | | | | | Branch (112:29): [True: 30.8k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 30.8k] | | | | | | | | | Branch (112:29): [True: 30.8k, False: 0] | | | | | | | | | Branch (112:29): [True: 30.8k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 30.8k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 30.8k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 680| 61.6k| } 681| 103k| total -= n - 1; /* got 'n' strings to create one new */ 682| 103k| L->top.p -= n - 1; /* popped 'n' strings and pushed one */ 683| 103k| } while (total > 1); /* repeat until only 1 result left */ ------------------ | Branch (683:12): [True: 0, False: 103k] ------------------ 684| 103k|} luaV_objlen: 690| 138k|void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) { 691| 138k| const TValue *tm; 692| 138k| switch (ttypetag(rb)) { ------------------ | | 84| 138k|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 138k|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 693| 138k| case LUA_VTABLE: { ------------------ | | 678| 138k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 138k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (693:5): [True: 138k, False: 0] ------------------ 694| 276k| Table *h = hvalue(rb); ------------------ | | 682| 138k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 110| 553k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 138k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 138k] | | | | | Branch (110:42): [True: 138k, False: 0] | | | | ------------------ | | ------------------ ------------------ 695| 138k| tm = fasttm(L, h->metatable, TM_LEN); ------------------ | | 67| 138k|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 64| 138k|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (64:26): [True: 138k, False: 0] | | | | ------------------ | | | | 65| 138k| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 696| 276k| if (tm) break; /* metamethod? break switch to call it */ ------------------ | Branch (696:11): [True: 0, False: 138k] ------------------ 697| 138k| setivalue(s2v(ra), luaH_getn(h)); /* else primitive len */ ------------------ | | 345| 138k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 138k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 138k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 698| 138k| return; 699| 276k| } 700| 0| case LUA_VSHRSTR: { ------------------ | | 360| 0|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (700:5): [True: 0, False: 138k] ------------------ 701| 0| setivalue(s2v(ra), tsvalue(rb)->shrlen); ------------------ | | 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)) | | ------------------ | | | Branch (345:35): [True: 0, False: 0] | | | Branch (345:35): [True: 0, False: 0] | | | Branch (345:35): [True: 0, False: 0] | | | Branch (345:35): [True: 0, False: 0] | | ------------------ ------------------ 702| 0| return; 703| 0| } 704| 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 (704:5): [True: 0, False: 138k] ------------------ 705| 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)) | | ------------------ | | | Branch (345:35): [True: 0, False: 0] | | | Branch (345:35): [True: 0, False: 0] | | | Branch (345:35): [True: 0, False: 0] | | | Branch (345:35): [True: 0, False: 0] | | ------------------ ------------------ 706| 0| return; 707| 0| } 708| 0| default: { /* try metamethod */ ------------------ | Branch (708:5): [True: 0, False: 138k] ------------------ 709| 0| tm = luaT_gettmbyobj(L, rb, TM_LEN); 710| 0| if (l_unlikely(notm(tm))) /* no metamethod? */ ------------------ | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 711| 0| luaG_typeerror(L, rb, "get length of"); 712| 0| break; 713| 0| } 714| 138k| } 715| 0| luaT_callTMres(L, tm, rb, rb, ra); 716| 0|} luaV_idiv: 725| 626k|lua_Integer luaV_idiv (lua_State *L, lua_Integer m, lua_Integer n) { 726| 626k| if (l_unlikely(l_castS2U(n) + 1u <= 1u)) { /* special cases: -1 or 0 */ ------------------ | | 697| 626k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 626k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 1, False: 626k] | | | | ------------------ | | ------------------ ------------------ 727| 1| if (n == 0) ------------------ | Branch (727:9): [True: 0, False: 1] ------------------ 728| 0| luaG_runerror(L, "attempt to divide by zero"); 729| 1| return intop(-, 0, m); /* n==-1; avoid overflow with 0x80000...//-1 */ ------------------ | | 73| 1|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 1|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 730| 1| } 731| 626k| else { 732| 626k| lua_Integer q = m / n; /* perform C division */ 733| 626k| if ((m ^ n) < 0 && m % n != 0) /* 'm/n' would be negative non-integer? */ ------------------ | Branch (733:9): [True: 54.5k, False: 571k] | Branch (733:24): [True: 8, False: 54.5k] ------------------ 734| 8| q -= 1; /* correct result for different rounding */ 735| 626k| return q; 736| 626k| } 737| 626k|} luaV_mod: 745| 631k|lua_Integer luaV_mod (lua_State *L, lua_Integer m, lua_Integer n) { 746| 631k| if (l_unlikely(l_castS2U(n) + 1u <= 1u)) { /* special cases: -1 or 0 */ ------------------ | | 697| 631k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 631k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 193, False: 631k] | | | | ------------------ | | ------------------ ------------------ 747| 193| if (n == 0) ------------------ | Branch (747:9): [True: 1, False: 192] ------------------ 748| 1| luaG_runerror(L, "attempt to perform 'n%%0'"); 749| 192| return 0; /* m % -1 == 0; avoid overflow with 0x80000...%-1 */ 750| 193| } 751| 631k| else { 752| 631k| lua_Integer r = m % n; 753| 631k| if (r != 0 && (r ^ n) < 0) /* 'm/n' would be non-integer negative? */ ------------------ | Branch (753:9): [True: 6.39k, False: 625k] | Branch (753:19): [True: 774, False: 5.62k] ------------------ 754| 774| r += n; /* correct result for different rounding */ 755| 631k| return r; 756| 631k| } 757| 631k|} luaV_modf: 763| 14.2k|lua_Number luaV_modf (lua_State *L, lua_Number m, lua_Number n) { 764| 14.2k| lua_Number r; 765| 14.2k| luai_nummod(L, m, n, r); ------------------ | | 334| 14.2k| { (void)L; (m) = l_mathop(fmod)(a,b); \ | | ------------------ | | | | 482| 14.2k|#define l_mathop(op) op | | ------------------ | | 335| 14.2k| if (((m) > 0) ? (b) < 0 : ((m) < 0 && (b) > 0)) (m) += (b); } | | ------------------ | | | Branch (335:9): [True: 13.3k, False: 878] | | | Branch (335:9): [True: 1.88k, False: 12.3k] | | | Branch (335:32): [True: 556, False: 322] | | | Branch (335:43): [True: 554, False: 2] | | ------------------ ------------------ 766| 14.2k| return r; 767| 14.2k|} luaV_shiftl: 777| 205k|lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) { 778| 205k| if (y < 0) { /* shift right? */ ------------------ | Branch (778:7): [True: 120k, False: 85.0k] ------------------ 779| 120k| if (y <= -NBITS) return 0; ------------------ | | 771| 120k|#define NBITS cast_int(sizeof(lua_Integer) * CHAR_BIT) | | ------------------ | | | | 141| 120k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 120k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (779:9): [True: 73.5k, False: 46.8k] ------------------ 780| 46.8k| else return intop(>>, x, -y); ------------------ | | 73| 46.8k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 46.8k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 781| 120k| } 782| 85.0k| else { /* shift left */ 783| 85.0k| if (y >= NBITS) return 0; ------------------ | | 771| 85.0k|#define NBITS cast_int(sizeof(lua_Integer) * CHAR_BIT) | | ------------------ | | | | 141| 85.0k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 85.0k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (783:9): [True: 43.0k, False: 41.9k] ------------------ 784| 41.9k| else return intop(<<, x, y); ------------------ | | 73| 41.9k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 41.9k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 785| 85.0k| } 786| 205k|} luaV_execute: 1151| 45|void luaV_execute (lua_State *L, CallInfo *ci) { 1152| 45| LClosure *cl; 1153| 45| TValue *k; 1154| 45| StkId base; 1155| 45| const Instruction *pc; 1156| 45| int trap; 1157| 45|#if LUA_USE_JUMPTABLE 1158| 45|#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| 45|#undef vmdispatch | | 9| 45|#undef vmcase | | 10| 45|#undef vmbreak | | 11| | | | 12| 45|#define vmdispatch(x) goto *disptab[x]; | | 13| | | | 14| 45|#define vmcase(l) L_##l: | | 15| | | | 16| 45|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | 17| | | | 18| | | | 19| 45|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| 45|&&L_OP_MOVE, | | 29| 45|&&L_OP_LOADI, | | 30| 45|&&L_OP_LOADF, | | 31| 45|&&L_OP_LOADK, | | 32| 45|&&L_OP_LOADKX, | | 33| 45|&&L_OP_LOADFALSE, | | 34| 45|&&L_OP_LFALSESKIP, | | 35| 45|&&L_OP_LOADTRUE, | | 36| 45|&&L_OP_LOADNIL, | | 37| 45|&&L_OP_GETUPVAL, | | 38| 45|&&L_OP_SETUPVAL, | | 39| 45|&&L_OP_GETTABUP, | | 40| 45|&&L_OP_GETTABLE, | | 41| 45|&&L_OP_GETI, | | 42| 45|&&L_OP_GETFIELD, | | 43| 45|&&L_OP_SETTABUP, | | 44| 45|&&L_OP_SETTABLE, | | 45| 45|&&L_OP_SETI, | | 46| 45|&&L_OP_SETFIELD, | | 47| 45|&&L_OP_NEWTABLE, | | 48| 45|&&L_OP_SELF, | | 49| 45|&&L_OP_ADDI, | | 50| 45|&&L_OP_ADDK, | | 51| 45|&&L_OP_SUBK, | | 52| 45|&&L_OP_MULK, | | 53| 45|&&L_OP_MODK, | | 54| 45|&&L_OP_POWK, | | 55| 45|&&L_OP_DIVK, | | 56| 45|&&L_OP_IDIVK, | | 57| 45|&&L_OP_BANDK, | | 58| 45|&&L_OP_BORK, | | 59| 45|&&L_OP_BXORK, | | 60| 45|&&L_OP_SHRI, | | 61| 45|&&L_OP_SHLI, | | 62| 45|&&L_OP_ADD, | | 63| 45|&&L_OP_SUB, | | 64| 45|&&L_OP_MUL, | | 65| 45|&&L_OP_MOD, | | 66| 45|&&L_OP_POW, | | 67| 45|&&L_OP_DIV, | | 68| 45|&&L_OP_IDIV, | | 69| 45|&&L_OP_BAND, | | 70| 45|&&L_OP_BOR, | | 71| 45|&&L_OP_BXOR, | | 72| 45|&&L_OP_SHL, | | 73| 45|&&L_OP_SHR, | | 74| 45|&&L_OP_MMBIN, | | 75| 45|&&L_OP_MMBINI, | | 76| 45|&&L_OP_MMBINK, | | 77| 45|&&L_OP_UNM, | | 78| 45|&&L_OP_BNOT, | | 79| 45|&&L_OP_NOT, | | 80| 45|&&L_OP_LEN, | | 81| 45|&&L_OP_CONCAT, | | 82| 45|&&L_OP_CLOSE, | | 83| 45|&&L_OP_TBC, | | 84| 45|&&L_OP_JMP, | | 85| 45|&&L_OP_EQ, | | 86| 45|&&L_OP_LT, | | 87| 45|&&L_OP_LE, | | 88| 45|&&L_OP_EQK, | | 89| 45|&&L_OP_EQI, | | 90| 45|&&L_OP_LTI, | | 91| 45|&&L_OP_LEI, | | 92| 45|&&L_OP_GTI, | | 93| 45|&&L_OP_GEI, | | 94| 45|&&L_OP_TEST, | | 95| 45|&&L_OP_TESTSET, | | 96| 45|&&L_OP_CALL, | | 97| 45|&&L_OP_TAILCALL, | | 98| 45|&&L_OP_RETURN, | | 99| 45|&&L_OP_RETURN0, | | 100| 45|&&L_OP_RETURN1, | | 101| 45|&&L_OP_FORLOOP, | | 102| 45|&&L_OP_FORPREP, | | 103| 45|&&L_OP_TFORPREP, | | 104| 45|&&L_OP_TFORCALL, | | 105| 45|&&L_OP_TFORLOOP, | | 106| 45|&&L_OP_SETLIST, | | 107| 45|&&L_OP_CLOSURE, | | 108| 45|&&L_OP_VARARG, | | 109| 45|&&L_OP_VARARGPREP, | | 110| 45|&&L_OP_EXTRAARG | | 111| | | | 112| 45|}; ------------------ 1159| 45|#endif 1160| 1.07M| startfunc: 1161| 1.07M| trap = L->hookmask; 1162| 2.08M| returning: /* trap already set */ 1163| 4.16M| cl = ci_func(ci); ------------------ | | 18| 2.08M|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 2.08M|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 110| 8.33M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 2.08M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 2.08M] | | | | | | | Branch (110:42): [True: 2.08M, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1164| 0| k = cl->p->k; 1165| 4.16M| pc = ci->u.l.savedpc; 1166| 4.16M| if (l_unlikely(trap)) ------------------ | | 697| 2.08M|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 2.08M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 9, False: 2.08M] | | | | ------------------ | | ------------------ ------------------ 1167| 9| trap = luaG_tracecall(L); 1168| 4.16M| base = ci->func.p + 1; 1169| | /* main loop of interpreter */ 1170| 4.16M| for (;;) { 1171| 2.08M| Instruction i; /* instruction being executed */ 1172| 2.08M| vmfetch(); ------------------ | | 1138| 2.08M|#define vmfetch() { \ | | 1139| 2.08M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | ------------------ | | | | 697| 2.08M|#define l_unlikely(x) luai_unlikely(x) | | | | ------------------ | | | | | | 685| 2.08M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | ------------------ | | | | | | | Branch (685:26): [True: 9, False: 2.08M] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1140| 9| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | 1141| 9| updatebase(ci); /* correct stack */ \ | | ------------------ | | | | 1077| 9|#define updatebase(ci) (base = ci->func.p + 1) | | ------------------ | | 1142| 9| } \ | | 1143| 2.08M| i = *(pc++); \ | | 1144| 2.08M|} ------------------ 1173| | #if 0 1174| | /* low-level line tracing for debugging Lua */ 1175| | printf("line: %d\n", luaG_getfuncline(cl->p, pcRel(pc, cl->p))); 1176| | #endif 1177| 2.08M| lua_assert(base == ci->func.p + 1); ------------------ | | 106| 2.08M|#define lua_assert(c) assert(c) ------------------ 1178| 2.08M| lua_assert(base <= L->top.p && L->top.p <= L->stack_last.p); ------------------ | | 106| 2.08M|#define lua_assert(c) assert(c) ------------------ 1179| | /* invalidate top for instructions not expecting it */ 1180| 2.08M| lua_assert(isIT(i) || (cast_void(L->top.p = base), 1)); ------------------ | | 106| 2.08M|#define lua_assert(c) assert(c) ------------------ 1181| 2.08M| vmdispatch (GET_OPCODE(i)) { ------------------ | | 12| 2.08M|#define vmdispatch(x) goto *disptab[x]; ------------------ 1182| 3.92M| vmcase(OP_MOVE) { ------------------ | | 14| 3.92M|#define vmcase(l) L_##l: ------------------ 1183| 3.92M| StkId ra = RA(i); ------------------ | | 1064| 3.92M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 3.92M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 3.92M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 3.92M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 3.92M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1184| 3.92M| setobjs2s(L, ra, RB(i)); ------------------ | | 129| 3.92M|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 15.6M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | ------------------ | | | | | Branch (119:43): [True: 0, False: 3.92M] | | | | | Branch (119:43): [True: 3.92M, False: 0] | | | | ------------------ | | | | 120| 3.92M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 3.92M|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 3.92M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 3.92M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 32.6M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 3.92M|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 1.91M] | | | | | | | | | Branch (112:29): [True: 1.91M, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 1.91M] | | | | | | | | | Branch (112:29): [True: 1.91M, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 1.91M] | | | | | | | | | Branch (112:29): [True: 1.91M, False: 0] | | | | | | | | | Branch (112:29): [True: 1.91M, False: 0] | | | | | | | | | Branch (112:29): [True: 2.01M, False: 1.91M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 3.92M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 3.92M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1185| 3.92M| vmbreak; ------------------ | | 16| 3.92M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 3.92M|#define vmfetch() { \ | | | | 1139| 3.92M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 3.92M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 3.92M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 3.92M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 3.92M| i = *(pc++); \ | | | | 1144| 3.92M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 3.92M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1186| 3.92M| } 1187| 336k| vmcase(OP_LOADI) { ------------------ | | 14| 336k|#define vmcase(l) L_##l: ------------------ 1188| 336k| StkId ra = RA(i); ------------------ | | 1064| 336k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 336k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 336k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 336k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 336k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1189| 336k| lua_Integer b = GETARG_sBx(i); ------------------ | | 147| 336k| check_exp(checkopm(i, iAsBx), getarg(i, POS_Bx, SIZE_Bx) - OFFSET_sBx) | | ------------------ | | | | 110| 336k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 336k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1190| 336k| setivalue(s2v(ra), b); ------------------ | | 345| 336k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 336k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 336k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1191| 336k| vmbreak; ------------------ | | 16| 336k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 336k|#define vmfetch() { \ | | | | 1139| 336k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 336k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 336k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 336k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 336k| i = *(pc++); \ | | | | 1144| 336k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 336k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1192| 336k| } 1193| 65.6k| vmcase(OP_LOADF) { ------------------ | | 14| 65.6k|#define vmcase(l) L_##l: ------------------ 1194| 65.6k| StkId ra = RA(i); ------------------ | | 1064| 65.6k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 65.6k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 65.6k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 65.6k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 65.6k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1195| 65.6k| int b = GETARG_sBx(i); ------------------ | | 147| 65.6k| check_exp(checkopm(i, iAsBx), getarg(i, POS_Bx, SIZE_Bx) - OFFSET_sBx) | | ------------------ | | | | 110| 65.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 65.6k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1196| 65.6k| setfltvalue(s2v(ra), cast_num(b)); ------------------ | | 339| 65.6k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 65.6k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 65.6k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1197| 65.6k| vmbreak; ------------------ | | 16| 65.6k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 65.6k|#define vmfetch() { \ | | | | 1139| 65.6k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 65.6k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 65.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 65.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 65.6k| i = *(pc++); \ | | | | 1144| 65.6k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 65.6k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1198| 65.6k| } 1199| 1.39M| vmcase(OP_LOADK) { ------------------ | | 14| 1.39M|#define vmcase(l) L_##l: ------------------ 1200| 1.39M| StkId ra = RA(i); ------------------ | | 1064| 1.39M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1.39M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1.39M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 1.39M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1.39M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1201| 1.39M| TValue *rb = k + GETARG_Bx(i); ------------------ | | 140| 1.39M|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 110| 1.39M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 1.39M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1202| 1.39M| setobj2s(L, ra, rb); ------------------ | | 131| 1.39M|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 1.39M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 1.39M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 1.39M|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 1.39M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 1.39M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 19.3M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 1.39M|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 1.19M] | | | | | | | | | Branch (112:29): [True: 1.19M, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 1.19M] | | | | | | | | | Branch (112:29): [True: 1.19M, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 1.19M] | | | | | | | | | Branch (112:29): [True: 1.19M, False: 0] | | | | | | | | | Branch (112:29): [True: 1.19M, False: 0] | | | | | | | | | Branch (112:29): [True: 198k, False: 1.19M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 1.39M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 1.39M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1203| 1.39M| vmbreak; ------------------ | | 16| 1.39M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 1.39M|#define vmfetch() { \ | | | | 1139| 1.39M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.39M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.39M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1.39M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 1.39M| i = *(pc++); \ | | | | 1144| 1.39M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.39M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1204| 1.39M| } 1205| 0| vmcase(OP_LOADKX) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1206| 0| StkId ra = RA(i); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1207| 0| TValue *rb; 1208| 0| rb = k + GETARG_Ax(*pc); pc++; ------------------ | | 143| 0|#define GETARG_Ax(i) check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1209| 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) || \ | | | | | | ------------------ | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1210| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1211| 0| } 1212| 0| vmcase(OP_LOADFALSE) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1213| 0| StkId ra = RA(i); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1214| 0| setbfvalue(s2v(ra)); ------------------ | | 250| 0|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1215| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1216| 0| } 1217| 287k| vmcase(OP_LFALSESKIP) { ------------------ | | 14| 287k|#define vmcase(l) L_##l: ------------------ 1218| 287k| StkId ra = RA(i); ------------------ | | 1064| 287k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 287k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 287k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 287k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 287k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1219| 287k| setbfvalue(s2v(ra)); ------------------ | | 250| 287k|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 287k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1220| 287k| pc++; /* skip next instruction */ 1221| 287k| vmbreak; ------------------ | | 16| 287k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 287k|#define vmfetch() { \ | | | | 1139| 287k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 287k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 287k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 287k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 287k| i = *(pc++); \ | | | | 1144| 287k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 287k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1222| 287k| } 1223| 287k| vmcase(OP_LOADTRUE) { ------------------ | | 14| 148k|#define vmcase(l) L_##l: ------------------ 1224| 148k| StkId ra = RA(i); ------------------ | | 1064| 148k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 148k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 148k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 148k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 148k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1225| 148k| setbtvalue(s2v(ra)); ------------------ | | 251| 148k|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 148k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1226| 148k| vmbreak; ------------------ | | 16| 148k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 148k|#define vmfetch() { \ | | | | 1139| 148k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 148k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 148k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 148k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 148k| i = *(pc++); \ | | | | 1144| 148k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 148k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1227| 148k| } 1228| 148k| vmcase(OP_LOADNIL) { ------------------ | | 14| 123k|#define vmcase(l) L_##l: ------------------ 1229| 123k| StkId ra = RA(i); ------------------ | | 1064| 123k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 123k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 123k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 123k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 123k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1230| 123k| int b = GETARG_B(i); ------------------ | | 128| 123k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 123k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 123k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1231| 242k| do { 1232| 242k| setnilvalue(s2v(ra++)); ------------------ | | 200| 242k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 242k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1233| 242k| } while (b--); ------------------ | Branch (1233:18): [True: 119k, False: 123k] ------------------ 1234| 123k| vmbreak; ------------------ | | 16| 123k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 123k|#define vmfetch() { \ | | | | 1139| 123k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 123k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 123k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 123k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 123k| i = *(pc++); \ | | | | 1144| 123k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 123k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1235| 123k| } 1236| 1.30M| vmcase(OP_GETUPVAL) { ------------------ | | 14| 1.30M|#define vmcase(l) L_##l: ------------------ 1237| 1.30M| StkId ra = RA(i); ------------------ | | 1064| 1.30M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1.30M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1.30M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 1.30M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1.30M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1238| 1.30M| int b = GETARG_B(i); ------------------ | | 128| 1.30M|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 1.30M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 1.30M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1239| 1.30M| setobj2s(L, ra, cl->upvals[b]->v.p); ------------------ | | 131| 1.30M|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 1.30M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 1.30M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 1.30M|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 1.30M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 1.30M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 19.6M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 1.30M|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 1.22M] | | | | | | | | | Branch (112:29): [True: 1.22M, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 1.22M] | | | | | | | | | Branch (112:29): [True: 1.22M, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 1.22M] | | | | | | | | | Branch (112:29): [True: 1.22M, False: 0] | | | | | | | | | Branch (112:29): [True: 1.22M, False: 0] | | | | | | | | | Branch (112:29): [True: 82.6k, False: 1.22M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 1.30M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 1.30M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1240| 1.30M| vmbreak; ------------------ | | 16| 1.30M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 1.30M|#define vmfetch() { \ | | | | 1139| 1.30M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.30M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.30M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1.30M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 1.30M| i = *(pc++); \ | | | | 1144| 1.30M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.30M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1241| 1.30M| } 1242| 155k| vmcase(OP_SETUPVAL) { ------------------ | | 14| 155k|#define vmcase(l) L_##l: ------------------ 1243| 155k| StkId ra = RA(i); ------------------ | | 1064| 155k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 155k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 155k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 155k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 155k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1244| 155k| UpVal *uv = cl->upvals[GETARG_B(i)]; ------------------ | | 128| 155k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 155k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 155k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1245| 155k| setobj(L, uv->v.p, s2v(ra)); ------------------ | | 119| 155k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 155k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 155k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 155k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 155k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 112| 1.24M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 106| 155k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (112:29): [True: 0, False: 72.4k] | | | | | | | Branch (112:29): [True: 72.4k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 72.4k] | | | | | | | Branch (112:29): [True: 72.4k, False: 0] | | | | | | | Branch (112:29): [True: 0, False: 72.4k] | | | | | | | Branch (112:29): [True: 72.4k, False: 0] | | | | | | | Branch (112:29): [True: 72.4k, False: 0] | | | | | | | Branch (112:29): [True: 82.6k, False: 72.4k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 155k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 106| 155k|#define lua_assert(c) assert(c) | | ------------------ ------------------ 1246| 155k| luaC_barrier(L, uv, s2v(ra)); ------------------ | | 179| 155k|#define luaC_barrier(L,p,v) ( \ | | 180| 155k| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 155k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 155k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 155k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 72.4k, False: 82.6k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 72.4k|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 72.4k| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 72.4k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 72.4k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 144k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 72.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] | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 177| 72.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)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 72.4k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 72.4k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 82.6k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 82.6k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1247| 155k| vmbreak; ------------------ | | 16| 155k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 155k|#define vmfetch() { \ | | | | 1139| 155k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 155k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 155k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 155k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 155k| i = *(pc++); \ | | | | 1144| 155k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 155k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1248| 155k| } 1249| 4.57M| vmcase(OP_GETTABUP) { ------------------ | | 14| 4.57M|#define vmcase(l) L_##l: ------------------ 1250| 4.57M| StkId ra = RA(i); ------------------ | | 1064| 4.57M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 4.57M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 4.57M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 4.57M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 4.57M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1251| 4.57M| const TValue *slot; 1252| 4.57M| TValue *upval = cl->upvals[GETARG_B(i)]->v.p; ------------------ | | 128| 4.57M|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 4.57M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 4.57M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1253| 4.57M| TValue *rc = KC(i); ------------------ | | 1070| 4.57M|#define KC(i) (k+GETARG_C(i)) | | ------------------ | | | | 132| 4.57M|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 110| 4.57M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 4.57M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1254| 9.14M| TString *key = tsvalue(rc); /* key must be a short string */ ------------------ | | 369| 4.57M|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 18.2M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 4.57M|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 4.57M] | | | | | Branch (110:42): [True: 4.57M, False: 0] | | | | ------------------ | | ------------------ ------------------ 1255| 4.57M| if (luaV_fastget(L, upval, key, slot, luaH_getshortstr)) { ------------------ | | 86| 4.57M| (!ttistable(t) \ | | ------------------ | | | | 680| 4.57M|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 4.57M|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 4.57M|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 95.7k, False: 4.47M] | | | Branch (86:4): [True: 0, False: 4.57M] | | ------------------ | | 87| 4.57M| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 9.14M| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 4.57M|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 18.2M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 4.57M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 4.57M] | | | | | | | Branch (110:42): [True: 4.57M, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 89| 9.14M| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 4.57M|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 4.57M|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 4.57M|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 4.57M|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 4.57M|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1256| 95.7k| setobj2s(L, ra, slot); ------------------ | | 131| 95.7k|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 95.7k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 95.7k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 95.7k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 95.7k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 95.7k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 443k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 95.7k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 23.1k] | | | | | | | | | Branch (112:29): [True: 23.1k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 23.1k] | | | | | | | | | Branch (112:29): [True: 23.1k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 23.1k] | | | | | | | | | Branch (112:29): [True: 23.1k, False: 0] | | | | | | | | | Branch (112:29): [True: 23.1k, False: 0] | | | | | | | | | Branch (112:29): [True: 72.5k, False: 23.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 95.7k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 95.7k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1257| 95.7k| } 1258| 4.47M| else 1259| 4.47M| Protect(luaV_finishget(L, upval, rc, ra, slot)); ------------------ | | 1119| 4.47M|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 4.47M|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 4.47M|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 4.47M|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1260| 4.57M| vmbreak; ------------------ | | 16| 4.57M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 4.57M|#define vmfetch() { \ | | | | 1139| 4.57M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 4.57M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 4.57M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 44, False: 4.57M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 44| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 44| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 44|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 44| } \ | | | | 1143| 4.57M| i = *(pc++); \ | | | | 1144| 4.57M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 4.57M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1261| 4.57M| } 1262| 125k| vmcase(OP_GETTABLE) { ------------------ | | 14| 125k|#define vmcase(l) L_##l: ------------------ 1263| 125k| StkId ra = RA(i); ------------------ | | 1064| 125k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 125k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 125k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 125k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 125k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1264| 125k| const TValue *slot; 1265| 125k| TValue *rb = vRB(i); ------------------ | | 1066| 125k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 500k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 125k] | | | | | Branch (172:19): [True: 125k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1266| 125k| TValue *rc = vRC(i); ------------------ | | 1069| 125k|#define vRC(i) s2v(RC(i)) | | ------------------ | | | | 172| 500k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 125k] | | | | | Branch (172:19): [True: 125k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1267| 0| lua_Unsigned n; 1268| | if (ttisinteger(rc) /* fast track for integers? */ ------------------ | | 328| 125k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 250k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 125k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 105k, False: 19.8k] | | | | ------------------ | | ------------------ ------------------ | Branch (1268:13): [True: 61.2k, False: 63.8k] ------------------ 1269| 125k| ? (cast_void(n = ivalue(rc)), luaV_fastgeti(L, rb, n, slot)) ------------------ | | 138| 105k|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 421k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 0, False: 105k] | | | | | Branch (136:27): [True: 105k, False: 0] | | | | ------------------ | | ------------------ ------------------ ? (cast_void(n = ivalue(rc)), luaV_fastgeti(L, rb, n, slot)) ------------------ | | 97| 105k| (!ttistable(t) \ | | ------------------ | | | | 680| 105k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 105k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 105k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (97:4): [True: 0, False: 105k] | | ------------------ | | 98| 105k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 99| 210k| : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 152| 105k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 682| 105k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 421k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 105k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 105k] | | | | | | | Branch (110:42): [True: 105k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (99:14): [True: 43.5k, False: 61.7k] | | ------------------ | | 100| 123k| ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 43.5k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 174k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 43.5k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 43.5k] | | | | | | | Branch (110:42): [True: 43.5k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 61.7k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 246k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 61.7k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 61.7k] | | | | | | | Branch (110:42): [True: 61.7k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 101| 105k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 105k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 105k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 105k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 105k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 105k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1270| 125k| : luaV_fastget(L, rb, rc, slot, luaH_get)) { ------------------ | | 86| 19.8k| (!ttistable(t) \ | | ------------------ | | | | 680| 19.8k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 19.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 19.8k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:4): [True: 0, False: 19.8k] | | ------------------ | | 87| 19.8k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 39.6k| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 19.8k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 79.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 19.8k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 19.8k] | | | | | | | Branch (110:42): [True: 19.8k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 89| 39.6k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 19.8k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 19.8k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 19.8k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 19.8k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 19.8k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1271| 61.2k| setobj2s(L, ra, slot); ------------------ | | 131| 61.2k|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 61.2k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 61.2k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 61.2k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 61.2k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 61.2k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 415k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 61.2k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 23.6k] | | | | | | | | | Branch (112:29): [True: 23.6k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 23.6k] | | | | | | | | | Branch (112:29): [True: 23.6k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 23.6k] | | | | | | | | | Branch (112:29): [True: 23.6k, False: 0] | | | | | | | | | Branch (112:29): [True: 23.6k, False: 0] | | | | | | | | | Branch (112:29): [True: 37.6k, False: 23.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 61.2k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 61.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1272| 61.2k| } 1273| 63.8k| else 1274| 63.8k| Protect(luaV_finishget(L, rb, rc, ra, slot)); ------------------ | | 1119| 63.8k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 63.8k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 63.8k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 63.8k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1275| 125k| vmbreak; ------------------ | | 16| 125k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 125k|#define vmfetch() { \ | | | | 1139| 125k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 125k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 125k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 125k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 125k| i = *(pc++); \ | | | | 1144| 125k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 125k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1276| 125k| } 1277| 13.6k| vmcase(OP_GETI) { ------------------ | | 14| 13.6k|#define vmcase(l) L_##l: ------------------ 1278| 13.6k| StkId ra = RA(i); ------------------ | | 1064| 13.6k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 13.6k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 13.6k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 13.6k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 13.6k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1279| 13.6k| const TValue *slot; 1280| 13.6k| TValue *rb = vRB(i); ------------------ | | 1066| 13.6k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 54.4k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 13.6k] | | | | | Branch (172:19): [True: 13.6k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1281| 13.6k| int c = GETARG_C(i); ------------------ | | 132| 13.6k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 110| 13.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 13.6k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1282| 13.6k| if (luaV_fastgeti(L, rb, c, slot)) { ------------------ | | 97| 13.6k| (!ttistable(t) \ | | ------------------ | | | | 680| 13.6k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 13.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 13.6k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (97:3): [True: 13.3k, False: 274] | | | Branch (97:4): [True: 0, False: 13.6k] | | ------------------ | | 98| 13.6k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 99| 27.2k| : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 152| 13.6k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 682| 13.6k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 54.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 13.6k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 13.6k] | | | | | | | Branch (110:42): [True: 13.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (99:14): [True: 13.3k, False: 295] | | ------------------ | | 100| 26.6k| ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 13.3k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 53.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 13.3k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 13.3k] | | | | | | | Branch (110:42): [True: 13.3k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 295|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 1.18k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 295|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 295] | | | | | | | Branch (110:42): [True: 295, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 101| 13.6k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 13.6k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 13.6k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 13.6k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 13.6k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 13.6k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1283| 13.3k| setobj2s(L, ra, slot); ------------------ | | 131| 13.3k|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 13.3k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 13.3k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 13.3k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 13.3k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 13.3k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 13.5k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 13.3k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 17] | | | | | | | | | Branch (112:29): [True: 17, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 17] | | | | | | | | | Branch (112:29): [True: 17, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 17] | | | | | | | | | Branch (112:29): [True: 17, False: 0] | | | | | | | | | Branch (112:29): [True: 17, False: 0] | | | | | | | | | Branch (112:29): [True: 13.3k, False: 17] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 13.3k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 13.3k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1284| 13.3k| } 1285| 274| else { 1286| 274| TValue key; 1287| 274| setivalue(&key, c); ------------------ | | 345| 274| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 274|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 274|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1288| 274| Protect(luaV_finishget(L, rb, &key, ra, slot)); ------------------ | | 1119| 274|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 274|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 274|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 274|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1289| 274| } 1290| 13.6k| vmbreak; ------------------ | | 16| 13.6k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 13.6k|#define vmfetch() { \ | | | | 1139| 13.6k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 13.6k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 13.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 13.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 13.6k| i = *(pc++); \ | | | | 1144| 13.6k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 13.6k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1291| 13.6k| } 1292| 26.9k| vmcase(OP_GETFIELD) { ------------------ | | 14| 26.9k|#define vmcase(l) L_##l: ------------------ 1293| 26.9k| StkId ra = RA(i); ------------------ | | 1064| 26.9k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 26.9k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 26.9k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 26.9k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 26.9k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1294| 26.9k| const TValue *slot; 1295| 26.9k| TValue *rb = vRB(i); ------------------ | | 1066| 26.9k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 107k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 26.9k] | | | | | Branch (172:19): [True: 26.9k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1296| 26.9k| TValue *rc = KC(i); ------------------ | | 1070| 26.9k|#define KC(i) (k+GETARG_C(i)) | | ------------------ | | | | 132| 26.9k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 110| 26.9k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 26.9k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1297| 53.8k| TString *key = tsvalue(rc); /* key must be a short string */ ------------------ | | 369| 26.9k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 107k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 26.9k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 26.9k] | | | | | Branch (110:42): [True: 26.9k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1298| 26.9k| if (luaV_fastget(L, rb, key, slot, luaH_getshortstr)) { ------------------ | | 86| 26.9k| (!ttistable(t) \ | | ------------------ | | | | 680| 26.9k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 26.9k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 26.9k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 26.9k] | | | Branch (86:4): [True: 2, False: 26.9k] | | ------------------ | | 87| 26.9k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 53.8k| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 26.9k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 107k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 26.9k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 26.9k] | | | | | | | Branch (110:42): [True: 26.9k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 89| 53.8k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 26.9k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 26.9k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 26.9k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 26.9k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 26.9k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1299| 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) || \ | | | | | | ------------------ | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1300| 0| } 1301| 26.9k| else 1302| 26.9k| Protect(luaV_finishget(L, rb, rc, ra, slot)); ------------------ | | 1119| 26.9k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 26.9k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 26.9k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 26.9k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1303| 26.9k| vmbreak; ------------------ | | 16| 26.9k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 26.9k|#define vmfetch() { \ | | | | 1139| 26.9k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 26.9k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 26.9k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 26.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 26.9k| i = *(pc++); \ | | | | 1144| 26.9k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 26.9k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1304| 26.9k| } 1305| 3.90M| vmcase(OP_SETTABUP) { ------------------ | | 14| 3.90M|#define vmcase(l) L_##l: ------------------ 1306| 3.90M| const TValue *slot; 1307| 3.90M| TValue *upval = cl->upvals[GETARG_A(i)]->v.p; ------------------ | | 125| 3.90M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 3.90M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 3.90M|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 3.90M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1308| 3.90M| TValue *rb = KB(i); ------------------ | | 1067| 3.90M|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 3.90M|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 110| 3.90M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 3.90M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1309| 3.90M| TValue *rc = RKC(i); ------------------ | | 1071| 3.90M|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 3.90M|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 110| 3.90M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 3.90M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 1.08M|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 110| 1.08M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 1.08M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 11.2M|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 2.81M] | | | | | Branch (172:19): [True: 2.81M, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1071:17): [True: 1.08M, False: 2.81M] | | ------------------ ------------------ 1310| 7.81M| TString *key = tsvalue(rb); /* key must be a short string */ ------------------ | | 369| 3.90M|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 15.6M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 3.90M|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 3.90M] | | | | | Branch (110:42): [True: 3.90M, False: 0] | | | | ------------------ | | ------------------ ------------------ 1311| 3.90M| if (luaV_fastget(L, upval, key, slot, luaH_getshortstr)) { ------------------ | | 86| 3.90M| (!ttistable(t) \ | | ------------------ | | | | 680| 3.90M|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 3.90M|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 3.90M|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 2.21M, False: 1.69M] | | | Branch (86:4): [True: 0, False: 3.90M] | | ------------------ | | 87| 3.90M| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 7.81M| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 3.90M|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 15.6M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 3.90M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 3.90M] | | | | | | | Branch (110:42): [True: 3.90M, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 89| 7.81M| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 3.90M|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 3.90M|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 3.90M|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 3.90M|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 3.90M|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1312| 2.21M| luaV_finishfastset(L, upval, slot, rc); ------------------ | | 109| 2.21M| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 2.21M|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 2.21M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 2.21M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 2.21M|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 2.21M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 2.21M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 112| 19.0M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 2.21M|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (112:29): [True: 0, False: 1.11M] | | | | | | | | | | | Branch (112:29): [True: 1.11M, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 1.11M] | | | | | | | | | | | Branch (112:29): [True: 1.11M, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 1.11M] | | | | | | | | | | | Branch (112:29): [True: 1.11M, False: 0] | | | | | | | | | | | Branch (112:29): [True: 1.11M, False: 0] | | | | | | | | | | | Branch (112:29): [True: 1.09M, False: 1.11M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 108| 2.21M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 106| 2.21M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 2.21M| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 2.21M|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 2.21M| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 2.21M|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 2.21M|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 2.21M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 1.11M, False: 1.09M] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 1.11M|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 1.11M| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 1.11M|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 1.11M|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 4.47M|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 89, False: 1.11M] | | | | | | | | | | | | | Branch (62:26): [True: 0, False: 1.11M] | | | | | | | | | | | | | Branch (62:26): [True: 1.11M, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 87| 89|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 62| 356|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 8, False: 81] | | | | | | | | | | | Branch (62:26): [True: 0, False: 89] | | | | | | | | | | | Branch (62:26): [True: 89, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 1.11M|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1.11M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (183:51): [True: 0, False: 8] | | | | | | | Branch (183:51): [True: 8, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 1.09M|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 1.09M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1313| 2.21M| } 1314| 1.69M| else 1315| 1.69M| Protect(luaV_finishset(L, upval, rb, rc, slot)); ------------------ | | 1119| 1.69M|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 1.69M|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 1.69M|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 1.69M|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1316| 3.90M| vmbreak; ------------------ | | 16| 3.90M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 3.90M|#define vmfetch() { \ | | | | 1139| 3.90M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 3.90M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 3.90M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 10, False: 3.90M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 10| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 10| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 10|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 10| } \ | | | | 1143| 3.90M| i = *(pc++); \ | | | | 1144| 3.90M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 3.90M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1317| 3.90M| } 1318| 928k| vmcase(OP_SETTABLE) { ------------------ | | 14| 928k|#define vmcase(l) L_##l: ------------------ 1319| 928k| StkId ra = RA(i); ------------------ | | 1064| 928k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 928k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 928k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 928k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 928k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1320| 928k| const TValue *slot; 1321| 928k| TValue *rb = vRB(i); /* key (table is in 'ra') */ ------------------ | | 1066| 928k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 3.71M|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 928k] | | | | | Branch (172:19): [True: 928k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1322| 928k| TValue *rc = RKC(i); /* value */ ------------------ | | 1071| 928k|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 928k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 110| 928k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 928k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 558k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 110| 558k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 558k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 1.47M|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 369k] | | | | | Branch (172:19): [True: 369k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1071:17): [True: 558k, False: 369k] | | ------------------ ------------------ 1323| 0| lua_Unsigned n; 1324| | if (ttisinteger(rb) /* fast track for integers? */ ------------------ | | 328| 928k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 1.85M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 928k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 798k, False: 129k] | | | | ------------------ | | ------------------ ------------------ | Branch (1324:13): [True: 859k, False: 68.7k] ------------------ 1325| 928k| ? (cast_void(n = ivalue(rb)), luaV_fastgeti(L, s2v(ra), n, slot)) ------------------ | | 138| 798k|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 3.19M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 0, False: 798k] | | | | | Branch (136:27): [True: 798k, False: 0] | | | | ------------------ | | ------------------ ------------------ ? (cast_void(n = ivalue(rb)), luaV_fastgeti(L, s2v(ra), n, slot)) ------------------ | | 97| 798k| (!ttistable(t) \ | | ------------------ | | | | 680| 798k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 798k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 798k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (97:4): [True: 0, False: 798k] | | ------------------ | | 98| 798k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 99| 1.59M| : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 152| 798k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 682| 798k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 3.19M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 798k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 798k] | | | | | | | Branch (110:42): [True: 798k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (99:14): [True: 238k, False: 559k] | | ------------------ | | 100| 1.11M| ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 238k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 952k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 238k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 238k] | | | | | | | Branch (110:42): [True: 238k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 559k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 2.23M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 559k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 559k] | | | | | | | Branch (110:42): [True: 559k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 101| 798k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 798k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 798k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 798k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 798k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 798k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1326| 928k| : luaV_fastget(L, s2v(ra), rb, slot, luaH_get)) { ------------------ | | 86| 129k| (!ttistable(t) \ | | ------------------ | | | | 680| 129k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 129k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 129k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:4): [True: 0, False: 129k] | | ------------------ | | 87| 129k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 259k| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 129k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 519k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 129k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 129k] | | | | | | | Branch (110:42): [True: 129k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 89| 259k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 129k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 129k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 129k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 129k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 129k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1327| 859k| luaV_finishfastset(L, s2v(ra), slot, rc); ------------------ | | 109| 859k| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 859k|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 859k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 859k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 859k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 859k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 859k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 112| 859k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 859k|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (112:29): [True: 0, False: 3] | | | | | | | | | | | Branch (112:29): [True: 3, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 3] | | | | | | | | | | | Branch (112:29): [True: 3, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 3] | | | | | | | | | | | Branch (112:29): [True: 3, False: 0] | | | | | | | | | | | Branch (112:29): [True: 3, False: 0] | | | | | | | | | | | Branch (112:29): [True: 859k, False: 3] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 108| 859k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 106| 859k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 859k| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 859k|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 859k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 859k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 859k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 859k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 3, False: 859k] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 3|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 3| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 3|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 3|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 12|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 0, False: 3] | | | | | | | | | | | | | Branch (62:26): [True: 0, False: 3] | | | | | | | | | | | | | Branch (62:26): [True: 3, 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] | | | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 3|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 3|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (183:51): [True: 0, False: 0] | | | | | | | Branch (183:51): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 859k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 859k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1328| 859k| } 1329| 68.7k| else 1330| 68.7k| Protect(luaV_finishset(L, s2v(ra), rb, rc, slot)); ------------------ | | 1119| 68.7k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 68.7k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 68.7k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 68.7k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1331| 928k| vmbreak; ------------------ | | 16| 928k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 928k|#define vmfetch() { \ | | | | 1139| 928k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 928k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 928k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 928k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 928k| i = *(pc++); \ | | | | 1144| 928k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 928k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1332| 928k| } 1333| 76.4k| vmcase(OP_SETI) { ------------------ | | 14| 76.4k|#define vmcase(l) L_##l: ------------------ 1334| 76.4k| StkId ra = RA(i); ------------------ | | 1064| 76.4k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 76.4k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 76.4k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 76.4k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 76.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1335| 76.4k| const TValue *slot; 1336| 76.4k| int c = GETARG_B(i); ------------------ | | 128| 76.4k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 76.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 76.4k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1337| 76.4k| TValue *rc = RKC(i); ------------------ | | 1071| 76.4k|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 76.4k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 110| 76.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 76.4k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 76.4k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 110| 76.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 76.4k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 0] | | | | | Branch (172:19): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1071:17): [True: 76.4k, False: 0] | | ------------------ ------------------ 1338| 76.4k| if (luaV_fastgeti(L, s2v(ra), c, slot)) { ------------------ | | 97| 76.4k| (!ttistable(t) \ | | ------------------ | | | | 680| 76.4k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 76.4k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 76.4k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (97:3): [True: 76.4k, False: 4] | | | Branch (97:4): [True: 1, False: 76.4k] | | ------------------ | | 98| 76.4k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 99| 152k| : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 152| 76.4k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 682| 76.4k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 305k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 76.4k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 76.4k] | | | | | | | Branch (110:42): [True: 76.4k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (99:14): [True: 2, False: 76.4k] | | ------------------ | | 100| 152k| ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 2|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 8|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 2|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 2] | | | | | | | Branch (110:42): [True: 2, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 76.4k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 305k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 76.4k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 76.4k] | | | | | | | Branch (110:42): [True: 76.4k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 101| 76.4k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 76.4k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 76.4k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 76.4k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 76.4k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 76.4k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1339| 76.4k| luaV_finishfastset(L, s2v(ra), slot, rc); ------------------ | | 109| 76.4k| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 76.4k|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 76.4k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 76.4k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 76.4k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 76.4k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 76.4k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 112| 76.4k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 76.4k|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | | | Branch (112:29): [True: 76.4k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 108| 76.4k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 106| 76.4k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 76.4k| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 76.4k|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 76.4k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 76.4k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 76.4k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 76.4k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 76.4k] | | | | | | ------------------ | | | | ------------------ | | | | 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] | | | | | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | | | | | Branch (62:26): [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] | | | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | | | Branch (62:26): [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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (183:51): [True: 0, False: 0] | | | | | | | Branch (183:51): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 76.4k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 76.4k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1340| 76.4k| } 1341| 4| else { 1342| 4| TValue key; 1343| 4| setivalue(&key, c); ------------------ | | 345| 4| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 4|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 4|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1344| 4| Protect(luaV_finishset(L, s2v(ra), &key, rc, slot)); ------------------ | | 1119| 4|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 4|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 4|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 4|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1345| 4| } 1346| 76.4k| vmbreak; ------------------ | | 16| 76.4k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 76.4k|#define vmfetch() { \ | | | | 1139| 76.4k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 76.4k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 76.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 76.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 76.4k| i = *(pc++); \ | | | | 1144| 76.4k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 76.4k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1347| 76.4k| } 1348| 25.7k| vmcase(OP_SETFIELD) { ------------------ | | 14| 25.7k|#define vmcase(l) L_##l: ------------------ 1349| 25.7k| StkId ra = RA(i); ------------------ | | 1064| 25.7k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 25.7k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 25.7k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 25.7k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 25.7k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1350| 25.7k| const TValue *slot; 1351| 25.7k| TValue *rb = KB(i); ------------------ | | 1067| 25.7k|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 25.7k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 110| 25.7k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 25.7k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1352| 25.7k| TValue *rc = RKC(i); ------------------ | | 1071| 25.7k|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 25.7k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 110| 25.7k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 25.7k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 103k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 25.7k] | | | | | Branch (172:19): [True: 25.7k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1071:17): [True: 0, False: 25.7k] | | ------------------ ------------------ 1353| 51.5k| TString *key = tsvalue(rb); /* key must be a short string */ ------------------ | | 369| 25.7k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 103k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 25.7k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 25.7k] | | | | | Branch (110:42): [True: 25.7k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1354| 25.7k| if (luaV_fastget(L, s2v(ra), key, slot, luaH_getshortstr)) { ------------------ | | 86| 25.7k| (!ttistable(t) \ | | ------------------ | | | | 680| 25.7k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 25.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 25.7k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 17.2k, False: 8.55k] | | | Branch (86:4): [True: 0, False: 25.7k] | | ------------------ | | 87| 25.7k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 51.5k| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 25.7k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 103k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 25.7k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 25.7k] | | | | | | | Branch (110:42): [True: 25.7k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 89| 51.5k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 25.7k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 25.7k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 25.7k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 25.7k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 25.7k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1355| 17.2k| luaV_finishfastset(L, s2v(ra), slot, rc); ------------------ | | 109| 17.2k| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 17.2k|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 17.2k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 17.2k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 17.2k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 17.2k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 17.2k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 112| 104k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 17.2k|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (112:29): [True: 0, False: 5.79k] | | | | | | | | | | | Branch (112:29): [True: 5.79k, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 5.79k] | | | | | | | | | | | Branch (112:29): [True: 5.79k, False: 0] | | | | | | | | | | | Branch (112:29): [True: 0, False: 5.79k] | | | | | | | | | | | Branch (112:29): [True: 5.79k, False: 0] | | | | | | | | | | | Branch (112:29): [True: 5.79k, False: 0] | | | | | | | | | | | Branch (112:29): [True: 11.4k, False: 5.79k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 108| 17.2k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 106| 17.2k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 17.2k| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 17.2k|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 17.2k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 17.2k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 17.2k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 17.2k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 5.79k, False: 11.4k] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 5.79k|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 5.79k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 5.79k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 5.79k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 23.1k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 0, False: 5.79k] | | | | | | | | | | | | | Branch (62:26): [True: 0, False: 5.79k] | | | | | | | | | | | | | Branch (62:26): [True: 5.79k, 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] | | | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 5.79k|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 5.79k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (183:51): [True: 0, False: 0] | | | | | | | Branch (183:51): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 11.4k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 11.4k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1356| 17.2k| } 1357| 8.55k| else 1358| 8.55k| Protect(luaV_finishset(L, s2v(ra), rb, rc, slot)); ------------------ | | 1119| 8.55k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 8.55k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 8.55k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 8.55k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1359| 25.7k| vmbreak; ------------------ | | 16| 25.7k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 25.7k|#define vmfetch() { \ | | | | 1139| 25.7k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 25.7k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 25.7k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 25.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 25.7k| i = *(pc++); \ | | | | 1144| 25.7k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 25.7k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1360| 25.7k| } 1361| 2.00k| vmcase(OP_NEWTABLE) { ------------------ | | 14| 2.00k|#define vmcase(l) L_##l: ------------------ 1362| 2.00k| StkId ra = RA(i); ------------------ | | 1064| 2.00k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 2.00k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 2.00k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 2.00k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 2.00k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1363| 2.00k| int b = GETARG_B(i); /* log2(hash size) + 1 */ ------------------ | | 128| 2.00k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 2.00k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.00k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1364| 2.00k| int c = GETARG_C(i); /* array size */ ------------------ | | 132| 2.00k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 110| 2.00k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.00k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1365| 0| Table *t; 1366| 2.00k| if (b > 0) ------------------ | Branch (1366:13): [True: 0, False: 2.00k] ------------------ 1367| 0| b = 1 << (b - 1); /* size is 2^(b - 1) */ 1368| 2.00k| lua_assert((!TESTARG_k(i)) == (GETARG_Ax(*pc) == 0)); ------------------ | | 106| 2.00k|#define lua_assert(c) assert(c) ------------------ 1369| 2.00k| if (TESTARG_k(i)) /* non-zero extra argument? */ ------------------ | | 136| 2.00k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 110| 2.00k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.00k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:25): [True: 0, False: 2.00k] | | | | ------------------ | | ------------------ ------------------ 1370| 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)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 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 */ 1373| 2.00k| t = luaH_new(L); /* memory allocation */ 1374| 2.00k| sethvalue2s(L, ra, t); ------------------ | | 689| 2.00k|#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) | | ------------------ | | | | 685| 2.00k| { TValue *io = (obj); Table *x_ = (x); \ | | | | 686| 2.00k| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 72| 2.00k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 390| 2.00k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 2.00k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 2.00k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 114| 2.00k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 687| 2.00k| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 2.00k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 32.0k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 2.00k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 2.00k] | | | | | | | | | Branch (112:29): [True: 2.00k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 2.00k] | | | | | | | | | Branch (112:29): [True: 2.00k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 2.00k] | | | | | | | | | Branch (112:29): [True: 2.00k, False: 0] | | | | | | | | | Branch (112:29): [True: 2.00k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 2.00k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 2.00k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1375| 2.00k| if (b != 0 || c != 0) ------------------ | Branch (1375:13): [True: 0, False: 2.00k] | Branch (1375:23): [True: 2.00k, False: 0] ------------------ 1376| 2.00k| luaH_resize(L, t, c, b); /* idem */ 1377| 2.00k| checkGC(L, ra + 1); ------------------ | | 1132| 2.00k| { luaC_condGC(L, (savepc(L), L->top.p = (c)), \ | | ------------------ | | | | 168| 2.00k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 2.00k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 2.00k] | | | | ------------------ | | | | 169| 2.00k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 2.00k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 1133| 2.00k| updatetrap(ci)); \ | | 1134| 2.00k| luai_threadyield(L); } | | ------------------ | | | | 273| 2.00k|#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 265| 2.00k|#define lua_unlock(L) ((void) 0) | | | | ------------------ | | | | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 264| 2.00k|#define lua_lock(L) ((void) 0) | | | | ------------------ | | ------------------ ------------------ 1378| 2.00k| vmbreak; ------------------ | | 16| 2.00k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 2.00k|#define vmfetch() { \ | | | | 1139| 2.00k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 2.00k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 2.00k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 2.00k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 2.00k| i = *(pc++); \ | | | | 1144| 2.00k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 2.00k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1379| 2.00k| } 1380| 0| vmcase(OP_SELF) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1381| 0| StkId ra = RA(i); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1382| 0| const TValue *slot; 1383| 0| TValue *rb = vRB(i); ------------------ | | 1066| 0|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 0] | | | | | Branch (172:19): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1384| 0| TValue *rc = RKC(i); ------------------ | | 1071| 0|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 0|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 0] | | | | | Branch (172:19): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1071:17): [True: 0, False: 0] | | ------------------ ------------------ 1385| 0| TString *key = tsvalue(rc); /* key must be a string */ ------------------ | | 369| 0|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 0] | | | | | Branch (110:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1386| 0| setobj2s(L, ra + 1, 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) || \ | | | | | | ------------------ | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1387| 0| if (luaV_fastget(L, rb, key, slot, luaH_getstr)) { ------------------ | | 86| 0| (!ttistable(t) \ | | ------------------ | | | | 680| 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 */ \ | | ------------------ | | | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | | Branch (110:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1388| 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) || \ | | | | | | ------------------ | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1389| 0| } 1390| 0| else 1391| 0| Protect(luaV_finishget(L, rb, rc, ra, slot)); ------------------ | | 1119| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1392| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1393| 0| } 1394| 107k| vmcase(OP_ADDI) { ------------------ | | 14| 107k|#define vmcase(l) L_##l: ------------------ 1395| 215k| op_arithI(L, l_addi, luai_numadd); ------------------ | | 905| 107k|#define op_arithI(L,iop,fop) { \ | | 906| 107k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 107k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 107k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 107k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 107k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 107k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 907| 107k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 107k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 431k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 107k] | | | | | | | Branch (172:19): [True: 107k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 908| 107k| int imm = GETARG_sC(i); \ | | ------------------ | | | | 133| 107k|#define GETARG_sC(i) sC2int(GETARG_C(i)) | | | | ------------------ | | | | | | 101| 431k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 107k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 107k|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 100k, False: 7.09k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 910| 100k| lua_Integer iv1 = ivalue(v1); \ | | ------------------ | | | | 333| 100k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 110| 100k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 100k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 911| 100k| pc++; setivalue(s2v(ra), iop(L, iv1, imm)); \ | | ------------------ | | | | 345| 100k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 100k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 100k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 912| 100k| } \ | | 913| 107k| else if (ttisfloat(v1)) { \ | | ------------------ | | | | 327| 7.09k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 7.09k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 7.09k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 7.09k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 914| 7.09k| lua_Number nb = fltvalue(v1); \ | | ------------------ | | | | 332| 7.09k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 110| 7.09k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 7.09k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 915| 7.09k| lua_Number fimm = cast_num(imm); \ | | ------------------ | | | | 140| 7.09k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 7.09k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 916| 7.09k| pc++; setfltvalue(s2v(ra), fop(L, nb, fimm)); \ | | ------------------ | | | | 339| 7.09k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | ------------------ | | | | | | 72| 7.09k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | ------------------ | | | | | | 114| 7.09k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 917| 7.09k| }} ------------------ 1396| 107k| vmbreak; ------------------ | | 16| 107k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 107k|#define vmfetch() { \ | | | | 1139| 107k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 107k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 107k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 107k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 107k| i = *(pc++); \ | | | | 1144| 107k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 107k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1397| 107k| } 1398| 214k| vmcase(OP_ADDK) { ------------------ | | 14| 214k|#define vmcase(l) L_##l: ------------------ 1399| 859k| op_arithK(L, l_addi, luai_numadd); ------------------ | | 975| 214k|#define op_arithK(L,iop,fop) { \ | | 976| 214k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 214k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 859k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 214k] | | | | | | | Branch (172:19): [True: 214k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 977| 214k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1070| 214k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 214k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 110| 214k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 214k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 106| 214k|#define lua_assert(c) assert(c) | | ------------------ | | 978| 214k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 214k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 214k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 214k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 214k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 214k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 214k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 214k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 214k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 214k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 429k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 214k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 214k, False: 19] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 214k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 214k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 214k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 77.6k, False: 137k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 77.6k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 77.6k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 77.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 77.6k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 77.6k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 77.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 77.6k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 958| 77.6k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 77.6k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 77.6k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 77.6k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 77.6k| } \ | | | | 960| 214k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 137k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 137k| lua_Number n1; lua_Number n2; \ | | | | | | 926| 137k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 274k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 137k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 137k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 137k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 19, False: 137k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 19|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 19|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 19|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 137k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 274k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 137k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 137k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 137k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 137k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 137k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 548k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 137k] | | | | | | | | | | | | | Branch (136:27): [True: 137k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 137k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 137k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 137k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 137k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 137k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 137k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 137k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 137k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 137k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 137k| (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)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 137k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 137k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 137k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 137k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 137k| }} | | | | ------------------ | | ------------------ ------------------ 1400| 859k| vmbreak; ------------------ | | 16| 214k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 214k|#define vmfetch() { \ | | | | 1139| 214k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 214k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 214k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 214k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 214k| i = *(pc++); \ | | | | 1144| 214k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 214k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1401| 859k| } 1402| 195| vmcase(OP_SUBK) { ------------------ | | 14| 195|#define vmcase(l) L_##l: ------------------ 1403| 780| op_arithK(L, l_subi, luai_numsub); ------------------ | | 975| 195|#define op_arithK(L,iop,fop) { \ | | 976| 195| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 195|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 780|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 195] | | | | | | | Branch (172:19): [True: 195, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 977| 195| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1070| 195|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 195|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 110| 195|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 195|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 106| 195|#define lua_assert(c) assert(c) | | ------------------ | | 978| 195| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 195|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 195| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 195|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 195|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 195|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 195|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 195|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 195| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 195|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 390|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 195|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 195, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 195|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 195|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 195|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 195, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 195| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 195|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 195|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 195|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 195|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 195|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 195|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 958| 195| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 195| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 195|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 195|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 195| } \ | | | | 960| 195| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 0|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 0| lua_Number n1; lua_Number n2; \ | | | | | | 926| 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) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | 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)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 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) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | 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)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 0| }} | | | | ------------------ | | ------------------ ------------------ 1404| 780| vmbreak; ------------------ | | 16| 195|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 195|#define vmfetch() { \ | | | | 1139| 195| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 195|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 195|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 195] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 195| i = *(pc++); \ | | | | 1144| 195|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 195|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1405| 780| } 1406| 129k| vmcase(OP_MULK) { ------------------ | | 14| 129k|#define vmcase(l) L_##l: ------------------ 1407| 519k| op_arithK(L, l_muli, luai_nummul); ------------------ | | 975| 129k|#define op_arithK(L,iop,fop) { \ | | 976| 129k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 129k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 519k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 129k] | | | | | | | Branch (172:19): [True: 129k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 977| 129k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1070| 129k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 129k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 110| 129k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 129k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 106| 129k|#define lua_assert(c) assert(c) | | ------------------ | | 978| 129k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 129k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 129k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 129k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 129k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 129k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 129k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 129k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 129k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 129k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 259k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 129k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 127k, False: 2.20k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 127k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 127k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 127k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 127k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 127k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 127k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 127k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 127k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 127k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 127k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 127k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 958| 127k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 127k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 127k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 127k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 127k| } \ | | | | 960| 129k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 2.20k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 2.20k| lua_Number n1; lua_Number n2; \ | | | | | | 926| 2.20k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 4.41k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 2.20k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 2.20k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 2.20k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 2.20k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 2.20k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 2.20k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 2.20k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 2.20k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 4.41k| (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)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 2.20k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 2.20k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 2.20k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 2.20k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 2.00k, False: 207] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 2.00k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 2.00k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 2.00k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 2.20k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 2.20k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 207|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 207|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 207|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 207, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 207|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 828|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 207] | | | | | | | | | | | | | Branch (136:27): [True: 207, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 2.20k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 2.20k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 2.20k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 2.20k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 2.20k| }} | | | | ------------------ | | ------------------ ------------------ 1408| 519k| vmbreak; ------------------ | | 16| 129k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 129k|#define vmfetch() { \ | | | | 1139| 129k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 129k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 129k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 129k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 129k| i = *(pc++); \ | | | | 1144| 129k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 129k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1409| 519k| } 1410| 4.21k| vmcase(OP_MODK) { ------------------ | | 14| 4.21k|#define vmcase(l) L_##l: ------------------ 1411| 4.21k| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1112| 4.21k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1105| 4.21k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1412| 16.8k| op_arithK(L, luaV_mod, luaV_modf); ------------------ | | 975| 4.21k|#define op_arithK(L,iop,fop) { \ | | 976| 4.21k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 4.21k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 16.8k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 4.21k] | | | | | | | Branch (172:19): [True: 4.21k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 977| 4.21k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1070| 4.21k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 4.21k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 110| 4.21k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 4.21k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 106| 4.21k|#define lua_assert(c) assert(c) | | ------------------ | | 978| 4.21k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 4.21k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 4.21k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 4.21k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 4.21k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 4.21k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 4.21k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 4.21k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 4.21k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 4.21k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 8.42k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 4.21k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 4.20k, False: 10] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 4.20k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 4.20k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 4.20k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 4.19k, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 4.19k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 4.19k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 4.19k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 4.19k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 4.19k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 4.19k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 4.19k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 958| 4.19k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 4.19k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 4.19k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 4.19k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 4.19k| } \ | | | | 960| 4.21k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 14|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 14| lua_Number n1; lua_Number n2; \ | | | | | | 926| 14| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 28| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 14|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 14|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 14|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 10, False: 4] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 10|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 10|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 10|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 14, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 28| (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| 16|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 4] | | | | | | | | | | | | | Branch (136:27): [True: 4, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 14| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 14|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 14|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 14|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 4, False: 10] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 4|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 4|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 4|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 14, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 14| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 10|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 10|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 10|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 10, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 10|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 40|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 10] | | | | | | | | | | | | | Branch (136:27): [True: 10, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 14| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 14| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 14|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 14|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 14| }} | | | | ------------------ | | ------------------ ------------------ 1413| 16.8k| vmbreak; ------------------ | | 16| 4.21k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 4.21k|#define vmfetch() { \ | | | | 1139| 4.21k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 4.21k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 4.21k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 4.21k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 4.21k| i = *(pc++); \ | | | | 1144| 4.21k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 4.21k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1414| 16.8k| } 1415| 47.8k| vmcase(OP_POWK) { ------------------ | | 14| 47.8k|#define vmcase(l) L_##l: ------------------ 1416| 143k| op_arithfK(L, luai_numpow); ------------------ | | 944| 47.8k|#define op_arithfK(L,fop) { \ | | 945| 47.8k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 47.8k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 47.8k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 47.8k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 47.8k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 47.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 946| 47.8k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 47.8k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 191k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 47.8k] | | | | | | | Branch (172:19): [True: 47.8k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 947| 47.8k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1070| 47.8k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 47.8k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 110| 47.8k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 47.8k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 106| 47.8k|#define lua_assert(c) assert(c) | | ------------------ | | 948| 47.8k| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 924| 47.8k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 925| 47.8k| lua_Number n1; lua_Number n2; \ | | | | 926| 47.8k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 95.6k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 47.8k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 47.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 47.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 0, False: 47.8k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 47.8k, False: 0] | | | | | | ------------------ | | | | | | 58| 95.6k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 47.8k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 47.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 47.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 47.8k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 47.8k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 191k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (136:27): [True: 0, False: 47.8k] | | | | | | | | | | | Branch (136:27): [True: 47.8k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 47.8k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 47.8k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 47.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 47.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 0, False: 47.8k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 47.8k, False: 0] | | | | | | ------------------ | | | | | | 58| 47.8k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 47.8k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 47.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 47.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 47.8k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 47.8k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 191k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (136:27): [True: 0, False: 47.8k] | | | | | | | | | | | Branch (136:27): [True: 47.8k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 927| 47.8k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | ------------------ | | | | | | 339| 95.6k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 72| 47.8k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 114| 47.8k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | | Branch (339:35): [True: 0, False: 47.8k] | | | | | | ------------------ | | | | ------------------ | | | | 928| 47.8k| }} | | ------------------ ------------------ 1417| 143k| vmbreak; ------------------ | | 16| 47.8k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 47.8k|#define vmfetch() { \ | | | | 1139| 47.8k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 47.8k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 47.8k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 47.8k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 47.8k| i = *(pc++); \ | | | | 1144| 47.8k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 47.8k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1418| 143k| } 1419| 0| vmcase(OP_DIVK) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1420| 0| op_arithfK(L, luai_numdiv); ------------------ | | 944| 0|#define op_arithfK(L,fop) { \ | | 945| 0| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 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)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 946| 0| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 0|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 947| 0| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1070| 0|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 106| 0|#define lua_assert(c) assert(c) | | ------------------ | | 948| 0| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 924| 0|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 925| 0| lua_Number n1; lua_Number n2; \ | | | | 926| 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) | | | | | | | | ------------------ | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | 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)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | Branch (136:27): [True: 0, False: 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) | | | | | | | | ------------------ | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | 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)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 927| 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)) | | | | | | ------------------ | | | | ------------------ | | | | 928| 0| }} | | ------------------ ------------------ 1421| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1422| 0| } 1423| 630k| vmcase(OP_IDIVK) { ------------------ | | 14| 630k|#define vmcase(l) L_##l: ------------------ 1424| 630k| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1112| 630k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1105| 630k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1425| 2.52M| op_arithK(L, luaV_idiv, luai_numidiv); ------------------ | | 975| 630k|#define op_arithK(L,iop,fop) { \ | | 976| 630k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 630k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 2.52M|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 630k] | | | | | | | Branch (172:19): [True: 630k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 977| 630k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1070| 630k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 630k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 110| 630k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 630k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 106| 630k|#define lua_assert(c) assert(c) | | ------------------ | | 978| 630k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 630k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 630k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 630k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 630k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 630k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 630k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 630k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 630k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 630k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 1.26M|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 630k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 630k, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 630k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 630k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 630k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 625k, False: 5.09k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 625k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 625k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 625k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 625k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 625k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 625k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 625k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 958| 625k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 625k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 625k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 625k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 625k| } \ | | | | 960| 630k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 5.09k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 5.09k| lua_Number n1; lua_Number n2; \ | | | | | | 926| 5.09k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 10.1k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 5.09k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 5.09k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 5.09k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 4, False: 5.09k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 4|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 4|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 4|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 5.09k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 10.1k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 5.09k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 5.09k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 5.09k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 5.09k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 5.09k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 20.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 5.09k] | | | | | | | | | | | | | Branch (136:27): [True: 5.09k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 5.09k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 5.09k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 5.09k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 5.09k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 5.09k, False: 4] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 5.09k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 5.09k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 5.09k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 5.09k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 5.09k| (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| 16|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 4] | | | | | | | | | | | | | Branch (136:27): [True: 4, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 5.09k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 5.09k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 5.09k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 5.09k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 5.09k| }} | | | | ------------------ | | ------------------ ------------------ 1426| 2.52M| vmbreak; ------------------ | | 16| 630k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 630k|#define vmfetch() { \ | | | | 1139| 630k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 630k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 630k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 630k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 630k| i = *(pc++); \ | | | | 1144| 630k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 630k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1427| 2.52M| } 1428| 623k| vmcase(OP_BANDK) { ------------------ | | 14| 623k|#define vmcase(l) L_##l: ------------------ 1429| 1.87M| op_bitwiseK(L, l_band); ------------------ | | 984| 623k|#define op_bitwiseK(L,op) { \ | | 985| 623k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 623k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 623k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 623k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 623k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 623k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 986| 623k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 623k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 2.49M|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 623k] | | | | | | | Branch (172:19): [True: 623k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 987| 623k| TValue *v2 = KC(i); \ | | ------------------ | | | | 1070| 623k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 623k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 110| 623k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 623k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 988| 623k| lua_Integer i1; \ | | 989| 623k| lua_Integer i2 = ivalue(v2); \ | | ------------------ | | | | 333| 623k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 110| 623k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 623k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 990| 623k| if (tointegerns(v1, &i1)) { \ | | ------------------ | | | | 69| 623k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 623k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 623k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 623k, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 623k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 623k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 623k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 623k, False: 1] | | | | ------------------ | | | | 70| 623k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 1|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 991| 623k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 623k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 623k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 623k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 992| 623k| }} ------------------ 1430| 1.87M| vmbreak; ------------------ | | 16| 623k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 623k|#define vmfetch() { \ | | | | 1139| 623k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 623k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 623k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 623k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 623k| i = *(pc++); \ | | | | 1144| 623k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 623k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1431| 1.87M| } 1432| 17.8k| vmcase(OP_BORK) { ------------------ | | 14| 17.8k|#define vmcase(l) L_##l: ------------------ 1433| 53.5k| op_bitwiseK(L, l_bor); ------------------ | | 984| 17.8k|#define op_bitwiseK(L,op) { \ | | 985| 17.8k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 17.8k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 17.8k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 17.8k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 17.8k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 17.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 986| 17.8k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 17.8k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 71.3k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 17.8k] | | | | | | | Branch (172:19): [True: 17.8k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 987| 17.8k| TValue *v2 = KC(i); \ | | ------------------ | | | | 1070| 17.8k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 17.8k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 110| 17.8k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 17.8k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 988| 17.8k| lua_Integer i1; \ | | 989| 17.8k| lua_Integer i2 = ivalue(v2); \ | | ------------------ | | | | 333| 17.8k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 110| 17.8k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 17.8k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 990| 17.8k| if (tointegerns(v1, &i1)) { \ | | ------------------ | | | | 69| 17.8k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 17.8k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 17.8k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 17.8k, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 17.8k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 17.8k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 17.8k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 17.8k, False: 0] | | | | ------------------ | | | | 70| 17.8k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 4|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 991| 17.8k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 17.8k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 17.8k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 17.8k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 992| 17.8k| }} ------------------ 1434| 53.5k| vmbreak; ------------------ | | 16| 17.8k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 17.8k|#define vmfetch() { \ | | | | 1139| 17.8k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 17.8k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 17.8k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 17.8k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 17.8k| i = *(pc++); \ | | | | 1144| 17.8k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 17.8k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1435| 53.5k| } 1436| 5| vmcase(OP_BXORK) { ------------------ | | 14| 5|#define vmcase(l) L_##l: ------------------ 1437| 15| op_bitwiseK(L, l_bxor); ------------------ | | 984| 5|#define op_bitwiseK(L,op) { \ | | 985| 5| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 5|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 5|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 5|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 5|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 5|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 986| 5| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 5|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 20|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 5] | | | | | | | Branch (172:19): [True: 5, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 987| 5| TValue *v2 = KC(i); \ | | ------------------ | | | | 1070| 5|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 5|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 110| 5|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 5|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 988| 5| lua_Integer i1; \ | | 989| 5| lua_Integer i2 = ivalue(v2); \ | | ------------------ | | | | 333| 5|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 110| 5|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 5|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 990| 5| if (tointegerns(v1, &i1)) { \ | | ------------------ | | | | 69| 5| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 5|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 5|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 0, False: 5] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 5, False: 0] | | | | ------------------ | | | | 70| 5| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 5|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 991| 5| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 5| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 5|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 5|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 992| 5| }} ------------------ 1438| 15| vmbreak; ------------------ | | 16| 5|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 5|#define vmfetch() { \ | | | | 1139| 5| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 5|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 5|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 5] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 5| i = *(pc++); \ | | | | 1144| 5|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 5|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1439| 15| } 1440| 0| vmcase(OP_SHRI) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1441| 0| StkId ra = RA(i); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1442| 0| TValue *rb = vRB(i); ------------------ | | 1066| 0|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 0] | | | | | Branch (172:19): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1443| 0| int ic = GETARG_sC(i); ------------------ | | 133| 0|#define GETARG_sC(i) sC2int(GETARG_C(i)) | | ------------------ | | | | 101| 0|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 0|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 0|#define MAXARG_C ((1<value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1447| 0| } 1448| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1449| 0| } 1450| 154k| vmcase(OP_SHLI) { ------------------ | | 14| 154k|#define vmcase(l) L_##l: ------------------ 1451| 154k| StkId ra = RA(i); ------------------ | | 1064| 154k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 154k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 154k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 154k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 154k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1452| 154k| TValue *rb = vRB(i); ------------------ | | 1066| 154k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 618k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 154k] | | | | | Branch (172:19): [True: 154k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1453| 154k| int ic = GETARG_sC(i); ------------------ | | 133| 154k|#define GETARG_sC(i) sC2int(GETARG_C(i)) | | ------------------ | | | | 101| 618k|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 154k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 154k|#define MAXARG_C ((1<value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 154k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1457| 154k| } 1458| 154k| vmbreak; ------------------ | | 16| 154k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 154k|#define vmfetch() { \ | | | | 1139| 154k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 154k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 154k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 154k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 154k| i = *(pc++); \ | | | | 1144| 154k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 154k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1459| 154k| } 1460| 1.15k| vmcase(OP_ADD) { ------------------ | | 14| 1.15k|#define vmcase(l) L_##l: ------------------ 1461| 3.46k| op_arith(L, l_addi, luai_numadd); ------------------ | | 966| 1.15k|#define op_arith(L,iop,fop) { \ | | 967| 1.15k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 1.15k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 4.62k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 1.15k] | | | | | | | Branch (172:19): [True: 1.15k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 968| 1.15k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 1.15k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 4.62k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 1.15k] | | | | | | | Branch (172:19): [True: 1.15k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 969| 1.15k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 1.15k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 1.15k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 1.15k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 1.15k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 1.15k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 1.15k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 1.15k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 1.15k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 1.15k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 2.31k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 1.15k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 1.15k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 1.15k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 1.15k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 1.15k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 1.15k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 1.15k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 1.15k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 1.15k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 1.15k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 1.15k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 1.15k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 1.15k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 958| 1.15k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 1.15k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 1.15k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 1.15k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 1.15k| } \ | | | | 960| 1.15k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 0|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 0| lua_Number n1; lua_Number n2; \ | | | | | | 926| 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) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | 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)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 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) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | 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)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 0| }} | | | | ------------------ | | ------------------ ------------------ 1462| 3.46k| vmbreak; ------------------ | | 16| 1.15k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 1.15k|#define vmfetch() { \ | | | | 1139| 1.15k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.15k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.15k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1.15k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 1.15k| i = *(pc++); \ | | | | 1144| 1.15k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.15k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1463| 3.46k| } 1464| 10.6k| vmcase(OP_SUB) { ------------------ | | 14| 10.6k|#define vmcase(l) L_##l: ------------------ 1465| 31.8k| op_arith(L, l_subi, luai_numsub); ------------------ | | 966| 10.6k|#define op_arith(L,iop,fop) { \ | | 967| 10.6k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 10.6k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 42.4k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 10.6k] | | | | | | | Branch (172:19): [True: 10.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 968| 10.6k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 10.6k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 42.4k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 10.6k] | | | | | | | Branch (172:19): [True: 10.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 969| 10.6k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 10.6k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 10.6k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 10.6k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 10.6k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 10.6k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 10.6k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 10.6k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 10.6k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 10.6k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 21.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 10.6k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 1.35k, False: 9.25k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 1.35k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 1.35k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 1.35k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 1.35k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 1.35k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 1.35k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 1.35k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 1.35k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 1.35k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 1.35k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 1.35k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 958| 1.35k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 1.35k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 1.35k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 1.35k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 1.35k| } \ | | | | 960| 10.6k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 9.25k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 9.25k| lua_Number n1; lua_Number n2; \ | | | | | | 926| 9.25k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 18.5k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 9.25k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 9.25k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 9.25k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 9.25k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 9.25k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 9.25k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 9.25k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 9.25k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 18.5k| (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)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 9.25k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 9.25k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 9.25k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 9.25k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 3, False: 9.25k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 3|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 3|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 3|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 9.25k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 9.25k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 9.25k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 9.25k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 9.25k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 9.25k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 9.25k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 37.0k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 9.25k] | | | | | | | | | | | | | Branch (136:27): [True: 9.25k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 9.25k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 9.25k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 9.25k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 9.25k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 9.25k| }} | | | | ------------------ | | ------------------ ------------------ 1466| 31.8k| vmbreak; ------------------ | | 16| 10.6k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 10.6k|#define vmfetch() { \ | | | | 1139| 10.6k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 10.6k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 10.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 10.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 10.6k| i = *(pc++); \ | | | | 1144| 10.6k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 10.6k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1467| 31.8k| } 1468| 3.95k| vmcase(OP_MUL) { ------------------ | | 14| 3.95k|#define vmcase(l) L_##l: ------------------ 1469| 11.8k| op_arith(L, l_muli, luai_nummul); ------------------ | | 966| 3.95k|#define op_arith(L,iop,fop) { \ | | 967| 3.95k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 3.95k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 15.8k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 3.95k] | | | | | | | Branch (172:19): [True: 3.95k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 968| 3.95k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 3.95k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 15.8k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 3.95k] | | | | | | | Branch (172:19): [True: 3.95k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 969| 3.95k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 3.95k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 3.95k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 3.95k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 3.95k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 3.95k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 3.95k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 3.95k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 3.95k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 3.95k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 7.90k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 3.95k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 3.90k, False: 46] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 3.90k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 3.90k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 3.90k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 3.90k, False: 7] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 3.90k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 3.90k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 3.90k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 3.90k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 3.90k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 3.90k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 3.90k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 958| 3.90k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 3.90k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 3.90k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 3.90k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 3.90k| } \ | | | | 960| 3.95k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 53|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 53| lua_Number n1; lua_Number n2; \ | | | | | | 926| 53| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 106| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 53|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 53|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 53|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 46, False: 7] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 46|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 46|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 46|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 53, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 106| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 7|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 7|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 7|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 7, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 7|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 28|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 7] | | | | | | | | | | | | | Branch (136:27): [True: 7, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 53| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 53|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 53|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 53|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 53, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 53|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 53|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 53|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 53, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 53| (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)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 53| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 53| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 53|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 53|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 53| }} | | | | ------------------ | | ------------------ ------------------ 1470| 11.8k| vmbreak; ------------------ | | 16| 3.95k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 3.95k|#define vmfetch() { \ | | | | 1139| 3.95k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 3.95k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 3.95k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 3.95k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 3.95k| i = *(pc++); \ | | | | 1144| 3.95k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 3.95k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1471| 11.8k| } 1472| 638k| vmcase(OP_MOD) { ------------------ | | 14| 638k|#define vmcase(l) L_##l: ------------------ 1473| 638k| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1112| 638k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1105| 638k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1474| 1.91M| op_arith(L, luaV_mod, luaV_modf); ------------------ | | 966| 638k|#define op_arith(L,iop,fop) { \ | | 967| 638k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 638k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 2.55M|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 638k] | | | | | | | Branch (172:19): [True: 638k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 968| 638k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 638k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 2.55M|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 638k] | | | | | | | Branch (172:19): [True: 638k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 969| 638k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 638k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 638k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 638k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 638k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 638k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 638k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 638k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 638k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 638k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 1.27M|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 638k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 624k, False: 13.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 624k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 624k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 624k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 624k, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 624k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 624k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 624k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 624k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 624k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 624k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 624k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 958| 624k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 624k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 624k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 624k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 624k| } \ | | | | 960| 638k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 13.2k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 13.2k| lua_Number n1; lua_Number n2; \ | | | | | | 926| 13.2k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 26.4k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 13.2k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 13.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 13.2k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 13.2k, False: 1] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 13.2k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 13.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 13.2k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 13.2k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 26.4k| (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| 4|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 1] | | | | | | | | | | | | | Branch (136:27): [True: 1, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 13.2k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 13.2k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 13.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 13.2k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 13.2k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 13.2k, False: 1] | | | | | | | | ------------------ | | | | | | | | 58| 13.2k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 13.2k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 13.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 13.2k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 13.2k, False: 1] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 13.2k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 52.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 13.2k] | | | | | | | | | | | | | Branch (136:27): [True: 13.2k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 13.2k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 13.2k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 13.2k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 13.2k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 13.2k| }} | | | | ------------------ | | ------------------ ------------------ 1475| 1.91M| vmbreak; ------------------ | | 16| 638k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 638k|#define vmfetch() { \ | | | | 1139| 638k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 638k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 638k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 638k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 638k| i = *(pc++); \ | | | | 1144| 638k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 638k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1476| 1.91M| } 1477| 7.86k| vmcase(OP_POW) { ------------------ | | 14| 7.86k|#define vmcase(l) L_##l: ------------------ 1478| 15.7k| op_arithf(L, luai_numpow); ------------------ | | 934| 7.86k|#define op_arithf(L,fop) { \ | | 935| 7.86k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 7.86k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 7.86k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 7.86k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 7.86k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 7.86k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 936| 7.86k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 7.86k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 31.4k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 7.86k] | | | | | | | Branch (172:19): [True: 7.86k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 937| 7.86k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 7.86k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 31.4k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 7.86k] | | | | | | | Branch (172:19): [True: 7.86k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 938| 7.86k| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 924| 7.86k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 925| 7.86k| lua_Number n1; lua_Number n2; \ | | | | 926| 7.86k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 15.7k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 7.86k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 7.86k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 7.86k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 0, False: 7.86k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 7.86k, False: 3] | | | | | | ------------------ | | | | | | 58| 15.7k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 7.86k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 7.86k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 7.86k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 7.86k, False: 3] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 7.86k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 31.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (136:27): [True: 0, False: 7.86k] | | | | | | | | | | | Branch (136:27): [True: 7.86k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 7.86k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 7.86k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 7.86k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 7.86k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 5, False: 7.86k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 5|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 110| 5|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 5|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 7.86k, False: 0] | | | | | | ------------------ | | | | | | 58| 7.86k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 7.86k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 7.86k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 7.86k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 7.86k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 7.86k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 31.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (136:27): [True: 0, False: 7.86k] | | | | | | | | | | | Branch (136:27): [True: 7.86k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 927| 7.86k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | ------------------ | | | | | | 339| 15.7k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 72| 7.86k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 114| 7.86k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | | Branch (339:35): [True: 4, False: 7.86k] | | | | | | ------------------ | | | | ------------------ | | | | 928| 7.86k| }} | | ------------------ ------------------ 1479| 15.7k| vmbreak; ------------------ | | 16| 7.86k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 7.86k|#define vmfetch() { \ | | | | 1139| 7.86k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 7.86k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 7.86k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 7.86k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 7.86k| i = *(pc++); \ | | | | 1144| 7.86k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 7.86k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1480| 15.7k| } 1481| 0| vmcase(OP_DIV) { /* float division (always with floats) */ ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1482| 0| op_arithf(L, luai_numdiv); ------------------ | | 934| 0|#define op_arithf(L,fop) { \ | | 935| 0| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 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)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 936| 0| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 0|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 937| 0| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 0|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 938| 0| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 924| 0|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 925| 0| lua_Number n1; lua_Number n2; \ | | | | 926| 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) | | | | | | | | ------------------ | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | 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)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | Branch (136:27): [True: 0, False: 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) | | | | | | | | ------------------ | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | 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)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 927| 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)) | | | | | | ------------------ | | | | ------------------ | | | | 928| 0| }} | | ------------------ ------------------ 1483| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1484| 0| } 1485| 4.64k| vmcase(OP_IDIV) { /* floor division */ ------------------ | | 14| 4.64k|#define vmcase(l) L_##l: ------------------ 1486| 4.64k| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1112| 4.64k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1105| 4.64k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1487| 13.9k| op_arith(L, luaV_idiv, luai_numidiv); ------------------ | | 966| 4.64k|#define op_arith(L,iop,fop) { \ | | 967| 4.64k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 4.64k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 18.5k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 4.64k] | | | | | | | Branch (172:19): [True: 4.64k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 968| 4.64k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 4.64k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 18.5k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 4.64k] | | | | | | | Branch (172:19): [True: 4.64k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 969| 4.64k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 4.64k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 4.64k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 4.64k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 4.64k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 4.64k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 4.64k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 4.64k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 4.64k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 4.64k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 9.28k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 4.64k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 1.15k, False: 3.48k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 1.15k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 1.15k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 1.15k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 1.15k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 1.15k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 1.15k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 1.15k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 1.15k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 1.15k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 1.15k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 1.15k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 958| 1.15k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 1.15k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 1.15k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 1.15k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 1.15k| } \ | | | | 960| 4.64k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 3.48k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 3.48k| lua_Number n1; lua_Number n2; \ | | | | | | 926| 3.48k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 6.96k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 3.48k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 3.48k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 3.48k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 3.48k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 3.48k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 3.48k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 3.48k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 3.48k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 6.96k| (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)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 3.48k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 3.48k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 3.48k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 3.48k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 3, False: 3.48k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 3|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 3|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 3|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 3.48k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 3.48k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 3.48k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 3.48k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 3.48k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 3.48k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 3.48k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 13.9k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (136:27): [True: 0, False: 3.48k] | | | | | | | | | | | | | Branch (136:27): [True: 3.48k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 3.48k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 3.48k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 3.48k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 3.48k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 3.48k| }} | | | | ------------------ | | ------------------ ------------------ 1488| 13.9k| vmbreak; ------------------ | | 16| 4.64k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 4.64k|#define vmfetch() { \ | | | | 1139| 4.64k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 4.64k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 4.64k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 4.64k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 4.64k| i = *(pc++); \ | | | | 1144| 4.64k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 4.64k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1489| 13.9k| } 1490| 5| vmcase(OP_BAND) { ------------------ | | 14| 5|#define vmcase(l) L_##l: ------------------ 1491| 10| op_bitwise(L, l_band); ------------------ | | 998| 5|#define op_bitwise(L,op) { \ | | 999| 5| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 5|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 5|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 5|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 5|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 5|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1000| 5| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 5|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 20|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 5] | | | | | | | Branch (172:19): [True: 5, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1001| 5| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 5|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 20|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 5] | | | | | | | Branch (172:19): [True: 5, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1002| 5| lua_Integer i1; lua_Integer i2; \ | | 1003| 5| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 10| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 5|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 5|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 0, False: 5] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 0, False: 5] | | | | ------------------ | | | | 70| 10| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 5|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 0| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 0|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 0|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 0, False: 0] | | | | ------------------ | | | | 70| 0| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 1004| 0| pc++; setivalue(s2v(ra), op(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)) | | | | ------------------ | | ------------------ | | 1005| 0| }} ------------------ 1492| 10| vmbreak; ------------------ | | 16| 5|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 5|#define vmfetch() { \ | | | | 1139| 5| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 5|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 5|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 5] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 5| i = *(pc++); \ | | | | 1144| 5|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 5|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1493| 10| } 1494| 12.2k| vmcase(OP_BOR) { ------------------ | | 14| 12.2k|#define vmcase(l) L_##l: ------------------ 1495| 24.5k| op_bitwise(L, l_bor); ------------------ | | 998| 12.2k|#define op_bitwise(L,op) { \ | | 999| 12.2k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 12.2k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 12.2k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 12.2k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 12.2k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 12.2k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1000| 12.2k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 12.2k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 49.1k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 12.2k] | | | | | | | Branch (172:19): [True: 12.2k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1001| 12.2k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 12.2k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 49.1k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 12.2k] | | | | | | | Branch (172:19): [True: 12.2k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1002| 12.2k| lua_Integer i1; lua_Integer i2; \ | | 1003| 12.2k| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 24.5k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 12.2k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 12.2k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 11.6k, False: 673] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 11.6k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 11.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 11.6k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 12.2k, False: 2] | | | | ------------------ | | | | 70| 24.5k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 673|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 12.2k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 12.2k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 12.2k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 12.2k, False: 42] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 12.2k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 12.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 12.2k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 12.2k, False: 0] | | | | ------------------ | | | | 70| 12.2k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 42|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 1004| 12.2k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 12.2k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 12.2k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 12.2k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 1005| 12.2k| }} ------------------ 1496| 24.5k| vmbreak; ------------------ | | 16| 12.2k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 12.2k|#define vmfetch() { \ | | | | 1139| 12.2k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 12.2k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 12.2k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 12.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 12.2k| i = *(pc++); \ | | | | 1144| 12.2k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 12.2k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1497| 24.5k| } 1498| 8.88k| vmcase(OP_BXOR) { ------------------ | | 14| 8.88k|#define vmcase(l) L_##l: ------------------ 1499| 17.7k| op_bitwise(L, l_bxor); ------------------ | | 998| 8.88k|#define op_bitwise(L,op) { \ | | 999| 8.88k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 8.88k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 8.88k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 8.88k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 8.88k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 8.88k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1000| 8.88k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 8.88k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 35.5k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 8.88k] | | | | | | | Branch (172:19): [True: 8.88k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1001| 8.88k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 8.88k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 35.5k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 8.88k] | | | | | | | Branch (172:19): [True: 8.88k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1002| 8.88k| lua_Integer i1; lua_Integer i2; \ | | 1003| 8.88k| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 17.7k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 8.88k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 8.88k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 8.39k, False: 486] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 8.39k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 8.39k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 8.39k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 8.88k, False: 0] | | | | ------------------ | | | | 70| 17.7k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 486|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 8.88k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 8.88k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 8.88k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 8.88k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 8.88k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 8.88k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 8.88k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 8.88k, False: 0] | | | | ------------------ | | | | 70| 8.88k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 1004| 8.88k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 8.88k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 8.88k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 8.88k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 1005| 8.88k| }} ------------------ 1500| 17.7k| vmbreak; ------------------ | | 16| 8.88k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 8.88k|#define vmfetch() { \ | | | | 1139| 8.88k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 8.88k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 8.88k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 8.88k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 8.88k| i = *(pc++); \ | | | | 1144| 8.88k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 8.88k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1501| 17.7k| } 1502| 0| vmcase(OP_SHR) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1503| 0| op_bitwise(L, luaV_shiftr); ------------------ | | 998| 0|#define op_bitwise(L,op) { \ | | 999| 0| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 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)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1000| 0| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 0|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1001| 0| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 0|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1002| 0| lua_Integer i1; lua_Integer i2; \ | | 1003| 0| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 0| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 0|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 0|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 0, False: 0] | | | | ------------------ | | | | 70| 0| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 0| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 0|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 0|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 0, False: 0] | | | | ------------------ | | | | 70| 0| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 1004| 0| pc++; setivalue(s2v(ra), op(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)) | | | | ------------------ | | ------------------ | | 1005| 0| }} ------------------ 1504| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1505| 0| } 1506| 50.6k| vmcase(OP_SHL) { ------------------ | | 14| 50.6k|#define vmcase(l) L_##l: ------------------ 1507| 101k| op_bitwise(L, luaV_shiftl); ------------------ | | 998| 50.6k|#define op_bitwise(L,op) { \ | | 999| 50.6k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 50.6k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 50.6k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 50.6k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 50.6k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 50.6k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1000| 50.6k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 50.6k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 202k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 50.6k] | | | | | | | Branch (172:19): [True: 50.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1001| 50.6k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 50.6k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 202k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 50.6k] | | | | | | | Branch (172:19): [True: 50.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1002| 50.6k| lua_Integer i1; lua_Integer i2; \ | | 1003| 50.6k| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 101k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 50.6k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 50.6k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 874, False: 49.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 874|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 874|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 874|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 50.6k, False: 5] | | | | ------------------ | | | | 70| 101k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 49.7k|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 50.6k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 50.6k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 50.6k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 50.6k, False: 7] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 50.6k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 110| 50.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 50.6k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 50.6k, False: 0] | | | | ------------------ | | | | 70| 50.6k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 7|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 1004| 50.6k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 50.6k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 50.6k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 50.6k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 1005| 50.6k| }} ------------------ 1508| 101k| vmbreak; ------------------ | | 16| 50.6k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 50.6k|#define vmfetch() { \ | | | | 1139| 50.6k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 50.6k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 50.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 50.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 50.6k| i = *(pc++); \ | | | | 1144| 50.6k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 50.6k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1509| 101k| } 1510| 16| vmcase(OP_MMBIN) { ------------------ | | 14| 16|#define vmcase(l) L_##l: ------------------ 1511| 16| StkId ra = RA(i); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1512| 16| Instruction pi = *(pc - 2); /* original arith. expression */ 1513| 16| TValue *rb = vRB(i); ------------------ | | 1066| 16|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 64|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 16] | | | | | Branch (172:19): [True: 16, False: 0] | | | | ------------------ | | ------------------ ------------------ 1514| 16| TMS tm = (TMS)GETARG_C(i); ------------------ | | 132| 16|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 110| 16|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 16|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1515| 16| StkId result = RA(pi); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1516| 16| lua_assert(OP_ADD <= GET_OPCODE(pi) && GET_OPCODE(pi) <= OP_SHR); ------------------ | | 106| 16|#define lua_assert(c) assert(c) ------------------ 1517| 16| Protect(luaT_trybinTM(L, s2v(ra), rb, result, tm)); ------------------ | | 1119| 16|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 16|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 16|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 16|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1518| 16| vmbreak; ------------------ | | 16| 16|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 16|#define vmfetch() { \ | | | | 1139| 16| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 16|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 16|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 16] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 16| i = *(pc++); \ | | | | 1144| 16|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 16|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1519| 16| } 1520| 0| vmcase(OP_MMBINI) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1521| 0| StkId ra = RA(i); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1522| 0| Instruction pi = *(pc - 2); /* original arith. expression */ 1523| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1527| 0| Protect(luaT_trybiniTM(L, s2v(ra), imm, flip, result, tm)); ------------------ | | 1119| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1528| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1529| 0| } 1530| 1| vmcase(OP_MMBINK) { ------------------ | | 14| 1|#define vmcase(l) L_##l: ------------------ 1531| 1| StkId ra = RA(i); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1532| 1| Instruction pi = *(pc - 2); /* original arith. expression */ 1533| 1| TValue *imm = KB(i); ------------------ | | 1067| 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)) | | | | ------------------ | | | | | | 110| 1|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 1|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1534| 1| TMS tm = (TMS)GETARG_C(i); ------------------ | | 132| 1|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 110| 1|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 1|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1535| 1| int flip = GETARG_k(i); ------------------ | | 137| 1|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | ------------------ | | | | 110| 1|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 1|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1536| 1| StkId result = RA(pi); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1537| 1| Protect(luaT_trybinassocTM(L, s2v(ra), imm, flip, result, tm)); ------------------ | | 1119| 1|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 1|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 1|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 1|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1538| 1| vmbreak; ------------------ | | 16| 1|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 1|#define vmfetch() { \ | | | | 1139| 1| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 1| i = *(pc++); \ | | | | 1144| 1|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1539| 1| } 1540| 90.9k| vmcase(OP_UNM) { ------------------ | | 14| 90.9k|#define vmcase(l) L_##l: ------------------ 1541| 90.9k| StkId ra = RA(i); ------------------ | | 1064| 90.9k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 90.9k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 90.9k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 90.9k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 90.9k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1542| 90.9k| TValue *rb = vRB(i); ------------------ | | 1066| 90.9k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 363k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 90.9k] | | | | | Branch (172:19): [True: 90.9k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1543| 0| lua_Number nb; 1544| 90.9k| if (ttisinteger(rb)) { ------------------ | | 328| 90.9k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 90.9k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 90.9k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 90.9k, False: 4] | | | | ------------------ | | ------------------ ------------------ 1545| 90.9k| lua_Integer ib = ivalue(rb); ------------------ | | 333| 90.9k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 90.9k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 90.9k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1546| 90.9k| setivalue(s2v(ra), intop(-, 0, ib)); ------------------ | | 345| 90.9k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 90.9k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 90.9k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1547| 90.9k| } 1548| 4| else if (tonumberns(rb, nb)) { ------------------ | | 57| 4| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 4|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 4|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 4|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 4] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 0, False: 4] | | ------------------ | | 58| 4| (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)) | | | | | | ------------------ | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | | Branch (136:27): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1549| 0| setfltvalue(s2v(ra), luai_numunm(L, nb)); ------------------ | | 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)) | | ------------------ ------------------ 1550| 0| } 1551| 4| else 1552| 4| Protect(luaT_trybinTM(L, rb, rb, ra, TM_UNM)); ------------------ | | 1119| 4|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 4|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 4|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 4|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1553| 90.9k| vmbreak; ------------------ | | 16| 90.9k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 90.9k|#define vmfetch() { \ | | | | 1139| 90.9k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 90.9k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 90.9k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 90.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 90.9k| i = *(pc++); \ | | | | 1144| 90.9k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 90.9k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1554| 90.9k| } 1555| 8.11k| vmcase(OP_BNOT) { ------------------ | | 14| 8.11k|#define vmcase(l) L_##l: ------------------ 1556| 8.11k| StkId ra = RA(i); ------------------ | | 1064| 8.11k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 8.11k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 8.11k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 8.11k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 8.11k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1557| 8.11k| TValue *rb = vRB(i); ------------------ | | 1066| 8.11k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 32.4k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 8.11k] | | | | | Branch (172:19): [True: 8.11k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1558| 0| lua_Integer ib; 1559| 8.11k| if (tointegerns(rb, &ib)) { ------------------ | | 69| 8.11k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 696| 8.11k|#define l_likely(x) luai_likely(x) | | | | ------------------ | | | | | | 684| 8.11k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | ------------------ | | | | | | | Branch (684:25): [True: 8.10k, False: 8] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 333| 8.10k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 110| 8.10k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 8.10k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (69:3): [True: 8.10k, False: 8] | | ------------------ | | 70| 8.11k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | ------------------ | | | | 36| 8|#define LUA_FLOORN2I F2Ieq | | ------------------ ------------------ 1560| 8.10k| setivalue(s2v(ra), intop(^, ~l_castS2U(0), ib)); ------------------ | | 345| 8.10k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 8.10k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 8.10k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1561| 8.10k| } 1562| 8| else 1563| 8| Protect(luaT_trybinTM(L, rb, rb, ra, TM_BNOT)); ------------------ | | 1119| 8|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 8|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 8|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 8|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1564| 8.11k| vmbreak; ------------------ | | 16| 8.11k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 8.11k|#define vmfetch() { \ | | | | 1139| 8.11k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 8.11k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 8.11k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 8.11k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 8.11k| i = *(pc++); \ | | | | 1144| 8.11k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 8.11k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1565| 8.11k| } 1566| 129k| vmcase(OP_NOT) { ------------------ | | 14| 129k|#define vmcase(l) L_##l: ------------------ 1567| 129k| StkId ra = RA(i); ------------------ | | 1064| 129k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 129k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 129k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 129k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 129k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1568| 129k| TValue *rb = vRB(i); ------------------ | | 1066| 129k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 519k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 129k] | | | | | Branch (172:19): [True: 129k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1569| 129k| if (l_isfalse(rb)) ------------------ | | 247| 129k|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 129k|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 259k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 129k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 129k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 193| 129k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 129k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 129k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 129k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 17.8k, False: 112k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1570| 129k| setbtvalue(s2v(ra)); ------------------ | | 251| 17.8k|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 17.8k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1571| 112k| else 1572| 129k| setbfvalue(s2v(ra)); ------------------ | | 250| 112k|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 112k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1573| 129k| vmbreak; ------------------ | | 16| 129k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 129k|#define vmfetch() { \ | | | | 1139| 129k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 129k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 129k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 129k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 129k| i = *(pc++); \ | | | | 1144| 129k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 129k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1574| 129k| } 1575| 138k| vmcase(OP_LEN) { ------------------ | | 14| 138k|#define vmcase(l) L_##l: ------------------ 1576| 138k| StkId ra = RA(i); ------------------ | | 1064| 138k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 138k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 138k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 138k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 138k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1577| 138k| Protect(luaV_objlen(L, ra, vRB(i))); ------------------ | | 1119| 553k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 138k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 138k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 138k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ | | | Branch (1119:42): [True: 0, False: 138k] | | | Branch (1119:42): [True: 138k, False: 0] | | ------------------ ------------------ 1578| 138k| vmbreak; ------------------ | | 16| 138k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 138k|#define vmfetch() { \ | | | | 1139| 138k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 138k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 138k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 138k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 138k| i = *(pc++); \ | | | | 1144| 138k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 138k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1579| 138k| } 1580| 103k| vmcase(OP_CONCAT) { ------------------ | | 14| 103k|#define vmcase(l) L_##l: ------------------ 1581| 103k| StkId ra = RA(i); ------------------ | | 1064| 103k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 103k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 103k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 103k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 103k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1582| 103k| int n = GETARG_B(i); /* number of elements to concatenate */ ------------------ | | 128| 103k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 103k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 103k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1583| 0| L->top.p = ra + n; /* mark the end of concat operands */ 1584| 103k| ProtectNT(luaV_concat(L, n)); ------------------ | | 1122| 103k|#define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1105| 103k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ | | #define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 103k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1585| 103k| checkGC(L, L->top.p); /* 'luaV_concat' ensures correct top */ ------------------ | | 1132| 103k| { luaC_condGC(L, (savepc(L), L->top.p = (c)), \ | | ------------------ | | | | 168| 103k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 103k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 78, False: 103k] | | | | ------------------ | | | | 169| 103k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 103k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 1133| 103k| updatetrap(ci)); \ | | 1134| 103k| luai_threadyield(L); } | | ------------------ | | | | 273| 103k|#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 265| 103k|#define lua_unlock(L) ((void) 0) | | | | ------------------ | | | | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 264| 103k|#define lua_lock(L) ((void) 0) | | | | ------------------ | | ------------------ ------------------ 1586| 103k| vmbreak; ------------------ | | 16| 103k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 103k|#define vmfetch() { \ | | | | 1139| 103k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 103k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 103k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 6, False: 103k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 6| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 6| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 6|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 6| } \ | | | | 1143| 103k| i = *(pc++); \ | | | | 1144| 103k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 103k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1587| 103k| } 1588| 13.4k| vmcase(OP_CLOSE) { ------------------ | | 14| 13.4k|#define vmcase(l) L_##l: ------------------ 1589| 13.4k| StkId ra = RA(i); ------------------ | | 1064| 13.4k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 13.4k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 13.4k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 13.4k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 13.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1590| 13.4k| Protect(luaF_close(L, ra, LUA_OK, 1)); ------------------ | | 1119| 13.4k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 13.4k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 13.4k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 13.4k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1591| 13.4k| vmbreak; ------------------ | | 16| 13.4k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 13.4k|#define vmfetch() { \ | | | | 1139| 13.4k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 13.4k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 13.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 13.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 13.4k| i = *(pc++); \ | | | | 1144| 13.4k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 13.4k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1592| 13.4k| } 1593| 13.4k| vmcase(OP_TBC) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1594| 0| StkId ra = RA(i); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1595| | /* create new to-be-closed upvalue */ 1596| 0| halfProtect(luaF_newtbcupval(L, ra)); ------------------ | | 1128| 0|#define halfProtect(exp) (savestate(L,ci), (exp)) | | ------------------ | | | | 1112| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ ------------------ 1597| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1598| 0| } 1599| 14.1k| vmcase(OP_JMP) { ------------------ | | 14| 14.1k|#define vmcase(l) L_##l: ------------------ 1600| 14.1k| dojump(ci, i, 0); ------------------ | | 1088| 14.1k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | ------------------ | | | | 151| 14.1k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | ------------------ | | | | | | 110| 14.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 14.1k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | ------------------ | | | | 1075| 14.1k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1601| 14.1k| vmbreak; ------------------ | | 16| 14.1k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 14.1k|#define vmfetch() { \ | | | | 1139| 14.1k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 14.1k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 14.1k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 14.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 14.1k| i = *(pc++); \ | | | | 1144| 14.1k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 14.1k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1602| 14.1k| } 1603| 42.0k| vmcase(OP_EQ) { ------------------ | | 14| 42.0k|#define vmcase(l) L_##l: ------------------ 1604| 42.0k| StkId ra = RA(i); ------------------ | | 1064| 42.0k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 42.0k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 42.0k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 42.0k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 42.0k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1605| 42.0k| int cond; 1606| 42.0k| TValue *rb = vRB(i); ------------------ | | 1066| 42.0k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 168k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 42.0k] | | | | | Branch (172:19): [True: 42.0k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1607| 42.0k| Protect(cond = luaV_equalobj(L, s2v(ra), rb)); ------------------ | | 1119| 42.0k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 42.0k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 42.0k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 42.0k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1608| 42.0k| docondjump(); ------------------ | | 1099| 42.0k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 42.0k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 110| 42.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 42.0k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1092| 0|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1088| 0|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 0| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1099:26): [True: 42.0k, False: 0] | | ------------------ ------------------ 1609| 42.0k| vmbreak; ------------------ | | 16| 42.0k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 42.0k|#define vmfetch() { \ | | | | 1139| 42.0k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 42.0k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 42.0k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 42.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 42.0k| i = *(pc++); \ | | | | 1144| 42.0k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 42.0k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1610| 42.0k| } 1611| 200k| vmcase(OP_LT) { ------------------ | | 14| 200k|#define vmcase(l) L_##l: ------------------ 1612| 602k| op_order(L, l_lti, LTnum, lessthanothers); ------------------ | | 1013| 200k|#define op_order(L,opi,opn,other) { \ | | 1014| 200k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 200k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 200k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 200k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 200k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 200k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1015| 200k| int cond; \ | | 1016| 200k| TValue *rb = vRB(i); \ | | ------------------ | | | | 1066| 200k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 803k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 200k] | | | | | | | Branch (172:19): [True: 200k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1017| 200k| if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 328| 200k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 401k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 200k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 165k, False: 35.2k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1018| 165k| lua_Integer ia = ivalue(s2v(ra)); \ | | ------------------ | | | | 333| 165k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 110| 165k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 165k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1019| 165k| lua_Integer ib = ivalue(rb); \ | | ------------------ | | | | 333| 165k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 110| 165k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 165k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1020| 165k| cond = opi(ia, ib); \ | | ------------------ | | | | 1612| 165k| op_order(L, l_lti, LTnum, lessthanothers); | | | | ------------------ | | | | | | 895| 165k|#define l_lti(a,b) (a < b) | | | | ------------------ | | ------------------ | | 1021| 165k| } \ | | 1022| 200k| else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 326| 35.2k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 70.4k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 35.2k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 35.2k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 31.2k, False: 4.01k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 326| 31.2k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 31.2k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 31.2k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 31.2k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 31.2k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1023| 35.2k| cond = opn(s2v(ra), rb); \ | | ------------------ | | | | 172| 31.2k|#define s2v(o) (&(o)->val) | | ------------------ | | 1024| 35.2k| else \ | | 1025| 35.2k| Protect(cond = other(L, s2v(ra), rb)); \ | | ------------------ | | | | 1119| 4.01k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1112| 4.01k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1105| 4.01k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1075| 4.01k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1026| 200k| docondjump(); } | | ------------------ | | | | 1099| 200k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 200k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 110| 200k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 200k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1092| 137k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1088| 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) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 137k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 137k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1075| 137k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1099:26): [True: 63.6k, False: 137k] | | | | ------------------ | | ------------------ ------------------ 1613| 602k| vmbreak; ------------------ | | 16| 200k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 200k|#define vmfetch() { \ | | | | 1139| 200k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 200k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 200k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 200k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 200k| i = *(pc++); \ | | | | 1144| 200k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 200k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1614| 602k| } 1615| 388| vmcase(OP_LE) { ------------------ | | 14| 388|#define vmcase(l) L_##l: ------------------ 1616| 1.16k| op_order(L, l_lei, LEnum, lessequalothers); ------------------ | | 1013| 388|#define op_order(L,opi,opn,other) { \ | | 1014| 388| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 388|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 388|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 388|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 388|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 388|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1015| 388| int cond; \ | | 1016| 388| TValue *rb = vRB(i); \ | | ------------------ | | | | 1066| 388|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 1.55k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 388] | | | | | | | Branch (172:19): [True: 388, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1017| 388| if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 328| 388|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 776|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 388|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 290, False: 98] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 328| 290|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 290|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 290|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 290, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1018| 290| lua_Integer ia = ivalue(s2v(ra)); \ | | ------------------ | | | | 333| 290|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 110| 290|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 290|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1019| 290| lua_Integer ib = ivalue(rb); \ | | ------------------ | | | | 333| 290|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 110| 290|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 290|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1020| 290| cond = opi(ia, ib); \ | | ------------------ | | | | 1616| 290| op_order(L, l_lei, LEnum, lessequalothers); | | | | ------------------ | | | | | | 896| 290|#define l_lei(a,b) (a <= b) | | | | ------------------ | | ------------------ | | 1021| 290| } \ | | 1022| 388| else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 326| 98|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 196|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 98|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 98|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 98, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 326| 98|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 98|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 98|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 98|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 98, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1023| 98| cond = opn(s2v(ra), rb); \ | | ------------------ | | | | 172| 98|#define s2v(o) (&(o)->val) | | ------------------ | | 1024| 98| else \ | | 1025| 98| Protect(cond = other(L, s2v(ra), rb)); \ | | ------------------ | | | | 1119| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1112| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1026| 388| docondjump(); } | | ------------------ | | | | 1099| 388|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 388|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 110| 388|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 388|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1092| 371|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1088| 371|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 371| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 371|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 371|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1075| 371|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1099:26): [True: 17, False: 371] | | | | ------------------ | | ------------------ ------------------ 1617| 1.16k| vmbreak; ------------------ | | 16| 388|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 388|#define vmfetch() { \ | | | | 1139| 388| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 388|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 388|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 388] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 388| i = *(pc++); \ | | | | 1144| 388|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 388|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1618| 1.16k| } 1619| 25.4k| vmcase(OP_EQK) { ------------------ | | 14| 25.4k|#define vmcase(l) L_##l: ------------------ 1620| 25.4k| StkId ra = RA(i); ------------------ | | 1064| 25.4k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 25.4k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 25.4k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 25.4k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 25.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1621| 25.4k| TValue *rb = KB(i); ------------------ | | 1067| 25.4k|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 25.4k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 110| 25.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 25.4k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1622| | /* basic types do not use '__eq'; we can use raw equality */ 1623| 25.4k| int cond = luaV_rawequalobj(s2v(ra), rb); ------------------ | | 75| 25.4k|#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2) ------------------ 1624| 25.4k| docondjump(); ------------------ | | 1099| 25.4k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 25.4k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 110| 25.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 25.4k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1092| 15.9k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1088| 15.9k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 15.9k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 110| 15.9k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 15.9k|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1075| 15.9k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1099:26): [True: 9.55k, False: 15.9k] | | ------------------ ------------------ 1625| 25.4k| vmbreak; ------------------ | | 16| 25.4k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 25.4k|#define vmfetch() { \ | | | | 1139| 25.4k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 25.4k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 25.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 25.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 25.4k| i = *(pc++); \ | | | | 1144| 25.4k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 25.4k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1626| 25.4k| } 1627| 4| vmcase(OP_EQI) { ------------------ | | 14| 4|#define vmcase(l) L_##l: ------------------ 1628| 4| StkId ra = RA(i); ------------------ | | 1064| 4|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 4|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 4|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 4|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 4|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1629| 4| int cond; 1630| 4| int im = GETARG_sB(i); ------------------ | | 129| 4|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | ------------------ | | | | 101| 16|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 4|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 4|#define MAXARG_C ((1<tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 4] | | | | ------------------ | | ------------------ ------------------ 1632| 0| cond = (ivalue(s2v(ra)) == im); ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1633| 4| else if (ttisfloat(s2v(ra))) ------------------ | | 327| 4|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 4|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 4|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 4] | | | | ------------------ | | ------------------ ------------------ 1634| 0| cond = luai_numeq(fltvalue(s2v(ra)), cast_num(im)); ------------------ | | 350| 0|#define luai_numeq(a,b) ((a)==(b)) | | ------------------ | | | Branch (350:35): [True: 0, False: 0] | | | Branch (350:35): [True: 0, False: 0] | | ------------------ ------------------ 1635| 4| else 1636| 4| cond = 0; /* other types cannot be equal to a number */ 1637| 8| docondjump(); ------------------ | | 1099| 4|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 4|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 110| 4|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 4|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1092| 0|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1088| 0|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 0| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1099:26): [True: 4, False: 0] | | ------------------ ------------------ 1638| 8| vmbreak; ------------------ | | 16| 4|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 4|#define vmfetch() { \ | | | | 1139| 4| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 4|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 4|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 4| i = *(pc++); \ | | | | 1144| 4|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 4|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1639| 8| } 1640| 0| vmcase(OP_LTI) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1641| 0| op_orderI(L, l_lti, luai_numlt, 0, TM_LT); ------------------ | | 1033| 0|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1034| 0| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 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)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 0| int cond; \ | | 1036| 0| int im = 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<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1038| 0| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1641| 0| op_orderI(L, l_lti, luai_numlt, 0, TM_LT); | | | | ------------------ | | | | | | 895| 0|#define l_lti(a,b) (a < b) | | | | | | ------------------ | | | | | | | Branch (895:21): [True: 0, False: 0] | | | | | | | Branch (895:21): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1039| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1040| 0| lua_Number fa = fltvalue(s2v(ra)); \ | | ------------------ | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1041| 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)) | | | | ------------------ | | ------------------ | | 1042| 0| cond = opf(fa, fim); \ | | ------------------ | | | | 1641| 0| op_orderI(L, l_lti, luai_numlt, 0, TM_LT); | | | | ------------------ | | | | | | 351| 0|#define luai_numlt(a,b) ((a)<(b)) | | | | ------------------ | | ------------------ | | 1043| 0| } \ | | 1044| 0| else { \ | | 1045| 0| int isf = GETARG_C(i); \ | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1046| 0| Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \ | | ------------------ | | | | 1119| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1112| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1047| 0| } \ | | 1048| 0| docondjump(); } | | ------------------ | | | | 1099| 0|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 0|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1092| 0|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1088| 0|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 0| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1099:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1642| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1643| 0| } 1644| 113k| vmcase(OP_LEI) { ------------------ | | 14| 113k|#define vmcase(l) L_##l: ------------------ 1645| 341k| op_orderI(L, l_lei, luai_numle, 0, TM_LE); ------------------ | | 1033| 113k|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1034| 113k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 113k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 113k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 113k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 113k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 113k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 113k| int cond; \ | | 1036| 113k| int im = GETARG_sB(i); \ | | ------------------ | | | | 129| 113k|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | | | ------------------ | | | | | | 101| 455k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 113k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 113k|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 113k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1038| 113k| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1645| 113k| op_orderI(L, l_lei, luai_numle, 0, TM_LE); | | | | ------------------ | | | | | | 896| 455k|#define l_lei(a,b) (a <= b) | | | | | | ------------------ | | | | | | | Branch (896:21): [True: 0, False: 113k] | | | | | | | Branch (896:21): [True: 113k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1039| 113k| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1040| 0| lua_Number fa = fltvalue(s2v(ra)); \ | | ------------------ | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1041| 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)) | | | | ------------------ | | ------------------ | | 1042| 0| cond = opf(fa, fim); \ | | ------------------ | | | | 1645| 0| op_orderI(L, l_lei, luai_numle, 0, TM_LE); | | | | ------------------ | | | | | | 352| 0|#define luai_numle(a,b) ((a)<=(b)) | | | | ------------------ | | ------------------ | | 1043| 0| } \ | | 1044| 0| else { \ | | 1045| 0| int isf = GETARG_C(i); \ | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1046| 0| Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \ | | ------------------ | | | | 1119| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1112| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1047| 0| } \ | | 1048| 113k| docondjump(); } | | ------------------ | | | | 1099| 113k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 113k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 110| 113k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 113k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1092| 85.2k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1088| 85.2k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 85.2k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 85.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 85.2k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1075| 85.2k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1099:26): [True: 28.6k, False: 85.2k] | | | | ------------------ | | ------------------ ------------------ 1646| 341k| vmbreak; ------------------ | | 16| 113k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 113k|#define vmfetch() { \ | | | | 1139| 113k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 113k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 113k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 79, False: 113k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 79| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 79| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 79|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 79| } \ | | | | 1143| 113k| i = *(pc++); \ | | | | 1144| 113k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 113k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1647| 341k| } 1648| 67.5k| vmcase(OP_GTI) { ------------------ | | 14| 67.5k|#define vmcase(l) L_##l: ------------------ 1649| 202k| op_orderI(L, l_gti, luai_numgt, 1, TM_LT); ------------------ | | 1033| 67.5k|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1034| 67.5k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 67.5k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 67.5k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 67.5k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 67.5k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 67.5k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 67.5k| int cond; \ | | 1036| 67.5k| int im = GETARG_sB(i); \ | | ------------------ | | | | 129| 67.5k|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | | | ------------------ | | | | | | 101| 270k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 67.5k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 67.5k|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 67.5k, False: 2] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1038| 67.5k| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1649| 67.5k| op_orderI(L, l_gti, luai_numgt, 1, TM_LT); | | | | ------------------ | | | | | | 897| 270k|#define l_gti(a,b) (a > b) | | | | | | ------------------ | | | | | | | Branch (897:21): [True: 0, False: 67.5k] | | | | | | | Branch (897:21): [True: 67.5k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1039| 67.5k| else if (ttisfloat(s2v(ra))) { \ | | ------------------ | | | | 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1040| 0| lua_Number fa = fltvalue(s2v(ra)); \ | | ------------------ | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1041| 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)) | | | | ------------------ | | ------------------ | | 1042| 0| cond = opf(fa, fim); \ | | ------------------ | | | | 1649| 0| op_orderI(L, l_gti, luai_numgt, 1, TM_LT); | | | | ------------------ | | | | | | 353| 0|#define luai_numgt(a,b) ((a)>(b)) | | | | ------------------ | | ------------------ | | 1043| 0| } \ | | 1044| 2| else { \ | | 1045| 2| int isf = GETARG_C(i); \ | | ------------------ | | | | 132| 2|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 110| 2|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 2|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1046| 2| Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \ | | ------------------ | | | | 1119| 2|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1112| 2|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1105| 2|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1075| 2|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1047| 2| } \ | | 1048| 67.5k| docondjump(); } | | ------------------ | | | | 1099| 67.5k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 67.5k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 110| 67.5k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 67.5k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1092| 448|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1088| 448|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 448| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 448|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 448|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1075| 446|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1099:26): [True: 67.0k, False: 448] | | | | ------------------ | | ------------------ ------------------ 1650| 202k| vmbreak; ------------------ | | 16| 67.5k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 67.5k|#define vmfetch() { \ | | | | 1139| 67.5k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 67.5k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 67.5k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 67.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 67.5k| i = *(pc++); \ | | | | 1144| 67.5k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 67.5k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1651| 202k| } 1652| 0| vmcase(OP_GEI) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1653| 0| op_orderI(L, l_gei, luai_numge, 1, TM_LE); ------------------ | | 1033| 0|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1034| 0| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 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)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 0| int cond; \ | | 1036| 0| int im = 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<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1038| 0| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1653| 0| op_orderI(L, l_gei, luai_numge, 1, TM_LE); | | | | ------------------ | | | | | | 898| 0|#define l_gei(a,b) (a >= b) | | | | | | ------------------ | | | | | | | Branch (898:21): [True: 0, False: 0] | | | | | | | Branch (898:21): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1039| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1040| 0| lua_Number fa = fltvalue(s2v(ra)); \ | | ------------------ | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1041| 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)) | | | | ------------------ | | ------------------ | | 1042| 0| cond = opf(fa, fim); \ | | ------------------ | | | | 1653| 0| op_orderI(L, l_gei, luai_numge, 1, TM_LE); | | | | ------------------ | | | | | | 354| 0|#define luai_numge(a,b) ((a)>=(b)) | | | | ------------------ | | ------------------ | | 1043| 0| } \ | | 1044| 0| else { \ | | 1045| 0| int isf = GETARG_C(i); \ | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1046| 0| Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \ | | ------------------ | | | | 1119| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1112| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1047| 0| } \ | | 1048| 0| docondjump(); } | | ------------------ | | | | 1099| 0|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 0|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1092| 0|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1088| 0|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 0| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1099:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1654| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1655| 0| } 1656| 201k| vmcase(OP_TEST) { ------------------ | | 14| 201k|#define vmcase(l) L_##l: ------------------ 1657| 201k| StkId ra = RA(i); ------------------ | | 1064| 201k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 201k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 201k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 201k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 201k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1658| 201k| int cond = !l_isfalse(s2v(ra)); ------------------ | | 247| 201k|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 201k|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 403k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 201k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 201k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 193| 201k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 201k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 201k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 201k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 10.3k, False: 191k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1659| 201k| docondjump(); ------------------ | | 1099| 201k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 201k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 110| 201k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 201k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1092| 10.3k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1088| 10.3k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 10.3k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 110| 10.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 106| 10.3k|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1075| 10.3k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1099:26): [True: 191k, False: 10.3k] | | ------------------ ------------------ 1660| 201k| vmbreak; ------------------ | | 16| 201k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 201k|#define vmfetch() { \ | | | | 1139| 201k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 201k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 201k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 201k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 201k| i = *(pc++); \ | | | | 1144| 201k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 201k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1661| 201k| } 1662| 10.1k| vmcase(OP_TESTSET) { ------------------ | | 14| 10.1k|#define vmcase(l) L_##l: ------------------ 1663| 10.1k| StkId ra = RA(i); ------------------ | | 1064| 10.1k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 10.1k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 10.1k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 10.1k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 10.1k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1664| 10.1k| TValue *rb = vRB(i); ------------------ | | 1066| 10.1k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 40.7k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 10.1k] | | | | | Branch (172:19): [True: 10.1k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1665| 10.1k| if (l_isfalse(rb) == GETARG_k(i)) ------------------ | | 247| 10.1k|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 10.1k|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 20.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 10.1k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 10.1k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 193| 10.1k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 10.1k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 10.1k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 10.1k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 10.1k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (l_isfalse(rb) == GETARG_k(i)) ------------------ | | 137| 10.1k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | ------------------ | | | | 110| 10.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 10.1k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (1665:13): [True: 0, False: 10.1k] ------------------ 1666| 0| pc++; 1667| 10.1k| else { 1668| 10.1k| setobj2s(L, ra, rb); ------------------ | | 131| 10.1k|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 10.1k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 10.1k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 10.1k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 10.1k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 10.1k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 162k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 10.1k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 10.1k] | | | | | | | | | Branch (112:29): [True: 10.1k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 10.1k] | | | | | | | | | Branch (112:29): [True: 10.1k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 10.1k] | | | | | | | | | Branch (112:29): [True: 10.1k, False: 0] | | | | | | | | | Branch (112:29): [True: 10.1k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 10.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 10.1k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 10.1k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1669| 10.1k| donextjump(ci); ------------------ | | 1092| 10.1k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | ------------------ | | | | 1088| 10.1k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | ------------------ | | | | | | 151| 10.1k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | ------------------ | | | | | | | | 110| 10.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 10.1k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | ------------------ | | | | | | 1075| 10.1k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ ------------------ 1670| 10.1k| } 1671| 10.1k| vmbreak; ------------------ | | 16| 10.1k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 10.1k|#define vmfetch() { \ | | | | 1139| 10.1k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 10.1k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 10.1k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 9, False: 10.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 9| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 9| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 9|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 9| } \ | | | | 1143| 10.1k| i = *(pc++); \ | | | | 1144| 10.1k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 10.1k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1672| 10.1k| } 1673| 1.00M| vmcase(OP_CALL) { ------------------ | | 14| 1.00M|#define vmcase(l) L_##l: ------------------ 1674| 1.00M| StkId ra = RA(i); ------------------ | | 1064| 1.00M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1.00M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1.00M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 1.00M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1.00M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1675| 1.00M| CallInfo *newci; 1676| 1.00M| int b = GETARG_B(i); ------------------ | | 128| 1.00M|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 1.00M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 1.00M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1677| 1.00M| int nresults = GETARG_C(i) - 1; ------------------ | | 132| 1.00M|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 110| 1.00M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 1.00M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1678| 1.00M| if (b != 0) /* fixed number of arguments? */ ------------------ | Branch (1678:13): [True: 1.00M, False: 0] ------------------ 1679| 1.00M| L->top.p = ra + b; /* top signals number of arguments */ 1680| | /* else previous instruction set top */ 1681| 1.00M| savepc(L); /* in case of errors */ ------------------ | | 1105| 1.00M|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1682| 1.00M| if ((newci = luaD_precall(L, ra, nresults)) == NULL) ------------------ | Branch (1682:13): [True: 0, False: 1.00M] ------------------ 1683| 0| updatetrap(ci); /* C call; nothing else to be done */ ------------------ | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1684| 1.00M| else { /* Lua call: run function in this same C frame */ 1685| 1.00M| ci = newci; 1686| 1.00M| goto startfunc; 1687| 1.00M| } 1688| 1.00M| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1689| 0| } 1690| 72.4k| vmcase(OP_TAILCALL) { ------------------ | | 14| 72.4k|#define vmcase(l) L_##l: ------------------ 1691| 72.4k| StkId ra = RA(i); ------------------ | | 1064| 72.4k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 72.4k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 72.4k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 72.4k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 72.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1692| 72.4k| int b = GETARG_B(i); /* number of arguments + 1 (function) */ ------------------ | | 128| 72.4k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 72.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 72.4k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1693| 0| int n; /* number of results when calling a C function */ 1694| 72.4k| int nparams1 = GETARG_C(i); ------------------ | | 132| 72.4k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 110| 72.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 72.4k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1695| | /* delta is virtual 'func' - real 'func' (vararg functions) */ 1696| 72.4k| int delta = (nparams1) ? ci->u.l.nextraargs + nparams1 : 0; ------------------ | Branch (1696:21): [True: 0, False: 72.4k] ------------------ 1697| 72.4k| if (b != 0) ------------------ | Branch (1697:13): [True: 72.4k, False: 0] ------------------ 1698| 72.4k| L->top.p = ra + b; 1699| 0| else /* previous instruction set top */ 1700| 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)) | | ------------------ ------------------ 1701| 72.4k| savepc(ci); /* several calls here can raise errors */ ------------------ | | 1105| 72.4k|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1702| 72.4k| if (TESTARG_k(i)) { ------------------ | | 136| 72.4k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 110| 72.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 72.4k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:25): [True: 72.4k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1703| 72.4k| luaF_closeupval(L, base); /* close upvalues from current call */ 1704| 72.4k| lua_assert(L->tbclist.p < base); /* no pending tbc variables */ ------------------ | | 106| 72.4k|#define lua_assert(c) assert(c) ------------------ 1705| 72.4k| lua_assert(base == ci->func.p + 1); ------------------ | | 106| 72.4k|#define lua_assert(c) assert(c) ------------------ 1706| 72.4k| } 1707| 72.4k| if ((n = luaD_pretailcall(L, ci, ra, b, delta)) < 0) /* Lua function? */ ------------------ | Branch (1707:13): [True: 72.4k, False: 0] ------------------ 1708| 72.4k| goto startfunc; /* execute the callee */ 1709| 0| else { /* C function? */ 1710| 0| ci->func.p -= delta; /* restore 'func' (if vararg) */ 1711| 0| luaD_poscall(L, ci, n); /* finish caller */ 1712| 0| updatetrap(ci); /* 'luaD_poscall' can change hooks */ ------------------ | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1713| 0| goto ret; /* caller returns after the tail call */ 1714| 0| } 1715| 72.4k| } 1716| 809k| vmcase(OP_RETURN) { ------------------ | | 14| 809k|#define vmcase(l) L_##l: ------------------ 1717| 809k| StkId ra = RA(i); ------------------ | | 1064| 809k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 809k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 809k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 809k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 809k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1718| 809k| int n = GETARG_B(i) - 1; /* number of results */ ------------------ | | 128| 809k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 809k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 809k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1719| 809k| int nparams1 = GETARG_C(i); ------------------ | | 132| 809k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 110| 809k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 809k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1720| 809k| if (n < 0) /* not fixed? */ ------------------ | Branch (1720:13): [True: 10.1k, False: 799k] ------------------ 1721| 10.1k| n = cast_int(L->top.p - ra); /* get what is available */ ------------------ | | 141| 10.1k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 10.1k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1722| 809k| savepc(ci); ------------------ | | 1105| 809k|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1723| 809k| if (TESTARG_k(i)) { /* may there be open upvalues? */ ------------------ | | 136| 809k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 110| 809k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 809k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:25): [True: 10.1k, False: 799k] | | | | ------------------ | | ------------------ ------------------ 1724| 10.1k| ci->u2.nres = n; /* save number of returns */ 1725| 10.1k| if (L->top.p < ci->top.p) ------------------ | Branch (1725:15): [True: 10.1k, False: 3] ------------------ 1726| 10.1k| L->top.p = ci->top.p; 1727| 10.1k| luaF_close(L, base, CLOSEKTOP, 1); ------------------ | | 47| 10.1k|#define CLOSEKTOP (-1) ------------------ 1728| 10.1k| updatetrap(ci); ------------------ | | 1075| 10.1k|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1729| 10.1k| updatestack(ci); ------------------ | | 1081| 10.1k| { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 697| 10.1k|#define l_unlikely(x) luai_unlikely(x) | | | | ------------------ | | | | | | 685| 10.1k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | ------------------ | | | | | | | Branch (685:26): [True: 9, False: 10.1k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 1077| 9|#define updatebase(ci) (base = ci->func.p + 1) | | ------------------ | | { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 1064| 9|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 9|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 9|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 9|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 9|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1730| 10.1k| } 1731| 809k| if (nparams1) /* vararg function? */ ------------------ | Branch (1731:13): [True: 2.00k, False: 807k] ------------------ 1732| 2.00k| ci->func.p -= ci->u.l.nextraargs + nparams1; 1733| 809k| L->top.p = ra + n; /* set call for 'luaD_poscall' */ 1734| 809k| luaD_poscall(L, ci, n); 1735| 809k| updatetrap(ci); /* 'luaD_poscall' can change hooks */ ------------------ | | 1075| 809k|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1736| 809k| goto ret; 1737| 809k| } 1738| 113k| vmcase(OP_RETURN0) { ------------------ | | 14| 113k|#define vmcase(l) L_##l: ------------------ 1739| 113k| if (l_unlikely(L->hookmask)) { ------------------ | | 697| 113k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 113k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 113k] | | | | ------------------ | | ------------------ ------------------ 1740| 0| StkId ra = RA(i); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1741| 0| L->top.p = ra; 1742| 0| savepc(ci); ------------------ | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1743| 0| luaD_poscall(L, ci, 0); /* no hurry... */ 1744| 0| trap = 1; 1745| 0| } 1746| 113k| else { /* do the 'poscall' here */ 1747| 113k| int nres; 1748| 113k| L->ci = ci->previous; /* back to caller */ 1749| 113k| L->top.p = base - 1; 1750| 113k| for (nres = ci->nresults; l_unlikely(nres > 0); nres--) 1751| 113k| setnilvalue(s2v(L->top.p++)); /* all results are nil */ ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1752| 113k| } 1753| 113k| goto ret; 1754| 809k| } 1755| 82.6k| vmcase(OP_RETURN1) { ------------------ | | 14| 82.6k|#define vmcase(l) L_##l: ------------------ 1756| 82.6k| if (l_unlikely(L->hookmask)) { ------------------ | | 697| 82.6k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 82.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 82.6k] | | | | ------------------ | | ------------------ ------------------ 1757| 0| StkId ra = RA(i); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1758| 0| L->top.p = ra + 1; 1759| 0| savepc(ci); ------------------ | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1760| 0| luaD_poscall(L, ci, 1); /* no hurry... */ 1761| 0| trap = 1; 1762| 0| } 1763| 82.6k| else { /* do the 'poscall' here */ 1764| 82.6k| int nres = ci->nresults; 1765| 82.6k| L->ci = ci->previous; /* back to caller */ 1766| 82.6k| if (nres == 0) ------------------ | Branch (1766:15): [True: 72.4k, False: 10.1k] ------------------ 1767| 72.4k| L->top.p = base - 1; /* asked for no results */ 1768| 10.1k| else { 1769| 10.1k| StkId ra = RA(i); ------------------ | | 1064| 10.1k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 10.1k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 10.1k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 10.1k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 10.1k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1770| 10.1k| setobjs2s(L, base - 1, ra); /* at least this result */ ------------------ | | 129| 10.1k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 10.1k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 10.1k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 10.1k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 10.1k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 10.1k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 10.1k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 10.1k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 10.1k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 10.1k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 10.1k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1771| 10.1k| L->top.p = base; 1772| 10.1k| for (; l_unlikely(nres > 1); nres--) 1773| 10.1k| setnilvalue(s2v(L->top.p++)); /* complete missing results */ ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 10.1k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1774| 10.1k| } 1775| 82.6k| } 1776| 1.00M| ret: /* return from a Lua function */ 1777| 1.00M| if (ci->callstatus & CIST_FRESH) ------------------ | | 212| 1.00M|#define CIST_FRESH (1<<2) /* call is on a fresh "luaV_execute" frame */ ------------------ | Branch (1777:13): [True: 5, False: 1.00M] ------------------ 1778| 5| return; /* end this frame */ 1779| 1.00M| else { 1780| 1.00M| ci = ci->previous; 1781| 1.00M| goto returning; /* continue running caller in this frame */ 1782| 1.00M| } 1783| 1.00M| } 1784| 211k| vmcase(OP_FORLOOP) { ------------------ | | 14| 211k|#define vmcase(l) L_##l: ------------------ 1785| 211k| StkId ra = RA(i); ------------------ | | 1064| 211k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 211k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 211k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 211k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 211k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1786| 211k| if (ttisinteger(s2v(ra + 2))) { /* integer loop? */ ------------------ | | 328| 211k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 211k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 211k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 211k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1787| 211k| lua_Unsigned count = l_castS2U(ivalue(s2v(ra + 1))); ------------------ | | 152| 845k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | | Branch (152:38): [True: 0, False: 211k] | | | Branch (152:38): [True: 211k, False: 0] | | ------------------ ------------------ 1788| 211k| if (count > 0) { /* still more iterations? */ ------------------ | Branch (1788:15): [True: 161k, False: 49.9k] ------------------ 1789| 161k| lua_Integer step = ivalue(s2v(ra + 2)); ------------------ | | 333| 161k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 161k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 161k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1790| 161k| lua_Integer idx = ivalue(s2v(ra)); /* internal index */ ------------------ | | 333| 161k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 161k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 161k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1791| 161k| chgivalue(s2v(ra + 1), count - 1); /* update counter */ ------------------ | | 348| 161k| { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 106| 161k|#define lua_assert(c) assert(c) | | ------------------ | | { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 72| 161k|#define val_(o) ((o)->value_) | | ------------------ ------------------ 1792| 161k| idx = intop(+, idx, step); /* add step to index */ ------------------ | | 73| 161k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 161k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 1793| 161k| chgivalue(s2v(ra), idx); /* update internal index */ ------------------ | | 348| 161k| { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 106| 161k|#define lua_assert(c) assert(c) | | ------------------ | | { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 72| 161k|#define val_(o) ((o)->value_) | | ------------------ ------------------ 1794| 161k| setivalue(s2v(ra + 3), idx); /* and control variable */ ------------------ | | 345| 161k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 161k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 161k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1795| 161k| pc -= GETARG_Bx(i); /* jump back */ ------------------ | | 140| 161k|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 110| 161k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 161k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1796| 161k| } 1797| 211k| } 1798| 0| else if (floatforloop(ra)) /* float loop */ ------------------ | Branch (1798:18): [True: 0, False: 0] ------------------ 1799| 0| pc -= GETARG_Bx(i); /* jump back */ ------------------ | | 140| 0|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1800| 211k| updatetrap(ci); /* allows a signal to break the loop */ ------------------ | | 1075| 211k|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1801| 211k| vmbreak; ------------------ | | 16| 211k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 211k|#define vmfetch() { \ | | | | 1139| 211k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 211k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 211k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 211k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 211k| i = *(pc++); \ | | | | 1144| 211k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 211k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1802| 211k| } 1803| 60.1k| vmcase(OP_FORPREP) { ------------------ | | 14| 60.1k|#define vmcase(l) L_##l: ------------------ 1804| 60.1k| StkId ra = RA(i); ------------------ | | 1064| 60.1k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 60.1k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 60.1k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 60.1k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 60.1k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1805| 60.1k| savestate(L, ci); /* in case of errors */ ------------------ | | 1112| 60.1k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1105| 60.1k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1806| 60.1k| if (forprep(L, ra)) ------------------ | Branch (1806:13): [True: 0, False: 60.1k] ------------------ 1807| 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)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1808| 60.1k| vmbreak; ------------------ | | 16| 60.1k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 60.1k|#define vmfetch() { \ | | | | 1139| 60.1k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 60.1k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 60.1k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 60.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 60.1k| i = *(pc++); \ | | | | 1144| 60.1k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 60.1k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1809| 60.1k| } 1810| 0| vmcase(OP_TFORPREP) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1811| 0| StkId ra = RA(i); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1812| | /* create to-be-closed upvalue (if needed) */ 1813| 0| halfProtect(luaF_newtbcupval(L, ra + 3)); ------------------ | | 1128| 0|#define halfProtect(exp) (savestate(L,ci), (exp)) | | ------------------ | | | | 1112| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ ------------------ 1814| 0| pc += GETARG_Bx(i); ------------------ | | 140| 0|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1815| 0| i = *(pc++); /* go to next instruction */ 1816| 0| lua_assert(GET_OPCODE(i) == OP_TFORCALL && ra == RA(i)); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ 1817| 0| goto l_tforcall; 1818| 0| } 1819| 0| vmcase(OP_TFORCALL) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1820| 0| l_tforcall: { 1821| 0| StkId ra = RA(i); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1822| | /* 'ra' has the iterator function, 'ra + 1' has the state, 1823| | 'ra + 2' has the control variable, and 'ra + 3' has the 1824| | to-be-closed variable. The call will use the stack after 1825| | these values (starting at 'ra + 4') 1826| | */ 1827| | /* push function, state, and control variable */ 1828| 0| memcpy(ra + 4, ra, 3 * sizeof(*ra)); 1829| 0| L->top.p = ra + 4 + 3; 1830| 0| ProtectNT(luaD_call(L, ra + 4, GETARG_C(i))); /* do the call */ ------------------ | | 1122| 0|#define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ | | #define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ | | | Branch (1122:38): [True: 0, False: 0] | | | Branch (1122:38): [True: 0, False: 0] | | ------------------ ------------------ 1831| 0| updatestack(ci); /* stack may have changed */ ------------------ | | 1081| 0| { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | ------------------ | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | ------------------ | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | ------------------ | | { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 1064| 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)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1832| 0| i = *(pc++); /* go to next instruction */ 1833| 0| lua_assert(GET_OPCODE(i) == OP_TFORLOOP && ra == RA(i)); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ 1834| 0| goto l_tforloop; 1835| 0| }} 1836| 0| vmcase(OP_TFORLOOP) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1837| 0| l_tforloop: { 1838| 0| StkId ra = RA(i); ------------------ | | 1064| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1839| 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 (1839:13): [True: 0, False: 0] ------------------ 1840| 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) || \ | | | | | | ------------------ | | | | | | | | 112| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1841| 0| pc -= GETARG_Bx(i); /* jump back */ ------------------ | | 140| 0|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1842| 0| } 1843| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1844| 0| }} 1845| 2.00k| vmcase(OP_SETLIST) { ------------------ | | 14| 2.00k|#define vmcase(l) L_##l: ------------------ 1846| 2.00k| StkId ra = RA(i); ------------------ | | 1064| 2.00k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 2.00k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 2.00k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 2.00k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 2.00k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1847| 2.00k| int n = GETARG_B(i); ------------------ | | 128| 2.00k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 110| 2.00k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.00k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1848| 2.00k| unsigned int last = GETARG_C(i); ------------------ | | 132| 2.00k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 110| 2.00k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.00k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1849| 4.00k| Table *h = hvalue(s2v(ra)); ------------------ | | 682| 2.00k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 110| 8.00k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.00k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 2.00k] | | | | | Branch (110:42): [True: 2.00k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1850| 2.00k| if (n == 0) ------------------ | Branch (1850:13): [True: 2.00k, False: 0] ------------------ 1851| 2.00k| n = cast_int(L->top.p - ra) - 1; /* get up to the top */ ------------------ | | 141| 2.00k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 2.00k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1852| 0| else 1853| 0| L->top.p = ci->top.p; /* correct top in case of emergency GC */ 1854| 4.00k| last += n; 1855| 4.00k| if (TESTARG_k(i)) { ------------------ | | 136| 2.00k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 110| 2.00k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 2.00k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:25): [True: 0, False: 2.00k] | | | | ------------------ | | ------------------ ------------------ 1856| 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)) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ last += GETARG_Ax(*pc) * (MAXARG_C + 1); ------------------ | | 97| 0|#define MAXARG_C ((1< luaH_realasize(h)) /* needs more space? */ ------------------ | Branch (1859:13): [True: 2.00k, False: 0] ------------------ 1860| 2.00k| luaH_resizearray(L, h, last); /* preallocate it at once */ 1861| 44.0k| for (; n > 0; n--) { ------------------ | Branch (1861:16): [True: 42.0k, False: 2.00k] ------------------ 1862| 42.0k| TValue *val = s2v(ra + n); ------------------ | | 172| 42.0k|#define s2v(o) (&(o)->val) ------------------ 1863| 42.0k| setobj2t(L, &h->array[last - 1], val); ------------------ | | 137| 42.0k|#define setobj2t setobj | | ------------------ | | | | 119| 42.0k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 42.0k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 42.0k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 42.0k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 42.0k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 72.0k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 42.0k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 2.00k] | | | | | | | | | Branch (112:29): [True: 2.00k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 2.00k] | | | | | | | | | Branch (112:29): [True: 2.00k, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 2.00k] | | | | | | | | | Branch (112:29): [True: 2.00k, False: 0] | | | | | | | | | Branch (112:29): [True: 2.00k, False: 0] | | | | | | | | | Branch (112:29): [True: 40.0k, False: 2.00k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 42.0k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 106| 42.0k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1864| 42.0k| last--; 1865| 42.0k| luaC_barrierback(L, obj2gco(h), val); ------------------ | | 185| 42.0k|#define luaC_barrierback(L,p,v) ( \ | | 186| 42.0k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 42.0k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 42.0k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 42.0k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 2.00k, False: 40.0k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 182| 2.00k|#define luaC_objbarrierback(L,p,o) ( \ | | | | 183| 2.00k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 88| 2.00k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 2.00k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 8.00k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 2.00k] | | | | | | | | | | | Branch (62:26): [True: 0, False: 2.00k] | | | | | | | | | | | Branch (62:26): [True: 2.00k, 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] | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | | Branch (62:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 138| 2.00k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 2.00k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (183:51): [True: 0, False: 0] | | | | | Branch (183:51): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 40.0k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 40.0k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1866| 42.0k| } 1867| 2.00k| vmbreak; ------------------ | | 16| 2.00k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 2.00k|#define vmfetch() { \ | | | | 1139| 2.00k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 2.00k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 2.00k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 2.00k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 2.00k| i = *(pc++); \ | | | | 1144| 2.00k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 2.00k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1868| 2.00k| } 1869| 1.11M| vmcase(OP_CLOSURE) { ------------------ | | 14| 1.11M|#define vmcase(l) L_##l: ------------------ 1870| 1.11M| StkId ra = RA(i); ------------------ | | 1064| 1.11M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1.11M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1.11M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 1.11M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1.11M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1871| 1.11M| Proto *p = cl->p->p[GETARG_Bx(i)]; ------------------ | | 140| 1.11M|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 110| 1.11M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 1.11M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1872| 1.11M| halfProtect(pushclosure(L, p, cl->upvals, base, ra)); ------------------ | | 1128| 1.11M|#define halfProtect(exp) (savestate(L,ci), (exp)) | | ------------------ | | | | 1112| 1.11M|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 1.11M|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ ------------------ 1873| 1.11M| checkGC(L, ra + 1); ------------------ | | 1132| 1.11M| { luaC_condGC(L, (savepc(L), L->top.p = (c)), \ | | ------------------ | | | | 168| 1.11M| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 1.11M|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 259, False: 1.11M] | | | | ------------------ | | | | 169| 1.11M| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 1.11M|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 1133| 1.11M| updatetrap(ci)); \ | | 1134| 1.11M| luai_threadyield(L); } | | ------------------ | | | | 273| 1.11M|#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 265| 1.11M|#define lua_unlock(L) ((void) 0) | | | | ------------------ | | | | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 264| 1.11M|#define lua_lock(L) ((void) 0) | | | | ------------------ | | ------------------ ------------------ 1874| 1.11M| vmbreak; ------------------ | | 16| 1.11M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 1.11M|#define vmfetch() { \ | | | | 1139| 1.11M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.11M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.11M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 118, False: 1.11M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 118| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 118| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 118|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 118| } \ | | | | 1143| 1.11M| i = *(pc++); \ | | | | 1144| 1.11M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.11M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1875| 1.11M| } 1876| 87.6k| vmcase(OP_VARARG) { ------------------ | | 14| 87.6k|#define vmcase(l) L_##l: ------------------ 1877| 87.6k| StkId ra = RA(i); ------------------ | | 1064| 87.6k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 87.6k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 87.6k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 87.6k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 87.6k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1878| 87.6k| int n = GETARG_C(i) - 1; /* required results */ ------------------ | | 132| 87.6k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 110| 87.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 87.6k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1879| 87.6k| Protect(luaT_getvarargs(L, ci, ra, n)); ------------------ | | 1119| 87.6k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 87.6k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 87.6k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 87.6k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1880| 87.6k| vmbreak; ------------------ | | 16| 87.6k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 87.6k|#define vmfetch() { \ | | | | 1139| 87.6k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 87.6k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 87.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 87.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 87.6k| i = *(pc++); \ | | | | 1144| 87.6k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 87.6k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1881| 87.6k| } 1882| 2.04k| vmcase(OP_VARARGPREP) { ------------------ | | 14| 2.04k|#define vmcase(l) L_##l: ------------------ 1883| 2.04k| ProtectNT(luaT_adjustvarargs(L, GETARG_A(i), ci, cl->p)); ------------------ | | 1122| 2.04k|#define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1105| 2.04k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ | | #define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 2.04k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1884| 2.04k| if (l_unlikely(trap)) { /* previous "Protect" updated trap */ ------------------ | | 697| 2.04k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 2.04k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 3, False: 2.04k] | | | | ------------------ | | ------------------ ------------------ 1885| 3| luaD_hookcall(L, ci); 1886| 3| L->oldpc = 1; /* next opcode will be seen as a "new" line */ 1887| 3| } 1888| 2.04k| updatebase(ci); /* function has new base after adjustment */ ------------------ | | 1077| 2.04k|#define updatebase(ci) (base = ci->func.p + 1) ------------------ 1889| 2.04k| vmbreak; ------------------ | | 16| 2.04k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 2.04k|#define vmfetch() { \ | | | | 1139| 2.04k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 2.04k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 2.04k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 3, False: 2.04k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 3| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 3| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 3|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 3| } \ | | | | 1143| 2.04k| i = *(pc++); \ | | | | 1144| 2.04k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 2.04k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1890| 2.04k| } 1891| 2.04k| vmcase(OP_EXTRAARG) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1892| 0| lua_assert(0); ------------------ | | 106| 0|#define lua_assert(c) assert(c) ------------------ 1893| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 0|#define vmfetch() { \ | | | | 1139| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 0| } \ | | | | 1143| 0| i = *(pc++); \ | | | | 1144| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1894| 0| } 1895| 0| } 1896| 0| } 1897| 4.16M|} lvm.c:l_strton: 90| 60.1k|static int l_strton (const TValue *obj, TValue *result) { 91| 60.1k| lua_assert(obj != result); ------------------ | | 106| 60.1k|#define lua_assert(c) assert(c) ------------------ 92| 60.1k| if (!cvt2num(obj)) /* is object not a string? */ ------------------ | | 24| 60.1k|#define cvt2num(o) ttisstring(o) | | ------------------ | | | | 363| 60.1k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | | | ------------------ | | | | | | 92| 60.1k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 60.1k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 60.1k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (92:7): [True: 60.1k, False: 4] ------------------ 93| 60.1k| return 0; 94| 4| else { 95| 4| TString *st = tsvalue(obj); ------------------ | | 369| 4|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 16|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 4|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 4] | | | | | Branch (110:42): [True: 4, False: 0] | | | | ------------------ | | ------------------ ------------------ 96| 4| return (luaO_str2num(getstr(st), result) == tsslen(st) + 1); ------------------ | | 404| 4|#define getstr(ts) ((ts)->contents) ------------------ return (luaO_str2num(getstr(st), result) == tsslen(st) + 1); ------------------ | | 411| 4| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 0, False: 4] | | ------------------ ------------------ 97| 4| } 98| 60.1k|} lvm.c:LTnum: 480| 31.2k|l_sinline int LTnum (const TValue *l, const TValue *r) { 481| 31.2k| lua_assert(ttisnumber(l) && ttisnumber(r)); ------------------ | | 106| 31.2k|#define lua_assert(c) assert(c) ------------------ 482| 31.2k| if (ttisinteger(l)) { ------------------ | | 328| 31.2k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 31.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 31.2k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 31.2k] | | | | ------------------ | | ------------------ ------------------ 483| 0| lua_Integer li = ivalue(l); ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 484| 0| if (ttisinteger(r)) ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 485| 0| return li < ivalue(r); /* both are integers */ ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 486| 0| else /* 'l' is int and 'r' is float */ 487| 0| return LTintfloat(li, fltvalue(r)); /* l < r ? */ ------------------ | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 488| 0| } 489| 31.2k| else { 490| 31.2k| lua_Number lf = fltvalue(l); /* 'l' must be float */ ------------------ | | 332| 31.2k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 110| 31.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 31.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 491| 31.2k| if (ttisfloat(r)) ------------------ | | 327| 31.2k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 31.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 31.2k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 3, False: 31.2k] | | | | ------------------ | | ------------------ ------------------ 492| 31.2k| return luai_numlt(lf, fltvalue(r)); /* both are float */ ------------------ | | 351| 12|#define luai_numlt(a,b) ((a)<(b)) | | ------------------ | | | Branch (351:39): [True: 0, False: 3] | | | Branch (351:39): [True: 3, False: 0] | | ------------------ ------------------ 493| 31.2k| else /* 'l' is float and 'r' is int */ 494| 31.2k| return LTfloatint(lf, ivalue(r)); ------------------ | | 333| 31.2k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 31.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 31.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 495| 31.2k| } 496| 31.2k|} lvm.c:LTfloatint: 447| 31.2k|l_sinline int LTfloatint (lua_Number f, lua_Integer i) { 448| 31.2k| if (l_intfitsf(i)) ------------------ | | 74| 31.2k|#define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 31.2k|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 31.2k|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 31.2k|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 152| 31.2k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 31.2k|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 31.2k|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 31.2k|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (74:23): [True: 30.3k, False: 910] | | ------------------ ------------------ 449| 30.3k| return luai_numlt(f, cast_num(i)); /* compare them as floats */ ------------------ | | 351| 30.3k|#define luai_numlt(a,b) ((a)<(b)) ------------------ 450| 910| else { /* f < i <=> floor(f) < i */ 451| 910| lua_Integer fi; 452| 910| if (luaV_flttointeger(f, &fi, F2Ifloor)) /* fi = floor(f) */ ------------------ | Branch (452:9): [True: 903, False: 7] ------------------ 453| 903| return fi < i; /* compare them as integers */ 454| 7| else /* 'f' is either greater or less than all integers */ 455| 7| return f < 0; /* less? */ 456| 910| } 457| 31.2k|} lvm.c:lessthanothers: 524| 4.01k|static int lessthanothers (lua_State *L, const TValue *l, const TValue *r) { 525| 4.01k| lua_assert(!ttisnumber(l) || !ttisnumber(r)); ------------------ | | 106| 4.01k|#define lua_assert(c) assert(c) ------------------ 526| 4.01k| if (ttisstring(l) && ttisstring(r)) /* both are strings? */ ------------------ | | 363| 4.01k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 8.02k|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 4.01k|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 4.01k|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 4.00k, False: 1] | | | | ------------------ | | ------------------ ------------------ if (ttisstring(l) && ttisstring(r)) /* both are strings? */ ------------------ | | 363| 4.00k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 4.00k|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 4.00k|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 4.00k|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 4.00k, False: 0] | | | | ------------------ | | ------------------ ------------------ 527| 8.01k| return l_strcmp(tsvalue(l), tsvalue(r)) < 0; ------------------ | | 369| 4.00k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 16.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 4.00k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 4.00k] | | | | | Branch (110:42): [True: 4.00k, False: 0] | | | | ------------------ | | ------------------ ------------------ return l_strcmp(tsvalue(l), tsvalue(r)) < 0; ------------------ | | 369| 4.00k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 16.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 4.00k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 4.00k] | | | | | Branch (110:42): [True: 4.00k, False: 0] | | | | ------------------ | | ------------------ ------------------ 528| 1| else 529| 1| return luaT_callorderTM(L, l, r, TM_LT); 530| 4.01k|} lvm.c:l_strcmp: 378| 4.00k|static int l_strcmp (const TString *ts1, const TString *ts2) { 379| 4.00k| const char *s1 = getstr(ts1); ------------------ | | 404| 4.00k|#define getstr(ts) ((ts)->contents) ------------------ 380| 4.00k| size_t rl1 = tsslen(ts1); /* real length */ ------------------ | | 411| 4.00k| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 0, False: 4.00k] | | ------------------ ------------------ 381| 4.00k| const char *s2 = getstr(ts2); ------------------ | | 404| 4.00k|#define getstr(ts) ((ts)->contents) ------------------ 382| 4.00k| size_t rl2 = tsslen(ts2); ------------------ | | 411| 4.00k| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 0, False: 4.00k] | | ------------------ ------------------ 383| 20.7k| for (;;) { /* for each segment */ 384| 20.7k| int temp = strcoll(s1, s2); 385| 20.7k| if (temp != 0) /* not equal? */ ------------------ | Branch (385:9): [True: 4.00k, False: 16.7k] ------------------ 386| 4.00k| return temp; /* done */ 387| 16.7k| else { /* strings are equal up to a '\0' */ 388| 16.7k| size_t zl1 = strlen(s1); /* index of first '\0' in 's1' */ 389| 16.7k| size_t zl2 = strlen(s2); /* index of first '\0' in 's2' */ 390| 16.7k| if (zl2 == rl2) /* 's2' is finished? */ ------------------ | Branch (390:11): [True: 0, False: 16.7k] ------------------ 391| 0| return (zl1 == rl1) ? 0 : 1; /* check 's1' */ ------------------ | Branch (391:16): [True: 0, False: 0] ------------------ 392| 16.7k| else if (zl1 == rl1) /* 's1' is finished? */ ------------------ | Branch (392:16): [True: 0, False: 16.7k] ------------------ 393| 0| return -1; /* 's1' is less than 's2' ('s2' is not finished) */ 394| | /* both strings longer than 'zl'; go on comparing after the '\0' */ 395| 16.7k| zl1++; zl2++; 396| 16.7k| s1 += zl1; rl1 -= zl1; s2 += zl2; rl2 -= zl2; 397| 16.7k| } 398| 20.7k| } 399| 4.00k|} lvm.c:LEnum: 502| 98|l_sinline int LEnum (const TValue *l, const TValue *r) { 503| 98| lua_assert(ttisnumber(l) && ttisnumber(r)); ------------------ | | 106| 98|#define lua_assert(c) assert(c) ------------------ 504| 98| if (ttisinteger(l)) { ------------------ | | 328| 98|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 98|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 98|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 98] | | | | ------------------ | | ------------------ ------------------ 505| 0| lua_Integer li = ivalue(l); ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 506| 0| if (ttisinteger(r)) ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 507| 0| return li <= ivalue(r); /* both are integers */ ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 508| 0| else /* 'l' is int and 'r' is float */ 509| 0| return LEintfloat(li, fltvalue(r)); /* l <= r ? */ ------------------ | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 510| 0| } 511| 98| else { 512| 98| lua_Number lf = fltvalue(l); /* 'l' must be float */ ------------------ | | 332| 98|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 110| 98|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 98|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 513| 98| if (ttisfloat(r)) ------------------ | | 327| 98|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 98|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 98|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 98] | | | | ------------------ | | ------------------ ------------------ 514| 98| return luai_numle(lf, fltvalue(r)); /* both are float */ ------------------ | | 352| 0|#define luai_numle(a,b) ((a)<=(b)) | | ------------------ | | | Branch (352:40): [True: 0, False: 0] | | | Branch (352:40): [True: 0, False: 0] | | ------------------ ------------------ 515| 98| else /* 'l' is float and 'r' is int */ 516| 98| return LEfloatint(lf, ivalue(r)); ------------------ | | 333| 98|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 98|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 98|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 517| 98| } 518| 98|} lvm.c:LEfloatint: 464| 98|l_sinline int LEfloatint (lua_Number f, lua_Integer i) { 465| 98| if (l_intfitsf(i)) ------------------ | | 74| 98|#define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 98|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 98|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 98|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 152| 98|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 98|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 98|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 98|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (74:23): [True: 75, False: 23] | | ------------------ ------------------ 466| 75| return luai_numle(f, cast_num(i)); /* compare them as floats */ ------------------ | | 352| 75|#define luai_numle(a,b) ((a)<=(b)) ------------------ 467| 23| else { /* f <= i <=> ceil(f) <= i */ 468| 23| lua_Integer fi; 469| 23| if (luaV_flttointeger(f, &fi, F2Iceil)) /* fi = ceil(f) */ ------------------ | Branch (469:9): [True: 23, False: 0] ------------------ 470| 23| return fi <= i; /* compare them as integers */ 471| 0| else /* 'f' is either greater or less than all integers */ 472| 0| return f < 0; /* less? */ 473| 23| } 474| 98|} lvm.c:copy2buff: 628| 30.8k|static void copy2buff (StkId top, int n, char *buff) { 629| 30.8k| size_t tl = 0; /* size already copied */ 630| 62.2k| do { 631| 124k| TString *st = tsvalue(s2v(top - n)); ------------------ | | 369| 62.2k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 110| 249k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 62.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (110:42): [True: 0, False: 62.2k] | | | | | Branch (110:42): [True: 62.2k, False: 0] | | | | ------------------ | | ------------------ ------------------ 632| 62.2k| size_t l = tsslen(st); /* length of string being copied */ ------------------ | | 411| 62.2k| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 43.1k, False: 19.1k] | | ------------------ ------------------ 633| 124k| memcpy(buff + tl, getstr(st), l * sizeof(char)); ------------------ | | 404| 62.2k|#define getstr(ts) ((ts)->contents) ------------------ 634| 124k| tl += l; 635| 124k| } while (--n > 0); ------------------ | Branch (635:12): [True: 31.4k, False: 30.8k] ------------------ 636| 30.8k|} lvm.c:forprep: 208| 60.1k|static int forprep (lua_State *L, StkId ra) { 209| 60.1k| TValue *pinit = s2v(ra); ------------------ | | 172| 60.1k|#define s2v(o) (&(o)->val) ------------------ 210| 60.1k| TValue *plimit = s2v(ra + 1); ------------------ | | 172| 60.1k|#define s2v(o) (&(o)->val) ------------------ 211| 60.1k| TValue *pstep = s2v(ra + 2); ------------------ | | 172| 60.1k|#define s2v(o) (&(o)->val) ------------------ 212| 60.1k| if (ttisinteger(pinit) && ttisinteger(pstep)) { /* integer loop? */ ------------------ | | 328| 60.1k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 120k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 60.1k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 60.1k, False: 2] | | | | ------------------ | | ------------------ ------------------ if (ttisinteger(pinit) && ttisinteger(pstep)) { /* integer loop? */ ------------------ | | 328| 60.1k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 60.1k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 60.1k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 60.1k, False: 0] | | | | ------------------ | | ------------------ ------------------ 213| 60.1k| lua_Integer init = ivalue(pinit); ------------------ | | 333| 60.1k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 60.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 60.1k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 214| 60.1k| lua_Integer step = ivalue(pstep); ------------------ | | 333| 60.1k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 110| 60.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 106| 60.1k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 215| 0| lua_Integer limit; 216| 60.1k| if (step == 0) ------------------ | Branch (216:9): [True: 0, False: 60.1k] ------------------ 217| 0| luaG_runerror(L, "'for' step is zero"); 218| 60.1k| setivalue(s2v(ra + 3), init); /* control variable */ ------------------ | | 345| 60.1k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 60.1k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 60.1k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 219| 60.1k| if (forlimit(L, init, plimit, &limit, step)) ------------------ | Branch (219:9): [True: 0, False: 60.1k] ------------------ 220| 0| return 1; /* skip the loop */ 221| 60.1k| else { /* prepare loop counter */ 222| 60.1k| lua_Unsigned count; 223| 60.1k| if (step > 0) { /* ascending loop? */ ------------------ | Branch (223:11): [True: 60.1k, False: 1] ------------------ 224| 60.1k| count = l_castS2U(limit) - l_castS2U(init); ------------------ | | 152| 60.1k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ count = l_castS2U(limit) - l_castS2U(init); ------------------ | | 152| 60.1k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 225| 60.1k| if (step != 1) /* avoid division in the too common case */ ------------------ | Branch (225:13): [True: 0, False: 60.1k] ------------------ 226| 0| count /= l_castS2U(step); ------------------ | | 152| 0|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 227| 60.1k| } 228| 1| else { /* step < 0; descending loop */ 229| 1| count = l_castS2U(init) - l_castS2U(limit); ------------------ | | 152| 1|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ count = l_castS2U(init) - l_castS2U(limit); ------------------ | | 152| 1|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 230| | /* 'step+1' avoids negating 'mininteger' */ 231| 1| count /= l_castS2U(-(step + 1)) + 1u; ------------------ | | 152| 1|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 232| 1| } 233| | /* store the counter in place of the limit (which won't be 234| | needed anymore) */ 235| 60.1k| setivalue(plimit, l_castU2S(count)); ------------------ | | 345| 60.1k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 60.1k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 60.1k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 236| 60.1k| } 237| 60.1k| } 238| 2| else { /* try making all values floats */ 239| 2| lua_Number init; lua_Number limit; lua_Number step; 240| 2| if (l_unlikely(!tonumber(plimit, &limit))) ------------------ | | 697| 2|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 4|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 2, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 2] | | | | ------------------ | | ------------------ ------------------ 241| 2| luaG_forerror(L, plimit, "limit"); 242| 0| if (l_unlikely(!tonumber(pstep, &step))) ------------------ | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 243| 0| luaG_forerror(L, pstep, "step"); 244| 0| if (l_unlikely(!tonumber(pinit, &init))) ------------------ | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 245| 0| luaG_forerror(L, pinit, "initial value"); 246| 0| if (step == 0) ------------------ | Branch (246:9): [True: 0, False: 0] ------------------ 247| 0| luaG_runerror(L, "'for' step is zero"); 248| 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 (248:9): [True: 0, False: 0] ------------------ 249| 0| : luai_numlt(init, limit)) ------------------ | | 351| 0|#define luai_numlt(a,b) ((a)<(b)) ------------------ 250| 0| return 1; /* skip the loop */ 251| 0| else { 252| | /* make sure internal values are all floats */ 253| 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)) | | ------------------ ------------------ 254| 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)) | | ------------------ ------------------ 255| 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)) | | ------------------ ------------------ 256| 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)) | | ------------------ ------------------ 257| 0| } 258| 0| } 259| 60.1k| return 0; 260| 60.1k|} lvm.c:forlimit: 179| 60.1k| lua_Integer *p, lua_Integer step) { 180| 60.1k| if (!luaV_tointeger(lim, p, (step < 0 ? F2Iceil : F2Ifloor))) { ------------------ | Branch (180:7): [True: 1, False: 60.1k] | Branch (180:32): [True: 0, False: 60.1k] ------------------ 181| | /* not coercible to in integer */ 182| 1| lua_Number flim; /* try to convert to float */ 183| 1| if (!tonumber(lim, &flim)) /* cannot convert to float? */ ------------------ | | 52| 1| (ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n)) | | ------------------ | | | | 327| 1|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 1|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 1|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n)) | | ------------------ | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (183:9): [True: 1, False: 0] ------------------ 184| 1| luaG_forerror(L, lim, "limit"); 185| | /* else 'flim' is a float out of integer bounds */ 186| 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] | | ------------------ ------------------ 187| 0| if (step < 0) return 1; /* initial value must be less than it */ ------------------ | Branch (187:11): [True: 0, False: 0] ------------------ 188| 0| *p = LUA_MAXINTEGER; /* truncate */ ------------------ | | 554| 0|#define LUA_MAXINTEGER LLONG_MAX ------------------ 189| 0| } 190| 0| else { /* it is less than min integer */ 191| 0| if (step > 0) return 1; /* initial value must be greater than it */ ------------------ | Branch (191:11): [True: 0, False: 0] ------------------ 192| 0| *p = LUA_MININTEGER; /* truncate */ ------------------ | | 555| 0|#define LUA_MININTEGER LLONG_MIN ------------------ 193| 0| } 194| 0| } 195| 60.1k| return (step > 0 ? init > *p : init < *p); /* not to run? */ ------------------ | Branch (195:11): [True: 60.1k, False: 0] ------------------ 196| 60.1k|} lvm.c:pushclosure: 794| 1.11M| StkId ra) { 795| 1.11M| int nup = p->sizeupvalues; 796| 1.11M| Upvaldesc *uv = p->upvalues; 797| 1.11M| int i; 798| 1.11M| LClosure *ncl = luaF_newLclosure(L, nup); 799| 1.11M| ncl->p = p; 800| 1.11M| setclLvalue2s(L, ra, ncl); /* anchor new closure in stack */ ------------------ | | 613| 1.11M|#define setclLvalue2s(L,o,cl) setclLvalue(L,s2v(o),cl) | | ------------------ | | | | 609| 1.11M| { TValue *io = (obj); LClosure *x_ = (x); \ | | | | 610| 1.11M| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 72| 1.11M|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 390| 1.11M|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 110| 1.11M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 106| 1.11M|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 114| 1.11M|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 611| 1.11M| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 1.11M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 112| 17.9M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 106| 1.11M|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (112:29): [True: 0, False: 1.11M] | | | | | | | | | Branch (112:29): [True: 1.11M, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 1.11M] | | | | | | | | | Branch (112:29): [True: 1.11M, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 1.11M] | | | | | | | | | Branch (112:29): [True: 1.11M, False: 0] | | | | | | | | | Branch (112:29): [True: 1.11M, False: 0] | | | | | | | | | Branch (112:29): [True: 0, False: 1.11M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 1.11M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 801| 2.52M| for (i = 0; i < nup; i++) { /* fill in its upvalues */ ------------------ | Branch (801:15): [True: 1.40M, False: 1.11M] ------------------ 802| 1.40M| if (uv[i].instack) /* upvalue refers to local variable? */ ------------------ | Branch (802:9): [True: 239k, False: 1.16M] ------------------ 803| 239k| ncl->upvals[i] = luaF_findupval(L, base + uv[i].idx); 804| 1.16M| else /* get upvalue from enclosing function */ 805| 1.16M| ncl->upvals[i] = encup[uv[i].idx]; 806| 1.40M| luaC_objbarrier(L, ncl, ncl->upvals[i]); ------------------ | | 175| 1.40M|#define luaC_objbarrier(L,p,o) ( \ | | 176| 1.40M| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 1.40M|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 1.40M|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 2.80M|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 1.40M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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.40M| 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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)) | | | | ------------------ | | | | | | 110| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 106| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 1.40M|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 1.40M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 807| 1.40M| } 808| 1.11M|} luaZ_fill: 23| 301|int luaZ_fill (ZIO *z) { 24| 301| size_t size; 25| 301| lua_State *L = z->L; 26| 301| const char *buff; 27| 301| lua_unlock(L); ------------------ | | 265| 301|#define lua_unlock(L) ((void) 0) ------------------ 28| 301| buff = z->reader(L, z->data, &size); 29| 301| lua_lock(L); ------------------ | | 264| 301|#define lua_lock(L) ((void) 0) ------------------ 30| 301| if (buff == NULL || size == 0) ------------------ | Branch (30:7): [True: 76, False: 225] | Branch (30:23): [True: 0, False: 225] ------------------ 31| 76| return EOZ; ------------------ | | 16| 76|#define EOZ (-1) /* end of stream */ ------------------ 32| 225| z->n = size - 1; /* discount char being returned */ 33| 225| z->p = buff; 34| 225| return cast_uchar(*(z->p++)); ------------------ | | 144| 225|#define cast_uchar(i) cast(unsigned char, (i)) | | ------------------ | | | | 136| 225|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 35| 301|} luaZ_init: 38| 225|void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) { 39| 225| z->L = L; 40| 225| z->reader = reader; 41| 225| z->data = data; 42| 225| z->n = 0; 43| 225| z->p = NULL; 44| 225|}