LLVMFuzzerTestOneInput: 145| 390|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 146| 390| lua_State *L = luaL_newstate(); 147| 390| if (L == NULL) { ------------------ | Branch (147:9): [True: 0, False: 390] ------------------ 148| 0| return 0; 149| 0| } 150| 390| dochunk(L, luaL_loadbufferx(L, (const char *)data, size, "test", "t")); 151| | 152| | 153| 390| lua_close(L); 154| 390| return 0; 155| 390|} fuzz_lua.c:dochunk: 134| 390|static int dochunk (lua_State *L, int status) { 135| 390| if (status == LUA_OK) status = docall(L, 0, 0); ------------------ | | 48| 390|#define LUA_OK 0 ------------------ | Branch (135:7): [True: 64, False: 326] ------------------ 136| 390| return report(L, status); 137| 390|} fuzz_lua.c:docall: 120| 64|static int docall (lua_State *L, int narg, int nres) { 121| 64| int status; 122| 64| int base = lua_gettop(L) - narg; /* function index */ 123| 64| lua_pushcfunction(L, msghandler); /* push message handler */ ------------------ | | 381| 64|#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0) ------------------ 124| 64| lua_insert(L, base); /* put it under function and args */ ------------------ | | 400| 64|#define lua_insert(L,idx) lua_rotate(L, (idx), 1) ------------------ 125| 64| globalL = L; /* to be available to 'laction' */ 126| 64| signal(SIGINT, laction); /* set C-signal handler */ 127| 64| status = lua_pcall(L, narg, nres, base); ------------------ | | 297| 64|#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) ------------------ 128| 64| signal(SIGINT, SIG_DFL); /* reset C-signal handler */ 129| 64| lua_remove(L, base); /* remove message handler from the stack */ ------------------ | | 402| 64|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 375| 64|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 130| 64| return status; 131| 64|} fuzz_lua.c:msghandler: 101| 56|static int msghandler (lua_State *L) { 102| 56| const char *msg = lua_tostring(L, 1); ------------------ | | 397| 56|#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) ------------------ 103| 56| if (msg == NULL) { /* is error object not a string? */ ------------------ | Branch (103:7): [True: 0, False: 56] ------------------ 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| 56| luaL_traceback(L, L, msg, 1); /* append a standard traceback */ 112| 56| return 1; /* return the traceback */ 113| 56|} fuzz_lua.c:report: 89| 390|static int report (lua_State *L, int status) { 90| 390| if (status != LUA_OK) { ------------------ | | 48| 390|#define LUA_OK 0 ------------------ | Branch (90:7): [True: 382, False: 8] ------------------ 91| 382| const char *msg = lua_tostring(L, -1); ------------------ | | 397| 382|#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) ------------------ 92| 382| l_message(progname, msg); 93| 382| lua_pop(L, 1); /* remove message */ ------------------ | | 375| 382|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 94| 382| } 95| 390| return status; 96| 390|} fuzz_lua.c:l_message: 78| 382|static void l_message (const char *pname, const char *msg) { 79| 382| if (pname) lua_writestringerror("%s: ", pname); ------------------ | | 271| 382| (fprintf(stderr, (s), (p)), fflush(stderr)) ------------------ | Branch (79:7): [True: 382, False: 0] ------------------ 80| 382| lua_writestringerror("%s\n", msg); ------------------ | | 271| 382| (fprintf(stderr, (s), (p)), fflush(stderr)) ------------------ 81| 382|} lua_checkstack: 111| 16|LUA_API int lua_checkstack (lua_State *L, int n) { 112| 16| int res; 113| 16| CallInfo *ci; 114| 16| lua_lock(L); ------------------ | | 264| 16|#define lua_lock(L) ((void) 0) ------------------ 115| 16| ci = L->ci; 116| 16| api_check(L, n >= 0, "negative 'n'"); ------------------ | | 126| 16|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 16|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 117| 16| if (L->stack_last.p - L->top.p > n) /* stack large enough? */ ------------------ | Branch (117:7): [True: 16, False: 0] ------------------ 118| 16| res = 1; /* yes; check is OK */ 119| 0| else /* need to grow stack */ 120| 0| res = luaD_growstack(L, n, 0); 121| 16| if (res && ci->top.p < L->top.p + n) ------------------ | Branch (121:7): [True: 16, False: 0] | Branch (121:14): [True: 0, False: 16] ------------------ 122| 0| ci->top.p = L->top.p + n; /* adjust frame top */ 123| 16| lua_unlock(L); ------------------ | | 265| 16|#define lua_unlock(L) ((void) 0) ------------------ 124| 16| return res; 125| 16|} lua_atpanic: 144| 390|LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) { 145| 390| lua_CFunction old; 146| 390| lua_lock(L); ------------------ | | 264| 390|#define lua_lock(L) ((void) 0) ------------------ 147| 390| old = G(L)->panic; ------------------ | | 335| 390|#define G(L) (L->l_G) ------------------ 148| 390| G(L)->panic = panicf; ------------------ | | 335| 390|#define G(L) (L->l_G) ------------------ 149| 390| lua_unlock(L); ------------------ | | 265| 390|#define lua_unlock(L) ((void) 0) ------------------ 150| 390| return old; 151| 390|} lua_gettop: 176| 120|LUA_API int lua_gettop (lua_State *L) { 177| 120| return cast_int(L->top.p - (L->ci->func.p + 1)); ------------------ | | 141| 120|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 120|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 178| 120|} lua_settop: 181| 718|LUA_API void lua_settop (lua_State *L, int idx) { 182| 718| CallInfo *ci; 183| 718| StkId func, newtop; 184| 718| ptrdiff_t diff; /* difference for new top */ 185| 718| lua_lock(L); ------------------ | | 264| 718|#define lua_lock(L) ((void) 0) ------------------ 186| 718| ci = L->ci; 187| 718| func = ci->func.p; 188| 718| if (idx >= 0) { ------------------ | Branch (188:7): [True: 56, False: 662] ------------------ 189| 56| api_check(L, idx <= ci->top.p - (func + 1), "new top too large"); ------------------ | | 126| 56|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 56|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 190| 56| diff = ((func + 1) + idx) - L->top.p; 191| 56| for (; diff > 0; diff--) ------------------ | Branch (191:12): [True: 0, False: 56] ------------------ 192| 56| setnilvalue(s2v(L->top.p++)); /* clear new slots */ ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 56|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 193| 56| } 194| 662| else { 195| 662| api_check(L, -(idx+1) <= (L->top.p - (func + 1)), "invalid new top"); ------------------ | | 126| 662|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 662|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 196| 662| diff = idx + 1; /* will "subtract" index (as it is negative) */ 197| 662| } 198| 718| api_check(L, L->tbclist.p < L->top.p, "previous pop of an unclosed slot"); ------------------ | | 126| 718|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 718|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 199| 718| newtop = L->top.p + diff; 200| 718| if (diff < 0 && L->tbclist.p >= newtop) { ------------------ | Branch (200:7): [True: 702, False: 16] | Branch (200:19): [True: 0, False: 702] ------------------ 201| 0| lua_assert(hastocloseCfunc(ci->nresults)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 202| 0| newtop = luaF_close(L, newtop, CLOSEKTOP, 0); ------------------ | | 47| 0|#define CLOSEKTOP (-1) ------------------ 203| 0| } 204| 718| L->top.p = newtop; /* correct top only after closing any upvalue */ 205| 718| lua_unlock(L); ------------------ | | 265| 718|#define lua_unlock(L) ((void) 0) ------------------ 206| 718|} lua_closeslot: 209| 16|LUA_API void lua_closeslot (lua_State *L, int idx) { 210| 16| StkId level; 211| 16| lua_lock(L); ------------------ | | 264| 16|#define lua_lock(L) ((void) 0) ------------------ 212| 16| level = index2stack(L, idx); 213| 16| api_check(L, hastocloseCfunc(L->ci->nresults) && L->tbclist.p == level, ------------------ | | 126| 16|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 16|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 214| 16| "no variable to close at given level"); 215| 16| level = luaF_close(L, level, CLOSEKTOP, 0); ------------------ | | 47| 16|#define CLOSEKTOP (-1) ------------------ 216| 16| setnilvalue(s2v(level)); ------------------ | | 200| 16|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 217| 16| lua_unlock(L); ------------------ | | 265| 16|#define lua_unlock(L) ((void) 0) ------------------ 218| 16|} lua_rotate: 241| 216|LUA_API void lua_rotate (lua_State *L, int idx, int n) { 242| 216| StkId p, t, m; 243| 216| lua_lock(L); ------------------ | | 264| 216|#define lua_lock(L) ((void) 0) ------------------ 244| 216| t = L->top.p - 1; /* end of stack segment being rotated */ 245| 216| p = index2stack(L, idx); /* start of segment */ 246| 216| api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'"); ------------------ | | 126| 216|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 216|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 247| 216| m = (n >= 0 ? t - n : p - n - 1); /* end of prefix */ ------------------ | Branch (247:8): [True: 80, False: 136] ------------------ 248| 216| reverse(L, p, m); /* reverse the prefix with length 'n' */ 249| 216| reverse(L, m + 1, t); /* reverse the suffix */ 250| 216| reverse(L, p, t); /* reverse the entire segment */ 251| 216| lua_unlock(L); ------------------ | | 265| 216|#define lua_unlock(L) ((void) 0) ------------------ 252| 216|} lua_pushvalue: 270| 16|LUA_API void lua_pushvalue (lua_State *L, int idx) { 271| 16| lua_lock(L); ------------------ | | 264| 16|#define lua_lock(L) ((void) 0) ------------------ 272| 16| setobj2s(L, L->top.p, index2value(L, idx)); ------------------ | | 131| 16|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 16| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 16| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 16| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 16| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 16|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 16| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 16|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 273| 16| api_incr_top(L); ------------------ | | 16| 16|#define api_incr_top(L) {L->top.p++; \ | | 17| 16| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 16|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 16|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 16| "stack overflow");} ------------------ 274| 16| lua_unlock(L); ------------------ | | 265| 16|#define lua_unlock(L) ((void) 0) ------------------ 275| 16|} lua_type: 284| 56|LUA_API int lua_type (lua_State *L, int idx) { 285| 56| const TValue *o = index2value(L, idx); 286| 56| return (isvalid(L, o) ? ttype(o) : LUA_TNONE); ------------------ | | 46| 56|#define isvalid(L, o) (!ttisnil(o) || o != &G(L)->nilvalue) | | ------------------ | | | | 193| 56|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 112|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 56|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 56|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define isvalid(L, o) (!ttisnil(o) || o != &G(L)->nilvalue) | | ------------------ | | | | 335| 56|#define G(L) (L->l_G) | | ------------------ | | | Branch (46:24): [True: 0, False: 56] | | | Branch (46:39): [True: 56, False: 0] | | ------------------ ------------------ return (isvalid(L, o) ? ttype(o) : LUA_TNONE); ------------------ | | 87| 56|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 56|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ return (isvalid(L, o) ? ttype(o) : LUA_TNONE); ------------------ | | 62| 0|#define LUA_TNONE (-1) ------------------ 287| 56|} lua_tolstring: 405| 550|LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) { 406| 550| TValue *o; 407| 550| lua_lock(L); ------------------ | | 264| 550|#define lua_lock(L) ((void) 0) ------------------ 408| 550| o = index2value(L, idx); 409| 550| if (!ttisstring(o)) { ------------------ | | 363| 550|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 550|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 550|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 550|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (409:7): [True: 0, False: 550] ------------------ 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| 550| if (len != NULL) ------------------ | Branch (419:7): [True: 112, False: 438] ------------------ 420| 112| *len = tsslen(tsvalue(o)); ------------------ | | 411| 112| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 112, False: 0] | | ------------------ ------------------ 421| 550| lua_unlock(L); ------------------ | | 265| 550|#define lua_unlock(L) ((void) 0) ------------------ 422| 550| return getstr(tsvalue(o)); ------------------ | | 404| 550|#define getstr(ts) ((ts)->contents) ------------------ 423| 550|} lua_touserdata: 456| 62|LUA_API void *lua_touserdata (lua_State *L, int idx) { 457| 62| const TValue *o = index2value(L, idx); 458| 62| return touserdata(o); 459| 62|} lua_pushlstring: 526| 56|LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) { 527| 56| TString *ts; 528| 56| lua_lock(L); ------------------ | | 264| 56|#define lua_lock(L) ((void) 0) ------------------ 529| 56| ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len); ------------------ | Branch (529:8): [True: 0, False: 56] ------------------ 530| 56| setsvalue2s(L, L->top.p, ts); ------------------ | | 377| 56|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 56| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 56| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 56|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 56|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 56|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 56|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 56| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 56| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 56|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 56| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 531| 56| api_incr_top(L); ------------------ | | 16| 56|#define api_incr_top(L) {L->top.p++; \ | | 17| 56| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 56|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 56|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 56| "stack overflow");} ------------------ 532| 56| luaC_checkGC(L); ------------------ | | 172| 56|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 56| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 56|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 56] | | | | ------------------ | | | | 169| 56| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 56|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 533| 56| lua_unlock(L); ------------------ | | 265| 56|#define lua_unlock(L) ((void) 0) ------------------ 534| 56| return getstr(ts); ------------------ | | 404| 56|#define getstr(ts) ((ts)->contents) ------------------ 535| 56|} lua_pushstring: 538| 72|LUA_API const char *lua_pushstring (lua_State *L, const char *s) { 539| 72| lua_lock(L); ------------------ | | 264| 72|#define lua_lock(L) ((void) 0) ------------------ 540| 72| if (s == NULL) ------------------ | Branch (540:7): [True: 0, False: 72] ------------------ 541| 72| setnilvalue(s2v(L->top.p)); ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 542| 72| else { 543| 72| TString *ts; 544| 72| ts = luaS_new(L, s); 545| 72| setsvalue2s(L, L->top.p, ts); ------------------ | | 377| 72|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 72| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 72| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 72|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 72|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 72|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 72|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 72| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 72| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 72|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 72| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 546| 72| s = getstr(ts); /* internal copy's address */ ------------------ | | 404| 72|#define getstr(ts) ((ts)->contents) ------------------ 547| 72| } 548| 72| api_incr_top(L); ------------------ | | 16| 72|#define api_incr_top(L) {L->top.p++; \ | | 17| 72| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 72|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 72|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 72| "stack overflow");} ------------------ 549| 72| luaC_checkGC(L); ------------------ | | 172| 72|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 72| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 72|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 72] | | | | ------------------ | | | | 169| 72| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 72|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 550| 72| lua_unlock(L); ------------------ | | 265| 72|#define lua_unlock(L) ((void) 0) ------------------ 551| 72| return s; 552| 72|} lua_pushfstring: 566| 56|LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) { 567| 56| const char *ret; 568| 56| va_list argp; 569| 56| lua_lock(L); ------------------ | | 264| 56|#define lua_lock(L) ((void) 0) ------------------ 570| 56| va_start(argp, fmt); 571| 56| ret = luaO_pushvfstring(L, fmt, argp); 572| 56| va_end(argp); 573| 56| luaC_checkGC(L); ------------------ | | 172| 56|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 56| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 56|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 56] | | | | ------------------ | | | | 169| 56| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 56|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 574| 56| lua_unlock(L); ------------------ | | 265| 56|#define lua_unlock(L) ((void) 0) ------------------ 575| 56| return ret; 576| 56|} lua_pushcclosure: 579| 96|LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) { 580| 96| lua_lock(L); ------------------ | | 264| 96|#define lua_lock(L) ((void) 0) ------------------ 581| 96| if (n == 0) { ------------------ | Branch (581:7): [True: 96, False: 0] ------------------ 582| 96| setfvalue(s2v(L->top.p), fn); ------------------ | | 616| 96| { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_VLCF); } | | ------------------ | | | | 72| 96|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_VLCF); } | | ------------------ | | | | 114| 96|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 583| 96| api_incr_top(L); ------------------ | | 16| 96|#define api_incr_top(L) {L->top.p++; \ | | 17| 96| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 96|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 96|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 96| "stack overflow");} ------------------ 584| 96| } 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) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 594| | /* does not need barrier because closure is white */ 595| 0| lua_assert(iswhite(cl)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 596| 0| } 597| 0| setclCvalue(L, s2v(L->top.p), cl); ------------------ | | 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)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VCCL)); \ | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 621| 0| checkliveness(L,io); } | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 598| 0| api_incr_top(L); ------------------ | | 16| 0|#define api_incr_top(L) {L->top.p++; \ | | 17| 0| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 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| 96| lua_unlock(L); ------------------ | | 265| 96|#define lua_unlock(L) ((void) 0) ------------------ 602| 96|} lua_pushlightuserdata: 616| 56|LUA_API void lua_pushlightuserdata (lua_State *L, void *p) { 617| 56| lua_lock(L); ------------------ | | 264| 56|#define lua_lock(L) ((void) 0) ------------------ 618| 56| setpvalue(s2v(L->top.p), p); ------------------ | | 440| 56| { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_VLIGHTUSERDATA); } | | ------------------ | | | | 72| 56|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_VLIGHTUSERDATA); } | | ------------------ | | | | 114| 56|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 619| 56| api_incr_top(L); ------------------ | | 16| 56|#define api_incr_top(L) {L->top.p++; \ | | 17| 56| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 56|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 56|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 56| "stack overflow");} ------------------ 620| 56| lua_unlock(L); ------------------ | | 265| 56|#define lua_unlock(L) ((void) 0) ------------------ 621| 56|} lua_getfield: 689| 72|LUA_API int lua_getfield (lua_State *L, int idx, const char *k) { 690| 72| lua_lock(L); ------------------ | | 264| 72|#define lua_lock(L) ((void) 0) ------------------ 691| 72| return auxgetstr(L, index2value(L, idx), k); 692| 72|} lua_createtable: 762| 16|LUA_API void lua_createtable (lua_State *L, int narray, int nrec) { 763| 16| Table *t; 764| 16| lua_lock(L); ------------------ | | 264| 16|#define lua_lock(L) ((void) 0) ------------------ 765| 16| t = luaH_new(L); 766| 16| sethvalue2s(L, L->top.p, t); ------------------ | | 689| 16|#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) | | ------------------ | | | | 685| 16| { TValue *io = (obj); Table *x_ = (x); \ | | | | 686| 16| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 72| 16|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 390| 16|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 16|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 687| 16| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 16| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 16|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 16| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 767| 16| api_incr_top(L); ------------------ | | 16| 16|#define api_incr_top(L) {L->top.p++; \ | | 17| 16| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 16|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 16|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 16| "stack overflow");} ------------------ 768| 16| if (narray > 0 || nrec > 0) ------------------ | Branch (768:7): [True: 0, False: 16] | Branch (768:21): [True: 16, False: 0] ------------------ 769| 16| luaH_resize(L, t, narray, nrec); 770| 16| luaC_checkGC(L); ------------------ | | 172| 16|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 16| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 16|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 16] | | | | ------------------ | | | | 169| 16| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 16|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 771| 16| lua_unlock(L); ------------------ | | 265| 16|#define lua_unlock(L) ((void) 0) ------------------ 772| 16|} lua_setfield: 871| 64|LUA_API void lua_setfield (lua_State *L, int idx, const char *k) { 872| 64| lua_lock(L); /* unlock done in 'auxsetstr' */ ------------------ | | 264| 64|#define lua_lock(L) ((void) 0) ------------------ 873| 64| auxsetstr(L, index2value(L, idx), k); 874| 64|} lua_setmetatable: 933| 16|LUA_API int lua_setmetatable (lua_State *L, int objindex) { 934| 16| TValue *obj; 935| 16| Table *mt; 936| 16| lua_lock(L); ------------------ | | 264| 16|#define lua_lock(L) ((void) 0) ------------------ 937| 16| api_checknelems(L, 1); ------------------ | | 33| 16| api_check(L, (n) < (L->top.p - L->ci->func.p), \ | | ------------------ | | | | 126| 16|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 16|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 34| 16| "not enough elements in the stack") ------------------ 938| 16| obj = index2value(L, objindex); 939| 16| if (ttisnil(s2v(L->top.p - 1))) ------------------ | | 193| 16|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 16|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 16|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 16|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 16] | | | | ------------------ | | ------------------ ------------------ 940| 0| mt = NULL; 941| 16| else { 942| 16| api_check(L, ttistable(s2v(L->top.p - 1)), "table expected"); ------------------ | | 126| 16|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 16|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 943| 16| mt = hvalue(s2v(L->top.p - 1)); ------------------ | | 682| 16|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ 944| 16| } 945| 16| switch (ttype(obj)) { ------------------ | | 87| 16|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 16|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 946| 0| case LUA_TTABLE: { ------------------ | | 69| 0|#define LUA_TTABLE 5 ------------------ | Branch (946:5): [True: 0, False: 16] ------------------ 947| 0| hvalue(obj)->metatable = mt; ------------------ | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 948| 0| if (mt) { ------------------ | Branch (948:11): [True: 0, False: 0] ------------------ 949| 0| luaC_objbarrier(L, gcvalue(obj), mt); ------------------ | | 175| 0|#define luaC_objbarrier(L,p,o) ( \ | | 176| 0| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 0| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 950| 0| luaC_checkfinalizer(L, gcvalue(obj), mt); ------------------ | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 951| 0| } 952| 0| break; 953| 0| } 954| 16| case LUA_TUSERDATA: { ------------------ | | 71| 16|#define LUA_TUSERDATA 7 ------------------ | Branch (954:5): [True: 16, False: 0] ------------------ 955| 16| uvalue(obj)->metatable = mt; ------------------ | | 435| 16|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ 956| 16| if (mt) { ------------------ | Branch (956:11): [True: 16, False: 0] ------------------ 957| 16| luaC_objbarrier(L, uvalue(obj), mt); ------------------ | | 175| 16|#define luaC_objbarrier(L,p,o) ( \ | | 176| 16| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 16|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 16|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 32|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 16] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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| 16| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 16|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 16|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 958| 16| luaC_checkfinalizer(L, gcvalue(obj), mt); ------------------ | | 305| 16|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ 959| 16| } 960| 16| break; 961| 0| } 962| 0| default: { ------------------ | Branch (962:5): [True: 0, False: 16] ------------------ 963| 0| G(L)->mt[ttype(obj)] = mt; ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ G(L)->mt[ttype(obj)] = mt; ------------------ | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 964| 0| break; 965| 0| } 966| 16| } 967| 16| L->top.p--; 968| 16| lua_unlock(L); ------------------ | | 265| 16|#define lua_unlock(L) ((void) 0) ------------------ 969| 16| return 1; 970| 16|} lua_pcallk: 1044| 64| lua_KContext ctx, lua_KFunction k) { 1045| 64| struct CallS c; 1046| 64| int status; 1047| 64| ptrdiff_t func; 1048| 64| lua_lock(L); ------------------ | | 264| 64|#define lua_lock(L) ((void) 0) ------------------ 1049| 64| api_check(L, k == NULL || !isLua(L->ci), ------------------ | | 126| 64|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 64|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1050| 64| "cannot use continuations inside hooks"); 1051| 64| api_checknelems(L, nargs+1); ------------------ | | 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") ------------------ 1052| 64| api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread"); ------------------ | | 126| 64|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 64|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1053| 64| checkresults(L, nargs, nresults); ------------------ | | 999| 64| api_check(L, (nr) == LUA_MULTRET \ | | ------------------ | | | | 126| 64|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 64|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 1000| 64| || (L->ci->top.p - L->top.p >= (nr) - (na)), \ | | 1001| 64| "results from function overflow current stack size") ------------------ 1054| 64| if (errfunc == 0) ------------------ | Branch (1054:7): [True: 0, False: 64] ------------------ 1055| 0| func = 0; 1056| 64| else { 1057| 64| StkId o = index2stack(L, errfunc); 1058| 64| api_check(L, ttisfunction(s2v(o)), "error handler must be a function"); ------------------ | | 126| 64|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 64|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1059| 64| func = savestack(L, o); ------------------ | | 36| 64|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 64|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 64|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 64|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 64|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1060| 64| } 1061| 64| c.func = L->top.p - (nargs+1); /* function to be called */ 1062| 64| if (k == NULL || !yieldable(L)) { /* no continuation or no yieldable? */ ------------------ | | 104| 0|#define yieldable(L) (((L)->nCcalls & 0xffff0000) == 0) ------------------ | Branch (1062:7): [True: 64, False: 0] | Branch (1062:20): [True: 0, False: 0] ------------------ 1063| 64| c.nresults = nresults; /* do a 'conventional' protected call */ 1064| 64| status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func); ------------------ | | 36| 64|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 64|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 64|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 64|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 64|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1065| 64| } 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| 64| adjustresults(L, nresults); ------------------ | | 27| 64| { if ((nres) <= LUA_MULTRET && L->ci->top.p < L->top.p) \ | | ------------------ | | | | 35| 128|#define LUA_MULTRET (-1) | | ------------------ | | | Branch (27:11): [True: 0, False: 64] | | | Branch (27:36): [True: 0, False: 0] | | ------------------ | | 28| 64| L->ci->top.p = L->top.p; } ------------------ 1082| 64| lua_unlock(L); ------------------ | | 265| 64|#define lua_unlock(L) ((void) 0) ------------------ 1083| 64| return status; 1084| 64|} lua_load: 1088| 390| const char *chunkname, const char *mode) { 1089| 390| ZIO z; 1090| 390| int status; 1091| 390| lua_lock(L); ------------------ | | 264| 390|#define lua_lock(L) ((void) 0) ------------------ 1092| 390| if (!chunkname) chunkname = "?"; ------------------ | Branch (1092:7): [True: 0, False: 390] ------------------ 1093| 390| luaZ_init(L, &z, reader, data); 1094| 390| status = luaD_protectedparser(L, &z, chunkname, mode); 1095| 390| if (status == LUA_OK) { /* no errors? */ ------------------ | | 48| 390|#define LUA_OK 0 ------------------ | Branch (1095:7): [True: 64, False: 326] ------------------ 1096| 64| LClosure *f = clLvalue(s2v(L->top.p - 1)); /* get new function */ ------------------ | | 602| 64|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | ------------------ | | | | 115| 64|#define check_exp(c,e) (e) | | ------------------ ------------------ 1097| 64| if (f->nupvalues >= 1) { /* does it have an upvalue? */ ------------------ | Branch (1097:9): [True: 64, False: 0] ------------------ 1098| | /* get global table from registry */ 1099| 64| const TValue *gt = getGtable(L); ------------------ | | 663| 64| (&hvalue(&G(L)->l_registry)->array[LUA_RIDX_GLOBALS - 1]) | | ------------------ | | | | 682| 64|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 64|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | (&hvalue(&G(L)->l_registry)->array[LUA_RIDX_GLOBALS - 1]) | | ------------------ | | | | 84| 64|#define LUA_RIDX_GLOBALS 2 | | ------------------ ------------------ 1100| | /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */ 1101| 64| setobj(L, f->upvals[0]->v.p, gt); ------------------ | | 119| 64| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 64| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 64|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 64| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 64| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 64|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 64| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 64|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 1102| 64| luaC_barrier(L, f->upvals[0], gt); ------------------ | | 179| 64|#define luaC_barrier(L,p,v) ( \ | | 180| 64| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 64|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 64|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 64|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 64, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 64|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 64| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 64|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 64|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 128|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 64] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (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| 64| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 64|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 64|#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| 64| } 1104| 64| } 1105| 390| lua_unlock(L); ------------------ | | 265| 390|#define lua_unlock(L) ((void) 0) ------------------ 1106| 390| return status; 1107| 390|} lua_toclose: 1270| 16|LUA_API void lua_toclose (lua_State *L, int idx) { 1271| 16| int nresults; 1272| 16| StkId o; 1273| 16| lua_lock(L); ------------------ | | 264| 16|#define lua_lock(L) ((void) 0) ------------------ 1274| 16| o = index2stack(L, idx); 1275| 16| nresults = L->ci->nresults; 1276| 16| api_check(L, L->tbclist.p < o, "given index below or equal a marked one"); ------------------ | | 126| 16|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 16|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1277| 16| luaF_newtbcupval(L, o); /* create new to-be-closed upvalue */ 1278| 16| if (!hastocloseCfunc(nresults)) /* function not marked yet? */ ------------------ | | 46| 16|#define hastocloseCfunc(n) ((n) < LUA_MULTRET) | | ------------------ | | | | 35| 16|#define LUA_MULTRET (-1) | | ------------------ ------------------ | Branch (1278:7): [True: 16, False: 0] ------------------ 1279| 16| L->ci->nresults = codeNresults(nresults); /* mark it */ ------------------ | | 49| 16|#define codeNresults(n) (-(n) - 3) ------------------ 1280| 16| lua_assert(hastocloseCfunc(L->ci->nresults)); ------------------ | | 114| 16|#define lua_assert(c) ((void)0) ------------------ 1281| 16| lua_unlock(L); ------------------ | | 265| 16|#define lua_unlock(L) ((void) 0) ------------------ 1282| 16|} lua_getallocf: 1309| 62|LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) { 1310| 62| lua_Alloc f; 1311| 62| lua_lock(L); ------------------ | | 264| 62|#define lua_lock(L) ((void) 0) ------------------ 1312| 62| if (ud) *ud = G(L)->ud; ------------------ | | 335| 62|#define G(L) (L->l_G) ------------------ | Branch (1312:7): [True: 62, False: 0] ------------------ 1313| 62| f = G(L)->frealloc; ------------------ | | 335| 62|#define G(L) (L->l_G) ------------------ 1314| 62| lua_unlock(L); ------------------ | | 265| 62|#define lua_unlock(L) ((void) 0) ------------------ 1315| 62| return f; 1316| 62|} lua_setwarnf: 1327| 390|void lua_setwarnf (lua_State *L, lua_WarnFunction f, void *ud) { 1328| 390| lua_lock(L); ------------------ | | 264| 390|#define lua_lock(L) ((void) 0) ------------------ 1329| 390| G(L)->ud_warn = ud; ------------------ | | 335| 390|#define G(L) (L->l_G) ------------------ 1330| 390| G(L)->warnf = f; ------------------ | | 335| 390|#define G(L) (L->l_G) ------------------ 1331| 390| lua_unlock(L); ------------------ | | 265| 390|#define lua_unlock(L) ((void) 0) ------------------ 1332| 390|} lua_newuserdatauv: 1343| 16|LUA_API void *lua_newuserdatauv (lua_State *L, size_t size, int nuvalue) { 1344| 16| Udata *u; 1345| 16| lua_lock(L); ------------------ | | 264| 16|#define lua_lock(L) ((void) 0) ------------------ 1346| 16| api_check(L, 0 <= nuvalue && nuvalue < USHRT_MAX, "invalid value"); ------------------ | | 126| 16|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 16|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1347| 16| u = luaS_newudata(L, size, nuvalue); 1348| 16| setuvalue(L, s2v(L->top.p), u); ------------------ | | 443| 16| { TValue *io = (obj); Udata *x_ = (x); \ | | 444| 16| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \ | | ------------------ | | | | 72| 16|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \ | | ------------------ | | | | 390| 16|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 16|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \ | | ------------------ | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 445| 16| checkliveness(L,io); } | | ------------------ | | | | 107| 16| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 16|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 16| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 1349| 16| api_incr_top(L); ------------------ | | 16| 16|#define api_incr_top(L) {L->top.p++; \ | | 17| 16| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 16|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 16|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 16| "stack overflow");} ------------------ 1350| 16| luaC_checkGC(L); ------------------ | | 172| 16|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 16| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 16|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 12, False: 4] | | | | ------------------ | | | | 169| 16| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 16|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1351| 16| lua_unlock(L); ------------------ | | 265| 16|#define lua_unlock(L) ((void) 0) ------------------ 1352| 16| return getudatamem(u); ------------------ | | 493| 16|#define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 146| 16|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 16|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 489| 16| ((nuv) == 0 ? offsetof(Udata0, bindata) \ | | | | ------------------ | | | | | Branch (489:3): [True: 16, False: 0] | | | | ------------------ | | | | 490| 16| : offsetof(Udata, uv) + (sizeof(UValue) * (nuv))) | | ------------------ ------------------ 1353| 16|} lapi.c:index2stack: 95| 312|l_sinline StkId index2stack (lua_State *L, int idx) { 96| 312| CallInfo *ci = L->ci; 97| 312| if (idx > 0) { ------------------ | Branch (97:7): [True: 192, False: 120] ------------------ 98| 192| StkId o = ci->func.p + idx; 99| 192| api_check(L, o < L->top.p, "invalid index"); ------------------ | | 126| 192|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 192|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 100| 192| return o; 101| 192| } 102| 120| else { /* non-positive index */ 103| 120| api_check(L, idx != 0 && -idx <= L->top.p - (ci->func.p + 1), ------------------ | | 126| 120|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 120|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 104| 120| "invalid index"); 105| 120| api_check(L, !ispseudo(idx), "invalid index"); ------------------ | | 126| 120|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 120|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 106| 120| return L->top.p + idx; 107| 120| } 108| 312|} lapi.c:reverse: 227| 648|l_sinline void reverse (lua_State *L, StkId from, StkId to) { 228| 824| for (; from < to; from++, to--) { ------------------ | Branch (228:10): [True: 176, False: 648] ------------------ 229| 176| TValue temp; 230| 176| setobj(L, &temp, s2v(from)); ------------------ | | 119| 176| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 176| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 176|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 176| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 176| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 176|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 176| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 176|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 231| 176| setobjs2s(L, from, to); ------------------ | | 129| 176|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 176| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 176| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 176|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 176| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 176| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 176|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 176| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 176|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 232| 176| setobj2s(L, to, &temp); ------------------ | | 131| 176|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 176| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 176| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 176|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 176| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 176| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 176|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 176| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 176|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 233| 176| } 234| 648|} lapi.c:index2value: 60| 836|static TValue *index2value (lua_State *L, int idx) { 61| 836| CallInfo *ci = L->ci; 62| 836| if (idx > 0) { ------------------ | Branch (62:7): [True: 88, False: 748] ------------------ 63| 88| StkId o = ci->func.p + idx; 64| 88| api_check(L, idx <= ci->top.p - (ci->func.p + 1), "unacceptable index"); ------------------ | | 126| 88|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 88|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 65| 88| if (o >= L->top.p) return &G(L)->nilvalue; ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ | Branch (65:9): [True: 0, False: 88] ------------------ 66| 88| else return s2v(o); ------------------ | | 172| 88|#define s2v(o) (&(o)->val) ------------------ 67| 88| } 68| 748| else if (!ispseudo(idx)) { /* negative index */ ------------------ | | 50| 748|#define ispseudo(i) ((i) <= LUA_REGISTRYINDEX) | | ------------------ | | | | 43| 748|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | | | ------------------ | | | | | | 749| 748|#define LUAI_MAXSTACK 1000000 | | | | ------------------ | | ------------------ ------------------ | Branch (68:12): [True: 660, False: 88] ------------------ 69| 660| api_check(L, idx != 0 && -idx <= L->top.p - (ci->func.p + 1), ------------------ | | 126| 660|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 660|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 70| 660| "invalid index"); 71| 660| return s2v(L->top.p + idx); ------------------ | | 172| 660|#define s2v(o) (&(o)->val) ------------------ 72| 660| } 73| 88| else if (idx == LUA_REGISTRYINDEX) ------------------ | | 43| 88|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 749| 88|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ | Branch (73:12): [True: 88, False: 0] ------------------ 74| 88| return &G(L)->l_registry; ------------------ | | 335| 88|#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)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 80| 0| return (idx <= func->nupvalues) ? &func->upvalue[idx-1] ------------------ | Branch (80:14): [True: 0, False: 0] ------------------ 81| 0| : &G(L)->nilvalue; ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ 82| 0| } 83| 0| else { /* light C function or Lua function (through a hook)?) */ 84| 0| api_check(L, ttislcf(s2v(ci->func.p)), "caller not a C function"); ------------------ | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 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| 836|} lapi.c:touserdata: 447| 62|l_sinline void *touserdata (const TValue *o) { 448| 62| switch (ttype(o)) { ------------------ | | 87| 62|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 62|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 449| 62| case LUA_TUSERDATA: return getudatamem(uvalue(o)); ------------------ | | 71| 62|#define LUA_TUSERDATA 7 ------------------ case LUA_TUSERDATA: return getudatamem(uvalue(o)); ------------------ | | 493| 62|#define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 146| 62|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 62|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 489| 62| ((nuv) == 0 ? offsetof(Udata0, bindata) \ | | | | ------------------ | | | | | Branch (489:3): [True: 62, False: 0] | | | | ------------------ | | | | 490| 62| : offsetof(Udata, uv) + (sizeof(UValue) * (nuv))) | | ------------------ ------------------ | Branch (449:5): [True: 62, False: 0] ------------------ 450| 0| case LUA_TLIGHTUSERDATA: return pvalue(o); ------------------ | | 66| 0|#define LUA_TLIGHTUSERDATA 2 ------------------ case LUA_TLIGHTUSERDATA: return pvalue(o); ------------------ | | 434| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (450:5): [True: 0, False: 62] ------------------ 451| 0| default: return NULL; ------------------ | Branch (451:5): [True: 0, False: 62] ------------------ 452| 62| } 453| 62|} lapi.c:auxgetstr: 639| 72|l_sinline int auxgetstr (lua_State *L, const TValue *t, const char *k) { 640| 72| const TValue *slot; 641| 72| TString *str = luaS_new(L, k); 642| 72| if (luaV_fastget(L, t, str, slot, luaH_getstr)) { ------------------ | | 86| 72| (!ttistable(t) \ | | ------------------ | | | | 680| 72|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 72|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 72|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 72] | | | Branch (86:4): [True: 0, False: 72] | | ------------------ | | 87| 72| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 72| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 72|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 72|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 72| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 72|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 72|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 72|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 72|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 72|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 643| 0| setobj2s(L, L->top.p, slot); ------------------ | | 131| 0|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 644| 0| api_incr_top(L); ------------------ | | 16| 0|#define api_incr_top(L) {L->top.p++; \ | | 17| 0| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 0| "stack overflow");} ------------------ 645| 0| } 646| 72| else { 647| 72| setsvalue2s(L, L->top.p, str); ------------------ | | 377| 72|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 72| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 72| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 72|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 72|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 72|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 72|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 72| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 72| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 72|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 72| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 648| 72| api_incr_top(L); ------------------ | | 16| 72|#define api_incr_top(L) {L->top.p++; \ | | 17| 72| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 72|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 72|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 72| "stack overflow");} ------------------ 649| 72| luaV_finishget(L, t, s2v(L->top.p - 1), L->top.p - 1, slot); ------------------ | | 172| 72|#define s2v(o) (&(o)->val) ------------------ 650| 72| } 651| 72| lua_unlock(L); ------------------ | | 265| 72|#define lua_unlock(L) ((void) 0) ------------------ 652| 72| return ttype(s2v(L->top.p - 1)); ------------------ | | 87| 72|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 72|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 653| 72|} lapi.c:auxsetstr: 829| 64|static void auxsetstr (lua_State *L, const TValue *t, const char *k) { 830| 64| const TValue *slot; 831| 64| TString *str = luaS_new(L, k); 832| 64| api_checknelems(L, 1); ------------------ | | 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") ------------------ 833| 64| if (luaV_fastget(L, t, str, slot, luaH_getstr)) { ------------------ | | 86| 64| (!ttistable(t) \ | | ------------------ | | | | 680| 64|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 64|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 64|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 64] | | | Branch (86:4): [True: 0, False: 64] | | ------------------ | | 87| 64| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 64| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 64|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 64|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 64| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 64|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 64|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 64|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 64|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 64|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 834| 0| luaV_finishfastset(L, t, slot, s2v(L->top.p - 1)); ------------------ | | 109| 0| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 0|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | | | ------------------ | | | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 0| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 0|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 0| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 0|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 0| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 835| 0| L->top.p--; /* pop value */ 836| 0| } 837| 64| else { 838| 64| setsvalue2s(L, L->top.p, str); /* push 'str' (to make it a TValue) */ ------------------ | | 377| 64|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 64| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 64| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 64|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 64|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 64|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 64|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 64| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 64| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 64|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 64| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 839| 64| api_incr_top(L); ------------------ | | 16| 64|#define api_incr_top(L) {L->top.p++; \ | | 17| 64| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 64|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 64|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 64| "stack overflow");} ------------------ 840| 64| luaV_finishset(L, t, s2v(L->top.p - 1), s2v(L->top.p - 2), slot); ------------------ | | 172| 64|#define s2v(o) (&(o)->val) ------------------ luaV_finishset(L, t, s2v(L->top.p - 1), s2v(L->top.p - 2), slot); ------------------ | | 172| 64|#define s2v(o) (&(o)->val) ------------------ 841| 64| L->top.p -= 2; /* pop value and key */ 842| 64| } 843| 64| lua_unlock(L); /* lock done by caller */ ------------------ | | 265| 64|#define lua_unlock(L) ((void) 0) ------------------ 844| 64|} lapi.c:f_call: 1036| 64|static void f_call (lua_State *L, void *ud) { 1037| 64| struct CallS *c = cast(struct CallS *, ud); ------------------ | | 136| 64|#define cast(t, exp) ((t)(exp)) ------------------ 1038| 64| luaD_callnoyield(L, c->func, c->nresults); 1039| 64|} luaL_traceback: 132| 56| const char *msg, int level) { 133| 56| luaL_Buffer b; 134| 56| lua_Debug ar; 135| 56| int last = lastlevel(L1); 136| 56| int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1; ------------------ | | 43| 56|#define LEVELS1 10 /* size of the first part of the stack */ ------------------ int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1; ------------------ | | 44| 56|#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: 56] ------------------ 137| 56| luaL_buffinit(L, &b); 138| 56| if (msg) { ------------------ | Branch (138:7): [True: 56, False: 0] ------------------ 139| 56| luaL_addstring(&b, msg); 140| 56| luaL_addchar(&b, '\n'); ------------------ | | 208| 56| ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \ | | ------------------ | | | Branch (208:11): [True: 42, False: 14] | | | Branch (208:33): [True: 14, False: 0] | | ------------------ | | 209| 56| ((B)->b[(B)->n++] = (c))) ------------------ 141| 56| } 142| 56| luaL_addstring(&b, "stack traceback:"); 143| 112| while (lua_getstack(L1, level++, &ar)) { ------------------ | Branch (143:10): [True: 56, False: 56] ------------------ 144| 56| if (limit2show-- == 0) { /* too many levels? */ ------------------ | Branch (144:9): [True: 0, False: 56] ------------------ 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| 56| else { 151| 56| lua_getinfo(L1, "Slnt", &ar); 152| 56| if (ar.currentline <= 0) ------------------ | Branch (152:11): [True: 0, False: 56] ------------------ 153| 0| lua_pushfstring(L, "\n\t%s: in ", ar.short_src); 154| 56| else 155| 56| lua_pushfstring(L, "\n\t%s:%d: in ", ar.short_src, ar.currentline); 156| 56| luaL_addvalue(&b); 157| 56| pushfuncname(L, &ar); 158| 56| luaL_addvalue(&b); 159| 56| if (ar.istailcall) ------------------ | Branch (159:11): [True: 0, False: 56] ------------------ 160| 0| luaL_addstring(&b, "\n\t(...tail calls...)"); 161| 56| } 162| 56| } 163| 56| luaL_pushresult(&b); 164| 56|} luaL_newmetatable: 311| 16|LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) { 312| 16| if (luaL_getmetatable(L, tname) != LUA_TNIL) /* name already in use? */ ------------------ | | 150| 16|#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) | | ------------------ | | | | 43| 16|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | | | ------------------ | | | | | | 749| 16|#define LUAI_MAXSTACK 1000000 | | | | ------------------ | | ------------------ ------------------ if (luaL_getmetatable(L, tname) != LUA_TNIL) /* name already in use? */ ------------------ | | 64| 16|#define LUA_TNIL 0 ------------------ | Branch (312:7): [True: 0, False: 16] ------------------ 313| 0| return 0; /* leave previous value on top, but return 0 */ 314| 16| lua_pop(L, 1); ------------------ | | 375| 16|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 315| 16| lua_createtable(L, 0, 2); /* create metatable */ 316| 16| lua_pushstring(L, tname); 317| 16| lua_setfield(L, -2, "__name"); /* metatable.__name = tname */ 318| 16| lua_pushvalue(L, -1); 319| 16| lua_setfield(L, LUA_REGISTRYINDEX, tname); /* registry.name = metatable */ ------------------ | | 43| 16|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 749| 16|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ 320| 16| return 1; 321| 16|} luaL_checkstack: 380| 16|LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) { 381| 16| if (l_unlikely(!lua_checkstack(L, space))) { ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 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| 16|} luaL_prepbuffsize: 575| 14|LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) { 576| 14| return prepbuffsize(B, sz, -1); 577| 14|} luaL_addlstring: 580| 112|LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) { 581| 112| if (l > 0) { /* avoid 'memcpy' when 's' can be NULL */ ------------------ | Branch (581:7): [True: 112, False: 0] ------------------ 582| 112| char *b = prepbuffsize(B, l, -1); 583| 112| memcpy(b, s, l * sizeof(char)); 584| 112| luaL_addsize(B, l); ------------------ | | 211| 112|#define luaL_addsize(B,s) ((B)->n += (s)) ------------------ 585| 112| } 586| 112|} luaL_addstring: 589| 112|LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) { 590| 112| luaL_addlstring(B, s, strlen(s)); 591| 112|} luaL_pushresult: 594| 56|LUALIB_API void luaL_pushresult (luaL_Buffer *B) { 595| 56| lua_State *L = B->L; 596| 56| checkbufferlevel(B, -1); ------------------ | | 523| 56| lua_assert(buffonstack(B) ? lua_touserdata(B->L, idx) != NULL \ | | ------------------ | | | | 178| 56| #define lua_assert(c) ((void)0) | | ------------------ | | 524| 56| : lua_touserdata(B->L, idx) == (void*)B) ------------------ 597| 56| lua_pushlstring(L, B->b, B->n); 598| 56| if (buffonstack(B)) ------------------ | | 515| 56|#define buffonstack(B) ((B)->b != (B)->init.b) | | ------------------ | | | Branch (515:24): [True: 16, False: 40] | | ------------------ ------------------ 599| 16| lua_closeslot(L, -2); /* close the box */ 600| 56| lua_remove(L, -2); /* remove box or placeholder from the stack */ ------------------ | | 402| 56|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 375| 56|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 601| 56|} luaL_addvalue: 619| 112|LUALIB_API void luaL_addvalue (luaL_Buffer *B) { 620| 112| lua_State *L = B->L; 621| 112| size_t len; 622| 112| const char *s = lua_tolstring(L, -1, &len); 623| 112| char *b = prepbuffsize(B, len, -2); 624| 112| memcpy(b, s, len * sizeof(char)); 625| 112| luaL_addsize(B, len); ------------------ | | 211| 112|#define luaL_addsize(B,s) ((B)->n += (s)) ------------------ 626| 112| lua_pop(L, 1); /* pop string */ ------------------ | | 375| 112|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 627| 112|} luaL_buffinit: 630| 56|LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) { 631| 56| B->L = L; 632| 56| B->b = B->init.b; 633| 56| B->n = 0; 634| 56| B->size = LUAL_BUFFERSIZE; ------------------ | | 775| 56|#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number))) ------------------ 635| 56| lua_pushlightuserdata(L, (void*)B); /* push placeholder */ 636| 56|} luaL_loadbufferx: 835| 390| const char *name, const char *mode) { 836| 390| LoadS ls; 837| 390| ls.s = buff; 838| 390| ls.size = size; 839| 390| return lua_load(L, getS, &ls, name, mode); 840| 390|} luaL_setfuncs: 933| 16|LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) { 934| 16| luaL_checkstack(L, nup, "too many upvalues"); 935| 48| for (; l->name != NULL; l++) { /* fill the table with given functions */ ------------------ | Branch (935:10): [True: 32, False: 16] ------------------ 936| 32| if (l->func == NULL) /* place holder? */ ------------------ | Branch (936:9): [True: 0, False: 32] ------------------ 937| 0| lua_pushboolean(L, 0); 938| 32| else { 939| 32| int i; 940| 32| for (i = 0; i < nup; i++) /* copy upvalues to the top */ ------------------ | Branch (940:19): [True: 0, False: 32] ------------------ 941| 0| lua_pushvalue(L, -nup); 942| 32| lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */ 943| 32| } 944| 32| lua_setfield(L, -(nup + 2), l->name); 945| 32| } 946| 16| lua_pop(L, nup); /* remove upvalues */ ------------------ | | 375| 16|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 947| 16|} luaL_newstate: 1094| 390|LUALIB_API lua_State *luaL_newstate (void) { 1095| 390| lua_State *L = lua_newstate(l_alloc, NULL); 1096| 390| if (l_likely(L)) { ------------------ | | 696| 390|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 684| 390|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (684:25): [True: 390, False: 0] | | | | ------------------ | | ------------------ ------------------ 1097| 390| lua_atpanic(L, &panic); 1098| 390| lua_setwarnf(L, warnfoff, L); /* default is warnings off */ 1099| 390| } 1100| 390| return L; 1101| 390|} lauxlib.c:lastlevel: 116| 56|static int lastlevel (lua_State *L) { 117| 56| lua_Debug ar; 118| 56| int li = 1, le = 1; 119| | /* find an upper bound */ 120| 112| while (lua_getstack(L, le, &ar)) { li = le; le *= 2; } ------------------ | Branch (120:10): [True: 56, False: 56] ------------------ 121| | /* do a binary search */ 122| 112| while (li < le) { ------------------ | Branch (122:10): [True: 56, False: 56] ------------------ 123| 56| int m = (li + le)/2; 124| 56| if (lua_getstack(L, m, &ar)) li = m + 1; ------------------ | Branch (124:9): [True: 56, False: 0] ------------------ 125| 0| else le = m; 126| 56| } 127| 56| return le - 1; 128| 56|} lauxlib.c:pushfuncname: 100| 56|static void pushfuncname (lua_State *L, lua_Debug *ar) { 101| 56| if (pushglobalfuncname(L, ar)) { /* try first a global name */ ------------------ | Branch (101:7): [True: 0, False: 56] ------------------ 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| 56| else if (*ar->namewhat != '\0') /* is there a name from code? */ ------------------ | Branch (105:12): [True: 0, False: 56] ------------------ 106| 0| lua_pushfstring(L, "%s '%s'", ar->namewhat, ar->name); /* use it */ 107| 56| else if (*ar->what == 'm') /* main? */ ------------------ | Branch (107:12): [True: 56, False: 0] ------------------ 108| 56| lua_pushliteral(L, "main chunk"); ------------------ | | 392| 56|#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| 56|} lauxlib.c:pushglobalfuncname: 79| 56|static int pushglobalfuncname (lua_State *L, lua_Debug *ar) { 80| 56| int top = lua_gettop(L); 81| 56| lua_getinfo(L, "f", ar); /* push function */ 82| 56| lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); ------------------ | | 43| 56|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 749| 56|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); ------------------ | | 31| 56|#define LUA_LOADED_TABLE "_LOADED" ------------------ 83| 56| if (findfield(L, top + 1, 2)) { ------------------ | Branch (83:7): [True: 0, False: 56] ------------------ 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| 56| else { 94| 56| lua_settop(L, top); /* remove function and global table */ 95| 56| return 0; 96| 56| } 97| 56|} lauxlib.c:findfield: 52| 56|static int findfield (lua_State *L, int objidx, int level) { 53| 56| if (level == 0 || !lua_istable(L, -1)) ------------------ | | 384| 56|#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE) | | ------------------ | | | | 69| 56|#define LUA_TTABLE 5 | | ------------------ ------------------ | Branch (53:7): [True: 0, False: 56] | Branch (53:21): [True: 56, False: 0] ------------------ 54| 56| 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| 238|static char *prepbuffsize (luaL_Buffer *B, size_t sz, int boxidx) { 548| 238| checkbufferlevel(B, boxidx); ------------------ | | 523| 238| lua_assert(buffonstack(B) ? lua_touserdata(B->L, idx) != NULL \ | | ------------------ | | | | 178| 238| #define lua_assert(c) ((void)0) | | ------------------ | | 524| 238| : lua_touserdata(B->L, idx) == (void*)B) ------------------ 549| 238| if (B->size - B->n >= sz) /* enough space? */ ------------------ | Branch (549:7): [True: 208, False: 30] ------------------ 550| 208| return B->b + B->n; 551| 30| else { 552| 30| lua_State *L = B->L; 553| 30| char *newbuff; 554| 30| size_t newsize = newbuffsize(B, sz); 555| | /* create larger buffer */ 556| 30| if (buffonstack(B)) /* buffer already has a box? */ ------------------ | | 515| 30|#define buffonstack(B) ((B)->b != (B)->init.b) | | ------------------ | | | Branch (515:24): [True: 14, False: 16] | | ------------------ ------------------ 557| 14| newbuff = (char *)resizebox(L, boxidx, newsize); /* resize it */ 558| 16| else { /* no box yet */ 559| 16| lua_remove(L, boxidx); /* remove placeholder */ ------------------ | | 402| 16|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 375| 16|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 560| 16| newbox(L); /* create a new box */ 561| 16| lua_insert(L, boxidx); /* move box to its intended position */ ------------------ | | 400| 16|#define lua_insert(L,idx) lua_rotate(L, (idx), 1) ------------------ 562| 16| lua_toclose(L, boxidx); 563| 16| newbuff = (char *)resizebox(L, boxidx, newsize); 564| 16| memcpy(newbuff, B->b, B->n * sizeof(char)); /* copy original content */ 565| 16| } 566| 30| B->b = newbuff; 567| 30| B->size = newsize; 568| 30| return newbuff + B->n; 569| 30| } 570| 238|} lauxlib.c:newbuffsize: 532| 30|static size_t newbuffsize (luaL_Buffer *B, size_t sz) { 533| 30| size_t newsize = (B->size / 2) * 3; /* buffer size * 1.5 */ 534| 30| if (l_unlikely(MAX_SIZET - sz < B->n)) /* overflow in (B->n + sz)? */ ------------------ | | 697| 30|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 30|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 30] | | | | ------------------ | | ------------------ ------------------ 535| 0| return luaL_error(B->L, "buffer too large"); 536| 30| if (newsize < B->n + sz) /* not big enough? */ ------------------ | Branch (536:7): [True: 14, False: 16] ------------------ 537| 14| newsize = B->n + sz; 538| 30| return newsize; 539| 30|} lauxlib.c:resizebox: 473| 62|static void *resizebox (lua_State *L, int idx, size_t newsize) { 474| 62| void *ud; 475| 62| lua_Alloc allocf = lua_getallocf(L, &ud); 476| 62| UBox *box = (UBox *)lua_touserdata(L, idx); 477| 62| void *temp = allocf(ud, box->box, box->bsize, newsize); 478| 62| if (l_unlikely(temp == NULL && newsize > 0)) { /* allocation error? */ ------------------ | | 697| 62|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 94|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 62] | | | | | Branch (685:46): [True: 32, False: 30] | | | | | Branch (685:46): [True: 0, False: 32] | | | | ------------------ | | ------------------ ------------------ 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| 62| box->box = temp; 483| 62| box->bsize = newsize; 484| 62| return temp; 485| 62|} lauxlib.c:newbox: 501| 16|static void newbox (lua_State *L) { 502| 16| UBox *box = (UBox *)lua_newuserdatauv(L, sizeof(UBox), 0); 503| 16| box->box = NULL; 504| 16| box->bsize = 0; 505| 16| if (luaL_newmetatable(L, "_UBOX*")) /* creating metatable? */ ------------------ | Branch (505:7): [True: 16, False: 0] ------------------ 506| 16| luaL_setfuncs(L, boxmt, 0); /* set its metamethods */ 507| 16| lua_setmetatable(L, -2); 508| 16|} lauxlib.c:boxgc: 488| 32|static int boxgc (lua_State *L) { 489| 32| resizebox(L, 1, 0); 490| 32| return 0; 491| 32|} lauxlib.c:getS: 824| 507|static const char *getS (lua_State *L, void *ud, size_t *size) { 825| 507| LoadS *ls = (LoadS *)ud; 826| 507| (void)L; /* not used */ 827| 507| if (ls->size == 0) return NULL; ------------------ | Branch (827:7): [True: 117, False: 390] ------------------ 828| 390| *size = ls->size; 829| 390| ls->size = 0; 830| 390| return ls->s; 831| 507|} lauxlib.c:l_alloc: 1017| 1.32M|static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) { 1018| 1.32M| (void)ud; (void)osize; /* not used */ 1019| 1.32M| if (nsize == 0) { ------------------ | Branch (1019:7): [True: 649k, False: 678k] ------------------ 1020| 649k| free(ptr); 1021| 649k| return NULL; 1022| 649k| } 1023| 678k| else 1024| 678k| return realloc(ptr, nsize); 1025| 1.32M|} luaK_semerror: 46| 8|l_noret luaK_semerror (LexState *ls, const char *msg) { 47| 8| ls->t.token = 0; /* remove "near " from final message */ 48| 8| luaX_syntaxerror(ls, msg); 49| 8|} luaK_exp2const: 84| 2.32k|int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v) { 85| 2.32k| if (hasjumps(e)) ------------------ | | 38| 2.32k|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 14, False: 2.31k] | | ------------------ ------------------ 86| 14| return 0; /* not a constant */ 87| 2.31k| switch (e->k) { 88| 269| case VFALSE: ------------------ | Branch (88:5): [True: 269, False: 2.04k] ------------------ 89| 269| setbfvalue(v); ------------------ | | 250| 269|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 269|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 90| 269| return 1; 91| 210| case VTRUE: ------------------ | Branch (91:5): [True: 210, False: 2.10k] ------------------ 92| 210| setbtvalue(v); ------------------ | | 251| 210|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 210|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 93| 210| return 1; 94| 145| case VNIL: ------------------ | Branch (94:5): [True: 145, False: 2.16k] ------------------ 95| 145| setnilvalue(v); ------------------ | | 200| 145|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 145|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 96| 145| return 1; 97| 72| case VKSTR: { ------------------ | Branch (97:5): [True: 72, False: 2.23k] ------------------ 98| 72| setsvalue(fs->ls->L, v, e->u.strval); ------------------ | | 372| 72| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 72| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 72|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 72|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 72|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 72|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 72| checkliveness(L,io); } | | ------------------ | | | | 107| 72| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 72|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 72| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 99| 72| return 1; 100| 0| } 101| 21| case VCONST: { ------------------ | Branch (101:5): [True: 21, False: 2.28k] ------------------ 102| 21| setobj(fs->ls->L, v, const2val(fs, e)); ------------------ | | 119| 21| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 21| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 21|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 21| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 21| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 21|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 21| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 21|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 103| 21| return 1; 104| 0| } 105| 1.59k| default: return tonumeral(e, v); ------------------ | Branch (105:5): [True: 1.59k, False: 717] ------------------ 106| 2.31k| } 107| 2.31k|} luaK_nil: 131| 179k|void luaK_nil (FuncState *fs, int from, int n) { 132| 179k| int l = from + n - 1; /* last register to set nil */ 133| 179k| Instruction *previous = previousinstruction(fs); 134| 179k| if (GET_OPCODE(*previous) == OP_LOADNIL) { /* previous is LOADNIL? */ ------------------ | | 114| 179k|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 179k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (134:7): [True: 578, False: 178k] ------------------ 135| 578| int pfrom = GETARG_A(*previous); /* get previous range */ ------------------ | | 125| 578|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 578|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 578|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 578|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 136| 578| int pl = pfrom + GETARG_B(*previous); ------------------ | | 128| 578|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 578|#define check_exp(c,e) (e) | | ------------------ ------------------ 137| 578| if ((pfrom <= from && from <= pl + 1) || ------------------ | Branch (137:10): [True: 545, False: 33] | Branch (137:27): [True: 512, False: 33] ------------------ 138| 578| (from <= pfrom && pfrom <= l + 1)) { /* can connect both? */ ------------------ | Branch (138:10): [True: 33, False: 33] | Branch (138:27): [True: 0, False: 33] ------------------ 139| 512| if (pfrom < from) from = pfrom; /* from = min(from, pfrom) */ ------------------ | Branch (139:11): [True: 512, False: 0] ------------------ 140| 512| if (pl > l) l = pl; /* l = max(l, pl) */ ------------------ | Branch (140:11): [True: 0, False: 512] ------------------ 141| 512| SETARG_A(*previous, from); ------------------ | | 126| 512|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 512|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 512|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 512|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 512| ((cast(Instruction, v)<lasttarget = fs->pc; 234| 25.4M| return fs->pc; 235| 25.4M|} luaK_patchlist: 306| 6.54M|void luaK_patchlist (FuncState *fs, int list, int target) { 307| 6.54M| lua_assert(target <= fs->pc); ------------------ | | 114| 6.54M|#define lua_assert(c) ((void)0) ------------------ 308| 6.54M| patchlistaux(fs, list, target, NO_REG, target); ------------------ | | 182| 6.54M|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 6.54M|#define MAXARG_A ((1<f; 384| | /* put new instruction in code array */ 385| 58.6M| luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction, ------------------ | | 67| 58.6M| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 117M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 58.6M| luaM_limitN(limit,t),e))) ------------------ 386| 58.6M| MAX_INT, "opcodes"); 387| 58.6M| f->code[fs->pc++] = i; 388| 58.6M| savelineinfo(fs, f, fs->ls->lastline); 389| 58.6M| return fs->pc - 1; /* index of new instruction */ 390| 58.6M|} luaK_codeABCk: 397| 48.4M|int luaK_codeABCk (FuncState *fs, OpCode o, int a, int b, int c, int k) { 398| 48.4M| lua_assert(getOpMode(o) == iABC); ------------------ | | 114| 48.4M|#define lua_assert(c) ((void)0) ------------------ 399| 48.4M| lua_assert(a <= MAXARG_A && b <= MAXARG_B && ------------------ | | 114| 48.4M|#define lua_assert(c) ((void)0) ------------------ 400| 48.4M| c <= MAXARG_C && (k & ~1) == 0); 401| 48.4M| return luaK_code(fs, CREATE_ABCk(o, a, b, c, k)); ------------------ | | 156| 48.4M|#define CREATE_ABCk(o,a,b,c,k) ((cast(Instruction, o)<freereg + n; 468| 32.8M| if (newstack > fs->f->maxstacksize) { ------------------ | Branch (468:7): [True: 35.5k, False: 32.7M] ------------------ 469| 35.5k| if (newstack >= MAXREGS) ------------------ | | 35| 35.5k|#define MAXREGS 255 ------------------ | Branch (469:9): [True: 0, False: 35.5k] ------------------ 470| 0| luaX_syntaxerror(fs->ls, 471| 0| "function or expression needs too many registers"); 472| 35.5k| fs->f->maxstacksize = cast_byte(newstack); ------------------ | | 143| 35.5k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 35.5k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 473| 35.5k| } 474| 32.8M|} luaK_reserveregs: 480| 32.8M|void luaK_reserveregs (FuncState *fs, int n) { 481| 32.8M| luaK_checkstack(fs, n); 482| 32.8M| fs->freereg += n; 483| 32.8M|} luaK_int: 672| 46.5k|void luaK_int (FuncState *fs, int reg, lua_Integer i) { 673| 46.5k| if (fitsBx(i)) ------------------ | Branch (673:7): [True: 42.7k, False: 3.80k] ------------------ 674| 42.7k| codeAsBx(fs, OP_LOADI, reg, cast_int(i)); ------------------ | | 141| 42.7k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 42.7k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 675| 3.80k| else 676| 3.80k| luaK_codek(fs, reg, luaK_intK(fs, i)); 677| 46.5k|} luaK_setreturns: 721| 2.63k|void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) { 722| 2.63k| Instruction *pc = &getinstruction(fs, e); ------------------ | | 55| 2.63k|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 723| 2.63k| if (e->k == VCALL) /* expression is an open function call? */ ------------------ | Branch (723:7): [True: 2.16k, False: 477] ------------------ 724| 2.63k| SETARG_C(*pc, nresults + 1); ------------------ | | 134| 2.16k|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 2.16k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 2.16k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 2.16k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 2.16k| ((cast(Instruction, v)<k == VVARARG); ------------------ | | 114| 477|#define lua_assert(c) ((void)0) ------------------ 727| 477| SETARG_C(*pc, nresults + 1); ------------------ | | 134| 477|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 477|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 477|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 477|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 477| ((cast(Instruction, v)<freereg); ------------------ | | 126| 477|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 477|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 477|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 477|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 477| ((cast(Instruction, v)<k == VCALL) { /* expression is an open function call? */ ------------------ | Branch (755:7): [True: 432k, False: 18.2k] ------------------ 756| | /* already returns 1 value */ 757| 432k| lua_assert(GETARG_C(getinstruction(fs, e)) == 2); ------------------ | | 114| 432k|#define lua_assert(c) ((void)0) ------------------ 758| 432k| e->k = VNONRELOC; /* result has fixed position */ 759| 432k| e->u.info = GETARG_A(getinstruction(fs, e)); ------------------ | | 125| 432k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 432k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 432k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 432k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 760| 432k| } 761| 18.2k| else if (e->k == VVARARG) { ------------------ | Branch (761:12): [True: 693, False: 17.5k] ------------------ 762| 693| SETARG_C(getinstruction(fs, e), 2); ------------------ | | 134| 693|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 693|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 693|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 693|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 693| ((cast(Instruction, v)<k = VRELOC; /* can relocate its simple result */ 764| 693| } 765| 451k|} luaK_dischargevars: 772| 137M|void luaK_dischargevars (FuncState *fs, expdesc *e) { 773| 137M| switch (e->k) { 774| 531k| case VCONST: { ------------------ | Branch (774:5): [True: 531k, False: 136M] ------------------ 775| 531k| const2exp(const2val(fs, e), e); 776| 531k| break; 777| 0| } 778| 155k| case VLOCAL: { /* already in a register */ ------------------ | Branch (778:5): [True: 155k, False: 136M] ------------------ 779| 155k| e->u.info = e->u.var.ridx; 780| 155k| e->k = VNONRELOC; /* becomes a non-relocatable value */ 781| 155k| break; 782| 0| } 783| 2.98M| case VUPVAL: { /* move value to some (pending) register */ ------------------ | Branch (783:5): [True: 2.98M, False: 134M] ------------------ 784| 2.98M| e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0); ------------------ | | 48| 2.98M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 785| 2.98M| e->k = VRELOC; 786| 2.98M| break; 787| 0| } 788| 9.04M| case VINDEXUP: { ------------------ | Branch (788:5): [True: 9.04M, False: 128M] ------------------ 789| 9.04M| e->u.info = luaK_codeABC(fs, OP_GETTABUP, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 9.04M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 790| 9.04M| e->k = VRELOC; 791| 9.04M| break; 792| 0| } 793| 335| case VINDEXI: { ------------------ | Branch (793:5): [True: 335, False: 137M] ------------------ 794| 335| freereg(fs, e->u.ind.t); 795| 335| e->u.info = luaK_codeABC(fs, OP_GETI, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 335|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 796| 335| e->k = VRELOC; 797| 335| break; 798| 0| } 799| 628k| case VINDEXSTR: { ------------------ | Branch (799:5): [True: 628k, False: 136M] ------------------ 800| 628k| freereg(fs, e->u.ind.t); 801| 628k| e->u.info = luaK_codeABC(fs, OP_GETFIELD, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 628k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 802| 628k| e->k = VRELOC; 803| 628k| break; 804| 0| } 805| 3.00M| case VINDEXED: { ------------------ | Branch (805:5): [True: 3.00M, False: 134M] ------------------ 806| 3.00M| freeregs(fs, e->u.ind.t, e->u.ind.idx); 807| 3.00M| e->u.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 3.00M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 808| 3.00M| e->k = VRELOC; 809| 3.00M| break; 810| 0| } 811| 433k| case VVARARG: case VCALL: { ------------------ | Branch (811:5): [True: 491, False: 137M] | Branch (811:19): [True: 432k, False: 136M] ------------------ 812| 433k| luaK_setoneret(fs, e); 813| 433k| break; 814| 491| } 815| 120M| default: break; /* there is one value available (somewhere) */ ------------------ | Branch (815:5): [True: 120M, False: 16.7M] ------------------ 816| 137M| } 817| 137M|} luaK_exp2nextreg: 942| 32.7M|void luaK_exp2nextreg (FuncState *fs, expdesc *e) { 943| 32.7M| luaK_dischargevars(fs, e); 944| 32.7M| freeexp(fs, e); 945| 32.7M| luaK_reserveregs(fs, 1); 946| 32.7M| exp2reg(fs, e, fs->freereg - 1); 947| 32.7M|} luaK_exp2anyreg: 954| 44.7M|int luaK_exp2anyreg (FuncState *fs, expdesc *e) { 955| 44.7M| luaK_dischargevars(fs, e); 956| 44.7M| if (e->k == VNONRELOC) { /* expression already has a register? */ ------------------ | Branch (956:7): [True: 12.9M, False: 31.8M] ------------------ 957| 12.9M| if (!hasjumps(e)) /* no jumps? */ ------------------ | | 38| 12.9M|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (957:9): [True: 12.9M, False: 19.6k] ------------------ 958| 12.9M| return e->u.info; /* result is already in a register */ 959| 19.6k| if (e->u.info >= luaY_nvarstack(fs)) { /* reg. is not a local? */ ------------------ | Branch (959:9): [True: 16.7k, False: 2.95k] ------------------ 960| 16.7k| exp2reg(fs, e, e->u.info); /* put final result in it */ 961| 16.7k| return e->u.info; 962| 16.7k| } 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| 19.6k| } 967| 31.8M| luaK_exp2nextreg(fs, e); /* default: use next available register */ 968| 31.8M| return e->u.info; 969| 44.7M|} luaK_exp2anyregup: 976| 12.7M|void luaK_exp2anyregup (FuncState *fs, expdesc *e) { 977| 12.7M| if (e->k != VUPVAL || hasjumps(e)) ------------------ | | 38| 12.0M|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 0, False: 12.0M] | | ------------------ ------------------ | Branch (977:7): [True: 655k, False: 12.0M] ------------------ 978| 655k| luaK_exp2anyreg(fs, e); 979| 12.7M|} luaK_exp2val: 986| 23.2k|void luaK_exp2val (FuncState *fs, expdesc *e) { 987| 23.2k| if (hasjumps(e)) ------------------ | | 38| 23.2k|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 336, False: 22.8k] | | ------------------ ------------------ 988| 336| luaK_exp2anyreg(fs, e); 989| 22.8k| else 990| 22.8k| luaK_dischargevars(fs, e); 991| 23.2k|} luaK_storevar: 1048| 28.8k|void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) { 1049| 28.8k| switch (var->k) { 1050| 3.30k| case VLOCAL: { ------------------ | Branch (1050:5): [True: 3.30k, False: 25.5k] ------------------ 1051| 3.30k| freeexp(fs, ex); 1052| 3.30k| exp2reg(fs, ex, var->u.var.ridx); /* compute 'ex' into proper place */ 1053| 3.30k| return; 1054| 0| } 1055| 1.22k| case VUPVAL: { ------------------ | Branch (1055:5): [True: 1.22k, False: 27.6k] ------------------ 1056| 1.22k| int e = luaK_exp2anyreg(fs, ex); 1057| 1.22k| luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0); ------------------ | | 48| 1.22k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1058| 1.22k| break; 1059| 0| } 1060| 16.6k| case VINDEXUP: { ------------------ | Branch (1060:5): [True: 16.6k, False: 12.2k] ------------------ 1061| 16.6k| codeABRK(fs, OP_SETTABUP, var->u.ind.t, var->u.ind.idx, ex); 1062| 16.6k| break; 1063| 0| } 1064| 604| case VINDEXI: { ------------------ | Branch (1064:5): [True: 604, False: 28.2k] ------------------ 1065| 604| codeABRK(fs, OP_SETI, var->u.ind.t, var->u.ind.idx, ex); 1066| 604| break; 1067| 0| } 1068| 4.80k| case VINDEXSTR: { ------------------ | Branch (1068:5): [True: 4.80k, False: 24.0k] ------------------ 1069| 4.80k| codeABRK(fs, OP_SETFIELD, var->u.ind.t, var->u.ind.idx, ex); 1070| 4.80k| break; 1071| 0| } 1072| 2.33k| case VINDEXED: { ------------------ | Branch (1072:5): [True: 2.33k, False: 26.5k] ------------------ 1073| 2.33k| codeABRK(fs, OP_SETTABLE, var->u.ind.t, var->u.ind.idx, ex); 1074| 2.33k| break; 1075| 0| } 1076| 0| default: lua_assert(0); /* invalid var kind to store */ ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (1076:5): [True: 0, False: 28.8k] ------------------ 1077| 28.8k| } 1078| 25.5k| freeexp(fs, ex); 1079| 25.5k|} luaK_self: 1085| 1.17k|void luaK_self (FuncState *fs, expdesc *e, expdesc *key) { 1086| 1.17k| int ereg; 1087| 1.17k| luaK_exp2anyreg(fs, e); 1088| 1.17k| ereg = e->u.info; /* register where 'e' was placed */ 1089| 1.17k| freeexp(fs, e); 1090| 1.17k| e->u.info = fs->freereg; /* base register for op_self */ 1091| 1.17k| e->k = VNONRELOC; /* self expression has a fixed register */ 1092| 1.17k| luaK_reserveregs(fs, 2); /* function and 'self' produced by op_self */ 1093| 1.17k| codeABRK(fs, OP_SELF, e->u.info, ereg, key); 1094| 1.17k| freeexp(fs, key); 1095| 1.17k|} luaK_goiftrue: 1133| 34.0k|void luaK_goiftrue (FuncState *fs, expdesc *e) { 1134| 34.0k| int pc; /* pc of new jump */ 1135| 34.0k| luaK_dischargevars(fs, e); 1136| 34.0k| switch (e->k) { 1137| 7.14k| case VJMP: { /* condition? */ ------------------ | Branch (1137:5): [True: 7.14k, False: 26.9k] ------------------ 1138| 7.14k| negatecondition(fs, e); /* jump when it is false */ 1139| 7.14k| pc = e->u.info; /* save jump position */ 1140| 7.14k| break; 1141| 0| } 1142| 2.47k| case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: { ------------------ | Branch (1142:5): [True: 0, False: 34.0k] | Branch (1142:14): [True: 460, False: 33.6k] | Branch (1142:26): [True: 610, False: 33.4k] | Branch (1142:38): [True: 311, False: 33.7k] | Branch (1142:50): [True: 1.09k, False: 32.9k] ------------------ 1143| 2.47k| pc = NO_JUMP; /* always true; do nothing */ ------------------ | | 20| 2.47k|#define NO_JUMP (-1) ------------------ 1144| 2.47k| break; 1145| 1.38k| } 1146| 24.4k| default: { ------------------ | Branch (1146:5): [True: 24.4k, False: 9.61k] ------------------ 1147| 24.4k| pc = jumponcond(fs, e, 0); /* jump when false */ 1148| 24.4k| break; 1149| 1.38k| } 1150| 34.0k| } 1151| 34.0k| luaK_concat(fs, &e->f, pc); /* insert new jump in false list */ 1152| 34.0k| luaK_patchtohere(fs, e->t); /* true list jumps to here (to go through) */ 1153| 34.0k| e->t = NO_JUMP; ------------------ | | 20| 34.0k|#define NO_JUMP (-1) ------------------ 1154| 34.0k|} luaK_goiffalse: 1160| 193k|void luaK_goiffalse (FuncState *fs, expdesc *e) { 1161| 193k| int pc; /* pc of new jump */ 1162| 193k| luaK_dischargevars(fs, e); 1163| 193k| switch (e->k) { 1164| 171k| case VJMP: { ------------------ | Branch (1164:5): [True: 171k, False: 22.6k] ------------------ 1165| 171k| pc = e->u.info; /* already jump if true */ 1166| 171k| break; 1167| 0| } 1168| 270| case VNIL: case VFALSE: { ------------------ | Branch (1168:5): [True: 270, False: 193k] | Branch (1168:16): [True: 0, False: 193k] ------------------ 1169| 270| pc = NO_JUMP; /* always false; do nothing */ ------------------ | | 20| 270|#define NO_JUMP (-1) ------------------ 1170| 270| break; 1171| 270| } 1172| 22.3k| default: { ------------------ | Branch (1172:5): [True: 22.3k, False: 171k] ------------------ 1173| 22.3k| pc = jumponcond(fs, e, 1); /* jump if true */ 1174| 22.3k| break; 1175| 270| } 1176| 193k| } 1177| 193k| luaK_concat(fs, &e->t, pc); /* insert new jump in 't' list */ 1178| 193k| luaK_patchtohere(fs, e->f); /* false list jumps to here (to go through) */ 1179| 193k| e->f = NO_JUMP; ------------------ | | 20| 193k|#define NO_JUMP (-1) ------------------ 1180| 193k|} luaK_indexed: 1278| 12.7M|void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) { 1279| 12.7M| if (k->k == VKSTR) ------------------ | Branch (1279:7): [True: 12.6M, False: 23.2k] ------------------ 1280| 12.6M| str2K(fs, k); 1281| 12.7M| lua_assert(!hasjumps(t) && ------------------ | | 114| 12.7M|#define lua_assert(c) ((void)0) ------------------ 1282| 12.7M| (t->k == VLOCAL || t->k == VNONRELOC || t->k == VUPVAL)); 1283| 12.7M| if (t->k == VUPVAL && !isKstr(fs, k)) /* upvalue indexed by non 'Kstr'? */ ------------------ | Branch (1283:7): [True: 12.0M, False: 655k] | Branch (1283:25): [True: 2.98M, False: 9.06M] ------------------ 1284| 2.98M| luaK_exp2anyreg(fs, t); /* put it in a register */ 1285| 12.7M| if (t->k == VUPVAL) { ------------------ | Branch (1285:7): [True: 9.06M, False: 3.63M] ------------------ 1286| 9.06M| lua_assert(isKstr(fs, k)); ------------------ | | 114| 9.06M|#define lua_assert(c) ((void)0) ------------------ 1287| 9.06M| t->u.ind.t = t->u.info; /* upvalue index */ 1288| 9.06M| t->u.ind.idx = k->u.info; /* literal short string */ 1289| 9.06M| t->k = VINDEXUP; 1290| 9.06M| } 1291| 3.63M| else { 1292| | /* register index of the table */ 1293| 3.63M| t->u.ind.t = (t->k == VLOCAL) ? t->u.var.ridx: t->u.info; ------------------ | Branch (1293:18): [True: 0, False: 3.63M] ------------------ 1294| 3.63M| if (isKstr(fs, k)) { ------------------ | Branch (1294:9): [True: 633k, False: 3.00M] ------------------ 1295| 633k| t->u.ind.idx = k->u.info; /* literal short string */ 1296| 633k| t->k = VINDEXSTR; 1297| 633k| } 1298| 3.00M| else if (isCint(k)) { ------------------ | Branch (1298:14): [True: 941, False: 3.00M] ------------------ 1299| 941| t->u.ind.idx = cast_int(k->u.ival); /* int. constant in proper range */ ------------------ | | 141| 941|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 941|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1300| 941| t->k = VINDEXI; 1301| 941| } 1302| 3.00M| else { 1303| 3.00M| t->u.ind.idx = luaK_exp2anyreg(fs, k); /* register */ 1304| 3.00M| t->k = VINDEXED; 1305| 3.00M| } 1306| 3.63M| } 1307| 12.7M|} luaK_prefix: 1613| 325k|void luaK_prefix (FuncState *fs, UnOpr opr, expdesc *e, int line) { 1614| 325k| static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP}; ------------------ | | 20| 325k|#define NO_JUMP (-1) ------------------ static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP}; ------------------ | | 20| 325k|#define NO_JUMP (-1) ------------------ 1615| 325k| luaK_dischargevars(fs, e); 1616| 325k| switch (opr) { 1617| 282k| case OPR_MINUS: case OPR_BNOT: /* use 'ef' as fake 2nd operand */ ------------------ | Branch (1617:5): [True: 176k, False: 148k] | Branch (1617:21): [True: 106k, False: 219k] ------------------ 1618| 282k| if (constfolding(fs, opr + LUA_OPUNM, e, &ef)) ------------------ | | 227| 282k|#define LUA_OPUNM 12 ------------------ | Branch (1618:11): [True: 58.3k, False: 223k] ------------------ 1619| 58.3k| break; 1620| | /* else */ /* FALLTHROUGH */ 1621| 260k| case OPR_LEN: ------------------ | Branch (1621:5): [True: 36.6k, False: 288k] ------------------ 1622| 260k| codeunexpval(fs, unopr2op(opr), e, line); 1623| 260k| break; 1624| 6.33k| case OPR_NOT: codenot(fs, e); break; ------------------ | Branch (1624:5): [True: 6.33k, False: 318k] ------------------ 1625| 0| default: lua_assert(0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (1625:5): [True: 0, False: 325k] ------------------ 1626| 325k| } 1627| 325k|} luaK_infix: 1634| 13.0M|void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) { 1635| 13.0M| luaK_dischargevars(fs, v); 1636| 13.0M| switch (op) { 1637| 32.0k| case OPR_AND: { ------------------ | Branch (1637:5): [True: 32.0k, False: 13.0M] ------------------ 1638| 32.0k| luaK_goiftrue(fs, v); /* go ahead only if 'v' is true */ 1639| 32.0k| break; 1640| 0| } 1641| 191k| case OPR_OR: { ------------------ | Branch (1641:5): [True: 191k, False: 12.8M] ------------------ 1642| 191k| luaK_goiffalse(fs, v); /* go ahead only if 'v' is false */ 1643| 191k| break; 1644| 0| } 1645| 18.7k| case OPR_CONCAT: { ------------------ | Branch (1645:5): [True: 18.7k, False: 13.0M] ------------------ 1646| 18.7k| luaK_exp2nextreg(fs, v); /* operand must be on the stack */ 1647| 18.7k| break; 1648| 0| } 1649| 42.5k| case OPR_ADD: case OPR_SUB: ------------------ | Branch (1649:5): [True: 5.67k, False: 13.0M] | Branch (1649:19): [True: 36.9k, False: 13.0M] ------------------ 1650| 5.33M| case OPR_MUL: case OPR_DIV: case OPR_IDIV: ------------------ | Branch (1650:5): [True: 38.3k, False: 12.9M] | Branch (1650:19): [True: 5.21M, False: 7.81M] | Branch (1650:33): [True: 33.7k, False: 13.0M] ------------------ 1651| 5.89M| case OPR_MOD: case OPR_POW: ------------------ | Branch (1651:5): [True: 24.9k, False: 13.0M] | Branch (1651:19): [True: 538k, False: 12.4M] ------------------ 1652| 5.96M| case OPR_BAND: case OPR_BOR: case OPR_BXOR: ------------------ | Branch (1652:5): [True: 17.3k, False: 13.0M] | Branch (1652:20): [True: 5.47k, False: 13.0M] | Branch (1652:34): [True: 50.1k, False: 12.9M] ------------------ 1653| 6.33M| case OPR_SHL: case OPR_SHR: { ------------------ | Branch (1653:5): [True: 354k, False: 12.6M] | Branch (1653:19): [True: 6.53k, False: 13.0M] ------------------ 1654| 6.33M| if (!tonumeral(v, NULL)) ------------------ | Branch (1654:11): [True: 6.16M, False: 164k] ------------------ 1655| 6.16M| luaK_exp2anyreg(fs, v); 1656| | /* else keep numeral, which may be folded or used as an immediate 1657| | operand */ 1658| 6.33M| break; 1659| 6.32M| } 1660| 10.4k| case OPR_EQ: case OPR_NE: { ------------------ | Branch (1660:5): [True: 5.25k, False: 13.0M] | Branch (1660:18): [True: 5.21k, False: 13.0M] ------------------ 1661| 10.4k| if (!tonumeral(v, NULL)) ------------------ | Branch (1661:11): [True: 6.09k, False: 4.36k] ------------------ 1662| 6.09k| exp2RK(fs, v); 1663| | /* else keep numeral, which may be an immediate operand */ 1664| 10.4k| break; 1665| 5.25k| } 1666| 6.40M| case OPR_LT: case OPR_LE: ------------------ | Branch (1666:5): [True: 6.39M, False: 6.64M] | Branch (1666:18): [True: 10.7k, False: 13.0M] ------------------ 1667| 6.45M| case OPR_GT: case OPR_GE: { ------------------ | Branch (1667:5): [True: 49.6k, False: 12.9M] | Branch (1667:18): [True: 1.16k, False: 13.0M] ------------------ 1668| 6.45M| int dummy, dummy2; 1669| 6.45M| if (!isSCnumber(v, &dummy, &dummy2)) ------------------ | Branch (1669:11): [True: 6.44M, False: 12.6k] ------------------ 1670| 6.44M| luaK_exp2anyreg(fs, v); 1671| | /* else keep numeral, which may be an immediate operand */ 1672| 6.45M| break; 1673| 6.45M| } 1674| 0| default: lua_assert(0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (1674:5): [True: 0, False: 13.0M] ------------------ 1675| 13.0M| } 1676| 13.0M|} luaK_posfix: 1704| 13.0M| expdesc *e1, expdesc *e2, int line) { 1705| 13.0M| luaK_dischargevars(fs, e2); 1706| 13.0M| if (foldbinop(opr) && constfolding(fs, opr + LUA_OPADD, e1, e2)) ------------------ | | 45| 26.0M|#define foldbinop(op) ((op) <= OPR_SHR) | | ------------------ | | | Branch (45:23): [True: 6.32M, False: 6.70M] | | ------------------ ------------------ if (foldbinop(opr) && constfolding(fs, opr + LUA_OPADD, e1, e2)) ------------------ | | 215| 6.32M|#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ ------------------ | Branch (1706:25): [True: 121k, False: 6.20M] ------------------ 1707| 121k| return; /* done by folding */ 1708| 12.9M| switch (opr) { 1709| 30.4k| case OPR_AND: { ------------------ | Branch (1709:5): [True: 30.4k, False: 12.8M] ------------------ 1710| 30.4k| lua_assert(e1->t == NO_JUMP); /* list closed by 'luaK_infix' */ ------------------ | | 114| 30.4k|#define lua_assert(c) ((void)0) ------------------ 1711| 30.4k| luaK_concat(fs, &e2->f, e1->f); 1712| 30.4k| *e1 = *e2; 1713| 30.4k| break; 1714| 0| } 1715| 191k| case OPR_OR: { ------------------ | Branch (1715:5): [True: 191k, False: 12.7M] ------------------ 1716| 191k| lua_assert(e1->f == NO_JUMP); /* list closed by 'luaK_infix' */ ------------------ | | 114| 191k|#define lua_assert(c) ((void)0) ------------------ 1717| 191k| luaK_concat(fs, &e2->t, e1->t); 1718| 191k| *e1 = *e2; 1719| 191k| break; 1720| 0| } 1721| 18.6k| case OPR_CONCAT: { /* e1 .. e2 */ ------------------ | Branch (1721:5): [True: 18.6k, False: 12.8M] ------------------ 1722| 18.6k| luaK_exp2nextreg(fs, e2); 1723| 18.6k| codeconcat(fs, e1, e2, line); 1724| 18.6k| break; 1725| 0| } 1726| 34.4k| case OPR_ADD: case OPR_MUL: { ------------------ | Branch (1726:5): [True: 3.88k, False: 12.9M] | Branch (1726:19): [True: 30.6k, False: 12.8M] ------------------ 1727| 34.4k| codecommutative(fs, opr, e1, e2, line); 1728| 34.4k| break; 1729| 3.88k| } 1730| 31.4k| case OPR_SUB: { ------------------ | Branch (1730:5): [True: 31.4k, False: 12.8M] ------------------ 1731| 31.4k| if (finishbinexpneg(fs, e1, e2, OP_ADDI, line, TM_SUB)) ------------------ | Branch (1731:11): [True: 17.9k, False: 13.4k] ------------------ 1732| 17.9k| break; /* coded as (r1 + -I) */ 1733| | /* ELSE */ 1734| 31.4k| } /* FALLTHROUGH */ 1735| 5.72M| case OPR_DIV: case OPR_IDIV: case OPR_MOD: case OPR_POW: { ------------------ | Branch (1735:5): [True: 5.21M, False: 7.69M] | Branch (1735:19): [True: 32.8k, False: 12.8M] | Branch (1735:34): [True: 15.3k, False: 12.8M] | Branch (1735:48): [True: 446k, False: 12.4M] ------------------ 1736| 5.72M| codearith(fs, opr, e1, e2, 0, line); 1737| 5.72M| break; 1738| 5.27M| } 1739| 69.9k| case OPR_BAND: case OPR_BOR: case OPR_BXOR: { ------------------ | Branch (1739:5): [True: 16.8k, False: 12.8M] | Branch (1739:20): [True: 5.42k, False: 12.9M] | Branch (1739:34): [True: 47.6k, False: 12.8M] ------------------ 1740| 69.9k| codebitwise(fs, opr, e1, e2, line); 1741| 69.9k| break; 1742| 22.3k| } 1743| 354k| case OPR_SHL: { ------------------ | Branch (1743:5): [True: 354k, False: 12.5M] ------------------ 1744| 354k| if (isSCint(e1)) { ------------------ | Branch (1744:11): [True: 4.08k, False: 350k] ------------------ 1745| 4.08k| swapexps(e1, e2); 1746| 4.08k| codebini(fs, OP_SHLI, e1, e2, 1, line, TM_SHL); /* I << r2 */ 1747| 4.08k| } 1748| 350k| else if (finishbinexpneg(fs, e1, e2, OP_SHRI, line, TM_SHL)) { ------------------ | Branch (1748:16): [True: 1.24k, False: 349k] ------------------ 1749| 1.24k| /* coded as (r1 >> -I) */; 1750| 1.24k| } 1751| 349k| else /* regular case (two registers) */ 1752| 349k| codebinexpval(fs, opr, e1, e2, line); 1753| 354k| break; 1754| 22.3k| } 1755| 4.80k| case OPR_SHR: { ------------------ | Branch (1755:5): [True: 4.80k, False: 12.9M] ------------------ 1756| 4.80k| if (isSCint(e2)) ------------------ | Branch (1756:11): [True: 1.19k, False: 3.60k] ------------------ 1757| 1.19k| codebini(fs, OP_SHRI, e1, e2, 0, line, TM_SHR); /* r1 >> I */ 1758| 3.60k| else /* regular case (two registers) */ 1759| 3.60k| codebinexpval(fs, opr, e1, e2, line); 1760| 4.80k| break; 1761| 22.3k| } 1762| 10.2k| case OPR_EQ: case OPR_NE: { ------------------ | Branch (1762:5): [True: 5.17k, False: 12.9M] | Branch (1762:18): [True: 5.10k, False: 12.9M] ------------------ 1763| 10.2k| codeeq(fs, opr, e1, e2); 1764| 10.2k| break; 1765| 5.17k| } 1766| 49.8k| case OPR_GT: case OPR_GE: { ------------------ | Branch (1766:5): [True: 48.6k, False: 12.8M] | Branch (1766:18): [True: 1.16k, False: 12.9M] ------------------ 1767| | /* '(a > b)' <=> '(b < a)'; '(a >= b)' <=> '(b <= a)' */ 1768| 49.8k| swapexps(e1, e2); 1769| 49.8k| opr = cast(BinOpr, (opr - OPR_GT) + OPR_LT); ------------------ | | 136| 49.8k|#define cast(t, exp) ((t)(exp)) ------------------ 1770| 49.8k| } /* FALLTHROUGH */ 1771| 6.45M| case OPR_LT: case OPR_LE: { ------------------ | Branch (1771:5): [True: 6.39M, False: 6.51M] | Branch (1771:18): [True: 10.3k, False: 12.9M] ------------------ 1772| 6.45M| codeorder(fs, opr, e1, e2); 1773| 6.45M| break; 1774| 6.44M| } 1775| 0| default: lua_assert(0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (1775:5): [True: 0, False: 12.9M] ------------------ 1776| 12.9M| } 1777| 12.9M|} luaK_fixline: 1784| 13.1M|void luaK_fixline (FuncState *fs, int line) { 1785| 13.1M| removelastlineinfo(fs); 1786| 13.1M| savelineinfo(fs, fs->f, line); 1787| 13.1M|} luaK_settablesize: 1790| 228|void luaK_settablesize (FuncState *fs, int pc, int ra, int asize, int hsize) { 1791| 228| Instruction *inst = &fs->f->code[pc]; 1792| 228| int rb = (hsize != 0) ? luaO_ceillog2(hsize) + 1 : 0; /* hash size */ ------------------ | Branch (1792:12): [True: 0, False: 228] ------------------ 1793| 228| int extra = asize / (MAXARG_C + 1); /* higher bits of array size */ ------------------ | | 97| 228|#define MAXARG_C ((1< 0); /* true iff needs extra argument */ 1796| 228| *inst = CREATE_ABCk(OP_NEWTABLE, ra, rb, rc, k); ------------------ | | 156| 228|#define CREATE_ABCk(o,a,b,c,k) ((cast(Instruction, o)<freereg = base + 1; /* free registers with list values */ 1821| 46|} luaK_finish: 1844| 2.78k|void luaK_finish (FuncState *fs) { 1845| 2.78k| int i; 1846| 2.78k| Proto *p = fs->f; 1847| 1.71M| for (i = 0; i < fs->pc; i++) { ------------------ | Branch (1847:15): [True: 1.71M, False: 2.78k] ------------------ 1848| 1.71M| Instruction *pc = &p->code[i]; 1849| 1.71M| lua_assert(i == 0 || isOT(*(pc - 1)) == isIT(*pc)); ------------------ | | 114| 1.71M|#define lua_assert(c) ((void)0) ------------------ 1850| 1.71M| switch (GET_OPCODE(*pc)) { ------------------ | | 114| 1.71M|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 1.71M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1851| 3.25k| case OP_RETURN0: case OP_RETURN1: { ------------------ | Branch (1851:7): [True: 2.78k, False: 1.71M] | Branch (1851:24): [True: 471, False: 1.71M] ------------------ 1852| 3.25k| if (!(fs->needclose || p->is_vararg)) ------------------ | Branch (1852:15): [True: 344, False: 2.90k] | Branch (1852:32): [True: 174, False: 2.73k] ------------------ 1853| 2.73k| break; /* no extra work */ 1854| | /* else use OP_RETURN to do the extra work */ 1855| 518| SET_OPCODE(*pc, OP_RETURN); ------------------ | | 115| 518|#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ | | ------------------ | | | | 108| 518|#define MASK0(n,p) (~MASK1(n,p)) | | | | ------------------ | | | | | | 105| 518|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | ------------------ | | ------------------ | | 116| 518| ((cast(Instruction, o)<needclose) ------------------ | Branch (1858:13): [True: 923, False: 392] ------------------ 1859| 1.31k| SETARG_k(*pc, 1); /* signal that it needs to close */ ------------------ | | 138| 923|#define SETARG_k(i,v) setarg(i, v, POS_k, 1) | | ------------------ | | | | 122| 923|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 923|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 923|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 923| ((cast(Instruction, v)<is_vararg) ------------------ | Branch (1860:13): [True: 185, False: 1.13k] ------------------ 1861| 1.31k| SETARG_C(*pc, p->numparams + 1); /* signal that it is vararg */ ------------------ | | 134| 185|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 185|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 185|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 185|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 185| ((cast(Instruction, v)<code, i); 1866| 225k| fixjump(fs, i, target); 1867| 225k| break; 1868| 1.01k| } 1869| 1.48M| default: break; ------------------ | Branch (1869:7): [True: 1.48M, False: 229k] ------------------ 1870| 1.71M| } 1871| 1.71M| } 1872| 2.78k|} lcode.c:const2val: 74| 531k|static TValue *const2val (FuncState *fs, const expdesc *e) { 75| 531k| lua_assert(e->k == VCONST); ------------------ | | 114| 531k|#define lua_assert(c) ((void)0) ------------------ 76| 531k| return &fs->ls->dyd->actvar.arr[e->u.info].k; 77| 531k|} lcode.c:tonumeral: 56| 18.9M|static int tonumeral (const expdesc *e, TValue *v) { 57| 18.9M| if (hasjumps(e)) ------------------ | | 38| 18.9M|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 8.41k, False: 18.9M] | | ------------------ ------------------ 58| 8.41k| return 0; /* not a numeral */ 59| 18.9M| switch (e->k) { 60| 534k| case VKINT: ------------------ | Branch (60:5): [True: 534k, False: 18.4M] ------------------ 61| 534k| if (v) setivalue(v, e->u.ival); ------------------ | | 345| 361k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 361k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 361k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ | Branch (61:11): [True: 361k, False: 172k] ------------------ 62| 534k| return 1; 63| 162k| case VKFLT: ------------------ | Branch (63:5): [True: 162k, False: 18.8M] ------------------ 64| 162k| if (v) setfltvalue(v, e->u.nval); ------------------ | | 339| 89.0k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 89.0k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 89.0k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ | Branch (64:11): [True: 89.0k, False: 73.7k] ------------------ 65| 162k| return 1; 66| 18.2M| default: return 0; ------------------ | Branch (66:5): [True: 18.2M, False: 696k] ------------------ 67| 18.9M| } 68| 18.9M|} lcode.c:previousinstruction: 116| 197k|static Instruction *previousinstruction (FuncState *fs) { 117| 197k| static const Instruction invalidinstruction = ~(Instruction)0; 118| 197k| if (fs->pc > fs->lasttarget) ------------------ | Branch (118:7): [True: 59.0k, False: 138k] ------------------ 119| 59.0k| return &fs->f->code[fs->pc - 1]; /* previous instruction */ 120| 138k| else 121| 138k| return cast(Instruction*, &invalidinstruction); ------------------ | | 136| 138k|#define cast(t, exp) ((t)(exp)) ------------------ 122| 197k|} lcode.c:getjump: 154| 64.2M|static int getjump (FuncState *fs, int pc) { 155| 64.2M| int offset = GETARG_sJ(fs->f->code[pc]); ------------------ | | 151| 64.2M| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | ------------------ | | | | 115| 64.2M|#define check_exp(c,e) (e) | | ------------------ ------------------ 156| 64.2M| if (offset == NO_JUMP) /* point to itself represents end of list */ ------------------ | | 20| 64.2M|#define NO_JUMP (-1) ------------------ | Branch (156:7): [True: 6.55M, False: 57.7M] ------------------ 157| 6.55M| return NO_JUMP; /* end of list */ ------------------ | | 20| 6.55M|#define NO_JUMP (-1) ------------------ 158| 57.7M| else 159| 57.7M| return (pc+1)+offset; /* turn offset into absolute position */ 160| 64.2M|} lcode.c:fixjump: 167| 6.91M|static void fixjump (FuncState *fs, int pc, int dest) { 168| 6.91M| Instruction *jmp = &fs->f->code[pc]; 169| 6.91M| int offset = dest - (pc + 1); 170| 6.91M| lua_assert(dest != NO_JUMP); ------------------ | | 114| 6.91M|#define lua_assert(c) ((void)0) ------------------ 171| 6.91M| if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) ------------------ | | 92| 6.91M|#define OFFSET_sJ (MAXARG_sJ >> 1) | | ------------------ | | | | 87| 6.91M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | | | ------------------ | | | | | | 43| 6.91M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 40| 6.91M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 38| 6.91M|#define SIZE_C 8 | | | | | | | | ------------------ | | | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 39| 6.91M|#define SIZE_B 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 41| 6.91M|#define SIZE_A 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) ------------------ | | 87| 6.91M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | ------------------ | | | | 43| 6.91M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | ------------------ | | | | | | 40| 6.91M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | ------------------ | | | | | | | | 38| 6.91M|#define SIZE_C 8 | | | | | | ------------------ | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | ------------------ | | | | | | | | 39| 6.91M|#define SIZE_B 8 | | | | | | ------------------ | | | | ------------------ | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | ------------------ | | | | | | 41| 6.91M|#define SIZE_A 8 | | | | ------------------ | | ------------------ ------------------ if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) ------------------ | | 92| 6.91M|#define OFFSET_sJ (MAXARG_sJ >> 1) | | ------------------ | | | | 87| 6.91M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | | | ------------------ | | | | | | 43| 6.91M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 40| 6.91M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 38| 6.91M|#define SIZE_C 8 | | | | | | | | ------------------ | | | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 39| 6.91M|#define SIZE_B 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 41| 6.91M|#define SIZE_A 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (171:9): [True: 6.91M, False: 0] | Branch (171:33): [True: 6.91M, False: 0] ------------------ 172| 0| luaX_syntaxerror(fs->ls, "control structure too long"); 173| 6.91M| lua_assert(GET_OPCODE(*jmp) == OP_JMP); ------------------ | | 114| 6.91M|#define lua_assert(c) ((void)0) ------------------ 174| 6.91M| SETARG_sJ(*jmp, offset); ------------------ | | 153| 6.91M| setarg(i, cast_uint((j)+OFFSET_sJ), POS_sJ, SIZE_sJ) | | ------------------ | | | | 122| 6.91M|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 6.91M|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 6.91M|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 6.91M| ((cast(Instruction, v)<>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 6.63M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (261:7): [True: 6.59M, False: 42.1k] ------------------ 262| 6.59M| return 0; /* cannot patch other instructions */ 263| 42.1k| if (reg != NO_REG && reg != GETARG_B(*i)) ------------------ | | 182| 42.1k|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 84.2k|#define MAXARG_A ((1<f->code[pc]; 245| 12.9M| if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1)))) ------------------ | | 385| 12.9M|#define testTMode(m) (luaP_opmodes[m] & (1 << 4)) | | ------------------ | | | Branch (385:22): [True: 12.9M, False: 25.5k] | | ------------------ ------------------ | Branch (245:7): [True: 12.9M, False: 0] ------------------ 246| 12.9M| return pi-1; 247| 25.5k| else 248| 25.5k| return pi; 249| 12.9M|} lcode.c:savelineinfo: 329| 71.7M|static void savelineinfo (FuncState *fs, Proto *f, int line) { 330| 71.7M| int linedif = line - fs->previousline; 331| 71.7M| int pc = fs->pc - 1; /* last instruction coded */ 332| 71.7M| if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) { ------------------ | | 319| 143M|#define LIMLINEDIFF 0x80 ------------------ if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) { ------------------ | | 35| 71.7M|#define MAXIWTHABS 128 ------------------ | Branch (332:7): [True: 436, False: 71.7M] | Branch (332:38): [True: 559k, False: 71.1M] ------------------ 333| 560k| luaM_growvector(fs->ls->L, f->abslineinfo, fs->nabslineinfo, ------------------ | | 67| 560k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 1.12M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 560k| luaM_limitN(limit,t),e))) ------------------ 334| 560k| f->sizeabslineinfo, AbsLineInfo, MAX_INT, "lines"); 335| 560k| f->abslineinfo[fs->nabslineinfo].pc = pc; 336| 560k| f->abslineinfo[fs->nabslineinfo++].line = line; 337| 560k| linedif = ABSLINEINFO; /* signal that there is absolute information */ ------------------ | | 27| 560k|#define ABSLINEINFO (-0x80) ------------------ 338| 560k| fs->iwthabs = 1; /* restart counter */ 339| 560k| } 340| 71.7M| luaM_growvector(fs->ls->L, f->lineinfo, pc, f->sizelineinfo, ls_byte, ------------------ | | 67| 71.7M| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 143M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 71.7M| luaM_limitN(limit,t),e))) ------------------ 341| 71.7M| MAX_INT, "opcodes"); 342| 71.7M| f->lineinfo[pc] = linedif; 343| 71.7M| fs->previousline = line; /* last line saved */ 344| 71.7M|} lcode.c:codesJ: 429| 6.54M|static int codesJ (FuncState *fs, OpCode o, int sj, int k) { 430| 6.54M| unsigned int j = sj + OFFSET_sJ; ------------------ | | 92| 6.54M|#define OFFSET_sJ (MAXARG_sJ >> 1) | | ------------------ | | | | 87| 6.54M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | | | ------------------ | | | | | | 43| 6.54M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 40| 6.54M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 38| 6.54M|#define SIZE_C 8 | | | | | | | | ------------------ | | | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 39| 6.54M|#define SIZE_B 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 41| 6.54M|#define SIZE_A 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 431| 6.54M| lua_assert(getOpMode(o) == isJ); ------------------ | | 114| 6.54M|#define lua_assert(c) ((void)0) ------------------ 432| 6.54M| lua_assert(j <= MAXARG_sJ && (k & ~1) == 0); ------------------ | | 114| 6.54M|#define lua_assert(c) ((void)0) ------------------ 433| 6.54M| return luaK_code(fs, CREATE_sJ(o, j, k)); ------------------ | | 169| 6.54M|#define CREATE_sJ(o,j,k) ((cast(Instruction, o) << POS_OP) \ | | ------------------ | | | | 136| 6.54M|#define cast(t, exp) ((t)(exp)) | | ------------------ | | #define CREATE_sJ(o,j,k) ((cast(Instruction, o) << POS_OP) \ | | ------------------ | | | | 47| 6.54M|#define POS_OP 0 | | ------------------ | | 170| 6.54M| | (cast(Instruction, j) << POS_sJ) \ | | ------------------ | | | | 136| 6.54M|#define cast(t, exp) ((t)(exp)) | | ------------------ | | | (cast(Instruction, j) << POS_sJ) \ | | ------------------ | | | | 58| 6.54M|#define POS_sJ POS_A | | | | ------------------ | | | | | | 49| 6.54M|#define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 47| 6.54M|#define POS_OP 0 | | | | | | ------------------ | | | | | | #define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 45| 6.54M|#define SIZE_OP 7 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 171| 6.54M| | (cast(Instruction, k) << POS_k)) | | ------------------ | | | | 136| 6.54M|#define cast(t, exp) ((t)(exp)) | | ------------------ | | | (cast(Instruction, k) << POS_k)) | | ------------------ | | | | 50| 6.54M|#define POS_k (POS_A + SIZE_A) | | | | ------------------ | | | | | | 49| 6.54M|#define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 47| 6.54M|#define POS_OP 0 | | | | | | ------------------ | | | | | | #define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 45| 6.54M|#define SIZE_OP 7 | | | | | | ------------------ | | | | ------------------ | | | | #define POS_k (POS_A + SIZE_A) | | | | ------------------ | | | | | | 41| 6.54M|#define SIZE_A 8 | | | | ------------------ | | ------------------ ------------------ 434| 6.54M|} lcode.c:fitsBx: 667| 81.3k|static int fitsBx (lua_Integer i) { 668| 81.3k| return (-OFFSET_sBx <= i && i <= MAXARG_Bx - OFFSET_sBx); ------------------ | | 77| 81.3k|#define OFFSET_sBx (MAXARG_Bx>>1) /* 'sBx' is signed */ | | ------------------ | | | | 72| 81.3k|#define MAXARG_Bx ((1<>1) /* 'sBx' is signed */ | | ------------------ | | | | 72| 80.8k|#define MAXARG_Bx ((1<>1) /* 'sBx' is signed */ | | ------------------ | | | | 72| 72.4k|#define MAXARG_Bx ((1<value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 61.4k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 588| 61.4k| return addk(fs, &o, &o); /* use integer itself as key */ 589| 61.4k|} lcode.c:addk: 543| 13.3M|static int addk (FuncState *fs, TValue *key, TValue *v) { 544| 13.3M| TValue val; 545| 13.3M| lua_State *L = fs->ls->L; 546| 13.3M| Proto *f = fs->f; 547| 13.3M| const TValue *idx = luaH_get(fs->ls->h, key); /* query scanner table */ 548| 13.3M| int k, oldsize; 549| 13.3M| if (ttisinteger(idx)) { /* is there an index there? */ ------------------ | | 328| 13.3M|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 13.3M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 13.3M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 13.3M, False: 24.9k] | | | | ------------------ | | ------------------ ------------------ 550| 13.3M| k = cast_int(ivalue(idx)); ------------------ | | 141| 13.3M|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 13.3M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 551| | /* correct value? (warning: must distinguish floats from integers!) */ 552| 13.3M| if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) && ------------------ | | 84| 13.3M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 13.3M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) && ------------------ | | 84| 13.3M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 26.6M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ | Branch (552:9): [True: 13.3M, False: 18.3k] | Branch (552:23): [True: 13.3M, False: 734] ------------------ 553| 13.3M| luaV_rawequalobj(&f->k[k], v)) ------------------ | | 75| 13.3M|#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2) | | ------------------ | | | Branch (75:34): [True: 13.2M, False: 45.8k] | | ------------------ ------------------ 554| 13.2M| return k; /* reuse index */ 555| 13.3M| } 556| | /* constant not found; create a new entry */ 557| 89.8k| oldsize = f->sizek; 558| 89.8k| 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| 89.8k| setivalue(&val, k); ------------------ | | 345| 89.8k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 89.8k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 89.8k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 562| 89.8k| luaH_finishset(L, fs->ls->h, key, idx, &val); 563| 89.8k| luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants"); ------------------ | | 67| 89.8k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 179k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 89.8k| luaM_limitN(limit,t),e))) ------------------ 564| 218k| while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]); ------------------ | | 200| 129k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 218k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ | Branch (564:10): [True: 129k, False: 89.8k] ------------------ 565| 89.8k| setobj(L, &f->k[k], v); ------------------ | | 119| 89.8k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 89.8k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 89.8k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 89.8k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 89.8k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 89.8k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 89.8k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 89.8k|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 566| 89.8k| fs->nk++; 567| 89.8k| luaC_barrier(L, f, v); ------------------ | | 179| 89.8k|#define luaC_barrier(L,p,v) ( \ | | 180| 89.8k| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 89.8k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 89.8k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 89.8k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 38.4k, False: 51.4k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 38.4k|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 38.4k| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 38.4k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 38.4k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 76.8k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 38.4k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 177| 38.4k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 38.4k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 38.4k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 51.4k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 51.4k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 568| 89.8k| return k; 569| 13.3M|} lcode.c:const2exp: 692| 531k|static void const2exp (TValue *v, expdesc *e) { 693| 531k| switch (ttypetag(v)) { ------------------ | | 84| 531k|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 531k|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 694| 2| case LUA_VNUMINT: ------------------ | | 323| 2|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 2|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (694:5): [True: 2, False: 531k] ------------------ 695| 2| e->k = VKINT; e->u.ival = ivalue(v); ------------------ | | 333| 2|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 2|#define check_exp(c,e) (e) | | ------------------ ------------------ 696| 2| 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: 531k] ------------------ 698| 0| e->k = VKFLT; e->u.nval = fltvalue(v); ------------------ | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 699| 0| break; 700| 303k| case LUA_VFALSE: ------------------ | | 239| 303k|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 303k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (700:5): [True: 303k, False: 228k] ------------------ 701| 303k| e->k = VFALSE; 702| 303k| break; 703| 201| case LUA_VTRUE: ------------------ | | 240| 201|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 201|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (703:5): [True: 201, False: 531k] ------------------ 704| 201| e->k = VTRUE; 705| 201| break; 706| 88.6k| case LUA_VNIL: ------------------ | | 183| 88.6k|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 88.6k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (706:5): [True: 88.6k, False: 443k] ------------------ 707| 88.6k| e->k = VNIL; 708| 88.6k| break; 709| 139k| case LUA_VSHRSTR: case LUA_VLNGSTR: ------------------ | | 360| 139k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 139k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VSHRSTR: case LUA_VLNGSTR: ------------------ | | 361| 139k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 139k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (709:5): [True: 139k, False: 392k] | Branch (709:24): [True: 0, False: 531k] ------------------ 710| 139k| e->k = VKSTR; e->u.strval = tsvalue(v); ------------------ | | 369| 139k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 139k|#define check_exp(c,e) (e) | | ------------------ ------------------ 711| 139k| break; 712| 0| default: lua_assert(0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (712:5): [True: 0, False: 531k] ------------------ 713| 531k| } 714| 531k|} lcode.c:freereg: 491| 32.5M|static void freereg (FuncState *fs, int reg) { 492| 32.5M| if (reg >= luaY_nvarstack(fs)) { ------------------ | Branch (492:7): [True: 32.3M, False: 268k] ------------------ 493| 32.3M| fs->freereg--; 494| 32.3M| lua_assert(reg == fs->freereg); ------------------ | | 114| 32.3M|#define lua_assert(c) ((void)0) ------------------ 495| 32.3M| } 496| 32.5M|} lcode.c:freeregs: 502| 15.6M|static void freeregs (FuncState *fs, int r1, int r2) { 503| 15.6M| if (r1 > r2) { ------------------ | Branch (503:7): [True: 182k, False: 15.4M] ------------------ 504| 182k| freereg(fs, r1); 505| 182k| freereg(fs, r2); 506| 182k| } 507| 15.4M| else { 508| 15.4M| freereg(fs, r2); 509| 15.4M| freereg(fs, r1); 510| 15.4M| } 511| 15.6M|} lcode.c:freeexp: 517| 33.1M|static void freeexp (FuncState *fs, expdesc *e) { 518| 33.1M| if (e->k == VNONRELOC) ------------------ | Branch (518:7): [True: 623k, False: 32.5M] ------------------ 519| 623k| freereg(fs, e->u.info); 520| 33.1M|} lcode.c:exp2reg: 914| 32.7M|static void exp2reg (FuncState *fs, expdesc *e, int reg) { 915| 32.7M| discharge2reg(fs, e, reg); 916| 32.7M| if (e->k == VJMP) /* expression itself is a test? */ ------------------ | Branch (916:7): [True: 6.28M, False: 26.5M] ------------------ 917| 6.28M| luaK_concat(fs, &e->t, e->u.info); /* put this jump in 't' list */ 918| 32.7M| if (hasjumps(e)) { ------------------ | | 38| 32.7M|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 6.31M, False: 26.4M] | | ------------------ ------------------ 919| 6.31M| int final; /* position after whole expression */ 920| 6.31M| int p_f = NO_JUMP; /* position of an eventual LOAD false */ ------------------ | | 20| 6.31M|#define NO_JUMP (-1) ------------------ 921| 6.31M| int p_t = NO_JUMP; /* position of an eventual LOAD true */ ------------------ | | 20| 6.31M|#define NO_JUMP (-1) ------------------ 922| 6.31M| if (need_value(fs, e->t) || need_value(fs, e->f)) { ------------------ | Branch (922:9): [True: 6.29M, False: 23.3k] | Branch (922:33): [True: 5.78k, False: 17.5k] ------------------ 923| 6.30M| int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs); ------------------ | | 20| 6.28M|#define NO_JUMP (-1) ------------------ | Branch (923:16): [True: 6.28M, False: 16.4k] ------------------ 924| 6.30M| p_f = code_loadbool(fs, reg, OP_LFALSESKIP); /* skip next inst. */ 925| 6.30M| p_t = code_loadbool(fs, reg, OP_LOADTRUE); 926| | /* jump around these booleans if 'e' is not a test */ 927| 6.30M| luaK_patchtohere(fs, fj); 928| 6.30M| } 929| 6.31M| final = luaK_getlabel(fs); 930| 6.31M| patchlistaux(fs, e->f, final, reg, p_f); 931| 6.31M| patchlistaux(fs, e->t, final, reg, p_t); 932| 6.31M| } 933| 32.7M| e->f = e->t = NO_JUMP; ------------------ | | 20| 32.7M|#define NO_JUMP (-1) ------------------ 934| 32.7M| e->u.info = reg; 935| 32.7M| e->k = VNONRELOC; 936| 32.7M|} lcode.c:discharge2reg: 825| 32.8M|static void discharge2reg (FuncState *fs, expdesc *e, int reg) { 826| 32.8M| luaK_dischargevars(fs, e); 827| 32.8M| switch (e->k) { 828| 177k| case VNIL: { ------------------ | Branch (828:5): [True: 177k, False: 32.6M] ------------------ 829| 177k| luaK_nil(fs, reg, 1); 830| 177k| break; 831| 0| } 832| 305k| case VFALSE: { ------------------ | Branch (832:5): [True: 305k, False: 32.5M] ------------------ 833| 305k| luaK_codeABC(fs, OP_LOADFALSE, reg, 0, 0); ------------------ | | 48| 305k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 834| 305k| break; 835| 0| } 836| 1.51k| case VTRUE: { ------------------ | Branch (836:5): [True: 1.51k, False: 32.8M] ------------------ 837| 1.51k| luaK_codeABC(fs, OP_LOADTRUE, reg, 0, 0); ------------------ | | 48| 1.51k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 838| 1.51k| break; 839| 0| } 840| 542k| case VKSTR: { ------------------ | Branch (840:5): [True: 542k, False: 32.2M] ------------------ 841| 542k| str2K(fs, e); 842| 542k| } /* FALLTHROUGH */ 843| 3.52M| case VK: { ------------------ | Branch (843:5): [True: 2.98M, False: 29.8M] ------------------ 844| 3.52M| luaK_codek(fs, reg, e->u.info); 845| 3.52M| break; 846| 542k| } 847| 60.0k| case VKFLT: { ------------------ | Branch (847:5): [True: 60.0k, False: 32.7M] ------------------ 848| 60.0k| luaK_float(fs, reg, e->u.nval); 849| 60.0k| break; 850| 542k| } 851| 46.0k| case VKINT: { ------------------ | Branch (851:5): [True: 46.0k, False: 32.7M] ------------------ 852| 46.0k| luaK_int(fs, reg, e->u.ival); 853| 46.0k| break; 854| 542k| } 855| 22.1M| case VRELOC: { ------------------ | Branch (855:5): [True: 22.1M, False: 10.6M] ------------------ 856| 22.1M| Instruction *pc = &getinstruction(fs, e); ------------------ | | 55| 22.1M|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 857| 22.1M| SETARG_A(*pc, reg); /* instruction will put result in 'reg' */ ------------------ | | 126| 22.1M|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 22.1M|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 22.1M|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 22.1M|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 22.1M| ((cast(Instruction, v)<u.info) ------------------ | Branch (861:11): [True: 31.2k, False: 256k] ------------------ 862| 31.2k| luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0); ------------------ | | 48| 31.2k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 863| 287k| break; 864| 542k| } 865| 6.28M| default: { ------------------ | Branch (865:5): [True: 6.28M, False: 26.5M] ------------------ 866| 6.28M| lua_assert(e->k == VJMP); ------------------ | | 114| 6.28M|#define lua_assert(c) ((void)0) ------------------ 867| 6.28M| return; /* nothing to do... */ 868| 542k| } 869| 32.8M| } 870| 26.5M| e->u.info = reg; 871| 26.5M| e->k = VNONRELOC; 872| 26.5M|} lcode.c:luaK_float: 680| 60.0k|static void luaK_float (FuncState *fs, int reg, lua_Number f) { 681| 60.0k| lua_Integer fi; 682| 60.0k| if (luaV_flttointeger(f, &fi, F2Ieq) && fitsBx(fi)) ------------------ | Branch (682:7): [True: 34.7k, False: 25.2k] | Branch (682:43): [True: 29.6k, False: 5.15k] ------------------ 683| 29.6k| codeAsBx(fs, OP_LOADF, reg, cast_int(fi)); ------------------ | | 141| 29.6k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 29.6k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 684| 30.4k| else 685| 30.4k| luaK_codek(fs, reg, luaK_numberK(fs, f)); 686| 60.0k|} lcode.c:luaK_numberK: 602| 76.4k|static int luaK_numberK (FuncState *fs, lua_Number r) { 603| 76.4k| TValue o; 604| 76.4k| lua_Integer ik; 605| 76.4k| setfltvalue(&o, r); ------------------ | | 339| 76.4k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 76.4k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 76.4k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 606| 76.4k| if (!luaV_flttointeger(r, &ik, F2Ieq)) /* not an integral value? */ ------------------ | Branch (606:7): [True: 36.6k, False: 39.7k] ------------------ 607| 36.6k| return addk(fs, &o, &o); /* use number itself as key */ 608| 39.7k| else { /* must build an alternative key */ 609| 39.7k| const int nbm = l_floatatt(MANT_DIG); ------------------ | | 475| 39.7k|#define l_floatatt(n) (DBL_##n) ------------------ 610| 39.7k| const lua_Number q = l_mathop(ldexp)(l_mathop(1.0), -nbm + 1); ------------------ | | 482| 39.7k|#define l_mathop(op) op ------------------ const lua_Number q = l_mathop(ldexp)(l_mathop(1.0), -nbm + 1); ------------------ | | 482| 39.7k|#define l_mathop(op) op ------------------ 611| 39.7k| const lua_Number k = (ik == 0) ? q : r + r*q; /* new key */ ------------------ | Branch (611:26): [True: 3.09k, False: 36.6k] ------------------ 612| 39.7k| TValue kv; 613| 39.7k| setfltvalue(&kv, k); ------------------ | | 339| 39.7k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 39.7k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 39.7k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 614| | /* result is not an integral value, unless value is too large */ 615| 39.7k| lua_assert(!luaV_flttointeger(k, &ik, F2Ieq) || ------------------ | | 114| 39.7k|#define lua_assert(c) ((void)0) ------------------ 616| 39.7k| l_mathop(fabs)(r) >= l_mathop(1e6)); 617| 39.7k| return addk(fs, &kv, &o); 618| 39.7k| } 619| 76.4k|} lcode.c:need_value: 898| 6.34M|static int need_value (FuncState *fs, int list) { 899| 6.36M| for (; list != NO_JUMP; list = getjump(fs, list)) { ------------------ | | 20| 6.36M|#define NO_JUMP (-1) ------------------ | Branch (899:10): [True: 6.32M, False: 40.8k] ------------------ 900| 6.32M| Instruction i = *getjumpcontrol(fs, list); 901| 6.32M| if (GET_OPCODE(i) != OP_TESTSET) return 1; ------------------ | | 114| 6.32M|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 6.32M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (901:9): [True: 6.30M, False: 25.7k] ------------------ 902| 6.32M| } 903| 40.8k| return 0; /* not found */ 904| 6.34M|} lcode.c:code_loadbool: 888| 12.6M|static int code_loadbool (FuncState *fs, int A, OpCode op) { 889| 12.6M| luaK_getlabel(fs); /* those instructions may be jump targets */ 890| 12.6M| return luaK_codeABC(fs, op, A, 0, 0); ------------------ | | 48| 12.6M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 891| 12.6M|} lcode.c:codeABRK: 1039| 25.5k| expdesc *ec) { 1040| 25.5k| int k = exp2RK(fs, ec); 1041| 25.5k| luaK_codeABCk(fs, o, a, b, ec->u.info, k); 1042| 25.5k|} lcode.c:negatecondition: 1101| 7.84k|static void negatecondition (FuncState *fs, expdesc *e) { 1102| 7.84k| Instruction *pc = getjumpcontrol(fs, e->u.info); 1103| 7.84k| lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET && ------------------ | | 114| 7.84k|#define lua_assert(c) ((void)0) ------------------ 1104| 7.84k| GET_OPCODE(*pc) != OP_TEST); 1105| 7.84k| SETARG_k(*pc, (GETARG_k(*pc) ^ 1)); ------------------ | | 138| 7.84k|#define SETARG_k(i,v) setarg(i, v, POS_k, 1) | | ------------------ | | | | 122| 7.84k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 7.84k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 7.84k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 7.84k| ((cast(Instruction, v)<k == VRELOC) { ------------------ | Branch (1116:7): [True: 32.7k, False: 14.0k] ------------------ 1117| 32.7k| Instruction ie = getinstruction(fs, e); ------------------ | | 55| 32.7k|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 1118| 32.7k| if (GET_OPCODE(ie) == OP_NOT) { ------------------ | | 114| 32.7k|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 32.7k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (1118:9): [True: 1.44k, False: 31.3k] ------------------ 1119| 1.44k| removelastinstruction(fs); /* remove previous OP_NOT */ 1120| 1.44k| return condjump(fs, OP_TEST, GETARG_B(ie), 0, 0, !cond); ------------------ | | 128| 1.44k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 1.44k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1121| 1.44k| } 1122| | /* else go through */ 1123| 32.7k| } 1124| 45.3k| discharge2anyreg(fs, e); 1125| 45.3k| freeexp(fs, e); 1126| 45.3k| return condjump(fs, OP_TESTSET, NO_REG, e->u.info, 0, cond); ------------------ | | 182| 45.3k|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 45.3k|#define MAXARG_A ((1<pc--; 375| 1.44k|} lcode.c:condjump: 222| 6.51M|static int condjump (FuncState *fs, OpCode op, int A, int B, int C, int k) { 223| 6.51M| luaK_codeABCk(fs, op, A, B, C, k); 224| 6.51M| return luaK_jump(fs); 225| 6.51M|} lcode.c:discharge2anyreg: 880| 50.0k|static void discharge2anyreg (FuncState *fs, expdesc *e) { 881| 50.0k| if (e->k != VNONRELOC) { /* no fixed register yet? */ ------------------ | Branch (881:7): [True: 36.2k, False: 13.7k] ------------------ 882| 36.2k| luaK_reserveregs(fs, 1); /* get a register */ 883| 36.2k| discharge2reg(fs, e, fs->freereg-1); /* put value there */ 884| 36.2k| } 885| 50.0k|} lcode.c:str2K: 737| 13.2M|static void str2K (FuncState *fs, expdesc *e) { 738| 13.2M| lua_assert(e->k == VKSTR); ------------------ | | 114| 13.2M|#define lua_assert(c) ((void)0) ------------------ 739| 13.2M| e->u.info = stringK(fs, e->u.strval); 740| 13.2M| e->k = VK; 741| 13.2M|} lcode.c:stringK: 575| 13.2M|static int stringK (FuncState *fs, TString *s) { 576| 13.2M| TValue o; 577| 13.2M| setsvalue(fs->ls->L, &o, s); ------------------ | | 372| 13.2M| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 13.2M| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 13.2M|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 13.2M|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 13.2M|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 13.2M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 13.2M| checkliveness(L,io); } | | ------------------ | | | | 107| 13.2M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 13.2M|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 13.2M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 578| 13.2M| return addk(fs, &o, &o); /* use string itself as key */ 579| 13.2M|} lcode.c:isKstr: 1220| 15.6M|static int isKstr (FuncState *fs, expdesc *e) { 1221| 15.6M| return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B && ------------------ | | 38| 31.3M|#define hasjumps(e) ((e)->t != (e)->f) ------------------ return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B && ------------------ | | 96| 31.3M|#define MAXARG_B ((1<f->k[e->u.info])); ------------------ | | 364| 9.70M|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | ------------------ | | | | 91| 9.70M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 9.70M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 9.69M, False: 2.20k] | | | | ------------------ | | ------------------ ------------------ 1223| 15.6M|} lcode.c:isCint: 1237| 3.00M|static int isCint (expdesc *e) { 1238| 3.00M| return isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C)); ------------------ | | 152| 1.07k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ return isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C)); ------------------ | | 152| 1.07k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (1238:10): [True: 1.07k, False: 3.00M] | Branch (1238:23): [True: 941, False: 133] ------------------ 1239| 3.00M|} lcode.c:isKint: 1228| 3.74M|static int isKint (expdesc *e) { 1229| 3.74M| return (e->k == VKINT && !hasjumps(e)); ------------------ | | 38| 31.6k|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (1229:11): [True: 31.6k, False: 3.71M] | Branch (1229:28): [True: 30.9k, False: 735] ------------------ 1230| 3.74M|} lcode.c:constfolding: 1335| 6.61M| const expdesc *e2) { 1336| 6.61M| TValue v1, v2, res; 1337| 6.61M| if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2)) ------------------ | Branch (1337:7): [True: 6.37M, False: 239k] | Branch (1337:30): [True: 29.3k, False: 210k] | Branch (1337:53): [True: 16.5k, False: 193k] ------------------ 1338| 6.41M| return 0; /* non-numeric operands or not safe to fold */ 1339| 193k| luaO_rawarith(fs->ls->L, op, &v1, &v2, &res); /* does operation */ 1340| 193k| if (ttisinteger(&res)) { ------------------ | | 328| 193k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 193k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 193k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 73.9k, False: 119k] | | | | ------------------ | | ------------------ ------------------ 1341| 73.9k| e1->k = VKINT; 1342| 73.9k| e1->u.ival = ivalue(&res); ------------------ | | 333| 73.9k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 73.9k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1343| 73.9k| } 1344| 119k| else { /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */ 1345| 119k| lua_Number n = fltvalue(&res); ------------------ | | 332| 119k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 119k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1346| 119k| if (luai_numisnan(n) || n == 0) ------------------ | | 355| 239k|#define luai_numisnan(a) (!luai_numeq((a), (a))) | | ------------------ | | | | 350| 119k|#define luai_numeq(a,b) ((a)==(b)) | | ------------------ | | | Branch (355:33): [True: 658, False: 118k] | | ------------------ ------------------ | Branch (1346:29): [True: 12.5k, False: 106k] ------------------ 1347| 13.2k| return 0; 1348| 106k| e1->k = VKFLT; 1349| 106k| e1->u.nval = n; 1350| 106k| } 1351| 180k| return 1; 1352| 193k|} lcode.c:validop: 1315| 210k|static int validop (int op, TValue *v1, TValue *v2) { 1316| 210k| switch (op) { 1317| 2.66k| case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 222| 394|#define LUA_OPBAND 7 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 223| 417|#define LUA_OPBOR 8 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 224| 2.66k|#define LUA_OPBXOR 9 ------------------ | Branch (1317:5): [True: 394, False: 209k] | Branch (1317:22): [True: 23, False: 210k] | Branch (1317:38): [True: 2.24k, False: 207k] ------------------ 1318| 68.4k| case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ ------------------ | | 225| 3.09k|#define LUA_OPSHL 10 ------------------ case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ ------------------ | | 226| 4.79k|#define LUA_OPSHR 11 ------------------ case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ ------------------ | | 228| 68.4k|#define LUA_OPBNOT 13 ------------------ | Branch (1318:5): [True: 427, False: 209k] | Branch (1318:21): [True: 1.69k, False: 208k] | Branch (1318:37): [True: 63.6k, False: 146k] ------------------ 1319| 68.4k| lua_Integer i; 1320| 68.4k| return (luaV_tointegerns(v1, &i, LUA_FLOORN2I) && ------------------ | | 36| 68.4k|#define LUA_FLOORN2I F2Ieq ------------------ | Branch (1320:15): [True: 52.1k, False: 16.3k] ------------------ 1321| 68.4k| luaV_tointegerns(v2, &i, LUA_FLOORN2I)); ------------------ | | 36| 52.1k|#define LUA_FLOORN2I F2Ieq ------------------ | Branch (1321:15): [True: 51.9k, False: 227] ------------------ 1322| 4.79k| } 1323| 12.1k| case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ ------------------ | | 220| 584|#define LUA_OPDIV 5 ------------------ case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ ------------------ | | 221| 1.46k|#define LUA_OPIDIV 6 ------------------ case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ ------------------ | | 218| 12.1k|#define LUA_OPMOD 3 ------------------ | Branch (1323:5): [True: 584, False: 209k] | Branch (1323:21): [True: 883, False: 209k] | Branch (1323:38): [True: 10.6k, False: 199k] ------------------ 1324| 12.1k| return (nvalue(v2) != 0); ------------------ | | 330| 12.1k|#define nvalue(o) check_exp(ttisnumber(o), \ | | ------------------ | | | | 115| 24.2k|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:26): [True: 9.89k, False: 2.22k] | | | | ------------------ | | ------------------ | | 331| 12.1k| (ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o))) ------------------ 1325| 129k| default: return 1; /* everything else is valid */ ------------------ | Branch (1325:5): [True: 129k, False: 80.5k] ------------------ 1326| 210k| } 1327| 210k|} lcode.c:codeunexpval: 1389| 260k|static void codeunexpval (FuncState *fs, OpCode op, expdesc *e, int line) { 1390| 260k| int r = luaK_exp2anyreg(fs, e); /* opcodes operate only on registers */ 1391| 260k| freeexp(fs, e); 1392| 260k| e->u.info = luaK_codeABC(fs, op, 0, r, 0); /* generate opcode */ ------------------ | | 48| 260k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1393| 260k| e->k = VRELOC; /* all those operations are relocatable */ 1394| 260k| luaK_fixline(fs, line); 1395| 260k|} lcode.c:unopr2op: 1369| 260k|l_sinline OpCode unopr2op (UnOpr opr) { 1370| 260k| return cast(OpCode, (cast_int(opr) - cast_int(OPR_MINUS)) + ------------------ | | 136| 260k|#define cast(t, exp) ((t)(exp)) ------------------ 1371| 260k| cast_int(OP_UNM)); 1372| 260k|} lcode.c:codenot: 1186| 6.33k|static void codenot (FuncState *fs, expdesc *e) { 1187| 6.33k| switch (e->k) { 1188| 219| case VNIL: case VFALSE: { ------------------ | Branch (1188:5): [True: 0, False: 6.33k] | Branch (1188:16): [True: 219, False: 6.11k] ------------------ 1189| 219| e->k = VTRUE; /* true == not nil == not false */ 1190| 219| break; 1191| 0| } 1192| 777| case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: { ------------------ | Branch (1192:5): [True: 0, False: 6.33k] | Branch (1192:14): [True: 366, False: 5.96k] | Branch (1192:26): [True: 161, False: 6.17k] | Branch (1192:38): [True: 10, False: 6.32k] | Branch (1192:50): [True: 240, False: 6.09k] ------------------ 1193| 777| e->k = VFALSE; /* false == not "x" == not 0.5 == not 1 == not true */ 1194| 777| break; 1195| 537| } 1196| 700| case VJMP: { ------------------ | Branch (1196:5): [True: 700, False: 5.63k] ------------------ 1197| 700| negatecondition(fs, e); 1198| 700| break; 1199| 537| } 1200| 3.06k| case VRELOC: ------------------ | Branch (1200:5): [True: 3.06k, False: 3.26k] ------------------ 1201| 4.63k| case VNONRELOC: { ------------------ | Branch (1201:5): [True: 1.57k, False: 4.76k] ------------------ 1202| 4.63k| discharge2anyreg(fs, e); 1203| 4.63k| freeexp(fs, e); 1204| 4.63k| e->u.info = luaK_codeABC(fs, OP_NOT, 0, e->u.info, 0); ------------------ | | 48| 4.63k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1205| 4.63k| e->k = VRELOC; 1206| 4.63k| break; 1207| 3.06k| } 1208| 0| default: lua_assert(0); /* cannot happen */ ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (1208:5): [True: 0, False: 6.33k] ------------------ 1209| 6.33k| } 1210| | /* interchange true and false lists */ 1211| 6.33k| { int temp = e->f; e->f = e->t; e->t = temp; } 1212| 6.33k| removevalues(fs, e->f); /* values are useless when negated */ 1213| 6.33k| removevalues(fs, e->t); 1214| 6.33k|} lcode.c:removevalues: 277| 12.6k|static void removevalues (FuncState *fs, int list) { 278| 137k| for (; list != NO_JUMP; list = getjump(fs, list)) ------------------ | | 20| 137k|#define NO_JUMP (-1) ------------------ | Branch (278:10): [True: 125k, False: 12.6k] ------------------ 279| 125k| patchtestreg(fs, list, NO_REG); ------------------ | | 182| 125k|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 125k|#define MAXARG_A ((1<t != (e)->f) ------------------ | Branch (999:7): [True: 135k, False: 2.95k] ------------------ 1000| 135k| int info; 1001| 135k| switch (e->k) { /* move constants to 'k' */ 1002| 932| case VTRUE: info = boolT(fs); break; ------------------ | Branch (1002:7): [True: 932, False: 134k] ------------------ 1003| 12| case VFALSE: info = boolF(fs); break; ------------------ | Branch (1003:7): [True: 12, False: 134k] ------------------ 1004| 1.14k| case VNIL: info = nilK(fs); break; ------------------ | Branch (1004:7): [True: 1.14k, False: 133k] ------------------ 1005| 57.6k| case VKINT: info = luaK_intK(fs, e->u.ival); break; ------------------ | Branch (1005:7): [True: 57.6k, False: 77.3k] ------------------ 1006| 45.9k| case VKFLT: info = luaK_numberK(fs, e->u.nval); break; ------------------ | Branch (1006:7): [True: 45.9k, False: 89.0k] ------------------ 1007| 1.92k| case VKSTR: info = stringK(fs, e->u.strval); break; ------------------ | Branch (1007:7): [True: 1.92k, False: 133k] ------------------ 1008| 1.16k| case VK: info = e->u.info; break; ------------------ | Branch (1008:7): [True: 1.16k, False: 133k] ------------------ 1009| 26.2k| default: return 0; /* not a constant */ ------------------ | Branch (1009:7): [True: 26.2k, False: 108k] ------------------ 1010| 135k| } 1011| 108k| if (info <= MAXINDEXRK) { /* does constant fit in 'argC'? */ ------------------ | | 175| 108k|#define MAXINDEXRK MAXARG_B | | ------------------ | | | | 96| 108k|#define MAXARG_B ((1<k = VK; /* make expression a 'K' expression */ 1013| 79.0k| e->u.info = info; 1014| 79.0k| return 1; 1015| 79.0k| } 1016| 108k| } 1017| | /* else, expression doesn't fit; leave it unchanged */ 1018| 32.6k| return 0; 1019| 137k|} lcode.c:boolT: 635| 932|static int boolT (FuncState *fs) { 636| 932| TValue o; 637| 932| setbtvalue(&o); ------------------ | | 251| 932|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 932|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 638| 932| return addk(fs, &o, &o); /* use boolean itself as key */ 639| 932|} lcode.c:boolF: 625| 12|static int boolF (FuncState *fs) { 626| 12| TValue o; 627| 12| setbfvalue(&o); ------------------ | | 250| 12|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 628| 12| return addk(fs, &o, &o); /* use boolean itself as key */ 629| 12|} lcode.c:nilK: 645| 1.14k|static int nilK (FuncState *fs) { 646| 1.14k| TValue k, v; 647| 1.14k| setnilvalue(&v); ------------------ | | 200| 1.14k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 1.14k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 648| | /* cannot use nil as key; instead use table itself to represent nil */ 649| 1.14k| sethvalue(fs->ls->L, &k, fs->ls->h); ------------------ | | 685| 1.14k| { TValue *io = (obj); Table *x_ = (x); \ | | 686| 1.14k| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 1.14k|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 390| 1.14k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 1.14k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 1.14k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 687| 1.14k| checkliveness(L,io); } | | ------------------ | | | | 107| 1.14k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 1.14k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 1.14k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 650| 1.14k| return addk(fs, &k, &v); 651| 1.14k|} lcode.c:isSCnumber: 1255| 19.3M|static int isSCnumber (expdesc *e, int *pi, int *isfloat) { 1256| 19.3M| lua_Integer i; 1257| 19.3M| if (e->k == VKINT) ------------------ | Branch (1257:7): [True: 31.0k, False: 19.3M] ------------------ 1258| 31.0k| i = e->u.ival; 1259| 19.3M| else if (e->k == VKFLT && luaV_flttointeger(e->u.nval, &i, F2Ieq)) ------------------ | Branch (1259:12): [True: 6.85k, False: 19.3M] | Branch (1259:29): [True: 5.51k, False: 1.33k] ------------------ 1260| 5.51k| *isfloat = 1; 1261| 19.3M| else 1262| 19.3M| return 0; /* not a number */ 1263| 36.5k| if (!hasjumps(e) && fitsC(i)) { ------------------ | | 38| 73.1k|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (1263:7): [True: 31.9k, False: 4.65k] | Branch (1263:23): [True: 29.8k, False: 2.05k] ------------------ 1264| 29.8k| *pi = int2sC(cast_int(i)); ------------------ | | 100| 29.8k|#define int2sC(i) ((i) + OFFSET_sC) | | ------------------ | | | | 98| 29.8k|#define OFFSET_sC (MAXARG_C >> 1) | | | | ------------------ | | | | | | 97| 29.8k|#define MAXARG_C ((1<> 1) | | ------------------ | | | | 97| 81.0k|#define MAXARG_C ((1<>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 18.6k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (1685:7): [True: 8.76k, False: 9.87k] ------------------ 1686| 8.76k| int n = GETARG_B(*ie2); /* # of elements concatenated in 'e2' */ ------------------ | | 128| 8.76k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 8.76k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1687| 8.76k| lua_assert(e1->u.info + 1 == GETARG_A(*ie2)); ------------------ | | 114| 8.76k|#define lua_assert(c) ((void)0) ------------------ 1688| 8.76k| freeexp(fs, e2); 1689| 8.76k| SETARG_A(*ie2, e1->u.info); /* correct first element ('e1') */ ------------------ | | 126| 8.76k|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 8.76k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 8.76k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 8.76k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 8.76k| ((cast(Instruction, v)<u.info, 2, 0); /* new concat opcode */ ------------------ | | 48| 9.87k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1694| 9.87k| freeexp(fs, e2); 1695| 9.87k| luaK_fixline(fs, line); 1696| 9.87k| } 1697| 18.6k|} lcode.c:codecommutative: 1515| 34.4k| expdesc *e1, expdesc *e2, int line) { 1516| 34.4k| int flip = 0; 1517| 34.4k| if (tonumeral(e1, NULL)) { /* is first operand a numeric constant? */ ------------------ | Branch (1517:7): [True: 4.65k, False: 29.8k] ------------------ 1518| 4.65k| swapexps(e1, e2); /* change order */ 1519| 4.65k| flip = 1; 1520| 4.65k| } 1521| 34.4k| if (op == OPR_ADD && isSCint(e2)) /* immediate operand? */ ------------------ | Branch (1521:7): [True: 3.88k, False: 30.6k] | Branch (1521:24): [True: 1.05k, False: 2.82k] ------------------ 1522| 1.05k| codebini(fs, OP_ADDI, e1, e2, flip, line, TM_ADD); 1523| 33.4k| else 1524| 33.4k| codearith(fs, op, e1, e2, flip, line); 1525| 34.4k|} lcode.c:finishbinexpneg: 1462| 381k| OpCode op, int line, TMS event) { 1463| 381k| if (!isKint(e2)) ------------------ | Branch (1463:7): [True: 361k, False: 19.9k] ------------------ 1464| 361k| return 0; /* not an integer constant */ 1465| 19.9k| else { 1466| 19.9k| lua_Integer i2 = e2->u.ival; 1467| 19.9k| if (!(fitsC(i2) && fitsC(-i2))) ------------------ | Branch (1467:11): [True: 19.2k, False: 722] | Branch (1467:24): [True: 19.2k, False: 0] ------------------ 1468| 722| return 0; /* not in the proper range */ 1469| 19.2k| else { /* operating a small integer constant */ 1470| 19.2k| int v2 = cast_int(i2); ------------------ | | 141| 19.2k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 19.2k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1471| 19.2k| finishbinexpval(fs, e1, e2, op, int2sC(-v2), 0, line, OP_MMBINI, event); ------------------ | | 100| 19.2k|#define int2sC(i) ((i) + OFFSET_sC) | | ------------------ | | | | 98| 19.2k|#define OFFSET_sC (MAXARG_C >> 1) | | | | ------------------ | | | | | | 97| 19.2k|#define MAXARG_C ((1<f->code[fs->pc - 1], int2sC(v2)); ------------------ | | 130| 19.2k|#define SETARG_B(i,v) setarg(i, v, POS_B, SIZE_B) | | ------------------ | | | | 122| 19.2k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 19.2k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 19.2k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 19.2k| ((cast(Instruction, v)<u.info = pc; 1411| 6.20M| e1->k = VRELOC; /* all those operations are relocatable */ 1412| 6.20M| luaK_fixline(fs, line); 1413| 6.20M| luaK_codeABCk(fs, mmop, v1, v2, event, flip); /* to call metamethod */ 1414| 6.20M| luaK_fixline(fs, line); 1415| 6.20M|} lcode.c:freeexps: 527| 12.6M|static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) { 528| 12.6M| int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1; ------------------ | Branch (528:12): [True: 12.6M, False: 7.98k] ------------------ 529| 12.6M| int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1; ------------------ | Branch (529:12): [True: 12.5M, False: 107k] ------------------ 530| 12.6M| freeregs(fs, r1, r2); 531| 12.6M|} lcode.c:codearith: 1501| 5.75M| expdesc *e1, expdesc *e2, int flip, int line) { 1502| 5.75M| if (tonumeral(e2, NULL) && luaK_exp2K(fs, e2)) /* K operand? */ ------------------ | Branch (1502:7): [True: 72.3k, False: 5.68M] | Branch (1502:30): [True: 44.7k, False: 27.6k] ------------------ 1503| 44.7k| codebinK(fs, opr, e1, e2, flip, line); 1504| 5.71M| else /* 'e2' is neither an immediate nor a K operand */ 1505| 5.71M| codebinNoK(fs, opr, e1, e2, flip, line); 1506| 5.75M|} lcode.c:codebinK: 1450| 69.7k| expdesc *e1, expdesc *e2, int flip, int line) { 1451| 69.7k| TMS event = binopr2TM(opr); 1452| 69.7k| int v2 = e2->u.info; /* K index */ 1453| 69.7k| OpCode op = binopr2op(opr, OPR_ADD, OP_ADDK); 1454| 69.7k| finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINK, event); 1455| 69.7k|} lcode.c:binopr2TM: 1378| 6.18M|l_sinline TMS binopr2TM (BinOpr opr) { 1379| 6.18M| lua_assert(OPR_ADD <= opr && opr <= OPR_SHR); ------------------ | | 114| 6.18M|#define lua_assert(c) ((void)0) ------------------ 1380| 6.18M| return cast(TMS, (cast_int(opr) - cast_int(OPR_ADD)) + cast_int(TM_ADD)); ------------------ | | 136| 6.18M|#define cast(t, exp) ((t)(exp)) ------------------ 1381| 6.18M|} lcode.c:binopr2op: 1358| 12.6M|l_sinline OpCode binopr2op (BinOpr opr, BinOpr baser, OpCode base) { 1359| 12.6M| lua_assert(baser <= opr && ------------------ | | 114| 12.6M|#define lua_assert(c) ((void)0) ------------------ 1360| 12.6M| ((baser == OPR_ADD && opr <= OPR_SHR) || 1361| 12.6M| (baser == OPR_LT && opr <= OPR_LE))); 1362| 12.6M| return cast(OpCode, (cast_int(opr) - cast_int(baser)) + cast_int(base)); ------------------ | | 136| 12.6M|#define cast(t, exp) ((t)(exp)) ------------------ 1363| 12.6M|} lcode.c:codebinNoK: 1489| 5.75M| expdesc *e1, expdesc *e2, int flip, int line) { 1490| 5.75M| if (flip) ------------------ | Branch (1490:7): [True: 1.34k, False: 5.75M] ------------------ 1491| 1.34k| swapexps(e1, e2); /* back to original order */ 1492| 5.75M| codebinexpval(fs, opr, e1, e2, line); /* use standard operators */ 1493| 5.75M|} lcode.c:codebitwise: 1533| 69.9k| expdesc *e1, expdesc *e2, int line) { 1534| 69.9k| int flip = 0; 1535| 69.9k| if (e1->k == VKINT) { ------------------ | Branch (1535:7): [True: 5.22k, False: 64.7k] ------------------ 1536| 5.22k| swapexps(e1, e2); /* 'e2' will be the constant operand */ 1537| 5.22k| flip = 1; 1538| 5.22k| } 1539| 69.9k| if (e2->k == VKINT && luaK_exp2K(fs, e2)) /* K operand? */ ------------------ | Branch (1539:7): [True: 27.0k, False: 42.9k] | Branch (1539:25): [True: 25.0k, False: 1.95k] ------------------ 1540| 25.0k| codebinK(fs, opr, e1, e2, flip, line); 1541| 44.9k| else /* no constants */ 1542| 44.9k| codebinNoK(fs, opr, e1, e2, flip, line); 1543| 69.9k|} lcode.c:isSCint: 1246| 363k|static int isSCint (expdesc *e) { 1247| 363k| return isKint(e) && fitsC(e->u.ival); ------------------ | Branch (1247:10): [True: 9.91k, False: 353k] | Branch (1247:23): [True: 6.32k, False: 3.59k] ------------------ 1248| 363k|} lcode.c:swapexps: 1480| 70.6k|static void swapexps (expdesc *e1, expdesc *e2) { 1481| 70.6k| expdesc temp = *e1; *e1 = *e2; *e2 = temp; /* swap 'e1' and 'e2' */ 1482| 70.6k|} lcode.c:codebini: 1439| 6.32k| TMS event) { 1440| 6.32k| int v2 = int2sC(cast_int(e2->u.ival)); /* immediate operand */ ------------------ | | 100| 6.32k|#define int2sC(i) ((i) + OFFSET_sC) | | ------------------ | | | | 98| 6.32k|#define OFFSET_sC (MAXARG_C >> 1) | | | | ------------------ | | | | | | 97| 6.32k|#define MAXARG_C ((1<k == VKINT); ------------------ | | 114| 6.32k|#define lua_assert(c) ((void)0) ------------------ 1442| 6.32k| finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINI, event); 1443| 6.32k|} lcode.c:codebinexpval: 1423| 6.11M| expdesc *e1, expdesc *e2, int line) { 1424| 6.11M| OpCode op = binopr2op(opr, OPR_ADD, OP_ADD); 1425| 6.11M| 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| 6.11M| lua_assert((VNIL <= e1->k && e1->k <= VKSTR) || ------------------ | | 114| 6.11M|#define lua_assert(c) ((void)0) ------------------ 1428| 6.11M| e1->k == VNONRELOC || e1->k == VRELOC); 1429| 6.11M| lua_assert(OP_ADD <= op && op <= OP_SHR); ------------------ | | 114| 6.11M|#define lua_assert(c) ((void)0) ------------------ 1430| 6.11M| finishbinexpval(fs, e1, e2, op, v2, 0, line, OP_MMBIN, binopr2TM(opr)); 1431| 6.11M|} lcode.c:codeeq: 1582| 10.2k|static void codeeq (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) { 1583| 10.2k| int r1, r2; 1584| 10.2k| int im; 1585| 10.2k| int isfloat = 0; /* not needed here, but kept for symmetry */ 1586| 10.2k| OpCode op; 1587| 10.2k| if (e1->k != VNONRELOC) { ------------------ | Branch (1587:7): [True: 5.51k, False: 4.76k] ------------------ 1588| 5.51k| lua_assert(e1->k == VK || e1->k == VKINT || e1->k == VKFLT); ------------------ | | 114| 5.51k|#define lua_assert(c) ((void)0) ------------------ 1589| 5.51k| swapexps(e1, e2); 1590| 5.51k| } 1591| 10.2k| r1 = luaK_exp2anyreg(fs, e1); /* 1st expression must be in register */ 1592| 10.2k| if (isSCnumber(e2, &im, &isfloat)) { ------------------ | Branch (1592:7): [True: 3.30k, False: 6.96k] ------------------ 1593| 3.30k| op = OP_EQI; 1594| 3.30k| r2 = im; /* immediate operand */ 1595| 3.30k| } 1596| 6.96k| else if (exp2RK(fs, e2)) { /* 2nd expression is constant? */ ------------------ | Branch (1596:12): [True: 3.10k, False: 3.86k] ------------------ 1597| 3.10k| op = OP_EQK; 1598| 3.10k| r2 = e2->u.info; /* constant index */ 1599| 3.10k| } 1600| 3.86k| else { 1601| 3.86k| op = OP_EQ; /* will compare two registers */ 1602| 3.86k| r2 = luaK_exp2anyreg(fs, e2); 1603| 3.86k| } 1604| 10.2k| freeexps(fs, e1, e2); 1605| 10.2k| e1->u.info = condjump(fs, op, r1, r2, isfloat, (opr == OPR_EQ)); 1606| 10.2k| e1->k = VJMP; 1607| 10.2k|} lcode.c:codeorder: 1550| 6.45M|static void codeorder (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) { 1551| 6.45M| int r1, r2; 1552| 6.45M| int im; 1553| 6.45M| int isfloat = 0; 1554| 6.45M| OpCode op; 1555| 6.45M| if (isSCnumber(e2, &im, &isfloat)) { ------------------ | Branch (1555:7): [True: 5.91k, False: 6.44M] ------------------ 1556| | /* use immediate operand */ 1557| 5.91k| r1 = luaK_exp2anyreg(fs, e1); 1558| 5.91k| r2 = im; 1559| 5.91k| op = binopr2op(opr, OPR_LT, OP_LTI); 1560| 5.91k| } 1561| 6.44M| else if (isSCnumber(e1, &im, &isfloat)) { ------------------ | Branch (1561:12): [True: 7.98k, False: 6.43M] ------------------ 1562| | /* transform (A < B) to (B > A) and (A <= B) to (B >= A) */ 1563| 7.98k| r1 = luaK_exp2anyreg(fs, e2); 1564| 7.98k| r2 = im; 1565| 7.98k| op = binopr2op(opr, OPR_LT, OP_GTI); 1566| 7.98k| } 1567| 6.43M| else { /* regular case, compare two registers */ 1568| 6.43M| r1 = luaK_exp2anyreg(fs, e1); 1569| 6.43M| r2 = luaK_exp2anyreg(fs, e2); 1570| 6.43M| op = binopr2op(opr, OPR_LT, OP_LT); 1571| 6.43M| } 1572| 6.45M| freeexps(fs, e1, e2); 1573| 6.45M| e1->u.info = condjump(fs, op, r1, r2, isfloat, 1); 1574| 6.45M| e1->k = VJMP; 1575| 6.45M|} lcode.c:removelastlineinfo: 353| 13.1M|static void removelastlineinfo (FuncState *fs) { 354| 13.1M| Proto *f = fs->f; 355| 13.1M| int pc = fs->pc - 1; /* last instruction coded */ 356| 13.1M| if (f->lineinfo[pc] != ABSLINEINFO) { /* relative line info? */ ------------------ | | 27| 13.1M|#define ABSLINEINFO (-0x80) ------------------ | Branch (356:7): [True: 13.0M, False: 102k] ------------------ 357| 13.0M| fs->previousline -= f->lineinfo[pc]; /* correct last line saved */ 358| 13.0M| fs->iwthabs--; /* undo previous increment */ 359| 13.0M| } 360| 102k| else { /* absolute line information */ 361| 102k| lua_assert(f->abslineinfo[fs->nabslineinfo - 1].pc == pc); ------------------ | | 114| 102k|#define lua_assert(c) ((void)0) ------------------ 362| 102k| fs->nabslineinfo--; /* remove it */ 363| 102k| fs->iwthabs = MAXIWTHABS + 1; /* force next line info to be absolute */ ------------------ | | 35| 102k|#define MAXIWTHABS 128 ------------------ 364| 102k| } 365| 13.1M|} lcode.c:finaltarget: 1827| 225k|static int finaltarget (Instruction *code, int i) { 1828| 225k| int count; 1829| 453k| for (count = 0; count < 100; count++) { /* avoid infinite loops */ ------------------ | Branch (1829:19): [True: 453k, False: 0] ------------------ 1830| 453k| Instruction pc = code[i]; 1831| 453k| if (GET_OPCODE(pc) != OP_JMP) ------------------ | | 114| 453k|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 453k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (1831:9): [True: 225k, False: 227k] ------------------ 1832| 225k| break; 1833| 227k| else 1834| 227k| i += GETARG_sJ(pc) + 1; ------------------ | | 151| 227k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | ------------------ | | | | 115| 227k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1835| 453k| } 1836| 225k| return i; 1837| 225k|} luaG_getfuncline: 83| 112|int luaG_getfuncline (const Proto *f, int pc) { 84| 112| if (f->lineinfo == NULL) /* no debug information? */ ------------------ | Branch (84:7): [True: 0, False: 112] ------------------ 85| 0| return -1; 86| 112| else { 87| 112| int basepc; 88| 112| int baseline = getbaseline(f, pc, &basepc); 89| 4.16k| while (basepc++ < pc) { /* walk until given instruction */ ------------------ | Branch (89:12): [True: 4.05k, False: 112] ------------------ 90| 4.05k| lua_assert(f->lineinfo[basepc] != ABSLINEINFO); ------------------ | | 114| 4.05k|#define lua_assert(c) ((void)0) ------------------ 91| 4.05k| baseline += f->lineinfo[basepc]; /* correct line */ 92| 4.05k| } 93| 112| return baseline; 94| 112| } 95| 112|} lua_getstack: 160| 280|LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) { 161| 280| int status; 162| 280| CallInfo *ci; 163| 280| if (level < 0) return 0; /* invalid (negative) level */ ------------------ | Branch (163:7): [True: 0, False: 280] ------------------ 164| 280| lua_lock(L); ------------------ | | 264| 280|#define lua_lock(L) ((void) 0) ------------------ 165| 672| for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous) ------------------ | Branch (165:20): [True: 392, False: 280] | Branch (165:33): [True: 392, False: 0] ------------------ 166| 392| level--; 167| 280| if (level == 0 && ci != &L->base_ci) { /* level found? */ ------------------ | Branch (167:7): [True: 280, False: 0] | Branch (167:21): [True: 168, False: 112] ------------------ 168| 168| status = 1; 169| 168| ar->i_ci = ci; 170| 168| } 171| 112| else status = 0; /* no such level */ 172| 280| lua_unlock(L); ------------------ | | 265| 280|#define lua_unlock(L) ((void) 0) ------------------ 173| 280| return status; 174| 280|} lua_getinfo: 383| 112|LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) { 384| 112| int status; 385| 112| Closure *cl; 386| 112| CallInfo *ci; 387| 112| TValue *func; 388| 112| lua_lock(L); ------------------ | | 264| 112|#define lua_lock(L) ((void) 0) ------------------ 389| 112| if (*what == '>') { ------------------ | Branch (389:7): [True: 0, False: 112] ------------------ 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| 112| else { 397| 112| ci = ar->i_ci; 398| 112| func = s2v(ci->func.p); ------------------ | | 172| 112|#define s2v(o) (&(o)->val) ------------------ 399| 112| lua_assert(ttisfunction(func)); ------------------ | | 114| 112|#define lua_assert(c) ((void)0) ------------------ 400| 112| } 401| 112| cl = ttisclosure(func) ? clvalue(func) : NULL; ------------------ | | 596| 112|#define ttisclosure(o) (ttisLclosure(o) || ttisCclosure(o)) | | ------------------ | | | | 593| 112|#define ttisLclosure(o) checktag((o), ctb(LUA_VLCL)) | | | | ------------------ | | | | | | 91| 224|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 112|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 112, 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| 112|#define clvalue(o) check_exp(ttisclosure(o), gco2cl(val_(o).gc)) | | ------------------ | | | | 115| 112|#define check_exp(c,e) (e) | | ------------------ ------------------ 402| 112| status = auxgetinfo(L, what, ar, cl, ci); 403| 112| if (strchr(what, 'f')) { ------------------ | Branch (403:7): [True: 56, False: 56] ------------------ 404| 56| setobj2s(L, L->top.p, func); ------------------ | | 131| 56|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 56| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 56| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 56|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 56| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 56| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 56|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 56| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 56|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 405| 56| api_incr_top(L); ------------------ | | 16| 56|#define api_incr_top(L) {L->top.p++; \ | | 17| 56| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 56|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 56|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 18| 56| "stack overflow");} ------------------ 406| 56| } 407| 112| if (strchr(what, 'L')) ------------------ | Branch (407:7): [True: 0, False: 112] ------------------ 408| 0| collectvalidlines(L, cl); 409| 112| lua_unlock(L); ------------------ | | 265| 112|#define lua_unlock(L) ((void) 0) ------------------ 410| 112| return status; 411| 112|} luaG_typeerror: 736| 46|l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) { 737| 46| typeerror(L, o, op, varinfo(L, o)); 738| 46|} luaG_callerror: 746| 2|l_noret luaG_callerror (lua_State *L, const TValue *o) { 747| 2| CallInfo *ci = L->ci; 748| 2| const char *name = NULL; /* to avoid warnings */ 749| 2| const char *kind = funcnamefromcall(L, ci, &name); 750| 2| const char *extra = kind ? formatvarinfo(L, kind, name) : varinfo(L, o); ------------------ | Branch (750:23): [True: 2, False: 0] ------------------ 751| 2| typeerror(L, o, "call", extra); 752| 2|} 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: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 763| 1| luaG_typeerror(L, p1, "concatenate"); 764| 1|} luaG_opinterror: 768| 44| const TValue *p2, const char *msg) { 769| 44| if (!ttisnumber(p1)) /* first operand is wrong? */ ------------------ | | 326| 44|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | ------------------ | | | | 92| 44|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 44|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 44|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (769:7): [True: 41, False: 3] ------------------ 770| 41| p2 = p1; /* now second is wrong */ 771| 44| luaG_typeerror(L, p2, msg); 772| 44|} luaG_tointerror: 778| 3|l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) { 779| 3| lua_Integer temp; 780| 3| if (!luaV_tointegerns(p1, &temp, LUA_FLOORN2I)) ------------------ | | 36| 3|#define LUA_FLOORN2I F2Ieq ------------------ | Branch (780:7): [True: 3, False: 0] ------------------ 781| 3| p2 = p1; 782| 3| luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2)); 783| 3|} luaG_ordererror: 786| 2|l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) { 787| 2| const char *t1 = luaT_objtypename(L, p1); 788| 2| const char *t2 = luaT_objtypename(L, p2); 789| 2| if (strcmp(t1, t2) == 0) ------------------ | Branch (789:7): [True: 1, False: 1] ------------------ 790| 1| luaG_runerror(L, "attempt to compare two %s values", t1); 791| 1| else 792| 1| luaG_runerror(L, "attempt to compare %s with %s", t1, t2); 793| 2|} luaG_addinfo: 798| 377| int line) { 799| 377| char buff[LUA_IDSIZE]; 800| 377| if (src) ------------------ | Branch (800:7): [True: 377, False: 0] ------------------ 801| 377| luaO_chunkid(buff, getstr(src), tsslen(src)); ------------------ | | 404| 377|#define getstr(ts) ((ts)->contents) ------------------ luaO_chunkid(buff, getstr(src), tsslen(src)); ------------------ | | 411| 377| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 377, False: 0] | | ------------------ ------------------ 802| 0| else { /* no source available; use "?" instead */ 803| 0| buff[0] = '?'; buff[1] = '\0'; 804| 0| } 805| 377| return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg); 806| 377|} luaG_errormsg: 809| 61|l_noret luaG_errormsg (lua_State *L) { 810| 61| if (L->errfunc != 0) { /* is there an error handling function? */ ------------------ | Branch (810:7): [True: 56, False: 5] ------------------ 811| 56| StkId errfunc = restorestack(L, L->errfunc); ------------------ | | 37| 56|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 56|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 812| 56| lua_assert(ttisfunction(s2v(errfunc))); ------------------ | | 114| 56|#define lua_assert(c) ((void)0) ------------------ 813| 56| setobjs2s(L, L->top.p, L->top.p - 1); /* move argument */ ------------------ | | 129| 56|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 56| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 56| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 56|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 56| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 56| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 56|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 56| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 56|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 814| 56| setobjs2s(L, L->top.p - 1, errfunc); /* push function */ ------------------ | | 129| 56|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 56| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 56| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 56|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 56| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 56| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 56|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 56| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 56|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 815| 56| L->top.p++; /* assume EXTRA_STACK */ 816| 56| luaD_callnoyield(L, L->top.p - 2, 1); /* call it */ 817| 56| } 818| 61| luaD_throw(L, LUA_ERRRUN); ------------------ | | 50| 61|#define LUA_ERRRUN 2 ------------------ 819| 61|} luaG_runerror: 822| 61|l_noret luaG_runerror (lua_State *L, const char *fmt, ...) { 823| 61| CallInfo *ci = L->ci; 824| 61| const char *msg; 825| 61| va_list argp; 826| 61| luaC_checkGC(L); /* error message uses memory */ ------------------ | | 172| 61|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 61| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 61|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 61] | | | | ------------------ | | | | 169| 61| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 61|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 827| 61| va_start(argp, fmt); 828| 61| msg = luaO_pushvfstring(L, fmt, argp); /* format message */ 829| 61| va_end(argp); 830| 61| if (isLua(ci)) { /* if Lua function, add source:line information */ ------------------ | | 241| 61|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 61|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 56, False: 5] | | ------------------ ------------------ 831| 56| luaG_addinfo(L, msg, ci_func(ci)->p->source, getcurrentline(ci)); ------------------ | | 18| 56|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 56|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 56|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 832| 56| setobjs2s(L, L->top.p - 2, L->top.p - 1); /* remove 'msg' */ ------------------ | | 129| 56|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 56| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 56| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 56|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 56| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 56| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 56|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 56| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 56|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 833| 56| L->top.p--; 834| 56| } 835| 61| luaG_errormsg(L); 836| 61|} luaG_traceexec: 902| 14|int luaG_traceexec (lua_State *L, const Instruction *pc) { 903| 14| CallInfo *ci = L->ci; 904| 14| lu_byte mask = L->hookmask; 905| 14| const Proto *p = ci_func(ci)->p; ------------------ | | 18| 14|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 14|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 14|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 906| 14| int counthook; 907| 14| if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) { /* no hooks? */ ------------------ | | 452| 14|#define LUA_MASKLINE (1 << LUA_HOOKLINE) | | ------------------ | | | | 442| 14|#define LUA_HOOKLINE 2 | | ------------------ ------------------ if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) { /* no hooks? */ ------------------ | | 453| 14|#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) | | ------------------ | | | | 443| 14|#define LUA_HOOKCOUNT 3 | | ------------------ ------------------ | Branch (907:7): [True: 14, False: 0] ------------------ 908| 14| ci->u.l.trap = 0; /* don't need to stop again */ 909| 14| return 0; /* turn off 'trap' */ 910| 14| } 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)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | 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| 112|static int getbaseline (const Proto *f, int pc, int *basepc) { 61| 112| if (f->sizeabslineinfo == 0 || pc < f->abslineinfo[0].pc) { ------------------ | Branch (61:7): [True: 50, False: 62] | Branch (61:34): [True: 16, False: 46] ------------------ 62| 66| *basepc = -1; /* start from the beginning */ 63| 66| return f->linedefined; 64| 66| } 65| 46| else { 66| 46| int i = cast_uint(pc) / MAXIWTHABS - 1; /* get an estimate */ ------------------ | | 142| 46|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 46|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ int i = cast_uint(pc) / MAXIWTHABS - 1; /* get an estimate */ ------------------ | | 35| 46|#define MAXIWTHABS 128 ------------------ 67| | /* estimate must be a lower bound of the correct base */ 68| 46| lua_assert(i < 0 || ------------------ | | 114| 46|#define lua_assert(c) ((void)0) ------------------ 69| 46| (i < f->sizeabslineinfo && f->abslineinfo[i].pc <= pc)); 70| 56| while (i + 1 < f->sizeabslineinfo && pc >= f->abslineinfo[i + 1].pc) ------------------ | Branch (70:12): [True: 36, False: 20] | Branch (70:42): [True: 10, False: 26] ------------------ 71| 10| i++; /* low estimate; adjust it */ 72| 46| *basepc = f->abslineinfo[i].pc; 73| 46| return f->abslineinfo[i].line; 74| 46| } 75| 112|} ldebug.c:currentpc: 41| 163|static int currentpc (CallInfo *ci) { 42| 163| lua_assert(isLua(ci)); ------------------ | | 114| 163|#define lua_assert(c) ((void)0) ------------------ 43| 163| return pcRel(ci->u.l.savedpc, ci_func(ci)->p); ------------------ | | 14| 163|#define pcRel(pc, p) (cast_int((pc) - (p)->code) - 1) | | ------------------ | | | | 141| 163|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 163|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 44| 163|} ldebug.c:auxgetinfo: 328| 112| Closure *f, CallInfo *ci) { 329| 112| int status = 1; 330| 392| for (; *what; what++) { ------------------ | Branch (330:10): [True: 280, False: 112] ------------------ 331| 280| switch (*what) { 332| 56| case 'S': { ------------------ | Branch (332:7): [True: 56, False: 224] ------------------ 333| 56| funcinfo(ar, f); 334| 56| break; 335| 0| } 336| 56| case 'l': { ------------------ | Branch (336:7): [True: 56, False: 224] ------------------ 337| 56| ar->currentline = (ci && isLua(ci)) ? getcurrentline(ci) : -1; ------------------ | | 241| 56|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 56|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 56, False: 0] | | ------------------ ------------------ | Branch (337:28): [True: 56, False: 0] ------------------ 338| 56| break; 339| 0| } 340| 0| case 'u': { ------------------ | Branch (340:7): [True: 0, False: 280] ------------------ 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| 56| case 't': { ------------------ | Branch (352:7): [True: 56, False: 224] ------------------ 353| 56| ar->istailcall = (ci) ? ci->callstatus & CIST_TAIL : 0; ------------------ | | 215| 56|#define CIST_TAIL (1<<5) /* call was tail called */ ------------------ | Branch (353:26): [True: 56, False: 0] ------------------ 354| 56| break; 355| 0| } 356| 56| case 'n': { ------------------ | Branch (356:7): [True: 56, False: 224] ------------------ 357| 56| ar->namewhat = getfuncname(L, ci, &ar->name); 358| 56| if (ar->namewhat == NULL) { ------------------ | Branch (358:13): [True: 56, False: 0] ------------------ 359| 56| ar->namewhat = ""; /* not found */ 360| 56| ar->name = NULL; 361| 56| } 362| 56| break; 363| 0| } 364| 0| case 'r': { ------------------ | Branch (364:7): [True: 0, False: 280] ------------------ 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: 280] ------------------ 374| 56| case 'f': /* handled by lua_getinfo */ ------------------ | Branch (374:7): [True: 56, False: 224] ------------------ 375| 56| break; 376| 0| default: status = 0; /* invalid option */ ------------------ | Branch (376:7): [True: 0, False: 280] ------------------ 377| 280| } 378| 280| } 379| 112| return status; 380| 112|} ldebug.c:funcinfo: 256| 56|static void funcinfo (lua_Debug *ar, Closure *cl) { 257| 56| if (noLuaClosure(cl)) { ------------------ | | 34| 56|#define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_VCCL) | | ------------------ | | | | 590| 56|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | | | ------------------ | | | | | | 42| 56|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (34:27): [True: 0, False: 56] | | | Branch (34:42): [True: 0, False: 56] | | ------------------ ------------------ 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| 56| else { 265| 56| const Proto *p = cl->l.p; 266| 56| if (p->source) { ------------------ | Branch (266:9): [True: 56, False: 0] ------------------ 267| 56| ar->source = getstr(p->source); ------------------ | | 404| 56|#define getstr(ts) ((ts)->contents) ------------------ 268| 56| ar->srclen = tsslen(p->source); ------------------ | | 411| 56| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 56, False: 0] | | ------------------ ------------------ 269| 56| } 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| 56| ar->linedefined = p->linedefined; 275| 56| ar->lastlinedefined = p->lastlinedefined; 276| 56| ar->what = (ar->linedefined == 0) ? "main" : "Lua"; ------------------ | Branch (276:16): [True: 56, False: 0] ------------------ 277| 56| } 278| 56| luaO_chunkid(ar->short_src, ar->source, ar->srclen); 279| 56|} ldebug.c:getfuncname: 319| 56|static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) { 320| | /* calling function is a known function? */ 321| 56| if (ci != NULL && !(ci->callstatus & CIST_TAIL)) ------------------ | | 215| 56|#define CIST_TAIL (1<<5) /* call was tail called */ ------------------ | Branch (321:7): [True: 56, False: 0] | Branch (321:21): [True: 56, False: 0] ------------------ 322| 56| return funcnamefromcall(L, ci->previous, name); 323| 0| else return NULL; /* no way to find a name */ 324| 56|} ldebug.c:typeerror: 726| 48| const char *extra) { 727| 48| const char *t = luaT_objtypename(L, o); 728| 48| luaG_runerror(L, "attempt to %s a %s value%s", op, t, extra); 729| 48|} ldebug.c:varinfo: 706| 49|static const char *varinfo (lua_State *L, const TValue *o) { 707| 49| CallInfo *ci = L->ci; 708| 49| const char *name = NULL; /* to avoid warnings */ 709| 49| const char *kind = NULL; 710| 49| if (isLua(ci)) { ------------------ | | 241| 49|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 49|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 49, False: 0] | | ------------------ ------------------ 711| 49| kind = getupvalname(ci, o, &name); /* check whether 'o' is an upvalue */ 712| 49| if (!kind) { /* not an upvalue? */ ------------------ | Branch (712:9): [True: 49, False: 0] ------------------ 713| 49| int reg = instack(ci, o); /* try a register */ 714| 49| if (reg >= 0) /* is 'o' a register? */ ------------------ | Branch (714:11): [True: 49, False: 0] ------------------ 715| 49| kind = getobjname(ci_func(ci)->p, currentpc(ci), reg, &name); ------------------ | | 18| 49|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 49|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 49|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 716| 49| } 717| 49| } 718| 49| return formatvarinfo(L, kind, name); 719| 49|} ldebug.c:getupvalname: 681| 49| const char **name) { 682| 49| LClosure *c = ci_func(ci); ------------------ | | 18| 49|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 49|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 49|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 683| 49| int i; 684| 98| for (i = 0; i < c->nupvalues; i++) { ------------------ | Branch (684:15): [True: 49, False: 49] ------------------ 685| 49| if (c->upvals[i]->v.p == o) { ------------------ | Branch (685:9): [True: 0, False: 49] ------------------ 686| 0| *name = upvalname(c->p, i); 687| 0| return "upvalue"; 688| 0| } 689| 49| } 690| 49| return NULL; 691| 49|} ldebug.c:upvalname: 177| 15|static const char *upvalname (const Proto *p, int uv) { 178| 15| TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name); ------------------ | | 115| 15|#define check_exp(c,e) (e) ------------------ 179| 15| if (s == NULL) return "?"; ------------------ | Branch (179:7): [True: 0, False: 15] ------------------ 180| 15| else return getstr(s); ------------------ | | 404| 15|#define getstr(ts) ((ts)->contents) ------------------ 181| 15|} ldebug.c:instack: 664| 49|static int instack (CallInfo *ci, const TValue *o) { 665| 49| int pos; 666| 49| StkId base = ci->func.p + 1; 667| 121| for (pos = 0; base + pos < ci->top.p; pos++) { ------------------ | Branch (667:17): [True: 121, False: 0] ------------------ 668| 121| if (o == s2v(base + pos)) ------------------ | | 172| 121|#define s2v(o) (&(o)->val) ------------------ | Branch (668:9): [True: 49, False: 72] ------------------ 669| 49| return pos; 670| 121| } 671| 0| return -1; /* not found */ 672| 49|} ldebug.c:getobjname: 527| 58| const char **name) { 528| 58| int pc; 529| 58| *name = luaF_getlocalname(p, reg + 1, lastpc); 530| 58| if (*name) /* is a local? */ ------------------ | Branch (530:7): [True: 1, False: 57] ------------------ 531| 1| return "local"; 532| | /* else try symbolic execution */ 533| 57| pc = findsetreg(p, lastpc, reg); 534| 57| if (pc != -1) { /* could find instruction? */ ------------------ | Branch (534:7): [True: 57, False: 0] ------------------ 535| 57| Instruction i = p->code[pc]; 536| 57| OpCode op = GET_OPCODE(i); ------------------ | | 114| 57|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 57|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 537| 57| switch (op) { 538| 0| case OP_MOVE: { ------------------ | Branch (538:7): [True: 0, False: 57] ------------------ 539| 0| int b = GETARG_B(i); /* move from 'b' to 'a' */ ------------------ | | 128| 0|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 540| 0| if (b < GETARG_A(i)) ------------------ | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (540:13): [True: 0, False: 0] ------------------ 541| 0| return getobjname(p, pc, b, name); /* get name for 'b' */ 542| 0| break; 543| 0| } 544| 12| case OP_GETTABUP: { ------------------ | Branch (544:7): [True: 12, False: 45] ------------------ 545| 12| int k = GETARG_C(i); /* key index */ ------------------ | | 132| 12|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 12|#define check_exp(c,e) (e) | | ------------------ ------------------ 546| 12| kname(p, k, name); 547| 12| return gxf(p, pc, i, 1); 548| 0| } 549| 3| case OP_GETTABLE: { ------------------ | Branch (549:7): [True: 3, False: 54] ------------------ 550| 3| int k = GETARG_C(i); /* key index */ ------------------ | | 132| 3|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 3|#define check_exp(c,e) (e) | | ------------------ ------------------ 551| 3| rname(p, pc, k, name); 552| 3| return gxf(p, pc, i, 0); 553| 0| } 554| 0| case OP_GETI: { ------------------ | Branch (554:7): [True: 0, False: 57] ------------------ 555| 0| *name = "integer index"; 556| 0| return "field"; 557| 0| } 558| 1| case OP_GETFIELD: { ------------------ | Branch (558:7): [True: 1, False: 56] ------------------ 559| 1| int k = GETARG_C(i); /* key index */ ------------------ | | 132| 1|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 1|#define check_exp(c,e) (e) | | ------------------ ------------------ 560| 1| kname(p, k, name); 561| 1| return gxf(p, pc, i, 0); 562| 0| } 563| 3| case OP_GETUPVAL: { ------------------ | Branch (563:7): [True: 3, False: 54] ------------------ 564| 3| *name = upvalname(p, GETARG_B(i)); ------------------ | | 128| 3|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 3|#define check_exp(c,e) (e) | | ------------------ ------------------ 565| 3| return "upvalue"; 566| 0| } 567| 36| case OP_LOADK: ------------------ | Branch (567:7): [True: 36, False: 21] ------------------ 568| 36| case OP_LOADKX: { ------------------ | Branch (568:7): [True: 0, False: 57] ------------------ 569| 36| int b = (op == OP_LOADK) ? GETARG_Bx(i) ------------------ | | 140| 36|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 115| 36|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (569:17): [True: 36, False: 0] ------------------ 570| 36| : GETARG_Ax(p->code[pc + 1]); ------------------ | | 143| 0|#define GETARG_Ax(i) check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 571| 36| if (ttisstring(&p->k[b])) { ------------------ | | 363| 36|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 36|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 36|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 36|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 34, False: 2] | | | | ------------------ | | ------------------ ------------------ 572| 34| *name = getstr(tsvalue(&p->k[b])); ------------------ | | 404| 34|#define getstr(ts) ((ts)->contents) ------------------ 573| 34| return "constant"; 574| 34| } 575| 2| break; 576| 36| } 577| 2| case OP_SELF: { ------------------ | Branch (577:7): [True: 0, False: 57] ------------------ 578| 0| rkname(p, pc, i, name); 579| 0| return "method"; 580| 36| } 581| 2| default: break; /* go through to return NULL */ ------------------ | Branch (581:7): [True: 2, False: 55] ------------------ 582| 57| } 583| 57| } 584| 4| return NULL; /* could not find reasonable name */ 585| 57|} ldebug.c:findsetreg: 465| 57|static int findsetreg (const Proto *p, int lastpc, int reg) { 466| 57| int pc; 467| 57| int setreg = -1; /* keep last instruction that changed 'reg' */ 468| 57| int jmptarget = 0; /* any code before this address is conditional */ 469| 57| if (testMMMode(GET_OPCODE(p->code[lastpc]))) ------------------ | | 388| 57|#define testMMMode(m) (luaP_opmodes[m] & (1 << 7)) | | ------------------ | | | Branch (388:23): [True: 26, False: 31] | | ------------------ ------------------ 470| 26| lastpc--; /* previous instruction was not actually executed */ 471| 1.24M| for (pc = 0; pc < lastpc; pc++) { ------------------ | Branch (471:16): [True: 1.24M, False: 57] ------------------ 472| 1.24M| Instruction i = p->code[pc]; 473| 1.24M| OpCode op = GET_OPCODE(i); ------------------ | | 114| 1.24M|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 1.24M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 474| 1.24M| int a = GETARG_A(i); ------------------ | | 125| 1.24M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 1.24M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 1.24M|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 1.24M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 475| 1.24M| int change; /* true if current instruction changed 'reg' */ 476| 1.24M| switch (op) { 477| 2.47k| case OP_LOADNIL: { /* set registers from 'a' to 'a+b' */ ------------------ | Branch (477:7): [True: 2.47k, False: 1.24M] ------------------ 478| 2.47k| int b = GETARG_B(i); ------------------ | | 128| 2.47k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 2.47k|#define check_exp(c,e) (e) | | ------------------ ------------------ 479| 2.47k| change = (a <= reg && reg <= a + b); ------------------ | Branch (479:19): [True: 2.30k, False: 166] | Branch (479:31): [True: 2.30k, False: 5] ------------------ 480| 2.47k| break; 481| 0| } 482| 0| case OP_TFORCALL: { /* affect all regs above its base */ ------------------ | Branch (482:7): [True: 0, False: 1.24M] ------------------ 483| 0| change = (reg >= a + 2); 484| 0| break; 485| 0| } 486| 135k| case OP_CALL: ------------------ | Branch (486:7): [True: 135k, False: 1.11M] ------------------ 487| 135k| case OP_TAILCALL: { /* affect all registers above base */ ------------------ | Branch (487:7): [True: 0, False: 1.24M] ------------------ 488| 135k| change = (reg >= a); 489| 135k| break; 490| 135k| } 491| 175k| case OP_JMP: { /* doesn't change registers, but changes 'jmptarget' */ ------------------ | Branch (491:7): [True: 175k, False: 1.07M] ------------------ 492| 175k| int b = GETARG_sJ(i); ------------------ | | 151| 175k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | ------------------ | | | | 115| 175k|#define check_exp(c,e) (e) | | ------------------ ------------------ 493| 175k| int dest = pc + 1 + b; 494| | /* jump does not skip 'lastpc' and is larger than current one? */ 495| 175k| if (dest <= lastpc && dest > jmptarget) ------------------ | Branch (495:13): [True: 175k, False: 2] | Branch (495:31): [True: 68, False: 175k] ------------------ 496| 68| jmptarget = dest; /* update 'jmptarget' */ 497| 175k| change = 0; 498| 175k| break; 499| 135k| } 500| 934k| default: /* any instruction that sets A */ ------------------ | Branch (500:7): [True: 934k, False: 313k] ------------------ 501| 934k| change = (testAMode(op) && reg == a); ------------------ | | 384| 1.86M|#define testAMode(m) (luaP_opmodes[m] & (1 << 3)) | | ------------------ | | | Branch (384:22): [True: 734k, False: 200k] | | ------------------ ------------------ | Branch (501:36): [True: 205k, False: 528k] ------------------ 502| 934k| break; 503| 1.24M| } 504| 1.24M| if (change) ------------------ | Branch (504:9): [True: 238k, False: 1.00M] ------------------ 505| 238k| setreg = filterpc(pc, jmptarget); 506| 1.24M| } 507| 57| return setreg; 508| 57|} ldebug.c:filterpc: 455| 238k|static int filterpc (int pc, int jmptarget) { 456| 238k| if (pc < jmptarget) /* is code conditional (inside a jump)? */ ------------------ | Branch (456:7): [True: 238k, False: 405] ------------------ 457| 238k| return -1; /* cannot know who sets that register */ 458| 405| else return pc; /* current position sets that register */ 459| 238k|} ldebug.c:kname: 427| 13|static void kname (const Proto *p, int c, const char **name) { 428| 13| TValue *kvalue = &p->k[c]; 429| 13| *name = (ttisstring(kvalue)) ? getstr(tsvalue(kvalue)) : "?"; ------------------ | | 363| 13|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 13|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 13|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 13|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ *name = (ttisstring(kvalue)) ? getstr(tsvalue(kvalue)) : "?"; ------------------ | | 404| 13|#define getstr(ts) ((ts)->contents) ------------------ | Branch (429:11): [True: 13, False: 0] ------------------ 430| 13|} ldebug.c:gxf: 515| 16|static const char *gxf (const Proto *p, int pc, Instruction i, int isup) { 516| 16| int t = GETARG_B(i); /* table index */ ------------------ | | 128| 16|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ 517| 16| const char *name; /* name of indexed variable */ 518| 16| if (isup) /* is an upvalue? */ ------------------ | Branch (518:7): [True: 12, False: 4] ------------------ 519| 12| name = upvalname(p, t); 520| 4| else 521| 4| getobjname(p, pc, t, &name); 522| 16| return (name && strcmp(name, LUA_ENV) == 0) ? "global" : "field"; ------------------ | | 24| 16|#define LUA_ENV "_ENV" ------------------ | Branch (522:11): [True: 16, False: 0] | Branch (522:19): [True: 16, False: 0] ------------------ 523| 16|} 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| 58| const char **name) { 640| 58| if (ci->callstatus & CIST_HOOKED) { /* was it called inside a hook? */ ------------------ | | 213| 58|#define CIST_HOOKED (1<<3) /* call is running a debug hook */ ------------------ | Branch (640:7): [True: 0, False: 58] ------------------ 641| 0| *name = "?"; 642| 0| return "hook"; 643| 0| } 644| 58| else if (ci->callstatus & CIST_FIN) { /* was it called as a finalizer? */ ------------------ | | 217| 58|#define CIST_FIN (1<<7) /* function "called" a finalizer */ ------------------ | Branch (644:12): [True: 0, False: 58] ------------------ 645| 0| *name = "__gc"; 646| 0| return "metamethod"; /* report it as such */ 647| 0| } 648| 58| else if (isLua(ci)) ------------------ | | 241| 58|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 58|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 2, False: 56] | | ------------------ ------------------ 649| 2| return funcnamefromcode(L, ci_func(ci)->p, currentpc(ci), name); ------------------ | | 18| 2|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 2|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 2|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 650| 56| else 651| 56| return NULL; 652| 58|} ldebug.c:funcnamefromcode: 595| 2| int pc, const char **name) { 596| 2| TMS tm = (TMS)0; /* (initial value avoids warnings) */ 597| 2| Instruction i = p->code[pc]; /* calling instruction */ 598| 2| switch (GET_OPCODE(i)) { ------------------ | | 114| 2|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 2|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 599| 2| case OP_CALL: ------------------ | Branch (599:5): [True: 2, False: 0] ------------------ 600| 2| case OP_TAILCALL: ------------------ | Branch (600:5): [True: 0, False: 2] ------------------ 601| 2| return getobjname(p, pc, GETARG_A(i), name); /* get function name */ ------------------ | | 125| 2|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 2|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 2|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 2|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 602| 0| case OP_TFORCALL: { /* for iterator */ ------------------ | Branch (602:5): [True: 0, False: 2] ------------------ 603| 0| *name = "for iterator"; 604| 0| return "for iterator"; 605| 2| } 606| | /* other instructions can do calls through metamethods */ 607| 0| case OP_SELF: case OP_GETTABUP: case OP_GETTABLE: ------------------ | Branch (607:5): [True: 0, False: 2] | Branch (607:19): [True: 0, False: 2] | Branch (607:37): [True: 0, False: 2] ------------------ 608| 0| case OP_GETI: case OP_GETFIELD: ------------------ | Branch (608:5): [True: 0, False: 2] | Branch (608:19): [True: 0, False: 2] ------------------ 609| 0| tm = TM_INDEX; 610| 0| break; 611| 0| case OP_SETTABUP: case OP_SETTABLE: case OP_SETI: case OP_SETFIELD: ------------------ | Branch (611:5): [True: 0, False: 2] | Branch (611:23): [True: 0, False: 2] | Branch (611:41): [True: 0, False: 2] | Branch (611:55): [True: 0, False: 2] ------------------ 612| 0| tm = TM_NEWINDEX; 613| 0| break; 614| 0| case OP_MMBIN: case OP_MMBINI: case OP_MMBINK: { ------------------ | Branch (614:5): [True: 0, False: 2] | Branch (614:20): [True: 0, False: 2] | Branch (614:36): [True: 0, False: 2] ------------------ 615| 0| tm = cast(TMS, GETARG_C(i)); ------------------ | | 136| 0|#define cast(t, exp) ((t)(exp)) ------------------ 616| 0| break; 617| 0| } 618| 0| case OP_UNM: tm = TM_UNM; break; ------------------ | Branch (618:5): [True: 0, False: 2] ------------------ 619| 0| case OP_BNOT: tm = TM_BNOT; break; ------------------ | Branch (619:5): [True: 0, False: 2] ------------------ 620| 0| case OP_LEN: tm = TM_LEN; break; ------------------ | Branch (620:5): [True: 0, False: 2] ------------------ 621| 0| case OP_CONCAT: tm = TM_CONCAT; break; ------------------ | Branch (621:5): [True: 0, False: 2] ------------------ 622| 0| case OP_EQ: tm = TM_EQ; break; ------------------ | Branch (622:5): [True: 0, False: 2] ------------------ 623| | /* no cases for OP_EQI and OP_EQK, as they don't call metamethods */ 624| 0| case OP_LT: case OP_LTI: case OP_GTI: tm = TM_LT; break; ------------------ | Branch (624:5): [True: 0, False: 2] | Branch (624:17): [True: 0, False: 2] | Branch (624:30): [True: 0, False: 2] ------------------ 625| 0| case OP_LE: case OP_LEI: case OP_GEI: tm = TM_LE; break; ------------------ | Branch (625:5): [True: 0, False: 2] | Branch (625:17): [True: 0, False: 2] | Branch (625:30): [True: 0, False: 2] ------------------ 626| 0| case OP_CLOSE: case OP_RETURN: tm = TM_CLOSE; break; ------------------ | Branch (626:5): [True: 0, False: 2] | Branch (626:20): [True: 0, False: 2] ------------------ 627| 0| default: ------------------ | Branch (627:5): [True: 0, False: 2] ------------------ 628| 0| return NULL; /* cannot find a reasonable name */ 629| 2| } 630| 0| *name = getshrstr(G(L)->tmname[tm]) + 2; ------------------ | | 406| 0|#define getshrstr(ts) check_exp((ts)->shrlen != 0xFF, (ts)->contents) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 631| 0| return "metamethod"; 632| 2|} ldebug.c:formatvarinfo: 695| 51| const char *name) { 696| 51| if (kind == NULL) ------------------ | Branch (696:7): [True: 4, False: 47] ------------------ 697| 4| return ""; /* no information */ 698| 47| else 699| 47| return luaO_pushfstring(L, " (%s '%s')", kind, name); 700| 51|} ldebug.c:getcurrentline: 98| 112|static int getcurrentline (CallInfo *ci) { 99| 112| return luaG_getfuncline(ci_func(ci)->p, currentpc(ci)); ------------------ | | 18| 112|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 112|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 112|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 100| 112|} luaD_seterrorobj: 91| 382|void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) { 92| 382| switch (errcode) { 93| 0| case LUA_ERRMEM: { /* memory error? */ ------------------ | | 52| 0|#define LUA_ERRMEM 4 ------------------ | Branch (93:5): [True: 0, False: 382] ------------------ 94| 0| setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */ ------------------ | | 377| 0|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 0| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 0| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 0| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 95| 0| break; 96| 0| } 97| 0| case LUA_ERRERR: { ------------------ | | 53| 0|#define LUA_ERRERR 5 ------------------ | Branch (97:5): [True: 0, False: 382] ------------------ 98| 0| setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling")); ------------------ | | 377| 0|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 0| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 0| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 0| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 99| 0| break; 100| 0| } 101| 0| case LUA_OK: { /* special case only for closing upvalues */ ------------------ | | 48| 0|#define LUA_OK 0 ------------------ | Branch (101:5): [True: 0, False: 382] ------------------ 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| 382| default: { ------------------ | Branch (105:5): [True: 382, False: 0] ------------------ 106| 382| lua_assert(errorstatus(errcode)); /* real error */ ------------------ | | 114| 382|#define lua_assert(c) ((void)0) ------------------ 107| 382| setobjs2s(L, oldtop, L->top.p - 1); /* error message on current top */ ------------------ | | 129| 382|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 382| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 382| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 382|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 382| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 382| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 382|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 382| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 382|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 108| 382| break; 109| 0| } 110| 382| } 111| 382| L->top.p = oldtop + 1; 112| 382|} luaD_throw: 115| 382|l_noret luaD_throw (lua_State *L, int errcode) { 116| 382| if (L->errorJmp) { /* thread has an error handler? */ ------------------ | Branch (116:7): [True: 382, False: 0] ------------------ 117| 382| L->errorJmp->status = errcode; /* set status */ 118| 382| LUAI_THROW(L, L->errorJmp); /* jump to it */ ------------------ | | 73| 382|#define LUAI_THROW(L,c) longjmp((c)->b, 1) ------------------ 119| 382| } 120| 0| else { /* thread has no error handler */ 121| 0| global_State *g = G(L); ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ 122| 0| errcode = luaE_resetthread(L, errcode); /* close all upvalues */ 123| 0| if (g->mainthread->errorJmp) { /* main thread has a handler? */ ------------------ | Branch (123:9): [True: 0, False: 0] ------------------ 124| 0| setobjs2s(L, g->mainthread->top.p++, L->top.p - 1); /* copy error obj. */ ------------------ | | 129| 0|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 125| 0| luaD_throw(g->mainthread, errcode); /* re-throw in main thread */ 126| 0| } 127| 0| else { /* no handler at all; abort */ 128| 0| if (g->panic) { /* panic function? */ ------------------ | Branch (128:11): [True: 0, False: 0] ------------------ 129| 0| lua_unlock(L); ------------------ | | 265| 0|#define lua_unlock(L) ((void) 0) ------------------ 130| 0| g->panic(L); /* call panic function (last chance to jump out) */ 131| 0| } 132| 0| abort(); 133| 0| } 134| 0| } 135| 382|} luaD_rawrunprotected: 138| 1.63k|int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) { 139| 1.63k| l_uint32 oldnCcalls = L->nCcalls; 140| 1.63k| struct lua_longjmp lj; 141| 1.63k| lj.status = LUA_OK; ------------------ | | 48| 1.63k|#define LUA_OK 0 ------------------ 142| 1.63k| lj.previous = L->errorJmp; /* chain new error handler */ 143| 1.63k| L->errorJmp = &lj; 144| 1.63k| LUAI_TRY(L, &lj, ------------------ | | 74| 1.63k|#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a } | | ------------------ | | | Branch (74:30): [True: 1.63k, False: 0] | | ------------------ ------------------ 145| 1.63k| (*f)(L, ud); 146| 1.63k| ); 147| 1.63k| L->errorJmp = lj.previous; /* restore old error handler */ 148| 1.63k| L->nCcalls = oldnCcalls; 149| 1.63k| return lj.status; 150| 1.63k|} luaD_reallocstack: 212| 31|int luaD_reallocstack (lua_State *L, int newsize, int raiseerror) { 213| 31| int oldsize = stacksize(L); ------------------ | | 147| 31|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 31|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 31|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 214| 31| int i; 215| 31| StkId newstack; 216| 31| int oldgcstop = G(L)->gcstopem; ------------------ | | 335| 31|#define G(L) (L->l_G) ------------------ 217| 31| lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE); ------------------ | | 114| 31|#define lua_assert(c) ((void)0) ------------------ 218| 31| relstack(L); /* change pointers to offsets */ 219| 31| G(L)->gcstopem = 1; /* stop emergency collection */ ------------------ | | 335| 31|#define G(L) (L->l_G) ------------------ 220| 31| newstack = luaM_reallocvector(L, L->stack.p, oldsize + EXTRA_STACK, ------------------ | | 71| 31| (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \ | | ------------------ | | | | 136| 31|#define cast(t, exp) ((t)(exp)) | | ------------------ | | 72| 31| cast_sizet(n) * sizeof(t)))) ------------------ 221| 31| newsize + EXTRA_STACK, StackValue); 222| 31| G(L)->gcstopem = oldgcstop; /* restore emergency collection */ ------------------ | | 335| 31|#define G(L) (L->l_G) ------------------ 223| 31| if (l_unlikely(newstack == NULL)) { /* reallocation failed? */ ------------------ | | 697| 31|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 31|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 31] | | | | ------------------ | | ------------------ ------------------ 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| 31| L->stack.p = newstack; 230| 31| correctstack(L); /* change offsets back to pointers */ 231| 31| L->stack_last.p = L->stack.p + newsize; 232| 1.18k| for (i = oldsize + EXTRA_STACK; i < newsize + EXTRA_STACK; i++) ------------------ | | 142| 31|#define EXTRA_STACK 5 ------------------ for (i = oldsize + EXTRA_STACK; i < newsize + EXTRA_STACK; i++) ------------------ | | 142| 1.18k|#define EXTRA_STACK 5 ------------------ | Branch (232:35): [True: 1.15k, False: 31] ------------------ 233| 1.15k| setnilvalue(s2v(newstack + i)); /* erase new segment */ ------------------ | | 200| 1.15k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 1.18k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 234| 31| return 1; 235| 31|} luaD_growstack: 242| 20|int luaD_growstack (lua_State *L, int n, int raiseerror) { 243| 20| int size = stacksize(L); ------------------ | | 147| 20|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 20|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 20|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 244| 20| if (l_unlikely(size > LUAI_MAXSTACK)) { ------------------ | | 697| 20|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 20|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 20] | | | | ------------------ | | ------------------ ------------------ 245| | /* if stack is larger than maximum, thread is already using the 246| | extra space reserved for errors, that is, thread is handling 247| | a stack error; cannot grow further than that. */ 248| 0| lua_assert(stacksize(L) == ERRORSTACKSIZE); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 249| 0| if (raiseerror) ------------------ | Branch (249:9): [True: 0, False: 0] ------------------ 250| 0| luaD_throw(L, LUA_ERRERR); /* error inside message handler */ ------------------ | | 53| 0|#define LUA_ERRERR 5 ------------------ 251| 0| return 0; /* if not 'raiseerror', just signal it */ 252| 0| } 253| 20| else if (n < LUAI_MAXSTACK) { /* avoids arithmetic overflows */ ------------------ | | 749| 20|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (253:12): [True: 20, False: 0] ------------------ 254| 20| int newsize = 2 * size; /* tentative new size */ 255| 20| int needed = cast_int(L->top.p - L->stack.p) + n; ------------------ | | 141| 20|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 20|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 256| 20| if (newsize > LUAI_MAXSTACK) /* cannot cross the limit */ ------------------ | | 749| 20|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (256:9): [True: 0, False: 20] ------------------ 257| 0| newsize = LUAI_MAXSTACK; ------------------ | | 749| 0|#define LUAI_MAXSTACK 1000000 ------------------ 258| 20| if (newsize < needed) /* but must respect what was asked for */ ------------------ | Branch (258:9): [True: 2, False: 18] ------------------ 259| 2| newsize = needed; 260| 20| if (l_likely(newsize <= LUAI_MAXSTACK)) ------------------ | | 696| 20|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 684| 20|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (684:25): [True: 20, False: 0] | | | | ------------------ | | ------------------ ------------------ 261| 20| return luaD_reallocstack(L, newsize, raiseerror); 262| 20| } 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| 2.07k|void luaD_shrinkstack (lua_State *L) { 301| 2.07k| int inuse = stackinuse(L); 302| 2.07k| int max = (inuse > LUAI_MAXSTACK / 3) ? LUAI_MAXSTACK : inuse * 3; ------------------ | | 749| 2.07k|#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: 2.07k] ------------------ 303| | /* if thread is currently not handling a stack overflow and its 304| | size is larger than maximum "reasonable" size, shrink it */ 305| 2.07k| if (inuse <= LUAI_MAXSTACK && stacksize(L) > max) { ------------------ | | 749| 4.15k|#define LUAI_MAXSTACK 1000000 ------------------ if (inuse <= LUAI_MAXSTACK && stacksize(L) > max) { ------------------ | | 147| 2.07k|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 2.07k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 2.07k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (305:7): [True: 2.07k, False: 0] | Branch (305:33): [True: 11, False: 2.06k] ------------------ 306| 11| int nsize = (inuse > LUAI_MAXSTACK / 2) ? LUAI_MAXSTACK : inuse * 2; ------------------ | | 749| 11|#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: 11] ------------------ 307| 11| luaD_reallocstack(L, nsize, 0); /* ok if that fails */ 308| 11| } 309| 2.06k| else /* don't change stack */ 310| 2.06k| condmovestack(L,{},{}); /* (change only for debugging) */ ------------------ | | 366| 2.06k|#define condmovestack(L,pre,pos) ((void)0) ------------------ 311| 2.07k| luaE_shrinkCI(L); /* shrink CI list */ 312| 2.07k|} luaD_inctop: 315| 780|void luaD_inctop (lua_State *L) { 316| 780| luaD_checkstack(L, 1); ------------------ | | 32| 780|#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0) | | ------------------ | | | | 27| 780| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 780|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 780|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 780] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 780| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 780| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 780|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 317| 780| L->top.p++; 318| 780|} luaD_hookcall: 369| 2|void luaD_hookcall (lua_State *L, CallInfo *ci) { 370| 2| L->oldpc = 0; /* set 'oldpc' for new function */ 371| 2| if (L->hookmask & LUA_MASKCALL) { /* is call hook on? */ ------------------ | | 450| 2|#define LUA_MASKCALL (1 << LUA_HOOKCALL) | | ------------------ | | | | 440| 2|#define LUA_HOOKCALL 0 | | ------------------ ------------------ | Branch (371:7): [True: 0, False: 2] ------------------ 372| 0| int event = (ci->callstatus & CIST_TAIL) ? LUA_HOOKTAILCALL ------------------ | | 215| 0|#define CIST_TAIL (1<<5) /* call was tail called */ ------------------ int event = (ci->callstatus & CIST_TAIL) ? LUA_HOOKTAILCALL ------------------ | | 444| 0|#define LUA_HOOKTAILCALL 4 ------------------ | Branch (372:17): [True: 0, False: 0] ------------------ 373| 0| : LUA_HOOKCALL; ------------------ | | 440| 0|#define LUA_HOOKCALL 0 ------------------ 374| 0| Proto *p = ci_func(ci)->p; ------------------ | | 18| 0|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 0|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 375| 0| ci->u.l.savedpc++; /* hooks assume 'pc' is already incremented */ 376| 0| luaD_hook(L, event, -1, 1, p->numparams); 377| 0| ci->u.l.savedpc--; /* correct 'pc' */ 378| 0| } 379| 2|} luaD_poscall: 485| 8.10k|void luaD_poscall (lua_State *L, CallInfo *ci, int nres) { 486| 8.10k| int wanted = ci->nresults; 487| 8.10k| if (l_unlikely(L->hookmask && !hastocloseCfunc(wanted))) ------------------ | | 697| 8.10k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 8.10k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 8.10k] | | | | | Branch (685:46): [True: 0, False: 8.10k] | | | | | Branch (685:46): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 488| 0| rethook(L, ci, nres); 489| | /* move results to proper place */ 490| 8.10k| moveresults(L, ci->func.p, nres, wanted); 491| | /* function cannot be in any of these cases when returning */ 492| 8.10k| lua_assert(!(ci->callstatus & ------------------ | | 114| 8.10k|#define lua_assert(c) ((void)0) ------------------ 493| 8.10k| (CIST_HOOKED | CIST_YPCALL | CIST_FIN | CIST_TRAN | CIST_CLSRET))); 494| 8.10k| L->ci = ci->previous; /* back to caller (after closing variables) */ 495| 8.10k|} luaD_precall: 588| 83.8k|CallInfo *luaD_precall (lua_State *L, StkId func, int nresults) { 589| 83.8k| retry: 590| 83.8k| switch (ttypetag(s2v(func))) { ------------------ | | 84| 83.8k|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 83.8k|#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: 83.8k] ------------------ 592| 0| precallC(L, func, nresults, clCvalue(s2v(func))->f); ------------------ | | 604| 0|#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 593| 0| return NULL; 594| 88| case LUA_VLCF: /* light C function */ ------------------ | | 589| 88|#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */ | | ------------------ | | | | 42| 88|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (594:5): [True: 88, False: 83.7k] ------------------ 595| 88| precallC(L, func, nresults, fvalue(s2v(func))); ------------------ | | 603| 88|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 115| 88|#define check_exp(c,e) (e) | | ------------------ ------------------ 596| 88| return NULL; 597| 83.7k| case LUA_VLCL: { /* Lua function */ ------------------ | | 588| 83.7k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 83.7k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (597:5): [True: 83.7k, False: 90] ------------------ 598| 83.7k| CallInfo *ci; 599| 83.7k| Proto *p = clLvalue(s2v(func))->p; ------------------ | | 602| 83.7k|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | ------------------ | | | | 115| 83.7k|#define check_exp(c,e) (e) | | ------------------ ------------------ 600| 83.7k| int narg = cast_int(L->top.p - func) - 1; /* number of real arguments */ ------------------ | | 141| 83.7k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 83.7k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 601| 83.7k| int nfixparams = p->numparams; 602| 83.7k| int fsize = p->maxstacksize; /* frame size */ 603| 83.7k| checkstackGCp(L, fsize, func); ------------------ | | 49| 83.7k| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 83.7k| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 83.7k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 83.7k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 12, False: 83.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 83.7k| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | ------------------ | | | | | Branch (28:6): [True: 0, False: 12] | | | | ------------------ | | | | 29| 83.7k| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 83.6k|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 50| 83.7k| ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ | | 51| 83.7k| luaC_checkGC(L), /* stack grow uses memory */ \ | | 52| 83.7k| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 604| 83.7k| L->ci = ci = prepCallInfo(L, func, nresults, 0, func + 1 + fsize); 605| 83.7k| ci->u.l.savedpc = p->code; /* starting point */ 606| 459k| for (; narg < nfixparams; narg++) ------------------ | Branch (606:14): [True: 375k, False: 83.7k] ------------------ 607| 375k| setnilvalue(s2v(L->top.p++)); /* complete missing arguments */ ------------------ | | 200| 375k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 459k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 608| 83.7k| lua_assert(ci->top.p <= L->stack_last.p); ------------------ | | 114| 83.7k|#define lua_assert(c) ((void)0) ------------------ 609| 83.7k| return ci; 610| 0| } 611| 2| default: { /* not a function */ ------------------ | Branch (611:5): [True: 2, False: 83.7k] ------------------ 612| 2| func = tryfuncTM(L, func); /* try to get '__call' metamethod */ 613| | /* return luaD_precall(L, func, nresults); */ 614| 2| goto retry; /* try again with metamethod */ 615| 0| } 616| 83.8k| } 617| 83.8k|} luaD_callnoyield: 654| 152|void luaD_callnoyield (lua_State *L, StkId func, int nResults) { 655| 152| ccall(L, func, nResults, nyci); ------------------ | | 117| 152|#define nyci (0x10000 | 1) ------------------ 656| 152|} luaD_closeprotected: 924| 772|int luaD_closeprotected (lua_State *L, ptrdiff_t level, int status) { 925| 772| CallInfo *old_ci = L->ci; 926| 772| lu_byte old_allowhooks = L->allowhook; 927| 772| for (;;) { /* keep closing upvalues until no more errors */ 928| 772| struct CloseP pcl; 929| 772| pcl.level = restorestack(L, level); pcl.status = status; ------------------ | | 37| 772|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 772|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 930| 772| status = luaD_rawrunprotected(L, &closepaux, &pcl); 931| 772| if (l_likely(status == LUA_OK)) /* no more errors? */ ------------------ | | 696| 772|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 684| 772|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (684:25): [True: 772, False: 0] | | | | ------------------ | | ------------------ ------------------ 932| 772| 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| 772| } 938| 772|} luaD_pcall: 947| 470| ptrdiff_t old_top, ptrdiff_t ef) { 948| 470| int status; 949| 470| CallInfo *old_ci = L->ci; 950| 470| lu_byte old_allowhooks = L->allowhook; 951| 470| ptrdiff_t old_errfunc = L->errfunc; 952| 470| L->errfunc = ef; 953| 470| status = luaD_rawrunprotected(L, func, u); 954| 470| if (l_unlikely(status != LUA_OK)) { /* an error occurred? */ ------------------ | | 697| 470|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 470|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 382, False: 88] | | | | ------------------ | | ------------------ ------------------ 955| 382| L->ci = old_ci; 956| 382| L->allowhook = old_allowhooks; 957| 382| status = luaD_closeprotected(L, old_top, status); 958| 382| luaD_seterrorobj(L, status, restorestack(L, old_top)); ------------------ | | 37| 382|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 382|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 959| 382| luaD_shrinkstack(L); /* restore stack size in case of overflow */ 960| 382| } 961| 470| L->errfunc = old_errfunc; 962| 470| return status; 963| 470|} luaD_protectedparser: 1006| 390| const char *mode) { 1007| 390| struct SParser p; 1008| 390| int status; 1009| 390| incnny(L); /* cannot yield during parsing */ ------------------ | | 111| 390|#define incnny(L) ((L)->nCcalls += 0x10000) ------------------ 1010| 390| p.z = z; p.name = name; p.mode = mode; 1011| 390| p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0; 1012| 390| p.dyd.gt.arr = NULL; p.dyd.gt.size = 0; 1013| 390| p.dyd.label.arr = NULL; p.dyd.label.size = 0; 1014| 390| luaZ_initbuffer(L, &p.buff); ------------------ | | 29| 390|#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0) ------------------ 1015| 390| status = luaD_pcall(L, f_parser, &p, savestack(L, L->top.p), L->errfunc); ------------------ | | 36| 390|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 390|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 390|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1016| 390| luaZ_freebuffer(L, &p.buff); ------------------ | | 44| 390|#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) | | ------------------ | | | | 40| 390| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | | | ------------------ | | | | | | 53| 390| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | | | ------------------ | | | | | | | | 146| 390|#define cast_charp(i) cast(char *, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 41| 390| (buff)->buffsize, size), \ | | | | 42| 390| (buff)->buffsize = size) | | ------------------ ------------------ 1017| 390| luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size); ------------------ | | 57| 390|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1018| 390| luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size); ------------------ | | 57| 390|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1019| 390| luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size); ------------------ | | 57| 390|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1020| 390| decnny(L); ------------------ | | 114| 390|#define decnny(L) ((L)->nCcalls -= 0x10000) ------------------ 1021| 390| return status; 1022| 390|} ldo.c:relstack: 165| 31|static void relstack (lua_State *L) { 166| 31| CallInfo *ci; 167| 31| UpVal *up; 168| 31| L->top.offset = savestack(L, L->top.p); ------------------ | | 36| 31|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 31|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 31|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 31|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 31|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 169| 31| L->tbclist.offset = savestack(L, L->tbclist.p); ------------------ | | 36| 31|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 31|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 31|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 31|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 31|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 170| 37| for (up = L->openupval; up != NULL; up = up->u.open.next) ------------------ | Branch (170:27): [True: 6, False: 31] ------------------ 171| 6| up->v.offset = savestack(L, uplevel(up)); ------------------ | | 36| 6|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 6|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 6|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 172| 82| for (ci = L->ci; ci != NULL; ci = ci->previous) { ------------------ | Branch (172:20): [True: 51, False: 31] ------------------ 173| 51| ci->top.offset = savestack(L, ci->top.p); ------------------ | | 36| 51|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 51|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 51|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 51|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 51|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 174| 51| ci->func.offset = savestack(L, ci->func.p); ------------------ | | 36| 51|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 51|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 51|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 51|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 51|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 175| 51| } 176| 31|} ldo.c:correctstack: 182| 31|static void correctstack (lua_State *L) { 183| 31| CallInfo *ci; 184| 31| UpVal *up; 185| 31| L->top.p = restorestack(L, L->top.offset); ------------------ | | 37| 31|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 31|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 186| 31| L->tbclist.p = restorestack(L, L->tbclist.offset); ------------------ | | 37| 31|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 31|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 187| 37| for (up = L->openupval; up != NULL; up = up->u.open.next) ------------------ | Branch (187:27): [True: 6, False: 31] ------------------ 188| 6| up->v.p = s2v(restorestack(L, up->v.offset)); ------------------ | | 172| 6|#define s2v(o) (&(o)->val) ------------------ 189| 82| for (ci = L->ci; ci != NULL; ci = ci->previous) { ------------------ | Branch (189:20): [True: 51, False: 31] ------------------ 190| 51| ci->top.p = restorestack(L, ci->top.offset); ------------------ | | 37| 51|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 51|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 191| 51| ci->func.p = restorestack(L, ci->func.offset); ------------------ | | 37| 51|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 51|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 192| 51| if (isLua(ci)) ------------------ | | 241| 51|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 51|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 20, False: 31] | | ------------------ ------------------ 193| 20| ci->u.l.trap = 1; /* signal to update 'trap' in 'luaV_execute' */ 194| 51| } 195| 31|} ldo.c:stackinuse: 276| 2.07k|static int stackinuse (lua_State *L) { 277| 2.07k| CallInfo *ci; 278| 2.07k| int res; 279| 2.07k| StkId lim = L->top.p; 280| 4.37k| for (ci = L->ci; ci != NULL; ci = ci->previous) { ------------------ | Branch (280:20): [True: 2.30k, False: 2.07k] ------------------ 281| 2.30k| if (lim < ci->top.p) lim = ci->top.p; ------------------ | Branch (281:9): [True: 2.10k, False: 199] ------------------ 282| 2.30k| } 283| 2.07k| lua_assert(lim <= L->stack_last.p + EXTRA_STACK); ------------------ | | 114| 2.07k|#define lua_assert(c) ((void)0) ------------------ 284| 2.07k| res = cast_int(lim - L->stack.p) + 1; /* part of stack in use */ ------------------ | | 141| 2.07k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 2.07k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 285| 2.07k| if (res < LUA_MINSTACK) ------------------ | | 79| 2.07k|#define LUA_MINSTACK 20 ------------------ | Branch (285:7): [True: 0, False: 2.07k] ------------------ 286| 0| res = LUA_MINSTACK; /* ensure a minimum size */ ------------------ | | 79| 0|#define LUA_MINSTACK 20 ------------------ 287| 2.07k| return res; 288| 2.07k|} ldo.c:moveresults: 433| 8.10k|l_sinline void moveresults (lua_State *L, StkId res, int nres, int wanted) { 434| 8.10k| StkId firstresult; 435| 8.10k| int i; 436| 8.10k| switch (wanted) { /* handle typical cases separately */ 437| 8.04k| case 0: /* no values needed */ ------------------ | Branch (437:5): [True: 8.04k, False: 56] ------------------ 438| 8.04k| L->top.p = res; 439| 8.04k| return; 440| 40| case 1: /* one value needed */ ------------------ | Branch (440:5): [True: 40, False: 8.06k] ------------------ 441| 40| if (nres == 0) /* no results? */ ------------------ | Branch (441:11): [True: 0, False: 40] ------------------ 442| 40| 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| 40| else /* at least one result */ 444| 40| setobjs2s(L, res, L->top.p - nres); /* move it to proper place */ ------------------ | | 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) || \ | | | | | | ------------------ | | | | | | | | 116| 40|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 40| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 40|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 445| 40| L->top.p = res + 1; 446| 40| return; 447| 0| case LUA_MULTRET: ------------------ | | 35| 0|#define LUA_MULTRET (-1) ------------------ | Branch (447:5): [True: 0, False: 8.10k] ------------------ 448| 0| wanted = nres; /* we want all results */ 449| 0| break; 450| 16| default: /* two/more results and/or to-be-closed variables */ ------------------ | Branch (450:5): [True: 16, False: 8.08k] ------------------ 451| 16| if (hastocloseCfunc(wanted)) { /* to-be-closed variables? */ ------------------ | | 46| 16|#define hastocloseCfunc(n) ((n) < LUA_MULTRET) | | ------------------ | | | | 35| 16|#define LUA_MULTRET (-1) | | ------------------ | | | Branch (46:28): [True: 16, False: 0] | | ------------------ ------------------ 452| 16| L->ci->callstatus |= CIST_CLSRET; /* in case of yields */ ------------------ | | 219| 16|#define CIST_CLSRET (1<<9) /* function is closing tbc variables */ ------------------ 453| 16| L->ci->u2.nres = nres; 454| 16| res = luaF_close(L, res, CLOSEKTOP, 1); ------------------ | | 47| 16|#define CLOSEKTOP (-1) ------------------ 455| 16| L->ci->callstatus &= ~CIST_CLSRET; ------------------ | | 219| 16|#define CIST_CLSRET (1<<9) /* function is closing tbc variables */ ------------------ 456| 16| if (L->hookmask) { /* if needed, call hook after '__close's */ ------------------ | Branch (456:13): [True: 0, False: 16] ------------------ 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| 16| wanted = decodeNresults(wanted); ------------------ | | 50| 16|#define decodeNresults(n) (-(n) - 3) ------------------ 462| 16| if (wanted == LUA_MULTRET) ------------------ | | 35| 16|#define LUA_MULTRET (-1) ------------------ | Branch (462:13): [True: 0, False: 16] ------------------ 463| 0| wanted = nres; /* we want all results */ 464| 16| } 465| 16| break; 466| 8.10k| } 467| | /* generic case */ 468| 16| firstresult = L->top.p - nres; /* index of first result */ 469| 16| if (nres > wanted) /* extra results? */ ------------------ | Branch (469:7): [True: 0, False: 16] ------------------ 470| 0| nres = wanted; /* don't need them */ 471| 32| for (i = 0; i < nres; i++) /* move all results to correct place */ ------------------ | Branch (471:15): [True: 16, False: 16] ------------------ 472| 16| setobjs2s(L, res + i, firstresult + i); ------------------ | | 129| 16|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 32| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 32| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 32| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 16| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 16|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 16| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 16|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 473| 16| for (; i < wanted; i++) /* complete wanted number of results */ ------------------ | Branch (473:10): [True: 0, False: 16] ------------------ 474| 16| setnilvalue(s2v(res + i)); ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 475| 16| L->top.p = res + wanted; /* top points after the last result */ 476| 16|} ldo.c:precallC: 517| 88| lua_CFunction f) { 518| 88| int n; /* number of returns */ 519| 88| CallInfo *ci; 520| 88| checkstackGCp(L, LUA_MINSTACK, func); /* ensure minimum stack size */ ------------------ | | 49| 88| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 88| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 88|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 88|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 6, False: 82] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 88| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | ------------------ | | | | | Branch (28:6): [True: 1, False: 5] | | | | ------------------ | | | | 29| 88| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 82|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 50| 88| ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ | | 51| 88| luaC_checkGC(L), /* stack grow uses memory */ \ | | 52| 88| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 521| 88| L->ci = ci = prepCallInfo(L, func, nresults, CIST_C, ------------------ | | 211| 88|#define CIST_C (1<<1) /* call is running a C function */ ------------------ 522| 88| L->top.p + LUA_MINSTACK); ------------------ | | 79| 88|#define LUA_MINSTACK 20 ------------------ 523| 88| lua_assert(ci->top.p <= L->stack_last.p); ------------------ | | 114| 88|#define lua_assert(c) ((void)0) ------------------ 524| 88| if (l_unlikely(L->hookmask & LUA_MASKCALL)) { ------------------ | | 697| 88|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 88|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 88] | | | | ------------------ | | ------------------ ------------------ 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| 88| lua_unlock(L); ------------------ | | 265| 88|#define lua_unlock(L) ((void) 0) ------------------ 529| 88| n = (*f)(L); /* do the actual call */ 530| 88| lua_lock(L); ------------------ | | 264| 88|#define lua_lock(L) ((void) 0) ------------------ 531| 88| api_checknelems(L, n); ------------------ | | 33| 88| api_check(L, (n) < (L->top.p - L->ci->func.p), \ | | ------------------ | | | | 126| 88|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 88|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 34| 88| "not enough elements in the stack") ------------------ 532| 88| luaD_poscall(L, ci, n); 533| 88| return n; 534| 88|} ldo.c:tryfuncTM: 412| 2|static StkId tryfuncTM (lua_State *L, StkId func) { 413| 2| const TValue *tm; 414| 2| StkId p; 415| 2| checkstackGCp(L, 1, func); /* space for metamethod */ ------------------ | | 49| 2| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 2| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 2|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 2|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 2| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | ------------------ | | | | | Branch (28:6): [True: 0, False: 0] | | | | ------------------ | | | | 29| 2| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 2|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 50| 2| ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ | | 51| 2| luaC_checkGC(L), /* stack grow uses memory */ \ | | 52| 2| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 416| 2| tm = luaT_gettmbyobj(L, s2v(func), TM_CALL); /* (after previous GC) */ ------------------ | | 172| 2|#define s2v(o) (&(o)->val) ------------------ 417| 2| if (l_unlikely(ttisnil(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] | | | | ------------------ | | ------------------ ------------------ 418| 2| luaG_callerror(L, s2v(func)); /* nothing to call */ ------------------ | | 172| 2|#define s2v(o) (&(o)->val) ------------------ 419| 0| for (p = L->top.p; p > func; p--) /* open space for metamethod */ ------------------ | Branch (419:22): [True: 0, False: 0] ------------------ 420| 0| setobjs2s(L, p, p-1); ------------------ | | 129| 0|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 421| 0| L->top.p++; /* stack space pre-allocated by the caller */ 422| 0| setobj2s(L, func, tm); /* metamethod is the new function to be called */ ------------------ | | 131| 0|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 423| 0| return func; 424| 2|} ldo.c:prepCallInfo: 503| 83.7k| int mask, StkId top) { 504| 83.7k| CallInfo *ci = L->ci = next_ci(L); /* new frame */ ------------------ | | 499| 83.7k|#define next_ci(L) (L->ci->next ? L->ci->next : luaE_extendCI(L)) | | ------------------ | | | Branch (499:22): [True: 83.6k, False: 143] | | ------------------ ------------------ 505| 83.7k| ci->func.p = func; 506| 83.7k| ci->nresults = nret; 507| 83.7k| ci->callstatus = mask; 508| 83.7k| ci->top.p = top; 509| 83.7k| return ci; 510| 83.7k|} ldo.c:ccall: 628| 152|l_sinline void ccall (lua_State *L, StkId func, int nResults, l_uint32 inc) { 629| 152| CallInfo *ci; 630| 152| L->nCcalls += inc; 631| 152| if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) { ------------------ | | 697| 152|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 152|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 152] | | | | ------------------ | | ------------------ ------------------ 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| 152| if ((ci = luaD_precall(L, func, nResults)) != NULL) { /* Lua function? */ ------------------ | Branch (635:7): [True: 64, False: 88] ------------------ 636| 64| ci->callstatus = CIST_FRESH; /* mark that it is a "fresh" execute */ ------------------ | | 212| 64|#define CIST_FRESH (1<<2) /* call is on a fresh "luaV_execute" frame */ ------------------ 637| 64| luaV_execute(L, ci); /* call it */ 638| 64| } 639| 152| L->nCcalls -= inc; 640| 152|} ldo.c:closepaux: 914| 772|static void closepaux (lua_State *L, void *ud) { 915| 772| struct CloseP *pcl = cast(struct CloseP *, ud); ------------------ | | 136| 772|#define cast(t, exp) ((t)(exp)) ------------------ 916| 772| luaF_close(L, pcl->level, pcl->status, 0); 917| 772|} ldo.c:f_parser: 988| 390|static void f_parser (lua_State *L, void *ud) { 989| 390| LClosure *cl; 990| 390| struct SParser *p = cast(struct SParser *, ud); ------------------ | | 136| 390|#define cast(t, exp) ((t)(exp)) ------------------ 991| 390| int c = zgetc(p->z); /* read first character */ ------------------ | | 20| 390|#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: 390] | | ------------------ ------------------ 992| 390| if (c == LUA_SIGNATURE[0]) { ------------------ | | 32| 390|#define LUA_SIGNATURE "\x1bLua" ------------------ | Branch (992:7): [True: 0, False: 390] ------------------ 993| 0| checkmode(L, p->mode, "binary"); 994| 0| cl = luaU_undump(L, p->z, p->name); 995| 0| } 996| 390| else { 997| 390| checkmode(L, p->mode, "text"); 998| 390| cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c); 999| 390| } 1000| 390| lua_assert(cl->nupvalues == cl->p->sizeupvalues); ------------------ | | 114| 390|#define lua_assert(c) ((void)0) ------------------ 1001| 390| luaF_initupvals(L, cl); 1002| 390|} ldo.c:checkmode: 979| 390|static void checkmode (lua_State *L, const char *mode, const char *x) { 980| 390| if (mode && strchr(mode, x[0]) == NULL) { ------------------ | Branch (980:7): [True: 390, False: 0] | Branch (980:15): [True: 0, False: 390] ------------------ 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| 390|} luaF_newLclosure: 35| 490k|LClosure *luaF_newLclosure (lua_State *L, int nupvals) { 36| 490k| GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals)); ------------------ | | 588| 490k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 490k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals)); ------------------ | | 17| 490k|#define sizeLclosure(n) (cast_int(offsetof(LClosure, upvals)) + \ | | ------------------ | | | | 141| 490k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 490k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 18| 490k| cast_int(sizeof(TValue *)) * (n)) | | ------------------ | | | | 141| 490k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 490k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 37| 490k| LClosure *c = gco2lcl(o); ------------------ | | 376| 490k|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 115| 490k|#define check_exp(c,e) (e) | | ------------------ ------------------ 38| 490k| c->p = NULL; 39| 490k| c->nupvalues = cast_byte(nupvals); ------------------ | | 143| 490k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 490k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 40| 577k| while (nupvals--) c->upvals[nupvals] = NULL; ------------------ | Branch (40:10): [True: 86.9k, False: 490k] ------------------ 41| 490k| return c; 42| 490k|} luaF_initupvals: 48| 64|void luaF_initupvals (lua_State *L, LClosure *cl) { 49| 64| int i; 50| 128| for (i = 0; i < cl->nupvalues; i++) { ------------------ | Branch (50:15): [True: 64, False: 64] ------------------ 51| 64| GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal)); ------------------ | | 584| 64|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 64|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 52| 64| UpVal *uv = gco2upv(o); ------------------ | | 383| 64|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 115| 64|#define check_exp(c,e) (e) | | ------------------ ------------------ 53| 64| uv->v.p = &uv->u.value; /* make it closed */ 54| 64| setnilvalue(uv->v.p); ------------------ | | 200| 64|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 64|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 55| 64| cl->upvals[i] = uv; 56| 64| luaC_objbarrier(L, cl, uv); ------------------ | | 175| 64|#define luaC_objbarrier(L,p,o) ( \ | | 176| 64| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 64|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 64|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 128|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 64] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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| 64| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 64|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 64|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 57| 64| } 58| 64|} luaF_findupval: 87| 3.14k|UpVal *luaF_findupval (lua_State *L, StkId level) { 88| 3.14k| UpVal **pp = &L->openupval; 89| 3.14k| UpVal *p; 90| 3.14k| lua_assert(isintwups(L) || L->openupval == NULL); ------------------ | | 114| 3.14k|#define lua_assert(c) ((void)0) ------------------ 91| 3.42k| while ((p = *pp) != NULL && uplevel(p) >= level) { /* search for it */ ------------------ | | 35| 278|#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p)) | | ------------------ | | | | 115| 278|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (91:10): [True: 278, False: 3.14k] | Branch (91:31): [True: 278, False: 0] ------------------ 92| 278| lua_assert(!isdead(G(L), p)); ------------------ | | 114| 278|#define lua_assert(c) ((void)0) ------------------ 93| 278| if (uplevel(p) == level) /* corresponding upvalue? */ ------------------ | | 35| 278|#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p)) | | ------------------ | | | | 115| 278|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (93:9): [True: 0, False: 278] ------------------ 94| 0| return p; /* return it */ 95| 278| pp = &p->u.open.next; 96| 278| } 97| | /* not found: create a new upvalue after 'pp' */ 98| 3.14k| return newupval(L, level, pp); 99| 3.14k|} luaF_newtbcupval: 168| 16|void luaF_newtbcupval (lua_State *L, StkId level) { 169| 16| lua_assert(level > L->tbclist.p); ------------------ | | 114| 16|#define lua_assert(c) ((void)0) ------------------ 170| 16| if (l_isfalse(s2v(level))) ------------------ | | 247| 16|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 16|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 32|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 16|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 16] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 193| 16|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 16|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 16|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 16|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 16] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 171| 0| return; /* false doesn't need to be closed */ 172| 16| checkclosemth(L, level); /* value must have a close method */ 173| 16| while (cast_uint(level - L->tbclist.p) > MAXDELTA) { ------------------ | | 142| 16|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 16|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ while (cast_uint(level - L->tbclist.p) > MAXDELTA) { ------------------ | | 162| 16| ((256ul << ((sizeof(L->stack.p->tbclist.delta) - 1) * 8)) - 1) ------------------ | Branch (173:10): [True: 0, False: 16] ------------------ 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| 16| level->tbclist.delta = cast(unsigned short, level - L->tbclist.p); ------------------ | | 136| 16|#define cast(t, exp) ((t)(exp)) ------------------ 178| 16| L->tbclist.p = level; 179| 16|} luaF_unlinkupval: 182| 3.14k|void luaF_unlinkupval (UpVal *uv) { 183| 3.14k| lua_assert(upisopen(uv)); ------------------ | | 114| 3.14k|#define lua_assert(c) ((void)0) ------------------ 184| 3.14k| *uv->u.open.previous = uv->u.open.next; 185| 3.14k| if (uv->u.open.next) ------------------ | Branch (185:7): [True: 278, False: 2.86k] ------------------ 186| 278| uv->u.open.next->u.open.previous = uv->u.open.previous; 187| 3.14k|} luaF_closeupval: 193| 3.95k|void luaF_closeupval (lua_State *L, StkId level) { 194| 3.95k| UpVal *uv; 195| 3.95k| StkId upl; /* stack index pointed by 'uv' */ 196| 7.09k| while ((uv = L->openupval) != NULL && (upl = uplevel(uv)) >= level) { ------------------ | | 35| 3.42k|#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p)) | | ------------------ | | | | 115| 3.42k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (196:10): [True: 3.42k, False: 3.67k] | Branch (196:41): [True: 3.14k, False: 278] ------------------ 197| 3.14k| TValue *slot = &uv->u.value; /* new position for value */ 198| 3.14k| lua_assert(uplevel(uv) < L->top.p); ------------------ | | 114| 3.14k|#define lua_assert(c) ((void)0) ------------------ 199| 3.14k| luaF_unlinkupval(uv); /* remove upvalue from 'openupval' list */ 200| 3.14k| setobj(L, slot, uv->v.p); /* move value to upvalue slot */ ------------------ | | 119| 3.14k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 3.14k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 3.14k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 3.14k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 3.14k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 3.14k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 3.14k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 3.14k|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 201| 3.14k| uv->v.p = slot; /* now current value lives here */ 202| 3.14k| if (!iswhite(uv)) { /* neither white nor dead? */ ------------------ | | 87| 3.14k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 3.14k|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (202:9): [True: 0, False: 3.14k] ------------------ 203| 0| nw2black(uv); /* closed upvalues cannot be gray */ ------------------ | | 100| 0| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 204| 0| luaC_barrier(L, uv, slot); ------------------ | | 179| 0|#define luaC_barrier(L,p,v) ( \ | | 180| 0| iscollectable(v) ? luaC_objbarrier(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_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 0|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 0| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 177| 0| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 205| 0| } 206| 3.14k| } 207| 3.95k|} luaF_close: 227| 3.95k|StkId luaF_close (lua_State *L, StkId level, int status, int yy) { 228| 3.95k| ptrdiff_t levelrel = savestack(L, level); ------------------ | | 36| 3.95k|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 3.95k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 3.95k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 3.95k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 3.95k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 229| 3.95k| luaF_closeupval(L, level); /* first, close the upvalues */ 230| 3.96k| while (L->tbclist.p >= level) { /* traverse tbc's down to that level */ ------------------ | Branch (230:10): [True: 16, False: 3.95k] ------------------ 231| 16| StkId tbc = L->tbclist.p; /* get variable index */ 232| 16| poptbclist(L); /* remove it from list */ 233| 16| prepcallclosemth(L, tbc, status, yy); /* close variable */ 234| 16| level = restorestack(L, levelrel); ------------------ | | 37| 16|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 16|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 235| 16| } 236| 3.95k| return level; 237| 3.95k|} luaF_newproto: 240| 3.55k|Proto *luaF_newproto (lua_State *L) { 241| 3.55k| GCObject *o = luaC_newobj(L, LUA_VPROTO, sizeof(Proto)); ------------------ | | 507| 3.55k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 3.55k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 242| 3.55k| Proto *f = gco2p(o); ------------------ | | 381| 3.55k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 115| 3.55k|#define check_exp(c,e) (e) | | ------------------ ------------------ 243| 3.55k| f->k = NULL; 244| 3.55k| f->sizek = 0; 245| 3.55k| f->p = NULL; 246| 3.55k| f->sizep = 0; 247| 3.55k| f->code = NULL; 248| 3.55k| f->sizecode = 0; 249| 3.55k| f->lineinfo = NULL; 250| 3.55k| f->sizelineinfo = 0; 251| 3.55k| f->abslineinfo = NULL; 252| 3.55k| f->sizeabslineinfo = 0; 253| 3.55k| f->upvalues = NULL; 254| 3.55k| f->sizeupvalues = 0; 255| 3.55k| f->numparams = 0; 256| 3.55k| f->is_vararg = 0; 257| 3.55k| f->maxstacksize = 0; 258| 3.55k| f->locvars = NULL; 259| 3.55k| f->sizelocvars = 0; 260| 3.55k| f->linedefined = 0; 261| 3.55k| f->lastlinedefined = 0; 262| 3.55k| f->source = NULL; 263| 3.55k| return f; 264| 3.55k|} luaF_freeproto: 267| 3.55k|void luaF_freeproto (lua_State *L, Proto *f) { 268| 3.55k| luaM_freearray(L, f->code, f->sizecode); ------------------ | | 57| 3.55k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 269| 3.55k| luaM_freearray(L, f->p, f->sizep); ------------------ | | 57| 3.55k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 270| 3.55k| luaM_freearray(L, f->k, f->sizek); ------------------ | | 57| 3.55k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 271| 3.55k| luaM_freearray(L, f->lineinfo, f->sizelineinfo); ------------------ | | 57| 3.55k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 272| 3.55k| luaM_freearray(L, f->abslineinfo, f->sizeabslineinfo); ------------------ | | 57| 3.55k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 273| 3.55k| luaM_freearray(L, f->locvars, f->sizelocvars); ------------------ | | 57| 3.55k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 274| 3.55k| luaM_freearray(L, f->upvalues, f->sizeupvalues); ------------------ | | 57| 3.55k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 275| 3.55k| luaM_free(L, f); ------------------ | | 56| 3.55k|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 276| 3.55k|} luaF_getlocalname: 283| 58|const char *luaF_getlocalname (const Proto *f, int local_number, int pc) { 284| 58| int i; 285| 113| for (i = 0; isizelocvars && f->locvars[i].startpc <= pc; i++) { ------------------ | Branch (285:15): [True: 60, False: 53] | Branch (285:35): [True: 56, False: 4] ------------------ 286| 56| if (pc < f->locvars[i].endpc) { /* is variable active? */ ------------------ | Branch (286:9): [True: 56, False: 0] ------------------ 287| 56| local_number--; 288| 56| if (local_number == 0) ------------------ | Branch (288:11): [True: 1, False: 55] ------------------ 289| 1| return getstr(f->locvars[i].varname); ------------------ | | 404| 1|#define getstr(ts) ((ts)->contents) ------------------ 290| 56| } 291| 56| } 292| 57| return NULL; /* not found */ 293| 58|} lfunc.c:newupval: 65| 3.14k|static UpVal *newupval (lua_State *L, StkId level, UpVal **prev) { 66| 3.14k| GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal)); ------------------ | | 584| 3.14k|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 3.14k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 67| 3.14k| UpVal *uv = gco2upv(o); ------------------ | | 383| 3.14k|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 115| 3.14k|#define check_exp(c,e) (e) | | ------------------ ------------------ 68| 3.14k| UpVal *next = *prev; 69| 3.14k| uv->v.p = s2v(level); /* current value lives in the stack */ ------------------ | | 172| 3.14k|#define s2v(o) (&(o)->val) ------------------ 70| 3.14k| uv->u.open.next = next; /* link it to list of open upvalues */ 71| 3.14k| uv->u.open.previous = prev; 72| 3.14k| if (next) ------------------ | Branch (72:7): [True: 0, False: 3.14k] ------------------ 73| 0| next->u.open.previous = &uv->u.open.next; 74| 3.14k| *prev = uv; 75| 3.14k| if (!isintwups(L)) { /* thread not in list of threads with upvalues? */ ------------------ | | 22| 3.14k|#define isintwups(L) (L->twups != L) ------------------ | Branch (75:7): [True: 8, False: 3.13k] ------------------ 76| 8| L->twups = G(L)->twups; /* link it to the list */ ------------------ | | 335| 8|#define G(L) (L->l_G) ------------------ 77| 8| G(L)->twups = L; ------------------ | | 335| 8|#define G(L) (L->l_G) ------------------ 78| 8| } 79| 3.14k| return uv; 80| 3.14k|} lfunc.c:checkclosemth: 125| 16|static void checkclosemth (lua_State *L, StkId level) { 126| 16| const TValue *tm = luaT_gettmbyobj(L, s2v(level), TM_CLOSE); ------------------ | | 172| 16|#define s2v(o) (&(o)->val) ------------------ 127| 16| if (ttisnil(tm)) { /* no metamethod? */ ------------------ | | 193| 16|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 16|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 16|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 16|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 16] | | | | ------------------ | | ------------------ ------------------ 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| 16|} lfunc.c:poptbclist: 213| 16|static void poptbclist (lua_State *L) { 214| 16| StkId tbc = L->tbclist.p; 215| 16| lua_assert(tbc->tbclist.delta > 0); /* first element cannot be dummy */ ------------------ | | 114| 16|#define lua_assert(c) ((void)0) ------------------ 216| 16| tbc -= tbc->tbclist.delta; 217| 16| while (tbc > L->stack.p && tbc->tbclist.delta == 0) ------------------ | Branch (217:10): [True: 0, False: 16] | Branch (217:30): [True: 0, False: 0] ------------------ 218| 0| tbc -= MAXDELTA; /* remove dummy nodes */ ------------------ | | 162| 0| ((256ul << ((sizeof(L->stack.p->tbclist.delta) - 1) * 8)) - 1) ------------------ 219| 16| L->tbclist.p = tbc; 220| 16|} lfunc.c:prepcallclosemth: 143| 16|static void prepcallclosemth (lua_State *L, StkId level, int status, int yy) { 144| 16| TValue *uv = s2v(level); /* value being closed */ ------------------ | | 172| 16|#define s2v(o) (&(o)->val) ------------------ 145| 16| TValue *errobj; 146| 16| if (status == CLOSEKTOP) ------------------ | | 47| 16|#define CLOSEKTOP (-1) ------------------ | Branch (146:7): [True: 16, False: 0] ------------------ 147| 16| errobj = &G(L)->nilvalue; /* error object is nil */ ------------------ | | 335| 16|#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| 16| callclosemethod(L, uv, errobj, yy); 153| 16|} lfunc.c:callclosemethod: 107| 16|static void callclosemethod (lua_State *L, TValue *obj, TValue *err, int yy) { 108| 16| StkId top = L->top.p; 109| 16| const TValue *tm = luaT_gettmbyobj(L, obj, TM_CLOSE); 110| 16| setobj2s(L, top, tm); /* will call metamethod... */ ------------------ | | 131| 16|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 16| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 16| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 16| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 16| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 16|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 16| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 16|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 111| 16| setobj2s(L, top + 1, obj); /* with 'self' as the 1st argument */ ------------------ | | 131| 16|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 16| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 16| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 16| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 16| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 16|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 16| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 16|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 112| 16| setobj2s(L, top + 2, err); /* and error msg. as 2nd argument */ ------------------ | | 131| 16|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 16| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 16| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 16| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 16| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 16|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 16| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 16|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 113| 16| L->top.p = top + 3; /* add function and arguments */ 114| 16| if (yy) ------------------ | Branch (114:7): [True: 0, False: 16] ------------------ 115| 0| luaD_call(L, top, 0); 116| 16| else 117| 16| luaD_callnoyield(L, top, 0); 118| 16|} luaC_fix: 243| 19.1k|void luaC_fix (lua_State *L, GCObject *o) { 244| 19.1k| global_State *g = G(L); ------------------ | | 335| 19.1k|#define G(L) (L->l_G) ------------------ 245| 19.1k| lua_assert(g->allgc == o); /* object must be 1st in 'allgc' list! */ ------------------ | | 114| 19.1k|#define lua_assert(c) ((void)0) ------------------ 246| 19.1k| set2gray(o); /* they will be gray forever */ ------------------ | | 75| 19.1k|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 60| 19.1k|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 19.1k|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 19.1k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 247| 19.1k| setage(o, G_OLD); /* and old forever */ ------------------ | | 117| 19.1k|#define setage(o,a) ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a)) | | ------------------ | | | | 143| 19.1k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 19.1k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 248| 19.1k| g->allgc = o->next; /* remove object from 'allgc' list */ 249| 19.1k| o->next = g->fixedgc; /* link it to 'fixedgc' list */ 250| 19.1k| g->fixedgc = o; 251| 19.1k|} luaC_newobjdt: 258| 598k|GCObject *luaC_newobjdt (lua_State *L, int tt, size_t sz, size_t offset) { 259| 598k| global_State *g = G(L); ------------------ | | 335| 598k|#define G(L) (L->l_G) ------------------ 260| 598k| char *p = cast_charp(luaM_newobject(L, novariant(tt), sz)); ------------------ | | 146| 598k|#define cast_charp(i) cast(char *, (i)) | | ------------------ | | | | 136| 598k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 261| 598k| GCObject *o = cast(GCObject *, p + offset); ------------------ | | 136| 598k|#define cast(t, exp) ((t)(exp)) ------------------ 262| 598k| o->marked = luaC_white(g); ------------------ | | 102| 598k|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 143| 598k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 598k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 263| 598k| o->tt = tt; 264| 598k| o->next = g->allgc; 265| 598k| g->allgc = o; 266| 598k| return o; 267| 598k|} luaC_newobj: 270| 598k|GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) { 271| 598k| return luaC_newobjdt(L, tt, sz, 0); 272| 598k|} luaC_checkfinalizer: 1019| 16|void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) { 1020| 16| global_State *g = G(L); ------------------ | | 335| 16|#define G(L) (L->l_G) ------------------ 1021| 16| if (tofinalize(o) || /* obj. is already marked... */ ------------------ | | 92| 16|#define tofinalize(x) testbit((x)->marked, FINALIZEDBIT) | | ------------------ | | | | 67| 16|#define testbit(x,b) testbits(x, bitmask(b)) | | | | ------------------ | | | | | | 62| 32|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 16] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1022| 16| gfasttm(g, mt, TM_GC) == NULL || /* or has no finalizer... */ ------------------ | | 64| 16|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | ------------------ | | | Branch (64:26): [True: 0, False: 16] | | ------------------ | | 65| 16| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | ------------------ | | | Branch (65:3): [True: 0, False: 16] | | ------------------ ------------------ | Branch (1022:7): [True: 0, False: 16] ------------------ 1023| 16| (g->gcstp & GCSTPCLS)) /* or closing state? */ ------------------ | | 157| 16|#define GCSTPCLS 4 /* bit true when closing Lua state */ ------------------ | Branch (1023:7): [True: 0, False: 16] ------------------ 1024| 0| return; /* nothing to be done */ 1025| 16| else { /* move 'o' to 'finobj' list */ 1026| 16| GCObject **p; 1027| 16| if (issweepphase(g)) { ------------------ | | 43| 16| (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 34| 16|#define GCSswpallgc 3 | | ------------------ | | (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 37| 16|#define GCSswpend 6 | | ------------------ | | | Branch (43:3): [True: 16, False: 0] | | | Branch (43:34): [True: 0, False: 16] | | ------------------ ------------------ 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| 16| else 1033| 16| correctpointers(g, o); 1034| | /* search for pointer pointing to 'o' */ 1035| 64| for (p = &g->allgc; *p != o; p = &(*p)->next) { /* empty */ } ------------------ | Branch (1035:25): [True: 48, False: 16] ------------------ 1036| 16| *p = o->next; /* remove 'o' from 'allgc' list */ 1037| 16| o->next = g->finobj; /* link it in 'finobj' list */ 1038| 16| g->finobj = o; 1039| 16| l_setbit(o->marked, FINALIZEDBIT); /* mark it as such */ ------------------ | | 65| 16|#define l_setbit(x,b) setbits(x, bitmask(b)) | | ------------------ | | | | 61| 16|#define setbits(x,m) ((x) |= (m)) | | ------------------ ------------------ 1040| 16| } 1041| 16|} luaC_changemode: 1360| 390|void luaC_changemode (lua_State *L, int newmode) { 1361| 390| global_State *g = G(L); ------------------ | | 335| 390|#define G(L) (L->l_G) ------------------ 1362| 390| if (newmode != g->gckind) { ------------------ | Branch (1362:7): [True: 0, False: 390] ------------------ 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| 390| g->lastatomic = 0; 1369| 390|} luaC_freeallobjects: 1511| 390|void luaC_freeallobjects (lua_State *L) { 1512| 390| global_State *g = G(L); ------------------ | | 335| 390|#define G(L) (L->l_G) ------------------ 1513| 390| g->gcstp = GCSTPCLS; /* no extra finalizers after here */ ------------------ | | 157| 390|#define GCSTPCLS 4 /* bit true when closing Lua state */ ------------------ 1514| 390| luaC_changemode(L, KGC_INC); ------------------ | | 151| 390|#define KGC_INC 0 /* incremental gc */ ------------------ 1515| 390| separatetobefnz(g, 1); /* separate all objects with finalizers */ 1516| 390| lua_assert(g->finobj == NULL); ------------------ | | 114| 390|#define lua_assert(c) ((void)0) ------------------ 1517| 390| callallpendingfinalizers(L); 1518| 390| deletelist(L, g->allgc, obj2gco(g->mainthread)); ------------------ | | 390| 390|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 390|#define check_exp(c,e) (e) | | ------------------ ------------------ 1519| 390| lua_assert(g->finobj == NULL); /* no new finalizers */ ------------------ | | 114| 390|#define lua_assert(c) ((void)0) ------------------ 1520| 390| deletelist(L, g->fixedgc, NULL); /* collect fixed objects */ 1521| 390| lua_assert(g->strt.nuse == 0); ------------------ | | 114| 390|#define lua_assert(c) ((void)0) ------------------ 1522| 390|} luaC_step: 1690| 1.69k|void luaC_step (lua_State *L) { 1691| 1.69k| global_State *g = G(L); ------------------ | | 335| 1.69k|#define G(L) (L->l_G) ------------------ 1692| 1.69k| if (!gcrunning(g)) /* not running? */ ------------------ | | 158| 1.69k|#define gcrunning(g) ((g)->gcstp == 0) ------------------ | Branch (1692:7): [True: 0, False: 1.69k] ------------------ 1693| 0| luaE_setdebt(g, -2000); 1694| 1.69k| else { 1695| 1.69k| if(isdecGCmodegen(g)) ------------------ | | 149| 1.69k|#define isdecGCmodegen(g) (g->gckind == KGC_GEN || g->lastatomic != 0) | | ------------------ | | | | 152| 3.38k|#define KGC_GEN 1 /* generational gc */ | | ------------------ | | | Branch (149:28): [True: 0, False: 1.69k] | | | Branch (149:52): [True: 0, False: 1.69k] | | ------------------ ------------------ 1696| 0| genstep(L, g); 1697| 1.69k| else 1698| 1.69k| incstep(L, g); 1699| 1.69k| } 1700| 1.69k|} lgc.c:linkgclist_: 148| 35.3k|static void linkgclist_ (GCObject *o, GCObject **pnext, GCObject **list) { 149| 35.3k| lua_assert(!isgray(o)); /* cannot be in a gray list */ ------------------ | | 114| 35.3k|#define lua_assert(c) ((void)0) ------------------ 150| 35.3k| *pnext = *list; 151| 35.3k| *list = o; 152| 35.3k| set2gray(o); /* now it is */ ------------------ | | 75| 35.3k|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 60| 35.3k|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 35.3k|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 35.3k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 153| 35.3k|} lgc.c:getgclist: 125| 68.9k|static GCObject **getgclist (GCObject *o) { 126| 68.9k| switch (o->tt) { 127| 9.74k| case LUA_VTABLE: return &gco2t(o)->gclist; ------------------ | | 678| 9.74k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 9.74k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTABLE: return &gco2t(o)->gclist; ------------------ | | 380| 9.74k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 9.74k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (127:5): [True: 9.74k, False: 59.2k] ------------------ 128| 3.96k| case LUA_VLCL: return &gco2lcl(o)->gclist; ------------------ | | 588| 3.96k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 3.96k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: return &gco2lcl(o)->gclist; ------------------ | | 376| 3.96k|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 115| 3.96k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (128:5): [True: 3.96k, False: 65.0k] ------------------ 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)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (129:5): [True: 0, False: 68.9k] ------------------ 130| 5.08k| case LUA_VTHREAD: return &gco2th(o)->gclist; ------------------ | | 262| 5.08k|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 5.08k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: return &gco2th(o)->gclist; ------------------ | | 382| 5.08k|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 115| 5.08k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (130:5): [True: 5.08k, False: 63.9k] ------------------ 131| 50.2k| case LUA_VPROTO: return &gco2p(o)->gclist; ------------------ | | 507| 50.2k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 50.2k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VPROTO: return &gco2p(o)->gclist; ------------------ | | 381| 50.2k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 115| 50.2k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (131:5): [True: 50.2k, False: 18.7k] ------------------ 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.9k] ------------------ 133| 0| Udata *u = gco2u(o); ------------------ | | 375| 0|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 134| 0| lua_assert(u->nuvalue > 0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 135| 0| return &u->gclist; 136| 0| } 137| 0| default: lua_assert(0); return 0; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (137:5): [True: 0, False: 68.9k] ------------------ 138| 68.9k| } 139| 68.9k|} lgc.c:reallymarkobject: 297| 93.0k|static void reallymarkobject (global_State *g, GCObject *o) { 298| 93.0k| switch (o->tt) { 299| 54.4k| case LUA_VSHRSTR: ------------------ | | 360| 54.4k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 54.4k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (299:5): [True: 54.4k, False: 38.6k] ------------------ 300| 59.0k| case LUA_VLNGSTR: { ------------------ | | 361| 59.0k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 59.0k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (300:5): [True: 4.60k, False: 88.4k] ------------------ 301| 59.0k| set2black(o); /* nothing to visit */ ------------------ | | 80| 59.0k| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 143| 59.0k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 59.0k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 302| 59.0k| break; 303| 54.4k| } 304| 340| case LUA_VUPVAL: { ------------------ | | 584| 340|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 340|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (304:5): [True: 340, False: 92.7k] ------------------ 305| 340| UpVal *uv = gco2upv(o); ------------------ | | 383| 340|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 115| 340|#define check_exp(c,e) (e) | | ------------------ ------------------ 306| 340| if (upisopen(uv)) ------------------ | | 32| 340|#define upisopen(up) ((up)->v.p != &(up)->u.value) | | ------------------ | | | Branch (32:22): [True: 128, False: 212] | | ------------------ ------------------ 307| 340| set2gray(uv); /* open upvalues are kept gray */ ------------------ | | 75| 128|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 60| 128|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 128|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 128|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 308| 212| else 309| 212| set2black(uv); /* closed upvalues are visited here */ ------------------ | | 80| 212| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 143| 212|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 212|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 310| 340| markvalue(g, uv->v.p); /* mark its content */ ------------------ | | 94| 340|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 340| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 340|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 340| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 340| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 340|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 680|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 340|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 340|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 212, False: 128] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 212|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 212|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 212] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 311| 340| break; 312| 54.4k| } 313| 12| case LUA_VUSERDATA: { ------------------ | | 429| 12|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 12|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (313:5): [True: 12, False: 93.0k] ------------------ 314| 12| Udata *u = gco2u(o); ------------------ | | 375| 12|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 115| 12|#define check_exp(c,e) (e) | | ------------------ ------------------ 315| 12| if (u->nuvalue == 0) { /* no user values? */ ------------------ | Branch (315:11): [True: 12, False: 0] ------------------ 316| 12| markobjectN(g, u->metatable); /* mark its metatable */ ------------------ | | 105| 12|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 12] | | ------------------ ------------------ 317| 12| set2black(u); /* nothing else to mark */ ------------------ | | 80| 12| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 143| 12|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 318| 12| break; 319| 12| } 320| | /* else... */ 321| 12| } /* FALLTHROUGH */ 322| 6.85k| case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 588| 1.98k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 1.98k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 590| 1.98k|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 1.98k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 678| 6.85k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 6.85k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (322:5): [True: 1.98k, False: 91.0k] | Branch (322:20): [True: 0, False: 93.0k] | Branch (322:35): [True: 4.87k, False: 88.1k] ------------------ 323| 33.6k| case LUA_VTHREAD: case LUA_VPROTO: { ------------------ | | 262| 8.54k|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 8.54k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: case LUA_VPROTO: { ------------------ | | 507| 33.6k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 33.6k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (323:5): [True: 1.69k, False: 91.3k] | Branch (323:23): [True: 25.1k, False: 67.9k] ------------------ 324| 33.6k| linkobjgclist(o, g->gray); /* to be visited later */ ------------------ | | 159| 33.6k|#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p)) | | ------------------ | | | | 390| 33.6k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 33.6k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 325| 33.6k| break; 326| 8.54k| } 327| 0| default: lua_assert(0); break; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (327:5): [True: 0, False: 93.0k] ------------------ 328| 93.0k| } 329| 93.0k|} lgc.c:sweeptolive: 851| 1.69k|static GCObject **sweeptolive (lua_State *L, GCObject **p) { 852| 1.69k| GCObject **old = p; 853| 5.40k| do { 854| 5.40k| p = sweeplist(L, p, 1, NULL); 855| 5.40k| } while (p == old); ------------------ | Branch (855:12): [True: 3.70k, False: 1.69k] ------------------ 856| 1.69k| return p; 857| 1.69k|} lgc.c:sweeplist: 825| 16.0k| int *countout) { 826| 16.0k| global_State *g = G(L); ------------------ | | 335| 16.0k|#define G(L) (L->l_G) ------------------ 827| 16.0k| int ow = otherwhite(g); ------------------ | | 94| 16.0k|#define otherwhite(g) ((g)->currentwhite ^ WHITEBITS) | | ------------------ | | | | 84| 16.0k|#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) | | | | ------------------ | | | | | | 64| 16.0k|#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 16.0k|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | | | #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 16.0k|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 828| 16.0k| int i; 829| 16.0k| int white = luaC_white(g); /* current white */ ------------------ | | 102| 16.0k|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 143| 16.0k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 16.0k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 830| 642k| for (i = 0; *p != NULL && i < countin; i++) { ------------------ | Branch (830:15): [True: 637k, False: 5.08k] | Branch (830:29): [True: 626k, False: 10.9k] ------------------ 831| 626k| GCObject *curr = *p; 832| 626k| int marked = curr->marked; 833| 626k| if (isdeadm(ow, marked)) { /* is 'curr' dead? */ ------------------ | | 95| 626k|#define isdeadm(ow,m) ((m) & (ow)) | | ------------------ | | | Branch (95:23): [True: 533k, False: 93.0k] | | ------------------ ------------------ 834| 533k| *p = curr->next; /* remove 'curr' from list */ 835| 533k| freeobj(L, curr); /* erase 'curr' */ 836| 533k| } 837| 93.0k| else { /* change mark to 'white' */ 838| 93.0k| curr->marked = cast_byte((marked & ~maskgcbits) | white); ------------------ | | 143| 93.0k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 93.0k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 839| 93.0k| p = &curr->next; /* go to next element */ 840| 93.0k| } 841| 626k| } 842| 16.0k| if (countout) ------------------ | Branch (842:7): [True: 10.6k, False: 5.40k] ------------------ 843| 10.6k| *countout = i; /* number of elements traversed */ 844| 16.0k| return (*p == NULL) ? NULL : p; ------------------ | Branch (844:10): [True: 5.08k, False: 10.9k] ------------------ 845| 16.0k|} lgc.c:freeobj: 772| 598k|static void freeobj (lua_State *L, GCObject *o) { 773| 598k| switch (o->tt) { 774| 3.55k| case LUA_VPROTO: ------------------ | | 507| 3.55k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 3.55k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (774:5): [True: 3.55k, False: 595k] ------------------ 775| 3.55k| luaF_freeproto(L, gco2p(o)); ------------------ | | 381| 3.55k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 115| 3.55k|#define check_exp(c,e) (e) | | ------------------ ------------------ 776| 3.55k| break; 777| 3.21k| case LUA_VUPVAL: ------------------ | | 584| 3.21k|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 3.21k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (777:5): [True: 3.21k, False: 595k] ------------------ 778| 3.21k| freeupval(L, gco2upv(o)); ------------------ | | 383| 3.21k|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 115| 3.21k|#define check_exp(c,e) (e) | | ------------------ ------------------ 779| 3.21k| break; 780| 490k| case LUA_VLCL: { ------------------ | | 588| 490k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 490k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (780:5): [True: 490k, False: 108k] ------------------ 781| 490k| LClosure *cl = gco2lcl(o); ------------------ | | 376| 490k|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 115| 490k|#define check_exp(c,e) (e) | | ------------------ ------------------ 782| 490k| luaM_freemem(L, cl, sizeLclosure(cl->nupvalues)); ------------------ | | 55| 490k|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 783| 490k| break; 784| 0| } 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: 598k] ------------------ 786| 0| CClosure *cl = gco2ccl(o); ------------------ | | 377| 0|#define gco2ccl(o) check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 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| 9.19k| case LUA_VTABLE: ------------------ | | 678| 9.19k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 9.19k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (790:5): [True: 9.19k, False: 589k] ------------------ 791| 9.19k| luaH_free(L, gco2t(o)); ------------------ | | 380| 9.19k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 9.19k|#define check_exp(c,e) (e) | | ------------------ ------------------ 792| 9.19k| 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: 598k] ------------------ 794| 0| luaE_freethread(L, gco2th(o)); ------------------ | | 382| 0|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 795| 0| break; 796| 16| case LUA_VUSERDATA: { ------------------ | | 429| 16|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 16|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (796:5): [True: 16, False: 598k] ------------------ 797| 16| Udata *u = gco2u(o); ------------------ | | 375| 16|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ 798| 16| luaM_freemem(L, o, sizeudata(u->nuvalue, u->len)); ------------------ | | 55| 32|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) | | ------------------ | | | Branch (55:51): [True: 16, False: 0] | | ------------------ ------------------ 799| 16| break; 800| 0| } 801| 62.1k| case LUA_VSHRSTR: { ------------------ | | 360| 62.1k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 62.1k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (801:5): [True: 62.1k, False: 536k] ------------------ 802| 62.1k| TString *ts = gco2ts(o); ------------------ | | 374| 62.1k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 115| 62.1k|#define check_exp(c,e) (e) | | ------------------ ------------------ 803| 62.1k| luaS_remove(L, ts); /* remove it from hash table */ 804| 62.1k| luaM_freemem(L, ts, sizelstring(ts->shrlen)); ------------------ | | 55| 62.1k|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 805| 62.1k| break; 806| 0| } 807| 30.5k| case LUA_VLNGSTR: { ------------------ | | 361| 30.5k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 30.5k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (807:5): [True: 30.5k, False: 568k] ------------------ 808| 30.5k| TString *ts = gco2ts(o); ------------------ | | 374| 30.5k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 115| 30.5k|#define check_exp(c,e) (e) | | ------------------ ------------------ 809| 30.5k| luaM_freemem(L, ts, sizelstring(ts->u.lnglen)); ------------------ | | 55| 30.5k|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 810| 30.5k| break; 811| 0| } 812| 0| default: lua_assert(0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (812:5): [True: 0, False: 598k] ------------------ 813| 598k| } 814| 598k|} lgc.c:freeupval: 765| 3.21k|static void freeupval (lua_State *L, UpVal *uv) { 766| 3.21k| if (upisopen(uv)) ------------------ | | 32| 3.21k|#define upisopen(up) ((up)->v.p != &(up)->u.value) | | ------------------ | | | Branch (32:22): [True: 0, False: 3.21k] | | ------------------ ------------------ 767| 0| luaF_unlinkupval(uv); 768| 3.21k| luaM_free(L, uv); ------------------ | | 56| 3.21k|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 769| 3.21k|} lgc.c:correctpointers: 1007| 16|static void correctpointers (global_State *g, GCObject *o) { 1008| 16| checkpointer(&g->survival, o); 1009| 16| checkpointer(&g->old1, o); 1010| 16| checkpointer(&g->reallyold, o); 1011| 16| checkpointer(&g->firstold1, o); 1012| 16|} lgc.c:checkpointer: 997| 64|static void checkpointer (GCObject **p, GCObject *o) { 998| 64| if (o == *p) ------------------ | Branch (998:7): [True: 0, False: 64] ------------------ 999| 0| *p = o->next; 1000| 64|} lgc.c:atomic: 1525| 1.69k|static lu_mem atomic (lua_State *L) { 1526| 1.69k| global_State *g = G(L); ------------------ | | 335| 1.69k|#define G(L) (L->l_G) ------------------ 1527| 1.69k| lu_mem work = 0; 1528| 1.69k| GCObject *origweak, *origall; 1529| 1.69k| GCObject *grayagain = g->grayagain; /* save original list */ 1530| 1.69k| g->grayagain = NULL; 1531| 1.69k| lua_assert(g->ephemeron == NULL && g->weak == NULL); ------------------ | | 114| 1.69k|#define lua_assert(c) ((void)0) ------------------ 1532| 1.69k| lua_assert(!iswhite(g->mainthread)); ------------------ | | 114| 1.69k|#define lua_assert(c) ((void)0) ------------------ 1533| 1.69k| g->gcstate = GCSatomic; ------------------ | | 33| 1.69k|#define GCSatomic 2 ------------------ 1534| 1.69k| markobject(g, L); /* mark running thread */ ------------------ | | 99| 1.69k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 1.69k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 1.69k|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 1.69k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1535| | /* registry and global metatables may be changed by API */ 1536| 1.69k| markvalue(g, &g->l_registry); ------------------ | | 94| 1.69k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 1.69k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 1.69k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 1.69k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 1.69k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 1.69k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 3.38k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 1.69k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 1.69k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 1.69k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 1.69k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 1.69k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 1.69k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1537| 1.69k| markmt(g); /* mark global metatables */ 1538| 1.69k| work += propagateall(g); /* empties 'gray' list */ 1539| | /* remark occasional upvalues of (maybe) dead threads */ 1540| 1.69k| work += remarkupvals(g); 1541| 1.69k| work += propagateall(g); /* propagate changes */ 1542| 1.69k| g->gray = grayagain; 1543| 1.69k| work += propagateall(g); /* traverse 'grayagain' list */ 1544| 1.69k| convergeephemerons(g); 1545| | /* at this point, all strongly accessible objects are marked. */ 1546| | /* Clear values from weak tables, before checking finalizers */ 1547| 1.69k| clearbyvalues(g, g->weak, NULL); 1548| 1.69k| clearbyvalues(g, g->allweak, NULL); 1549| 1.69k| origweak = g->weak; origall = g->allweak; 1550| 1.69k| separatetobefnz(g, 0); /* separate objects to be finalized */ 1551| 1.69k| work += markbeingfnz(g); /* mark objects that will be finalized */ 1552| 1.69k| work += propagateall(g); /* remark, to propagate 'resurrection' */ 1553| 1.69k| convergeephemerons(g); 1554| | /* at this point, all resurrected objects are marked. */ 1555| | /* remove dead objects from weak tables */ 1556| 1.69k| clearbykeys(g, g->ephemeron); /* clear keys from all ephemeron tables */ 1557| 1.69k| clearbykeys(g, g->allweak); /* clear keys from all 'allweak' tables */ 1558| | /* clear values from resurrected weak tables */ 1559| 1.69k| clearbyvalues(g, g->weak, origweak); 1560| 1.69k| clearbyvalues(g, g->allweak, origall); 1561| 1.69k| luaS_clearcache(g); 1562| 1.69k| g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */ ------------------ | | 143| 1.69k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 1.69k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1563| 1.69k| lua_assert(g->gray == NULL); ------------------ | | 114| 1.69k|#define lua_assert(c) ((void)0) ------------------ 1564| 1.69k| return work; /* estimate of slots marked by 'atomic' */ 1565| 1.69k|} lgc.c:markmt: 335| 3.38k|static void markmt (global_State *g) { 336| 3.38k| int i; 337| 33.8k| for (i=0; i < LUA_NUMTAGS; i++) ------------------ | | 426| 33.8k|#define LUA_NUMTAGS LUA_NUMTYPES | | ------------------ | | | | 74| 33.8k|#define LUA_NUMTYPES 9 | | ------------------ ------------------ | Branch (337:13): [True: 30.4k, False: 3.38k] ------------------ 338| 30.4k| markobjectN(g, g->mt[i]); ------------------ | | 105| 30.4k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 30.4k] | | ------------------ ------------------ 339| 3.38k|} lgc.c:propagateall: 676| 6.77k|static lu_mem propagateall (global_State *g) { 677| 6.77k| lu_mem tot = 0; 678| 8.47k| while (g->gray) ------------------ | Branch (678:10): [True: 1.69k, False: 6.77k] ------------------ 679| 1.69k| tot += propagatemark(g); 680| 6.77k| return tot; 681| 6.77k|} lgc.c:propagatemark: 660| 35.3k|static lu_mem propagatemark (global_State *g) { 661| 35.3k| GCObject *o = g->gray; 662| 35.3k| nw2black(o); ------------------ | | 100| 35.3k| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 115| 35.3k|#define check_exp(c,e) (e) | | ------------------ ------------------ 663| 35.3k| g->gray = *getgclist(o); /* remove from 'gray' list */ 664| 35.3k| switch (o->tt) { 665| 4.87k| case LUA_VTABLE: return traversetable(g, gco2t(o)); ------------------ | | 678| 4.87k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 4.87k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTABLE: return traversetable(g, gco2t(o)); ------------------ | | 380| 4.87k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 4.87k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (665:5): [True: 4.87k, False: 30.4k] ------------------ 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)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (666:5): [True: 0, False: 35.3k] ------------------ 667| 1.98k| case LUA_VLCL: return traverseLclosure(g, gco2lcl(o)); ------------------ | | 588| 1.98k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 1.98k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: return traverseLclosure(g, gco2lcl(o)); ------------------ | | 376| 1.98k|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 115| 1.98k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (667:5): [True: 1.98k, False: 33.3k] ------------------ 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)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (668:5): [True: 0, False: 35.3k] ------------------ 669| 25.1k| case LUA_VPROTO: return traverseproto(g, gco2p(o)); ------------------ | | 507| 25.1k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 25.1k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VPROTO: return traverseproto(g, gco2p(o)); ------------------ | | 381| 25.1k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 115| 25.1k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (669:5): [True: 25.1k, False: 10.2k] ------------------ 670| 3.38k| case LUA_VTHREAD: return traversethread(g, gco2th(o)); ------------------ | | 262| 3.38k|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 3.38k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: return traversethread(g, gco2th(o)); ------------------ | | 382| 3.38k|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 115| 3.38k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (670:5): [True: 3.38k, False: 31.9k] ------------------ 671| 0| default: lua_assert(0); return 0; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (671:5): [True: 0, False: 35.3k] ------------------ 672| 35.3k| } 673| 35.3k|} lgc.c:traversetable: 542| 4.87k|static lu_mem traversetable (global_State *g, Table *h) { 543| 4.87k| const char *weakkey, *weakvalue; 544| 4.87k| const TValue *mode = gfasttm(g, h->metatable, TM_MODE); ------------------ | | 64| 4.87k|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | ------------------ | | | Branch (64:26): [True: 4.87k, False: 0] | | ------------------ | | 65| 4.87k| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | ------------------ | | | Branch (65:3): [True: 0, False: 0] | | ------------------ ------------------ 545| 4.87k| TString *smode; 546| 4.87k| markobjectN(g, h->metatable); ------------------ | | 105| 4.87k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 4.87k] | | ------------------ ------------------ 547| 4.87k| if (mode && ttisshrstring(mode) && /* is there a weak mode? */ ------------------ | | 364| 0|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | ------------------ | | | | 91| 4.87k|#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: 4.87k] ------------------ 548| 4.87k| (cast_void(smode = tsvalue(mode)), ------------------ | | 138| 0|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | 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)) | | ------------------ ------------------ 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)) | | ------------------ ------------------ 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)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 558| 0| } 559| 4.87k| else /* not weak */ 560| 4.87k| traversestrongtable(g, h); 561| 4.87k| return 1 + h->alimit + 2 * allocsizenode(h); ------------------ | | 31| 4.87k|#define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 27| 4.87k|#define isdummy(t) ((t)->lastfree == NULL) | | | | ------------------ | | | | | Branch (27:21): [True: 3.19k, False: 1.68k] | | | | ------------------ | | ------------------ | | #define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 791| 1.68k|#define sizenode(t) (twoto((t)->lsizenode)) | | | | ------------------ | | | | | | 790| 1.68k|#define twoto(x) (1<<(x)) | | | | ------------------ | | ------------------ ------------------ 562| 4.87k|} lgc.c:clearkey: 171| 134k|static void clearkey (Node *n) { 172| 134k| lua_assert(isempty(gval(n))); ------------------ | | 114| 134k|#define lua_assert(c) ((void)0) ------------------ 173| 134k| if (keyiscollectable(n)) ------------------ | | 764| 134k|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 753| 134k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 298| 134k|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ | | | Branch (764:29): [True: 2, False: 134k] | | ------------------ ------------------ 174| 2| setdeadkey(n); /* unused key; remove it */ ------------------ | | 776| 2|#define setdeadkey(node) (keytt(node) = LUA_TDEADKEY) | | ------------------ | | | | 753| 2|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define setdeadkey(node) (keytt(node) = LUA_TDEADKEY) | | ------------------ | | | | 24| 2|#define LUA_TDEADKEY (LUA_NUMTYPES+2) /* removed keys in tables */ | | | | ------------------ | | | | | | 74| 2|#define LUA_NUMTYPES 9 | | | | ------------------ | | ------------------ ------------------ 175| 134k|} lgc.c:genlink: 430| 4.87k|static void genlink (global_State *g, GCObject *o) { 431| 4.87k| lua_assert(isblack(o)); ------------------ | | 114| 4.87k|#define lua_assert(c) ((void)0) ------------------ 432| 4.87k| if (getage(o) == G_TOUCHED1) { /* touched in this cycle? */ ------------------ | | 116| 4.87k|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 114| 4.87k|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ if (getage(o) == G_TOUCHED1) { /* touched in this cycle? */ ------------------ | | 111| 4.87k|#define G_TOUCHED1 5 /* old object touched this cycle */ ------------------ | Branch (432:7): [True: 0, False: 4.87k] ------------------ 433| 0| linkobjgclist(o, g->grayagain); /* link it back in 'grayagain' */ ------------------ | | 159| 0|#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 434| 0| } /* everything else do not need to be linked back */ 435| 4.87k| else if (getage(o) == G_TOUCHED2) ------------------ | | 116| 4.87k|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 114| 4.87k|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ else if (getage(o) == G_TOUCHED2) ------------------ | | 112| 4.87k|#define G_TOUCHED2 6 /* old object touched in previous cycle */ ------------------ | Branch (435:12): [True: 0, False: 4.87k] ------------------ 436| 0| changeage(o, G_TOUCHED2, G_OLD); /* advance age */ ------------------ | | 121| 0| check_exp(getage(o) == (f), (o)->marked ^= ((f)^(t))) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 437| 4.87k|} lgc.c:traversestrongtable: 523| 4.87k|static void traversestrongtable (global_State *g, Table *h) { 524| 4.87k| Node *n, *limit = gnodelast(h); ------------------ | | 122| 4.87k|#define gnodelast(h) gnode(h, cast_sizet(sizenode(h))) | | ------------------ | | | | 13| 4.87k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 525| 4.87k| unsigned int i; 526| 4.87k| unsigned int asize = luaH_realasize(h); 527| 56.3k| for (i = 0; i < asize; i++) /* traverse array part */ ------------------ | Branch (527:15): [True: 51.4k, False: 4.87k] ------------------ 528| 51.4k| markvalue(g, &h->array[i]); ------------------ | | 94| 51.4k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 51.4k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 51.4k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 51.4k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 51.4k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 51.4k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 102k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 51.4k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 51.4k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 3.38k, False: 48.0k] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 3.38k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 3.38k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 1.69k, False: 1.69k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 1.69k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 1.69k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 529| 446k| for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */ ------------------ | | 13| 4.87k|#define gnode(t,i) (&(t)->node[i]) ------------------ | Branch (529:25): [True: 441k, False: 4.87k] ------------------ 530| 441k| if (isempty(gval(n))) /* entry is empty? */ ------------------ | | 217| 441k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 441k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 441k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 441k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 441k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 134k, False: 306k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 531| 134k| clearkey(n); /* clear its key */ 532| 306k| else { 533| 306k| lua_assert(!keyisnil(n)); ------------------ | | 114| 306k|#define lua_assert(c) ((void)0) ------------------ 534| 306k| markkey(g, n); ------------------ | | 97| 306k|#define markkey(g, n) { if keyiswhite(n) reallymarkobject(g,gckey(n)); } | | ------------------ | | | | 85| 306k|#define keyiswhite(n) (keyiscollectable(n) && iswhite(gckey(n))) | | | | ------------------ | | | | | | 764| 613k|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 753| 306k|#define keytt(node) ((node)->u.key_tt) | | | | | | ------------------ | | | | | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 306k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (764:29): [True: 58.1k, False: 248k] | | | | | | ------------------ | | | | ------------------ | | | | #define keyiswhite(n) (keyiscollectable(n) && iswhite(gckey(n))) | | | | ------------------ | | | | | | 87| 58.1k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 58.1k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 50.6k, False: 7.43k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markkey(g, n) { if keyiswhite(n) reallymarkobject(g,gckey(n)); } | | ------------------ | | | | 766| 50.6k|#define gckey(n) (keyval(n).gc) | | | | ------------------ | | | | | | 754| 50.6k|#define keyval(node) ((node)->u.key_val) | | | | ------------------ | | ------------------ ------------------ 535| 306k| markvalue(g, gval(n)); ------------------ | | 94| 306k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 306k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 306k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 306k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 306k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 306k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 613k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 306k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 306k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 10.6k, False: 296k] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 10.6k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 10.6k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 81, False: 10.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 81|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 81|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 536| 306k| } 537| 441k| } 538| 4.87k| genlink(g, obj2gco(h)); ------------------ | | 390| 4.87k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 4.87k|#define check_exp(c,e) (e) | | ------------------ ------------------ 539| 4.87k|} lgc.c:traverseLclosure: 606| 1.98k|static int traverseLclosure (global_State *g, LClosure *cl) { 607| 1.98k| int i; 608| 1.98k| markobjectN(g, cl->p); /* mark its prototype */ ------------------ | | 105| 1.98k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 1.98k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 1.98k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 1.98k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 1.98k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 1.98k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 1.98k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 1.98k, False: 0] | | ------------------ ------------------ 609| 3.79k| for (i = 0; i < cl->nupvalues; i++) { /* visit its upvalues */ ------------------ | Branch (609:15): [True: 1.81k, False: 1.98k] ------------------ 610| 1.81k| UpVal *uv = cl->upvals[i]; 611| 1.81k| markobjectN(g, uv); /* mark upvalue */ ------------------ | | 105| 1.81k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 334|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 334|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 334|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 214, False: 120] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 214|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 214|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 334, False: 1.48k] | | ------------------ ------------------ 612| 1.81k| } 613| 1.98k| return 1 + cl->nupvalues; 614| 1.98k|} lgc.c:traverseproto: 580| 25.1k|static int traverseproto (global_State *g, Proto *f) { 581| 25.1k| int i; 582| 25.1k| markobjectN(g, f->source); ------------------ | | 105| 25.1k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 25.1k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 25.1k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 25.1k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 1.69k, False: 23.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 1.69k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 1.69k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 25.1k, False: 0] | | ------------------ ------------------ 583| 306k| for (i = 0; i < f->sizek; i++) /* mark literals */ ------------------ | Branch (583:15): [True: 281k, False: 25.1k] ------------------ 584| 281k| markvalue(g, &f->k[i]); ------------------ | | 94| 281k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 281k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 281k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 281k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 281k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 281k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 562k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 281k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 281k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 116k, False: 164k] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 116k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 116k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 2.91k, False: 113k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 2.91k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 2.91k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 585| 41.4k| for (i = 0; i < f->sizeupvalues; i++) /* mark upvalue names */ ------------------ | Branch (585:15): [True: 16.3k, False: 25.1k] ------------------ 586| 16.3k| markobjectN(g, f->upvalues[i].name); ------------------ | | 105| 16.3k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 11.1k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 11.1k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 11.1k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 6, False: 11.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 6|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 6|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 11.1k, False: 5.23k] | | ------------------ ------------------ 587| 50.8k| for (i = 0; i < f->sizep; i++) /* mark nested protos */ ------------------ | Branch (587:15): [True: 25.7k, False: 25.1k] ------------------ 588| 25.7k| markobjectN(g, f->p[i]); ------------------ | | 105| 25.7k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 23.4k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 23.4k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 23.4k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 23.1k, False: 286] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 23.1k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 23.1k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 23.4k, False: 2.33k] | | ------------------ ------------------ 589| 75.4k| for (i = 0; i < f->sizelocvars; i++) /* mark local-variable names */ ------------------ | Branch (589:15): [True: 50.3k, False: 25.1k] ------------------ 590| 50.3k| markobjectN(g, f->locvars[i].varname); ------------------ | | 105| 50.3k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 45.6k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 45.6k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 45.6k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 2.12k, False: 43.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #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)) | | | | | | ------------------ | | | | | | | | 115| 2.12k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 45.6k, False: 4.66k] | | ------------------ ------------------ 591| 25.1k| return 1 + f->sizek + f->sizeupvalues + f->sizep + f->sizelocvars; 592| 25.1k|} lgc.c:traversethread: 629| 3.38k|static int traversethread (global_State *g, lua_State *th) { 630| 3.38k| UpVal *uv; 631| 3.38k| StkId o = th->stack.p; 632| 3.38k| if (isold(th) || g->gcstate == GCSpropagate) ------------------ | | 118| 6.77k|#define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 116| 3.38k|#define getage(o) ((o)->marked & AGEBITS) | | | | ------------------ | | | | | | 114| 3.38k|#define AGEBITS 7 /* all age bits (111) */ | | | | ------------------ | | ------------------ | | #define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 107| 3.38k|#define G_SURVIVAL 1 /* created in previous cycle */ | | ------------------ | | | Branch (118:18): [True: 0, False: 3.38k] | | ------------------ ------------------ if (isold(th) || g->gcstate == GCSpropagate) ------------------ | | 31| 3.38k|#define GCSpropagate 0 ------------------ | Branch (632:20): [True: 1.69k, False: 1.69k] ------------------ 633| 1.69k| linkgclist(th, g->grayagain); /* insert into 'grayagain' list */ ------------------ | | 146| 1.69k|#define linkgclist(o,p) linkgclist_(obj2gco(o), &(o)->gclist, &(p)) | | ------------------ | | | | 390| 1.69k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 1.69k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 634| 3.38k| if (o == NULL) ------------------ | Branch (634:7): [True: 0, False: 3.38k] ------------------ 635| 0| return 1; /* stack not completely built yet */ 636| 3.38k| lua_assert(g->gcstate == GCSatomic || ------------------ | | 114| 3.38k|#define lua_assert(c) ((void)0) ------------------ 637| 3.38k| th->openupval == NULL || isintwups(th)); 638| 24.0k| for (; o < th->top.p; o++) /* mark live elements in the stack */ ------------------ | Branch (638:10): [True: 20.6k, False: 3.38k] ------------------ 639| 20.6k| markvalue(g, s2v(o)); ------------------ | | 94| 24.0k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 20.6k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 20.6k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 20.6k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 24.0k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 20.6k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 41.3k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 20.6k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 20.6k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 10.8k, False: 9.80k] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 10.8k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 10.8k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 5.01k, False: 5.83k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 5.01k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 5.01k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 640| 3.64k| for (uv = th->openupval; uv != NULL; uv = uv->u.open.next) ------------------ | Branch (640:28): [True: 256, False: 3.38k] ------------------ 641| 256| markobject(g, uv); /* open upvalues cannot be collected */ ------------------ | | 99| 3.64k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 256|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 256|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 126, False: 130] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 126|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 126|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 642| 3.38k| if (g->gcstate == GCSatomic) { /* final traversal? */ ------------------ | | 33| 3.38k|#define GCSatomic 2 ------------------ | Branch (642:7): [True: 1.69k, False: 1.69k] ------------------ 643| 1.69k| if (!g->gcemergency) ------------------ | Branch (643:9): [True: 1.69k, False: 0] ------------------ 644| 1.69k| luaD_shrinkstack(th); /* do not change stack in emergency cycle */ 645| 73.0k| for (o = th->top.p; o < th->stack_last.p + EXTRA_STACK; o++) ------------------ | | 142| 73.0k|#define EXTRA_STACK 5 ------------------ | Branch (645:25): [True: 71.3k, False: 1.69k] ------------------ 646| 71.3k| setnilvalue(s2v(o)); /* clear dead stack slice */ ------------------ | | 200| 71.3k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 71.3k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 647| | /* 'remarkupvals' may have removed thread from 'twups' list */ 648| 1.69k| if (!isintwups(th) && th->openupval != NULL) { ------------------ | | 22| 3.38k|#define isintwups(L) (L->twups != L) ------------------ | Branch (648:9): [True: 1.56k, False: 128] | Branch (648:27): [True: 0, False: 1.56k] ------------------ 649| 0| th->twups = g->twups; /* link it back to the list */ 650| 0| g->twups = th; 651| 0| } 652| 1.69k| } 653| 3.38k| return 1 + stacksize(th); ------------------ | | 147| 3.38k|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 3.38k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 3.38k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 654| 3.38k|} lgc.c:remarkupvals: 367| 1.69k|static int remarkupvals (global_State *g) { 368| 1.69k| lua_State *thread; 369| 1.69k| lua_State **p = &g->twups; 370| 1.69k| int work = 0; /* estimate of how much work was done here */ 371| 1.82k| while ((thread = *p) != NULL) { ------------------ | Branch (371:10): [True: 132, False: 1.69k] ------------------ 372| 132| work++; 373| 132| if (!iswhite(thread) && thread->openupval != NULL) ------------------ | | 87| 132|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 264|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (373:9): [True: 132, False: 0] | Branch (373:29): [True: 128, False: 4] ------------------ 374| 128| p = &thread->twups; /* keep marked thread with upvalues in the list */ 375| 4| else { /* thread is not marked or without upvalues */ 376| 4| UpVal *uv; 377| 4| lua_assert(!isold(thread) || thread->openupval == NULL); ------------------ | | 114| 4|#define lua_assert(c) ((void)0) ------------------ 378| 4| *p = thread->twups; /* remove thread from the list */ 379| 4| thread->twups = thread; /* mark that it is out of list */ 380| 4| for (uv = thread->openupval; uv != NULL; uv = uv->u.open.next) { ------------------ | Branch (380:36): [True: 0, False: 4] ------------------ 381| 0| lua_assert(getage(uv) <= getage(thread)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 382| 0| work++; 383| 0| if (!iswhite(uv)) { /* upvalue already visited? */ ------------------ | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (383:13): [True: 0, False: 0] ------------------ 384| 0| lua_assert(upisopen(uv) && isgray(uv)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 385| 0| markvalue(g, uv->v.p); /* mark its value */ ------------------ | | 94| 0|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 0| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 0|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 386| 0| } 387| 0| } 388| 4| } 389| 132| } 390| 1.69k| return work; 391| 1.69k|} lgc.c:convergeephemerons: 691| 3.38k|static void convergeephemerons (global_State *g) { 692| 3.38k| int changed; 693| 3.38k| int dir = 0; 694| 3.38k| do { 695| 3.38k| GCObject *w; 696| 3.38k| GCObject *next = g->ephemeron; /* get ephemeron list */ 697| 3.38k| g->ephemeron = NULL; /* tables may return to this list when traversed */ 698| 3.38k| changed = 0; 699| 3.38k| while ((w = next) != NULL) { /* for each ephemeron table */ ------------------ | Branch (699:12): [True: 0, False: 3.38k] ------------------ 700| 0| Table *h = gco2t(w); ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 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)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 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| 3.38k| dir = !dir; /* invert direction next time */ 709| 3.38k| } while (changed); /* repeat until no more changes */ ------------------ | Branch (709:12): [True: 0, False: 3.38k] ------------------ 710| 3.38k|} lgc.c:clearbyvalues: 744| 6.77k|static void clearbyvalues (global_State *g, GCObject *l, GCObject *f) { 745| 6.77k| for (; l != f; l = gco2t(l)->gclist) { ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (745:10): [True: 0, False: 6.77k] ------------------ 746| 0| Table *h = gco2t(l); ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 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) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ | 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) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ | 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| 6.77k|} lgc.c:markbeingfnz: 345| 3.38k|static lu_mem markbeingfnz (global_State *g) { 346| 3.38k| GCObject *o; 347| 3.38k| lu_mem count = 0; 348| 3.38k| for (o = g->tobefnz; o != NULL; o = o->next) { ------------------ | Branch (348:24): [True: 0, False: 3.38k] ------------------ 349| 0| count++; 350| 0| markobject(g, o); ------------------ | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 351| 0| } 352| 3.38k| return count; 353| 3.38k|} lgc.c:clearbykeys: 725| 3.38k|static void clearbykeys (global_State *g, GCObject *l) { 726| 3.38k| for (; l; l = gco2t(l)->gclist) { ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (726:10): [True: 0, False: 3.38k] ------------------ 727| 0| Table *h = gco2t(l); ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 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| 3.38k|} lgc.c:cleargraylists: 394| 1.69k|static void cleargraylists (global_State *g) { 395| 1.69k| g->gray = g->grayagain = NULL; 396| 1.69k| g->weak = g->allweak = g->ephemeron = NULL; 397| 1.69k|} lgc.c:checkSizes: 871| 1.69k|static void checkSizes (lua_State *L, global_State *g) { 872| 1.69k| if (!g->gcemergency) { ------------------ | Branch (872:7): [True: 1.69k, False: 0] ------------------ 873| 1.69k| if (g->strt.nuse < g->strt.size / 4) { /* string table too big? */ ------------------ | Branch (873:9): [True: 22, False: 1.67k] ------------------ 874| 22| l_mem olddebt = g->GCdebt; 875| 22| luaS_resize(L, g->strt.size / 2); 876| 22| g->GCestimate += g->GCdebt - olddebt; /* correct estimate */ 877| 22| } 878| 1.69k| } 879| 1.69k|} lgc.c:separatetobefnz: 974| 2.08k|static void separatetobefnz (global_State *g, int all) { 975| 2.08k| GCObject *curr; 976| 2.08k| GCObject **p = &g->finobj; 977| 2.08k| GCObject **lastnext = findlast(&g->tobefnz); 978| 2.10k| while ((curr = *p) != g->finobjold1) { /* traverse all finalizable objects */ ------------------ | Branch (978:10): [True: 16, False: 2.08k] ------------------ 979| 16| lua_assert(tofinalize(curr)); ------------------ | | 114| 16|#define lua_assert(c) ((void)0) ------------------ 980| 16| if (!(iswhite(curr) || all)) /* not being collected? */ ------------------ | | 87| 16|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 32|#define testbits(x,m) ((x) & (m)) | | | | ------------------ | | | | | Branch (62:24): [True: 16, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (980:28): [True: 0, False: 0] ------------------ 981| 0| p = &curr->next; /* don't bother with it */ 982| 16| else { 983| 16| if (curr == g->finobjsur) /* removing 'finobjsur'? */ ------------------ | Branch (983:11): [True: 0, False: 16] ------------------ 984| 0| g->finobjsur = curr->next; /* correct it */ 985| 16| *p = curr->next; /* remove 'curr' from 'finobj' list */ 986| 16| curr->next = *lastnext; /* link at the end of 'tobefnz' list */ 987| 16| *lastnext = curr; 988| 16| lastnext = &curr->next; 989| 16| } 990| 16| } 991| 2.08k|} lgc.c:findlast: 960| 2.08k|static GCObject **findlast (GCObject **p) { 961| 2.08k| while (*p != NULL) ------------------ | Branch (961:10): [True: 0, False: 2.08k] ------------------ 962| 0| p = &(*p)->next; 963| 2.08k| return p; 964| 2.08k|} lgc.c:callallpendingfinalizers: 950| 390|static void callallpendingfinalizers (lua_State *L) { 951| 390| global_State *g = G(L); ------------------ | | 335| 390|#define G(L) (L->l_G) ------------------ 952| 406| while (g->tobefnz) ------------------ | Branch (952:10): [True: 16, False: 390] ------------------ 953| 16| GCTM(L); 954| 390|} lgc.c:GCTM: 907| 16|static void GCTM (lua_State *L) { 908| 16| global_State *g = G(L); ------------------ | | 335| 16|#define G(L) (L->l_G) ------------------ 909| 16| const TValue *tm; 910| 16| TValue v; 911| 16| lua_assert(!g->gcemergency); ------------------ | | 114| 16|#define lua_assert(c) ((void)0) ------------------ 912| 16| setgcovalue(L, &v, udata2finalize(g)); ------------------ | | 310| 16| { TValue *io = (obj); GCObject *i_g=(x); \ | | 311| 16| val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); } | | ------------------ | | | | 72| 16|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); } | | ------------------ | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 913| 16| tm = luaT_gettmbyobj(L, &v, TM_GC); 914| 16| if (!notm(tm)) { /* is there a finalizer? */ ------------------ | | 61| 16|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 193| 16|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 16|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 16|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 16|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (914:7): [True: 16, False: 0] ------------------ 915| 16| int status; 916| 16| lu_byte oldah = L->allowhook; 917| 16| int oldgcstp = g->gcstp; 918| 16| g->gcstp |= GCSTPGC; /* avoid GC steps */ ------------------ | | 156| 16|#define GCSTPGC 2 /* bit true when GC stopped by itself */ ------------------ 919| 16| L->allowhook = 0; /* stop debug hooks during GC metamethod */ 920| 16| setobj2s(L, L->top.p++, tm); /* push finalizer... */ ------------------ | | 131| 16|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 16| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 16| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 16| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 16| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 16|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 16| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 16|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 921| 16| setobj2s(L, L->top.p++, &v); /* ... and its argument */ ------------------ | | 131| 16|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 16| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 16| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 16| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 16| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 16|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 16| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 16|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 922| 16| L->ci->callstatus |= CIST_FIN; /* will run a finalizer */ ------------------ | | 217| 16|#define CIST_FIN (1<<7) /* function "called" a finalizer */ ------------------ 923| 16| status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top.p - 2), 0); ------------------ | | 36| 16|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 16|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 16|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 16|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 16|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 924| 16| L->ci->callstatus &= ~CIST_FIN; /* not running a finalizer anymore */ ------------------ | | 217| 16|#define CIST_FIN (1<<7) /* function "called" a finalizer */ ------------------ 925| 16| L->allowhook = oldah; /* restore hooks */ 926| 16| g->gcstp = oldgcstp; /* restore state */ 927| 16| if (l_unlikely(status != LUA_OK)) { /* error while running __gc? */ ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 928| 0| luaE_warnerror(L, "__gc"); 929| 0| L->top.p--; /* pops error object */ 930| 0| } 931| 16| } 932| 16|} lgc.c:udata2finalize: 886| 16|static GCObject *udata2finalize (global_State *g) { 887| 16| GCObject *o = g->tobefnz; /* get first element */ 888| 16| lua_assert(tofinalize(o)); ------------------ | | 114| 16|#define lua_assert(c) ((void)0) ------------------ 889| 16| g->tobefnz = o->next; /* remove it from 'tobefnz' list */ 890| 16| o->next = g->allgc; /* return it to 'allgc' list */ 891| 16| g->allgc = o; 892| 16| resetbit(o->marked, FINALIZEDBIT); /* object is "normal" again */ ------------------ | | 66| 16|#define resetbit(x,b) resetbits(x, bitmask(b)) | | ------------------ | | | | 60| 16|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 16|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 16|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 893| 16| if (issweepphase(g)) ------------------ | | 43| 16| (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 34| 16|#define GCSswpallgc 3 | | ------------------ | | (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 37| 16|#define GCSswpend 6 | | ------------------ | | | Branch (43:3): [True: 16, False: 0] | | | Branch (43:34): [True: 0, False: 16] | | ------------------ ------------------ 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| 16| else if (getage(o) == G_OLD1) ------------------ | | 116| 16|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 114| 16|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ else if (getage(o) == G_OLD1) ------------------ | | 109| 16|#define G_OLD1 3 /* first full cycle as old */ ------------------ | Branch (895:12): [True: 0, False: 16] ------------------ 896| 0| g->firstold1 = o; /* it is the first OLD1 object in the list */ 897| 16| return o; 898| 16|} lgc.c:dothecall: 901| 16|static void dothecall (lua_State *L, void *ud) { 902| 16| UNUSED(ud); ------------------ | | 131| 16|#define UNUSED(x) ((void)(x)) ------------------ 903| 16| luaD_callnoyield(L, L->top.p - 2, 0); 904| 16|} lgc.c:deletelist: 1498| 780|static void deletelist (lua_State *L, GCObject *p, GCObject *limit) { 1499| 66.0k| while (p != limit) { ------------------ | Branch (1499:10): [True: 65.2k, False: 780] ------------------ 1500| 65.2k| GCObject *next = p->next; 1501| 65.2k| freeobj(L, p); 1502| 65.2k| p = next; 1503| 65.2k| } 1504| 780|} lgc.c:singlestep: 1585| 57.8k|static lu_mem singlestep (lua_State *L) { 1586| 57.8k| global_State *g = G(L); ------------------ | | 335| 57.8k|#define G(L) (L->l_G) ------------------ 1587| 57.8k| lu_mem work; 1588| 57.8k| lua_assert(!g->gcstopem); /* collector is not reentrant */ ------------------ | | 114| 57.8k|#define lua_assert(c) ((void)0) ------------------ 1589| 57.8k| g->gcstopem = 1; /* no emergency collections while collecting */ 1590| 57.8k| switch (g->gcstate) { 1591| 1.69k| case GCSpause: { ------------------ | | 39| 1.69k|#define GCSpause 8 ------------------ | Branch (1591:5): [True: 1.69k, False: 56.1k] ------------------ 1592| 1.69k| restartcollection(g); 1593| 1.69k| g->gcstate = GCSpropagate; ------------------ | | 31| 1.69k|#define GCSpropagate 0 ------------------ 1594| 1.69k| work = 1; 1595| 1.69k| break; 1596| 0| } 1597| 35.3k| case GCSpropagate: { ------------------ | | 31| 35.3k|#define GCSpropagate 0 ------------------ | Branch (1597:5): [True: 35.3k, False: 22.5k] ------------------ 1598| 35.3k| if (g->gray == NULL) { /* no more gray objects? */ ------------------ | Branch (1598:11): [True: 1.69k, False: 33.6k] ------------------ 1599| 1.69k| g->gcstate = GCSenteratomic; /* finish propagate phase */ ------------------ | | 32| 1.69k|#define GCSenteratomic 1 ------------------ 1600| 1.69k| work = 0; 1601| 1.69k| } 1602| 33.6k| else 1603| 33.6k| work = propagatemark(g); /* traverse one gray object */ 1604| 35.3k| break; 1605| 0| } 1606| 1.69k| case GCSenteratomic: { ------------------ | | 32| 1.69k|#define GCSenteratomic 1 ------------------ | Branch (1606:5): [True: 1.69k, False: 56.1k] ------------------ 1607| 1.69k| work = atomic(L); /* work is what was traversed by 'atomic' */ 1608| 1.69k| entersweep(L); 1609| 1.69k| g->GCestimate = gettotalbytes(g); /* first estimate */ ------------------ | | 394| 1.69k|#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) | | ------------------ | | | | 136| 1.69k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1610| 1.69k| break; 1611| 0| } 1612| 8.96k| case GCSswpallgc: { /* sweep "regular" objects */ ------------------ | | 34| 8.96k|#define GCSswpallgc 3 ------------------ | Branch (1612:5): [True: 8.96k, False: 48.8k] ------------------ 1613| 8.96k| work = sweepstep(L, g, GCSswpfinobj, &g->finobj); ------------------ | | 35| 8.96k|#define GCSswpfinobj 4 ------------------ 1614| 8.96k| break; 1615| 0| } 1616| 3.38k| case GCSswpfinobj: { /* sweep objects with finalizers */ ------------------ | | 35| 3.38k|#define GCSswpfinobj 4 ------------------ | Branch (1616:5): [True: 3.38k, False: 54.4k] ------------------ 1617| 3.38k| work = sweepstep(L, g, GCSswptobefnz, &g->tobefnz); ------------------ | | 36| 3.38k|#define GCSswptobefnz 5 ------------------ 1618| 3.38k| break; 1619| 0| } 1620| 3.38k| case GCSswptobefnz: { /* sweep objects to be finalized */ ------------------ | | 36| 3.38k|#define GCSswptobefnz 5 ------------------ | Branch (1620:5): [True: 3.38k, False: 54.4k] ------------------ 1621| 3.38k| work = sweepstep(L, g, GCSswpend, NULL); ------------------ | | 37| 3.38k|#define GCSswpend 6 ------------------ 1622| 3.38k| break; 1623| 0| } 1624| 1.69k| case GCSswpend: { /* finish sweeps */ ------------------ | | 37| 1.69k|#define GCSswpend 6 ------------------ | Branch (1624:5): [True: 1.69k, False: 56.1k] ------------------ 1625| 1.69k| checkSizes(L, g); 1626| 1.69k| g->gcstate = GCScallfin; ------------------ | | 38| 1.69k|#define GCScallfin 7 ------------------ 1627| 1.69k| work = 0; 1628| 1.69k| break; 1629| 0| } 1630| 1.69k| case GCScallfin: { /* call remaining finalizers */ ------------------ | | 38| 1.69k|#define GCScallfin 7 ------------------ | Branch (1630:5): [True: 1.69k, False: 56.1k] ------------------ 1631| 1.69k| if (g->tobefnz && !g->gcemergency) { ------------------ | Branch (1631:11): [True: 0, False: 1.69k] | 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.69k| else { /* emergency mode or no more finalizers */ 1636| 1.69k| g->gcstate = GCSpause; /* finish collection */ ------------------ | | 39| 1.69k|#define GCSpause 8 ------------------ 1637| 1.69k| work = 0; 1638| 1.69k| } 1639| 1.69k| break; 1640| 0| } 1641| 0| default: lua_assert(0); return 0; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (1641:5): [True: 0, False: 57.8k] ------------------ 1642| 57.8k| } 1643| 57.8k| g->gcstopem = 0; 1644| 57.8k| return work; 1645| 57.8k|} lgc.c:restartcollection: 403| 1.69k|static void restartcollection (global_State *g) { 404| 1.69k| cleargraylists(g); 405| 1.69k| markobject(g, g->mainthread); ------------------ | | 99| 1.69k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 1.69k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 1.69k|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 1.69k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 1.69k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 1.69k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 406| 1.69k| markvalue(g, &g->l_registry); ------------------ | | 94| 1.69k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 1.69k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 1.69k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 1.69k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 1.69k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 1.69k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 3.38k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 1.69k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 1.69k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 1.69k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 1.69k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 1.69k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 1.69k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 1.69k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 1.69k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 407| 1.69k| markmt(g); 408| 1.69k| markbeingfnz(g); /* mark any finalizing object left from previous cycle */ 409| 1.69k|} lgc.c:entersweep: 1486| 1.69k|static void entersweep (lua_State *L) { 1487| 1.69k| global_State *g = G(L); ------------------ | | 335| 1.69k|#define G(L) (L->l_G) ------------------ 1488| 1.69k| g->gcstate = GCSswpallgc; ------------------ | | 34| 1.69k|#define GCSswpallgc 3 ------------------ 1489| 1.69k| lua_assert(g->sweepgc == NULL); ------------------ | | 114| 1.69k|#define lua_assert(c) ((void)0) ------------------ 1490| 1.69k| g->sweepgc = sweeptolive(L, &g->allgc); 1491| 1.69k|} lgc.c:sweepstep: 1569| 15.7k| int nextstate, GCObject **nextlist) { 1570| 15.7k| if (g->sweepgc) { ------------------ | Branch (1570:7): [True: 10.6k, False: 5.08k] ------------------ 1571| 10.6k| l_mem olddebt = g->GCdebt; 1572| 10.6k| int count; 1573| 10.6k| g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX, &count); ------------------ | | 35| 10.6k|#define GCSWEEPMAX 100 ------------------ 1574| 10.6k| g->GCestimate += g->GCdebt - olddebt; /* update estimate */ 1575| 10.6k| return count; 1576| 10.6k| } 1577| 5.08k| else { /* enter next state */ 1578| 5.08k| g->gcstate = nextstate; 1579| 5.08k| g->sweepgc = nextlist; 1580| 5.08k| return 0; /* no work done */ 1581| 5.08k| } 1582| 15.7k|} lgc.c:setpause: 1059| 1.69k|static void setpause (global_State *g) { 1060| 1.69k| l_mem threshold, debt; 1061| 1.69k| int pause = getgcparam(g->gcpause); ------------------ | | 135| 1.69k|#define getgcparam(p) ((p) * 4) ------------------ 1062| 1.69k| l_mem estimate = g->GCestimate / PAUSEADJ; /* adjust 'estimate' */ ------------------ | | 60| 1.69k|#define PAUSEADJ 100 ------------------ 1063| 1.69k| lua_assert(estimate > 0); ------------------ | | 114| 1.69k|#define lua_assert(c) ((void)0) ------------------ 1064| 1.69k| threshold = (pause < MAX_LMEM / estimate) /* overflow? */ ------------------ | | 50| 1.69k|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 1.69k|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ | Branch (1064:15): [True: 1.69k, False: 0] ------------------ 1065| 1.69k| ? estimate * pause /* no overflow */ 1066| 1.69k| : MAX_LMEM; /* overflow; truncate to maximum */ ------------------ | | 50| 1.69k|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 0|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ 1067| 1.69k| debt = gettotalbytes(g) - threshold; ------------------ | | 394| 1.69k|#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) | | ------------------ | | | | 136| 1.69k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1068| 1.69k| if (debt > 0) debt = 0; ------------------ | Branch (1068:7): [True: 0, False: 1.69k] ------------------ 1069| 1.69k| luaE_setdebt(g, debt); 1070| 1.69k|} lgc.c:incstep: 1667| 1.69k|static void incstep (lua_State *L, global_State *g) { 1668| 1.69k| int stepmul = (getgcparam(g->gcstepmul) | 1); /* avoid division by 0 */ ------------------ | | 135| 1.69k|#define getgcparam(p) ((p) * 4) ------------------ 1669| 1.69k| l_mem debt = (g->GCdebt / WORK2MEM) * stepmul; ------------------ | | 53| 1.69k|#define WORK2MEM sizeof(TValue) ------------------ 1670| 1.69k| l_mem stepsize = (g->gcstepsize <= log2maxs(l_mem)) ------------------ | | 60| 1.69k|#define log2maxs(t) (sizeof(t) * 8 - 2) ------------------ | Branch (1670:20): [True: 1.69k, False: 0] ------------------ 1671| 1.69k| ? ((cast(l_mem, 1) << g->gcstepsize) / WORK2MEM) * stepmul ------------------ | | 136| 1.69k|#define cast(t, exp) ((t)(exp)) ------------------ ? ((cast(l_mem, 1) << g->gcstepsize) / WORK2MEM) * stepmul ------------------ | | 53| 1.69k|#define WORK2MEM sizeof(TValue) ------------------ 1672| 1.69k| : MAX_LMEM; /* overflow; keep maximum value */ ------------------ | | 50| 1.69k|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 0|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ 1673| 57.8k| do { /* repeat until pause or enough "credit" (negative debt) */ 1674| 57.8k| lu_mem work = singlestep(L); /* perform one single step */ 1675| 57.8k| debt -= work; 1676| 57.8k| } while (debt > -stepsize && g->gcstate != GCSpause); ------------------ | | 39| 57.8k|#define GCSpause 8 ------------------ | Branch (1676:12): [True: 57.8k, False: 0] | Branch (1676:32): [True: 56.1k, False: 1.69k] ------------------ 1677| 1.69k| if (g->gcstate == GCSpause) ------------------ | | 39| 1.69k|#define GCSpause 8 ------------------ | Branch (1677:7): [True: 1.69k, False: 0] ------------------ 1678| 1.69k| setpause(g); /* pause until next cycle */ 1679| 0| else { 1680| 0| debt = (debt / stepmul) * WORK2MEM; /* convert 'work units' to bytes */ ------------------ | | 53| 0|#define WORK2MEM sizeof(TValue) ------------------ 1681| 0| luaE_setdebt(g, debt); 1682| 0| } 1683| 1.69k|} luaX_init: 70| 390|void luaX_init (lua_State *L) { 71| 390| int i; 72| 390| TString *e = luaS_newliteral(L, LUA_ENV); /* create env name */ ------------------ | | 28| 390|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 390| (sizeof(s)/sizeof(char))-1)) ------------------ 73| 390| luaC_fix(L, obj2gco(e)); /* never collect this name */ ------------------ | | 390| 390|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 390|#define check_exp(c,e) (e) | | ------------------ ------------------ 74| 8.97k| for (i=0; itt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 8.58k|#define check_exp(c,e) (e) | | ------------------ ------------------ 77| 8.58k| ts->extra = cast_byte(i+1); /* reserved word */ ------------------ | | 143| 8.58k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 8.58k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 78| 8.58k| } 79| 390|} luaX_token2str: 82| 291|const char *luaX_token2str (LexState *ls, int token) { 83| 291| if (token < FIRST_RESERVED) { /* single-byte symbols? */ ------------------ | | 20| 291|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ | Branch (83:7): [True: 205, False: 86] ------------------ 84| 205| if (lisprint(token)) ------------------ | | 61| 205|#define lisprint(c) testprop(c, MASK(PRINTBIT)) | | ------------------ | | | | 52| 205|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 132, False: 73] | | | | ------------------ | | ------------------ ------------------ 85| 132| return luaO_pushfstring(ls->L, "'%c'", token); 86| 73| else /* control character */ 87| 73| return luaO_pushfstring(ls->L, "'<\\%d>'", token); 88| 205| } 89| 86| else { 90| 86| const char *s = luaX_tokens[token - FIRST_RESERVED]; ------------------ | | 20| 86|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ 91| 86| if (token < TK_EOS) /* fixed format (symbols and reserved words)? */ ------------------ | Branch (91:9): [True: 40, False: 46] ------------------ 92| 40| return luaO_pushfstring(ls->L, "'%s'", s); 93| 46| else /* names, strings, and numerals */ 94| 46| return s; 95| 86| } 96| 291|} luaX_syntaxerror: 119| 208|l_noret luaX_syntaxerror (LexState *ls, const char *msg) { 120| 208| lexerror(ls, msg, ls->t.token); 121| 208|} luaX_newstring: 134| 13.5M|TString *luaX_newstring (LexState *ls, const char *str, size_t l) { 135| 13.5M| lua_State *L = ls->L; 136| 13.5M| TString *ts = luaS_newlstr(L, str, l); /* create new string */ 137| 13.5M| const TValue *o = luaH_getstr(ls->h, ts); 138| 13.5M| if (!ttisnil(o)) /* string already present? */ ------------------ | | 193| 13.5M|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 13.5M|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 13.5M|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 13.5M|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (138:7): [True: 13.5M, False: 22.5k] ------------------ 139| 13.5M| ts = keystrval(nodefromval(o)); /* get saved copy */ ------------------ | | 760| 13.5M|#define keystrval(node) (gco2ts(keyval(node).gc)) | | ------------------ | | | | 374| 13.5M| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | | | ------------------ | | | | | | 115| 13.5M|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 140| 22.5k| else { /* not in use yet */ 141| 22.5k| TValue *stv = s2v(L->top.p++); /* reserve stack space for string */ ------------------ | | 172| 22.5k|#define s2v(o) (&(o)->val) ------------------ 142| 22.5k| setsvalue(L, stv, ts); /* temporarily anchor the string */ ------------------ | | 372| 22.5k| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 22.5k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 22.5k|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 22.5k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 22.5k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 22.5k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 22.5k| checkliveness(L,io); } | | ------------------ | | | | 107| 22.5k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 22.5k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 22.5k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 143| 22.5k| 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| 22.5k| luaC_checkGC(L); ------------------ | | 172| 22.5k|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 22.5k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 22.5k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 1.42k, False: 21.0k] | | | | ------------------ | | | | 169| 22.5k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 22.5k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 146| 22.5k| L->top.p--; /* remove string from stack */ 147| 22.5k| } 148| 13.5M| return ts; 149| 13.5M|} luaX_setinput: 168| 390| int firstchar) { 169| 390| ls->t.token = 0; 170| 390| ls->L = L; 171| 390| ls->current = firstchar; 172| 390| ls->lookahead.token = TK_EOS; /* no look-ahead token */ 173| 390| ls->z = z; 174| 390| ls->fs = NULL; 175| 390| ls->linenumber = 1; 176| 390| ls->lastline = 1; 177| 390| ls->source = source; 178| 390| ls->envn = luaS_newliteral(L, LUA_ENV); /* get env name */ ------------------ | | 28| 390|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 390| (sizeof(s)/sizeof(char))-1)) ------------------ 179| 390| luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */ ------------------ | | 40| 390| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | ------------------ | | | | 53| 390| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | ------------------ | | | | | | 146| 390|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 41| 390| (buff)->buffsize, size), \ | | 42| 390| (buff)->buffsize = size) ------------------ 180| 390|} luaX_next: 565| 27.4M|void luaX_next (LexState *ls) { 566| 27.4M| ls->lastline = ls->linenumber; 567| 27.4M| if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */ ------------------ | Branch (567:7): [True: 134, False: 27.4M] ------------------ 568| 134| ls->t = ls->lookahead; /* use this one */ 569| 134| ls->lookahead.token = TK_EOS; /* and discharge it */ 570| 134| } 571| 27.4M| else 572| 27.4M| ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */ 573| 27.4M|} luaX_lookahead: 576| 134|int luaX_lookahead (LexState *ls) { 577| 134| lua_assert(ls->lookahead.token == TK_EOS); ------------------ | | 114| 134|#define lua_assert(c) ((void)0) ------------------ 578| 134| ls->lookahead.token = llex(ls, &ls->lookahead.seminfo); 579| 134| return ls->lookahead.token; 580| 134|} llex.c:lexerror: 111| 321|static l_noret lexerror (LexState *ls, const char *msg, int token) { 112| 321| msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber); 113| 321| if (token) ------------------ | Branch (113:7): [True: 300, False: 21] ------------------ 114| 300| luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token)); 115| 321| luaD_throw(ls->L, LUA_ERRSYNTAX); ------------------ | | 51| 321|#define LUA_ERRSYNTAX 3 ------------------ 116| 321|} llex.c:txtToken: 99| 300|static const char *txtToken (LexState *ls, int token) { 100| 300| switch (token) { 101| 72| case TK_NAME: case TK_STRING: ------------------ | Branch (101:5): [True: 12, False: 288] | Branch (101:19): [True: 60, False: 240] ------------------ 102| 115| case TK_FLT: case TK_INT: ------------------ | Branch (102:5): [True: 39, False: 261] | Branch (102:18): [True: 4, False: 296] ------------------ 103| 115| save(ls, '\0'); 104| 115| return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff)); ------------------ | | 31| 115|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 105| 185| default: ------------------ | Branch (105:5): [True: 185, False: 115] ------------------ 106| 185| return luaX_token2str(ls, token); 107| 300| } 108| 300|} llex.c:save: 57| 45.9M|static void save (LexState *ls, int c) { 58| 45.9M| Mbuffer *b = ls->buff; 59| 45.9M| if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { ------------------ | | 33| 45.9M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { ------------------ | | 32| 45.9M|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ | Branch (59:7): [True: 1.73k, False: 45.9M] ------------------ 60| 1.73k| size_t newsize; 61| 1.73k| if (luaZ_sizebuffer(b) >= MAX_SIZE/2) ------------------ | | 32| 1.73k|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ if (luaZ_sizebuffer(b) >= MAX_SIZE/2) ------------------ | | 44| 1.73k|#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.73k| : (size_t)(LUA_MAXINTEGER)) | | ------------------ | | | | 554| 1.73k|#define LUA_MAXINTEGER LLONG_MAX | | ------------------ ------------------ | Branch (61:9): [True: 0, False: 1.73k] ------------------ 62| 0| lexerror(ls, "lexical element too long", 0); 63| 1.73k| newsize = luaZ_sizebuffer(b) * 2; ------------------ | | 32| 1.73k|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ 64| 1.73k| luaZ_resizebuffer(ls->L, b, newsize); ------------------ | | 40| 1.73k| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | ------------------ | | | | 53| 1.73k| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | ------------------ | | | | | | 146| 1.73k|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 136| 1.73k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 41| 1.73k| (buff)->buffsize, size), \ | | 42| 1.73k| (buff)->buffsize = size) ------------------ 65| 1.73k| } 66| 45.9M| b->buffer[luaZ_bufflen(b)++] = cast_char(c); ------------------ | | 33| 45.9M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ b->buffer[luaZ_bufflen(b)++] = cast_char(c); ------------------ | | 145| 45.9M|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 136| 45.9M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 67| 45.9M|} llex.c:llex: 445| 27.4M|static int llex (LexState *ls, SemInfo *seminfo) { 446| 27.4M| luaZ_resetbuffer(ls->buff); ------------------ | | 36| 27.4M|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 447| 27.8M| for (;;) { 448| 27.8M| switch (ls->current) { 449| 220k| case '\n': case '\r': { /* line breaks */ ------------------ | Branch (449:7): [True: 99.3k, False: 27.7M] | Branch (449:18): [True: 120k, False: 27.7M] ------------------ 450| 220k| inclinenumber(ls); 451| 220k| break; 452| 99.3k| } 453| 131k| case ' ': case '\f': case '\t': case '\v': { /* spaces */ ------------------ | Branch (453:7): [True: 26.8k, False: 27.8M] | Branch (453:17): [True: 7.54k, False: 27.8M] | Branch (453:28): [True: 83.1k, False: 27.7M] | Branch (453:39): [True: 14.1k, False: 27.8M] ------------------ 454| 131k| next(ls); ------------------ | | 32| 131k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 131k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 131k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 131k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 131k, False: 1] | | | | ------------------ | | ------------------ ------------------ 455| 131k| break; 456| 117k| } 457| 254k| case '-': { /* '-' or '--' (comment) */ ------------------ | Branch (457:7): [True: 254k, False: 27.5M] ------------------ 458| 254k| next(ls); ------------------ | | 32| 254k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 254k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 254k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 254k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 254k, False: 0] | | | | ------------------ | | ------------------ ------------------ 459| 254k| if (ls->current != '-') return '-'; ------------------ | Branch (459:13): [True: 213k, False: 41.3k] ------------------ 460| | /* else is a comment */ 461| 41.3k| next(ls); ------------------ | | 32| 41.3k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 41.3k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 41.3k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 41.3k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 41.3k, False: 3] | | | | ------------------ | | ------------------ ------------------ 462| 41.3k| if (ls->current == '[') { /* long comment? */ ------------------ | Branch (462:13): [True: 17, False: 41.3k] ------------------ 463| 17| size_t sep = skip_sep(ls); 464| 17| luaZ_resetbuffer(ls->buff); /* 'skip_sep' may dirty the buffer */ ------------------ | | 36| 17|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 465| 17| if (sep >= 2) { ------------------ | Branch (465:15): [True: 3, False: 14] ------------------ 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| 17| } 471| | /* else short comment */ 472| 5.57M| while (!currIsNewline(ls) && ls->current != EOZ) ------------------ | | 36| 11.1M|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 16.9k, False: 5.55M] | | | Branch (36:51): [True: 24.3k, False: 5.53M] | | ------------------ ------------------ while (!currIsNewline(ls) && ls->current != EOZ) ------------------ | | 16| 5.53M|#define EOZ (-1) /* end of stream */ ------------------ | Branch (472:38): [True: 5.53M, False: 17] ------------------ 473| 5.53M| next(ls); /* skip until end of line (or end of file) */ ------------------ | | 32| 5.57M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 5.53M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 5.53M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 5.53M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 5.53M, False: 14] | | | | ------------------ | | ------------------ ------------------ 474| 41.3k| break; 475| 41.3k| } 476| 227k| case '[': { /* long string or simply '[' */ ------------------ | Branch (476:7): [True: 227k, False: 27.6M] ------------------ 477| 227k| size_t sep = skip_sep(ls); 478| 227k| if (sep >= 2) { ------------------ | Branch (478:13): [True: 204k, False: 23.3k] ------------------ 479| 204k| read_long_string(ls, seminfo, sep); 480| 204k| return TK_STRING; 481| 204k| } 482| 23.3k| else if (sep == 0) /* '[=...' missing second bracket? */ ------------------ | Branch (482:18): [True: 0, False: 23.3k] ------------------ 483| 0| lexerror(ls, "invalid long string delimiter", TK_STRING); 484| 23.3k| return '['; 485| 227k| } 486| 32.3k| case '=': { ------------------ | Branch (486:7): [True: 32.3k, False: 27.7M] ------------------ 487| 32.3k| next(ls); ------------------ | | 32| 32.3k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 32.3k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 32.3k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 32.3k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 32.3k, False: 0] | | | | ------------------ | | ------------------ ------------------ 488| 32.3k| if (check_next1(ls, '=')) return TK_EQ; /* '==' */ ------------------ | Branch (488:13): [True: 5.25k, False: 27.1k] ------------------ 489| 27.1k| else return '='; 490| 32.3k| } 491| 6.76M| case '<': { ------------------ | Branch (491:7): [True: 6.76M, False: 21.0M] ------------------ 492| 6.76M| next(ls); ------------------ | | 32| 6.76M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 6.76M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 6.76M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 6.76M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 6.76M, False: 0] | | | | ------------------ | | ------------------ ------------------ 493| 6.76M| if (check_next1(ls, '=')) return TK_LE; /* '<=' */ ------------------ | Branch (493:13): [True: 10.7k, False: 6.75M] ------------------ 494| 6.75M| else if (check_next1(ls, '<')) return TK_SHL; /* '<<' */ ------------------ | Branch (494:18): [True: 354k, False: 6.39M] ------------------ 495| 6.39M| else return '<'; 496| 6.76M| } 497| 60.0k| case '>': { ------------------ | Branch (497:7): [True: 60.0k, False: 27.7M] ------------------ 498| 60.0k| next(ls); ------------------ | | 32| 60.0k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 60.0k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 60.0k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 60.0k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 60.0k, False: 0] | | | | ------------------ | | ------------------ ------------------ 499| 60.0k| if (check_next1(ls, '=')) return TK_GE; /* '>=' */ ------------------ | Branch (499:13): [True: 1.16k, False: 58.8k] ------------------ 500| 58.8k| else if (check_next1(ls, '>')) return TK_SHR; /* '>>' */ ------------------ | Branch (500:18): [True: 6.54k, False: 52.3k] ------------------ 501| 52.3k| else return '>'; 502| 60.0k| } 503| 5.25M| case '/': { ------------------ | Branch (503:7): [True: 5.25M, False: 22.5M] ------------------ 504| 5.25M| next(ls); ------------------ | | 32| 5.25M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 5.25M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 5.25M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 5.25M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 5.25M, False: 3] | | | | ------------------ | | ------------------ ------------------ 505| 5.25M| if (check_next1(ls, '/')) return TK_IDIV; /* '//' */ ------------------ | Branch (505:13): [True: 33.7k, False: 5.21M] ------------------ 506| 5.21M| else return '/'; 507| 5.25M| } 508| 161k| case '~': { ------------------ | Branch (508:7): [True: 161k, False: 27.6M] ------------------ 509| 161k| next(ls); ------------------ | | 32| 161k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 161k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 161k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 161k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 161k, False: 0] | | | | ------------------ | | ------------------ ------------------ 510| 161k| if (check_next1(ls, '=')) return TK_NE; /* '~=' */ ------------------ | Branch (510:13): [True: 5.21k, False: 156k] ------------------ 511| 156k| else return '~'; 512| 161k| } 513| 1.73k| case ':': { ------------------ | Branch (513:7): [True: 1.73k, False: 27.8M] ------------------ 514| 1.73k| next(ls); ------------------ | | 32| 1.73k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 1.73k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 1.73k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 1.73k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 1.73k, False: 0] | | | | ------------------ | | ------------------ ------------------ 515| 1.73k| if (check_next1(ls, ':')) return TK_DBCOLON; /* '::' */ ------------------ | Branch (515:13): [True: 550, False: 1.18k] ------------------ 516| 1.18k| else return ':'; 517| 1.73k| } 518| 200k| case '"': case '\'': { /* short literal strings */ ------------------ | Branch (518:7): [True: 163k, False: 27.6M] | Branch (518:17): [True: 36.9k, False: 27.7M] ------------------ 519| 200k| read_string(ls, ls->current, seminfo); 520| 200k| return TK_STRING; 521| 163k| } 522| 28.3k| case '.': { /* '.', '..', '...', or number */ ------------------ | Branch (522:7): [True: 28.3k, False: 27.8M] ------------------ 523| 28.3k| save_and_next(ls); ------------------ | | 51| 28.3k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 28.3k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 28.3k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 28.3k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 28.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 28.3k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 524| 28.3k| if (check_next1(ls, '.')) { ------------------ | Branch (524:13): [True: 20.0k, False: 8.23k] ------------------ 525| 20.0k| if (check_next1(ls, '.')) ------------------ | Branch (525:15): [True: 1.30k, False: 18.7k] ------------------ 526| 1.30k| return TK_DOTS; /* '...' */ 527| 18.7k| else return TK_CONCAT; /* '..' */ 528| 20.0k| } 529| 8.23k| else if (!lisdigit(ls->current)) return '.'; ------------------ | | 59| 8.23k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 8.23k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ | Branch (529:18): [True: 5.06k, False: 3.17k] ------------------ 530| 3.17k| else return read_numeral(ls, seminfo); 531| 28.3k| } 532| 250k| case '0': case '1': case '2': case '3': case '4': ------------------ | Branch (532:7): [True: 58.4k, False: 27.7M] | Branch (532:17): [True: 109k, False: 27.7M] | Branch (532:27): [True: 54.1k, False: 27.7M] | Branch (532:37): [True: 18.7k, False: 27.8M] | Branch (532:47): [True: 9.45k, False: 27.8M] ------------------ 533| 346k| case '5': case '6': case '7': case '8': case '9': { ------------------ | Branch (533:7): [True: 36.3k, False: 27.7M] | Branch (533:17): [True: 15.5k, False: 27.8M] | Branch (533:27): [True: 3.29k, False: 27.8M] | Branch (533:37): [True: 18.8k, False: 27.8M] | Branch (533:47): [True: 21.6k, False: 27.8M] ------------------ 534| 346k| return read_numeral(ls, seminfo); 535| 324k| } 536| 93| case EOZ: { ------------------ | | 16| 93|#define EOZ (-1) /* end of stream */ ------------------ | Branch (536:7): [True: 93, False: 27.8M] ------------------ 537| 93| return TK_EOS; 538| 324k| } 539| 14.1M| default: { ------------------ | Branch (539:7): [True: 14.1M, False: 13.6M] ------------------ 540| 14.1M| if (lislalpha(ls->current)) { /* identifier or reserved word? */ ------------------ | | 57| 14.1M|#define lislalpha(c) testprop(c, MASK(ALPHABIT)) | | ------------------ | | | | 52| 14.1M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 13.1M, False: 997k] | | | | ------------------ | | ------------------ ------------------ 541| 13.1M| TString *ts; 542| 20.9M| do { 543| 20.9M| save_and_next(ls); ------------------ | | 51| 20.9M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 20.9M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 20.9M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 20.9M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 20.9M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 20.9M, False: 32] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 544| 20.9M| } while (lislalnum(ls->current)); ------------------ | | 58| 20.9M|#define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT))) | | ------------------ | | | | 52| 20.9M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 7.75M, False: 13.1M] | | | | ------------------ | | ------------------ ------------------ 545| 13.1M| ts = luaX_newstring(ls, luaZ_buffer(ls->buff), ------------------ | | 31| 13.1M|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 546| 13.1M| luaZ_bufflen(ls->buff)); ------------------ | | 33| 13.1M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ 547| 13.1M| seminfo->ts = ts; 548| 13.1M| if (isreserved(ts)) /* reserved word? */ ------------------ | | 35| 13.1M|#define isreserved(s) ((s)->tt == LUA_VSHRSTR && (s)->extra > 0) | | ------------------ | | | | 360| 13.1M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | ------------------ | | | | | | 42| 26.3M|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (35:24): [True: 13.1M, False: 1.19k] | | | Branch (35:50): [True: 370k, False: 12.7M] | | ------------------ ------------------ 549| 370k| return ts->extra - 1 + FIRST_RESERVED; ------------------ | | 20| 370k|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ 550| 12.7M| else { 551| 12.7M| return TK_NAME; 552| 12.7M| } 553| 13.1M| } 554| 997k| else { /* single-char tokens ('+', '*', '%', '{', '}', ...) */ 555| 997k| int c = ls->current; 556| 997k| next(ls); ------------------ | | 32| 997k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 997k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 997k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 997k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 997k, False: 2] | | | | ------------------ | | ------------------ ------------------ 557| 997k| return c; 558| 997k| } 559| 14.1M| } 560| 27.8M| } 561| 27.8M| } 562| 27.4M|} llex.c:inclinenumber: 156| 1.97M|static void inclinenumber (LexState *ls) { 157| 1.97M| int old = ls->current; 158| 1.97M| lua_assert(currIsNewline(ls)); ------------------ | | 114| 1.97M|#define lua_assert(c) ((void)0) ------------------ 159| 1.97M| next(ls); /* skip '\n' or '\r' */ ------------------ | | 32| 1.97M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 1.97M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 1.97M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 1.97M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 1.97M, False: 2] | | | | ------------------ | | ------------------ ------------------ 160| 1.97M| if (currIsNewline(ls) && ls->current != old) ------------------ | | 36| 3.95M|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 116k, False: 1.85M] | | | Branch (36:51): [True: 1.52M, False: 329k] | | ------------------ ------------------ | Branch (160:28): [True: 80.0k, False: 1.56M] ------------------ 161| 80.0k| next(ls); /* skip '\n\r' or '\r\n' */ ------------------ | | 32| 80.0k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 80.0k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 80.0k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 80.0k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 80.0k, False: 0] | | | | ------------------ | | ------------------ ------------------ 162| 1.97M| if (++ls->linenumber >= MAX_INT) ------------------ | | 53| 1.97M|#define MAX_INT INT_MAX /* maximum value of an int */ ------------------ | Branch (162:7): [True: 0, False: 1.97M] ------------------ 163| 0| lexerror(ls, "chunk has too many lines", 0); 164| 1.97M|} llex.c:skip_sep: 265| 441k|static size_t skip_sep (LexState *ls) { 266| 441k| size_t count = 0; 267| 441k| int s = ls->current; 268| 441k| lua_assert(s == '[' || s == ']'); ------------------ | | 114| 441k|#define lua_assert(c) ((void)0) ------------------ 269| 441k| save_and_next(ls); ------------------ | | 51| 441k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 441k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 441k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 441k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 441k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 441k, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 270| 442k| while (ls->current == '=') { ------------------ | Branch (270:10): [True: 602, False: 441k] ------------------ 271| 602| save_and_next(ls); ------------------ | | 51| 602|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 602|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 602|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 602|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 602|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 602, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 272| 602| count++; 273| 602| } 274| 441k| return (ls->current == s) ? count + 2 ------------------ | Branch (274:10): [True: 408k, False: 32.6k] ------------------ 275| 441k| : (count == 0) ? 1 ------------------ | Branch (275:12): [True: 32.0k, False: 602] ------------------ 276| 32.6k| : 0; 277| 441k|} llex.c:read_long_string: 280| 204k|static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) { 281| 204k| int line = ls->linenumber; /* initial line (for error message) */ 282| 204k| save_and_next(ls); /* skip 2nd '[' */ ------------------ | | 51| 204k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 204k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 204k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 204k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 204k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 204k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 283| 204k| if (currIsNewline(ls)) /* string starts with a newline? */ ------------------ | | 36| 204k|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 180k, False: 24.3k] | | | Branch (36:51): [True: 16.9k, False: 7.37k] | | ------------------ ------------------ 284| 197k| inclinenumber(ls); /* skip it */ 285| 7.91M| for (;;) { 286| 7.91M| switch (ls->current) { 287| 11| case EOZ: { /* error */ ------------------ | | 16| 11|#define EOZ (-1) /* end of stream */ ------------------ | Branch (287:7): [True: 11, False: 7.91M] ------------------ 288| 11| const char *what = (seminfo ? "string" : "comment"); ------------------ | Branch (288:29): [True: 11, False: 0] ------------------ 289| 11| const char *msg = luaO_pushfstring(ls->L, 290| 11| "unfinished long %s (starting at line %d)", what, line); 291| 11| lexerror(ls, msg, TK_EOS); 292| 0| break; /* to avoid warnings */ 293| 0| } 294| 213k| case ']': { ------------------ | Branch (294:7): [True: 213k, False: 7.69M] ------------------ 295| 213k| if (skip_sep(ls) == sep) { ------------------ | Branch (295:13): [True: 204k, False: 9.24k] ------------------ 296| 204k| save_and_next(ls); /* skip 2nd ']' */ ------------------ | | 51| 204k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 204k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 204k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 204k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 204k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 204k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 297| 204k| goto endloop; 298| 204k| } 299| 9.24k| break; 300| 213k| } 301| 1.55M| case '\n': case '\r': { ------------------ | Branch (301:7): [True: 123k, False: 7.78M] | Branch (301:18): [True: 1.43M, False: 6.47M] ------------------ 302| 1.55M| save(ls, '\n'); 303| 1.55M| inclinenumber(ls); 304| 1.55M| if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */ ------------------ | | 36| 0|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ | Branch (304:13): [True: 0, False: 1.55M] ------------------ 305| 1.55M| break; 306| 123k| } 307| 6.14M| default: { ------------------ | Branch (307:7): [True: 6.14M, False: 1.77M] ------------------ 308| 6.14M| if (seminfo) save_and_next(ls); ------------------ | | 51| 6.14M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 6.14M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 6.14M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 6.14M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 6.14M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 6.14M, False: 11] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (308:13): [True: 6.14M, False: 69] ------------------ 309| 69| else next(ls); ------------------ | | 32| 69|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 69|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 69|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 69|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 69, False: 0] | | | | ------------------ | | ------------------ ------------------ 310| 6.14M| } 311| 7.91M| } 312| 7.91M| } endloop: 313| 204k| if (seminfo) ------------------ | Branch (313:7): [True: 204k, False: 3] ------------------ 314| 204k| seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep, ------------------ | | 31| 204k|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 315| 204k| luaZ_bufflen(ls->buff) - 2 * sep); ------------------ | | 33| 204k|#define luaZ_bufflen(buff) ((buff)->n) ------------------ 316| 204k|} llex.c:check_next1: 191| 19.1M|static int check_next1 (LexState *ls, int c) { 192| 19.1M| if (ls->current == c) { ------------------ | Branch (192:7): [True: 439k, False: 18.6M] ------------------ 193| 439k| next(ls); ------------------ | | 32| 439k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 439k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 439k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 439k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 439k, False: 0] | | | | ------------------ | | ------------------ ------------------ 194| 439k| return 1; 195| 439k| } 196| 18.6M| else return 0; 197| 19.1M|} llex.c:read_string: 382| 200k|static void read_string (LexState *ls, int del, SemInfo *seminfo) { 383| 200k| save_and_next(ls); /* keep delimiter (for error messages) */ ------------------ | | 51| 200k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 200k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 200k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 200k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 200k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 200k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 384| 13.4M| while (ls->current != del) { ------------------ | Branch (384:10): [True: 13.2M, False: 200k] ------------------ 385| 13.2M| switch (ls->current) { 386| 8| case EOZ: ------------------ | | 16| 8|#define EOZ (-1) /* end of stream */ ------------------ | Branch (386:7): [True: 8, False: 13.2M] ------------------ 387| 8| lexerror(ls, "unfinished string", TK_EOS); 388| 0| break; /* to avoid warnings */ 389| 6| case '\n': ------------------ | Branch (389:7): [True: 6, False: 13.2M] ------------------ 390| 9| case '\r': ------------------ | Branch (390:7): [True: 3, False: 13.2M] ------------------ 391| 9| lexerror(ls, "unfinished string", TK_STRING); 392| 0| break; /* to avoid warnings */ 393| 57.4k| case '\\': { /* escape sequences */ ------------------ | Branch (393:7): [True: 57.4k, False: 13.2M] ------------------ 394| 57.4k| int c; /* final character to be saved */ 395| 57.4k| save_and_next(ls); /* keep '\\' for error messages */ ------------------ | | 51| 57.4k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 57.4k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 57.4k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 57.4k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 57.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 57.4k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 396| 57.4k| switch (ls->current) { 397| 1.31k| case 'a': c = '\a'; goto read_save; ------------------ | Branch (397:11): [True: 1.31k, False: 56.1k] ------------------ 398| 192| case 'b': c = '\b'; goto read_save; ------------------ | Branch (398:11): [True: 192, False: 57.2k] ------------------ 399| 7.94k| case 'f': c = '\f'; goto read_save; ------------------ | Branch (399:11): [True: 7.94k, False: 49.5k] ------------------ 400| 25| case 'n': c = '\n'; goto read_save; ------------------ | Branch (400:11): [True: 25, False: 57.4k] ------------------ 401| 4.12k| case 'r': c = '\r'; goto read_save; ------------------ | Branch (401:11): [True: 4.12k, False: 53.3k] ------------------ 402| 361| case 't': c = '\t'; goto read_save; ------------------ | Branch (402:11): [True: 361, False: 57.0k] ------------------ 403| 81| case 'v': c = '\v'; goto read_save; ------------------ | Branch (403:11): [True: 81, False: 57.3k] ------------------ 404| 1.76k| case 'x': c = readhexaesc(ls); goto read_save; ------------------ | Branch (404:11): [True: 1.76k, False: 55.6k] ------------------ 405| 9.48k| case 'u': utf8esc(ls); goto no_save; ------------------ | Branch (405:11): [True: 9.48k, False: 47.9k] ------------------ 406| 273| case '\n': case '\r': ------------------ | Branch (406:11): [True: 273, False: 57.1k] | Branch (406:22): [True: 0, False: 57.4k] ------------------ 407| 273| inclinenumber(ls); c = '\n'; goto only_save; 408| 5.63k| case '\\': case '\"': case '\'': ------------------ | Branch (408:11): [True: 3.93k, False: 53.5k] | Branch (408:22): [True: 1.69k, False: 55.7k] | Branch (408:33): [True: 7, False: 57.4k] ------------------ 409| 5.63k| 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: 57.4k] ------------------ 411| 263| case 'z': { /* zap following span of spaces */ ------------------ | Branch (411:11): [True: 263, False: 57.1k] ------------------ 412| 263| luaZ_buffremove(ls->buff, 1); /* remove '\\' */ ------------------ | | 35| 263|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 413| 263| next(ls); /* skip the 'z' */ ------------------ | | 32| 263|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 263|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 263|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 263|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 263, False: 0] | | | | ------------------ | | ------------------ ------------------ 414| 263| while (lisspace(ls->current)) { 415| 112| if (currIsNewline(ls)) inclinenumber(ls); ------------------ | | 36| 112|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 0, False: 112] | | | Branch (36:51): [True: 84, False: 28] | | ------------------ ------------------ 416| 28| else next(ls); ------------------ | | 32| 28|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 28|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 28|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 28|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 28, False: 0] | | | | ------------------ | | ------------------ ------------------ 417| 112| } 418| 263| goto no_save; 419| 5.63k| } 420| 25.9k| default: { ------------------ | Branch (420:11): [True: 25.9k, False: 31.4k] ------------------ 421| 25.9k| esccheck(ls, lisdigit(ls->current), "invalid escape sequence"); ------------------ | | 59| 25.9k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 25.9k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ 422| 25.9k| c = readdecesc(ls); /* digital escape '\ddd' */ 423| 25.9k| goto only_save; 424| 5.63k| } 425| 57.4k| } 426| 21.4k| read_save: 427| 21.4k| next(ls); ------------------ | | 32| 21.4k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 21.4k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 21.4k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 21.4k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 21.4k, False: 0] | | | | ------------------ | | ------------------ ------------------ 428| | /* go through */ 429| 47.6k| only_save: 430| 47.6k| luaZ_buffremove(ls->buff, 1); /* remove '\\' */ ------------------ | | 35| 47.6k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 431| 47.6k| save(ls, c); 432| | /* go through */ 433| 57.3k| no_save: break; 434| 47.6k| } 435| 13.2M| default: ------------------ | Branch (435:7): [True: 13.2M, False: 57.4k] ------------------ 436| 13.2M| save_and_next(ls); ------------------ | | 51| 13.2M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 13.2M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 13.2M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 13.2M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 13.2M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 13.2M, False: 8] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 437| 13.2M| } 438| 13.2M| } 439| 200k| save_and_next(ls); /* skip delimiter */ ------------------ | | 51| 200k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 200k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 200k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 200k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 200k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 200k, False: 28] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 440| 200k| seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1, ------------------ | | 31| 200k|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 441| 200k| luaZ_bufflen(ls->buff) - 2); ------------------ | | 33| 200k|#define luaZ_bufflen(buff) ((buff)->n) ------------------ 442| 200k|} llex.c:readhexaesc: 335| 1.76k|static int readhexaesc (LexState *ls) { 336| 1.76k| int r = gethexa(ls); 337| 1.76k| r = (r << 4) + gethexa(ls); 338| 1.76k| luaZ_buffremove(ls->buff, 2); /* remove saved chars from buffer */ ------------------ | | 35| 1.76k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 339| 1.76k| return r; 340| 1.76k|} llex.c:gethexa: 328| 13.0k|static int gethexa (LexState *ls) { 329| 13.0k| save_and_next(ls); ------------------ | | 51| 13.0k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 13.0k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 13.0k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 13.0k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 13.0k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 13.0k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 330| 13.0k| esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected"); ------------------ | | 62| 13.0k|#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) | | ------------------ | | | | 52| 13.0k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ 331| 13.0k| return luaO_hexavalue(ls->current); 332| 13.0k|} llex.c:utf8esc: 361| 9.48k|static void utf8esc (LexState *ls) { 362| 9.48k| char buff[UTF8BUFFSZ]; 363| 9.48k| int n = luaO_utf8esc(buff, readutf8esc(ls)); 364| 57.4k| for (; n > 0; n--) /* add 'buff' to string */ ------------------ | Branch (364:10): [True: 47.9k, False: 9.48k] ------------------ 365| 47.9k| save(ls, buff[UTF8BUFFSZ - n]); ------------------ | | 795| 47.9k|#define UTF8BUFFSZ 8 ------------------ 366| 9.48k|} llex.c:readutf8esc: 343| 9.48k|static unsigned long readutf8esc (LexState *ls) { 344| 9.48k| unsigned long r; 345| 9.48k| int i = 4; /* chars to be removed: '\', 'u', '{', and first digit */ 346| 9.48k| save_and_next(ls); /* skip 'u' */ ------------------ | | 51| 9.48k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 9.48k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 9.48k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 9.48k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 9.48k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 9.48k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 347| 9.48k| esccheck(ls, ls->current == '{', "missing '{'"); 348| 9.48k| r = gethexa(ls); /* must have at least one digit */ 349| 57.4k| while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) { ------------------ | | 138| 57.4k|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 114k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 57.4k, False: 14] | | | | ------------------ | | ------------------ ------------------ while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) { ------------------ | | 62| 57.4k|#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) | | ------------------ | | | | 52| 57.4k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ | Branch (349:10): [True: 48.0k, False: 9.48k] ------------------ 350| 48.0k| i++; 351| 48.0k| esccheck(ls, r <= (0x7FFFFFFFu >> 4), "UTF-8 value too large"); 352| 48.0k| r = (r << 4) + luaO_hexavalue(ls->current); 353| 48.0k| } 354| 9.48k| esccheck(ls, ls->current == '}', "missing '}'"); 355| 9.48k| next(ls); /* skip '}' */ ------------------ | | 32| 9.48k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 9.48k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 9.44k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 9.44k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 9.44k, False: 32] | | | | ------------------ | | ------------------ ------------------ 356| 9.48k| luaZ_buffremove(ls->buff, i); /* remove saved chars from buffer */ ------------------ | | 35| 9.48k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 357| 9.48k| return r; 358| 9.48k|} llex.c:esccheck: 319| 131k|static void esccheck (LexState *ls, int c, const char *msg) { 320| 131k| if (!c) { ------------------ | Branch (320:7): [True: 46, False: 131k] ------------------ 321| 46| if (ls->current != EOZ) ------------------ | | 16| 46|#define EOZ (-1) /* end of stream */ ------------------ | Branch (321:9): [True: 46, False: 0] ------------------ 322| 46| save_and_next(ls); /* add current to buffer for error message */ ------------------ | | 51| 46|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 46|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 46|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 46|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 46|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 46, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 323| 46| lexerror(ls, msg, TK_STRING); 324| 46| } 325| 131k|} llex.c:readdecesc: 369| 25.9k|static int readdecesc (LexState *ls) { 370| 25.9k| int i; 371| 25.9k| int r = 0; /* result accumulator */ 372| 88.2k| for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */ ------------------ | | 59| 73.1k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 73.1k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 62.2k, False: 10.8k] | | | | ------------------ | | ------------------ ------------------ | Branch (372:15): [True: 73.1k, False: 15.1k] ------------------ 373| 62.2k| r = 10*r + ls->current - '0'; 374| 62.2k| save_and_next(ls); ------------------ | | 51| 62.2k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 62.2k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 62.2k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 62.2k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 62.2k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 62.2k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 375| 62.2k| } 376| 25.9k| esccheck(ls, r <= UCHAR_MAX, "decimal escape too large"); 377| 25.9k| luaZ_buffremove(ls->buff, i); /* remove read digits from buffer */ ------------------ | | 35| 25.9k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 378| 25.9k| return r; 379| 25.9k|} llex.c:read_numeral: 227| 349k|static int read_numeral (LexState *ls, SemInfo *seminfo) { 228| 349k| TValue obj; 229| 349k| const char *expo = "Ee"; 230| 349k| int first = ls->current; 231| 349k| lua_assert(lisdigit(ls->current)); ------------------ | | 114| 349k|#define lua_assert(c) ((void)0) ------------------ 232| 349k| save_and_next(ls); ------------------ | | 51| 349k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 349k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 349k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 349k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 349k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 349k, False: 6] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 233| 349k| if (first == '0' && check_next2(ls, "xX")) /* hexadecimal? */ ------------------ | Branch (233:7): [True: 59.6k, False: 289k] | Branch (233:23): [True: 3, False: 59.6k] ------------------ 234| 3| expo = "Pp"; 235| 2.16M| for (;;) { 236| 2.16M| if (check_next2(ls, expo)) /* exponent mark? */ ------------------ | Branch (236:9): [True: 854, False: 2.16M] ------------------ 237| 854| check_next2(ls, "-+"); /* optional exponent sign */ 238| 2.16M| else if (lisxdigit(ls->current) || ls->current == '.') /* '%x|%.' */ ------------------ | | 62| 2.16M|#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) | | ------------------ | | | | 52| 4.33M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 1.78M, False: 383k] | | | | ------------------ | | ------------------ ------------------ | Branch (238:40): [True: 34.7k, False: 349k] ------------------ 239| 1.81M| save_and_next(ls); ------------------ | | 51| 1.81M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 1.81M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 1.81M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 1.81M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1.81M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 1.81M, False: 6] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 240| 349k| else break; 241| 2.16M| } 242| 349k| if (lislalpha(ls->current)) /* is numeral touching a letter? */ ------------------ | | 57| 349k|#define lislalpha(c) testprop(c, MASK(ALPHABIT)) | | ------------------ | | | | 52| 349k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 35, False: 349k] | | | | ------------------ | | ------------------ ------------------ 243| 35| save_and_next(ls); /* force an error */ ------------------ | | 51| 35|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 35|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 35|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 35|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 35|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 35, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 244| 349k| save(ls, '\0'); 245| 349k| if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0) /* format error? */ ------------------ | | 31| 349k|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ | Branch (245:7): [True: 39, False: 349k] ------------------ 246| 39| lexerror(ls, "malformed number", TK_FLT); 247| 349k| if (ttisinteger(&obj)) { ------------------ | | 328| 349k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 349k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 349k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 308k, False: 40.9k] | | | | ------------------ | | ------------------ ------------------ 248| 308k| seminfo->i = ivalue(&obj); ------------------ | | 333| 308k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 308k|#define check_exp(c,e) (e) | | ------------------ ------------------ 249| 308k| return TK_INT; 250| 308k| } 251| 40.9k| else { 252| 40.9k| lua_assert(ttisfloat(&obj)); ------------------ | | 114| 40.9k|#define lua_assert(c) ((void)0) ------------------ 253| 40.9k| seminfo->r = fltvalue(&obj); ------------------ | | 332| 40.9k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 40.9k|#define check_exp(c,e) (e) | | ------------------ ------------------ 254| 40.9k| return TK_FLT; 255| 40.9k| } 256| 349k|} llex.c:check_next2: 204| 2.23M|static int check_next2 (LexState *ls, const char *set) { 205| 2.23M| lua_assert(set[2] == '\0'); ------------------ | | 114| 2.23M|#define lua_assert(c) ((void)0) ------------------ 206| 2.23M| if (ls->current == set[0] || ls->current == set[1]) { ------------------ | Branch (206:7): [True: 49, False: 2.22M] | Branch (206:32): [True: 834, False: 2.22M] ------------------ 207| 883| save_and_next(ls); ------------------ | | 51| 883|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 883|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 883|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 883|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 883|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 883, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 208| 883| return 1; 209| 883| } 210| 2.22M| else return 0; 211| 2.23M|} luaM_growaux_: 98| 131M| int size_elems, int limit, const char *what) { 99| 131M| void *newblock; 100| 131M| int size = *psize; 101| 131M| if (nelems + 1 <= size) /* does one extra element still fit? */ ------------------ | Branch (101:7): [True: 131M, False: 44.6k] ------------------ 102| 131M| return block; /* nothing to be done */ 103| 44.6k| if (size >= limit / 2) { /* cannot double it? */ ------------------ | Branch (103:7): [True: 0, False: 44.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| 44.6k| else { 109| 44.6k| size *= 2; 110| 44.6k| if (size < MINSIZEARRAY) ------------------ | | 94| 44.6k|#define MINSIZEARRAY 4 ------------------ | Branch (110:9): [True: 16.0k, False: 28.6k] ------------------ 111| 16.0k| size = MINSIZEARRAY; /* minimum size */ ------------------ | | 94| 16.0k|#define MINSIZEARRAY 4 ------------------ 112| 44.6k| } 113| 44.6k| lua_assert(nelems + 1 <= size && size <= limit); ------------------ | | 114| 44.6k|#define lua_assert(c) ((void)0) ------------------ 114| | /* 'limit' ensures that multiplication will not overflow */ 115| 44.6k| newblock = luaM_saferealloc_(L, block, cast_sizet(*psize) * size_elems, ------------------ | | 147| 44.6k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 44.6k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 116| 44.6k| cast_sizet(size) * size_elems); ------------------ | | 147| 44.6k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 44.6k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 117| 44.6k| *psize = size; /* update only when everything else is OK */ 118| 44.6k| return newblock; 119| 44.6k|} luaM_shrinkvector_: 129| 19.4k| int final_n, int size_elem) { 130| 19.4k| void *newblock; 131| 19.4k| size_t oldsize = cast_sizet((*size) * size_elem); ------------------ | | 147| 19.4k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 19.4k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 132| 19.4k| size_t newsize = cast_sizet(final_n * size_elem); ------------------ | | 147| 19.4k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 19.4k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 133| 19.4k| lua_assert(newsize <= oldsize); ------------------ | | 114| 19.4k|#define lua_assert(c) ((void)0) ------------------ 134| 19.4k| newblock = luaM_saferealloc_(L, block, oldsize, newsize); 135| 19.4k| *size = final_n; 136| 19.4k| return newblock; 137| 19.4k|} luaM_free_: 150| 637k|void luaM_free_ (lua_State *L, void *block, size_t osize) { 151| 637k| global_State *g = G(L); ------------------ | | 335| 637k|#define G(L) (L->l_G) ------------------ 152| 637k| lua_assert((osize == 0) == (block == NULL)); ------------------ | | 114| 637k|#define lua_assert(c) ((void)0) ------------------ 153| 637k| callfrealloc(g, block, osize, 0); ------------------ | | 47| 637k|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) ------------------ 154| 637k| g->GCdebt -= osize; 155| 637k|} luaM_realloc_: 176| 86.1k|void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) { 177| 86.1k| void *newblock; 178| 86.1k| global_State *g = G(L); ------------------ | | 335| 86.1k|#define G(L) (L->l_G) ------------------ 179| 86.1k| lua_assert((osize == 0) == (block == NULL)); ------------------ | | 114| 86.1k|#define lua_assert(c) ((void)0) ------------------ 180| 86.1k| newblock = firsttry(g, block, osize, nsize); ------------------ | | 76| 86.1k|#define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns) | | ------------------ | | | | 47| 86.1k|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) | | ------------------ ------------------ 181| 86.1k| if (l_unlikely(newblock == NULL && nsize > 0)) { ------------------ | | 697| 86.1k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 96.7k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 86.1k] | | | | | Branch (685:46): [True: 10.6k, False: 75.4k] | | | | | Branch (685:46): [True: 0, False: 10.6k] | | | | ------------------ | | ------------------ ------------------ 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| 86.1k| lua_assert((nsize == 0) == (newblock == NULL)); ------------------ | | 114| 86.1k|#define lua_assert(c) ((void)0) ------------------ 187| 86.1k| g->GCdebt = (g->GCdebt + nsize) - osize; 188| 86.1k| return newblock; 189| 86.1k|} luaM_saferealloc_: 193| 66.6k| size_t nsize) { 194| 66.6k| void *newblock = luaM_realloc_(L, block, osize, nsize); 195| 66.6k| if (l_unlikely(newblock == NULL && nsize > 0)) /* allocation failed? */ ------------------ | | 697| 66.6k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 75.1k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 66.6k] | | | | | Branch (685:46): [True: 8.48k, False: 58.1k] | | | | | Branch (685:46): [True: 0, False: 8.48k] | | | | ------------------ | | ------------------ ------------------ 196| 0| luaM_error(L); ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 52| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 197| 66.6k| return newblock; 198| 66.6k|} luaM_malloc_: 201| 602k|void *luaM_malloc_ (lua_State *L, size_t size, int tag) { 202| 602k| if (size == 0) ------------------ | Branch (202:7): [True: 0, False: 602k] ------------------ 203| 0| return NULL; /* that's all */ 204| 602k| else { 205| 602k| global_State *g = G(L); ------------------ | | 335| 602k|#define G(L) (L->l_G) ------------------ 206| 602k| void *newblock = firsttry(g, NULL, tag, size); ------------------ | | 76| 602k|#define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns) | | ------------------ | | | | 47| 602k|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) | | ------------------ ------------------ 207| 602k| if (l_unlikely(newblock == NULL)) { ------------------ | | 697| 602k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 602k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 602k] | | | | ------------------ | | ------------------ ------------------ 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| 602k| g->GCdebt += size; 213| 602k| return newblock; 214| 602k| } 215| 602k|} luaO_ceillog2: 35| 21.7k|int luaO_ceillog2 (unsigned int x) { 36| 21.7k| static const lu_byte log_2[256] = { /* log_2[i] = ceil(log2(i - 1)) */ 37| 21.7k| 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| 21.7k| 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| 21.7k| 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| 21.7k| 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| 21.7k| 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| 21.7k| 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| 21.7k| 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| 21.7k| 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| 21.7k| }; 46| 21.7k| int l = 0; 47| 21.7k| x--; 48| 38.8k| while (x >= 256) { l += 8; x >>= 8; } ------------------ | Branch (48:10): [True: 17.1k, False: 21.7k] ------------------ 49| 21.7k| return l + log_2[x]; 50| 21.7k|} luaO_rawarith: 90| 193k| TValue *res) { 91| 193k| switch (op) { 92| 2.58k| case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 222| 374|#define LUA_OPBAND 7 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 223| 396|#define LUA_OPBOR 8 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 224| 2.58k|#define LUA_OPBXOR 9 ------------------ | Branch (92:5): [True: 374, False: 193k] | Branch (92:22): [True: 22, False: 193k] | Branch (92:38): [True: 2.18k, False: 191k] ------------------ 93| 4.52k| case LUA_OPSHL: case LUA_OPSHR: ------------------ | | 225| 2.89k|#define LUA_OPSHL 10 ------------------ case LUA_OPSHL: case LUA_OPSHR: ------------------ | | 226| 4.52k|#define LUA_OPSHR 11 ------------------ | Branch (93:5): [True: 311, False: 193k] | Branch (93:21): [True: 1.63k, False: 191k] ------------------ 94| 51.9k| case LUA_OPBNOT: { /* operate only on integers */ ------------------ | | 228| 51.9k|#define LUA_OPBNOT 13 ------------------ | Branch (94:5): [True: 47.4k, False: 146k] ------------------ 95| 51.9k| lua_Integer i1; lua_Integer i2; 96| 51.9k| if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) { ------------------ | | 69| 103k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 696| 51.9k|#define l_likely(x) luai_likely(x) | | | | ------------------ | | | | | | 684| 51.9k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | ------------------ | | | | | | | Branch (684:25): [True: 44.9k, False: 7.01k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 333| 44.9k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 44.9k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (69:3): [True: 51.9k, False: 0] | | ------------------ | | 70| 103k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | ------------------ | | | | 36| 7.01k|#define LUA_FLOORN2I F2Ieq | | ------------------ ------------------ if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) { ------------------ | | 69| 51.9k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 696| 51.9k|#define l_likely(x) luai_likely(x) | | | | ------------------ | | | | | | 684| 51.9k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | ------------------ | | | | | | | Branch (684:25): [True: 51.0k, False: 901] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 333| 51.0k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 51.0k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (69:3): [True: 51.9k, False: 0] | | ------------------ | | 70| 51.9k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | ------------------ | | | | 36| 901|#define LUA_FLOORN2I F2Ieq | | ------------------ ------------------ 97| 51.9k| setivalue(res, intarith(L, op, i1, i2)); ------------------ | | 345| 51.9k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 51.9k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 51.9k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 98| 51.9k| return 1; 99| 51.9k| } 100| 0| else return 0; /* fail */ 101| 51.9k| } 102| 103k| case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */ ------------------ | | 220| 581|#define LUA_OPDIV 5 ------------------ case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */ ------------------ | | 219| 103k|#define LUA_OPPOW 4 ------------------ | Branch (102:5): [True: 581, False: 192k] | Branch (102:21): [True: 103k, False: 90.2k] ------------------ 103| 103k| lua_Number n1; lua_Number n2; 104| 103k| if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 207k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 103k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 103k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 103k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 13.6k, False: 90.2k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 13.6k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 13.6k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 103k, False: 0] | | ------------------ | | 58| 207k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 90.2k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 90.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 90.2k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 90.2k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 140| 90.2k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 90.2k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 103k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 103k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 103k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 103k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 28.3k, False: 75.5k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 28.3k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 28.3k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 103k, False: 0] | | ------------------ | | 58| 103k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 75.5k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 75.5k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 75.5k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 75.5k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 140| 75.5k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 75.5k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 105| 103k| setfltvalue(res, numarith(L, op, n1, n2)); ------------------ | | 339| 103k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 103k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 103k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 106| 103k| return 1; 107| 103k| } 108| 0| else return 0; /* fail */ 109| 103k| } 110| 37.7k| default: { /* other operations */ ------------------ | Branch (110:5): [True: 37.7k, False: 155k] ------------------ 111| 37.7k| lua_Number n1; lua_Number n2; 112| 37.7k| if (ttisinteger(p1) && ttisinteger(p2)) { ------------------ | | 328| 37.7k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 75.4k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 37.7k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 25.5k, False: 12.1k] | | | | ------------------ | | ------------------ ------------------ if (ttisinteger(p1) && ttisinteger(p2)) { ------------------ | | 328| 25.5k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 25.5k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 25.5k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 22.0k, False: 3.53k] | | | | ------------------ | | ------------------ ------------------ 113| 22.0k| setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2))); ------------------ | | 345| 22.0k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 22.0k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 22.0k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 114| 22.0k| return 1; 115| 22.0k| } 116| 15.6k| else if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 31.3k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 15.6k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 15.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 15.6k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 12.1k, False: 3.53k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 12.1k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 12.1k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 15.6k, False: 0] | | ------------------ | | 58| 31.3k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 3.53k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 3.53k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 3.53k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 3.53k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 140| 3.53k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 3.53k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ else if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 15.6k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 15.6k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 15.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 15.6k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 5.68k, False: 9.99k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 5.68k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 5.68k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 15.6k, False: 0] | | ------------------ | | 58| 15.6k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 9.99k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 9.99k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 9.99k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 9.99k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 140| 9.99k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 9.99k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 117| 15.6k| setfltvalue(res, numarith(L, op, n1, n2)); ------------------ | | 339| 15.6k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 15.6k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 15.6k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 118| 15.6k| return 1; 119| 15.6k| } 120| 0| else return 0; /* fail */ 121| 37.7k| } 122| 193k| } 123| 193k|} luaO_hexavalue: 135| 61.0k|int luaO_hexavalue (int c) { 136| 61.0k| if (lisdigit(c)) return c - '0'; ------------------ | | 59| 61.0k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 61.0k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 47.9k, False: 13.0k] | | | | ------------------ | | ------------------ ------------------ 137| 13.0k| else return (ltolower(c) - 'a') + 10; ------------------ | | 72| 13.0k| check_exp(('A' <= (c) && (c) <= 'Z') || (c) == ((c) | ('A' ^ 'a')), \ | | ------------------ | | | | 115| 13.0k|#define check_exp(c,e) (e) | | ------------------ | | 73| 13.0k| (c) | ('A' ^ 'a')) ------------------ 138| 61.0k|} luaO_str2num: 308| 349k|size_t luaO_str2num (const char *s, TValue *o) { 309| 349k| lua_Integer i; lua_Number n; 310| 349k| const char *e; 311| 349k| if ((e = l_str2int(s, &i)) != NULL) { /* try as an integer */ ------------------ | Branch (311:7): [True: 308k, False: 41.0k] ------------------ 312| 308k| setivalue(o, i); ------------------ | | 345| 308k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 308k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 308k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 313| 308k| } 314| 41.0k| else if ((e = l_str2d(s, &n)) != NULL) { /* else try as a float */ ------------------ | Branch (314:12): [True: 40.9k, False: 44] ------------------ 315| 40.9k| setfltvalue(o, n); ------------------ | | 339| 40.9k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 40.9k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 40.9k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 316| 40.9k| } 317| 44| else 318| 44| return 0; /* conversion failed */ 319| 349k| return (e - s) + 1; /* success; return string size */ 320| 349k|} luaO_utf8esc: 323| 9.44k|int luaO_utf8esc (char *buff, unsigned long x) { 324| 9.44k| int n = 1; /* number of bytes put in buffer (backwards) */ 325| 9.44k| lua_assert(x <= 0x7FFFFFFFu); ------------------ | | 114| 9.44k|#define lua_assert(c) ((void)0) ------------------ 326| 9.44k| if (x < 0x80) /* ascii? */ ------------------ | Branch (326:7): [True: 92, False: 9.35k] ------------------ 327| 92| buff[UTF8BUFFSZ - 1] = cast_char(x); ------------------ | | 795| 92|#define UTF8BUFFSZ 8 ------------------ buff[UTF8BUFFSZ - 1] = cast_char(x); ------------------ | | 145| 92|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 136| 92|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 328| 9.35k| else { /* need continuation bytes */ 329| 9.35k| unsigned int mfb = 0x3f; /* maximum that fits in first byte */ 330| 38.4k| do { /* add continuation bytes */ 331| 38.4k| buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f)); ------------------ | | 795| 38.4k|#define UTF8BUFFSZ 8 ------------------ buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f)); ------------------ | | 145| 38.4k|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 136| 38.4k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 332| 38.4k| x >>= 6; /* remove added bits */ 333| 38.4k| mfb >>= 1; /* now there is one less bit available in first byte */ 334| 38.4k| } while (x > mfb); /* still needs continuation byte? */ ------------------ | Branch (334:14): [True: 29.1k, False: 9.35k] ------------------ 335| 9.35k| buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x); /* add first byte */ ------------------ | | 795| 9.35k|#define UTF8BUFFSZ 8 ------------------ buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x); /* add first byte */ ------------------ | | 145| 9.35k|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 136| 9.35k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 336| 9.35k| } 337| 9.44k| return n; 338| 9.44k|} luaO_tostring: 374| 122k|void luaO_tostring (lua_State *L, TValue *obj) { 375| 122k| char buff[MAXNUMBER2STR]; 376| 122k| int len = tostringbuff(obj, buff); 377| 122k| setsvalue(L, obj, luaS_newlstr(L, buff, len)); ------------------ | | 372| 122k| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 122k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 122k|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 122k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 122k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 122k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 122k| checkliveness(L,io); } | | ------------------ | | | | 107| 122k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 122k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 122k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 378| 122k|} luaO_pushvfstring: 480| 1.29k|const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) { 481| 1.29k| BuffFS buff; /* holds last part of the result */ 482| 1.29k| const char *e; /* points to next '%' */ 483| 1.29k| buff.pushed = buff.blen = 0; 484| 1.29k| buff.L = L; 485| 3.92k| while ((e = strchr(fmt, '%')) != NULL) { ------------------ | Branch (485:10): [True: 2.62k, False: 1.29k] ------------------ 486| 2.62k| addstr2buff(&buff, fmt, e - fmt); /* add 'fmt' up to '%' */ 487| 2.62k| switch (*(e + 1)) { /* conversion specifier */ 488| 1.94k| case 's': { /* zero-terminated string */ ------------------ | Branch (488:7): [True: 1.94k, False: 686] ------------------ 489| 1.94k| const char *s = va_arg(argp, char *); 490| 1.94k| if (s == NULL) s = "(null)"; ------------------ | Branch (490:13): [True: 0, False: 1.94k] ------------------ 491| 1.94k| addstr2buff(&buff, s, strlen(s)); 492| 1.94k| break; 493| 0| } 494| 132| case 'c': { /* an 'int' as a character */ ------------------ | Branch (494:7): [True: 132, False: 2.49k] ------------------ 495| 132| char c = cast_uchar(va_arg(argp, int)); ------------------ | | 144| 132|#define cast_uchar(i) cast(unsigned char, (i)) | | ------------------ | | | | 136| 132|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 496| 132| addstr2buff(&buff, &c, sizeof(char)); 497| 132| break; 498| 0| } 499| 554| case 'd': { /* an 'int' */ ------------------ | Branch (499:7): [True: 554, False: 2.07k] ------------------ 500| 554| TValue num; 501| 554| setivalue(&num, va_arg(argp, int)); ------------------ | | 345| 554| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 554|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 554|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 502| 554| addnum2buff(&buff, &num); 503| 554| break; 504| 0| } 505| 0| case 'I': { /* a 'lua_Integer' */ ------------------ | Branch (505:7): [True: 0, False: 2.62k] ------------------ 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: 2.62k] ------------------ 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: 2.62k] ------------------ 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: 2.62k] ------------------ 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| 0| case '%': { ------------------ | Branch (531:7): [True: 0, False: 2.62k] ------------------ 532| 0| addstr2buff(&buff, "%", 1); 533| 0| break; 534| 0| } 535| 0| default: { ------------------ | Branch (535:7): [True: 0, False: 2.62k] ------------------ 536| 0| luaG_runerror(L, "invalid option '%%%c' to 'lua_pushfstring'", 537| 0| *(e + 1)); 538| 0| } 539| 2.62k| } 540| 2.62k| fmt = e + 2; /* skip '%' and the specifier */ 541| 2.62k| } 542| 1.29k| addstr2buff(&buff, fmt, strlen(fmt)); /* rest of 'fmt' */ 543| 1.29k| clearbuff(&buff); /* empty buffer into the stack */ 544| 1.29k| lua_assert(buff.pushed == 1); ------------------ | | 114| 1.29k|#define lua_assert(c) ((void)0) ------------------ 545| 1.29k| return getstr(tsvalue(s2v(L->top.p - 1))); ------------------ | | 404| 1.29k|#define getstr(ts) ((ts)->contents) ------------------ 546| 1.29k|} luaO_pushfstring: 549| 1.17k|const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) { 550| 1.17k| const char *msg; 551| 1.17k| va_list argp; 552| 1.17k| va_start(argp, fmt); 553| 1.17k| msg = luaO_pushvfstring(L, fmt, argp); 554| 1.17k| va_end(argp); 555| 1.17k| return msg; 556| 1.17k|} luaO_chunkid: 567| 433|void luaO_chunkid (char *out, const char *source, size_t srclen) { 568| 433| size_t bufflen = LUA_IDSIZE; /* free space in buffer */ ------------------ | | 768| 433|#define LUA_IDSIZE 60 ------------------ 569| 433| if (*source == '=') { /* 'literal' source */ ------------------ | Branch (569:7): [True: 0, False: 433] ------------------ 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| 433| else if (*source == '@') { /* file name */ ------------------ | Branch (577:12): [True: 0, False: 433] ------------------ 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| 433| else { /* string; format as [string "source"] */ 587| 433| const char *nl = strchr(source, '\n'); /* find first new line (if any) */ 588| 433| addstr(out, PRE, LL(PRE)); /* add prefix */ ------------------ | | 565| 433|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 589| 433| bufflen -= LL(PRE RETS POS) + 1; /* save space for prefix+suffix+'\0' */ ------------------ | | 70| 433|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 590| 433| if (srclen < bufflen && nl == NULL) { /* small one-line source? */ ------------------ | Branch (590:9): [True: 433, False: 0] | Branch (590:29): [True: 433, False: 0] ------------------ 591| 433| addstr(out, source, srclen); /* keep it */ ------------------ | | 565| 433|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 592| 433| } 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| 433| memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); ------------------ | | 563| 433|#define POS "\"]" ------------------ memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); ------------------ | | 70| 433|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 600| 433| } 601| 433|} lobject.c:intarith: 54| 73.9k| lua_Integer v2) { 55| 73.9k| switch (op) { 56| 1.06k| case LUA_OPADD: return intop(+, v1, v2); ------------------ | | 215| 1.06k|#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ ------------------ case LUA_OPADD: return intop(+, v1, v2); ------------------ | | 73| 1.06k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 1.06k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (56:5): [True: 1.06k, False: 72.9k] ------------------ 57| 3.55k| case LUA_OPSUB:return intop(-, v1, v2); ------------------ | | 216| 3.55k|#define LUA_OPSUB 1 ------------------ case LUA_OPSUB:return intop(-, v1, v2); ------------------ | | 73| 3.55k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 3.55k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (57:5): [True: 3.55k, False: 70.4k] ------------------ 58| 3.07k| case LUA_OPMUL:return intop(*, v1, v2); ------------------ | | 217| 3.07k|#define LUA_OPMUL 2 ------------------ case LUA_OPMUL:return intop(*, v1, v2); ------------------ | | 73| 3.07k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 3.07k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (58:5): [True: 3.07k, False: 70.9k] ------------------ 59| 6.40k| case LUA_OPMOD: return luaV_mod(L, v1, v2); ------------------ | | 218| 6.40k|#define LUA_OPMOD 3 ------------------ | Branch (59:5): [True: 6.40k, False: 67.5k] ------------------ 60| 829| case LUA_OPIDIV: return luaV_idiv(L, v1, v2); ------------------ | | 221| 829|#define LUA_OPIDIV 6 ------------------ | Branch (60:5): [True: 829, False: 73.1k] ------------------ 61| 374| case LUA_OPBAND: return intop(&, v1, v2); ------------------ | | 222| 374|#define LUA_OPBAND 7 ------------------ case LUA_OPBAND: return intop(&, v1, v2); ------------------ | | 73| 374|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 374|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (61:5): [True: 374, False: 73.6k] ------------------ 62| 22| case LUA_OPBOR: return intop(|, v1, v2); ------------------ | | 223| 22|#define LUA_OPBOR 8 ------------------ case LUA_OPBOR: return intop(|, v1, v2); ------------------ | | 73| 22|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 22|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (62:5): [True: 22, False: 73.9k] ------------------ 63| 2.18k| case LUA_OPBXOR: return intop(^, v1, v2); ------------------ | | 224| 2.18k|#define LUA_OPBXOR 9 ------------------ case LUA_OPBXOR: return intop(^, v1, v2); ------------------ | | 73| 2.18k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 2.18k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (63:5): [True: 2.18k, False: 71.8k] ------------------ 64| 311| case LUA_OPSHL: return luaV_shiftl(v1, v2); ------------------ | | 225| 311|#define LUA_OPSHL 10 ------------------ | Branch (64:5): [True: 311, False: 73.6k] ------------------ 65| 1.63k| case LUA_OPSHR: return luaV_shiftr(v1, v2); ------------------ | | 226| 1.63k|#define LUA_OPSHR 11 ------------------ case LUA_OPSHR: return luaV_shiftr(v1, v2); ------------------ | | 116| 1.63k|#define luaV_shiftr(x,y) luaV_shiftl(x,intop(-, 0, y)) | | ------------------ | | | | 73| 1.63k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | | | ------------------ | | | | | | 161| 1.63k|#define l_castU2S(i) ((lua_Integer)(i)) | | | | ------------------ | | ------------------ ------------------ | Branch (65:5): [True: 1.63k, False: 72.3k] ------------------ 66| 7.13k| case LUA_OPUNM: return intop(-, 0, v1); ------------------ | | 227| 7.13k|#define LUA_OPUNM 12 ------------------ case LUA_OPUNM: return intop(-, 0, v1); ------------------ | | 73| 7.13k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 7.13k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (66:5): [True: 7.13k, False: 66.8k] ------------------ 67| 47.4k| case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1); ------------------ | | 228| 47.4k|#define LUA_OPBNOT 13 ------------------ case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1); ------------------ | | 73| 47.4k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 47.4k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (67:5): [True: 47.4k, False: 26.5k] ------------------ 68| 0| default: lua_assert(0); return 0; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (68:5): [True: 0, False: 73.9k] ------------------ 69| 73.9k| } 70| 73.9k|} lobject.c:numarith: 74| 119k| lua_Number v2) { 75| 119k| switch (op) { 76| 1.23k| case LUA_OPADD: return luai_numadd(L, v1, v2); ------------------ | | 215| 1.23k|#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ ------------------ case LUA_OPADD: return luai_numadd(L, v1, v2); ------------------ | | 346| 1.23k|#define luai_numadd(L,a,b) ((a)+(b)) ------------------ | Branch (76:5): [True: 1.23k, False: 118k] ------------------ 77| 1.59k| case LUA_OPSUB: return luai_numsub(L, v1, v2); ------------------ | | 216| 1.59k|#define LUA_OPSUB 1 ------------------ case LUA_OPSUB: return luai_numsub(L, v1, v2); ------------------ | | 347| 1.59k|#define luai_numsub(L,a,b) ((a)-(b)) ------------------ | Branch (77:5): [True: 1.59k, False: 117k] ------------------ 78| 4.66k| case LUA_OPMUL: return luai_nummul(L, v1, v2); ------------------ | | 217| 4.66k|#define LUA_OPMUL 2 ------------------ case LUA_OPMUL: return luai_nummul(L, v1, v2); ------------------ | | 348| 4.66k|#define luai_nummul(L,a,b) ((a)*(b)) ------------------ | Branch (78:5): [True: 4.66k, False: 114k] ------------------ 79| 581| case LUA_OPDIV: return luai_numdiv(L, v1, v2); ------------------ | | 220| 581|#define LUA_OPDIV 5 ------------------ case LUA_OPDIV: return luai_numdiv(L, v1, v2); ------------------ | | 318| 581|#define luai_numdiv(L,a,b) ((a)/(b)) ------------------ | Branch (79:5): [True: 581, False: 118k] ------------------ 80| 103k| case LUA_OPPOW: return luai_numpow(L, v1, v2); ------------------ | | 219| 103k|#define LUA_OPPOW 4 ------------------ case LUA_OPPOW: return luai_numpow(L, v1, v2); ------------------ | | 341| 103k| ((void)L, (b == 2) ? (a)*(a) : l_mathop(pow)(a,b)) | | ------------------ | | | | 482| 83.6k|#define l_mathop(op) op | | ------------------ | | | Branch (341:13): [True: 19.6k, False: 83.6k] | | ------------------ ------------------ | Branch (80:5): [True: 103k, False: 16.2k] ------------------ 81| 51| case LUA_OPIDIV: return luai_numidiv(L, v1, v2); ------------------ | | 221| 51|#define LUA_OPIDIV 6 ------------------ case LUA_OPIDIV: return luai_numidiv(L, v1, v2); ------------------ | | 313| 51|#define luai_numidiv(L,a,b) ((void)L, l_floor(luai_numdiv(L,a,b))) | | ------------------ | | | | 418| 51|#define l_floor(x) (l_mathop(floor)(x)) | | | | ------------------ | | | | | | 482| 51|#define l_mathop(op) op | | | | ------------------ | | ------------------ ------------------ | Branch (81:5): [True: 51, False: 119k] ------------------ 82| 3.90k| case LUA_OPUNM: return luai_numunm(L, v1); ------------------ | | 227| 3.90k|#define LUA_OPUNM 12 ------------------ case LUA_OPUNM: return luai_numunm(L, v1); ------------------ | | 349| 3.90k|#define luai_numunm(L,a) (-(a)) ------------------ | Branch (82:5): [True: 3.90k, False: 115k] ------------------ 83| 4.22k| case LUA_OPMOD: return luaV_modf(L, v1, v2); ------------------ | | 218| 4.22k|#define LUA_OPMOD 3 ------------------ | Branch (83:5): [True: 4.22k, False: 115k] ------------------ 84| 0| default: lua_assert(0); return 0; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (84:5): [True: 0, False: 119k] ------------------ 85| 119k| } 86| 119k|} lobject.c:l_str2int: 276| 349k|static const char *l_str2int (const char *s, lua_Integer *result) { 277| 349k| lua_Unsigned a = 0; 278| 349k| int empty = 1; 279| 349k| int neg; 280| 349k| while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */ 281| 349k| neg = isneg(&s); 282| 349k| if (s[0] == '0' && ------------------ | Branch (282:7): [True: 58.4k, False: 290k] ------------------ 283| 349k| (s[1] == 'x' || s[1] == 'X')) { /* hex? */ ------------------ | Branch (283:8): [True: 3, False: 58.4k] | Branch (283:23): [True: 0, False: 58.4k] ------------------ 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| 349k| else { /* decimal */ 291| 775k| for (; lisdigit(cast_uchar(*s)); s++) { 292| 775k| int d = *s - '0'; 293| 775k| if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 273| 775k|#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) | | ------------------ | | | | 136| 1.55M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 273| 4.10k|#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) | | ------------------ | | | | 136| 8.21k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 274| 2.18k|#define MAXLASTD cast_int(LUA_MAXINTEGER % 10) | | ------------------ | | | | 141| 2.18k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 2.18k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (293:11): [True: 4.10k, False: 771k] | Branch (293:28): [True: 1.91k, False: 2.18k] | Branch (293:43): [True: 244, False: 1.94k] ------------------ 294| 2.16k| return NULL; /* do not accept it (as integer) */ 295| 773k| a = a * 10 + d; 296| 773k| empty = 0; 297| 773k| } 298| 349k| } 299| 347k| while (lisspace(cast_uchar(*s))) s++; /* skip trailing spaces */ 300| 347k| if (empty || *s != '\0') return NULL; /* something wrong in the numeral */ ------------------ | Branch (300:7): [True: 3.18k, False: 343k] | Branch (300:16): [True: 35.6k, False: 308k] ------------------ 301| 308k| else { 302| 308k| *result = l_castU2S((neg) ? 0u - a : a); ------------------ | | 161| 616k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ | | | Branch (161:37): [True: 0, False: 308k] | | ------------------ ------------------ 303| 308k| return s; 304| 308k| } 305| 347k|} lobject.c:isneg: 141| 349k|static int isneg (const char **s) { 142| 349k| if (**s == '-') { (*s)++; return 1; } ------------------ | Branch (142:7): [True: 0, False: 349k] ------------------ 143| 349k| else if (**s == '+') (*s)++; ------------------ | Branch (143:12): [True: 0, False: 349k] ------------------ 144| 349k| return 0; 145| 349k|} lobject.c:l_str2d: 251| 41.0k|static const char *l_str2d (const char *s, lua_Number *result) { 252| 41.0k| const char *endptr; 253| 41.0k| const char *pmode = strpbrk(s, ".xXnN"); /* look for special chars */ 254| 41.0k| int mode = pmode ? ltolower(cast_uchar(*pmode)) : 0; ------------------ | | 72| 37.9k| check_exp(('A' <= (c) && (c) <= 'Z') || (c) == ((c) | ('A' ^ 'a')), \ | | ------------------ | | | | 115| 37.9k|#define check_exp(c,e) (e) | | ------------------ | | 73| 41.0k| (c) | ('A' ^ 'a')) ------------------ | Branch (254:14): [True: 37.9k, False: 3.02k] ------------------ 255| 41.0k| if (mode == 'n') /* reject 'inf' and 'nan' */ ------------------ | Branch (255:7): [True: 26, False: 40.9k] ------------------ 256| 26| return NULL; 257| 40.9k| endptr = l_str2dloc(s, result, mode); /* try to convert */ 258| 40.9k| if (endptr == NULL) { /* failed? may be a different locale */ ------------------ | Branch (258:7): [True: 18, False: 40.9k] ------------------ 259| 18| char buff[L_MAXLENNUM + 1]; 260| 18| const char *pdot = strchr(s, '.'); 261| 18| if (pdot == NULL || strlen(s) > L_MAXLENNUM) ------------------ | | 220| 7|#define L_MAXLENNUM 200 ------------------ | Branch (261:9): [True: 11, False: 7] | Branch (261:25): [True: 7, False: 0] ------------------ 262| 18| 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| 40.9k| return endptr; 270| 40.9k|} lobject.c:l_str2dloc: 228| 40.9k|static const char *l_str2dloc (const char *s, lua_Number *result, int mode) { 229| 40.9k| char *endptr; 230| | *result = (mode == 'x') ? lua_strx2number(s, &endptr) /* try to convert */ ------------------ | | 610| 1|#define lua_strx2number(s,p) lua_str2number(s,p) | | ------------------ | | | | 484| 1|#define lua_str2number(s,p) strtod((s), (p)) | | ------------------ ------------------ | Branch (230:13): [True: 1, False: 40.9k] ------------------ 231| 40.9k| : lua_str2number(s, &endptr); ------------------ | | 484| 81.9k|#define lua_str2number(s,p) strtod((s), (p)) ------------------ 232| 40.9k| if (endptr == s) return NULL; /* nothing recognized? */ ------------------ | Branch (232:7): [True: 5, False: 40.9k] ------------------ 233| 40.9k| while (lisspace(cast_uchar(*endptr))) endptr++; /* skip trailing spaces */ 234| 40.9k| return (*endptr == '\0') ? endptr : NULL; /* OK iff no trailing chars */ ------------------ | Branch (234:10): [True: 40.9k, False: 13] ------------------ 235| 40.9k|} lobject.c:tostringbuff: 355| 123k|static int tostringbuff (TValue *obj, char *buff) { 356| 123k| int len; 357| 123k| lua_assert(ttisnumber(obj)); ------------------ | | 114| 123k|#define lua_assert(c) ((void)0) ------------------ 358| 123k| if (ttisinteger(obj)) ------------------ | | 328| 123k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 123k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 123k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 110k, False: 12.9k] | | | | ------------------ | | ------------------ ------------------ 359| 110k| len = lua_integer2str(buff, MAXNUMBER2STR, ivalue(obj)); ------------------ | | 514| 110k| l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) | | ------------------ | | | | 597| 110k|#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) | | ------------------ ------------------ 360| 12.9k| else { 361| 12.9k| len = lua_number2str(buff, MAXNUMBER2STR, fltvalue(obj)); ------------------ | | 421| 12.9k| l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) | | ------------------ | | | | 597| 12.9k|#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) | | ------------------ ------------------ 362| 12.9k| if (buff[strspn(buff, "-0123456789")] == '\0') { /* looks like an int? */ ------------------ | Branch (362:9): [True: 10.3k, False: 2.59k] ------------------ 363| 10.3k| buff[len++] = lua_getlocaledecpoint(); ------------------ | | 671| 10.3k|#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) ------------------ 364| 10.3k| buff[len++] = '0'; /* adds '.0' to result */ 365| 10.3k| } 366| 12.9k| } 367| 123k| return len; 368| 123k|} lobject.c:addstr2buff: 453| 5.99k|static void addstr2buff (BuffFS *buff, const char *str, size_t slen) { 454| 5.99k| if (slen <= BUFVFS) { /* does string fit into buffer? */ ------------------ | | 394| 5.99k|#define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 768| 5.99k|#define LUA_IDSIZE 60 | | ------------------ | | #define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 349| 5.99k|#define MAXNUMBER2STR 44 | | ------------------ ------------------ | Branch (454:7): [True: 5.89k, False: 101] ------------------ 455| 5.89k| char *bf = getbuff(buff, cast_int(slen)); ------------------ | | 141| 5.89k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 5.89k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 456| 5.89k| memcpy(bf, str, slen); /* add string to buffer */ 457| 5.89k| addsize(buff, cast_int(slen)); ------------------ | | 446| 5.89k|#define addsize(b,sz) ((b)->blen += (sz)) ------------------ 458| 5.89k| } 459| 101| else { /* string larger than buffer */ 460| 101| clearbuff(buff); /* string comes after buffer's content */ 461| 101| pushstr(buff, str, slen); /* push string */ 462| 101| } 463| 5.99k|} lobject.c:pushstr: 414| 1.50k|static void pushstr (BuffFS *buff, const char *str, size_t lstr) { 415| 1.50k| lua_State *L = buff->L; 416| 1.50k| setsvalue2s(L, L->top.p, luaS_newlstr(L, str, lstr)); ------------------ | | 377| 1.50k|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 1.50k| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 1.50k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 1.50k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 1.50k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 1.50k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 1.50k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 1.50k| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 1.50k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 1.50k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 1.50k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 417| 1.50k| L->top.p++; /* may use one slot from EXTRA_STACK */ 418| 1.50k| if (!buff->pushed) /* no previous string on the stack? */ ------------------ | Branch (418:7): [True: 1.29k, False: 205] ------------------ 419| 1.29k| buff->pushed = 1; /* now there is one */ 420| 205| else /* join previous string with new one */ 421| 205| luaV_concat(L, 2); 422| 1.50k|} lobject.c:addnum2buff: 469| 554|static void addnum2buff (BuffFS *buff, TValue *num) { 470| 554| char *numbuff = getbuff(buff, MAXNUMBER2STR); ------------------ | | 349| 554|#define MAXNUMBER2STR 44 ------------------ 471| 554| int len = tostringbuff(num, numbuff); /* format number into 'numbuff' */ 472| 554| addsize(buff, len); ------------------ | | 446| 554|#define addsize(b,sz) ((b)->blen += (sz)) ------------------ 473| 554|} lobject.c:getbuff: 438| 6.45k|static char *getbuff (BuffFS *buff, int sz) { 439| 6.45k| lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS); ------------------ | | 114| 6.45k|#define lua_assert(c) ((void)0) ------------------ lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS); ------------------ | | 114| 6.45k|#define lua_assert(c) ((void)0) ------------------ 440| 6.45k| if (sz > BUFVFS - buff->blen) /* not enough space? */ ------------------ | | 394| 6.45k|#define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 768| 6.45k|#define LUA_IDSIZE 60 | | ------------------ | | #define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 349| 6.45k|#define MAXNUMBER2STR 44 | | ------------------ ------------------ | Branch (440:7): [True: 3, False: 6.44k] ------------------ 441| 3| clearbuff(buff); 442| 6.45k| return buff->space + buff->blen; 443| 6.45k|} lobject.c:clearbuff: 428| 1.40k|static void clearbuff (BuffFS *buff) { 429| 1.40k| pushstr(buff, buff->space, buff->blen); /* push buffer contents */ 430| 1.40k| buff->blen = 0; /* space now is empty */ 431| 1.40k|} luaY_nvarstack: 243| 32.7M|int luaY_nvarstack (FuncState *fs) { 244| 32.7M| return reglevel(fs, fs->nactvar); 245| 32.7M|} luaY_parser: 1943| 390| Dyndata *dyd, const char *name, int firstchar) { 1944| 390| LexState lexstate; 1945| 390| FuncState funcstate; 1946| 390| LClosure *cl = luaF_newLclosure(L, 1); /* create main closure */ 1947| 390| setclLvalue2s(L, L->top.p, cl); /* anchor it (to avoid being collected) */ ------------------ | | 613| 390|#define setclLvalue2s(L,o,cl) setclLvalue(L,s2v(o),cl) | | ------------------ | | | | 609| 390| { TValue *io = (obj); LClosure *x_ = (x); \ | | | | 610| 390| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 72| 390|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 390| 390|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 390|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 114| 390|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 611| 390| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 390| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 390|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 390| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1948| 390| luaD_inctop(L); 1949| 390| lexstate.h = luaH_new(L); /* create table for scanner */ 1950| 390| sethvalue2s(L, L->top.p, lexstate.h); /* anchor it */ ------------------ | | 689| 390|#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) | | ------------------ | | | | 685| 390| { TValue *io = (obj); Table *x_ = (x); \ | | | | 686| 390| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 72| 390|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 390| 390|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 390|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 114| 390|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 687| 390| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 390| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 390|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 390| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1951| 390| luaD_inctop(L); 1952| 390| funcstate.f = cl->p = luaF_newproto(L); 1953| 390| luaC_objbarrier(L, cl, cl->p); ------------------ | | 175| 390|#define luaC_objbarrier(L,p,o) ( \ | | 176| 390| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 390|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 390|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 780|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 390] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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| 390| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 390|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1954| 390| funcstate.f->source = luaS_new(L, name); /* create and anchor TString */ 1955| 390| luaC_objbarrier(L, funcstate.f, funcstate.f->source); ------------------ | | 175| 390|#define luaC_objbarrier(L,p,o) ( \ | | 176| 390| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 390|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 390|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 780|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 390] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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| 390| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 390|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1956| 390| lexstate.buff = buff; 1957| 390| lexstate.dyd = dyd; 1958| 390| dyd->actvar.n = dyd->gt.n = dyd->label.n = 0; 1959| 390| luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar); 1960| 390| mainfunc(&lexstate, &funcstate); 1961| 390| lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs); ------------------ | | 114| 390|#define lua_assert(c) ((void)0) ------------------ 1962| | /* all scopes should be correctly finished */ 1963| 390| lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0); ------------------ | | 114| 390|#define lua_assert(c) ((void)0) ------------------ 1964| 390| L->top.p--; /* remove scanner's table */ 1965| 390| return cl; /* closure is on the stack, too */ 1966| 390|} lparser.c:reglevel: 229| 32.7M|static int reglevel (FuncState *fs, int nvar) { 230| 37.1M| while (nvar-- > 0) { ------------------ | Branch (230:10): [True: 22.4M, False: 14.6M] ------------------ 231| 22.4M| Vardesc *vd = getlocalvardesc(fs, nvar); /* get previous variable */ 232| 22.4M| if (vd->vd.kind != RDKCTC) /* is in a register? */ ------------------ | | 93| 22.4M|#define RDKCTC 3 /* compile-time constant */ ------------------ | Branch (232:9): [True: 18.0M, False: 4.37M] ------------------ 233| 18.0M| return vd->vd.ridx + 1; 234| 22.4M| } 235| 14.6M| return 0; /* no variables in registers */ 236| 32.7M|} lparser.c:getlocalvardesc: 219| 124M|static Vardesc *getlocalvardesc (FuncState *fs, int vidx) { 220| 124M| return &fs->ls->dyd->actvar.arr[fs->firstlocal + vidx]; 221| 124M|} lparser.c:mainfunc: 1924| 390|static void mainfunc (LexState *ls, FuncState *fs) { 1925| 390| BlockCnt bl; 1926| 390| Upvaldesc *env; 1927| 390| open_func(ls, fs, &bl); 1928| 390| setvararg(fs, 0); /* main function is always declared vararg */ 1929| 390| env = allocupvalue(fs); /* ...set environment upvalue */ 1930| 390| env->instack = 1; 1931| 390| env->idx = 0; 1932| 390| env->kind = VDKREG; ------------------ | | 90| 390|#define VDKREG 0 /* regular */ ------------------ 1933| 390| env->name = ls->envn; 1934| 390| luaC_objbarrier(ls->L, fs->f, env->name); ------------------ | | 175| 390|#define luaC_objbarrier(L,p,o) ( \ | | 176| 390| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 390|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 390|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 780|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 390] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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| 390| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 390|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1935| 390| luaX_next(ls); /* read first token */ 1936| 390| statlist(ls); /* parse main body */ 1937| 390| check(ls, TK_EOS); 1938| 390| close_func(ls); 1939| 390|} lparser.c:open_func: 729| 3.55k|static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) { 730| 3.55k| Proto *f = fs->f; 731| 3.55k| fs->prev = ls->fs; /* linked list of funcstates */ 732| 3.55k| fs->ls = ls; 733| 3.55k| ls->fs = fs; 734| 3.55k| fs->pc = 0; 735| 3.55k| fs->previousline = f->linedefined; 736| 3.55k| fs->iwthabs = 0; 737| 3.55k| fs->lasttarget = 0; 738| 3.55k| fs->freereg = 0; 739| 3.55k| fs->nk = 0; 740| 3.55k| fs->nabslineinfo = 0; 741| 3.55k| fs->np = 0; 742| 3.55k| fs->nups = 0; 743| 3.55k| fs->ndebugvars = 0; 744| 3.55k| fs->nactvar = 0; 745| 3.55k| fs->needclose = 0; 746| 3.55k| fs->firstlocal = ls->dyd->actvar.n; 747| 3.55k| fs->firstlabel = ls->dyd->label.n; 748| 3.55k| fs->bl = NULL; 749| 3.55k| f->source = ls->source; 750| 3.55k| luaC_objbarrier(ls->L, f, f->source); ------------------ | | 175| 3.55k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 3.55k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 3.55k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 3.55k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 7.11k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 3.55k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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.55k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 3.55k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 3.55k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 751| 3.55k| f->maxstacksize = 2; /* registers 0/1 are always valid */ 752| 3.55k| enterblock(fs, bl, 0); 753| 3.55k|} lparser.c:enterblock: 642| 13.5k|static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) { 643| 13.5k| bl->isloop = isloop; 644| 13.5k| bl->nactvar = fs->nactvar; 645| 13.5k| bl->firstlabel = fs->ls->dyd->label.n; 646| 13.5k| bl->firstgoto = fs->ls->dyd->gt.n; 647| 13.5k| bl->upval = 0; 648| 13.5k| bl->insidetbc = (fs->bl != NULL && fs->bl->insidetbc); ------------------ | Branch (648:20): [True: 9.95k, False: 3.55k] | Branch (648:38): [True: 627, False: 9.32k] ------------------ 649| 13.5k| bl->previous = fs->bl; 650| 13.5k| fs->bl = bl; 651| 13.5k| lua_assert(fs->freereg == luaY_nvarstack(fs)); ------------------ | | 114| 13.5k|#define lua_assert(c) ((void)0) ------------------ 652| 13.5k|} lparser.c:setvararg: 953| 525|static void setvararg (FuncState *fs, int nparams) { 954| 525| fs->f->is_vararg = 1; 955| 525| luaK_codeABC(fs, OP_VARARGPREP, nparams, 0, 0); ------------------ | | 48| 525|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 956| 525|} lparser.c:allocupvalue: 352| 5.42k|static Upvaldesc *allocupvalue (FuncState *fs) { 353| 5.42k| Proto *f = fs->f; 354| 5.42k| int oldsize = f->sizeupvalues; 355| 5.42k| checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues"); ------------------ | | 29| 5.42k|#define MAXUPVAL 255 ------------------ 356| 5.42k| luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues, ------------------ | | 67| 5.42k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 10.8k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 5.42k| luaM_limitN(limit,t),e))) ------------------ 357| 5.42k| Upvaldesc, MAXUPVAL, "upvalues"); 358| 17.4k| while (oldsize < f->sizeupvalues) ------------------ | Branch (358:10): [True: 11.9k, False: 5.42k] ------------------ 359| 11.9k| f->upvalues[oldsize++].name = NULL; 360| 5.42k| return &f->upvalues[fs->nups++]; 361| 5.42k|} lparser.c:checklimit: 87| 24.7k|static void checklimit (FuncState *fs, int v, int l, const char *what) { 88| 24.7k| if (v > l) errorlimit(fs, l, what); ------------------ | Branch (88:7): [True: 1, False: 24.6k] ------------------ 89| 24.7k|} lparser.c:errorlimit: 74| 1|static l_noret errorlimit (FuncState *fs, int limit, const char *what) { 75| 1| lua_State *L = fs->ls->L; 76| 1| const char *msg; 77| 1| int line = fs->f->linedefined; 78| 1| const char *where = (line == 0) ------------------ | Branch (78:23): [True: 1, False: 0] ------------------ 79| 1| ? "main function" 80| 1| : luaO_pushfstring(L, "function at line %d", line); 81| 1| msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s", 82| 1| what, limit, where); 83| 1| luaX_syntaxerror(fs->ls, msg); 84| 1|} lparser.c:statlist: 799| 9.41k|static void statlist (LexState *ls) { 800| | /* statlist -> { stat [';'] } */ 801| 95.2k| while (!block_follow(ls, 1)) { ------------------ | Branch (801:10): [True: 88.8k, False: 6.45k] ------------------ 802| 88.8k| if (ls->t.token == TK_RETURN) { ------------------ | Branch (802:9): [True: 2.95k, False: 85.8k] ------------------ 803| 2.95k| statement(ls); 804| 2.95k| return; /* 'return' must be last statement */ 805| 2.95k| } 806| 85.8k| statement(ls); 807| 85.8k| } 808| 9.41k|} lparser.c:block_follow: 788| 97.8k|static int block_follow (LexState *ls, int withuntil) { 789| 97.8k| switch (ls->t.token) { 790| 509| case TK_ELSE: case TK_ELSEIF: ------------------ | Branch (790:5): [True: 508, False: 97.3k] | Branch (790:19): [True: 1, False: 97.8k] ------------------ 791| 4.60k| case TK_END: case TK_EOS: ------------------ | Branch (791:5): [True: 4.01k, False: 93.8k] | Branch (791:18): [True: 80, False: 97.7k] ------------------ 792| 4.60k| return 1; 793| 426| case TK_UNTIL: return withuntil; ------------------ | Branch (793:5): [True: 426, False: 97.4k] ------------------ 794| 92.8k| default: return 0; ------------------ | Branch (794:5): [True: 92.8k, False: 5.03k] ------------------ 795| 97.8k| } 796| 97.8k|} lparser.c:statement: 1845| 88.8k|static void statement (LexState *ls) { 1846| 88.8k| int line = ls->linenumber; /* may be needed for error messages */ 1847| 88.8k| enterlevel(ls); ------------------ | | 504| 88.8k|#define enterlevel(ls) luaE_incCstack(ls->L) ------------------ 1848| 88.8k| switch (ls->t.token) { 1849| 33.1k| case ';': { /* stat -> ';' (empty statement) */ ------------------ | Branch (1849:5): [True: 33.1k, False: 55.6k] ------------------ 1850| 33.1k| luaX_next(ls); /* skip ';' */ 1851| 33.1k| break; 1852| 0| } 1853| 1.67k| case TK_IF: { /* stat -> ifstat */ ------------------ | Branch (1853:5): [True: 1.67k, False: 87.1k] ------------------ 1854| 1.67k| ifstat(ls, line); 1855| 1.67k| break; 1856| 0| } 1857| 1.11k| case TK_WHILE: { /* stat -> whilestat */ ------------------ | Branch (1857:5): [True: 1.11k, False: 87.7k] ------------------ 1858| 1.11k| whilestat(ls, line); 1859| 1.11k| break; 1860| 0| } 1861| 1.91k| case TK_DO: { /* stat -> DO block END */ ------------------ | Branch (1861:5): [True: 1.91k, False: 86.9k] ------------------ 1862| 1.91k| luaX_next(ls); /* skip DO */ 1863| 1.91k| block(ls); 1864| 1.91k| check_match(ls, TK_END, TK_DO, line); 1865| 1.91k| break; 1866| 0| } 1867| 591| case TK_FOR: { /* stat -> forstat */ ------------------ | Branch (1867:5): [True: 591, False: 88.2k] ------------------ 1868| 591| forstat(ls, line); 1869| 591| break; 1870| 0| } 1871| 933| case TK_REPEAT: { /* stat -> repeatstat */ ------------------ | Branch (1871:5): [True: 933, False: 87.9k] ------------------ 1872| 933| repeatstat(ls, line); 1873| 933| break; 1874| 0| } 1875| 1.77k| case TK_FUNCTION: { /* stat -> funcstat */ ------------------ | Branch (1875:5): [True: 1.77k, False: 87.0k] ------------------ 1876| 1.77k| funcstat(ls, line); 1877| 1.77k| break; 1878| 0| } 1879| 3.98k| case TK_LOCAL: { /* stat -> localstat */ ------------------ | Branch (1879:5): [True: 3.98k, False: 84.8k] ------------------ 1880| 3.98k| luaX_next(ls); /* skip LOCAL */ 1881| 3.98k| if (testnext(ls, TK_FUNCTION)) /* local function? */ ------------------ | Branch (1881:11): [True: 412, False: 3.57k] ------------------ 1882| 412| localfunc(ls); 1883| 3.57k| else 1884| 3.57k| localstat(ls); 1885| 3.98k| break; 1886| 0| } 1887| 275| case TK_DBCOLON: { /* stat -> label */ ------------------ | Branch (1887:5): [True: 275, False: 88.5k] ------------------ 1888| 275| luaX_next(ls); /* skip double colon */ 1889| 275| labelstat(ls, str_checkname(ls), line); 1890| 275| break; 1891| 0| } 1892| 2.95k| case TK_RETURN: { /* stat -> retstat */ ------------------ | Branch (1892:5): [True: 2.95k, False: 85.8k] ------------------ 1893| 2.95k| luaX_next(ls); /* skip RETURN */ 1894| 2.95k| retstat(ls); 1895| 2.95k| break; 1896| 0| } 1897| 1.35k| case TK_BREAK: { /* stat -> breakstat */ ------------------ | Branch (1897:5): [True: 1.35k, False: 87.4k] ------------------ 1898| 1.35k| breakstat(ls); 1899| 1.35k| break; 1900| 0| } 1901| 13.3k| case TK_GOTO: { /* stat -> 'goto' NAME */ ------------------ | Branch (1901:5): [True: 13.3k, False: 75.5k] ------------------ 1902| 13.3k| luaX_next(ls); /* skip 'goto' */ 1903| 13.3k| gotostat(ls); 1904| 13.3k| break; 1905| 0| } 1906| 25.7k| default: { /* stat -> func | assignment */ ------------------ | Branch (1906:5): [True: 25.7k, False: 63.0k] ------------------ 1907| 25.7k| exprstat(ls); 1908| 25.7k| break; 1909| 0| } 1910| 88.8k| } 1911| 86.5k| lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg && ------------------ | | 114| 86.5k|#define lua_assert(c) ((void)0) ------------------ 1912| 86.5k| ls->fs->freereg >= luaY_nvarstack(ls->fs)); 1913| 86.5k| ls->fs->freereg = luaY_nvarstack(ls->fs); /* free registers */ 1914| 86.5k| leavelevel(ls); ------------------ | | 507| 86.5k|#define leavelevel(ls) ((ls)->L->nCcalls--) ------------------ 1915| 86.5k|} lparser.c:ifstat: 1675| 1.67k|static void ifstat (LexState *ls, int line) { 1676| | /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */ 1677| 1.67k| FuncState *fs = ls->fs; 1678| 1.67k| int escapelist = NO_JUMP; /* exit list for finished parts */ ------------------ | | 20| 1.67k|#define NO_JUMP (-1) ------------------ 1679| 1.67k| test_then_block(ls, &escapelist); /* IF cond THEN block */ 1680| 1.68k| while (ls->t.token == TK_ELSEIF) ------------------ | Branch (1680:10): [True: 2, False: 1.67k] ------------------ 1681| 2| test_then_block(ls, &escapelist); /* ELSEIF cond THEN block */ 1682| 1.67k| if (testnext(ls, TK_ELSE)) ------------------ | Branch (1682:7): [True: 508, False: 1.17k] ------------------ 1683| 508| block(ls); /* 'else' part */ 1684| 1.67k| check_match(ls, TK_END, TK_IF, line); 1685| 1.67k| luaK_patchtohere(fs, escapelist); /* patch escape list to 'if' end */ 1686| 1.67k|} lparser.c:test_then_block: 1638| 1.68k|static void test_then_block (LexState *ls, int *escapelist) { 1639| | /* test_then_block -> [IF | ELSEIF] cond THEN block */ 1640| 1.68k| BlockCnt bl; 1641| 1.68k| FuncState *fs = ls->fs; 1642| 1.68k| expdesc v; 1643| 1.68k| int jf; /* instruction to skip 'then' code (if condition is false) */ 1644| 1.68k| luaX_next(ls); /* skip IF or ELSEIF */ 1645| 1.68k| expr(ls, &v); /* read condition */ 1646| 1.68k| checknext(ls, TK_THEN); 1647| 1.68k| if (ls->t.token == TK_BREAK) { /* 'if x then break' ? */ ------------------ | Branch (1647:7): [True: 1.67k, False: 3] ------------------ 1648| 1.67k| int line = ls->linenumber; 1649| 1.67k| luaK_goiffalse(ls->fs, &v); /* will jump if condition is true */ 1650| 1.67k| luaX_next(ls); /* skip 'break' */ 1651| 1.67k| enterblock(fs, &bl, 0); /* must enter block before 'goto' */ 1652| 1.67k| newgotoentry(ls, luaS_newliteral(ls->L, "break"), line, v.t); ------------------ | | 28| 1.67k|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 1.67k| (sizeof(s)/sizeof(char))-1)) ------------------ 1653| 1.68k| while (testnext(ls, ';')) {} /* skip semicolons */ ------------------ | Branch (1653:12): [True: 6, False: 1.67k] ------------------ 1654| 1.67k| if (block_follow(ls, 0)) { /* jump is the entire block? */ ------------------ | Branch (1654:9): [True: 864, False: 813] ------------------ 1655| 864| leaveblock(fs); 1656| 864| return; /* and that is it */ 1657| 864| } 1658| 813| else /* must skip over 'then' part if condition is false */ 1659| 813| jf = luaK_jump(fs); 1660| 1.67k| } 1661| 3| else { /* regular case (not a break) */ 1662| 3| luaK_goiftrue(ls->fs, &v); /* skip over block if condition is false */ 1663| 3| enterblock(fs, &bl, 0); 1664| 3| jf = v.f; 1665| 3| } 1666| 816| statlist(ls); /* 'then' part */ 1667| 816| leaveblock(fs); 1668| 816| if (ls->t.token == TK_ELSE || ------------------ | Branch (1668:7): [True: 358, False: 458] ------------------ 1669| 816| ls->t.token == TK_ELSEIF) /* followed by 'else'/'elseif'? */ ------------------ | Branch (1669:7): [True: 2, False: 456] ------------------ 1670| 70| luaK_concat(fs, escapelist, luaK_jump(fs)); /* must jump over it */ 1671| 816| luaK_patchtohere(fs, jf); 1672| 816|} lparser.c:expr: 1290| 198k|static void expr (LexState *ls, expdesc *v) { 1291| 198k| subexpr(ls, v, 0); 1292| 198k|} lparser.c:subexpr: 1260| 13.5M|static BinOpr subexpr (LexState *ls, expdesc *v, int limit) { 1261| 13.5M| BinOpr op; 1262| 13.5M| UnOpr uop; 1263| 13.5M| enterlevel(ls); ------------------ | | 504| 13.5M|#define enterlevel(ls) luaE_incCstack(ls->L) ------------------ 1264| 13.5M| uop = getunopr(ls->t.token); 1265| 13.5M| if (uop != OPR_NOUNOPR) { /* prefix (unary) operator? */ ------------------ | Branch (1265:7): [True: 326k, False: 13.2M] ------------------ 1266| 326k| int line = ls->linenumber; 1267| 326k| luaX_next(ls); /* skip operator */ 1268| 326k| subexpr(ls, v, UNARY_PRIORITY); ------------------ | | 1253| 326k|#define UNARY_PRIORITY 12 /* priority for unary operators */ ------------------ 1269| 326k| luaK_prefix(ls->fs, uop, v, line); 1270| 326k| } 1271| 13.2M| else simpleexp(ls, v); 1272| | /* expand while operators have priorities higher than 'limit' */ 1273| 13.5M| op = getbinopr(ls->t.token); 1274| 26.6M| while (op != OPR_NOBINOPR && priority[op].left > limit) { ------------------ | Branch (1274:10): [True: 26.2M, False: 327k] | Branch (1274:32): [True: 13.0M, False: 13.2M] ------------------ 1275| 13.0M| expdesc v2; 1276| 13.0M| BinOpr nextop; 1277| 13.0M| int line = ls->linenumber; 1278| 13.0M| luaX_next(ls); /* skip operator */ 1279| 13.0M| luaK_infix(ls->fs, op, v); 1280| | /* read sub-expression with higher priority */ 1281| 13.0M| nextop = subexpr(ls, &v2, priority[op].right); 1282| 13.0M| luaK_posfix(ls->fs, op, v, &v2, line); 1283| 13.0M| op = nextop; 1284| 13.0M| } 1285| 13.5M| leavelevel(ls); ------------------ | | 507| 13.5M|#define leavelevel(ls) ((ls)->L->nCcalls--) ------------------ 1286| 13.5M| return op; /* return first untreated operator */ 1287| 13.5M|} lparser.c:getunopr: 1195| 13.5M|static UnOpr getunopr (int op) { 1196| 13.5M| switch (op) { 1197| 7.32k| case TK_NOT: return OPR_NOT; ------------------ | Branch (1197:5): [True: 7.32k, False: 13.5M] ------------------ 1198| 176k| case '-': return OPR_MINUS; ------------------ | Branch (1198:5): [True: 176k, False: 13.3M] ------------------ 1199| 106k| case '~': return OPR_BNOT; ------------------ | Branch (1199:5): [True: 106k, False: 13.4M] ------------------ 1200| 36.6k| case '#': return OPR_LEN; ------------------ | Branch (1200:5): [True: 36.6k, False: 13.5M] ------------------ 1201| 13.2M| default: return OPR_NOUNOPR; ------------------ | Branch (1201:5): [True: 13.2M, False: 326k] ------------------ 1202| 13.5M| } 1203| 13.5M|} lparser.c:simpleexp: 1140| 13.2M|static void simpleexp (LexState *ls, expdesc *v) { 1141| | /* simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... | 1142| | constructor | FUNCTION body | suffixedexp */ 1143| 13.2M| switch (ls->t.token) { 1144| 40.9k| case TK_FLT: { ------------------ | Branch (1144:5): [True: 40.9k, False: 13.1M] ------------------ 1145| 40.9k| init_exp(v, VKFLT, 0); 1146| 40.9k| v->u.nval = ls->t.seminfo.r; 1147| 40.9k| break; 1148| 0| } 1149| 308k| case TK_INT: { ------------------ | Branch (1149:5): [True: 308k, False: 12.9M] ------------------ 1150| 308k| init_exp(v, VKINT, 0); 1151| 308k| v->u.ival = ls->t.seminfo.i; 1152| 308k| break; 1153| 0| } 1154| 8.31k| case TK_STRING: { ------------------ | Branch (1154:5): [True: 8.31k, False: 13.2M] ------------------ 1155| 8.31k| codestring(v, ls->t.seminfo.ts); 1156| 8.31k| break; 1157| 0| } 1158| 91.5k| case TK_NIL: { ------------------ | Branch (1158:5): [True: 91.5k, False: 13.1M] ------------------ 1159| 91.5k| init_exp(v, VNIL, 0); 1160| 91.5k| break; 1161| 0| } 1162| 3.44k| case TK_TRUE: { ------------------ | Branch (1162:5): [True: 3.44k, False: 13.2M] ------------------ 1163| 3.44k| init_exp(v, VTRUE, 0); 1164| 3.44k| break; 1165| 0| } 1166| 7| case TK_FALSE: { ------------------ | Branch (1166:5): [True: 7, False: 13.2M] ------------------ 1167| 7| init_exp(v, VFALSE, 0); 1168| 7| break; 1169| 0| } 1170| 1.17k| case TK_DOTS: { /* vararg */ ------------------ | Branch (1170:5): [True: 1.17k, False: 13.2M] ------------------ 1171| 1.17k| FuncState *fs = ls->fs; 1172| 1.17k| check_condition(ls, fs->f->is_vararg, ------------------ | | 122| 1.17k|#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } | | ------------------ | | | Branch (122:41): [True: 0, False: 1.17k] | | ------------------ ------------------ 1173| 1.17k| "cannot use '...' outside a vararg function"); 1174| 1.17k| init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 0, 1)); ------------------ | | 48| 1.17k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1175| 1.17k| break; 1176| 1.17k| } 1177| 255| case '{': { /* constructor */ ------------------ | Branch (1177:5): [True: 255, False: 13.2M] ------------------ 1178| 255| constructor(ls, v); 1179| 255| return; 1180| 1.17k| } 1181| 980| case TK_FUNCTION: { ------------------ | Branch (1181:5): [True: 980, False: 13.2M] ------------------ 1182| 980| luaX_next(ls); 1183| 980| body(ls, v, 0, ls->linenumber); 1184| 980| return; 1185| 1.17k| } 1186| 12.7M| default: { ------------------ | Branch (1186:5): [True: 12.7M, False: 454k] ------------------ 1187| 12.7M| suffixedexp(ls, v); 1188| 12.7M| return; 1189| 1.17k| } 1190| 13.2M| } 1191| 453k| luaX_next(ls); 1192| 453k|} lparser.c:init_exp: 152| 26.1M|static void init_exp (expdesc *e, expkind k, int i) { 153| 26.1M| e->f = e->t = NO_JUMP; ------------------ | | 20| 26.1M|#define NO_JUMP (-1) ------------------ 154| 26.1M| e->k = k; 155| 26.1M| e->u.info = i; 156| 26.1M|} lparser.c:codestring: 159| 13.0M|static void codestring (expdesc *e, TString *s) { 160| 13.0M| e->f = e->t = NO_JUMP; ------------------ | | 20| 13.0M|#define NO_JUMP (-1) ------------------ 161| 13.0M| e->k = VKSTR; 162| 13.0M| e->u.strval = s; 163| 13.0M|} lparser.c:constructor: 925| 269|static void constructor (LexState *ls, expdesc *t) { 926| | /* constructor -> '{' [ field { sep field } [sep] ] '}' 927| | sep -> ',' | ';' */ 928| 269| FuncState *fs = ls->fs; 929| 269| int line = ls->linenumber; 930| 269| int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0); ------------------ | | 48| 269|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 931| 269| ConsControl cc; 932| 269| luaK_code(fs, 0); /* space for extra arg. */ 933| 269| cc.na = cc.nh = cc.tostore = 0; 934| 269| cc.t = t; 935| 269| init_exp(t, VNONRELOC, fs->freereg); /* table will be at stack top */ 936| 269| luaK_reserveregs(fs, 1); 937| 269| init_exp(&cc.v, VVOID, 0); /* no value (yet) */ 938| 269| checknext(ls, '{'); 939| 360| do { 940| 360| lua_assert(cc.v.k == VVOID || cc.tostore > 0); ------------------ | | 114| 360|#define lua_assert(c) ((void)0) ------------------ 941| 360| if (ls->t.token == '}') break; ------------------ | Branch (941:9): [True: 182, False: 178] ------------------ 942| 178| closelistfield(fs, &cc); 943| 178| field(ls, &cc); 944| 178| } while (testnext(ls, ',') || testnext(ls, ';')); ------------------ | Branch (944:12): [True: 128, False: 50] | Branch (944:33): [True: 4, False: 46] ------------------ 945| 0| check_match(ls, '}', '{', line); 946| 269| lastlistfield(fs, &cc); 947| 269| luaK_settablesize(fs, pc, t->u.info, cc.na, cc.nh); 948| 269|} lparser.c:closelistfield: 868| 177|static void closelistfield (FuncState *fs, ConsControl *cc) { 869| 177| if (cc->v.k == VVOID) return; /* there is no list item */ ------------------ | Branch (869:7): [True: 86, False: 91] ------------------ 870| 91| luaK_exp2nextreg(fs, &cc->v); 871| 91| cc->v.k = VVOID; 872| 91| if (cc->tostore == LFIELDS_PER_FLUSH) { ------------------ | | 403| 91|#define LFIELDS_PER_FLUSH 50 ------------------ | Branch (872:7): [True: 0, False: 91] ------------------ 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| 91|} lparser.c:field: 903| 177|static void field (LexState *ls, ConsControl *cc) { 904| | /* field -> listfield | recfield */ 905| 177| switch(ls->t.token) { 906| 134| case TK_NAME: { /* may be 'listfield' or 'recfield' */ ------------------ | Branch (906:5): [True: 134, False: 43] ------------------ 907| 134| if (luaX_lookahead(ls) != '=') /* expression? */ ------------------ | Branch (907:11): [True: 133, False: 1] ------------------ 908| 133| listfield(ls, cc); 909| 1| else 910| 1| recfield(ls, cc); 911| 134| break; 912| 0| } 913| 2| case '[': { ------------------ | Branch (913:5): [True: 2, False: 175] ------------------ 914| 2| recfield(ls, cc); 915| 2| break; 916| 0| } 917| 41| default: { ------------------ | Branch (917:5): [True: 41, False: 136] ------------------ 918| 41| listfield(ls, cc); 919| 41| break; 920| 0| } 921| 177| } 922| 177|} lparser.c:listfield: 896| 174|static void listfield (LexState *ls, ConsControl *cc) { 897| | /* listfield -> exp */ 898| 174| expr(ls, &cc->v); 899| 174| cc->tostore++; 900| 174|} 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| 6.24k|static void codename (LexState *ls, expdesc *e) { 167| 6.24k| codestring(e, str_checkname(ls)); 168| 6.24k|} lparser.c:yindex: 822| 23.3k|static void yindex (LexState *ls, expdesc *v) { 823| | /* index -> '[' expr ']' */ 824| 23.3k| luaX_next(ls); /* skip the '[' */ 825| 23.3k| expr(ls, v); 826| 23.3k| luaK_exp2val(ls->fs, v); 827| 23.3k| checknext(ls, ']'); 828| 23.3k|} lparser.c:lastlistfield: 880| 228|static void lastlistfield (FuncState *fs, ConsControl *cc) { 881| 228| if (cc->tostore == 0) return; ------------------ | Branch (881:7): [True: 182, False: 46] ------------------ 882| 46| if (hasmultret(cc->v.k)) { ------------------ | | 38| 46|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 0, False: 46] | | | Branch (38:41): [True: 4, False: 42] | | ------------------ ------------------ 883| 4| luaK_setmultret(fs, &cc->v); ------------------ | | 58| 4|#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) | | ------------------ | | | | 35| 4|#define LUA_MULTRET (-1) | | ------------------ ------------------ 884| 4| luaK_setlist(fs, cc->t->u.info, cc->na, LUA_MULTRET); ------------------ | | 35| 4|#define LUA_MULTRET (-1) ------------------ 885| 4| cc->na--; /* do not count last expression (unknown number of elements) */ 886| 4| } 887| 42| else { 888| 42| if (cc->v.k != VVOID) ------------------ | Branch (888:9): [True: 42, False: 0] ------------------ 889| 42| luaK_exp2nextreg(fs, &cc->v); 890| 42| luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); 891| 42| } 892| 46| cc->na += cc->tostore; 893| 46|} lparser.c:body: 990| 3.16k|static void body (LexState *ls, expdesc *e, int ismethod, int line) { 991| | /* body -> '(' parlist ')' block END */ 992| 3.16k| FuncState new_fs; 993| 3.16k| BlockCnt bl; 994| 3.16k| new_fs.f = addprototype(ls); 995| 3.16k| new_fs.f->linedefined = line; 996| 3.16k| open_func(ls, &new_fs, &bl); 997| 3.16k| checknext(ls, '('); 998| 3.16k| if (ismethod) { ------------------ | Branch (998:7): [True: 9, False: 3.15k] ------------------ 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| 3.16k| parlist(ls); 1003| 3.16k| checknext(ls, ')'); 1004| 3.16k| statlist(ls); 1005| 3.16k| new_fs.f->lastlinedefined = ls->linenumber; 1006| 3.16k| check_match(ls, TK_END, TK_FUNCTION, line); 1007| 3.16k| codeclosure(ls, e); 1008| 3.16k| close_func(ls); 1009| 3.16k|} lparser.c:addprototype: 698| 3.16k|static Proto *addprototype (LexState *ls) { 699| 3.16k| Proto *clp; 700| 3.16k| lua_State *L = ls->L; 701| 3.16k| FuncState *fs = ls->fs; 702| 3.16k| Proto *f = fs->f; /* prototype of current function */ 703| 3.16k| if (fs->np >= f->sizep) { ------------------ | Branch (703:7): [True: 987, False: 2.18k] ------------------ 704| 987| int oldsize = f->sizep; 705| 987| luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions"); ------------------ | | 67| 987| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 1.97k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 987| luaM_limitN(limit,t),e))) ------------------ 706| 7.42k| while (oldsize < f->sizep) ------------------ | Branch (706:12): [True: 6.43k, False: 987] ------------------ 707| 6.43k| f->p[oldsize++] = NULL; 708| 987| } 709| 3.16k| f->p[fs->np++] = clp = luaF_newproto(L); 710| 3.16k| luaC_objbarrier(L, f, clp); ------------------ | | 175| 3.16k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 3.16k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 3.16k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 3.16k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 6.33k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 3.16k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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.16k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 3.16k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 3.16k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 711| 3.16k| return clp; 712| 3.16k|} lparser.c:new_localvar: 193| 19.2k|static int new_localvar (LexState *ls, TString *name) { 194| 19.2k| lua_State *L = ls->L; 195| 19.2k| FuncState *fs = ls->fs; 196| 19.2k| Dyndata *dyd = ls->dyd; 197| 19.2k| Vardesc *var; 198| 19.2k| checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal, 199| 19.2k| MAXVARS, "local variables"); ------------------ | | 35| 19.2k|#define MAXVARS 200 ------------------ 200| 19.2k| luaM_growvector(L, dyd->actvar.arr, dyd->actvar.n + 1, ------------------ | | 67| 19.2k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 38.5k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 19.2k| luaM_limitN(limit,t),e))) ------------------ 201| 19.2k| dyd->actvar.size, Vardesc, USHRT_MAX, "local variables"); 202| 19.2k| var = &dyd->actvar.arr[dyd->actvar.n++]; 203| 19.2k| var->vd.kind = VDKREG; /* default */ ------------------ | | 90| 19.2k|#define VDKREG 0 /* regular */ ------------------ 204| 19.2k| var->vd.name = name; 205| 19.2k| return dyd->actvar.n - 1 - fs->firstlocal; 206| 19.2k|} lparser.c:adjustlocalvars: 311| 8.33k|static void adjustlocalvars (LexState *ls, int nvars) { 312| 8.33k| FuncState *fs = ls->fs; 313| 8.33k| int reglevel = luaY_nvarstack(fs); 314| 8.33k| int i; 315| 25.6k| for (i = 0; i < nvars; i++) { ------------------ | Branch (315:15): [True: 17.3k, False: 8.33k] ------------------ 316| 17.3k| int vidx = fs->nactvar++; 317| 17.3k| Vardesc *var = getlocalvardesc(fs, vidx); 318| 17.3k| var->vd.ridx = reglevel++; 319| 17.3k| var->vd.pidx = registerlocalvar(ls, fs, var->vd.name); 320| 17.3k| } 321| 8.33k|} lparser.c:registerlocalvar: 175| 17.3k|static int registerlocalvar (LexState *ls, FuncState *fs, TString *varname) { 176| 17.3k| Proto *f = fs->f; 177| 17.3k| int oldsize = f->sizelocvars; 178| 17.3k| luaM_growvector(ls->L, f->locvars, fs->ndebugvars, f->sizelocvars, ------------------ | | 67| 17.3k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 34.6k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 17.3k| luaM_limitN(limit,t),e))) ------------------ 179| 17.3k| LocVar, SHRT_MAX, "local variables"); 180| 41.6k| while (oldsize < f->sizelocvars) ------------------ | Branch (180:10): [True: 24.3k, False: 17.3k] ------------------ 181| 24.3k| f->locvars[oldsize++].varname = NULL; 182| 17.3k| f->locvars[fs->ndebugvars].varname = varname; 183| 17.3k| f->locvars[fs->ndebugvars].startpc = fs->pc; 184| 17.3k| luaC_objbarrier(ls->L, f, varname); ------------------ | | 175| 17.3k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 17.3k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 17.3k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 17.3k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 34.6k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 17.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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| 17.3k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 17.3k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 17.3k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 185| 17.3k| return fs->ndebugvars++; 186| 17.3k|} lparser.c:parlist: 959| 3.16k|static void parlist (LexState *ls) { 960| | /* parlist -> [ {NAME ','} (NAME | '...') ] */ 961| 3.16k| FuncState *fs = ls->fs; 962| 3.16k| Proto *f = fs->f; 963| 3.16k| int nparams = 0; 964| 3.16k| int isvararg = 0; 965| 3.16k| if (ls->t.token != ')') { /* is 'parlist' not empty? */ ------------------ | Branch (965:7): [True: 1.41k, False: 1.75k] ------------------ 966| 9.99k| do { 967| 9.99k| switch (ls->t.token) { 968| 9.86k| case TK_NAME: { ------------------ | Branch (968:9): [True: 9.86k, False: 135] ------------------ 969| 9.86k| new_localvar(ls, str_checkname(ls)); 970| 9.86k| nparams++; 971| 9.86k| break; 972| 0| } 973| 135| case TK_DOTS: { ------------------ | Branch (973:9): [True: 135, False: 9.86k] ------------------ 974| 135| luaX_next(ls); 975| 135| isvararg = 1; 976| 135| break; 977| 0| } 978| 0| default: luaX_syntaxerror(ls, " or '...' expected"); ------------------ | Branch (978:9): [True: 0, False: 9.99k] ------------------ 979| 9.99k| } 980| 9.99k| } while (!isvararg && testnext(ls, ',')); ------------------ | Branch (980:14): [True: 9.86k, False: 135] | Branch (980:27): [True: 8.57k, False: 1.28k] ------------------ 981| 1.41k| } 982| 3.16k| adjustlocalvars(ls, nparams); 983| 3.16k| f->numparams = cast_byte(fs->nactvar); ------------------ | | 143| 3.16k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 3.16k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 984| 3.16k| if (isvararg) ------------------ | Branch (984:7): [True: 135, False: 3.03k] ------------------ 985| 135| setvararg(fs, f->numparams); /* declared vararg */ 986| 3.16k| luaK_reserveregs(fs, fs->nactvar); /* reserve registers for parameters */ 987| 3.16k|} lparser.c:codeclosure: 722| 2.71k|static void codeclosure (LexState *ls, expdesc *v) { 723| 2.71k| FuncState *fs = ls->fs->prev; 724| 2.71k| init_exp(v, VRELOC, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1)); 725| 2.71k| luaK_exp2nextreg(fs, v); /* fix it at the last register */ 726| 2.71k|} lparser.c:suffixedexp: 1103| 12.8M|static void suffixedexp (LexState *ls, expdesc *v) { 1104| | /* suffixedexp -> 1105| | primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */ 1106| 12.8M| FuncState *fs = ls->fs; 1107| 12.8M| primaryexp(ls, v); 1108| 13.2M| for (;;) { 1109| 13.2M| switch (ls->t.token) { 1110| 5.06k| case '.': { /* fieldsel */ ------------------ | Branch (1110:7): [True: 5.06k, False: 13.2M] ------------------ 1111| 5.06k| fieldsel(ls, v); 1112| 5.06k| break; 1113| 0| } 1114| 23.3k| case '[': { /* '[' exp ']' */ ------------------ | Branch (1114:7): [True: 23.3k, False: 13.2M] ------------------ 1115| 23.3k| expdesc key; 1116| 23.3k| luaK_exp2anyregup(fs, v); 1117| 23.3k| yindex(ls, &key); 1118| 23.3k| luaK_indexed(fs, v, &key); 1119| 23.3k| break; 1120| 0| } 1121| 1.17k| case ':': { /* ':' NAME funcargs */ ------------------ | Branch (1121:7): [True: 1.17k, False: 13.2M] ------------------ 1122| 1.17k| expdesc key; 1123| 1.17k| luaX_next(ls); 1124| 1.17k| codename(ls, &key); 1125| 1.17k| luaK_self(fs, v, &key); 1126| 1.17k| funcargs(ls, v); 1127| 1.17k| break; 1128| 0| } 1129| 435k| case '(': case TK_STRING: case '{': { /* funcargs */ ------------------ | Branch (1129:7): [True: 39.7k, False: 13.2M] | Branch (1129:17): [True: 396k, False: 12.8M] | Branch (1129:33): [True: 14, False: 13.2M] ------------------ 1130| 435k| luaK_exp2nextreg(fs, v); 1131| 435k| funcargs(ls, v); 1132| 435k| break; 1133| 435k| } 1134| 12.8M| default: return; ------------------ | Branch (1134:7): [True: 12.8M, False: 465k] ------------------ 1135| 13.2M| } 1136| 13.2M| } 1137| 12.8M|} lparser.c:primaryexp: 1081| 12.8M|static void primaryexp (LexState *ls, expdesc *v) { 1082| | /* primaryexp -> NAME | '(' expr ')' */ 1083| 12.8M| switch (ls->t.token) { 1084| 68.9k| case '(': { ------------------ | Branch (1084:5): [True: 68.9k, False: 12.7M] ------------------ 1085| 68.9k| int line = ls->linenumber; 1086| 68.9k| luaX_next(ls); 1087| 68.9k| expr(ls, v); 1088| 68.9k| check_match(ls, ')', '(', line); 1089| 68.9k| luaK_dischargevars(ls->fs, v); 1090| 68.9k| return; 1091| 0| } 1092| 12.7M| case TK_NAME: { ------------------ | Branch (1092:5): [True: 12.7M, False: 69.0k] ------------------ 1093| 12.7M| singlevar(ls, v); 1094| 12.7M| return; 1095| 0| } 1096| 105| default: { ------------------ | Branch (1096:5): [True: 105, False: 12.8M] ------------------ 1097| 105| luaX_syntaxerror(ls, "unexpected symbol"); 1098| 0| } 1099| 12.8M| } 1100| 12.8M|} lparser.c:singlevar: 463| 12.7M|static void singlevar (LexState *ls, expdesc *var) { 464| 12.7M| TString *varname = str_checkname(ls); 465| 12.7M| FuncState *fs = ls->fs; 466| 12.7M| singlevaraux(fs, varname, var, 1); 467| 12.7M| if (var->k == VVOID) { /* global name? */ ------------------ | Branch (467:7): [True: 12.6M, False: 69.8k] ------------------ 468| 12.6M| expdesc key; 469| 12.6M| singlevaraux(fs, ls->envn, var, 1); /* get environment variable */ 470| 12.6M| lua_assert(var->k != VVOID); /* this one must exist */ ------------------ | | 114| 12.6M|#define lua_assert(c) ((void)0) ------------------ 471| 12.6M| luaK_exp2anyregup(fs, var); /* but could be a constant */ 472| 12.6M| codestring(&key, varname); /* key is variable name */ 473| 12.6M| luaK_indexed(fs, var, &key); /* env[varname] */ 474| 12.6M| } 475| 12.7M|} lparser.c:singlevaraux: 435| 38.8M|static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { 436| 38.8M| if (fs == NULL) /* no more levels? */ ------------------ | Branch (436:7): [True: 12.6M, False: 26.1M] ------------------ 437| 12.6M| init_exp(var, VVOID, 0); /* default is global */ 438| 26.1M| else { 439| 26.1M| int v = searchvar(fs, n, var); /* look up locals at current level */ 440| 26.1M| if (v >= 0) { /* found? */ ------------------ | Branch (440:9): [True: 692k, False: 25.4M] ------------------ 441| 692k| if (v == VLOCAL && !base) ------------------ | Branch (441:11): [True: 160k, False: 531k] | Branch (441:26): [True: 1.59k, False: 158k] ------------------ 442| 1.59k| markupval(fs, var->u.var.vidx); /* local will be used as an upval */ 443| 692k| } 444| 25.4M| else { /* not found as local at current level; try upvalues */ 445| 25.4M| int idx = searchupvalue(fs, n); /* try existing upvalues */ 446| 25.4M| if (idx < 0) { /* not found? */ ------------------ | Branch (446:11): [True: 13.3M, False: 12.0M] ------------------ 447| 13.3M| singlevaraux(fs->prev, n, var, 0); /* try upper levels */ 448| 13.3M| if (var->k == VLOCAL || var->k == VUPVAL) /* local or upvalue? */ ------------------ | Branch (448:13): [True: 1.59k, False: 13.3M] | Branch (448:33): [True: 3.43k, False: 13.3M] ------------------ 449| 5.03k| idx = newupvalue(fs, n, var); /* will be a new upvalue */ 450| 13.3M| else /* it is a global or a constant */ 451| 13.3M| return; /* don't need to do anything at this level */ 452| 13.3M| } 453| 12.0M| init_exp(var, VUPVAL, idx); /* new or old upvalue */ 454| 12.0M| } 455| 26.1M| } 456| 38.8M|} lparser.c:searchvar: 390| 26.1M|static int searchvar (FuncState *fs, TString *n, expdesc *var) { 391| 26.1M| int i; 392| 127M| for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) { ------------------ | | 141| 26.1M|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 26.1M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (392:39): [True: 101M, False: 25.4M] ------------------ 393| 101M| Vardesc *vd = getlocalvardesc(fs, i); 394| 101M| if (eqstr(n, vd->vd.name)) { /* found? */ ------------------ | | 43| 101M|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 692k, False: 101M] | | ------------------ ------------------ 395| 692k| if (vd->vd.kind == RDKCTC) /* compile-time constant? */ ------------------ | | 93| 692k|#define RDKCTC 3 /* compile-time constant */ ------------------ | Branch (395:11): [True: 531k, False: 160k] ------------------ 396| 531k| init_exp(var, VCONST, fs->firstlocal + i); 397| 160k| else /* real variable */ 398| 160k| init_var(fs, var, i); 399| 692k| return var->k; 400| 692k| } 401| 101M| } 402| 25.4M| return -1; /* not found */ 403| 26.1M|} lparser.c:init_var: 266| 160k|static void init_var (FuncState *fs, expdesc *e, int vidx) { 267| 160k| e->f = e->t = NO_JUMP; ------------------ | | 20| 160k|#define NO_JUMP (-1) ------------------ 268| 160k| e->k = VLOCAL; 269| 160k| e->u.var.vidx = vidx; 270| 160k| e->u.var.ridx = getlocalvardesc(fs, vidx)->vd.ridx; 271| 160k|} lparser.c:markupval: 410| 1.59k|static void markupval (FuncState *fs, int level) { 411| 1.59k| BlockCnt *bl = fs->bl; 412| 5.99k| while (bl->nactvar > level) ------------------ | Branch (412:10): [True: 4.39k, False: 1.59k] ------------------ 413| 4.39k| bl = bl->previous; 414| 1.59k| bl->upval = 1; 415| 1.59k| fs->needclose = 1; 416| 1.59k|} lparser.c:searchupvalue: 342| 25.4M|static int searchupvalue (FuncState *fs, TString *name) { 343| 25.4M| int i; 344| 25.4M| Upvaldesc *up = fs->f->upvalues; 345| 39.4M| for (i = 0; i < fs->nups; i++) { ------------------ | Branch (345:15): [True: 26.0M, False: 13.3M] ------------------ 346| 26.0M| if (eqstr(up[i].name, name)) return i; ------------------ | | 43| 26.0M|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 12.0M, False: 14.0M] | | ------------------ ------------------ 347| 26.0M| } 348| 13.3M| return -1; /* not found */ 349| 25.4M|} lparser.c:newupvalue: 364| 5.03k|static int newupvalue (FuncState *fs, TString *name, expdesc *v) { 365| 5.03k| Upvaldesc *up = allocupvalue(fs); 366| 5.03k| FuncState *prev = fs->prev; 367| 5.03k| if (v->k == VLOCAL) { ------------------ | Branch (367:7): [True: 1.59k, False: 3.43k] ------------------ 368| 1.59k| up->instack = 1; 369| 1.59k| up->idx = v->u.var.ridx; 370| 1.59k| up->kind = getlocalvardesc(prev, v->u.var.vidx)->vd.kind; 371| 1.59k| lua_assert(eqstr(name, getlocalvardesc(prev, v->u.var.vidx)->vd.name)); ------------------ | | 114| 1.59k|#define lua_assert(c) ((void)0) ------------------ 372| 1.59k| } 373| 3.43k| else { 374| 3.43k| up->instack = 0; 375| 3.43k| up->idx = cast_byte(v->u.info); ------------------ | | 143| 3.43k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 3.43k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 376| 3.43k| up->kind = prev->f->upvalues[v->u.info].kind; 377| 3.43k| lua_assert(eqstr(name, prev->f->upvalues[v->u.info].name)); ------------------ | | 114| 3.43k|#define lua_assert(c) ((void)0) ------------------ 378| 3.43k| } 379| 5.03k| up->name = name; 380| 5.03k| luaC_objbarrier(fs->ls->L, fs->f, name); ------------------ | | 175| 5.03k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 5.03k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 5.03k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 5.03k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 10.0k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 5.03k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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.03k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 5.03k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 5.03k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 381| 5.03k| return fs->nups - 1; 382| 5.03k|} lparser.c:fieldsel: 811| 5.07k|static void fieldsel (LexState *ls, expdesc *v) { 812| | /* fieldsel -> ['.' | ':'] NAME */ 813| 5.07k| FuncState *fs = ls->fs; 814| 5.07k| expdesc key; 815| 5.07k| luaK_exp2anyregup(fs, v); 816| 5.07k| luaX_next(ls); /* skip the dot or colon */ 817| 5.07k| codename(ls, &key); 818| 5.07k| luaK_indexed(fs, v, &key); 819| 5.07k|} lparser.c:funcargs: 1025| 437k|static void funcargs (LexState *ls, expdesc *f) { 1026| 437k| FuncState *fs = ls->fs; 1027| 437k| expdesc args; 1028| 437k| int base, nparams; 1029| 437k| int line = ls->linenumber; 1030| 437k| switch (ls->t.token) { 1031| 40.9k| case '(': { /* funcargs -> '(' [ explist ] ')' */ ------------------ | Branch (1031:5): [True: 40.9k, False: 396k] ------------------ 1032| 40.9k| luaX_next(ls); 1033| 40.9k| if (ls->t.token == ')') /* arg list is empty? */ ------------------ | Branch (1033:11): [True: 3.87k, False: 37.0k] ------------------ 1034| 3.87k| args.k = VVOID; 1035| 37.0k| else { 1036| 37.0k| explist(ls, &args); 1037| 37.0k| if (hasmultret(args.k)) ------------------ | | 38| 37.0k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 562, False: 36.4k] | | | Branch (38:41): [True: 219, False: 36.2k] | | ------------------ ------------------ 1038| 485| luaK_setmultret(fs, &args); ------------------ | | 58| 485|#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) | | ------------------ | | | | 35| 485|#define LUA_MULTRET (-1) | | ------------------ ------------------ 1039| 37.0k| } 1040| 40.9k| check_match(ls, ')', '(', line); 1041| 40.9k| break; 1042| 0| } 1043| 14| case '{': { /* funcargs -> constructor */ ------------------ | Branch (1043:5): [True: 14, False: 437k] ------------------ 1044| 14| constructor(ls, &args); 1045| 14| break; 1046| 0| } 1047| 396k| case TK_STRING: { /* funcargs -> STRING */ ------------------ | Branch (1047:5): [True: 396k, False: 40.9k] ------------------ 1048| 396k| codestring(&args, ls->t.seminfo.ts); 1049| 396k| luaX_next(ls); /* must use 'seminfo' before 'next' */ 1050| 396k| break; 1051| 0| } 1052| 0| default: { ------------------ | Branch (1052:5): [True: 0, False: 437k] ------------------ 1053| 0| luaX_syntaxerror(ls, "function arguments expected"); 1054| 0| } 1055| 437k| } 1056| 436k| lua_assert(f->k == VNONRELOC); ------------------ | | 114| 436k|#define lua_assert(c) ((void)0) ------------------ 1057| 436k| base = f->u.info; /* base register for call */ 1058| 436k| if (hasmultret(args.k)) ------------------ | | 38| 436k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 266, False: 436k] | | | Branch (38:41): [True: 219, False: 436k] | | ------------------ ------------------ 1059| 485| nparams = LUA_MULTRET; /* open call */ ------------------ | | 35| 485|#define LUA_MULTRET (-1) ------------------ 1060| 436k| else { 1061| 436k| if (args.k != VVOID) ------------------ | Branch (1061:9): [True: 432k, False: 3.87k] ------------------ 1062| 432k| luaK_exp2nextreg(fs, &args); /* close last argument */ 1063| 436k| nparams = fs->freereg - (base+1); 1064| 436k| } 1065| 436k| init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2)); ------------------ | | 48| 436k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1066| 436k| luaK_fixline(fs, line); 1067| 436k| fs->freereg = base+1; /* call removes function and arguments and leaves 1068| | one result (unless changed later) */ 1069| 436k|} lparser.c:explist: 1012| 66.5k|static int explist (LexState *ls, expdesc *v) { 1013| | /* explist -> expr { ',' expr } */ 1014| 66.5k| int n = 1; /* at least one expression */ 1015| 66.5k| expr(ls, v); 1016| 100k| while (testnext(ls, ',')) { ------------------ | Branch (1016:10): [True: 34.3k, False: 66.5k] ------------------ 1017| 34.3k| luaK_exp2nextreg(ls->fs, v); 1018| 34.3k| expr(ls, v); 1019| 34.3k| n++; 1020| 34.3k| } 1021| 66.5k| return n; 1022| 66.5k|} lparser.c:getbinopr: 1206| 13.5M|static BinOpr getbinopr (int op) { 1207| 13.5M| switch (op) { 1208| 7.37k| case '+': return OPR_ADD; ------------------ | Branch (1208:5): [True: 7.37k, False: 13.5M] ------------------ 1209| 48.5k| case '-': return OPR_SUB; ------------------ | Branch (1209:5): [True: 48.5k, False: 13.5M] ------------------ 1210| 83.5k| case '*': return OPR_MUL; ------------------ | Branch (1210:5): [True: 83.5k, False: 13.4M] ------------------ 1211| 28.8k| case '%': return OPR_MOD; ------------------ | Branch (1211:5): [True: 28.8k, False: 13.5M] ------------------ 1212| 538k| case '^': return OPR_POW; ------------------ | Branch (1212:5): [True: 538k, False: 13.0M] ------------------ 1213| 5.22M| case '/': return OPR_DIV; ------------------ | Branch (1213:5): [True: 5.22M, False: 8.33M] ------------------ 1214| 35.1k| case TK_IDIV: return OPR_IDIV; ------------------ | Branch (1214:5): [True: 35.1k, False: 13.5M] ------------------ 1215| 17.7k| case '&': return OPR_BAND; ------------------ | Branch (1215:5): [True: 17.7k, False: 13.5M] ------------------ 1216| 5.55k| case '|': return OPR_BOR; ------------------ | Branch (1216:5): [True: 5.55k, False: 13.5M] ------------------ 1217| 55.6k| case '~': return OPR_BXOR; ------------------ | Branch (1217:5): [True: 55.6k, False: 13.5M] ------------------ 1218| 440k| case TK_SHL: return OPR_SHL; ------------------ | Branch (1218:5): [True: 440k, False: 13.1M] ------------------ 1219| 6.82k| case TK_SHR: return OPR_SHR; ------------------ | Branch (1219:5): [True: 6.82k, False: 13.5M] ------------------ 1220| 26.2k| case TK_CONCAT: return OPR_CONCAT; ------------------ | Branch (1220:5): [True: 26.2k, False: 13.5M] ------------------ 1221| 6.18k| case TK_NE: return OPR_NE; ------------------ | Branch (1221:5): [True: 6.18k, False: 13.5M] ------------------ 1222| 6.24k| case TK_EQ: return OPR_EQ; ------------------ | Branch (1222:5): [True: 6.24k, False: 13.5M] ------------------ 1223| 6.52M| case '<': return OPR_LT; ------------------ | Branch (1223:5): [True: 6.52M, False: 7.03M] ------------------ 1224| 11.2k| case TK_LE: return OPR_LE; ------------------ | Branch (1224:5): [True: 11.2k, False: 13.5M] ------------------ 1225| 55.1k| case '>': return OPR_GT; ------------------ | Branch (1225:5): [True: 55.1k, False: 13.5M] ------------------ 1226| 1.60k| case TK_GE: return OPR_GE; ------------------ | Branch (1226:5): [True: 1.60k, False: 13.5M] ------------------ 1227| 39.4k| case TK_AND: return OPR_AND; ------------------ | Branch (1227:5): [True: 39.4k, False: 13.5M] ------------------ 1228| 195k| case TK_OR: return OPR_OR; ------------------ | Branch (1228:5): [True: 195k, False: 13.3M] ------------------ 1229| 205k| default: return OPR_NOBINOPR; ------------------ | Branch (1229:5): [True: 205k, False: 13.3M] ------------------ 1230| 13.5M| } 1231| 13.5M|} lparser.c:checknext: 116| 61.1k|static void checknext (LexState *ls, int c) { 117| 61.1k| check(ls, c); 118| 61.1k| luaX_next(ls); 119| 61.1k|} lparser.c:newgotoentry: 575| 10.7k|static int newgotoentry (LexState *ls, TString *name, int line, int pc) { 576| 10.7k| return newlabelentry(ls, &ls->dyd->gt, name, line, pc); 577| 10.7k|} lparser.c:newlabelentry: 561| 13.2k| int line, int pc) { 562| 13.2k| int n = l->n; 563| 13.2k| luaM_growvector(ls->L, l->arr, n, l->size, ------------------ | | 67| 13.2k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 26.4k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 13.2k| luaM_limitN(limit,t),e))) ------------------ 564| 13.2k| Labeldesc, SHRT_MAX, "labels/gotos"); 565| 13.2k| l->arr[n].name = name; 566| 13.2k| l->arr[n].line = line; 567| 13.2k| l->arr[n].nactvar = ls->fs->nactvar; 568| 13.2k| l->arr[n].close = 0; 569| 13.2k| l->arr[n].pc = pc; 570| 13.2k| l->n = n + 1; 571| 13.2k| return n; 572| 13.2k|} lparser.c:leaveblock: 672| 10.3k|static void leaveblock (FuncState *fs) { 673| 10.3k| BlockCnt *bl = fs->bl; 674| 10.3k| LexState *ls = fs->ls; 675| 10.3k| int hasclose = 0; 676| 10.3k| int stklevel = reglevel(fs, bl->nactvar); /* level outside the block */ 677| 10.3k| removevars(fs, bl->nactvar); /* remove block locals */ 678| 10.3k| lua_assert(bl->nactvar == fs->nactvar); /* back to level on entry */ ------------------ | | 114| 10.3k|#define lua_assert(c) ((void)0) ------------------ 679| 10.3k| if (bl->isloop) /* has to fix pending breaks? */ ------------------ | Branch (679:7): [True: 2.21k, False: 8.12k] ------------------ 680| 2.21k| hasclose = createlabel(ls, luaS_newliteral(ls->L, "break"), 0, 0); ------------------ | | 28| 2.21k|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 2.21k| (sizeof(s)/sizeof(char))-1)) ------------------ 681| 10.3k| if (!hasclose && bl->previous && bl->upval) /* still need a 'close'? */ ------------------ | Branch (681:7): [True: 10.0k, False: 292] | Branch (681:20): [True: 7.25k, False: 2.78k] | Branch (681:36): [True: 361, False: 6.89k] ------------------ 682| 361| luaK_codeABC(fs, OP_CLOSE, stklevel, 0, 0); ------------------ | | 48| 361|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 683| 10.3k| fs->freereg = stklevel; /* free registers */ 684| 10.3k| ls->dyd->label.n = bl->firstlabel; /* remove local labels */ 685| 10.3k| fs->bl = bl->previous; /* current block now is previous one */ 686| 10.3k| if (bl->previous) /* was it a nested block? */ ------------------ | Branch (686:7): [True: 7.54k, False: 2.78k] ------------------ 687| 7.54k| movegotosout(fs, bl); /* update pending gotos to enclosing block */ 688| 2.78k| else { 689| 2.78k| if (bl->firstgoto < ls->dyd->gt.n) /* still pending gotos? */ ------------------ | Branch (689:9): [True: 5, False: 2.78k] ------------------ 690| 5| undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */ 691| 2.78k| } 692| 10.3k|} lparser.c:removevars: 328| 10.3k|static void removevars (FuncState *fs, int tolevel) { 329| 10.3k| fs->ls->dyd->actvar.n -= (fs->nactvar - tolevel); 330| 20.2k| while (fs->nactvar > tolevel) { ------------------ | Branch (330:10): [True: 9.92k, False: 10.3k] ------------------ 331| 9.92k| LocVar *var = localdebuginfo(fs, --fs->nactvar); 332| 9.92k| if (var) /* does it have debug information? */ ------------------ | Branch (332:9): [True: 9.03k, False: 888] ------------------ 333| 9.03k| var->endpc = fs->pc; 334| 9.92k| } 335| 10.3k|} lparser.c:localdebuginfo: 251| 10.2k|static LocVar *localdebuginfo (FuncState *fs, int vidx) { 252| 10.2k| Vardesc *vd = getlocalvardesc(fs, vidx); 253| 10.2k| if (vd->vd.kind == RDKCTC) ------------------ | | 93| 10.2k|#define RDKCTC 3 /* compile-time constant */ ------------------ | Branch (253:7): [True: 888, False: 9.35k] ------------------ 254| 888| return NULL; /* no debug info. for constants */ 255| 9.35k| else { 256| 9.35k| int idx = vd->vd.pidx; 257| 9.35k| lua_assert(idx < fs->ndebugvars); ------------------ | | 114| 9.35k|#define lua_assert(c) ((void)0) ------------------ 258| 9.35k| return &fs->f->locvars[idx]; 259| 9.35k| } 260| 10.2k|} lparser.c:createlabel: 609| 2.48k| int last) { 610| 2.48k| FuncState *fs = ls->fs; 611| 2.48k| Labellist *ll = &ls->dyd->label; 612| 2.48k| int l = newlabelentry(ls, ll, name, line, luaK_getlabel(fs)); 613| 2.48k| if (last) { /* label is last no-op statement in the block? */ ------------------ | Branch (613:7): [True: 0, False: 2.48k] ------------------ 614| | /* assume that locals are already out of scope */ 615| 0| ll->arr[l].nactvar = fs->bl->nactvar; 616| 0| } 617| 2.48k| if (solvegotos(ls, &ll->arr[l])) { /* need close? */ ------------------ | Branch (617:7): [True: 292, False: 2.19k] ------------------ 618| 292| luaK_codeABC(fs, OP_CLOSE, luaY_nvarstack(fs), 0, 0); ------------------ | | 48| 292|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 619| 292| return 1; 620| 292| } 621| 2.19k| return 0; 622| 2.48k|} lparser.c:solvegotos: 585| 2.48k|static int solvegotos (LexState *ls, Labeldesc *lb) { 586| 2.48k| Labellist *gl = &ls->dyd->gt; 587| 2.48k| int i = ls->fs->bl->firstgoto; 588| 2.48k| int needsclose = 0; 589| 3.67k| while (i < gl->n) { ------------------ | Branch (589:10): [True: 1.18k, False: 2.48k] ------------------ 590| 1.18k| if (eqstr(gl->arr[i].name, lb->name)) { ------------------ | | 43| 1.18k|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 1.18k, False: 0] | | ------------------ ------------------ 591| 1.18k| needsclose |= gl->arr[i].close; 592| 1.18k| solvegoto(ls, i, lb); /* will remove 'i' from the list */ 593| 1.18k| } 594| 0| else 595| 0| i++; 596| 1.18k| } 597| 2.48k| return needsclose; 598| 2.48k|} lparser.c:solvegoto: 527| 1.18k|static void solvegoto (LexState *ls, int g, Labeldesc *label) { 528| 1.18k| int i; 529| 1.18k| Labellist *gl = &ls->dyd->gt; /* list of gotos */ 530| 1.18k| Labeldesc *gt = &gl->arr[g]; /* goto to be resolved */ 531| 1.18k| lua_assert(eqstr(gt->name, label->name)); ------------------ | | 114| 1.18k|#define lua_assert(c) ((void)0) ------------------ 532| 1.18k| if (l_unlikely(gt->nactvar < label->nactvar)) /* enter some scope? */ ------------------ | | 697| 1.18k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 1.18k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 1.18k] | | | | ------------------ | | ------------------ ------------------ 533| 0| jumpscopeerror(ls, gt); 534| 1.18k| luaK_patchlist(ls->fs, gt->pc, label->pc); 535| 1.48k| for (i = g; i < gl->n - 1; i++) /* remove goto from pending list */ ------------------ | Branch (535:15): [True: 301, False: 1.18k] ------------------ 536| 301| gl->arr[i] = gl->arr[i + 1]; 537| 1.18k| gl->n--; 538| 1.18k|} lparser.c:movegotosout: 628| 7.54k|static void movegotosout (FuncState *fs, BlockCnt *bl) { 629| 7.54k| int i; 630| 7.54k| Labellist *gl = &fs->ls->dyd->gt; 631| | /* correct pending gotos to current block */ 632| 10.4k| for (i = bl->firstgoto; i < gl->n; i++) { /* for each pending goto */ ------------------ | Branch (632:27): [True: 2.88k, False: 7.54k] ------------------ 633| 2.88k| Labeldesc *gt = &gl->arr[i]; 634| | /* leaving a variable scope? */ 635| 2.88k| if (reglevel(fs, gt->nactvar) > reglevel(fs, bl->nactvar)) ------------------ | Branch (635:9): [True: 361, False: 2.52k] ------------------ 636| 361| gt->close |= bl->upval; /* jump may need a close */ 637| 2.88k| gt->nactvar = bl->nactvar; /* update goto level */ 638| 2.88k| } 639| 7.54k|} lparser.c:undefgoto: 658| 5|static l_noret undefgoto (LexState *ls, Labeldesc *gt) { 659| 5| const char *msg; 660| 5| if (eqstr(gt->name, luaS_newliteral(ls->L, "break"))) { ------------------ | | 43| 5|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 0, False: 5] | | ------------------ ------------------ 661| 0| msg = "break outside loop at line %d"; 662| 0| msg = luaO_pushfstring(ls->L, msg, gt->line); 663| 0| } 664| 5| else { 665| 5| msg = "no visible label '%s' for at line %d"; 666| 5| msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line); ------------------ | | 404| 5|#define getstr(ts) ((ts)->contents) ------------------ 667| 5| } 668| 5| luaK_semerror(ls, msg); 669| 5|} lparser.c:whilestat: 1468| 1.11k|static void whilestat (LexState *ls, int line) { 1469| | /* whilestat -> WHILE cond DO block END */ 1470| 1.11k| FuncState *fs = ls->fs; 1471| 1.11k| int whileinit; 1472| 1.11k| int condexit; 1473| 1.11k| BlockCnt bl; 1474| 1.11k| luaX_next(ls); /* skip WHILE */ 1475| 1.11k| whileinit = luaK_getlabel(fs); 1476| 1.11k| condexit = cond(ls); 1477| 1.11k| enterblock(fs, &bl, 1); 1478| 1.11k| checknext(ls, TK_DO); 1479| 1.11k| block(ls); 1480| 1.11k| luaK_jumpto(fs, whileinit); ------------------ | | 60| 1.11k|#define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t) ------------------ 1481| 1.11k| check_match(ls, TK_END, TK_WHILE, line); 1482| 1.11k| leaveblock(fs); 1483| 1.11k| luaK_patchtohere(fs, condexit); /* false conditions finish the loop */ 1484| 1.11k|} lparser.c:cond: 1406| 2.03k|static int cond (LexState *ls) { 1407| | /* cond -> exp */ 1408| 2.03k| expdesc v; 1409| 2.03k| expr(ls, &v); /* read condition */ 1410| 2.03k| if (v.k == VNIL) v.k = VFALSE; /* 'falses' are all equal here */ ------------------ | Branch (1410:7): [True: 1.27k, False: 768] ------------------ 1411| 2.03k| luaK_goiftrue(ls->fs, &v); 1412| 2.03k| return v.f; 1413| 2.03k|} lparser.c:block: 1305| 4.11k|static void block (LexState *ls) { 1306| | /* block -> statlist */ 1307| 4.11k| FuncState *fs = ls->fs; 1308| 4.11k| BlockCnt bl; 1309| 4.11k| enterblock(fs, &bl, 0); 1310| 4.11k| statlist(ls); 1311| 4.11k| leaveblock(fs); 1312| 4.11k|} lparser.c:check_match: 130| 113k|static void check_match (LexState *ls, int what, int who, int where) { 131| 113k| if (l_unlikely(!testnext(ls, what))) { ------------------ | | 697| 113k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 113k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 64, False: 113k] | | | | ------------------ | | ------------------ ------------------ 132| 64| if (where == ls->linenumber) /* all in the same line? */ ------------------ | Branch (132:9): [True: 33, False: 31] ------------------ 133| 33| error_expected(ls, what); /* do not need a complex message */ 134| 31| else { 135| 31| luaX_syntaxerror(ls, luaO_pushfstring(ls->L, 136| 31| "%s expected (to close %s at line %d)", 137| 31| luaX_token2str(ls, what), luaX_token2str(ls, who), where)); 138| 31| } 139| 64| } 140| 113k|} lparser.c:error_expected: 68| 44|static l_noret error_expected (LexState *ls, int token) { 69| 44| luaX_syntaxerror(ls, 70| 44| luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token))); 71| 44|} lparser.c:forstat: 1620| 591|static void forstat (LexState *ls, int line) { 1621| | /* forstat -> FOR (fornum | forlist) END */ 1622| 591| FuncState *fs = ls->fs; 1623| 591| TString *varname; 1624| 591| BlockCnt bl; 1625| 591| enterblock(fs, &bl, 1); /* scope for loop and control variables */ 1626| 591| luaX_next(ls); /* skip 'for' */ 1627| 591| varname = str_checkname(ls); /* first variable name */ 1628| 591| switch (ls->t.token) { 1629| 556| case '=': fornum(ls, varname, line); break; ------------------ | Branch (1629:5): [True: 556, False: 35] ------------------ 1630| 35| case ',': case TK_IN: forlist(ls, varname); break; ------------------ | Branch (1630:5): [True: 35, False: 556] | Branch (1630:15): [True: 0, False: 591] ------------------ 1631| 0| default: luaX_syntaxerror(ls, "'=' or 'in' expected"); ------------------ | Branch (1631:5): [True: 0, False: 591] ------------------ 1632| 591| } 1633| 182| check_match(ls, TK_END, TK_FOR, line); 1634| 182| leaveblock(fs); /* loop scope ('break' jumps to this point) */ 1635| 182|} lparser.c:fornum: 1569| 556|static void fornum (LexState *ls, TString *varname, int line) { 1570| | /* fornum -> NAME = exp,exp[,exp] forbody */ 1571| 556| FuncState *fs = ls->fs; 1572| 556| int base = fs->freereg; 1573| 556| new_localvarliteral(ls, "(for state)"); ------------------ | | 209| 556| new_localvar(ls, \ | | 210| 556| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1574| 556| new_localvarliteral(ls, "(for state)"); ------------------ | | 209| 556| new_localvar(ls, \ | | 210| 556| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1575| 556| new_localvarliteral(ls, "(for state)"); ------------------ | | 209| 556| new_localvar(ls, \ | | 210| 556| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1576| 556| new_localvar(ls, varname); 1577| 556| checknext(ls, '='); 1578| 556| exp1(ls); /* initial value */ 1579| 556| checknext(ls, ','); 1580| 556| exp1(ls); /* limit */ 1581| 556| if (testnext(ls, ',')) ------------------ | Branch (1581:7): [True: 39, False: 517] ------------------ 1582| 39| exp1(ls); /* optional step */ 1583| 517| else { /* default step = 1 */ 1584| 517| luaK_int(fs, fs->freereg, 1); 1585| 517| luaK_reserveregs(fs, 1); 1586| 517| } 1587| 556| adjustlocalvars(ls, 3); /* control variables */ 1588| 556| forbody(ls, base, line, 1, 0); 1589| 556|} lparser.c:exp1: 1517| 1.14k|static void exp1 (LexState *ls) { 1518| 1.14k| expdesc e; 1519| 1.14k| expr(ls, &e); 1520| 1.14k| luaK_exp2nextreg(ls->fs, &e); 1521| 1.14k| lua_assert(e.k == VNONRELOC); ------------------ | | 114| 1.14k|#define lua_assert(c) ((void)0) ------------------ 1522| 1.14k|} lparser.c:forbody: 1544| 586|static void forbody (LexState *ls, int base, int line, int nvars, int isgen) { 1545| | /* forbody -> DO block */ 1546| 586| static const OpCode forprep[2] = {OP_FORPREP, OP_TFORPREP}; 1547| 586| static const OpCode forloop[2] = {OP_FORLOOP, OP_TFORLOOP}; 1548| 586| BlockCnt bl; 1549| 586| FuncState *fs = ls->fs; 1550| 586| int prep, endfor; 1551| 586| checknext(ls, TK_DO); 1552| 586| prep = luaK_codeABx(fs, forprep[isgen], base, 0); 1553| 586| enterblock(fs, &bl, 0); /* scope for declared variables */ 1554| 586| adjustlocalvars(ls, nvars); 1555| 586| luaK_reserveregs(fs, nvars); 1556| 586| block(ls); 1557| 586| leaveblock(fs); /* end of scope for declared variables */ 1558| 586| fixforjump(fs, prep, luaK_getlabel(fs), 0); 1559| 586| if (isgen) { /* generic for? */ ------------------ | Branch (1559:7): [True: 34, False: 552] ------------------ 1560| 34| luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars); ------------------ | | 48| 34|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1561| 34| luaK_fixline(fs, line); 1562| 34| } 1563| 586| endfor = luaK_codeABx(fs, forloop[isgen], base, 0); 1564| 586| fixforjump(fs, endfor, prep + 1, 1); 1565| 586| luaK_fixline(fs, line); 1566| 586|} lparser.c:fixforjump: 1530| 365|static void fixforjump (FuncState *fs, int pc, int dest, int back) { 1531| 365| Instruction *jmp = &fs->f->code[pc]; 1532| 365| int offset = dest - (pc + 1); 1533| 365| if (back) ------------------ | Branch (1533:7): [True: 182, False: 183] ------------------ 1534| 182| offset = -offset; 1535| 365| if (l_unlikely(offset > MAXARG_Bx)) ------------------ | | 697| 365|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 365|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 1, False: 364] | | | | ------------------ | | ------------------ ------------------ 1536| 1| luaX_syntaxerror(fs->ls, "control structure too long"); 1537| 364| SETARG_Bx(*jmp, offset); ------------------ | | 141| 364|#define SETARG_Bx(i,v) setarg(i, v, POS_Bx, SIZE_Bx) | | ------------------ | | | | 122| 364|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 364|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 364|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 364| ((cast(Instruction, v)< NAME {,NAME} IN explist forbody */ 1594| 35| FuncState *fs = ls->fs; 1595| 35| expdesc e; 1596| 35| int nvars = 5; /* gen, state, control, toclose, 'indexname' */ 1597| 35| int line; 1598| 35| int base = fs->freereg; 1599| | /* create control variables */ 1600| 35| new_localvarliteral(ls, "(for state)"); ------------------ | | 209| 35| new_localvar(ls, \ | | 210| 35| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1601| 35| new_localvarliteral(ls, "(for state)"); ------------------ | | 209| 35| new_localvar(ls, \ | | 210| 35| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1602| 35| new_localvarliteral(ls, "(for state)"); ------------------ | | 209| 35| new_localvar(ls, \ | | 210| 35| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1603| 35| new_localvarliteral(ls, "(for state)"); ------------------ | | 209| 35| new_localvar(ls, \ | | 210| 35| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1604| | /* create declared variables */ 1605| 35| new_localvar(ls, indexname); 1606| 101| while (testnext(ls, ',')) { ------------------ | Branch (1606:10): [True: 66, False: 35] ------------------ 1607| 66| new_localvar(ls, str_checkname(ls)); 1608| 66| nvars++; 1609| 66| } 1610| 35| checknext(ls, TK_IN); 1611| 35| line = ls->linenumber; 1612| 35| adjust_assign(ls, 4, explist(ls, &e), &e); 1613| 35| adjustlocalvars(ls, 4); /* control variables */ 1614| 35| marktobeclosed(fs); /* last control var. must be closed */ 1615| 35| luaK_checkstack(fs, 3); /* extra space to call generator */ 1616| 35| forbody(ls, base, line, nvars - 4, 1); 1617| 35|} lparser.c:adjust_assign: 482| 7.59k|static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) { 483| 7.59k| FuncState *fs = ls->fs; 484| 7.59k| int needed = nvars - nexps; /* extra values needed */ 485| 7.59k| if (hasmultret(e->k)) { /* last expression has multiple returns? */ ------------------ | | 38| 7.59k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 187, False: 7.41k] | | | Branch (38:41): [True: 51, False: 7.36k] | | ------------------ ------------------ 486| 238| int extra = needed + 1; /* discount last expression itself */ 487| 238| if (extra < 0) ------------------ | Branch (487:9): [True: 45, False: 193] ------------------ 488| 45| extra = 0; 489| 238| luaK_setreturns(fs, e, extra); /* last exp. provides the difference */ 490| 238| } 491| 7.36k| else { 492| 7.36k| if (e->k != VVOID) /* at least one expression? */ ------------------ | Branch (492:9): [True: 6.51k, False: 847] ------------------ 493| 6.51k| luaK_exp2nextreg(fs, e); /* close last expression */ 494| 7.36k| if (needed > 0) /* missing values? */ ------------------ | Branch (494:9): [True: 1.95k, False: 5.40k] ------------------ 495| 1.95k| luaK_nil(fs, fs->freereg, needed); /* complete with nils */ 496| 7.36k| } 497| 7.59k| if (needed > 0) ------------------ | Branch (497:7): [True: 2.12k, False: 5.46k] ------------------ 498| 2.12k| luaK_reserveregs(fs, needed); /* registers for extra values */ 499| 5.46k| else /* adding 'needed' is actually a subtraction */ 500| 5.46k| fs->freereg += needed; /* remove extra values */ 501| 7.59k|} lparser.c:marktobeclosed: 422| 399|static void marktobeclosed (FuncState *fs) { 423| 399| BlockCnt *bl = fs->bl; 424| 399| bl->upval = 1; 425| 399| bl->insidetbc = 1; 426| 399| fs->needclose = 1; 427| 399|} lparser.c:repeatstat: 1487| 933|static void repeatstat (LexState *ls, int line) { 1488| | /* repeatstat -> REPEAT block UNTIL cond */ 1489| 933| int condexit; 1490| 933| FuncState *fs = ls->fs; 1491| 933| int repeat_init = luaK_getlabel(fs); 1492| 933| BlockCnt bl1, bl2; 1493| 933| enterblock(fs, &bl1, 1); /* loop block */ 1494| 933| enterblock(fs, &bl2, 0); /* scope block */ 1495| 933| luaX_next(ls); /* skip REPEAT */ 1496| 933| statlist(ls); 1497| 933| check_match(ls, TK_UNTIL, TK_REPEAT, line); 1498| 933| condexit = cond(ls); /* read condition (inside scope block) */ 1499| 933| leaveblock(fs); /* finish scope */ 1500| 933| if (bl2.upval) { /* upvalues? */ ------------------ | Branch (1500:7): [True: 292, False: 641] ------------------ 1501| 292| int exit = luaK_jump(fs); /* normal exit must jump over fix */ 1502| 292| luaK_patchtohere(fs, condexit); /* repetition must close upvalues */ 1503| 292| luaK_codeABC(fs, OP_CLOSE, reglevel(fs, bl2.nactvar), 0, 0); ------------------ | | 48| 292|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1504| 292| condexit = luaK_jump(fs); /* repeat after closing upvalues */ 1505| 292| luaK_patchtohere(fs, exit); /* normal exit comes to here */ 1506| 292| } 1507| 933| luaK_patchlist(fs, condexit, repeat_init); /* close the loop */ 1508| 933| leaveblock(fs); /* finish loop */ 1509| 933|} lparser.c:funcstat: 1782| 1.77k|static void funcstat (LexState *ls, int line) { 1783| | /* funcstat -> FUNCTION funcname body */ 1784| 1.77k| int ismethod; 1785| 1.77k| expdesc v, b; 1786| 1.77k| luaX_next(ls); /* skip FUNCTION */ 1787| 1.77k| ismethod = funcname(ls, &v); 1788| 1.77k| body(ls, &b, ismethod, line); 1789| 1.77k| check_readonly(ls, &v); 1790| 1.77k| luaK_storevar(ls->fs, &v, &b); 1791| 1.77k| luaK_fixline(ls->fs, line); /* definition "happens" in the first line */ 1792| 1.77k|} lparser.c:funcname: 1768| 1.77k|static int funcname (LexState *ls, expdesc *v) { 1769| | /* funcname -> NAME {fieldsel} [':' NAME] */ 1770| 1.77k| int ismethod = 0; 1771| 1.77k| singlevar(ls, v); 1772| 1.77k| while (ls->t.token == '.') ------------------ | Branch (1772:10): [True: 0, False: 1.77k] ------------------ 1773| 0| fieldsel(ls, v); 1774| 1.77k| if (ls->t.token == ':') { ------------------ | Branch (1774:7): [True: 9, False: 1.76k] ------------------ 1775| 9| ismethod = 1; 1776| 9| fieldsel(ls, v); 1777| 9| } 1778| 1.77k| return ismethod; 1779| 1.77k|} lparser.c:check_readonly: 277| 29.2k|static void check_readonly (LexState *ls, expdesc *e) { 278| 29.2k| FuncState *fs = ls->fs; 279| 29.2k| TString *varname = NULL; /* to be set if variable is const */ 280| 29.2k| switch (e->k) { 281| 0| case VCONST: { ------------------ | Branch (281:5): [True: 0, False: 29.2k] ------------------ 282| 0| varname = ls->dyd->actvar.arr[e->u.info].vd.name; 283| 0| break; 284| 0| } 285| 3.31k| case VLOCAL: { ------------------ | Branch (285:5): [True: 3.31k, False: 25.8k] ------------------ 286| 3.31k| Vardesc *vardesc = getlocalvardesc(fs, e->u.var.vidx); 287| 3.31k| if (vardesc->vd.kind != VDKREG) /* not a regular variable? */ ------------------ | | 90| 3.31k|#define VDKREG 0 /* regular */ ------------------ | Branch (287:11): [True: 1, False: 3.31k] ------------------ 288| 1| varname = vardesc->vd.name; 289| 3.31k| break; 290| 0| } 291| 1.22k| case VUPVAL: { ------------------ | Branch (291:5): [True: 1.22k, False: 27.9k] ------------------ 292| 1.22k| Upvaldesc *up = &fs->f->upvalues[e->u.info]; 293| 1.22k| if (up->kind != VDKREG) ------------------ | | 90| 1.22k|#define VDKREG 0 /* regular */ ------------------ | Branch (293:11): [True: 1, False: 1.22k] ------------------ 294| 1| varname = up->name; 295| 1.22k| break; 296| 0| } 297| 24.6k| default: ------------------ | Branch (297:5): [True: 24.6k, False: 4.54k] ------------------ 298| 24.6k| return; /* other cases cannot be read-only */ 299| 29.2k| } 300| 4.54k| if (varname) { ------------------ | Branch (300:7): [True: 2, False: 4.54k] ------------------ 301| 2| const char *msg = luaO_pushfstring(ls->L, 302| 2| "attempt to assign to const variable '%s'", getstr(varname)); ------------------ | | 404| 2|#define getstr(ts) ((ts)->contents) ------------------ 303| 2| luaK_semerror(ls, msg); /* error */ 304| 2| } 305| 4.54k|} lparser.c:testnext: 95| 279k|static int testnext (LexState *ls, int c) { 96| 279k| if (ls->t.token == c) { ------------------ | Branch (96:7): [True: 170k, False: 108k] ------------------ 97| 170k| luaX_next(ls); 98| 170k| return 1; 99| 170k| } 100| 108k| else return 0; 101| 279k|} lparser.c:localfunc: 1689| 412|static void localfunc (LexState *ls) { 1690| 412| expdesc b; 1691| 412| FuncState *fs = ls->fs; 1692| 412| int fvar = fs->nactvar; /* function's variable index */ 1693| 412| new_localvar(ls, str_checkname(ls)); /* new local variable */ 1694| 412| adjustlocalvars(ls, 1); /* enter its scope */ 1695| 412| body(ls, &b, 0, ls->linenumber); /* function created in next register */ 1696| | /* debug information will only see the variable after this point! */ 1697| 412| localdebuginfo(fs, fvar)->startpc = fs->pc; 1698| 412|} lparser.c:localstat: 1726| 3.57k|static void localstat (LexState *ls) { 1727| | /* stat -> LOCAL NAME ATTRIB { ',' NAME ATTRIB } ['=' explist] */ 1728| 3.57k| FuncState *fs = ls->fs; 1729| 3.57k| int toclose = -1; /* index of to-be-closed variable (if any) */ 1730| 3.57k| Vardesc *var; /* last variable */ 1731| 3.57k| int vidx, kind; /* index and kind of last variable */ 1732| 3.57k| int nvars = 0; 1733| 3.57k| int nexps; 1734| 3.57k| expdesc e; 1735| 6.53k| do { 1736| 6.53k| vidx = new_localvar(ls, str_checkname(ls)); 1737| 6.53k| kind = getlocalattribute(ls); 1738| 6.53k| getlocalvardesc(fs, vidx)->vd.kind = kind; 1739| 6.53k| if (kind == RDKTOCLOSE) { /* to-be-closed? */ ------------------ | | 92| 6.53k|#define RDKTOCLOSE 2 /* to-be-closed */ ------------------ | Branch (1739:9): [True: 364, False: 6.17k] ------------------ 1740| 364| if (toclose != -1) /* one already present? */ ------------------ | Branch (1740:11): [True: 0, False: 364] ------------------ 1741| 0| luaK_semerror(ls, "multiple to-be-closed variables in local list"); 1742| 364| toclose = fs->nactvar + nvars; 1743| 364| } 1744| 6.53k| nvars++; 1745| 6.53k| } while (testnext(ls, ',')); ------------------ | Branch (1745:12): [True: 2.95k, False: 3.57k] ------------------ 1746| 3.57k| if (testnext(ls, '=')) ------------------ | Branch (1746:7): [True: 2.72k, False: 848] ------------------ 1747| 2.72k| nexps = explist(ls, &e); 1748| 848| else { 1749| 848| e.k = VVOID; 1750| 848| nexps = 0; 1751| 848| } 1752| 3.57k| var = getlocalvardesc(fs, vidx); /* get last variable */ 1753| 3.57k| if (nvars == nexps && /* no adjustments? */ ------------------ | Branch (1753:7): [True: 2.44k, False: 1.12k] ------------------ 1754| 3.57k| var->vd.kind == RDKCONST && /* last variable is const? */ ------------------ | | 91| 6.02k|#define RDKCONST 1 /* constant */ ------------------ | Branch (1754:7): [True: 2.32k, False: 125] ------------------ 1755| 3.57k| luaK_exp2const(fs, &e, &var->k)) { /* compile-time constant? */ ------------------ | Branch (1755:7): [True: 1.91k, False: 408] ------------------ 1756| 1.91k| var->vd.kind = RDKCTC; /* variable is a compile-time constant */ ------------------ | | 93| 1.91k|#define RDKCTC 3 /* compile-time constant */ ------------------ 1757| 1.91k| adjustlocalvars(ls, nvars - 1); /* exclude last variable */ 1758| 1.91k| fs->nactvar++; /* but count it */ 1759| 1.91k| } 1760| 1.66k| else { 1761| 1.66k| adjust_assign(ls, nvars, nexps, &e); 1762| 1.66k| adjustlocalvars(ls, nvars); 1763| 1.66k| } 1764| 3.57k| checktoclose(fs, toclose); 1765| 3.57k|} lparser.c:getlocalattribute: 1701| 6.53k|static int getlocalattribute (LexState *ls) { 1702| | /* ATTRIB -> ['<' Name '>'] */ 1703| 6.53k| if (testnext(ls, '<')) { ------------------ | Branch (1703:7): [True: 2.71k, False: 3.82k] ------------------ 1704| 2.71k| const char *attr = getstr(str_checkname(ls)); ------------------ | | 404| 2.71k|#define getstr(ts) ((ts)->contents) ------------------ 1705| 2.71k| checknext(ls, '>'); 1706| 2.71k| if (strcmp(attr, "const") == 0) ------------------ | Branch (1706:9): [True: 2.34k, False: 365] ------------------ 1707| 2.34k| return RDKCONST; /* read-only variable */ ------------------ | | 91| 2.34k|#define RDKCONST 1 /* constant */ ------------------ 1708| 365| else if (strcmp(attr, "close") == 0) ------------------ | Branch (1708:14): [True: 364, False: 1] ------------------ 1709| 364| return RDKTOCLOSE; /* to-be-closed variable */ ------------------ | | 92| 364|#define RDKTOCLOSE 2 /* to-be-closed */ ------------------ 1710| 1| else 1711| 1| luaK_semerror(ls, 1712| 1| luaO_pushfstring(ls->L, "unknown attribute '%s'", attr)); 1713| 2.71k| } 1714| 3.82k| return VDKREG; /* regular variable */ ------------------ | | 90| 3.82k|#define VDKREG 0 /* regular */ ------------------ 1715| 6.53k|} lparser.c:checktoclose: 1718| 3.57k|static void checktoclose (FuncState *fs, int level) { 1719| 3.57k| if (level != -1) { /* is there a to-be-closed variable? */ ------------------ | Branch (1719:7): [True: 364, False: 3.20k] ------------------ 1720| 364| marktobeclosed(fs); 1721| 364| luaK_codeABC(fs, OP_TBC, reglevel(fs, level), 0, 0); ------------------ | | 48| 364|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1722| 364| } 1723| 3.57k|} lparser.c:labelstat: 1458| 275|static void labelstat (LexState *ls, TString *name, int line) { 1459| | /* label -> '::' NAME '::' */ 1460| 275| checknext(ls, TK_DBCOLON); /* skip double colon */ 1461| 295| while (ls->t.token == ';' || ls->t.token == TK_DBCOLON) ------------------ | Branch (1461:10): [True: 14, False: 281] | Branch (1461:32): [True: 6, False: 275] ------------------ 1462| 20| statement(ls); /* skip other no-op statements */ 1463| 275| checkrepeated(ls, name); /* check for repeated labels */ 1464| 275| createlabel(ls, name, line, block_follow(ls, 0)); 1465| 275|} lparser.c:checkrepeated: 1448| 275|static void checkrepeated (LexState *ls, TString *name) { 1449| 275| Labeldesc *lb = findlabel(ls, name); 1450| 275| if (l_unlikely(lb != NULL)) { /* already defined? */ ------------------ | | 697| 275|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 275|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 275] | | | | ------------------ | | ------------------ ------------------ 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| 275|} lparser.c:findlabel: 544| 13.5k|static Labeldesc *findlabel (LexState *ls, TString *name) { 545| 13.5k| int i; 546| 13.5k| Dyndata *dyd = ls->dyd; 547| | /* check labels in current function for a match */ 548| 14.4k| for (i = ls->fs->firstlabel; i < dyd->label.n; i++) { ------------------ | Branch (548:32): [True: 6.41k, False: 7.98k] ------------------ 549| 6.41k| Labeldesc *lb = &dyd->label.arr[i]; 550| 6.41k| if (eqstr(lb->name, name)) /* correct label? */ ------------------ | | 43| 6.41k|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 5.60k, False: 813] | | ------------------ ------------------ 551| 5.60k| return lb; 552| 6.41k| } 553| 7.98k| return NULL; /* label not found */ 554| 13.5k|} lparser.c:str_checkname: 143| 12.7M|static TString *str_checkname (LexState *ls) { 144| 12.7M| TString *ts; 145| 12.7M| check(ls, TK_NAME); 146| 12.7M| ts = ls->t.seminfo.ts; 147| 12.7M| luaX_next(ls); 148| 12.7M| return ts; 149| 12.7M|} 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: 37, False: 2.91k] | Branch (1819:30): [True: 2, False: 2.91k] ------------------ 1820| 39| nret = 0; /* return no values */ 1821| 2.91k| else { 1822| 2.91k| nret = explist(ls, &e); /* optional return values */ 1823| 2.91k| if (hasmultret(e.k)) { ------------------ | | 38| 2.91k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 1.70k, False: 1.20k] | | | Branch (38:41): [True: 203, False: 1.00k] | | ------------------ ------------------ 1824| 1.91k| luaK_setmultret(fs, &e); ------------------ | | 58| 1.91k|#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) | | ------------------ | | | | 35| 1.91k|#define LUA_MULTRET (-1) | | ------------------ ------------------ 1825| 1.91k| if (e.k == VCALL && nret == 1 && !fs->bl->insidetbc) { /* tail call? */ ------------------ | Branch (1825:11): [True: 1.70k, False: 203] | Branch (1825:27): [True: 307, False: 1.40k] | Branch (1825:40): [True: 307, False: 0] ------------------ 1826| 307| SET_OPCODE(getinstruction(fs,&e), OP_TAILCALL); ------------------ | | 115| 307|#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ | | ------------------ | | | | 108| 307|#define MASK0(n,p) (~MASK1(n,p)) | | | | ------------------ | | | | | | 105| 307|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | ------------------ | | ------------------ | | 116| 307| ((cast(Instruction, o)<freereg - first); ------------------ | | 114| 137|#define lua_assert(c) ((void)0) ------------------ 1837| 137| } 1838| 1.00k| } 1839| 2.91k| } 1840| 2.95k| luaK_ret(fs, first, nret); 1841| 2.95k| testnext(ls, ';'); /* skip optional semicolon */ 1842| 2.95k|} lparser.c:breakstat: 1438| 1.35k|static void breakstat (LexState *ls) { 1439| 1.35k| int line = ls->linenumber; 1440| 1.35k| luaX_next(ls); /* skip break */ 1441| 1.35k| newgotoentry(ls, luaS_newliteral(ls->L, "break"), line, luaK_jump(ls->fs)); ------------------ | | 28| 1.35k|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 1.35k| (sizeof(s)/sizeof(char))-1)) ------------------ 1442| 1.35k|} lparser.c:gotostat: 1416| 13.3k|static void gotostat (LexState *ls) { 1417| 13.3k| FuncState *fs = ls->fs; 1418| 13.3k| int line = ls->linenumber; 1419| 13.3k| TString *name = str_checkname(ls); /* label's name */ 1420| 13.3k| Labeldesc *lb = findlabel(ls, name); 1421| 13.3k| if (lb == NULL) /* no label? */ ------------------ | Branch (1421:7): [True: 7.71k, False: 5.60k] ------------------ 1422| | /* forward jump; will be resolved when the label is declared */ 1423| 7.71k| newgotoentry(ls, name, line, luaK_jump(fs)); 1424| 5.60k| else { /* found a label */ 1425| | /* backward jump; will be resolved here */ 1426| 5.60k| int lblevel = reglevel(fs, lb->nactvar); /* label level */ 1427| 5.60k| if (luaY_nvarstack(fs) > lblevel) /* leaving the scope of a variable? */ ------------------ | Branch (1427:9): [True: 1.41k, False: 4.19k] ------------------ 1428| 1.41k| luaK_codeABC(fs, OP_CLOSE, lblevel, 0, 0); ------------------ | | 48| 1.41k|#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| 5.60k| luaK_patchlist(fs, luaK_jump(fs), lb->pc); 1431| 5.60k| } 1432| 13.3k|} lparser.c:exprstat: 1795| 25.7k|static void exprstat (LexState *ls) { 1796| | /* stat -> func | assignment */ 1797| 25.7k| FuncState *fs = ls->fs; 1798| 25.7k| struct LHS_assign v; 1799| 25.7k| suffixedexp(ls, &v.v); 1800| 25.7k| if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */ ------------------ | Branch (1800:7): [True: 22.7k, False: 3.00k] | Branch (1800:29): [True: 1.17k, False: 1.83k] ------------------ 1801| 23.8k| v.prev = NULL; 1802| 23.8k| restassign(ls, &v, 1); 1803| 23.8k| } 1804| 1.91k| else { /* stat -> func */ 1805| 1.91k| Instruction *inst; 1806| 1.91k| check_condition(ls, v.v.k == VCALL, "syntax error"); ------------------ | | 122| 1.91k|#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } | | ------------------ | | | Branch (122:41): [True: 17, False: 1.89k] | | ------------------ ------------------ 1807| 1.89k| inst = &getinstruction(fs, &v.v); ------------------ | | 55| 1.89k|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 1808| 1.89k| SETARG_C(*inst, 1); /* call statement uses no results */ ------------------ | | 134| 1.89k|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 1.89k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 1.89k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 1.89k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 1.89k| ((cast(Instruction, v)<v.k), "syntax error"); ------------------ | | 122| 55.5k|#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } | | ------------------ | | | Branch (122:43): [True: 27.7k, False: 0] | | | Branch (122:43): [True: 27.7k, False: 1] | | ------------------ ------------------ 1378| 27.7k| check_readonly(ls, &lh->v); 1379| 27.7k| if (testnext(ls, ',')) { /* restassign -> ',' suffixedexp restassign */ ------------------ | Branch (1379:7): [True: 3.94k, False: 23.8k] ------------------ 1380| 3.94k| struct LHS_assign nv; 1381| 3.94k| nv.prev = lh; 1382| 3.94k| suffixedexp(ls, &nv.v); 1383| 3.94k| if (!vkisindexed(nv.v.k)) ------------------ | | 65| 3.94k|#define vkisindexed(k) (VINDEXED <= (k) && (k) <= VINDEXSTR) | | ------------------ | | | Branch (65:25): [True: 2.47k, False: 1.47k] | | | Branch (65:44): [True: 2.47k, False: 1] | | ------------------ ------------------ 1384| 1.47k| check_conflict(ls, lh, &nv.v); 1385| 3.94k| enterlevel(ls); /* control recursion depth */ ------------------ | | 504| 3.94k|#define enterlevel(ls) luaE_incCstack(ls->L) ------------------ 1386| 3.94k| restassign(ls, &nv, nvars+1); 1387| 3.94k| leavelevel(ls); ------------------ | | 507| 3.94k|#define leavelevel(ls) ((ls)->L->nCcalls--) ------------------ 1388| 3.94k| } 1389| 23.8k| else { /* restassign -> '=' explist */ 1390| 23.8k| int nexps; 1391| 23.8k| checknext(ls, '='); 1392| 23.8k| nexps = explist(ls, &e); 1393| 23.8k| if (nexps != nvars) ------------------ | Branch (1393:9): [True: 5.90k, False: 17.9k] ------------------ 1394| 5.90k| adjust_assign(ls, nvars, nexps, &e); 1395| 17.9k| else { 1396| 17.9k| luaK_setoneret(ls->fs, &e); /* close last expression */ 1397| 17.9k| luaK_storevar(ls->fs, &lh->v, &e); 1398| 17.9k| return; /* avoid default */ 1399| 17.9k| } 1400| 23.8k| } 1401| 9.85k| init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */ 1402| 9.85k| luaK_storevar(ls->fs, &lh->v, &e); 1403| 9.85k|} lparser.c:check_conflict: 1331| 1.47k|static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) { 1332| 1.47k| FuncState *fs = ls->fs; 1333| 1.47k| int extra = fs->freereg; /* eventual position to save local variable */ 1334| 1.47k| int conflict = 0; 1335| 6.30k| for (; lh; lh = lh->prev) { /* check all previous assignments */ ------------------ | Branch (1335:10): [True: 4.83k, False: 1.47k] ------------------ 1336| 4.83k| if (vkisindexed(lh->v.k)) { /* assignment to table field? */ ------------------ | | 65| 4.83k|#define vkisindexed(k) (VINDEXED <= (k) && (k) <= VINDEXSTR) | | ------------------ | | | Branch (65:25): [True: 1.38k, False: 3.45k] | | | Branch (65:44): [True: 1.38k, False: 0] | | ------------------ ------------------ 1337| 1.38k| if (lh->v.k == VINDEXUP) { /* is table an upvalue? */ ------------------ | Branch (1337:11): [True: 1.29k, False: 90] ------------------ 1338| 1.29k| if (v->k == VUPVAL && lh->v.u.ind.t == v->u.info) { ------------------ | Branch (1338:13): [True: 1.00k, False: 288] | Branch (1338:31): [True: 4, False: 1.00k] ------------------ 1339| 4| conflict = 1; /* table is the upvalue being assigned now */ 1340| 4| lh->v.k = VINDEXSTR; 1341| 4| lh->v.u.ind.t = extra; /* assignment will use safe copy */ 1342| 4| } 1343| 1.29k| } 1344| 90| else { /* table is a register */ 1345| 90| if (v->k == VLOCAL && lh->v.u.ind.t == v->u.var.ridx) { ------------------ | Branch (1345:13): [True: 5, False: 85] | Branch (1345:31): [True: 0, False: 5] ------------------ 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| 90| if (lh->v.k == VINDEXED && v->k == VLOCAL && ------------------ | Branch (1350:13): [True: 1, False: 89] | Branch (1350:36): [True: 1, False: 0] ------------------ 1351| 90| lh->v.u.ind.idx == v->u.var.ridx) { ------------------ | Branch (1351:13): [True: 0, False: 1] ------------------ 1352| 0| conflict = 1; 1353| 0| lh->v.u.ind.idx = extra; /* previous assignment will use safe copy */ 1354| 0| } 1355| 90| } 1356| 1.38k| } 1357| 4.83k| } 1358| 1.47k| if (conflict) { ------------------ | Branch (1358:7): [True: 4, False: 1.46k] ------------------ 1359| | /* copy upvalue/local value to a temporary (in position 'extra') */ 1360| 4| if (v->k == VLOCAL) ------------------ | Branch (1360:9): [True: 0, False: 4] ------------------ 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| 4| else 1363| 4| luaK_codeABC(fs, OP_GETUPVAL, extra, v->u.info, 0); ------------------ | | 48| 4|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1364| 4| luaK_reserveregs(fs, 1); 1365| 4| } 1366| 1.47k|} lparser.c:check: 107| 12.8M|static void check (LexState *ls, int c) { 108| 12.8M| if (ls->t.token != c) ------------------ | Branch (108:7): [True: 11, False: 12.8M] ------------------ 109| 11| error_expected(ls, c); 110| 12.8M|} lparser.c:close_func: 756| 2.78k|static void close_func (LexState *ls) { 757| 2.78k| lua_State *L = ls->L; 758| 2.78k| FuncState *fs = ls->fs; 759| 2.78k| Proto *f = fs->f; 760| 2.78k| luaK_ret(fs, luaY_nvarstack(fs), 0); /* final return */ 761| 2.78k| leaveblock(fs); 762| 2.78k| lua_assert(fs->bl == NULL); ------------------ | | 114| 2.78k|#define lua_assert(c) ((void)0) ------------------ 763| 2.78k| luaK_finish(fs); 764| 2.78k| luaM_shrinkvector(L, f->code, f->sizecode, fs->pc, Instruction); ------------------ | | 75| 2.78k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.78k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 765| 2.78k| luaM_shrinkvector(L, f->lineinfo, f->sizelineinfo, fs->pc, ls_byte); ------------------ | | 75| 2.78k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.78k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 766| 2.78k| luaM_shrinkvector(L, f->abslineinfo, f->sizeabslineinfo, ------------------ | | 75| 2.78k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.78k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 767| 2.78k| fs->nabslineinfo, AbsLineInfo); 768| 2.78k| luaM_shrinkvector(L, f->k, f->sizek, fs->nk, TValue); ------------------ | | 75| 2.78k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.78k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 769| 2.78k| luaM_shrinkvector(L, f->p, f->sizep, fs->np, Proto *); ------------------ | | 75| 2.78k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.78k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 770| 2.78k| luaM_shrinkvector(L, f->locvars, f->sizelocvars, fs->ndebugvars, LocVar); ------------------ | | 75| 2.78k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.78k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 771| 2.78k| luaM_shrinkvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc); ------------------ | | 75| 2.78k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 2.78k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 772| 2.78k| ls->fs = fs->prev; 773| 2.78k| luaC_checkGC(L); ------------------ | | 172| 2.78k|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 2.78k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 2.78k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 53, False: 2.73k] | | | | ------------------ | | | | 169| 2.78k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 2.78k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 774| 2.78k|} luaE_setdebt: 89| 1.69k|void luaE_setdebt (global_State *g, l_mem debt) { 90| 1.69k| l_mem tb = gettotalbytes(g); ------------------ | | 394| 1.69k|#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) | | ------------------ | | | | 136| 1.69k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 91| 1.69k| lua_assert(tb > 0); ------------------ | | 114| 1.69k|#define lua_assert(c) ((void)0) ------------------ 92| 1.69k| if (debt < tb - MAX_LMEM) ------------------ | | 50| 1.69k|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 1.69k|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ | Branch (92:7): [True: 0, False: 1.69k] ------------------ 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.69k| g->totalbytes = tb - debt; 95| 1.69k| g->GCdebt = debt; 96| 1.69k|} luaE_extendCI: 105| 143|CallInfo *luaE_extendCI (lua_State *L) { 106| 143| CallInfo *ci; 107| 143| lua_assert(L->ci->next == NULL); ------------------ | | 114| 143|#define lua_assert(c) ((void)0) ------------------ 108| 143| ci = luaM_new(L, CallInfo); ------------------ | | 59| 143|#define luaM_new(L,t) cast(t*, luaM_malloc_(L, sizeof(t), 0)) | | ------------------ | | | | 136| 143|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 109| 143| lua_assert(L->ci->next == NULL); ------------------ | | 114| 143|#define lua_assert(c) ((void)0) ------------------ 110| 143| L->ci->next = ci; 111| 143| ci->previous = L->ci; 112| 143| ci->next = NULL; 113| 143| ci->u.l.trap = 0; 114| 143| L->nci++; 115| 143| return ci; 116| 143|} luaE_shrinkCI: 138| 2.07k|void luaE_shrinkCI (lua_State *L) { 139| 2.07k| CallInfo *ci = L->ci->next; /* first free CallInfo */ 140| 2.07k| CallInfo *next; 141| 2.07k| if (ci == NULL) ------------------ | Branch (141:7): [True: 1.88k, False: 190] ------------------ 142| 1.88k| return; /* no extra elements */ 143| 206| while ((next = ci->next) != NULL) { /* two extra elements? */ ------------------ | Branch (143:10): [True: 56, False: 150] ------------------ 144| 56| CallInfo *next2 = next->next; /* next's next */ 145| 56| ci->next = next2; /* remove next from the list */ 146| 56| L->nci--; 147| 56| luaM_free(L, next); /* free next */ ------------------ | | 56| 56|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 148| 56| if (next2 == NULL) ------------------ | Branch (148:9): [True: 40, False: 16] ------------------ 149| 40| break; /* no more elements */ 150| 16| else { 151| 16| next2->previous = ci; 152| 16| ci = next2; /* continue */ 153| 16| } 154| 56| } 155| 190|} luaE_checkcstack: 165| 5|void luaE_checkcstack (lua_State *L) { 166| 5| if (getCcalls(L) == LUAI_MAXCCALLS) ------------------ | | 107| 5|#define getCcalls(L) ((L)->nCcalls & 0xffff) ------------------ if (getCcalls(L) == LUAI_MAXCCALLS) ------------------ | | 255| 5|#define LUAI_MAXCCALLS 200 ------------------ | Branch (166:7): [True: 5, False: 0] ------------------ 167| 5| 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| 5|} luaE_incCstack: 173| 13.6M|LUAI_FUNC void luaE_incCstack (lua_State *L) { 174| 13.6M| L->nCcalls++; 175| 13.6M| if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) ------------------ | | 697| 13.6M|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 13.6M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 5, False: 13.6M] | | | | ------------------ | | ------------------ ------------------ 176| 5| luaE_checkcstack(L); 177| 13.6M|} lua_newstate: 360| 390|LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) { 361| 390| int i; 362| 390| lua_State *L; 363| 390| global_State *g; 364| 390| LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG))); ------------------ | | 136| 390|#define cast(t, exp) ((t)(exp)) ------------------ 365| 390| if (l == NULL) return NULL; ------------------ | Branch (365:7): [True: 0, False: 390] ------------------ 366| 390| L = &l->l.l; 367| 390| g = &l->g; 368| 390| L->tt = LUA_VTHREAD; ------------------ | | 262| 390|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 390|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 369| 390| g->currentwhite = bitmask(WHITE0BIT); ------------------ | | 63| 390|#define bitmask(b) (1<<(b)) ------------------ 370| 390| L->marked = luaC_white(g); ------------------ | | 102| 390|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 143| 390|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 371| 390| preinit_thread(L, g); 372| 390| g->allgc = obj2gco(L); /* by now, only object is the main thread */ ------------------ | | 390| 390|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 390|#define check_exp(c,e) (e) | | ------------------ ------------------ 373| 390| L->next = NULL; 374| 390| incnny(L); /* main thread is always non yieldable */ ------------------ | | 111| 390|#define incnny(L) ((L)->nCcalls += 0x10000) ------------------ 375| 390| g->frealloc = f; 376| 390| g->ud = ud; 377| 390| g->warnf = NULL; 378| 390| g->ud_warn = NULL; 379| 390| g->mainthread = L; 380| 390| g->seed = luai_makeseed(L); 381| 390| g->gcstp = GCSTPGC; /* no GC while building state */ ------------------ | | 156| 390|#define GCSTPGC 2 /* bit true when GC stopped by itself */ ------------------ 382| 390| g->strt.size = g->strt.nuse = 0; 383| 390| g->strt.hash = NULL; 384| 390| setnilvalue(&g->l_registry); ------------------ | | 200| 390|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 390|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 385| 390| g->panic = NULL; 386| 390| g->gcstate = GCSpause; ------------------ | | 39| 390|#define GCSpause 8 ------------------ 387| 390| g->gckind = KGC_INC; ------------------ | | 151| 390|#define KGC_INC 0 /* incremental gc */ ------------------ 388| 390| g->gcstopem = 0; 389| 390| g->gcemergency = 0; 390| 390| g->finobj = g->tobefnz = g->fixedgc = NULL; 391| 390| g->firstold1 = g->survival = g->old1 = g->reallyold = NULL; 392| 390| g->finobjsur = g->finobjold1 = g->finobjrold = NULL; 393| 390| g->sweepgc = NULL; 394| 390| g->gray = g->grayagain = NULL; 395| 390| g->weak = g->ephemeron = g->allweak = NULL; 396| 390| g->twups = NULL; 397| 390| g->totalbytes = sizeof(LG); 398| 390| g->GCdebt = 0; 399| 390| g->lastatomic = 0; 400| 390| setivalue(&g->nilvalue, 0); /* to signal that state is not yet built */ ------------------ | | 345| 390| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 390|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 390|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 401| 390| setgcparam(g->gcpause, LUAI_GCPAUSE); ------------------ | | 136| 390|#define setgcparam(p,v) ((p) = (v) / 4) ------------------ 402| 390| setgcparam(g->gcstepmul, LUAI_GCMUL); ------------------ | | 136| 390|#define setgcparam(p,v) ((p) = (v) / 4) ------------------ 403| 390| g->gcstepsize = LUAI_GCSTEPSIZE; ------------------ | | 141| 390|#define LUAI_GCSTEPSIZE 13 /* 8 KB */ ------------------ 404| 390| setgcparam(g->genmajormul, LUAI_GENMAJORMUL); ------------------ | | 136| 390|#define setgcparam(p,v) ((p) = (v) / 4) ------------------ 405| 390| g->genminormul = LUAI_GENMINORMUL; ------------------ | | 126| 390|#define LUAI_GENMINORMUL 20 ------------------ 406| 3.90k| for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL; ------------------ | | 426| 3.90k|#define LUA_NUMTAGS LUA_NUMTYPES | | ------------------ | | | | 74| 3.90k|#define LUA_NUMTYPES 9 | | ------------------ ------------------ | Branch (406:13): [True: 3.51k, False: 390] ------------------ 407| 390| if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) { ------------------ | | 48| 390|#define LUA_OK 0 ------------------ | Branch (407:7): [True: 0, False: 390] ------------------ 408| | /* memory allocation error: free partial state */ 409| 0| close_state(L); 410| 0| L = NULL; 411| 0| } 412| 390| return L; 413| 390|} lua_close: 416| 390|LUA_API void lua_close (lua_State *L) { 417| 390| lua_lock(L); ------------------ | | 264| 390|#define lua_lock(L) ((void) 0) ------------------ 418| 390| L = G(L)->mainthread; /* only the main thread can be closed */ ------------------ | | 335| 390|#define G(L) (L->l_G) ------------------ 419| 390| close_state(L); 420| 390|} lstate.c:preinit_thread: 249| 390|static void preinit_thread (lua_State *L, global_State *g) { 250| 390| G(L) = g; ------------------ | | 335| 390|#define G(L) (L->l_G) ------------------ 251| 390| L->stack.p = NULL; 252| 390| L->ci = NULL; 253| 390| L->nci = 0; 254| 390| L->twups = L; /* thread has no upvalues */ 255| 390| L->nCcalls = 0; 256| 390| L->errorJmp = NULL; 257| 390| L->hook = NULL; 258| 390| L->hookmask = 0; 259| 390| L->basehookcount = 0; 260| 390| L->allowhook = 1; 261| 390| resethookcount(L); ------------------ | | 21| 390|#define resethookcount(L) (L->hookcount = L->basehookcount) ------------------ 262| 390| L->openupval = NULL; 263| 390| L->status = LUA_OK; ------------------ | | 48| 390|#define LUA_OK 0 ------------------ 264| 390| L->errfunc = 0; 265| 390| L->oldpc = 0; 266| 390|} lstate.c:stack_init: 180| 390|static void stack_init (lua_State *L1, lua_State *L) { 181| 390| int i; CallInfo *ci; 182| | /* initialize stack array */ 183| 390| L1->stack.p = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, StackValue); ------------------ | | 60| 390|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 184| 390| L1->tbclist.p = L1->stack.p; 185| 17.9k| for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++) ------------------ | | 145| 17.9k|#define BASIC_STACK_SIZE (2*LUA_MINSTACK) | | ------------------ | | | | 79| 17.9k|#define LUA_MINSTACK 20 | | ------------------ ------------------ for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++) ------------------ | | 142| 17.9k|#define EXTRA_STACK 5 ------------------ | Branch (185:15): [True: 17.5k, False: 390] ------------------ 186| 17.5k| setnilvalue(s2v(L1->stack.p + i)); /* erase new stack */ ------------------ | | 200| 17.5k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 17.5k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 187| 390| L1->top.p = L1->stack.p; 188| 390| L1->stack_last.p = L1->stack.p + BASIC_STACK_SIZE; ------------------ | | 145| 390|#define BASIC_STACK_SIZE (2*LUA_MINSTACK) | | ------------------ | | | | 79| 390|#define LUA_MINSTACK 20 | | ------------------ ------------------ 189| | /* initialize first ci */ 190| 390| ci = &L1->base_ci; 191| 390| ci->next = ci->previous = NULL; 192| 390| ci->callstatus = CIST_C; ------------------ | | 211| 390|#define CIST_C (1<<1) /* call is running a C function */ ------------------ 193| 390| ci->func.p = L1->top.p; 194| 390| ci->u.c.k = NULL; 195| 390| ci->nresults = 0; 196| 390| setnilvalue(s2v(L1->top.p)); /* 'function' entry for this 'ci' */ ------------------ | | 200| 390|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 390|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 197| 390| L1->top.p++; 198| 390| ci->top.p = L1->top.p + LUA_MINSTACK; ------------------ | | 79| 390|#define LUA_MINSTACK 20 ------------------ 199| 390| L1->ci = ci; 200| 390|} lstate.c:freestack: 203| 390|static void freestack (lua_State *L) { 204| 390| if (L->stack.p == NULL) ------------------ | Branch (204:7): [True: 0, False: 390] ------------------ 205| 0| return; /* stack not completely built yet */ 206| 390| L->ci = &L->base_ci; /* free the entire 'ci' list */ 207| 390| freeCI(L); 208| 390| lua_assert(L->nci == 0); ------------------ | | 114| 390|#define lua_assert(c) ((void)0) ------------------ 209| 390| luaM_freearray(L, L->stack.p, stacksize(L) + EXTRA_STACK); /* free stack */ ------------------ | | 57| 390|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 210| 390|} lstate.c:freeCI: 122| 390|static void freeCI (lua_State *L) { 123| 390| CallInfo *ci = L->ci; 124| 390| CallInfo *next = ci->next; 125| 390| ci->next = NULL; 126| 477| while ((ci = next) != NULL) { ------------------ | Branch (126:10): [True: 87, False: 390] ------------------ 127| 87| next = ci->next; 128| 87| luaM_free(L, ci); ------------------ | | 56| 87|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 129| 87| L->nci--; 130| 87| } 131| 390|} lstate.c:luai_makeseed: 71| 390|static unsigned int luai_makeseed (lua_State *L) { 72| 390| char buff[3 * sizeof(size_t)]; 73| 390| unsigned int h = cast_uint(time(NULL)); ------------------ | | 142| 390|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 74| 390| int p = 0; 75| 390| addbuff(buff, p, L); /* heap variable */ ------------------ | | 68| 390| { size_t t = cast_sizet(e); \ | | ------------------ | | | | 147| 390|#define cast_sizet(i) cast(size_t, (i)) | | | | ------------------ | | | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 69| 390| memcpy(b + p, &t, sizeof(t)); p += sizeof(t); } ------------------ 76| 390| addbuff(buff, p, &h); /* local variable */ ------------------ | | 68| 390| { size_t t = cast_sizet(e); \ | | ------------------ | | | | 147| 390|#define cast_sizet(i) cast(size_t, (i)) | | | | ------------------ | | | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 69| 390| memcpy(b + p, &t, sizeof(t)); p += sizeof(t); } ------------------ 77| 390| addbuff(buff, p, &lua_newstate); /* public function */ ------------------ | | 68| 390| { size_t t = cast_sizet(e); \ | | ------------------ | | | | 147| 390|#define cast_sizet(i) cast(size_t, (i)) | | | | ------------------ | | | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 69| 390| memcpy(b + p, &t, sizeof(t)); p += sizeof(t); } ------------------ 78| 390| lua_assert(p == sizeof(buff)); ------------------ | | 114| 390|#define lua_assert(c) ((void)0) ------------------ 79| 390| return luaS_hash(buff, p, h); 80| 390|} lstate.c:f_luaopen: 231| 390|static void f_luaopen (lua_State *L, void *ud) { 232| 390| global_State *g = G(L); ------------------ | | 335| 390|#define G(L) (L->l_G) ------------------ 233| 390| UNUSED(ud); ------------------ | | 131| 390|#define UNUSED(x) ((void)(x)) ------------------ 234| 390| stack_init(L, L); /* init stack */ 235| 390| init_registry(L, g); 236| 390| luaS_init(L); 237| 390| luaT_init(L); 238| 390| luaX_init(L); 239| 390| g->gcstp = 0; /* allow gc */ 240| 390| setnilvalue(&g->nilvalue); /* now state is complete */ ------------------ | | 200| 390|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 390|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 241| 390| luai_userstateopen(L); ------------------ | | 282| 390|#define luai_userstateopen(L) ((void)L) ------------------ 242| 390|} lstate.c:init_registry: 216| 390|static void init_registry (lua_State *L, global_State *g) { 217| | /* create registry */ 218| 390| Table *registry = luaH_new(L); 219| 390| sethvalue(L, &g->l_registry, registry); ------------------ | | 685| 390| { TValue *io = (obj); Table *x_ = (x); \ | | 686| 390| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 390|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 390| 390|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 390|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 390|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 687| 390| checkliveness(L,io); } | | ------------------ | | | | 107| 390| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 390|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 390| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 220| 390| luaH_resize(L, registry, LUA_RIDX_LAST, 0); ------------------ | | 85| 390|#define LUA_RIDX_LAST LUA_RIDX_GLOBALS | | ------------------ | | | | 84| 390|#define LUA_RIDX_GLOBALS 2 | | ------------------ ------------------ 221| | /* registry[LUA_RIDX_MAINTHREAD] = L */ 222| 390| setthvalue(L, ®istry->array[LUA_RIDX_MAINTHREAD - 1], L); ------------------ | | 269| 390| { TValue *io = (obj); lua_State *x_ = (x); \ | | 270| 390| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 72| 390|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 390| 390|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 390|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 114| 390|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 271| 390| checkliveness(L,io); } | | ------------------ | | | | 107| 390| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 390|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 390| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 223| | /* registry[LUA_RIDX_GLOBALS] = new table (table of globals) */ 224| 390| sethvalue(L, ®istry->array[LUA_RIDX_GLOBALS - 1], luaH_new(L)); ------------------ | | 685| 390| { TValue *io = (obj); Table *x_ = (x); \ | | 686| 390| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 390|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 390| 390|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 390|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 390|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 687| 390| checkliveness(L,io); } | | ------------------ | | | | 107| 390| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 390|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 390| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 225| 390|} lstate.c:close_state: 269| 390|static void close_state (lua_State *L) { 270| 390| global_State *g = G(L); ------------------ | | 335| 390|#define G(L) (L->l_G) ------------------ 271| 390| if (!completestate(g)) /* closing a partially built state? */ ------------------ | | 341| 390|#define completestate(g) ttisnil(&g->nilvalue) | | ------------------ | | | | 193| 390|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 390|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 390|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 390|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (271:7): [True: 0, False: 390] ------------------ 272| 0| luaC_freeallobjects(L); /* just collect its objects */ 273| 390| else { /* closing a fully built state */ 274| 390| L->ci = &L->base_ci; /* unwind CallInfo list */ 275| 390| luaD_closeprotected(L, 1, LUA_OK); /* close all upvalues */ ------------------ | | 48| 390|#define LUA_OK 0 ------------------ 276| 390| luaC_freeallobjects(L); /* collect all objects */ 277| 390| luai_userstateclose(L); ------------------ | | 286| 390|#define luai_userstateclose(L) ((void)L) ------------------ 278| 390| } 279| 390| luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size); ------------------ | | 57| 390|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 280| 390| freestack(L); 281| 390| lua_assert(gettotalbytes(g) == sizeof(LG)); ------------------ | | 114| 390|#define lua_assert(c) ((void)0) ------------------ 282| 390| (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0); /* free main block */ ------------------ | | 51| 390|#define fromstate(L) (cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l))) | | ------------------ | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 283| 390|} luaS_eqlngstr: 34| 94.1k|int luaS_eqlngstr (TString *a, TString *b) { 35| 94.1k| size_t len = a->u.lnglen; 36| 94.1k| lua_assert(a->tt == LUA_VLNGSTR && b->tt == LUA_VLNGSTR); ------------------ | | 114| 94.1k|#define lua_assert(c) ((void)0) ------------------ 37| 94.1k| return (a == b) || /* same instance or... */ ------------------ | Branch (37:10): [True: 57.2k, False: 36.9k] ------------------ 38| 94.1k| ((len == b->u.lnglen) && /* equal length and ... */ ------------------ | Branch (38:6): [True: 28.4k, False: 8.52k] ------------------ 39| 36.9k| (memcmp(getlngstr(a), getlngstr(b), len) == 0)); /* equal contents */ ------------------ | | 405| 28.4k|#define getlngstr(ts) check_exp((ts)->shrlen == 0xFF, (ts)->contents) | | ------------------ | | | | 115| 28.4k|#define check_exp(c,e) (e) | | ------------------ ------------------ (memcmp(getlngstr(a), getlngstr(b), len) == 0)); /* equal contents */ ------------------ | | 405| 28.4k|#define getlngstr(ts) check_exp((ts)->shrlen == 0xFF, (ts)->contents) | | ------------------ | | | | 115| 28.4k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (39:6): [True: 28.1k, False: 308] ------------------ 40| 94.1k|} luaS_hash: 43| 13.7M|unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) { 44| 13.7M| unsigned int h = seed ^ cast_uint(l); ------------------ | | 142| 13.7M|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 13.7M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 45| 47.2M| for (; l > 0; l--) ------------------ | Branch (45:10): [True: 33.4M, False: 13.7M] ------------------ 46| 33.4M| h ^= ((h<<5) + (h>>2) + cast_byte(str[l - 1])); ------------------ | | 143| 33.4M|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 33.4M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 47| 13.7M| return h; 48| 13.7M|} luaS_hashlongstr: 51| 73.4k|unsigned int luaS_hashlongstr (TString *ts) { 52| 73.4k| lua_assert(ts->tt == LUA_VLNGSTR); ------------------ | | 114| 73.4k|#define lua_assert(c) ((void)0) ------------------ 53| 73.4k| if (ts->extra == 0) { /* no hash? */ ------------------ | Branch (53:7): [True: 29.7k, False: 43.6k] ------------------ 54| 29.7k| size_t len = ts->u.lnglen; 55| 29.7k| ts->hash = luaS_hash(getlngstr(ts), len, ts->hash); ------------------ | | 405| 29.7k|#define getlngstr(ts) check_exp((ts)->shrlen == 0xFF, (ts)->contents) | | ------------------ | | | | 115| 29.7k|#define check_exp(c,e) (e) | | ------------------ ------------------ 56| 29.7k| ts->extra = 1; /* now it has its hash */ 57| 29.7k| } 58| 73.4k| return ts->hash; 59| 73.4k|} luaS_resize: 85| 168|void luaS_resize (lua_State *L, int nsize) { 86| 168| stringtable *tb = &G(L)->strt; ------------------ | | 335| 168|#define G(L) (L->l_G) ------------------ 87| 168| int osize = tb->size; 88| 168| TString **newvect; 89| 168| if (nsize < osize) /* shrinking table? */ ------------------ | Branch (89:7): [True: 22, False: 146] ------------------ 90| 22| tablerehash(tb->hash, osize, nsize); /* depopulate shrinking part */ 91| 168| newvect = luaM_reallocvector(L, tb->hash, osize, nsize, TString*); ------------------ | | 71| 168| (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \ | | ------------------ | | | | 136| 168|#define cast(t, exp) ((t)(exp)) | | ------------------ | | 72| 168| cast_sizet(n) * sizeof(t)))) ------------------ 92| 168| if (l_unlikely(newvect == NULL)) { /* reallocation failed? */ ------------------ | | 697| 168|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 168|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 168] | | | | ------------------ | | ------------------ ------------------ 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| 168| else { /* allocation succeeded */ 98| 168| tb->hash = newvect; 99| 168| tb->size = nsize; 100| 168| if (nsize > osize) ------------------ | Branch (100:9): [True: 146, False: 22] ------------------ 101| 146| tablerehash(newvect, osize, nsize); /* rehash for new size */ 102| 168| } 103| 168|} luaS_clearcache: 110| 1.69k|void luaS_clearcache (global_State *g) { 111| 1.69k| int i, j; 112| 91.4k| for (i = 0; i < STRCACHE_N; i++) ------------------ | | 237| 91.4k|#define STRCACHE_N 53 ------------------ | Branch (112:15): [True: 89.7k, False: 1.69k] ------------------ 113| 269k| for (j = 0; j < STRCACHE_M; j++) { ------------------ | | 238| 269k|#define STRCACHE_M 2 ------------------ | Branch (113:17): [True: 179k, False: 89.7k] ------------------ 114| 179k| if (iswhite(g->strcache[i][j])) /* will entry be collected? */ ------------------ | | 87| 179k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 179k|#define testbits(x,m) ((x) & (m)) | | | | ------------------ | | | | | Branch (62:24): [True: 0, False: 179k] | | | | ------------------ | | ------------------ ------------------ 115| 0| g->strcache[i][j] = g->memerrmsg; /* replace it with something fixed */ 116| 179k| } 117| 1.69k|} luaS_init: 123| 390|void luaS_init (lua_State *L) { 124| 390| global_State *g = G(L); ------------------ | | 335| 390|#define G(L) (L->l_G) ------------------ 125| 390| int i, j; 126| 390| stringtable *tb = &G(L)->strt; ------------------ | | 335| 390|#define G(L) (L->l_G) ------------------ 127| 390| tb->hash = luaM_newvector(L, MINSTRTABSIZE, TString*); ------------------ | | 60| 390|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 128| 390| tablerehash(tb->hash, 0, MINSTRTABSIZE); /* clear array */ ------------------ | | 227| 390|#define MINSTRTABSIZE 128 ------------------ 129| 390| tb->size = MINSTRTABSIZE; ------------------ | | 227| 390|#define MINSTRTABSIZE 128 ------------------ 130| | /* pre-create memory-error message */ 131| 390| g->memerrmsg = luaS_newliteral(L, MEMERRMSG); ------------------ | | 28| 390|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 390| (sizeof(s)/sizeof(char))-1)) ------------------ 132| 390| luaC_fix(L, obj2gco(g->memerrmsg)); /* it should never be collected */ ------------------ | | 390| 390|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 390|#define check_exp(c,e) (e) | | ------------------ ------------------ 133| 21.0k| for (i = 0; i < STRCACHE_N; i++) /* fill cache with valid strings */ ------------------ | | 237| 21.0k|#define STRCACHE_N 53 ------------------ | Branch (133:15): [True: 20.6k, False: 390] ------------------ 134| 62.0k| for (j = 0; j < STRCACHE_M; j++) ------------------ | | 238| 62.0k|#define STRCACHE_M 2 ------------------ | Branch (134:17): [True: 41.3k, False: 20.6k] ------------------ 135| 41.3k| g->strcache[i][j] = g->memerrmsg; 136| 390|} luaS_createlngstrobj: 157| 30.5k|TString *luaS_createlngstrobj (lua_State *L, size_t l) { 158| 30.5k| TString *ts = createstrobj(L, l, LUA_VLNGSTR, G(L)->seed); ------------------ | | 361| 30.5k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 30.5k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ TString *ts = createstrobj(L, l, LUA_VLNGSTR, G(L)->seed); ------------------ | | 335| 30.5k|#define G(L) (L->l_G) ------------------ 159| 30.5k| ts->u.lnglen = l; 160| 30.5k| ts->shrlen = 0xFF; /* signals that it is a long string */ 161| 30.5k| return ts; 162| 30.5k|} luaS_remove: 165| 62.1k|void luaS_remove (lua_State *L, TString *ts) { 166| 62.1k| stringtable *tb = &G(L)->strt; ------------------ | | 335| 62.1k|#define G(L) (L->l_G) ------------------ 167| 62.1k| TString **p = &tb->hash[lmod(ts->hash, tb->size)]; ------------------ | | 787| 62.1k| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 115| 62.1k|#define check_exp(c,e) (e) | | ------------------ ------------------ 168| 67.5k| while (*p != ts) /* find previous element */ ------------------ | Branch (168:10): [True: 5.40k, False: 62.1k] ------------------ 169| 5.40k| p = &(*p)->u.hnext; 170| 62.1k| *p = (*p)->u.hnext; /* remove element from its list */ 171| 62.1k| tb->nuse--; 172| 62.1k|} luaS_newlstr: 222| 13.7M|TString *luaS_newlstr (lua_State *L, const char *str, size_t l) { 223| 13.7M| if (l <= LUAI_MAXSHORTLEN) /* short string? */ ------------------ | | 216| 13.7M|#define LUAI_MAXSHORTLEN 40 ------------------ | Branch (223:7): [True: 13.7M, False: 30.4k] ------------------ 224| 13.7M| return internshrstr(L, str, l); 225| 30.4k| else { 226| 30.4k| TString *ts; 227| 30.4k| if (l_unlikely(l >= (MAX_SIZE - sizeof(TString))/sizeof(char))) ------------------ | | 697| 30.4k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 60.8k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 30.4k] | | | | | Branch (685:46): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 228| 0| luaM_toobig(L); 229| 30.4k| ts = luaS_createlngstrobj(L, l); 230| 30.4k| memcpy(getlngstr(ts), str, l * sizeof(char)); ------------------ | | 405| 30.4k|#define getlngstr(ts) check_exp((ts)->shrlen == 0xFF, (ts)->contents) | | ------------------ | | | | 115| 30.4k|#define check_exp(c,e) (e) | | ------------------ ------------------ 231| 30.4k| return ts; 232| 30.4k| } 233| 13.7M|} luaS_new: 242| 18.9k|TString *luaS_new (lua_State *L, const char *str) { 243| 18.9k| unsigned int i = point2uint(str) % STRCACHE_N; /* hash */ ------------------ | | 91| 18.9k|#define point2uint(p) ((unsigned int)((L_P2I)(p) & UINT_MAX)) ------------------ unsigned int i = point2uint(str) % STRCACHE_N; /* hash */ ------------------ | | 237| 18.9k|#define STRCACHE_N 53 ------------------ 244| 18.9k| int j; 245| 18.9k| TString **p = G(L)->strcache[i]; ------------------ | | 335| 18.9k|#define G(L) (L->l_G) ------------------ 246| 56.6k| for (j = 0; j < STRCACHE_M; j++) { ------------------ | | 238| 56.6k|#define STRCACHE_M 2 ------------------ | Branch (246:15): [True: 37.8k, False: 18.8k] ------------------ 247| 37.8k| if (strcmp(str, getstr(p[j])) == 0) /* hit? */ ------------------ | | 404| 37.8k|#define getstr(ts) ((ts)->contents) ------------------ | Branch (247:9): [True: 64, False: 37.7k] ------------------ 248| 64| return p[j]; /* that is it */ 249| 37.8k| } 250| | /* normal route */ 251| 37.7k| for (j = STRCACHE_M - 1; j > 0; j--) ------------------ | | 238| 18.8k|#define STRCACHE_M 2 ------------------ | Branch (251:28): [True: 18.8k, False: 18.8k] ------------------ 252| 18.8k| p[j] = p[j - 1]; /* move out last element */ 253| | /* new element is first in the list */ 254| 18.8k| p[0] = luaS_newlstr(L, str, strlen(str)); 255| 18.8k| return p[0]; 256| 18.9k|} luaS_newudata: 259| 16|Udata *luaS_newudata (lua_State *L, size_t s, int nuvalue) { 260| 16| Udata *u; 261| 16| int i; 262| 16| GCObject *o; 263| 16| if (l_unlikely(s > MAX_SIZE - udatamemoffset(nuvalue))) ------------------ | | 697| 16|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 64|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 16] | | | | | Branch (685:46): [Folded - Ignored] | | | | | Branch (685:46): [True: 16, False: 0] | | | | ------------------ | | ------------------ ------------------ 264| 0| luaM_toobig(L); 265| 16| o = luaC_newobj(L, LUA_VUSERDATA, sizeudata(nuvalue, s)); ------------------ | | 429| 16|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 16|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ o = luaC_newobj(L, LUA_VUSERDATA, sizeudata(nuvalue, s)); ------------------ | | 496| 16|#define sizeudata(nuv,nb) (udatamemoffset(nuv) + (nb)) | | ------------------ | | | | 489| 16| ((nuv) == 0 ? offsetof(Udata0, bindata) \ | | | | ------------------ | | | | | Branch (489:3): [True: 16, False: 0] | | | | ------------------ | | | | 490| 16| : offsetof(Udata, uv) + (sizeof(UValue) * (nuv))) | | ------------------ ------------------ 266| 16| u = gco2u(o); ------------------ | | 375| 16|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ 267| 16| u->len = s; 268| 16| u->nuvalue = nuvalue; 269| 16| u->metatable = NULL; 270| 16| for (i = 0; i < nuvalue; i++) ------------------ | Branch (270:15): [True: 0, False: 16] ------------------ 271| 16| setnilvalue(&u->uv[i].uv); ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 272| 16| return u; 273| 16|} lstring.c:tablerehash: 62| 558|static void tablerehash (TString **vect, int osize, int nsize) { 63| 558| int i; 64| 75.5k| for (i = osize; i < nsize; i++) /* clear new elements */ ------------------ | Branch (64:19): [True: 75.0k, False: 558] ------------------ 65| 75.0k| vect[i] = NULL; 66| 39.4k| for (i = 0; i < osize; i++) { /* rehash old part of the array */ ------------------ | Branch (66:15): [True: 38.9k, False: 558] ------------------ 67| 38.9k| TString *p = vect[i]; 68| 38.9k| vect[i] = NULL; 69| 65.9k| while (p) { /* for each string in the list */ ------------------ | Branch (69:12): [True: 27.0k, False: 38.9k] ------------------ 70| 27.0k| TString *hnext = p->u.hnext; /* save next */ 71| 27.0k| unsigned int h = lmod(p->hash, nsize); /* new position */ ------------------ | | 787| 27.0k| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 115| 27.0k|#define check_exp(c,e) (e) | | ------------------ ------------------ 72| 27.0k| p->u.hnext = vect[h]; /* chain it into array */ 73| 27.0k| vect[h] = p; 74| 27.0k| p = hnext; 75| 27.0k| } 76| 38.9k| } 77| 558|} lstring.c:createstrobj: 143| 92.7k|static TString *createstrobj (lua_State *L, size_t l, int tag, unsigned int h) { 144| 92.7k| TString *ts; 145| 92.7k| GCObject *o; 146| 92.7k| size_t totalsize; /* total size of TString object */ 147| 92.7k| totalsize = sizelstring(l); ------------------ | | 26| 92.7k|#define sizelstring(l) (offsetof(TString, contents) + ((l) + 1) * sizeof(char)) ------------------ 148| 92.7k| o = luaC_newobj(L, tag, totalsize); 149| 92.7k| ts = gco2ts(o); ------------------ | | 374| 92.7k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 115| 92.7k|#define check_exp(c,e) (e) | | ------------------ ------------------ 150| 92.7k| ts->hash = h; 151| 92.7k| ts->extra = 0; 152| 92.7k| getstr(ts)[l] = '\0'; /* ending 0 */ ------------------ | | 404| 92.7k|#define getstr(ts) ((ts)->contents) ------------------ 153| 92.7k| return ts; 154| 92.7k|} lstring.c:internshrstr: 189| 13.7M|static TString *internshrstr (lua_State *L, const char *str, size_t l) { 190| 13.7M| TString *ts; 191| 13.7M| global_State *g = G(L); ------------------ | | 335| 13.7M|#define G(L) (L->l_G) ------------------ 192| 13.7M| stringtable *tb = &g->strt; 193| 13.7M| unsigned int h = luaS_hash(str, l, g->seed); 194| 13.7M| TString **list = &tb->hash[lmod(h, tb->size)]; ------------------ | | 787| 13.7M| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 115| 13.7M|#define check_exp(c,e) (e) | | ------------------ ------------------ 195| 13.7M| lua_assert(str != NULL); /* otherwise 'memcmp'/'memcpy' are undefined */ ------------------ | | 114| 13.7M|#define lua_assert(c) ((void)0) ------------------ 196| 18.4M| for (ts = *list; ts != NULL; ts = ts->u.hnext) { ------------------ | Branch (196:20): [True: 18.3M, False: 62.1k] ------------------ 197| 18.3M| if (l == ts->shrlen && (memcmp(str, getshrstr(ts), l * sizeof(char)) == 0)) { ------------------ | | 406| 13.8M|#define getshrstr(ts) check_exp((ts)->shrlen != 0xFF, (ts)->contents) | | ------------------ | | | | 115| 13.8M|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (197:9): [True: 13.8M, False: 4.51M] | Branch (197:28): [True: 13.6M, False: 169k] ------------------ 198| | /* found! */ 199| 13.6M| if (isdead(g, ts)) /* dead (but not collected yet)? */ ------------------ | | 96| 13.6M|#define isdead(g,v) isdeadm(otherwhite(g), (v)->marked) | | ------------------ | | | | 95| 13.6M|#define isdeadm(ow,m) ((m) & (ow)) | | | | ------------------ | | | | | Branch (95:23): [True: 0, False: 13.6M] | | | | ------------------ | | ------------------ ------------------ 200| 0| changewhite(ts); /* resurrect it */ ------------------ | | 98| 0|#define changewhite(x) ((x)->marked ^= WHITEBITS) | | ------------------ | | | | 84| 0|#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) | | | | ------------------ | | | | | | 64| 0|#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 0|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | | | #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 0|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 201| 13.6M| return ts; 202| 13.6M| } 203| 18.3M| } 204| | /* else must create a new string */ 205| 62.1k| if (tb->nuse >= tb->size) { /* need to grow string table? */ ------------------ | Branch (205:7): [True: 146, False: 61.9k] ------------------ 206| 146| growstrtab(L, tb); 207| 146| list = &tb->hash[lmod(h, tb->size)]; /* rehash with new size */ ------------------ | | 787| 146| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 115| 146|#define check_exp(c,e) (e) | | ------------------ ------------------ 208| 146| } 209| 62.1k| ts = createstrobj(L, l, LUA_VSHRSTR, h); ------------------ | | 360| 62.1k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 62.1k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 210| 62.1k| ts->shrlen = cast_byte(l); ------------------ | | 143| 62.1k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 62.1k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 211| 62.1k| memcpy(getshrstr(ts), str, l * sizeof(char)); ------------------ | | 406| 62.1k|#define getshrstr(ts) check_exp((ts)->shrlen != 0xFF, (ts)->contents) | | ------------------ | | | | 115| 62.1k|#define check_exp(c,e) (e) | | ------------------ ------------------ 212| 62.1k| ts->u.hnext = *list; 213| 62.1k| *list = ts; 214| 62.1k| tb->nuse++; 215| 62.1k| return ts; 216| 13.7M|} lstring.c:growstrtab: 175| 146|static void growstrtab (lua_State *L, stringtable *tb) { 176| 146| if (l_unlikely(tb->nuse == MAX_INT)) { /* too many strings? */ ------------------ | | 697| 146|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 146|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 146] | | | | ------------------ | | ------------------ ------------------ 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| 146| if (tb->size <= MAXSTRTB / 2) /* can grow string table? */ ------------------ | | 28| 146|#define MAXSTRTB cast_int(luaM_limitN(MAX_INT, TString*)) | | ------------------ | | | | 141| 146|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 292|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (136:27): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (181:7): [True: 146, False: 0] ------------------ 182| 146| luaS_resize(L, tb->size * 2); 183| 146|} luaH_realasize: 250| 44.1k|LUAI_FUNC unsigned int luaH_realasize (const Table *t) { 251| 44.1k| if (limitequalsasize(t)) ------------------ | | 244| 44.1k|#define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 732| 88.2k|#define isrealasize(t) (!((t)->flags & BITRAS)) | | | | ------------------ | | | | | | 731| 44.1k|#define BITRAS (1 << 7) | | | | ------------------ | | | | | Branch (732:25): [True: 44.1k, False: 0] | | | | ------------------ | | ------------------ | | #define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 66| 0|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | | | ------------------ | | | | | Branch (66:19): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 252| 44.1k| return t->alimit; /* this is the size */ 253| 0| else { 254| 0| unsigned int size = t->alimit; 255| | /* compute the smallest power of 2 not smaller than 'n' */ 256| 0| size |= (size >> 1); 257| 0| size |= (size >> 2); 258| 0| size |= (size >> 4); 259| 0| size |= (size >> 8); 260| 0|#if (UINT_MAX >> 14) > 3 /* unsigned int has more than 16 bits */ 261| 0| size |= (size >> 16); 262| |#if (UINT_MAX >> 30) > 3 263| | size |= (size >> 32); /* unsigned int has more than 32 bits */ 264| |#endif 265| 0|#endif 266| 0| size++; 267| 0| lua_assert(ispow2(size) && size/2 < t->alimit && t->alimit < size); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 268| 0| return size; 269| 0| } 270| 44.1k|} luaH_resize: 554| 19.2k| unsigned int nhsize) { 555| 19.2k| unsigned int i; 556| 19.2k| Table newt; /* to keep the new hash part */ 557| 19.2k| unsigned int oldasize = setlimittosize(t); 558| 19.2k| TValue *newarray; 559| | /* create new hash part with appropriate size into 'newt' */ 560| 19.2k| setnodevector(L, &newt, nhsize); 561| 19.2k| if (newasize < oldasize) { /* will array shrink? */ ------------------ | Branch (561:7): [True: 6, False: 19.2k] ------------------ 562| 6| t->alimit = newasize; /* pretend array has new size... */ 563| 6| exchangehashpart(t, &newt); /* and new hash */ 564| | /* re-insert into the new hash the elements from vanishing slice */ 565| 12| for (i = newasize; i < oldasize; i++) { ------------------ | Branch (565:24): [True: 6, False: 6] ------------------ 566| 6| if (!isempty(&t->array[i])) ------------------ | | 217| 6|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 6|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 6|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 6|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 6|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (566:11): [True: 0, False: 6] ------------------ 567| 0| luaH_setint(L, t, i + 1, &t->array[i]); 568| 6| } 569| 6| t->alimit = oldasize; /* restore current size... */ 570| 6| exchangehashpart(t, &newt); /* and hash (in case of errors) */ 571| 6| } 572| | /* allocate new array */ 573| 19.2k| newarray = luaM_reallocvector(L, t->array, oldasize, newasize, TValue); ------------------ | | 71| 19.2k| (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \ | | ------------------ | | | | 136| 19.2k|#define cast(t, exp) ((t)(exp)) | | ------------------ | | 72| 19.2k| cast_sizet(n) * sizeof(t)))) ------------------ 574| 19.2k| if (l_unlikely(newarray == NULL && newasize > 0)) { /* allocation failed? */ ------------------ | | 697| 19.2k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 21.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 19.2k] | | | | | Branch (685:46): [True: 2.19k, False: 17.0k] | | | | | Branch (685:46): [True: 0, False: 2.19k] | | | | ------------------ | | ------------------ ------------------ 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| 19.2k| exchangehashpart(t, &newt); /* 't' has the new hash ('newt' has the old) */ 580| 19.2k| t->array = newarray; /* set new array part */ 581| 19.2k| t->alimit = newasize; 582| 190k| for (i = oldasize; i < newasize; i++) /* clear new slice of the array */ ------------------ | Branch (582:22): [True: 171k, False: 19.2k] ------------------ 583| 171k| setempty(&t->array[i]); ------------------ | | 225| 171k|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 190k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 584| | /* re-insert elements from old hash part into new parts */ 585| 19.2k| reinsert(L, &newt, t); /* 'newt' now has the old hash */ 586| 19.2k| freehash(L, &newt); /* free old hash part */ 587| 19.2k|} luaH_resizearray: 590| 8.00k|void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize) { 591| 8.00k| int nsize = allocsizenode(t); ------------------ | | 31| 8.00k|#define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 27| 8.00k|#define isdummy(t) ((t)->lastfree == NULL) | | | | ------------------ | | | | | Branch (27:21): [True: 8.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| 8.00k| luaH_resize(L, t, nasize, nsize); 593| 8.00k|} luaH_new: 626| 9.19k|Table *luaH_new (lua_State *L) { 627| 9.19k| GCObject *o = luaC_newobj(L, LUA_VTABLE, sizeof(Table)); ------------------ | | 678| 9.19k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 9.19k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 628| 9.19k| Table *t = gco2t(o); ------------------ | | 380| 9.19k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 9.19k|#define check_exp(c,e) (e) | | ------------------ ------------------ 629| 9.19k| t->metatable = NULL; 630| 9.19k| t->flags = cast_byte(maskflags); /* table has no metamethod fields */ ------------------ | | 143| 9.19k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 9.19k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 631| 9.19k| t->array = NULL; 632| 9.19k| t->alimit = 0; 633| 9.19k| setnodevector(L, t, 0); 634| 9.19k| return t; 635| 9.19k|} luaH_free: 638| 9.19k|void luaH_free (lua_State *L, Table *t) { 639| 9.19k| freehash(L, t); 640| 9.19k| luaM_freearray(L, t->array, luaH_realasize(t)); ------------------ | | 57| 9.19k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 641| 9.19k| luaM_free(L, t); ------------------ | | 56| 9.19k|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 642| 9.19k|} luaH_getint: 731| 1.32M|const TValue *luaH_getint (Table *t, lua_Integer key) { 732| 1.32M| if (l_castS2U(key) - 1u < t->alimit) /* 'key' in [1, t->alimit]? */ ------------------ | | 152| 1.32M|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (732:7): [True: 26.3k, False: 1.29M] ------------------ 733| 26.3k| return &t->array[key - 1]; 734| 1.29M| else if (!limitequalsasize(t) && /* key still may be in the array part? */ ------------------ | | 244| 2.59M|#define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 732| 2.59M|#define isrealasize(t) (!((t)->flags & BITRAS)) | | | | ------------------ | | | | | | 731| 1.29M|#define BITRAS (1 << 7) | | | | ------------------ | | | | | Branch (732:25): [True: 1.29M, False: 0] | | | | ------------------ | | ------------------ | | #define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 66| 0|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | | | ------------------ | | | | | Branch (66:19): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 735| 1.29M| (l_castS2U(key) == t->alimit + 1 || ------------------ | | 152| 0|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (735:13): [True: 0, False: 0] ------------------ 736| 0| l_castS2U(key) - 1u < luaH_realasize(t))) { ------------------ | | 152| 0|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (736:13): [True: 0, False: 0] ------------------ 737| 0| t->alimit = cast_uint(key); /* probably '#t' is here now */ ------------------ | | 142| 0|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 738| 0| return &t->array[key - 1]; 739| 0| } 740| 1.29M| else { 741| 1.29M| Node *n = hashint(t, key); 742| 2.99M| for (;;) { /* check whether 'key' is somewhere in the chain */ 743| 2.99M| if (keyisinteger(n) && keyival(n) == key) ------------------ | | 757| 5.99M|#define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 753| 2.99M|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 323| 2.99M|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | | | ------------------ | | | | | | 42| 2.99M|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (757:28): [True: 2.77M, False: 225k] | | ------------------ ------------------ if (keyisinteger(n) && keyival(n) == key) ------------------ | | 758| 2.77M|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 754| 2.77M|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ | Branch (743:30): [True: 811k, False: 1.95M] ------------------ 744| 811k| return gval(n); /* that's it */ ------------------ | | 14| 811k|#define gval(n) (&(n)->i_val) ------------------ 745| 2.18M| else { 746| 2.18M| int nx = gnext(n); ------------------ | | 15| 2.18M|#define gnext(n) ((n)->u.next) ------------------ 747| 2.18M| if (nx == 0) break; ------------------ | Branch (747:13): [True: 484k, False: 1.70M] ------------------ 748| 1.70M| n += nx; 749| 1.70M| } 750| 2.99M| } 751| 484k| return &absentkey; 752| 1.29M| } 753| 1.32M|} luaH_getshortstr: 759| 29.0M|const TValue *luaH_getshortstr (Table *t, TString *key) { 760| 29.0M| Node *n = hashstr(t, key); ------------------ | | 84| 29.0M|#define hashstr(t,str) hashpow2(t, (str)->hash) | | ------------------ | | | | 75| 29.0M|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 29.0M|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 761| 29.0M| lua_assert(key->tt == LUA_VSHRSTR); ------------------ | | 114| 29.0M|#define lua_assert(c) ((void)0) ------------------ 762| 36.7M| for (;;) { /* check whether 'key' is somewhere in the chain */ 763| 36.7M| if (keyisshrstr(n) && eqshrstr(keystrval(n), key)) ------------------ | | 759| 73.5M|#define keyisshrstr(node) (keytt(node) == ctb(LUA_VSHRSTR)) | | ------------------ | | | | 753| 36.7M|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisshrstr(node) (keytt(node) == ctb(LUA_VSHRSTR)) | | ------------------ | | | | 303| 36.7M|#define ctb(t) ((t) | BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 36.7M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | ------------------ | | | Branch (759:27): [True: 33.6M, False: 3.13M] | | ------------------ ------------------ if (keyisshrstr(n) && eqshrstr(keystrval(n), key)) ------------------ | | 41| 33.6M|#define eqshrstr(a,b) check_exp((a)->tt == LUA_VSHRSTR, (a) == (b)) | | ------------------ | | | | 115| 33.6M|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:25): [True: 27.4M, False: 6.22M] | | | | ------------------ | | ------------------ ------------------ 764| 27.4M| return gval(n); /* that's it */ ------------------ | | 14| 27.4M|#define gval(n) (&(n)->i_val) ------------------ 765| 9.36M| else { 766| 9.36M| int nx = gnext(n); ------------------ | | 15| 9.36M|#define gnext(n) ((n)->u.next) ------------------ 767| 9.36M| if (nx == 0) ------------------ | Branch (767:11): [True: 1.61M, False: 7.74M] ------------------ 768| 1.61M| return &absentkey; /* not found */ 769| 7.74M| n += nx; 770| 7.74M| } 771| 36.7M| } 772| 29.0M|} luaH_getstr: 775| 13.5M|const TValue *luaH_getstr (Table *t, TString *key) { 776| 13.5M| if (key->tt == LUA_VSHRSTR) ------------------ | | 360| 13.5M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 13.5M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (776:7): [True: 13.5M, False: 29.7k] ------------------ 777| 13.5M| return luaH_getshortstr(t, key); 778| 29.7k| else { /* for long strings, use generic case */ 779| 29.7k| TValue ko; 780| 29.7k| setsvalue(cast(lua_State *, NULL), &ko, key); ------------------ | | 372| 29.7k| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 29.7k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 29.7k|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 29.7k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 29.7k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 29.7k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 29.7k| checkliveness(L,io); } | | ------------------ | | | | 107| 29.7k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 29.7k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 29.7k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 781| 29.7k| return getgeneric(t, &ko, 0); 782| 29.7k| } 783| 13.5M|} luaH_get: 789| 13.4M|const TValue *luaH_get (Table *t, const TValue *key) { 790| 13.4M| switch (ttypetag(key)) { ------------------ | | 84| 13.4M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 13.4M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 791| 13.2M| case LUA_VSHRSTR: return luaH_getshortstr(t, tsvalue(key)); ------------------ | | 360| 13.2M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 13.2M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VSHRSTR: return luaH_getshortstr(t, tsvalue(key)); ------------------ | | 369| 13.2M|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 13.2M|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (791:5): [True: 13.2M, False: 226k] ------------------ 792| 92.6k| case LUA_VNUMINT: return luaH_getint(t, ivalue(key)); ------------------ | | 323| 92.6k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 92.6k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNUMINT: return luaH_getint(t, ivalue(key)); ------------------ | | 333| 92.6k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 92.6k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (792:5): [True: 92.6k, False: 13.3M] ------------------ 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: 13.4M] ------------------ 794| 82.0k| case LUA_VNUMFLT: { ------------------ | | 324| 82.0k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 82.0k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (794:5): [True: 82.0k, False: 13.3M] ------------------ 795| 82.0k| lua_Integer k; 796| 82.0k| if (luaV_flttointeger(fltvalue(key), &k, F2Ieq)) /* integral index? */ ------------------ | | 332| 82.0k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 82.0k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (796:11): [True: 3.27k, False: 78.7k] ------------------ 797| 3.27k| return luaH_getint(t, k); /* use specialized version */ 798| | /* else... */ 799| 82.0k| } /* FALLTHROUGH */ 800| 130k| default: ------------------ | Branch (800:5): [True: 51.8k, False: 13.4M] ------------------ 801| 130k| return getgeneric(t, key, 0); 802| 13.4M| } 803| 13.4M|} luaH_finishset: 813| 437k| const TValue *slot, TValue *value) { 814| 437k| if (isabstkey(slot)) ------------------ | | 203| 437k|#define isabstkey(v) checktag((v), LUA_VABSTKEY) | | ------------------ | | | | 91| 437k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 437k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 334k, False: 102k] | | | | ------------------ | | ------------------ ------------------ 815| 334k| luaH_newkey(L, t, key, value); 816| 102k| else 817| 102k| setobj2t(L, cast(TValue *, slot), value); ------------------ | | 137| 102k|#define setobj2t setobj | | ------------------ | | | | 119| 102k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 102k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 102k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 102k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 102k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 102k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 102k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 102k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 818| 437k|} luaH_set: 825| 78.6k|void luaH_set (lua_State *L, Table *t, const TValue *key, TValue *value) { 826| 78.6k| const TValue *slot = luaH_get(t, key); 827| 78.6k| luaH_finishset(L, t, key, slot, value); 828| 78.6k|} luaH_getn: 924| 18.8k|lua_Unsigned luaH_getn (Table *t) { 925| 18.8k| unsigned int limit = t->alimit; 926| 18.8k| if (limit > 0 && isempty(&t->array[limit - 1])) { /* (1)? */ ------------------ | | 217| 15.8k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 15.8k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 15.8k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 15.8k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 15.8k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 15.8k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (926:7): [True: 15.8k, False: 2.98k] ------------------ 927| | /* there must be a boundary before 'limit' */ 928| 0| if (limit >= 2 && !isempty(&t->array[limit - 2])) { ------------------ | | 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 (928:9): [True: 0, False: 0] | Branch (928:23): [True: 0, False: 0] ------------------ 929| | /* 'limit - 1' is a boundary; can it be a new limit? */ 930| 0| if (ispow2realasize(t) && !ispow2(limit - 1)) { ------------------ | | 66| 0|#define ispow2(x) (((x) & ((x) - 1)) == 0) ------------------ | Branch (930:11): [True: 0, False: 0] | Branch (930:33): [True: 0, False: 0] ------------------ 931| 0| t->alimit = limit - 1; 932| 0| setnorealasize(t); /* now 'alimit' is not the real size */ ------------------ | | 734| 0|#define setnorealasize(t) ((t)->flags |= BITRAS) | | ------------------ | | | | 731| 0|#define BITRAS (1 << 7) | | ------------------ ------------------ 933| 0| } 934| 0| return limit - 1; 935| 0| } 936| 0| else { /* must search for a boundary in [0, limit] */ 937| 0| unsigned int boundary = binsearch(t->array, 0, limit); 938| | /* can this boundary represent the real size of the array? */ 939| 0| if (ispow2realasize(t) && boundary > luaH_realasize(t) / 2) { ------------------ | Branch (939:11): [True: 0, False: 0] | Branch (939:33): [True: 0, False: 0] ------------------ 940| 0| t->alimit = boundary; /* use it as the new limit */ 941| 0| setnorealasize(t); ------------------ | | 734| 0|#define setnorealasize(t) ((t)->flags |= BITRAS) | | ------------------ | | | | 731| 0|#define BITRAS (1 << 7) | | ------------------ ------------------ 942| 0| } 943| 0| return boundary; 944| 0| } 945| 0| } 946| | /* 'limit' is zero or present in table */ 947| 18.8k| if (!limitequalsasize(t)) { /* (2)? */ ------------------ | | 244| 18.8k|#define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 732| 37.6k|#define isrealasize(t) (!((t)->flags & BITRAS)) | | | | ------------------ | | | | | | 731| 18.8k|#define BITRAS (1 << 7) | | | | ------------------ | | | | | Branch (732:25): [True: 18.8k, False: 0] | | | | ------------------ | | ------------------ | | #define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 66| 0|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | | | ------------------ | | | | | Branch (66:19): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 948| | /* 'limit' > 0 and array has more elements after 'limit' */ 949| 0| if (isempty(&t->array[limit])) /* 'limit + 1' is 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 950| 0| return limit; /* this is the boundary */ 951| | /* else, try last element in the array */ 952| 0| limit = luaH_realasize(t); 953| 0| if (isempty(&t->array[limit - 1])) { /* 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 954| | /* there must be a boundary in the array after old limit, 955| | and it must be a valid new limit */ 956| 0| unsigned int boundary = binsearch(t->array, t->alimit, limit); 957| 0| t->alimit = boundary; 958| 0| return boundary; 959| 0| } 960| | /* else, new limit is present in the table; check the hash part */ 961| 0| } 962| | /* (3) 'limit' is the last element and either is zero or present in table */ 963| 18.8k| lua_assert(limit == luaH_realasize(t) && ------------------ | | 114| 18.8k|#define lua_assert(c) ((void)0) ------------------ 964| 18.8k| (limit == 0 || !isempty(&t->array[limit - 1]))); 965| 18.8k| if (isdummy(t) || isempty(luaH_getint(t, cast(lua_Integer, limit + 1)))) ------------------ | | 27| 37.6k|#define isdummy(t) ((t)->lastfree == NULL) | | ------------------ | | | Branch (27:21): [True: 8.01k, False: 10.8k] | | ------------------ ------------------ if (isdummy(t) || isempty(luaH_getint(t, cast(lua_Integer, limit + 1)))) ------------------ | | 217| 10.8k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 10.8k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 10.8k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 10.8k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 10.8k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 1.16k, False: 9.64k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 966| 9.17k| return limit; /* 'limit + 1' is absent */ 967| 9.64k| else /* 'limit + 1' is also present */ 968| 9.64k| return hash_search(t, limit); 969| 18.8k|} ltable.c:arrayindex: 318| 31.2k|static unsigned int arrayindex (lua_Integer k) { 319| 31.2k| if (l_castS2U(k) - 1u < MAXASIZE) /* 'k' in [1, MAXASIZE]? */ ------------------ | | 152| 31.2k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ if (l_castS2U(k) - 1u < MAXASIZE) /* 'k' in [1, MAXASIZE]? */ ------------------ | | 54| 31.2k|#define MAXASIZE luaM_limitN(1u << MAXABITS, TValue) | | ------------------ | | | | 45| 31.2k| ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 147| 31.2k|#define cast_sizet(i) cast(size_t, (i)) | | | | | | ------------------ | | | | | | | | 136| 31.2k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 41| 31.2k|#define MAX_SIZET ((size_t)(~(size_t)0)) | | | | ------------------ | | | | | Branch (45:4): [Folded - Ignored] | | | | ------------------ | | | | 46| 31.2k| 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: 18.8k, False: 12.3k] ------------------ 320| 18.8k| return cast_uint(k); /* 'key' is an appropriate array index */ ------------------ | | 142| 18.8k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 18.8k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 321| 12.3k| else 322| 12.3k| return 0; 323| 31.2k|} ltable.c:setlimittosize: 283| 22.0k|static unsigned int setlimittosize (Table *t) { 284| 22.0k| t->alimit = luaH_realasize(t); 285| 22.0k| setrealasize(t); ------------------ | | 733| 22.0k|#define setrealasize(t) ((t)->flags &= cast_byte(~BITRAS)) | | ------------------ | | | | 143| 22.0k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 22.0k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 286| 22.0k| return t->alimit; 287| 22.0k|} ltable.c:setnodevector: 480| 28.4k|static void setnodevector (lua_State *L, Table *t, unsigned int size) { 481| 28.4k| if (size == 0) { /* no elements to hash part? */ ------------------ | Branch (481:7): [True: 25.6k, False: 2.83k] ------------------ 482| 25.6k| t->node = cast(Node *, dummynode); /* use common 'dummynode' */ ------------------ | | 136| 25.6k|#define cast(t, exp) ((t)(exp)) ------------------ 483| 25.6k| t->lsizenode = 0; 484| 25.6k| t->lastfree = NULL; /* signal that it is using dummy node */ 485| 25.6k| } 486| 2.83k| else { 487| 2.83k| int i; 488| 2.83k| int lsize = luaO_ceillog2(size); 489| 2.83k| if (lsize > MAXHBITS || (1u << lsize) > MAXHSIZE) ------------------ | | 60| 5.66k|#define MAXHBITS (MAXABITS - 1) | | ------------------ | | | | 46| 2.83k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | | | ------------------ | | | | | | 141| 2.83k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 2.83k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (lsize > MAXHBITS || (1u << lsize) > MAXHSIZE) ------------------ | | 68| 2.83k|#define MAXHSIZE luaM_limitN(1u << MAXHBITS, Node) | | ------------------ | | | | 45| 2.83k| ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 147| 2.83k|#define cast_sizet(i) cast(size_t, (i)) | | | | | | ------------------ | | | | | | | | 136| 2.83k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 41| 2.83k|#define MAX_SIZET ((size_t)(~(size_t)0)) | | | | ------------------ | | | | | Branch (45:4): [Folded - Ignored] | | | | ------------------ | | | | 46| 2.83k| 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: 2.83k] | Branch (489:29): [True: 0, False: 2.83k] ------------------ 490| 0| luaG_runerror(L, "table overflow"); 491| 2.83k| size = twoto(lsize); ------------------ | | 790| 2.83k|#define twoto(x) (1<<(x)) ------------------ 492| 2.83k| t->node = luaM_newvector(L, size, Node); ------------------ | | 60| 2.83k|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 136| 2.83k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 493| 128k| for (i = 0; i < cast_int(size); i++) { ------------------ | | 141| 128k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 128k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (493:17): [True: 125k, False: 2.83k] ------------------ 494| 125k| Node *n = gnode(t, i); ------------------ | | 13| 125k|#define gnode(t,i) (&(t)->node[i]) ------------------ 495| 125k| gnext(n) = 0; ------------------ | | 15| 125k|#define gnext(n) ((n)->u.next) ------------------ 496| 125k| setnilkey(n); ------------------ | | 762| 125k|#define setnilkey(node) (keytt(node) = LUA_TNIL) | | ------------------ | | | | 753| 125k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define setnilkey(node) (keytt(node) = LUA_TNIL) | | ------------------ | | | | 64| 125k|#define LUA_TNIL 0 | | ------------------ ------------------ 497| 125k| setempty(gval(n)); ------------------ | | 225| 125k|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 125k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 498| 125k| } 499| 2.83k| t->lsizenode = cast_byte(lsize); ------------------ | | 143| 2.83k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 2.83k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 500| 2.83k| t->lastfree = gnode(t, size); /* all positions are free */ ------------------ | | 13| 2.83k|#define gnode(t,i) (&(t)->node[i]) ------------------ 501| 2.83k| } 502| 28.4k|} ltable.c:exchangehashpart: 527| 19.2k|static void exchangehashpart (Table *t1, Table *t2) { 528| 19.2k| lu_byte lsizenode = t1->lsizenode; 529| 19.2k| Node *node = t1->node; 530| 19.2k| Node *lastfree = t1->lastfree; 531| 19.2k| t1->lsizenode = t2->lsizenode; 532| 19.2k| t1->node = t2->node; 533| 19.2k| t1->lastfree = t2->lastfree; 534| 19.2k| t2->lsizenode = lsizenode; 535| 19.2k| t2->node = node; 536| 19.2k| t2->lastfree = lastfree; 537| 19.2k|} ltable.c:freehash: 371| 28.4k|static void freehash (lua_State *L, Table *t) { 372| 28.4k| if (!isdummy(t)) ------------------ | | 27| 28.4k|#define isdummy(t) ((t)->lastfree == NULL) ------------------ | Branch (372:7): [True: 2.83k, False: 25.6k] ------------------ 373| 2.83k| luaM_freearray(L, t->node, cast_sizet(sizenode(t))); ------------------ | | 57| 2.83k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 374| 28.4k|} ltable.c:reinsert: 508| 19.2k|static void reinsert (lua_State *L, Table *ot, Table *t) { 509| 19.2k| int j; 510| 19.2k| int size = sizenode(ot); ------------------ | | 791| 19.2k|#define sizenode(t) (twoto((t)->lsizenode)) | | ------------------ | | | | 790| 19.2k|#define twoto(x) (1<<(x)) | | ------------------ ------------------ 511| 111k| for (j = 0; j < size; j++) { ------------------ | Branch (511:15): [True: 92.6k, False: 19.2k] ------------------ 512| 92.6k| Node *old = gnode(ot, j); ------------------ | | 13| 92.6k|#define gnode(t,i) (&(t)->node[i]) ------------------ 513| 92.6k| if (!isempty(gval(old))) { ------------------ | | 217| 92.6k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 92.6k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 92.6k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 92.6k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 92.6k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (513:9): [True: 75.8k, False: 16.8k] ------------------ 514| | /* doesn't need barrier/invalidate cache, as entry was 515| | already present in the table */ 516| 75.8k| TValue k; 517| 75.8k| getnodekey(L, &k, old); ------------------ | | 719| 75.8k| { TValue *io_=(obj); const Node *n_=(node); \ | | 720| 75.8k| io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \ | | 721| 75.8k| checkliveness(L,io_); } | | ------------------ | | | | 107| 75.8k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 75.8k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 75.8k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 518| 75.8k| luaH_set(L, t, &k, gval(old)); ------------------ | | 14| 75.8k|#define gval(n) (&(n)->i_val) ------------------ 519| 75.8k| } 520| 92.6k| } 521| 19.2k|} ltable.c:hashint: 108| 1.35M|static Node *hashint (const Table *t, lua_Integer i) { 109| 1.35M| lua_Unsigned ui = l_castS2U(i); ------------------ | | 152| 1.35M|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 110| 1.35M| if (ui <= cast_uint(INT_MAX)) ------------------ | | 142| 1.35M|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 1.35M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (110:7): [True: 492k, False: 859k] ------------------ 111| 492k| return hashmod(t, cast_int(ui)); ------------------ | | 81| 492k|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | ------------------ | | | | 13| 492k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 112| 859k| else 113| 859k| return hashmod(t, ui); ------------------ | | 81| 859k|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | ------------------ | | | | 13| 859k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 114| 1.35M|} ltable.c:getgeneric: 299| 160k|static const TValue *getgeneric (Table *t, const TValue *key, int deadok) { 300| 160k| Node *n = mainpositionTV(t, key); 301| 211k| for (;;) { /* check whether 'key' is somewhere in the chain */ 302| 211k| if (equalkey(key, n, deadok)) ------------------ | Branch (302:9): [True: 138k, False: 72.6k] ------------------ 303| 138k| return gval(n); /* that's it */ ------------------ | | 14| 138k|#define gval(n) (&(n)->i_val) ------------------ 304| 72.6k| else { 305| 72.6k| int nx = gnext(n); ------------------ | | 15| 72.6k|#define gnext(n) ((n)->u.next) ------------------ 306| 72.6k| if (nx == 0) ------------------ | Branch (306:11): [True: 21.5k, False: 51.0k] ------------------ 307| 21.5k| return &absentkey; /* not found */ 308| 51.0k| n += nx; 309| 51.0k| } 310| 211k| } 311| 160k|} ltable.c:mainpositionTV: 151| 316k|static Node *mainpositionTV (const Table *t, const TValue *key) { 152| 316k| switch (ttypetag(key)) { ------------------ | | 84| 316k|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 316k|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 153| 55.2k| case LUA_VNUMINT: { ------------------ | | 323| 55.2k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 55.2k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (153:5): [True: 55.2k, False: 261k] ------------------ 154| 55.2k| lua_Integer i = ivalue(key); ------------------ | | 333| 55.2k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 55.2k|#define check_exp(c,e) (e) | | ------------------ ------------------ 155| 55.2k| return hashint(t, i); 156| 0| } 157| 89.8k| case LUA_VNUMFLT: { ------------------ | | 324| 89.8k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 89.8k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (157:5): [True: 89.8k, False: 226k] ------------------ 158| 89.8k| lua_Number n = fltvalue(key); ------------------ | | 332| 89.8k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 89.8k|#define check_exp(c,e) (e) | | ------------------ ------------------ 159| 89.8k| return hashmod(t, l_hashfloat(n)); ------------------ | | 81| 89.8k|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | ------------------ | | | | 13| 89.8k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 160| 0| } 161| 85.0k| case LUA_VSHRSTR: { ------------------ | | 360| 85.0k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 85.0k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (161:5): [True: 85.0k, False: 231k] ------------------ 162| 85.0k| TString *ts = tsvalue(key); ------------------ | | 369| 85.0k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 85.0k|#define check_exp(c,e) (e) | | ------------------ ------------------ 163| 85.0k| return hashstr(t, ts); ------------------ | | 84| 85.0k|#define hashstr(t,str) hashpow2(t, (str)->hash) | | ------------------ | | | | 75| 85.0k|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 85.0k|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 164| 0| } 165| 73.4k| case LUA_VLNGSTR: { ------------------ | | 361| 73.4k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 73.4k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (165:5): [True: 73.4k, False: 243k] ------------------ 166| 73.4k| TString *ts = tsvalue(key); ------------------ | | 369| 73.4k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 73.4k|#define check_exp(c,e) (e) | | ------------------ ------------------ 167| 73.4k| return hashpow2(t, luaS_hashlongstr(ts)); ------------------ | | 75| 73.4k|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | ------------------ | | | | 13| 73.4k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 168| 0| } 169| 10.4k| case LUA_VFALSE: ------------------ | | 239| 10.4k|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 10.4k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (169:5): [True: 10.4k, False: 306k] ------------------ 170| 10.4k| return hashboolean(t, 0); ------------------ | | 85| 10.4k|#define hashboolean(t,p) hashpow2(t, p) | | ------------------ | | | | 75| 10.4k|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 10.4k|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 171| 1.41k| case LUA_VTRUE: ------------------ | | 240| 1.41k|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 1.41k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (171:5): [True: 1.41k, False: 315k] ------------------ 172| 1.41k| return hashboolean(t, 1); ------------------ | | 85| 1.41k|#define hashboolean(t,p) hashpow2(t, p) | | ------------------ | | | | 75| 1.41k|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 1.41k|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 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: 316k] ------------------ 174| 0| void *p = pvalue(key); ------------------ | | 434| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 175| 0| return hashpointer(t, p); ------------------ | | 88| 0|#define hashpointer(t,p) hashmod(t, point2uint(p)) | | ------------------ | | | | 81| 0|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | | | ------------------ | | | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 176| 0| } 177| 0| case LUA_VLCF: { ------------------ | | 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: 316k] ------------------ 178| 0| lua_CFunction f = fvalue(key); ------------------ | | 603| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 179| 0| return hashpointer(t, f); ------------------ | | 88| 0|#define hashpointer(t,p) hashmod(t, point2uint(p)) | | ------------------ | | | | 81| 0|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | | | ------------------ | | | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 180| 0| } 181| 1.26k| default: { ------------------ | Branch (181:5): [True: 1.26k, False: 315k] ------------------ 182| 1.26k| GCObject *o = gcvalue(key); ------------------ | | 305| 1.26k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 1.26k|#define check_exp(c,e) (e) | | ------------------ ------------------ 183| 1.26k| return hashpointer(t, o); ------------------ | | 88| 1.26k|#define hashpointer(t,p) hashmod(t, point2uint(p)) | | ------------------ | | | | 81| 1.26k|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | | | ------------------ | | | | | | 13| 1.26k|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 184| 0| } 185| 316k| } 186| 316k|} ltable.c:l_hashfloat: 131| 89.8k|static int l_hashfloat (lua_Number n) { 132| 89.8k| int i; 133| 89.8k| lua_Integer ni; 134| 89.8k| n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN); ------------------ | | 482| 89.8k|#define l_mathop(op) op ------------------ n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN); ------------------ | | 140| 89.8k|#define cast_num(i) cast(lua_Number, (i)) | | ------------------ | | | | 136| 89.8k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 135| 89.8k| if (!lua_numbertointeger(n, &ni)) { /* is 'n' inf/-inf/NaN? */ ------------------ | | 433| 89.8k| ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 555| 89.8k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (433:4): [True: 89.6k, False: 290] | | ------------------ | | 434| 89.8k| (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 555| 89.6k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (434:4): [True: 87.3k, False: 2.20k] | | ------------------ | | 435| 89.8k| (*(p) = (LUA_INTEGER)(n), 1)) | | ------------------ | | | Branch (435:7): [True: 87.3k, False: 0] | | ------------------ ------------------ 136| 2.49k| lua_assert(luai_numisnan(n) || l_mathop(fabs)(n) == cast_num(HUGE_VAL)); ------------------ | | 114| 2.49k|#define lua_assert(c) ((void)0) ------------------ 137| 2.49k| return 0; 138| 2.49k| } 139| 87.3k| else { /* normal case */ 140| 87.3k| unsigned int u = cast_uint(i) + cast_uint(ni); ------------------ | | 142| 87.3k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 87.3k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ unsigned int u = cast_uint(i) + cast_uint(ni); ------------------ | | 142| 87.3k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 87.3k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 141| 87.3k| return cast_int(u <= cast_uint(INT_MAX) ? u : ~u); ------------------ | | 141| 87.3k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 174k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 83.3k, False: 4.02k] | | | | ------------------ | | ------------------ ------------------ 142| 87.3k| } 143| 89.8k|} ltable.c:equalkey: 216| 211k|static int equalkey (const TValue *k1, const Node *n2, int deadok) { 217| 211k| if ((rawtt(k1) != keytt(n2)) && /* not the same variants? */ ------------------ | | 77| 211k|#define rawtt(o) ((o)->tt_) ------------------ if ((rawtt(k1) != keytt(n2)) && /* not the same variants? */ ------------------ | | 753| 211k|#define keytt(node) ((node)->u.key_tt) ------------------ | Branch (217:7): [True: 58.1k, False: 153k] ------------------ 218| 211k| !(deadok && keyisdead(n2) && iscollectable(k1))) ------------------ | | 777| 58.1k|#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: 58.1k] ------------------ 219| 58.1k| return 0; /* cannot be same key */ 220| 153k| switch (keytt(n2)) { ------------------ | | 753| 153k|#define keytt(node) ((node)->u.key_tt) ------------------ 221| 8.65k| 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| 7.77k|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 7.77k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: ------------------ | | 240| 8.65k|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 8.65k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (221:5): [True: 0, False: 153k] | Branch (221:20): [True: 7.77k, False: 145k] | Branch (221:37): [True: 881, False: 152k] ------------------ 222| 8.65k| 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: 153k] ------------------ 224| 0| return (ivalue(k1) == keyival(n2)); ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ return (ivalue(k1) == keyival(n2)); ------------------ | | 758| 0|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 754| 0|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ 225| 77.1k| case LUA_VNUMFLT: ------------------ | | 324| 77.1k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 77.1k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (225:5): [True: 77.1k, False: 76.2k] ------------------ 226| 77.1k| return luai_numeq(fltvalue(k1), fltvalueraw(keyval(n2))); ------------------ | | 350| 77.1k|#define luai_numeq(a,b) ((a)==(b)) ------------------ 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: 153k] ------------------ 228| 0| return pvalue(k1) == pvalueraw(keyval(n2)); ------------------ | | 434| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ return pvalue(k1) == pvalueraw(keyval(n2)); ------------------ | | 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: 153k] ------------------ 230| 0| return fvalue(k1) == fvalueraw(keyval(n2)); ------------------ | | 603| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ return fvalue(k1) == fvalueraw(keyval(n2)); ------------------ | | 606| 0|#define fvalueraw(v) ((v).f) ------------------ 231| 66.4k| case ctb(LUA_VLNGSTR): ------------------ | | 303| 66.4k|#define ctb(t) ((t) | BIT_ISCOLLECTABLE) | | ------------------ | | | | 298| 66.4k|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ ------------------ | Branch (231:5): [True: 66.4k, False: 86.9k] ------------------ 232| 66.4k| return luaS_eqlngstr(tsvalue(k1), keystrval(n2)); ------------------ | | 369| 66.4k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 66.4k|#define check_exp(c,e) (e) | | ------------------ ------------------ return luaS_eqlngstr(tsvalue(k1), keystrval(n2)); ------------------ | | 760| 66.4k|#define keystrval(node) (gco2ts(keyval(node).gc)) | | ------------------ | | | | 374| 66.4k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | | | ------------------ | | | | | | 115| 66.4k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 233| 1.13k| default: ------------------ | Branch (233:5): [True: 1.13k, False: 152k] ------------------ 234| 1.13k| return gcvalue(k1) == gcvalueraw(keyval(n2)); ------------------ | | 305| 1.13k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 1.13k|#define check_exp(c,e) (e) | | ------------------ ------------------ return gcvalue(k1) == gcvalueraw(keyval(n2)); ------------------ | | 307| 1.13k|#define gcvalueraw(v) ((v).gc) ------------------ 235| 153k| } 236| 153k|} ltable.c:luaH_newkey: 666| 334k| TValue *value) { 667| 334k| Node *mp; 668| 334k| TValue aux; 669| 334k| if (l_unlikely(ttisnil(key))) ------------------ | | 697| 334k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 334k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 334k] | | | | ------------------ | | ------------------ ------------------ 670| 0| luaG_runerror(L, "table index is nil"); 671| 334k| else if (ttisfloat(key)) { ------------------ | | 327| 334k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 334k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 334k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 7.36k, False: 327k] | | | | ------------------ | | ------------------ ------------------ 672| 7.36k| lua_Number f = fltvalue(key); ------------------ | | 332| 7.36k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 7.36k|#define check_exp(c,e) (e) | | ------------------ ------------------ 673| 7.36k| lua_Integer k; 674| 7.36k| if (luaV_flttointeger(f, &k, F2Ieq)) { /* does key fit in an integer? */ ------------------ | Branch (674:9): [True: 66, False: 7.30k] ------------------ 675| 66| setivalue(&aux, k); ------------------ | | 345| 66| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 66|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 66|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 676| 66| key = &aux; /* insert it as an integer */ 677| 66| } 678| 7.30k| else if (l_unlikely(luai_numisnan(f))) ------------------ | | 697| 7.30k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 7.30k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 7.30k] | | | | ------------------ | | ------------------ ------------------ 679| 0| luaG_runerror(L, "table index is NaN"); 680| 7.36k| } 681| 334k| if (ttisnil(value)) ------------------ | | 193| 334k|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 334k|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 334k|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 334k|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 222k, False: 111k] | | | | ------------------ | | ------------------ ------------------ 682| 222k| return; /* do not insert nil values */ 683| 111k| mp = mainpositionTV(t, key); 684| 111k| if (!isempty(gval(mp)) || isdummy(t)) { /* main position is taken? */ ------------------ | | 217| 111k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 111k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 223k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 111k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 111k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!isempty(gval(mp)) || isdummy(t)) { /* main position is taken? */ ------------------ | | 27| 64.8k|#define isdummy(t) ((t)->lastfree == NULL) | | ------------------ | | | Branch (27:21): [True: 405, False: 64.4k] | | ------------------ ------------------ | Branch (684:7): [True: 46.9k, False: 64.8k] ------------------ 685| 47.3k| Node *othern; 686| 47.3k| Node *f = getfreepos(t); /* get a free place */ 687| 47.3k| if (f == NULL) { /* cannot find a free place? */ ------------------ | Branch (687:9): [True: 2.81k, False: 44.5k] ------------------ 688| 2.81k| rehash(L, t, key); /* grow table */ 689| | /* whatever called 'newkey' takes care of TM cache */ 690| 2.81k| luaH_set(L, t, key, value); /* insert key into grown table */ 691| 2.81k| return; 692| 2.81k| } 693| 44.5k| lua_assert(!isdummy(t)); ------------------ | | 114| 44.5k|#define lua_assert(c) ((void)0) ------------------ 694| 44.5k| othern = mainpositionfromnode(t, mp); 695| 44.5k| if (othern != mp) { /* is colliding node out of its main position? */ ------------------ | Branch (695:9): [True: 10.2k, False: 34.3k] ------------------ 696| | /* yes; move colliding node into free position */ 697| 14.6k| while (othern + gnext(othern) != mp) /* find previous */ ------------------ | | 15| 14.6k|#define gnext(n) ((n)->u.next) ------------------ | Branch (697:14): [True: 4.46k, False: 10.2k] ------------------ 698| 4.46k| othern += gnext(othern); ------------------ | | 15| 4.46k|#define gnext(n) ((n)->u.next) ------------------ 699| 10.2k| gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */ ------------------ | | 15| 10.2k|#define gnext(n) ((n)->u.next) ------------------ gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */ ------------------ | | 141| 10.2k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 10.2k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 700| 10.2k| *f = *mp; /* copy colliding node into free pos. (mp->next also goes) */ 701| 10.2k| if (gnext(mp) != 0) { ------------------ | | 15| 10.2k|#define gnext(n) ((n)->u.next) ------------------ | Branch (701:11): [True: 2.46k, False: 7.76k] ------------------ 702| 2.46k| gnext(f) += cast_int(mp - f); /* correct 'next' */ ------------------ | | 15| 2.46k|#define gnext(n) ((n)->u.next) ------------------ gnext(f) += cast_int(mp - f); /* correct 'next' */ ------------------ | | 141| 2.46k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 2.46k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 703| 2.46k| gnext(mp) = 0; /* now 'mp' is free */ ------------------ | | 15| 2.46k|#define gnext(n) ((n)->u.next) ------------------ 704| 2.46k| } 705| 10.2k| setempty(gval(mp)); ------------------ | | 225| 10.2k|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 10.2k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 706| 10.2k| } 707| 34.3k| else { /* colliding node is in its own main position */ 708| | /* new node will go into free position */ 709| 34.3k| if (gnext(mp) != 0) ------------------ | | 15| 34.3k|#define gnext(n) ((n)->u.next) ------------------ | Branch (709:11): [True: 11.5k, False: 22.7k] ------------------ 710| 11.5k| gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */ ------------------ | | 15| 11.5k|#define gnext(n) ((n)->u.next) ------------------ gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */ ------------------ | | 141| 11.5k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 11.5k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 711| 22.7k| else lua_assert(gnext(f) == 0); ------------------ | | 114| 22.7k|#define lua_assert(c) ((void)0) ------------------ 712| 34.3k| gnext(mp) = cast_int(f - mp); ------------------ | | 15| 34.3k|#define gnext(n) ((n)->u.next) ------------------ gnext(mp) = cast_int(f - mp); ------------------ | | 141| 34.3k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 34.3k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 713| 34.3k| mp = f; 714| 34.3k| } 715| 44.5k| } 716| 109k| setnodekey(L, mp, key); ------------------ | | 712| 109k| { Node *n_=(node); const TValue *io_=(obj); \ | | 713| 109k| n_->u.key_val = io_->value_; n_->u.key_tt = io_->tt_; \ | | 714| 109k| checkliveness(L,io_); } | | ------------------ | | | | 107| 109k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 109k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 109k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 717| 109k| luaC_barrierback(L, obj2gco(t), key); ------------------ | | 185| 109k|#define luaC_barrierback(L,p,v) ( \ | | 186| 109k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 109k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 109k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 109k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 62.2k, False: 46.7k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 182| 62.2k|#define luaC_objbarrierback(L,p,o) ( \ | | | | 183| 62.2k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 88| 62.2k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 62.2k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 124k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 62.2k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 138| 62.2k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 62.2k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 46.7k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 46.7k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 718| 109k| lua_assert(isempty(gval(mp))); ------------------ | | 114| 109k|#define lua_assert(c) ((void)0) ------------------ 719| 109k| setobj2t(L, gval(mp), value); ------------------ | | 137| 109k|#define setobj2t setobj | | ------------------ | | | | 119| 109k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 109k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 109k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 109k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 109k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 109k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 109k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 109k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 720| 109k|} ltable.c:getfreepos: 645| 47.3k|static Node *getfreepos (Table *t) { 646| 47.3k| if (!isdummy(t)) { ------------------ | | 27| 47.3k|#define isdummy(t) ((t)->lastfree == NULL) ------------------ | Branch (646:7): [True: 46.9k, False: 405] ------------------ 647| 95.0k| while (t->lastfree > t->node) { ------------------ | Branch (647:12): [True: 92.6k, False: 2.41k] ------------------ 648| 92.6k| t->lastfree--; 649| 92.6k| if (keyisnil(t->lastfree)) ------------------ | | 756| 92.6k|#define keyisnil(node) (keytt(node) == LUA_TNIL) | | ------------------ | | | | 753| 92.6k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisnil(node) (keytt(node) == LUA_TNIL) | | ------------------ | | | | 64| 92.6k|#define LUA_TNIL 0 | | ------------------ | | | Branch (756:25): [True: 44.5k, False: 48.1k] | | ------------------ ------------------ 650| 44.5k| return t->lastfree; 651| 92.6k| } 652| 46.9k| } 653| 2.81k| return NULL; /* could not find a free place */ 654| 47.3k|} ltable.c:rehash: 598| 2.81k|static void rehash (lua_State *L, Table *t, const TValue *ek) { 599| 2.81k| unsigned int asize; /* optimal size for array part */ 600| 2.81k| unsigned int na; /* number of keys in the array part */ 601| 2.81k| unsigned int nums[MAXABITS + 1]; 602| 2.81k| int i; 603| 2.81k| int totaluse; 604| 92.9k| for (i = 0; i <= MAXABITS; i++) nums[i] = 0; /* reset counts */ ------------------ | | 46| 92.9k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | ------------------ | | | | 141| 92.9k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 92.9k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (604:15): [True: 90.1k, False: 2.81k] ------------------ 605| 2.81k| setlimittosize(t); 606| 2.81k| na = numusearray(t, nums); /* count keys in array part */ 607| 2.81k| totaluse = na; /* all those keys are integer keys */ 608| 2.81k| totaluse += numusehash(t, nums, &na); /* count keys in hash part */ 609| | /* count extra key */ 610| 2.81k| if (ttisinteger(ek)) ------------------ | | 328| 2.81k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 2.81k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 2.81k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 413, False: 2.40k] | | | | ------------------ | | ------------------ ------------------ 611| 413| na += countint(ivalue(ek), nums); ------------------ | | 333| 413|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 413|#define check_exp(c,e) (e) | | ------------------ ------------------ 612| 2.81k| totaluse++; 613| | /* compute new size for array part */ 614| 2.81k| asize = computesizes(nums, &na); 615| | /* resize the table to new computed sizes */ 616| 2.81k| luaH_resize(L, t, asize, totaluse - na); 617| 2.81k|} ltable.c:numusearray: 429| 2.81k|static unsigned int numusearray (const Table *t, unsigned int *nums) { 430| 2.81k| int lg; 431| 2.81k| unsigned int ttlg; /* 2^lg */ 432| 2.81k| unsigned int ause = 0; /* summation of 'nums' */ 433| 2.81k| unsigned int i = 1; /* count to traverse all array keys */ 434| 2.81k| unsigned int asize = limitasasize(t); /* real array size */ ------------------ | | 290| 2.81k|#define limitasasize(t) check_exp(isrealasize(t), t->alimit) | | ------------------ | | | | 115| 2.81k|#define check_exp(c,e) (e) | | ------------------ ------------------ 435| | /* traverse each slice */ 436| 3.73k| for (lg = 0, ttlg = 1; lg <= MAXABITS; lg++, ttlg *= 2) { ------------------ | | 46| 3.73k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | ------------------ | | | | 141| 3.73k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 3.73k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (436:26): [True: 3.73k, False: 0] ------------------ 437| 3.73k| unsigned int lc = 0; /* counter */ 438| 3.73k| unsigned int lim = ttlg; 439| 3.73k| if (lim > asize) { ------------------ | Branch (439:9): [True: 2.81k, False: 919] ------------------ 440| 2.81k| lim = asize; /* adjust upper limit */ 441| 2.81k| if (i > lim) ------------------ | Branch (441:11): [True: 2.81k, False: 0] ------------------ 442| 2.81k| break; /* no more elements to count */ 443| 2.81k| } 444| | /* count elements in range (2^(lg - 1), 2^lg] */ 445| 3.16k| for (; i <= lim; i++) { ------------------ | Branch (445:12): [True: 2.24k, False: 919] ------------------ 446| 2.24k| if (!isempty(&t->array[i-1])) ------------------ | | 217| 2.24k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 2.24k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 2.24k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 2.24k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 2.24k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (446:11): [True: 2.07k, False: 174] ------------------ 447| 2.07k| lc++; 448| 2.24k| } 449| 919| nums[lg] += lc; 450| 919| ause += lc; 451| 919| } 452| 2.81k| return ause; 453| 2.81k|} ltable.c:numusehash: 456| 2.81k|static int numusehash (const Table *t, unsigned int *nums, unsigned int *pna) { 457| 2.81k| int totaluse = 0; /* total number of elements */ 458| 2.81k| int ause = 0; /* elements added to 'nums' (can go to array part) */ 459| 2.81k| int i = sizenode(t); ------------------ | | 791| 2.81k|#define sizenode(t) (twoto((t)->lsizenode)) | | ------------------ | | | | 790| 2.81k|#define twoto(x) (1<<(x)) | | ------------------ ------------------ 460| 79.0k| while (i--) { ------------------ | Branch (460:10): [True: 76.2k, False: 2.81k] ------------------ 461| 76.2k| Node *n = &t->node[i]; 462| 76.2k| if (!isempty(gval(n))) { ------------------ | | 217| 76.2k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 76.2k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 76.2k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 76.2k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 76.2k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (462:9): [True: 75.8k, False: 411] ------------------ 463| 75.8k| if (keyisinteger(n)) ------------------ | | 757| 75.8k|#define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 753| 75.8k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 323| 75.8k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | | | ------------------ | | | | | | 42| 75.8k|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (757:28): [True: 30.8k, False: 44.9k] | | ------------------ ------------------ 464| 30.8k| ause += countint(keyival(n), nums); ------------------ | | 758| 30.8k|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 754| 30.8k|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ 465| 75.8k| totaluse++; 466| 75.8k| } 467| 76.2k| } 468| 2.81k| *pna += ause; 469| 2.81k| return totaluse; 470| 2.81k|} ltable.c:countint: 413| 31.2k|static int countint (lua_Integer key, unsigned int *nums) { 414| 31.2k| unsigned int k = arrayindex(key); 415| 31.2k| if (k != 0) { /* is 'key' an appropriate array index? */ ------------------ | Branch (415:7): [True: 18.8k, False: 12.3k] ------------------ 416| 18.8k| nums[luaO_ceillog2(k)]++; /* count as such */ 417| 18.8k| return 1; 418| 18.8k| } 419| 12.3k| else 420| 12.3k| return 0; 421| 31.2k|} ltable.c:computesizes: 391| 2.81k|static unsigned int computesizes (unsigned int nums[], unsigned int *pna) { 392| 2.81k| int i; 393| 2.81k| unsigned int twotoi; /* 2^i (candidate for optimal size) */ 394| 2.81k| unsigned int a = 0; /* number of elements smaller than 2^i */ 395| 2.81k| unsigned int na = 0; /* number of elements to go to array part */ 396| 2.81k| unsigned int optimal = 0; /* optimal size for array part */ 397| | /* loop while keys can fill more than half of total size */ 398| 2.81k| for (i = 0, twotoi = 1; 399| 6.72k| twotoi > 0 && *pna > twotoi / 2; ------------------ | Branch (399:8): [True: 6.72k, False: 0] | Branch (399:22): [True: 3.90k, False: 2.81k] ------------------ 400| 3.90k| i++, twotoi *= 2) { 401| 3.90k| a += nums[i]; 402| 3.90k| if (a > twotoi/2) { /* more than half elements present? */ ------------------ | Branch (402:9): [True: 1.36k, False: 2.54k] ------------------ 403| 1.36k| optimal = twotoi; /* optimal size (till now) */ 404| 1.36k| na = a; /* all elements up to 'optimal' will go to array part */ 405| 1.36k| } 406| 3.90k| } 407| 2.81k| lua_assert((optimal == 0 || optimal / 2 < na) && na <= optimal); ------------------ | | 114| 2.81k|#define lua_assert(c) ((void)0) ------------------ 408| 2.81k| *pna = na; 409| 2.81k| return optimal; 410| 2.81k|} ltable.c:mainpositionfromnode: 189| 44.5k|l_sinline Node *mainpositionfromnode (const Table *t, Node *nd) { 190| 44.5k| TValue key; 191| 44.5k| getnodekey(cast(lua_State *, NULL), &key, nd); ------------------ | | 719| 44.5k| { TValue *io_=(obj); const Node *n_=(node); \ | | 720| 44.5k| io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \ | | 721| 44.5k| checkliveness(L,io_); } | | ------------------ | | | | 107| 44.5k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 44.5k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 44.5k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 192| 44.5k| return mainpositionTV(t, &key); 193| 44.5k|} ltable.c:hash_search: 856| 9.64k|static lua_Unsigned hash_search (Table *t, lua_Unsigned j) { 857| 9.64k| lua_Unsigned i; 858| 9.64k| if (j == 0) j++; /* the caller ensures 'j + 1' is present */ ------------------ | Branch (858:7): [True: 2.56k, False: 7.07k] ------------------ 859| 384k| do { 860| 384k| i = j; /* 'i' is a present index */ 861| 384k| if (j <= l_castS2U(LUA_MAXINTEGER) / 2) ------------------ | | 152| 384k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (861:9): [True: 377k, False: 6.97k] ------------------ 862| 377k| j *= 2; 863| 6.97k| else { 864| 6.97k| j = LUA_MAXINTEGER; ------------------ | | 554| 6.97k|#define LUA_MAXINTEGER LLONG_MAX ------------------ 865| 6.97k| if (isempty(luaH_getint(t, j))) /* t[j] not present? */ ------------------ | | 217| 6.97k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 6.97k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 6.97k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 6.97k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 6.97k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 6.97k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 866| 6.97k| break; /* 'j' now is an absent index */ 867| 0| else /* weird case */ 868| 0| return j; /* well, max integer is a boundary... */ 869| 6.97k| } 870| 384k| } while (!isempty(luaH_getint(t, j))); /* repeat until an absent t[j] */ ------------------ | | 217| 377k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 377k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 377k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 377k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 377k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (870:12): [True: 374k, False: 2.66k] ------------------ 871| | /* i < j && t[i] present && t[j] absent */ 872| 438k| while (j - i > 1u) { /* do a binary search between them */ ------------------ | Branch (872:10): [True: 428k, False: 9.64k] ------------------ 873| 428k| lua_Unsigned m = (i + j) / 2; 874| 428k| if (isempty(luaH_getint(t, m))) j = m; ------------------ | | 217| 428k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 428k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 428k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 428k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 428k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 428k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 875| 0| else i = m; 876| 428k| } 877| 9.64k| return i; 878| 9.64k|} luaT_init: 38| 390|void luaT_init (lua_State *L) { 39| 390| static const char *const luaT_eventname[] = { /* ORDER TM */ 40| 390| "__index", "__newindex", 41| 390| "__gc", "__mode", "__len", "__eq", 42| 390| "__add", "__sub", "__mul", "__mod", "__pow", 43| 390| "__div", "__idiv", 44| 390| "__band", "__bor", "__bxor", "__shl", "__shr", 45| 390| "__unm", "__bnot", "__lt", "__le", 46| 390| "__concat", "__call", "__close" 47| 390| }; 48| 390| int i; 49| 10.1k| for (i=0; itmname[i] = luaS_new(L, luaT_eventname[i]); ------------------ | | 335| 9.75k|#define G(L) (L->l_G) ------------------ 51| 9.75k| luaC_fix(L, obj2gco(G(L)->tmname[i])); /* never collect these names */ ------------------ | | 390| 9.75k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 9.75k|#define check_exp(c,e) (e) | | ------------------ ------------------ 52| 9.75k| } 53| 390|} luaT_gettm: 60| 16|const TValue *luaT_gettm (Table *events, TMS event, TString *ename) { 61| 16| const TValue *tm = luaH_getshortstr(events, ename); 62| 16| lua_assert(event <= TM_EQ); ------------------ | | 114| 16|#define lua_assert(c) ((void)0) ------------------ 63| 16| if (notm(tm)) { /* no tag method? */ ------------------ | | 61| 16|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 193| 16|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 16|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 16|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 16|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 16] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 64| 0| events->flags |= cast_byte(1u<metatable; ------------------ | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 76| 0| break; 77| 48| case LUA_TUSERDATA: ------------------ | | 71| 48|#define LUA_TUSERDATA 7 ------------------ | Branch (77:5): [True: 48, False: 103] ------------------ 78| 48| mt = uvalue(o)->metatable; ------------------ | | 435| 48|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 115| 48|#define check_exp(c,e) (e) | | ------------------ ------------------ 79| 48| break; 80| 103| default: ------------------ | Branch (80:5): [True: 103, False: 48] ------------------ 81| 103| mt = G(L)->mt[ttype(o)]; ------------------ | | 335| 103|#define G(L) (L->l_G) ------------------ mt = G(L)->mt[ttype(o)]; ------------------ | | 87| 103|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 103|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 82| 151| } 83| 151| return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : &G(L)->nilvalue); ------------------ | | 335| 48|#define G(L) (L->l_G) ------------------ return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : &G(L)->nilvalue); ------------------ | | 335| 103|#define G(L) (L->l_G) ------------------ | Branch (83:11): [True: 48, False: 103] ------------------ 84| 151|} luaT_objtypename: 91| 55|const char *luaT_objtypename (lua_State *L, const TValue *o) { 92| 55| Table *mt; 93| 55| if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) || ------------------ | | 680| 55|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | ------------------ | | | | 91| 110|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 55|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 55] | | | | ------------------ | | ------------------ ------------------ if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) || ------------------ | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (93:24): [True: 0, False: 0] ------------------ 94| 55| (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) { ------------------ | | 432| 55|#define ttisfulluserdata(o) checktag((o), ctb(LUA_VUSERDATA)) | | ------------------ | | | | 91| 110|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 55|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 55] | | | | ------------------ | | ------------------ ------------------ (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) { ------------------ | | 435| 0|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (94:31): [True: 0, False: 0] ------------------ 95| 0| const TValue *name = luaH_getshortstr(mt, luaS_new(L, "__name")); 96| 0| if (ttisstring(name)) /* is '__name' a string? */ ------------------ | | 363| 0|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 97| 0| return getstr(tsvalue(name)); /* use it as type name */ ------------------ | | 404| 0|#define getstr(ts) ((ts)->contents) ------------------ 98| 0| } 99| 55| return ttypename(ttype(o)); /* else use standard type name */ ------------------ | | 69| 55|#define ttypename(x) luaT_typenames_[(x) + 1] ------------------ 100| 55|} luaT_trybinTM: 149| 47| StkId res, TMS event) { 150| 47| if (l_unlikely(!callbinTM(L, p1, p2, res, event))) { ------------------ | | 697| 47|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 47|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 47, False: 0] | | | | ------------------ | | ------------------ ------------------ 151| 47| switch (event) { 152| 16| case TM_BAND: case TM_BOR: case TM_BXOR: ------------------ | Branch (152:7): [True: 15, False: 32] | Branch (152:21): [True: 0, False: 47] | Branch (152:34): [True: 1, False: 46] ------------------ 153| 38| case TM_SHL: case TM_SHR: case TM_BNOT: { ------------------ | Branch (153:7): [True: 7, False: 40] | Branch (153:20): [True: 0, False: 47] | Branch (153:33): [True: 15, False: 32] ------------------ 154| 38| if (ttisnumber(p1) && ttisnumber(p2)) ------------------ | | 326| 38|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | ------------------ | | | | 92| 76|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 38|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 38|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 4, False: 34] | | | | ------------------ | | ------------------ ------------------ if (ttisnumber(p1) && ttisnumber(p2)) ------------------ | | 326| 4|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | ------------------ | | | | 92| 4|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 4|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 4|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 3, False: 1] | | | | ------------------ | | ------------------ ------------------ 155| 3| luaG_tointerror(L, p1, p2); 156| 35| else 157| 35| luaG_opinterror(L, p1, p2, "perform bitwise operation on"); 158| 38| } 159| | /* calls never return, but to avoid warnings: *//* FALLTHROUGH */ 160| 9| default: ------------------ | Branch (160:7): [True: 9, False: 38] ------------------ 161| 9| luaG_opinterror(L, p1, p2, "perform arithmetic on"); 162| 47| } 163| 47| } 164| 47|} 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| 5| int flip, StkId res, TMS event) { 177| 5| if (flip) ------------------ | Branch (177:7): [True: 1, False: 4] ------------------ 178| 1| luaT_trybinTM(L, p2, p1, res, event); 179| 4| else 180| 4| luaT_trybinTM(L, p1, p2, res, event); 181| 5|} luaT_trybiniTM: 185| 1| int flip, StkId res, TMS event) { 186| 1| TValue aux; 187| 1| setivalue(&aux, i2); ------------------ | | 345| 1| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 1|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 1|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 188| 1| luaT_trybinassocTM(L, p1, &aux, flip, res, event); 189| 1|} luaT_callorderTM: 202| 2| TMS event) { 203| 2| if (callbinTM(L, p1, p2, L->top.p, event)) /* try original event */ ------------------ | Branch (203:7): [True: 0, False: 2] ------------------ 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| 2| luaG_ordererror(L, p1, p2); /* no metamethod found */ 217| 0| return 0; /* to avoid warnings */ 218| 2|} luaT_adjustvarargs: 239| 8.07k| const Proto *p) { 240| 8.07k| int i; 241| 8.07k| int actual = cast_int(L->top.p - ci->func.p) - 1; /* number of arguments */ ------------------ | | 141| 8.07k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 8.07k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 242| 8.07k| int nextra = actual - nfixparams; /* number of extra arguments */ 243| 8.07k| ci->u.l.nextraargs = nextra; 244| 8.07k| luaD_checkstack(L, p->maxstacksize + 1); ------------------ | | 32| 8.07k|#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0) | | ------------------ | | | | 27| 8.07k| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 8.07k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 8.07k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 2, False: 8.07k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 8.07k| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 8.07k| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 8.07k|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 245| | /* copy function to the top of the stack */ 246| 8.07k| setobjs2s(L, L->top.p++, ci->func.p); ------------------ | | 129| 8.07k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 8.07k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 8.07k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 8.07k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 8.07k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 8.07k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 8.07k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 8.07k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 8.07k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 247| | /* move fixed parameters to the top of the stack */ 248| 8.07k| for (i = 1; i <= nfixparams; i++) { ------------------ | Branch (248:15): [True: 0, False: 8.07k] ------------------ 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) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 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| 8.07k| ci->func.p += actual + 1; 253| 8.07k| ci->top.p += actual + 1; 254| 8.07k| lua_assert(L->top.p <= ci->top.p && ci->top.p <= L->stack_last.p); ------------------ | | 114| 8.07k|#define lua_assert(c) ((void)0) ------------------ 255| 8.07k|} luaT_getvarargs: 258| 8.00k|void luaT_getvarargs (lua_State *L, CallInfo *ci, StkId where, int wanted) { 259| 8.00k| int i; 260| 8.00k| int nextra = ci->u.l.nextraargs; 261| 8.00k| if (wanted < 0) { ------------------ | Branch (261:7): [True: 8.00k, False: 0] ------------------ 262| 8.00k| wanted = nextra; /* get all extra arguments available */ 263| 8.00k| checkstackGCp(L, nextra, where); /* ensure stack space */ ------------------ | | 49| 8.00k| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 8.00k| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 8.00k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 8.00k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 8.00k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 8.00k| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | ------------------ | | | | | Branch (28:6): [True: 0, False: 0] | | | | ------------------ | | | | 29| 8.00k| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 8.00k|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 50| 8.00k| ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ | | 51| 8.00k| luaC_checkGC(L), /* stack grow uses memory */ \ | | 52| 8.00k| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 264| 8.00k| L->top.p = where + nextra; /* next instruction will need top */ 265| 8.00k| } 266| 16.0k| for (i = 0; i < wanted && i < nextra; i++) ------------------ | Branch (266:15): [True: 8.00k, False: 8.00k] | Branch (266:29): [True: 8.00k, False: 0] ------------------ 267| 8.00k| setobjs2s(L, where + i, ci->func.p - nextra + i); ------------------ | | 129| 8.00k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 8.00k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 8.00k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 8.00k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 8.00k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 8.00k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 8.00k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 8.00k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 8.00k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 268| 8.00k| for (; i < wanted; i++) /* complete required results with nil */ ------------------ | Branch (268:10): [True: 0, False: 8.00k] ------------------ 269| 8.00k| setnilvalue(s2v(where + i)); ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 270| 8.00k|} ltm.c:callbinTM: 138| 50| StkId res, TMS event) { 139| 50| const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */ 140| 50| if (notm(tm)) ------------------ | | 61| 50|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 193| 50|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 50|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 50|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 50|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 50, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 141| 50| tm = luaT_gettmbyobj(L, p2, event); /* try second operand */ 142| 50| if (notm(tm)) return 0; ------------------ | | 61| 50|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 193| 50|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 50|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 50|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 50|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 50, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 143| 0| luaT_callTMres(L, tm, p1, p2, res); 144| 0| return 1; 145| 50|} 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)) | | ------------------ ------------------ 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), \ | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 331| 0| (ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o))) ------------------ 113| 0| return 1; 114| 0| } 115| 3| else 116| 3| return 0; /* conversion failed */ 117| 3|} luaV_flttointeger: 123| 475k|int luaV_flttointeger (lua_Number n, lua_Integer *p, F2Imod mode) { 124| 475k| lua_Number f = l_floor(n); ------------------ | | 418| 475k|#define l_floor(x) (l_mathop(floor)(x)) | | ------------------ | | | | 482| 475k|#define l_mathop(op) op | | ------------------ ------------------ 125| 475k| if (n != f) { /* not an integral value? */ ------------------ | Branch (125:7): [True: 286k, False: 188k] ------------------ 126| 286k| if (mode == F2Ieq) return 0; /* fails if mode demands integral value */ ------------------ | Branch (126:9): [True: 270k, False: 16.0k] ------------------ 127| 16.0k| else if (mode == F2Iceil) /* needs ceil? */ ------------------ | Branch (127:14): [True: 16.0k, False: 0] ------------------ 128| 16.0k| f += 1; /* convert floor to ceil (remember: n != f) */ 129| 286k| } 130| 204k| return lua_numbertointeger(f, p); ------------------ | | 433| 204k| ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 555| 204k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (433:4): [True: 202k, False: 2.54k] | | ------------------ | | 434| 204k| (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 555| 202k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (434:4): [True: 185k, False: 17.2k] | | ------------------ | | 435| 204k| (*(p) = (LUA_INTEGER)(n), 1)) | | ------------------ | | | Branch (435:7): [True: 185k, False: 0] | | ------------------ ------------------ 131| 475k|} luaV_tointegerns: 139| 440k|int luaV_tointegerns (const TValue *obj, lua_Integer *p, F2Imod mode) { 140| 440k| if (ttisfloat(obj)) ------------------ | | 327| 440k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 440k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 440k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 223k, False: 217k] | | | | ------------------ | | ------------------ ------------------ 141| 223k| return luaV_flttointeger(fltvalue(obj), p, mode); ------------------ | | 332| 223k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 223k|#define check_exp(c,e) (e) | | ------------------ ------------------ 142| 217k| else if (ttisinteger(obj)) { ------------------ | | 328| 217k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 217k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 217k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 217k, False: 37] | | | | ------------------ | | ------------------ ------------------ 143| 217k| *p = ivalue(obj); ------------------ | | 333| 217k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 217k|#define check_exp(c,e) (e) | | ------------------ ------------------ 144| 217k| return 1; 145| 217k| } 146| 37| else 147| 37| return 0; 148| 440k|} luaV_tointeger: 154| 16|int luaV_tointeger (const TValue *obj, lua_Integer *p, F2Imod mode) { 155| 16| TValue v; 156| 16| if (l_strton(obj, &v)) /* does 'obj' point to a numerical string? */ ------------------ | Branch (156:7): [True: 0, False: 16] ------------------ 157| 0| obj = &v; /* change it to point to its corresponding number */ 158| 16| return luaV_tointegerns(obj, p, mode); 159| 16|} luaV_finishget: 290| 1.34M| const TValue *slot) { 291| 1.34M| int loop; /* counter to avoid infinite loops */ 292| 1.34M| const TValue *tm; /* metamethod */ 293| 1.34M| for (loop = 0; loop < MAXTAGLOOP; loop++) { ------------------ | | 49| 1.34M|#define MAXTAGLOOP 2000 ------------------ | Branch (293:18): [True: 1.34M, False: 0] ------------------ 294| 1.34M| if (slot == NULL) { /* 't' is not a table? */ ------------------ | Branch (294:9): [True: 1, False: 1.34M] ------------------ 295| 1| lua_assert(!ttistable(t)); ------------------ | | 114| 1|#define lua_assert(c) ((void)0) ------------------ 296| 1| tm = luaT_gettmbyobj(L, t, TM_INDEX); 297| 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] | | | | ------------------ | | ------------------ ------------------ 298| 1| luaG_typeerror(L, t, "index"); /* no metamethod */ 299| | /* else will try the metamethod */ 300| 1| } 301| 1.34M| else { /* 't' is a table */ 302| 1.34M| lua_assert(isempty(slot)); ------------------ | | 114| 1.34M|#define lua_assert(c) ((void)0) ------------------ 303| 1.34M| tm = fasttm(L, hvalue(t)->metatable, TM_INDEX); /* table's metamethod */ ------------------ | | 67| 1.34M|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 64| 1.34M|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (64:26): [True: 1.34M, False: 0] | | | | ------------------ | | | | 65| 1.34M| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 304| 1.34M| if (tm == NULL) { /* no metamethod? */ ------------------ | Branch (304:11): [True: 1.34M, False: 0] ------------------ 305| 1.34M| setnilvalue(s2v(val)); /* result is nil */ ------------------ | | 200| 1.34M|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 1.34M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 306| 1.34M| return; 307| 1.34M| } 308| | /* else will try the metamethod */ 309| 1.34M| } 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)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 0| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 0|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 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) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 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| 1.34M|} luaV_finishset: 333| 246k| TValue *val, const TValue *slot) { 334| 246k| int loop; /* counter to avoid infinite loops */ 335| 246k| for (loop = 0; loop < MAXTAGLOOP; loop++) { ------------------ | | 49| 246k|#define MAXTAGLOOP 2000 ------------------ | Branch (335:18): [True: 246k, False: 0] ------------------ 336| 246k| const TValue *tm; /* '__newindex' metamethod */ 337| 246k| if (slot != NULL) { /* is 't' a table? */ ------------------ | Branch (337:9): [True: 246k, False: 0] ------------------ 338| 246k| Table *h = hvalue(t); /* save 't' table */ ------------------ | | 682| 246k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 246k|#define check_exp(c,e) (e) | | ------------------ ------------------ 339| 246k| lua_assert(isempty(slot)); /* slot must be empty */ ------------------ | | 114| 246k|#define lua_assert(c) ((void)0) ------------------ 340| 246k| tm = fasttm(L, h->metatable, TM_NEWINDEX); /* get metamethod */ ------------------ | | 67| 246k|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 64| 246k|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (64:26): [True: 246k, False: 0] | | | | ------------------ | | | | 65| 246k| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 341| 246k| if (tm == NULL) { /* no metamethod? */ ------------------ | Branch (341:11): [True: 246k, False: 0] ------------------ 342| 246k| luaH_finishset(L, h, key, slot, val); /* set new value */ 343| 246k| invalidateTMcache(h); ------------------ | | 23| 246k|#define invalidateTMcache(t) ((t)->flags &= ~maskflags) | | ------------------ | | | | 54| 246k|#define maskflags (~(~0u << (TM_EQ + 1))) | | ------------------ ------------------ 344| 246k| luaC_barrierback(L, obj2gco(h), val); ------------------ | | 185| 246k|#define luaC_barrierback(L,p,v) ( \ | | 186| 246k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 246k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 246k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 246k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 8.05k, False: 238k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 182| 8.05k|#define luaC_objbarrierback(L,p,o) ( \ | | | | 183| 8.05k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 88| 8.05k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 8.05k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 16.1k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 8.05k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 138| 8.05k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 8.05k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 238k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 238k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 345| 246k| return; 346| 246k| } 347| | /* else will try the metamethod */ 348| 246k| } 349| 0| else { /* not a table; check metamethod */ 350| 0| tm = luaT_gettmbyobj(L, t, TM_NEWINDEX); 351| 0| if (l_unlikely(notm(tm))) ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 352| 0| luaG_typeerror(L, t, "index"); 353| 0| } 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)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 0| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 0|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 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) || \ | | | | | | | | ------------------ | | | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | | | ------------------ | | | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 0| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 0|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 0| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 0|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 0| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 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| 246k|} luaV_equalobj: 569| 13.8M|int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) { 570| 13.8M| const TValue *tm; 571| 13.8M| if (ttypetag(t1) != ttypetag(t2)) { /* not the same variant? */ ------------------ | | 84| 13.8M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 13.8M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ if (ttypetag(t1) != ttypetag(t2)) { /* not the same variant? */ ------------------ | | 84| 13.8M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 13.8M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ | Branch (571:7): [True: 349k, False: 13.4M] ------------------ 572| 349k| if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 87| 349k|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 349k|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 87| 699k|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 349k|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 87| 121k|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 121k|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 67| 121k|#define LUA_TNUMBER 3 ------------------ | Branch (572:9): [True: 227k, False: 121k] | Branch (572:35): [True: 0, False: 121k] ------------------ 573| 227k| return 0; /* only numbers can be equal with different variants */ 574| 121k| 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| 121k| lua_Integer i1, i2; 579| 121k| return (luaV_tointegerns(t1, &i1, F2Ieq) && ------------------ | Branch (579:15): [True: 121k, False: 0] ------------------ 580| 121k| luaV_tointegerns(t2, &i2, F2Ieq) && ------------------ | Branch (580:15): [True: 0, False: 121k] ------------------ 581| 121k| i1 == i2); ------------------ | Branch (581:15): [True: 0, False: 0] ------------------ 582| 121k| } 583| 349k| } 584| | /* values have same type and same variant */ 585| 13.4M| switch (ttypetag(t1)) { ------------------ | | 84| 13.4M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 13.4M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 586| 1.96k| case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1; ------------------ | | 183| 1.08k|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 1.08k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1; ------------------ | | 239| 1.08k|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 1.08k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1; ------------------ | | 240| 1.96k|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 1.96k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (586:5): [True: 1.08k, False: 13.4M] | Branch (586:20): [True: 8, False: 13.4M] | Branch (586:37): [True: 881, False: 13.4M] ------------------ 587| 118k| case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2)); ------------------ | | 323| 118k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 118k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2)); ------------------ | | 333| 118k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 118k|#define check_exp(c,e) (e) | | ------------------ ------------------ case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2)); ------------------ | | 333| 118k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 118k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (587:5): [True: 118k, False: 13.3M] ------------------ 588| 74.5k| case LUA_VNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2)); ------------------ | | 324| 74.5k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 74.5k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2)); ------------------ | | 350| 74.5k|#define luai_numeq(a,b) ((a)==(b)) ------------------ | Branch (588:5): [True: 74.5k, False: 13.3M] ------------------ 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) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ case LUA_VLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); ------------------ | | 434| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (589:5): [True: 0, False: 13.4M] ------------------ 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) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ case LUA_VLCF: return fvalue(t1) == fvalue(t2); ------------------ | | 603| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (590:5): [True: 0, False: 13.4M] ------------------ 591| 13.1M| case LUA_VSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 360| 13.1M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 13.1M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 41| 13.1M|#define eqshrstr(a,b) check_exp((a)->tt == LUA_VSHRSTR, (a) == (b)) | | ------------------ | | | | 115| 13.1M|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (591:5): [True: 13.1M, False: 308k] ------------------ 592| 27.7k| case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 361| 27.7k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 27.7k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 369| 27.7k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 27.7k|#define check_exp(c,e) (e) | | ------------------ ------------------ case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 369| 27.7k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 27.7k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (592:5): [True: 27.7k, False: 13.4M] ------------------ 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: 13.4M] ------------------ 594| 0| if (uvalue(t1) == uvalue(t2)) return 1; ------------------ | | 435| 0|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ if (uvalue(t1) == uvalue(t2)) return 1; ------------------ | | 435| 0|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | 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] | | | | ------------------ | | | | 65| 0| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [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] | | | | ------------------ | | | | 65| 0| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [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: 13.4M] ------------------ 602| 0| if (hvalue(t1) == hvalue(t2)) return 1; ------------------ | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ if (hvalue(t1) == hvalue(t2)) return 1; ------------------ | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | 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] | | | | ------------------ | | | | 65| 0| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [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] | | | | ------------------ | | | | 65| 0| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 607| 0| break; /* will try TM */ 608| 0| } 609| 85.4k| default: ------------------ | Branch (609:5): [True: 85.4k, False: 13.3M] ------------------ 610| 85.4k| return gcvalue(t1) == gcvalue(t2); ------------------ | | 305| 85.4k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 85.4k|#define check_exp(c,e) (e) | | ------------------ ------------------ return gcvalue(t1) == gcvalue(t2); ------------------ | | 305| 85.4k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 85.4k|#define check_exp(c,e) (e) | | ------------------ ------------------ 611| 13.4M| } 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| 65.8k|void luaV_concat (lua_State *L, int total) { 644| 65.8k| if (total == 1) ------------------ | Branch (644:7): [True: 0, False: 65.8k] ------------------ 645| 0| return; /* "all" values already concatenated */ 646| 65.8k| do { 647| 65.8k| StkId top = L->top.p; 648| 65.8k| int n = 2; /* number of elements handled in this pass (at least 2) */ 649| 65.8k| if (!(ttisstring(s2v(top - 2)) || cvt2str(s2v(top - 2))) || ------------------ | | 363| 65.8k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 131k|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 65.8k|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 65.8k|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 8.21k, False: 57.5k] | | | | ------------------ | | ------------------ ------------------ if (!(ttisstring(s2v(top - 2)) || cvt2str(s2v(top - 2))) || ------------------ | | 17| 65.8k|#define cvt2str(o) ttisnumber(o) | | ------------------ | | | | 326| 57.5k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 57.5k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 57.5k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 57.5k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 57.5k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 650| 65.8k| !tostring(L, s2v(top - 1))) ------------------ | | 623| 65.8k| (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 363| 65.8k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | | | ------------------ | | | | | | 92| 131k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 65.8k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 65.8k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 766, False: 65.0k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 17| 65.0k|#define cvt2str(o) ttisnumber(o) | | | | ------------------ | | | | | | 326| 65.0k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | | | ------------------ | | | | | | | | 92| 130k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 65.0k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 65.0k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (92:25): [True: 65.0k, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (623:35): [True: 65.0k, False: 0] | | ------------------ ------------------ 651| 1| luaT_tryconcatTM(L); /* may invalidate 'top' */ 652| 65.8k| else if (isemptystr(s2v(top - 1))) /* second operand is empty? */ ------------------ | | 625| 65.8k|#define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 364| 65.8k|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | | | ------------------ | | | | | | 91| 131k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 65.8k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 65.7k, False: 109] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 369| 65.7k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | | | ------------------ | | | | | | 115| 65.7k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (625:44): [True: 61, False: 65.6k] | | ------------------ ------------------ 653| 65.8k| cast_void(tostring(L, s2v(top - 2))); /* result is first operand */ ------------------ | | 138| 61|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 61|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 0, False: 0] | | | | | Branch (136:27): [True: 0, False: 0] | | | | | Branch (136:27): [True: 61, False: 0] | | | | ------------------ | | ------------------ ------------------ 654| 65.7k| else if (isemptystr(s2v(top - 2))) { /* first operand is empty string? */ ------------------ | | 625| 65.7k|#define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 364| 65.7k|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | | | ------------------ | | | | | | 91| 131k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 65.7k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 8.07k, False: 57.6k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 369| 8.07k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | | | ------------------ | | | | | | 115| 8.07k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (625:44): [True: 0, False: 8.07k] | | ------------------ ------------------ 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) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 656| 0| } 657| 65.7k| else { 658| | /* at least two non-empty string values; get as many as possible */ 659| 65.7k| size_t tl = tsslen(tsvalue(s2v(top - 1))); ------------------ | | 411| 65.7k| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 65.6k, False: 109] | | ------------------ ------------------ 660| 65.7k| TString *ts; 661| | /* collect total length and number of strings */ 662| 131k| for (n = 1; n < total && tostring(L, s2v(top - n - 1)); n++) { ------------------ | | 623| 65.7k| (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 363| 65.7k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | | | ------------------ | | | | | | 92| 131k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 65.7k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 65.7k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 8.18k, False: 57.5k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 17| 57.5k|#define cvt2str(o) ttisnumber(o) | | | | ------------------ | | | | | | 326| 57.5k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | | | ------------------ | | | | | | | | 92| 115k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 57.5k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 57.5k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (92:25): [True: 57.5k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (623:35): [True: 57.5k, False: 0] | | ------------------ ------------------ | Branch (662:19): [True: 65.7k, False: 65.7k] ------------------ 663| 65.7k| size_t l = tsslen(tsvalue(s2v(top - n - 1))); ------------------ | | 411| 65.7k| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 65.6k, False: 95] | | ------------------ ------------------ 664| 65.7k| if (l_unlikely(l >= (MAX_SIZE/sizeof(char)) - tl)) { ------------------ | | 697| 65.7k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 131k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 65.7k] | | | | | 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| 65.7k| tl += l; 669| 65.7k| } 670| 65.7k| if (tl <= LUAI_MAXSHORTLEN) { /* is result a short string? */ ------------------ | | 216| 65.7k|#define LUAI_MAXSHORTLEN 40 ------------------ | Branch (670:11): [True: 65.6k, False: 149] ------------------ 671| 65.6k| char buff[LUAI_MAXSHORTLEN]; 672| 65.6k| copy2buff(top, n, buff); /* copy strings to buffer */ 673| 65.6k| ts = luaS_newlstr(L, buff, tl); 674| 65.6k| } 675| 149| else { /* long string; copy strings directly to final result */ 676| 149| ts = luaS_createlngstrobj(L, tl); 677| 149| copy2buff(top, n, getlngstr(ts)); ------------------ | | 405| 149|#define getlngstr(ts) check_exp((ts)->shrlen == 0xFF, (ts)->contents) | | ------------------ | | | | 115| 149|#define check_exp(c,e) (e) | | ------------------ ------------------ 678| 149| } 679| 65.7k| setsvalue2s(L, top - n, ts); /* create result */ ------------------ | | 377| 65.7k|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 65.7k| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 65.7k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 65.7k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 65.7k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 65.7k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 65.7k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 65.7k| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 65.7k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 65.7k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 65.7k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 680| 65.7k| } 681| 65.8k| total -= n - 1; /* got 'n' strings to create one new */ 682| 65.8k| L->top.p -= n - 1; /* popped 'n' strings and pushed one */ 683| 65.8k| } while (total > 1); /* repeat until only 1 result left */ ------------------ | Branch (683:12): [True: 0, False: 65.8k] ------------------ 684| 65.8k|} luaV_objlen: 690| 18.8k|void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) { 691| 18.8k| const TValue *tm; 692| 18.8k| switch (ttypetag(rb)) { ------------------ | | 84| 18.8k|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 18.8k|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 693| 18.8k| case LUA_VTABLE: { ------------------ | | 678| 18.8k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 18.8k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (693:5): [True: 18.8k, False: 0] ------------------ 694| 18.8k| Table *h = hvalue(rb); ------------------ | | 682| 18.8k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 18.8k|#define check_exp(c,e) (e) | | ------------------ ------------------ 695| 18.8k| tm = fasttm(L, h->metatable, TM_LEN); ------------------ | | 67| 18.8k|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 64| 18.8k|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (64:26): [True: 18.8k, False: 0] | | | | ------------------ | | | | 65| 18.8k| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (65:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 696| 18.8k| if (tm) break; /* metamethod? break switch to call it */ ------------------ | Branch (696:11): [True: 0, False: 18.8k] ------------------ 697| 18.8k| setivalue(s2v(ra), luaH_getn(h)); /* else primitive len */ ------------------ | | 345| 18.8k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 18.8k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 18.8k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 698| 18.8k| return; 699| 18.8k| } 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: 18.8k] ------------------ 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)) | | ------------------ ------------------ 702| 0| return; 703| 18.8k| } 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: 18.8k] ------------------ 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)) | | ------------------ ------------------ 706| 0| return; 707| 18.8k| } 708| 0| default: { /* try metamethod */ ------------------ | Branch (708:5): [True: 0, False: 18.8k] ------------------ 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| 18.8k| } 715| 0| luaT_callTMres(L, tm, rb, rb, ra); 716| 0|} luaV_idiv: 725| 829|lua_Integer luaV_idiv (lua_State *L, lua_Integer m, lua_Integer n) { 726| 829| if (l_unlikely(l_castS2U(n) + 1u <= 1u)) { /* special cases: -1 or 0 */ ------------------ | | 697| 829|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 829|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 5, False: 824] | | | | ------------------ | | ------------------ ------------------ 727| 5| if (n == 0) ------------------ | Branch (727:9): [True: 0, False: 5] ------------------ 728| 0| luaG_runerror(L, "attempt to divide by zero"); 729| 5| return intop(-, 0, m); /* n==-1; avoid overflow with 0x80000...//-1 */ ------------------ | | 73| 5|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 5|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 730| 5| } 731| 824| else { 732| 824| lua_Integer q = m / n; /* perform C division */ 733| 824| if ((m ^ n) < 0 && m % n != 0) /* 'm/n' would be negative non-integer? */ ------------------ | Branch (733:9): [True: 126, False: 698] | Branch (733:24): [True: 120, False: 6] ------------------ 734| 120| q -= 1; /* correct result for different rounding */ 735| 824| return q; 736| 824| } 737| 829|} luaV_mod: 745| 22.9k|lua_Integer luaV_mod (lua_State *L, lua_Integer m, lua_Integer n) { 746| 22.9k| if (l_unlikely(l_castS2U(n) + 1u <= 1u)) { /* special cases: -1 or 0 */ ------------------ | | 697| 22.9k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 22.9k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 284, False: 22.6k] | | | | ------------------ | | ------------------ ------------------ 747| 284| if (n == 0) ------------------ | Branch (747:9): [True: 0, False: 284] ------------------ 748| 0| luaG_runerror(L, "attempt to perform 'n%%0'"); 749| 284| return 0; /* m % -1 == 0; avoid overflow with 0x80000...%-1 */ 750| 284| } 751| 22.6k| else { 752| 22.6k| lua_Integer r = m % n; 753| 22.6k| if (r != 0 && (r ^ n) < 0) /* 'm/n' would be non-integer negative? */ ------------------ | Branch (753:9): [True: 19.8k, False: 2.81k] | Branch (753:19): [True: 905, False: 18.9k] ------------------ 754| 905| r += n; /* correct result for different rounding */ 755| 22.6k| return r; 756| 22.6k| } 757| 22.9k|} luaV_modf: 763| 11.9k|lua_Number luaV_modf (lua_State *L, lua_Number m, lua_Number n) { 764| 11.9k| lua_Number r; 765| 11.9k| luai_nummod(L, m, n, r); ------------------ | | 334| 11.9k| { (void)L; (m) = l_mathop(fmod)(a,b); \ | | ------------------ | | | | 482| 11.9k|#define l_mathop(op) op | | ------------------ | | 335| 11.9k| if (((m) > 0) ? (b) < 0 : ((m) < 0 && (b) > 0)) (m) += (b); } | | ------------------ | | | Branch (335:9): [True: 6.55k, False: 5.41k] | | | Branch (335:9): [True: 2.81k, False: 9.15k] | | | Branch (335:32): [True: 1.71k, False: 3.70k] | | | Branch (335:43): [True: 1.69k, False: 16] | | ------------------ ------------------ 766| 11.9k| return r; 767| 11.9k|} luaV_shiftl: 777| 475k|lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) { 778| 475k| if (y < 0) { /* shift right? */ ------------------ | Branch (778:7): [True: 269k, False: 206k] ------------------ 779| 269k| if (y <= -NBITS) return 0; ------------------ | | 771| 269k|#define NBITS cast_int(sizeof(lua_Integer) * CHAR_BIT) | | ------------------ | | | | 141| 269k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 269k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (779:9): [True: 214k, False: 55.2k] ------------------ 780| 55.2k| else return intop(>>, x, -y); ------------------ | | 73| 55.2k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 55.2k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 781| 269k| } 782| 206k| else { /* shift left */ 783| 206k| if (y >= NBITS) return 0; ------------------ | | 771| 206k|#define NBITS cast_int(sizeof(lua_Integer) * CHAR_BIT) | | ------------------ | | | | 141| 206k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 206k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (783:9): [True: 60.5k, False: 145k] ------------------ 784| 145k| else return intop(<<, x, y); ------------------ | | 73| 145k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 145k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 785| 206k| } 786| 475k|} luaV_execute: 1151| 64|void luaV_execute (lua_State *L, CallInfo *ci) { 1152| 64| LClosure *cl; 1153| 64| TValue *k; 1154| 64| StkId base; 1155| 64| const Instruction *pc; 1156| 64| int trap; 1157| 64|#if LUA_USE_JUMPTABLE 1158| 64|#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| 64|#undef vmdispatch | | 9| 64|#undef vmcase | | 10| 64|#undef vmbreak | | 11| | | | 12| 64|#define vmdispatch(x) goto *disptab[x]; | | 13| | | | 14| 64|#define vmcase(l) L_##l: | | 15| | | | 16| 64|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | 17| | | | 18| | | | 19| 64|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| 64|&&L_OP_MOVE, | | 29| 64|&&L_OP_LOADI, | | 30| 64|&&L_OP_LOADF, | | 31| 64|&&L_OP_LOADK, | | 32| 64|&&L_OP_LOADKX, | | 33| 64|&&L_OP_LOADFALSE, | | 34| 64|&&L_OP_LFALSESKIP, | | 35| 64|&&L_OP_LOADTRUE, | | 36| 64|&&L_OP_LOADNIL, | | 37| 64|&&L_OP_GETUPVAL, | | 38| 64|&&L_OP_SETUPVAL, | | 39| 64|&&L_OP_GETTABUP, | | 40| 64|&&L_OP_GETTABLE, | | 41| 64|&&L_OP_GETI, | | 42| 64|&&L_OP_GETFIELD, | | 43| 64|&&L_OP_SETTABUP, | | 44| 64|&&L_OP_SETTABLE, | | 45| 64|&&L_OP_SETI, | | 46| 64|&&L_OP_SETFIELD, | | 47| 64|&&L_OP_NEWTABLE, | | 48| 64|&&L_OP_SELF, | | 49| 64|&&L_OP_ADDI, | | 50| 64|&&L_OP_ADDK, | | 51| 64|&&L_OP_SUBK, | | 52| 64|&&L_OP_MULK, | | 53| 64|&&L_OP_MODK, | | 54| 64|&&L_OP_POWK, | | 55| 64|&&L_OP_DIVK, | | 56| 64|&&L_OP_IDIVK, | | 57| 64|&&L_OP_BANDK, | | 58| 64|&&L_OP_BORK, | | 59| 64|&&L_OP_BXORK, | | 60| 64|&&L_OP_SHRI, | | 61| 64|&&L_OP_SHLI, | | 62| 64|&&L_OP_ADD, | | 63| 64|&&L_OP_SUB, | | 64| 64|&&L_OP_MUL, | | 65| 64|&&L_OP_MOD, | | 66| 64|&&L_OP_POW, | | 67| 64|&&L_OP_DIV, | | 68| 64|&&L_OP_IDIV, | | 69| 64|&&L_OP_BAND, | | 70| 64|&&L_OP_BOR, | | 71| 64|&&L_OP_BXOR, | | 72| 64|&&L_OP_SHL, | | 73| 64|&&L_OP_SHR, | | 74| 64|&&L_OP_MMBIN, | | 75| 64|&&L_OP_MMBINI, | | 76| 64|&&L_OP_MMBINK, | | 77| 64|&&L_OP_UNM, | | 78| 64|&&L_OP_BNOT, | | 79| 64|&&L_OP_NOT, | | 80| 64|&&L_OP_LEN, | | 81| 64|&&L_OP_CONCAT, | | 82| 64|&&L_OP_CLOSE, | | 83| 64|&&L_OP_TBC, | | 84| 64|&&L_OP_JMP, | | 85| 64|&&L_OP_EQ, | | 86| 64|&&L_OP_LT, | | 87| 64|&&L_OP_LE, | | 88| 64|&&L_OP_EQK, | | 89| 64|&&L_OP_EQI, | | 90| 64|&&L_OP_LTI, | | 91| 64|&&L_OP_LEI, | | 92| 64|&&L_OP_GTI, | | 93| 64|&&L_OP_GEI, | | 94| 64|&&L_OP_TEST, | | 95| 64|&&L_OP_TESTSET, | | 96| 64|&&L_OP_CALL, | | 97| 64|&&L_OP_TAILCALL, | | 98| 64|&&L_OP_RETURN, | | 99| 64|&&L_OP_RETURN0, | | 100| 64|&&L_OP_RETURN1, | | 101| 64|&&L_OP_FORLOOP, | | 102| 64|&&L_OP_FORPREP, | | 103| 64|&&L_OP_TFORPREP, | | 104| 64|&&L_OP_TFORCALL, | | 105| 64|&&L_OP_TFORLOOP, | | 106| 64|&&L_OP_SETLIST, | | 107| 64|&&L_OP_CLOSURE, | | 108| 64|&&L_OP_VARARG, | | 109| 64|&&L_OP_VARARGPREP, | | 110| 64|&&L_OP_EXTRAARG | | 111| | | | 112| 64|}; ------------------ 1159| 64|#endif 1160| 83.7k| startfunc: 1161| 83.7k| trap = L->hookmask; 1162| 167k| returning: /* trap already set */ 1163| 167k| cl = ci_func(ci); ------------------ | | 18| 167k|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 602| 167k|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 167k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1164| 167k| k = cl->p->k; 1165| 167k| pc = ci->u.l.savedpc; 1166| 167k| if (l_unlikely(trap)) ------------------ | | 697| 167k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 167k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 167k] | | | | ------------------ | | ------------------ ------------------ 1167| 0| trap = luaG_tracecall(L); 1168| 167k| base = ci->func.p + 1; 1169| | /* main loop of interpreter */ 1170| 167k| for (;;) { 1171| 167k| Instruction i; /* instruction being executed */ 1172| 167k| vmfetch(); ------------------ | | 1138| 167k|#define vmfetch() { \ | | 1139| 167k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | ------------------ | | | | 697| 167k|#define l_unlikely(x) luai_unlikely(x) | | | | ------------------ | | | | | | 685| 167k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | ------------------ | | | | | | | Branch (685:26): [True: 0, False: 167k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 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| 167k| i = *(pc++); \ | | 1144| 167k|} ------------------ 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| 167k| lua_assert(base == ci->func.p + 1); ------------------ | | 114| 167k|#define lua_assert(c) ((void)0) ------------------ 1178| 167k| lua_assert(base <= L->top.p && L->top.p <= L->stack_last.p); ------------------ | | 114| 167k|#define lua_assert(c) ((void)0) ------------------ 1179| | /* invalidate top for instructions not expecting it */ 1180| 167k| lua_assert(isIT(i) || (cast_void(L->top.p = base), 1)); ------------------ | | 114| 167k|#define lua_assert(c) ((void)0) ------------------ 1181| 167k| vmdispatch (GET_OPCODE(i)) { ------------------ | | 12| 167k|#define vmdispatch(x) goto *disptab[x]; ------------------ 1182| 1.19M| vmcase(OP_MOVE) { ------------------ | | 14| 1.19M|#define vmcase(l) L_##l: ------------------ 1183| 1.19M| StkId ra = RA(i); ------------------ | | 1064| 1.19M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1.19M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1.19M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 1.19M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1.19M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1184| 1.19M| setobjs2s(L, ra, RB(i)); ------------------ | | 129| 1.19M|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 1.19M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 1.19M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 1.19M|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 1.19M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 1.19M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 1.19M|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 1.19M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 1.19M|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1185| 1.19M| vmbreak; ------------------ | | 16| 1.19M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 1.19M|#define vmfetch() { \ | | | | 1139| 1.19M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.19M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.19M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1.19M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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.19M| i = *(pc++); \ | | | | 1144| 1.19M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.19M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1186| 1.19M| } 1187| 1.19M| vmcase(OP_LOADI) { ------------------ | | 14| 284k|#define vmcase(l) L_##l: ------------------ 1188| 284k| StkId ra = RA(i); ------------------ | | 1064| 284k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 284k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 284k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 284k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 284k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1189| 284k| lua_Integer b = GETARG_sBx(i); ------------------ | | 147| 284k| check_exp(checkopm(i, iAsBx), getarg(i, POS_Bx, SIZE_Bx) - OFFSET_sBx) | | ------------------ | | | | 115| 284k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1190| 284k| setivalue(s2v(ra), b); ------------------ | | 345| 284k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 284k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 284k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1191| 284k| vmbreak; ------------------ | | 16| 284k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 284k|#define vmfetch() { \ | | | | 1139| 284k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 284k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 284k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 284k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 284k| i = *(pc++); \ | | | | 1144| 284k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 284k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1192| 284k| } 1193| 284k| vmcase(OP_LOADF) { ------------------ | | 14| 40.0k|#define vmcase(l) L_##l: ------------------ 1194| 40.0k| StkId ra = RA(i); ------------------ | | 1064| 40.0k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 40.0k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 40.0k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 40.0k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 40.0k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1195| 40.0k| int b = GETARG_sBx(i); ------------------ | | 147| 40.0k| check_exp(checkopm(i, iAsBx), getarg(i, POS_Bx, SIZE_Bx) - OFFSET_sBx) | | ------------------ | | | | 115| 40.0k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1196| 40.0k| setfltvalue(s2v(ra), cast_num(b)); ------------------ | | 339| 40.0k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 40.0k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 40.0k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1197| 40.0k| vmbreak; ------------------ | | 16| 40.0k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 40.0k|#define vmfetch() { \ | | | | 1139| 40.0k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 40.0k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 40.0k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 40.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| 40.0k| i = *(pc++); \ | | | | 1144| 40.0k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 40.0k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1198| 40.0k| } 1199| 273k| vmcase(OP_LOADK) { ------------------ | | 14| 273k|#define vmcase(l) L_##l: ------------------ 1200| 273k| StkId ra = RA(i); ------------------ | | 1064| 273k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 273k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 273k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 273k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 273k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1201| 273k| TValue *rb = k + GETARG_Bx(i); ------------------ | | 140| 273k|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 115| 273k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1202| 273k| setobj2s(L, ra, rb); ------------------ | | 131| 273k|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 273k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 273k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 273k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 273k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 273k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 273k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 273k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 273k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1203| 273k| vmbreak; ------------------ | | 16| 273k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 273k|#define vmfetch() { \ | | | | 1139| 273k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 273k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 273k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 273k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 273k| i = *(pc++); \ | | | | 1144| 273k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 273k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1204| 273k| } 1205| 273k| 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)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 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) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 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| 746k| vmcase(OP_LFALSESKIP) { ------------------ | | 14| 746k|#define vmcase(l) L_##l: ------------------ 1218| 746k| StkId ra = RA(i); ------------------ | | 1064| 746k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 746k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 746k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 746k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 746k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1219| 746k| setbfvalue(s2v(ra)); ------------------ | | 250| 746k|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 746k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1220| 746k| pc++; /* skip next instruction */ 1221| 746k| vmbreak; ------------------ | | 16| 746k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 746k|#define vmfetch() { \ | | | | 1139| 746k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 746k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 746k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 746k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 746k| i = *(pc++); \ | | | | 1144| 746k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 746k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1222| 746k| } 1223| 746k| vmcase(OP_LOADTRUE) { ------------------ | | 14| 307k|#define vmcase(l) L_##l: ------------------ 1224| 307k| StkId ra = RA(i); ------------------ | | 1064| 307k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 307k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 307k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 307k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 307k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1225| 307k| setbtvalue(s2v(ra)); ------------------ | | 251| 307k|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 307k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1226| 307k| vmbreak; ------------------ | | 16| 307k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 307k|#define vmfetch() { \ | | | | 1139| 307k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 307k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 307k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 307k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 307k| i = *(pc++); \ | | | | 1144| 307k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 307k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1227| 307k| } 1228| 307k| vmcase(OP_LOADNIL) { ------------------ | | 14| 17.2k|#define vmcase(l) L_##l: ------------------ 1229| 17.2k| StkId ra = RA(i); ------------------ | | 1064| 17.2k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 17.2k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 17.2k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 17.2k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 17.2k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1230| 17.2k| int b = GETARG_B(i); ------------------ | | 128| 17.2k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 17.2k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1231| 94.9k| do { 1232| 94.9k| setnilvalue(s2v(ra++)); ------------------ | | 200| 94.9k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 94.9k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1233| 94.9k| } while (b--); ------------------ | Branch (1233:18): [True: 77.7k, False: 17.2k] ------------------ 1234| 17.2k| vmbreak; ------------------ | | 16| 17.2k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 17.2k|#define vmfetch() { \ | | | | 1139| 17.2k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 17.2k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 17.2k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 17.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| 17.2k| i = *(pc++); \ | | | | 1144| 17.2k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 17.2k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1235| 17.2k| } 1236| 457k| vmcase(OP_GETUPVAL) { ------------------ | | 14| 457k|#define vmcase(l) L_##l: ------------------ 1237| 457k| StkId ra = RA(i); ------------------ | | 1064| 457k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 457k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 457k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 457k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 457k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1238| 457k| int b = GETARG_B(i); ------------------ | | 128| 457k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 457k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1239| 457k| setobj2s(L, ra, cl->upvals[b]->v.p); ------------------ | | 131| 457k|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 457k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 457k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 457k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 457k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 457k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 457k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 457k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 457k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1240| 457k| vmbreak; ------------------ | | 16| 457k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 457k|#define vmfetch() { \ | | | | 1139| 457k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 457k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 457k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 457k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 457k| i = *(pc++); \ | | | | 1144| 457k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 457k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1241| 457k| } 1242| 457k| vmcase(OP_SETUPVAL) { ------------------ | | 14| 5.56k|#define vmcase(l) L_##l: ------------------ 1243| 5.56k| StkId ra = RA(i); ------------------ | | 1064| 5.56k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 5.56k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 5.56k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 5.56k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 5.56k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1244| 5.56k| UpVal *uv = cl->upvals[GETARG_B(i)]; ------------------ | | 128| 5.56k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 5.56k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1245| 5.56k| setobj(L, uv->v.p, s2v(ra)); ------------------ | | 119| 5.56k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 5.56k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 5.56k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 5.56k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 5.56k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 5.56k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 5.56k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 5.56k|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 1246| 5.56k| luaC_barrier(L, uv, s2v(ra)); ------------------ | | 179| 5.56k|#define luaC_barrier(L,p,v) ( \ | | 180| 5.56k| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 5.56k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 5.56k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 5.56k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 556, False: 5.00k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 556|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 556| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 556|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 556|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 1.11k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 556] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (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| 556| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 556|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 556|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 5.00k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 5.00k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1247| 5.56k| vmbreak; ------------------ | | 16| 5.56k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 5.56k|#define vmfetch() { \ | | | | 1139| 5.56k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 5.56k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 5.56k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 5.56k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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.56k| i = *(pc++); \ | | | | 1144| 5.56k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 5.56k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1248| 5.56k| } 1249| 1.42M| vmcase(OP_GETTABUP) { ------------------ | | 14| 1.42M|#define vmcase(l) L_##l: ------------------ 1250| 1.42M| StkId ra = RA(i); ------------------ | | 1064| 1.42M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1.42M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1.42M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 1.42M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1.42M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1251| 1.42M| const TValue *slot; 1252| 1.42M| TValue *upval = cl->upvals[GETARG_B(i)]->v.p; ------------------ | | 128| 1.42M|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 1.42M|#define check_exp(c,e) (e) | | ------------------ ------------------ 1253| 1.42M| TValue *rc = KC(i); ------------------ | | 1070| 1.42M|#define KC(i) (k+GETARG_C(i)) | | ------------------ | | | | 132| 1.42M|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 1.42M|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1254| 1.42M| TString *key = tsvalue(rc); /* key must be a short string */ ------------------ | | 369| 1.42M|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 1.42M|#define check_exp(c,e) (e) | | ------------------ ------------------ 1255| 1.42M| if (luaV_fastget(L, upval, key, slot, luaH_getshortstr)) { ------------------ | | 86| 1.42M| (!ttistable(t) \ | | ------------------ | | | | 680| 1.42M|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 1.42M|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 1.42M|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 86.5k, False: 1.34M] | | | Branch (86:4): [True: 0, False: 1.42M] | | ------------------ | | 87| 1.42M| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 1.42M| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 1.42M|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 1.42M|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 1.42M| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 1.42M|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 1.42M|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 1.42M|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 1.42M|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 1.42M|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1256| 86.5k| setobj2s(L, ra, slot); ------------------ | | 131| 86.5k|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 86.5k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 86.5k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 86.5k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 86.5k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 86.5k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 86.5k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 86.5k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 86.5k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1257| 86.5k| } 1258| 1.34M| else 1259| 1.34M| Protect(luaV_finishget(L, upval, rc, ra, slot)); ------------------ | | 1119| 1.34M|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 1.34M|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 1.34M|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 1.34M|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1260| 1.42M| vmbreak; ------------------ | | 16| 1.42M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 1.42M|#define vmfetch() { \ | | | | 1139| 1.42M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.42M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.42M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1.42M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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.42M| i = *(pc++); \ | | | | 1144| 1.42M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.42M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1261| 1.42M| } 1262| 1.42M| vmcase(OP_GETTABLE) { ------------------ | | 14| 8.01k|#define vmcase(l) L_##l: ------------------ 1263| 8.01k| StkId ra = RA(i); ------------------ | | 1064| 8.01k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 8.01k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 8.01k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 8.01k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 8.01k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1264| 8.01k| const TValue *slot; 1265| 8.01k| TValue *rb = vRB(i); ------------------ | | 1066| 8.01k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 8.01k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1266| 8.01k| TValue *rc = vRC(i); ------------------ | | 1069| 8.01k|#define vRC(i) s2v(RC(i)) | | ------------------ | | | | 172| 8.01k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1267| 8.01k| lua_Unsigned n; 1268| | if (ttisinteger(rc) /* fast track for integers? */ ------------------ | | 328| 8.01k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 16.0k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 8.01k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 8.01k] | | | | ------------------ | | ------------------ ------------------ | Branch (1268:13): [True: 0, False: 8.01k] ------------------ 1269| 8.01k| ? (cast_void(n = ivalue(rc)), luaV_fastgeti(L, rb, n, slot)) ------------------ | | 138| 0|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ ? (cast_void(n = ivalue(rc)), luaV_fastgeti(L, rb, n, slot)) ------------------ | | 97| 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 (97:4): [True: 0, False: 0] | | ------------------ | | 98| 0| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 99| 0| : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 152| 0|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (99:14): [True: 0, False: 0] | | ------------------ | | 100| 0| ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 101| 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) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1270| 8.01k| : luaV_fastget(L, rb, rc, slot, luaH_get)) { ------------------ | | 86| 8.01k| (!ttistable(t) \ | | ------------------ | | | | 680| 8.01k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 8.01k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 8.01k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:4): [True: 0, False: 8.01k] | | ------------------ | | 87| 8.01k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 8.01k| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 8.01k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 8.01k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 8.01k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 8.01k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 8.01k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 8.01k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 8.01k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 8.01k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1271| 0| setobj2s(L, ra, slot); ------------------ | | 131| 0|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1272| 0| } 1273| 8.01k| else 1274| 8.01k| Protect(luaV_finishget(L, rb, rc, ra, slot)); ------------------ | | 1119| 8.01k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 8.01k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 8.01k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 8.01k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1275| 8.01k| vmbreak; ------------------ | | 16| 8.01k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 8.01k|#define vmfetch() { \ | | | | 1139| 8.01k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 8.01k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 8.01k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 8.01k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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.01k| i = *(pc++); \ | | | | 1144| 8.01k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 8.01k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1276| 8.01k| } 1277| 8.01k| vmcase(OP_GETI) { ------------------ | | 14| 2|#define vmcase(l) L_##l: ------------------ 1278| 2| StkId ra = RA(i); ------------------ | | 1064| 2|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 2|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 2|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 2|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 2|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1279| 2| const TValue *slot; 1280| 2| TValue *rb = vRB(i); ------------------ | | 1066| 2|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 2|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1281| 2| int c = GETARG_C(i); ------------------ | | 132| 2|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 2|#define check_exp(c,e) (e) | | ------------------ ------------------ 1282| 2| if (luaV_fastgeti(L, rb, c, slot)) { ------------------ | | 97| 2| (!ttistable(t) \ | | ------------------ | | | | 680| 2|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 2|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 2|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (97:3): [True: 0, False: 2] | | | Branch (97:4): [True: 0, False: 2] | | ------------------ | | 98| 2| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 99| 2| : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 152| 2|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 682| 2|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 2|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (99:14): [True: 0, False: 2] | | ------------------ | | 100| 2| ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 2|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 2|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 101| 2| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 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) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1283| 0| setobj2s(L, ra, slot); ------------------ | | 131| 0|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1284| 0| } 1285| 2| else { 1286| 2| TValue key; 1287| 2| setivalue(&key, c); ------------------ | | 345| 2| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 2|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 2|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1288| 2| Protect(luaV_finishget(L, rb, &key, ra, slot)); ------------------ | | 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) | | ------------------ ------------------ 1289| 2| } 1290| 2| vmbreak; ------------------ | | 16| 2|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 2|#define vmfetch() { \ | | | | 1139| 2| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 2|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 2|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| i = *(pc++); \ | | | | 1144| 2|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 2|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1291| 2| } 1292| 4| vmcase(OP_GETFIELD) { ------------------ | | 14| 4|#define vmcase(l) L_##l: ------------------ 1293| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1294| 4| const TValue *slot; 1295| 4| TValue *rb = vRB(i); ------------------ | | 1066| 4|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 4|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1296| 4| TValue *rc = KC(i); ------------------ | | 1070| 4|#define KC(i) (k+GETARG_C(i)) | | ------------------ | | | | 132| 4|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 4|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1297| 4| TString *key = tsvalue(rc); /* key must be a short string */ ------------------ | | 369| 4|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 4|#define check_exp(c,e) (e) | | ------------------ ------------------ 1298| 4| if (luaV_fastget(L, rb, key, slot, luaH_getshortstr)) { ------------------ | | 86| 4| (!ttistable(t) \ | | ------------------ | | | | 680| 4|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 4|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 4|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 4] | | | Branch (86:4): [True: 1, False: 3] | | ------------------ | | 87| 4| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 4| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 3|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 3|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 3| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 3|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 3|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 3|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 3|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 3|#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) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1300| 0| } 1301| 4| else 1302| 4| Protect(luaV_finishget(L, rb, rc, ra, 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) | | ------------------ ------------------ 1303| 4| 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]; | | ------------------ ------------------ 1304| 4| } 1305| 839k| vmcase(OP_SETTABUP) { ------------------ | | 14| 839k|#define vmcase(l) L_##l: ------------------ 1306| 839k| const TValue *slot; 1307| 839k| TValue *upval = cl->upvals[GETARG_A(i)]->v.p; ------------------ | | 125| 839k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 839k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 839k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 839k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1308| 839k| TValue *rb = KB(i); ------------------ | | 1067| 839k|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 839k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 115| 839k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1309| 839k| TValue *rc = RKC(i); ------------------ | | 1071| 839k|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 839k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 115| 839k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 2.88k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 2.88k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 836k|#define s2v(o) (&(o)->val) | | ------------------ | | | Branch (1071:17): [True: 2.88k, False: 836k] | | ------------------ ------------------ 1310| 839k| TString *key = tsvalue(rb); /* key must be a short string */ ------------------ | | 369| 839k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 839k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1311| 839k| if (luaV_fastget(L, upval, key, slot, luaH_getshortstr)) { ------------------ | | 86| 839k| (!ttistable(t) \ | | ------------------ | | | | 680| 839k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 839k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 839k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 616k, False: 222k] | | | Branch (86:4): [True: 0, False: 839k] | | ------------------ | | 87| 839k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 839k| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 839k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 839k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 839k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 839k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 839k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 839k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 839k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 839k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1312| 616k| luaV_finishfastset(L, upval, slot, rc); ------------------ | | 109| 616k| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 616k|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 616k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 616k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 616k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 616k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 616k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 116| 616k|#define lua_longassert(c) ((void)0) | | | | | | | | ------------------ | | | | | | | | 108| 616k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 114| 616k|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 616k| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 616k|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 616k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 616k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 616k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 616k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 83.3k, False: 533k] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 83.3k|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 83.3k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 83.3k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 83.3k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 166k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 0, False: 83.3k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 83.3k|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 83.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 533k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 533k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1313| 616k| } 1314| 222k| else 1315| 222k| Protect(luaV_finishset(L, upval, rb, rc, slot)); ------------------ | | 1119| 222k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 222k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 222k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 222k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1316| 839k| vmbreak; ------------------ | | 16| 839k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 839k|#define vmfetch() { \ | | | | 1139| 839k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 839k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 839k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 10, False: 839k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 839k| i = *(pc++); \ | | | | 1144| 839k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 839k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1317| 839k| } 1318| 839k| vmcase(OP_SETTABLE) { ------------------ | | 14| 220k|#define vmcase(l) L_##l: ------------------ 1319| 220k| StkId ra = RA(i); ------------------ | | 1064| 220k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 220k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 220k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 220k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 220k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1320| 220k| const TValue *slot; 1321| 220k| TValue *rb = vRB(i); /* key (table is in 'ra') */ ------------------ | | 1066| 220k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 220k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1322| 220k| TValue *rc = RKC(i); /* value */ ------------------ | | 1071| 220k|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 220k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 115| 220k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 7.76k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 7.76k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 212k|#define s2v(o) (&(o)->val) | | ------------------ | | | Branch (1071:17): [True: 7.76k, False: 212k] | | ------------------ ------------------ 1323| 220k| lua_Unsigned n; 1324| | if (ttisinteger(rb) /* fast track for integers? */ ------------------ | | 328| 220k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 440k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 220k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 209k, False: 10.6k] | | | | ------------------ | | ------------------ ------------------ | Branch (1324:13): [True: 202k, False: 17.8k] ------------------ 1325| 220k| ? (cast_void(n = ivalue(rb)), luaV_fastgeti(L, s2v(ra), n, slot)) ------------------ | | 138| 209k|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 209k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ ? (cast_void(n = ivalue(rb)), luaV_fastgeti(L, s2v(ra), n, slot)) ------------------ | | 97| 209k| (!ttistable(t) \ | | ------------------ | | | | 680| 209k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 209k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 209k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (97:4): [True: 0, False: 209k] | | ------------------ | | 98| 209k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 99| 209k| : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 152| 209k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 682| 209k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 209k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (99:14): [True: 240, False: 209k] | | ------------------ | | 100| 209k| ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 240|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 240|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 209k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 209k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 101| 209k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 209k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 209k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 209k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 209k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 209k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1326| 220k| : luaV_fastget(L, s2v(ra), rb, slot, luaH_get)) { ------------------ | | 86| 10.6k| (!ttistable(t) \ | | ------------------ | | | | 680| 10.6k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 10.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 10.6k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:4): [True: 0, False: 10.6k] | | ------------------ | | 87| 10.6k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 10.6k| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 10.6k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 10.6k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 10.6k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 10.6k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 10.6k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 10.6k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 10.6k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 10.6k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1327| 202k| luaV_finishfastset(L, s2v(ra), slot, rc); ------------------ | | 109| 202k| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 202k|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 202k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 202k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 202k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 202k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 202k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 116| 202k|#define lua_longassert(c) ((void)0) | | | | | | | | ------------------ | | | | | | | | 108| 202k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 114| 202k|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 202k| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 202k|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 202k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 202k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 202k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 202k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 10.3k, False: 192k] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 10.3k|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 10.3k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 10.3k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 10.3k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 20.7k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 0, False: 10.3k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 10.3k|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 10.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 192k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 192k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1328| 202k| } 1329| 17.8k| else 1330| 17.8k| Protect(luaV_finishset(L, s2v(ra), rb, rc, slot)); ------------------ | | 1119| 17.8k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 17.8k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 17.8k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 17.8k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1331| 220k| vmbreak; ------------------ | | 16| 220k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 220k|#define vmfetch() { \ | | | | 1139| 220k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 220k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 220k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 220k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 220k| i = *(pc++); \ | | | | 1144| 220k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 220k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1332| 220k| } 1333| 220k| vmcase(OP_SETI) { ------------------ | | 14| 215k|#define vmcase(l) L_##l: ------------------ 1334| 215k| StkId ra = RA(i); ------------------ | | 1064| 215k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 215k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 215k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 215k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 215k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1335| 215k| const TValue *slot; 1336| 215k| int c = GETARG_B(i); ------------------ | | 128| 215k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 215k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1337| 215k| TValue *rc = RKC(i); ------------------ | | 1071| 215k|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 215k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 115| 215k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 201k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 201k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 13.2k|#define s2v(o) (&(o)->val) | | ------------------ | | | Branch (1071:17): [True: 201k, False: 13.2k] | | ------------------ ------------------ 1338| 215k| if (luaV_fastgeti(L, s2v(ra), c, slot)) { ------------------ | | 97| 215k| (!ttistable(t) \ | | ------------------ | | | | 680| 215k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 215k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 215k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (97:3): [True: 209k, False: 5.45k] | | | Branch (97:4): [True: 0, False: 215k] | | ------------------ | | 98| 215k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 99| 215k| : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 152| 215k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 682| 215k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 215k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (99:14): [True: 21.6k, False: 193k] | | ------------------ | | 100| 215k| ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 21.6k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 21.6k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 682| 193k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 193k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 101| 215k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 215k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 215k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 215k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 215k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 215k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1339| 209k| luaV_finishfastset(L, s2v(ra), slot, rc); ------------------ | | 109| 209k| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 209k|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 209k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 209k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 209k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 209k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 209k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 116| 209k|#define lua_longassert(c) ((void)0) | | | | | | | | ------------------ | | | | | | | | 108| 209k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 114| 209k|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 209k| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 209k|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 209k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 209k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 209k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 209k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 209k] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 0|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 0| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 209k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 209k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1340| 209k| } 1341| 5.45k| else { 1342| 5.45k| TValue key; 1343| 5.45k| setivalue(&key, c); ------------------ | | 345| 5.45k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 5.45k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 5.45k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1344| 5.45k| Protect(luaV_finishset(L, s2v(ra), &key, rc, slot)); ------------------ | | 1119| 5.45k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 5.45k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 5.45k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 5.45k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1345| 5.45k| } 1346| 215k| vmbreak; ------------------ | | 16| 215k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 215k|#define vmfetch() { \ | | | | 1139| 215k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 215k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 215k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 215k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 215k| i = *(pc++); \ | | | | 1144| 215k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 215k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1347| 215k| } 1348| 215k| vmcase(OP_SETFIELD) { ------------------ | | 14| 1|#define vmcase(l) L_##l: ------------------ 1349| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1350| 1| const TValue *slot; 1351| 1| TValue *rb = 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)) | | | | ------------------ | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1352| 1| TValue *rc = RKC(i); ------------------ | | 1071| 1|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 1|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 1|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 0|#define s2v(o) (&(o)->val) | | ------------------ | | | Branch (1071:17): [True: 1, False: 0] | | ------------------ ------------------ 1353| 1| TString *key = tsvalue(rb); /* key must be a short string */ ------------------ | | 369| 1|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 1|#define check_exp(c,e) (e) | | ------------------ ------------------ 1354| 1| if (luaV_fastget(L, s2v(ra), key, slot, luaH_getshortstr)) { ------------------ | | 86| 1| (!ttistable(t) \ | | ------------------ | | | | 680| 1|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 1|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 1|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 1] | | | Branch (86:4): [True: 0, False: 1] | | ------------------ | | 87| 1| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 1| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 682| 1|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 1| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 1|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 1|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 1|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 1|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 1|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1355| 0| luaV_finishfastset(L, s2v(ra), slot, rc); ------------------ | | 109| 0| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 0|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | | | ------------------ | | | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 0| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 0|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 0| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 0|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 0| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1356| 0| } 1357| 1| else 1358| 1| Protect(luaV_finishset(L, s2v(ra), rb, rc, slot)); ------------------ | | 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) | | ------------------ ------------------ 1359| 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]; | | ------------------ ------------------ 1360| 1| } 1361| 8.00k| vmcase(OP_NEWTABLE) { ------------------ | | 14| 8.00k|#define vmcase(l) L_##l: ------------------ 1362| 8.00k| StkId ra = RA(i); ------------------ | | 1064| 8.00k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 8.00k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 8.00k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 8.00k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 8.00k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1363| 8.00k| int b = GETARG_B(i); /* log2(hash size) + 1 */ ------------------ | | 128| 8.00k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 8.00k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1364| 8.00k| int c = GETARG_C(i); /* array size */ ------------------ | | 132| 8.00k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 8.00k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1365| 8.00k| Table *t; 1366| 8.00k| if (b > 0) ------------------ | Branch (1366:13): [True: 0, False: 8.00k] ------------------ 1367| 0| b = 1 << (b - 1); /* size is 2^(b - 1) */ 1368| 8.00k| lua_assert((!TESTARG_k(i)) == (GETARG_Ax(*pc) == 0)); ------------------ | | 114| 8.00k|#define lua_assert(c) ((void)0) ------------------ 1369| 8.00k| if (TESTARG_k(i)) /* non-zero extra argument? */ ------------------ | | 136| 8.00k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 115| 8.00k|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:25): [True: 0, False: 8.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)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ c += GETARG_Ax(*pc) * (MAXARG_C + 1); /* add it to size */ ------------------ | | 97| 0|#define MAXARG_C ((1<top.p = ra + 1; /* correct top in case of emergency GC */ 1373| 8.00k| t = luaH_new(L); /* memory allocation */ 1374| 8.00k| sethvalue2s(L, ra, t); ------------------ | | 689| 8.00k|#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) | | ------------------ | | | | 685| 8.00k| { TValue *io = (obj); Table *x_ = (x); \ | | | | 686| 8.00k| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 72| 8.00k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 390| 8.00k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 8.00k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 114| 8.00k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 687| 8.00k| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 8.00k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 8.00k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 8.00k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1375| 8.00k| if (b != 0 || c != 0) ------------------ | Branch (1375:13): [True: 0, False: 8.00k] | Branch (1375:23): [True: 8.00k, False: 0] ------------------ 1376| 8.00k| luaH_resize(L, t, c, b); /* idem */ 1377| 8.00k| checkGC(L, ra + 1); ------------------ | | 1132| 8.00k| { luaC_condGC(L, (savepc(L), L->top.p = (c)), \ | | ------------------ | | | | 168| 8.00k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 8.00k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 3, False: 8.00k] | | | | ------------------ | | | | 169| 8.00k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 8.00k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 1133| 8.00k| updatetrap(ci)); \ | | 1134| 8.00k| luai_threadyield(L); } | | ------------------ | | | | 273| 8.00k|#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 265| 8.00k|#define lua_unlock(L) ((void) 0) | | | | ------------------ | | | | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 264| 8.00k|#define lua_lock(L) ((void) 0) | | | | ------------------ | | ------------------ ------------------ 1378| 8.00k| vmbreak; ------------------ | | 16| 8.00k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 8.00k|#define vmfetch() { \ | | | | 1139| 8.00k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 8.00k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 8.00k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 8.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| 8.00k| i = *(pc++); \ | | | | 1144| 8.00k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 8.00k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1379| 8.00k| } 1380| 8.00k| 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) | | ------------------ ------------------ 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))))) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 0|#define s2v(o) (&(o)->val) | | ------------------ | | | 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)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 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) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 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)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 0| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 0|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 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) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 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| 394k| vmcase(OP_ADDI) { ------------------ | | 14| 394k|#define vmcase(l) L_##l: ------------------ 1395| 394k| op_arithI(L, l_addi, luai_numadd); ------------------ | | 905| 394k|#define op_arithI(L,iop,fop) { \ | | 906| 394k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 394k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 394k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 394k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 394k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 394k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 907| 394k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 394k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 394k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 908| 394k| int imm = GETARG_sC(i); \ | | ------------------ | | | | 133| 394k|#define GETARG_sC(i) sC2int(GETARG_C(i)) | | | | ------------------ | | | | | | 101| 394k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 394k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 394k|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 313k, False: 80.7k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 910| 313k| lua_Integer iv1 = ivalue(v1); \ | | ------------------ | | | | 333| 313k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 313k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 911| 313k| pc++; setivalue(s2v(ra), iop(L, iv1, imm)); \ | | ------------------ | | | | 345| 313k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 313k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 313k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 912| 313k| } \ | | 913| 394k| else if (ttisfloat(v1)) { \ | | ------------------ | | | | 327| 80.7k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 80.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 80.7k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 80.7k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 914| 80.7k| lua_Number nb = fltvalue(v1); \ | | ------------------ | | | | 332| 80.7k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 80.7k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 915| 80.7k| lua_Number fimm = cast_num(imm); \ | | ------------------ | | | | 140| 80.7k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 80.7k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 916| 80.7k| pc++; setfltvalue(s2v(ra), fop(L, nb, fimm)); \ | | ------------------ | | | | 339| 80.7k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | ------------------ | | | | | | 72| 80.7k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | ------------------ | | | | | | 114| 80.7k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 917| 80.7k| }} ------------------ 1396| 394k| vmbreak; ------------------ | | 16| 394k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 394k|#define vmfetch() { \ | | | | 1139| 394k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 394k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 394k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 394k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 394k| i = *(pc++); \ | | | | 1144| 394k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 394k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1397| 394k| } 1398| 394k| vmcase(OP_ADDK) { ------------------ | | 14| 13.3k|#define vmcase(l) L_##l: ------------------ 1399| 13.3k| op_arithK(L, l_addi, luai_numadd); ------------------ | | 975| 13.3k|#define op_arithK(L,iop,fop) { \ | | 976| 13.3k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 13.3k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 13.3k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 977| 13.3k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1070| 13.3k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 13.3k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 13.3k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 13.3k|#define lua_assert(c) ((void)0) | | ------------------ | | 978| 13.3k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 13.3k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 13.3k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 13.3k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 13.3k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 13.3k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 13.3k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 13.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 13.3k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 13.3k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 26.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 13.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 10.7k, False: 2.59k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 10.7k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 10.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 10.7k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 0, False: 10.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 0| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 958| 0| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 0| } \ | | | | 960| 13.3k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 13.3k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 13.3k| lua_Number n1; lua_Number n2; \ | | | | | | 926| 13.3k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 26.6k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 13.3k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 13.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 13.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 2.59k, False: 10.7k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 2.59k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 2.59k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 13.3k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 26.6k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 10.7k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 10.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 10.7k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 10.7k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 10.7k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 10.7k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 13.3k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 13.3k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 13.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 13.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 10.7k, False: 2.59k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 10.7k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 10.7k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 13.3k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 13.3k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 2.59k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 2.59k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 2.59k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 2.59k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 2.59k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 2.59k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 13.3k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 13.3k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 13.3k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 13.3k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 13.3k| }} | | | | ------------------ | | ------------------ ------------------ 1400| 13.3k| vmbreak; ------------------ | | 16| 13.3k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 13.3k|#define vmfetch() { \ | | | | 1139| 13.3k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 13.3k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 13.3k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 13.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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.3k| i = *(pc++); \ | | | | 1144| 13.3k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 13.3k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1401| 13.3k| } 1402| 13.3k| vmcase(OP_SUBK) { ------------------ | | 14| 306|#define vmcase(l) L_##l: ------------------ 1403| 306| op_arithK(L, l_subi, luai_numsub); ------------------ | | 975| 306|#define op_arithK(L,iop,fop) { \ | | 976| 306| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 306|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 306|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 977| 306| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1070| 306|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 306|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 306|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 306|#define lua_assert(c) ((void)0) | | ------------------ | | 978| 306| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 306|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 306| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 306|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 306|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 306|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 306|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 306|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 306| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 306|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 612|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 306|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 0, False: 306] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 0| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 958| 0| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 0| } \ | | | | 960| 306| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 306|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 306| lua_Number n1; lua_Number n2; \ | | | | | | 926| 306| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 612| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 306|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 306|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 306|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 306, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 306|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 306|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 306, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 612| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 0|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 306| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 306|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 306|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 306|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 306, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 306|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 306|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 306, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 306| (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)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 306| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 306| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 306|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 306|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 306| }} | | | | ------------------ | | ------------------ ------------------ 1404| 306| vmbreak; ------------------ | | 16| 306|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 306|#define vmfetch() { \ | | | | 1139| 306| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 306|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 306|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 306] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 306| i = *(pc++); \ | | | | 1144| 306|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 306|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1405| 306| } 1406| 282k| vmcase(OP_MULK) { ------------------ | | 14| 282k|#define vmcase(l) L_##l: ------------------ 1407| 282k| op_arithK(L, l_muli, luai_nummul); ------------------ | | 975| 282k|#define op_arithK(L,iop,fop) { \ | | 976| 282k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 282k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 282k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 977| 282k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1070| 282k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 282k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 282k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 282k|#define lua_assert(c) ((void)0) | | ------------------ | | 978| 282k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 282k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 282k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 282k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 282k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 282k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 282k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 282k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 282k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 282k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 565k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 282k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 274k, False: 8.16k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 274k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 274k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 274k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 274k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 274k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 274k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 274k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 274k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 274k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 958| 274k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 274k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 274k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 274k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 274k| } \ | | | | 960| 282k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 8.16k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 8.16k| lua_Number n1; lua_Number n2; \ | | | | | | 926| 8.16k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 16.3k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 8.16k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 8.16k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 8.16k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 8.16k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 8.16k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 8.16k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 8.16k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 16.3k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 0|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 8.16k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 8.16k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 8.16k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 8.16k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 8.00k, False: 153] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 8.00k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 8.00k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 8.16k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 8.16k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 153|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 153|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 153|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 153, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 153|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 153|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 8.16k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 8.16k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 8.16k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 8.16k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 8.16k| }} | | | | ------------------ | | ------------------ ------------------ 1408| 282k| vmbreak; ------------------ | | 16| 282k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 282k|#define vmfetch() { \ | | | | 1139| 282k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 282k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 282k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 282k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 282k| i = *(pc++); \ | | | | 1144| 282k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 282k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1409| 282k| } 1410| 282k| vmcase(OP_MODK) { ------------------ | | 14| 21.2k|#define vmcase(l) L_##l: ------------------ 1411| 21.2k| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1112| 21.2k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1105| 21.2k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1412| 21.2k| op_arithK(L, luaV_mod, luaV_modf); ------------------ | | 975| 21.2k|#define op_arithK(L,iop,fop) { \ | | 976| 21.2k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 21.2k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 21.2k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 977| 21.2k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1070| 21.2k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 21.2k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 21.2k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 21.2k|#define lua_assert(c) ((void)0) | | ------------------ | | 978| 21.2k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 21.2k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 21.2k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 21.2k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 21.2k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 21.2k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 21.2k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 21.2k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 21.2k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 21.2k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 42.5k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 21.2k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 18.6k, False: 2.61k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 18.6k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 18.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 18.6k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 16.0k, False: 2.59k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 16.0k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 16.0k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 16.0k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 16.0k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 16.0k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 958| 16.0k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 16.0k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 16.0k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 16.0k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 16.0k| } \ | | | | 960| 21.2k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 5.20k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 5.20k| lua_Number n1; lua_Number n2; \ | | | | | | 926| 5.20k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 10.4k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 5.20k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 5.20k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 5.20k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 2.61k, False: 2.59k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 2.61k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 2.61k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 5.20k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 10.4k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 2.59k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 2.59k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 2.59k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 2.59k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 2.59k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 2.59k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 5.20k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 5.20k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 5.20k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 5.20k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 2.59k, False: 2.61k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 2.59k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 2.59k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 5.20k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 5.20k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 2.61k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 2.61k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 2.61k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 2.61k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 2.61k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 2.61k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 5.20k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 5.20k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 5.20k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 5.20k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 5.20k| }} | | | | ------------------ | | ------------------ ------------------ 1413| 21.2k| vmbreak; ------------------ | | 16| 21.2k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 21.2k|#define vmfetch() { \ | | | | 1139| 21.2k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 21.2k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 21.2k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 21.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| 21.2k| i = *(pc++); \ | | | | 1144| 21.2k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 21.2k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1414| 21.2k| } 1415| 39.1k| vmcase(OP_POWK) { ------------------ | | 14| 39.1k|#define vmcase(l) L_##l: ------------------ 1416| 39.1k| op_arithfK(L, luai_numpow); ------------------ | | 944| 39.1k|#define op_arithfK(L,fop) { \ | | 945| 39.1k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 39.1k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 39.1k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 39.1k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 39.1k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 39.1k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 946| 39.1k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 39.1k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 39.1k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 947| 39.1k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1070| 39.1k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 39.1k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 39.1k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 39.1k|#define lua_assert(c) ((void)0) | | ------------------ | | 948| 39.1k| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 924| 39.1k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 925| 39.1k| lua_Number n1; lua_Number n2; \ | | | | 926| 39.1k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 78.3k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 39.1k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 39.1k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 39.1k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 305, False: 38.8k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 305|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 305|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 39.1k, False: 0] | | | | | | ------------------ | | | | | | 58| 78.3k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 38.8k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 38.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 38.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 38.8k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 38.8k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 38.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 39.1k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 39.1k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 39.1k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 39.1k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 2.59k, False: 36.5k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 2.59k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 2.59k|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 39.1k, False: 0] | | | | | | ------------------ | | | | | | 58| 39.1k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 36.5k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 36.5k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 36.5k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 36.5k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 36.5k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 36.5k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 927| 39.1k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | ------------------ | | | | | | 339| 78.3k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 72| 39.1k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 114| 39.1k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | | Branch (339:35): [True: 36.2k, False: 2.90k] | | | | | | ------------------ | | | | ------------------ | | | | 928| 39.1k| }} | | ------------------ ------------------ 1417| 39.1k| vmbreak; ------------------ | | 16| 39.1k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 39.1k|#define vmfetch() { \ | | | | 1139| 39.1k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 39.1k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 39.1k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 39.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| 39.1k| i = *(pc++); \ | | | | 1144| 39.1k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 39.1k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1418| 39.1k| } 1419| 39.1k| vmcase(OP_DIVK) { ------------------ | | 14| 1|#define vmcase(l) L_##l: ------------------ 1420| 1| op_arithfK(L, luai_numdiv); ------------------ | | 944| 1|#define op_arithfK(L,fop) { \ | | 945| 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)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 946| 1| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 1|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 1|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 947| 1| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1070| 1|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 1|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 1|#define lua_assert(c) ((void)0) | | ------------------ | | 948| 1| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 924| 1|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 925| 1| lua_Number n1; lua_Number n2; \ | | | | 926| 1| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 2| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 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) : \ | | | | | | ------------------ | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 58| 2| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 1|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 1|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 1|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 1, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 1|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 1| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 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) : \ | | | | | | ------------------ | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 58| 1| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 1|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 1|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 1|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 1, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 1|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 927| 1| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | ------------------ | | | | | | 339| 1| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 72| 1|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 114| 1|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 928| 1| }} | | ------------------ ------------------ 1421| 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]; | | ------------------ ------------------ 1422| 1| } 1423| 1| vmcase(OP_IDIVK) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1424| 0| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1112| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1425| 0| op_arithK(L, luaV_idiv, luai_numidiv); ------------------ | | 975| 0|#define op_arithK(L,iop,fop) { \ | | 976| 0| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 0|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 977| 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)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 0|#define lua_assert(c) ((void)0) | | ------------------ | | 978| 0| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 0|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 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)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 0| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 0| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 958| 0| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 0| } \ | | | | 960| 0| 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) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 0| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 0|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 0| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 0|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 0| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 0|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 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| }} | | | | ------------------ | | ------------------ ------------------ 1426| 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]; | | ------------------ ------------------ 1427| 0| } 1428| 83| vmcase(OP_BANDK) { ------------------ | | 14| 83|#define vmcase(l) L_##l: ------------------ 1429| 83| op_bitwiseK(L, l_band); ------------------ | | 984| 83|#define op_bitwiseK(L,op) { \ | | 985| 83| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 83|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 83|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 83|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 83|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 83|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 986| 83| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 83|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 83|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 987| 83| TValue *v2 = KC(i); \ | | ------------------ | | | | 1070| 83|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 83|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 83|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 988| 83| lua_Integer i1; \ | | 989| 83| lua_Integer i2 = ivalue(v2); \ | | ------------------ | | | | 333| 83|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 83|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 990| 83| if (tointegerns(v1, &i1)) { \ | | ------------------ | | | | 69| 83| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 83|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 83|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 0, False: 83] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 79, False: 4] | | | | ------------------ | | | | 70| 83| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 83|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 991| 79| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 79| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 79|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 79|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 992| 79| }} ------------------ 1430| 83| vmbreak; ------------------ | | 16| 83|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 83|#define vmfetch() { \ | | | | 1139| 83| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 83|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 83|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 83] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 83| i = *(pc++); \ | | | | 1144| 83|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 83|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1431| 83| } 1432| 132k| vmcase(OP_BORK) { ------------------ | | 14| 132k|#define vmcase(l) L_##l: ------------------ 1433| 132k| op_bitwiseK(L, l_bor); ------------------ | | 984| 132k|#define op_bitwiseK(L,op) { \ | | 985| 132k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 132k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 132k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 132k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 132k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 132k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 986| 132k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 132k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 132k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 987| 132k| TValue *v2 = KC(i); \ | | ------------------ | | | | 1070| 132k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 132k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 132k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 988| 132k| lua_Integer i1; \ | | 989| 132k| lua_Integer i2 = ivalue(v2); \ | | ------------------ | | | | 333| 132k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 132k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 990| 132k| if (tointegerns(v1, &i1)) { \ | | ------------------ | | | | 69| 132k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 132k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 132k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 132k, False: 3] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 132k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 132k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 132k, False: 0] | | | | ------------------ | | | | 70| 132k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 3|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 991| 132k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 132k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 132k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 132k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 992| 132k| }} ------------------ 1434| 132k| vmbreak; ------------------ | | 16| 132k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 132k|#define vmfetch() { \ | | | | 1139| 132k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 132k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 132k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 132k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 132k| i = *(pc++); \ | | | | 1144| 132k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 132k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1435| 132k| } 1436| 297k| vmcase(OP_BXORK) { ------------------ | | 14| 297k|#define vmcase(l) L_##l: ------------------ 1437| 297k| op_bitwiseK(L, l_bxor); ------------------ | | 984| 297k|#define op_bitwiseK(L,op) { \ | | 985| 297k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 297k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 297k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 297k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 297k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 297k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 986| 297k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 297k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 297k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 987| 297k| TValue *v2 = KC(i); \ | | ------------------ | | | | 1070| 297k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 297k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 297k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 988| 297k| lua_Integer i1; \ | | 989| 297k| lua_Integer i2 = ivalue(v2); \ | | ------------------ | | | | 333| 297k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 297k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 990| 297k| if (tointegerns(v1, &i1)) { \ | | ------------------ | | | | 69| 297k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 297k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 297k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 297k, False: 12] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 297k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 297k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 297k, False: 0] | | | | ------------------ | | | | 70| 297k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 12|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 991| 297k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 297k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 297k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 297k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 992| 297k| }} ------------------ 1438| 297k| vmbreak; ------------------ | | 16| 297k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 297k|#define vmfetch() { \ | | | | 1139| 297k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 297k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 297k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 297k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 297k| i = *(pc++); \ | | | | 1144| 297k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 297k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1439| 297k| } 1440| 297k| vmcase(OP_SHRI) { ------------------ | | 14| 144k|#define vmcase(l) L_##l: ------------------ 1441| 144k| StkId ra = RA(i); ------------------ | | 1064| 144k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 144k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 144k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 144k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 144k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1442| 144k| TValue *rb = vRB(i); ------------------ | | 1066| 144k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 144k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1443| 144k| int ic = GETARG_sC(i); ------------------ | | 133| 144k|#define GETARG_sC(i) sC2int(GETARG_C(i)) | | ------------------ | | | | 101| 144k|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 144k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 144k|#define MAXARG_C ((1<value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 144k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1447| 144k| } 1448| 144k| vmbreak; ------------------ | | 16| 144k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 144k|#define vmfetch() { \ | | | | 1139| 144k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 144k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 144k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 144k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 144k| i = *(pc++); \ | | | | 1144| 144k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 144k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1449| 144k| } 1450| 300k| vmcase(OP_SHLI) { ------------------ | | 14| 300k|#define vmcase(l) L_##l: ------------------ 1451| 300k| StkId ra = RA(i); ------------------ | | 1064| 300k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 300k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 300k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 300k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 300k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1452| 300k| TValue *rb = vRB(i); ------------------ | | 1066| 300k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 300k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1453| 300k| int ic = GETARG_sC(i); ------------------ | | 133| 300k|#define GETARG_sC(i) sC2int(GETARG_C(i)) | | ------------------ | | | | 101| 300k|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 300k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 300k|#define MAXARG_C ((1<value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 300k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1457| 300k| } 1458| 300k| vmbreak; ------------------ | | 16| 300k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 300k|#define vmfetch() { \ | | | | 1139| 300k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 300k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 300k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 300k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 300k| i = *(pc++); \ | | | | 1144| 300k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 300k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1459| 300k| } 1460| 300k| vmcase(OP_ADD) { ------------------ | | 14| 321|#define vmcase(l) L_##l: ------------------ 1461| 321| op_arith(L, l_addi, luai_numadd); ------------------ | | 966| 321|#define op_arith(L,iop,fop) { \ | | 967| 321| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 321|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 321|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 968| 321| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 321|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 321|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 969| 321| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 321|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 321| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 321|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 321|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 321|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 321|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 321|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 321| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 321|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 642|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 321|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 76, False: 245] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 76|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 76|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 76|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 76, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 76| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 76|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 76|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 76|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 76|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 958| 76| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 76| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 76|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 76|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 76| } \ | | | | 960| 321| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 245|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 245| lua_Number n1; lua_Number n2; \ | | | | | | 926| 245| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 490| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 245|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 245|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 245|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 245, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 245|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 245|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 245, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 490| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 0|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 245| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 245|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 245|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 245|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 245, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 245|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 245|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 245, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 245| (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)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 245| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 245| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 245|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 245|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 245| }} | | | | ------------------ | | ------------------ ------------------ 1462| 321| vmbreak; ------------------ | | 16| 321|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 321|#define vmfetch() { \ | | | | 1139| 321| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 321|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 321|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 321] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 321| i = *(pc++); \ | | | | 1144| 321|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 321|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1463| 321| } 1464| 462| vmcase(OP_SUB) { ------------------ | | 14| 462|#define vmcase(l) L_##l: ------------------ 1465| 462| op_arith(L, l_subi, luai_numsub); ------------------ | | 966| 462|#define op_arith(L,iop,fop) { \ | | 967| 462| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 462|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 462|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 968| 462| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 462|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 462|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 969| 462| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 462|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 462| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 462|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 462|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 462|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 462|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 462|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 462| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 462|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 924|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 462|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 0, False: 462] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 0| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 958| 0| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 0| } \ | | | | 960| 462| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 462|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 462| lua_Number n1; lua_Number n2; \ | | | | | | 926| 462| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 924| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 462|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 462|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 462|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 462, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 462|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 462|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 462, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 924| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 0|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 462| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 462|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 462|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 462|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 462] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 462, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 462| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 462|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 462|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 462|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 462, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 462|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 462|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 462| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 462| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 462|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 462|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 462| }} | | | | ------------------ | | ------------------ ------------------ 1466| 462| vmbreak; ------------------ | | 16| 462|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 462|#define vmfetch() { \ | | | | 1139| 462| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 462|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 462|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 462] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 462| i = *(pc++); \ | | | | 1144| 462|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 462|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1467| 462| } 1468| 462| vmcase(OP_MUL) { ------------------ | | 14| 125|#define vmcase(l) L_##l: ------------------ 1469| 125| op_arith(L, l_muli, luai_nummul); ------------------ | | 966| 125|#define op_arith(L,iop,fop) { \ | | 967| 125| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 125|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 125|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 968| 125| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 125|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 125|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 969| 125| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 125|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 125| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 125|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 125|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 125|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 125|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 125|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 125| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 125|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 250|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 125|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 0, False: 125] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 0| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 958| 0| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 0| } \ | | | | 960| 125| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 125|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 125| lua_Number n1; lua_Number n2; \ | | | | | | 926| 125| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 250| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 125|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 125|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 125|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 125, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 125|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 125|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 125, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 250| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 0|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 125| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 125|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 125|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 125|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 125, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 125|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 125|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 125, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 125| (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)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 125| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 125| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 125|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 125|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 125| }} | | | | ------------------ | | ------------------ ------------------ 1470| 125| vmbreak; ------------------ | | 16| 125|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 125|#define vmfetch() { \ | | | | 1139| 125| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 125|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 125|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 125] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 125| i = *(pc++); \ | | | | 1144| 125|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 125|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1471| 125| } 1472| 2.99k| vmcase(OP_MOD) { ------------------ | | 14| 2.99k|#define vmcase(l) L_##l: ------------------ 1473| 2.99k| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1112| 2.99k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1105| 2.99k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1474| 2.99k| op_arith(L, luaV_mod, luaV_modf); ------------------ | | 966| 2.99k|#define op_arith(L,iop,fop) { \ | | 967| 2.99k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 2.99k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 2.99k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 968| 2.99k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 2.99k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 2.99k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 969| 2.99k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 2.99k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 2.99k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1064| 2.99k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 2.99k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 2.99k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 2.99k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 2.99k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 2.99k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 2.99k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 5.99k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 2.99k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 463, False: 2.53k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 463|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 463|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 463|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 462, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 462| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 462|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 462|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 462|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 462|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 958| 462| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 462| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 462|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 462|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 462| } \ | | | | 960| 2.99k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 924| 2.53k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 925| 2.53k| lua_Number n1; lua_Number n2; \ | | | | | | 926| 2.53k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 5.07k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 2.53k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 2.53k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 2.53k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 2.53k, False: 1] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 2.53k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 2.53k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 2.53k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 5.07k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 1|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 1|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 1|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 1, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 1|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 1|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 2.53k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 2.53k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 2.53k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 2.53k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 2.53k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 2.53k, False: 1] | | | | | | | | ------------------ | | | | | | | | 58| 2.53k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 2.53k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 2.53k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 2.53k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 2.53k, False: 1] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 2.53k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 2.53k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 927| 2.53k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 2.53k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 2.53k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 2.53k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 928| 2.53k| }} | | | | ------------------ | | ------------------ ------------------ 1475| 2.99k| vmbreak; ------------------ | | 16| 2.99k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 2.99k|#define vmfetch() { \ | | | | 1139| 2.99k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 2.99k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 2.99k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 2.99k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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.99k| i = *(pc++); \ | | | | 1144| 2.99k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 2.99k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1476| 2.99k| } 1477| 23.7k| vmcase(OP_POW) { ------------------ | | 14| 23.7k|#define vmcase(l) L_##l: ------------------ 1478| 23.7k| op_arithf(L, luai_numpow); ------------------ | | 934| 23.7k|#define op_arithf(L,fop) { \ | | 935| 23.7k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 23.7k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 23.7k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 23.7k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 23.7k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 23.7k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 936| 23.7k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 23.7k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 23.7k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 937| 23.7k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 23.7k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 23.7k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 938| 23.7k| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 924| 23.7k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 925| 23.7k| lua_Number n1; lua_Number n2; \ | | | | 926| 23.7k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 47.4k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 23.7k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 23.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 23.7k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 423, False: 23.3k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 423|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 423|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 23.7k, False: 1] | | | | | | ------------------ | | | | | | 58| 47.4k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 23.3k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 23.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 23.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 23.3k, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 23.3k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 23.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 23.7k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 23.7k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 23.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 23.7k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 10.5k, False: 13.2k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 10.5k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 10.5k|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 23.7k, False: 0] | | | | | | ------------------ | | | | | | 58| 23.7k| (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: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 13.2k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 13.2k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 927| 23.7k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | ------------------ | | | | | | 339| 47.4k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 72| 23.7k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 114| 23.7k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | | Branch (339:35): [True: 282, False: 23.4k] | | | | | | ------------------ | | | | ------------------ | | | | 928| 23.7k| }} | | ------------------ ------------------ 1479| 23.7k| vmbreak; ------------------ | | 16| 23.7k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 23.7k|#define vmfetch() { \ | | | | 1139| 23.7k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 23.7k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 23.7k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 23.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| 23.7k| i = *(pc++); \ | | | | 1144| 23.7k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 23.7k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1480| 23.7k| } 1481| 23.7k| vmcase(OP_DIV) { /* float division (always with floats) */ ------------------ | | 14| 1|#define vmcase(l) L_##l: ------------------ 1482| 1| op_arithf(L, luai_numdiv); ------------------ | | 934| 1|#define op_arithf(L,fop) { \ | | 935| 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)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 936| 1| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 1|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 1|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 937| 1| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 1|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 1|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 938| 1| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 924| 1|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 925| 1| lua_Number n1; lua_Number n2; \ | | | | 926| 1| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 2| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 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) : \ | | | | | | ------------------ | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 58| 2| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 1|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 1|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 1|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 1, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 1|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 1| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 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) : \ | | | | | | ------------------ | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 58| 1| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 1|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 1|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 1|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 0, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 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]; | | ------------------ ------------------ 1484| 1| } 1485| 1| vmcase(OP_IDIV) { /* floor division */ ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1486| 0| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1112| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1487| 0| op_arith(L, luaV_idiv, luai_numidiv); ------------------ | | 966| 0|#define op_arith(L,iop,fop) { \ | | 967| 0| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 0|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 968| 0| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 0|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 969| 0| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 954| 0|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 955| 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)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 956| 0| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 957| 0| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 958| 0| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 959| 0| } \ | | | | 960| 0| 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) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 0| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 0|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 0| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 0|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 0| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 0|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 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| }} | | | | ------------------ | | ------------------ ------------------ 1488| 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]; | | ------------------ ------------------ 1489| 0| } 1490| 11| vmcase(OP_BAND) { ------------------ | | 14| 11|#define vmcase(l) L_##l: ------------------ 1491| 11| op_bitwise(L, l_band); ------------------ | | 998| 11|#define op_bitwise(L,op) { \ | | 999| 11| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 11|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 11|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 11|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 11|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 11|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1000| 11| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 11|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 11|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 1001| 11| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 11|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 11|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 1002| 11| lua_Integer i1; lua_Integer i2; \ | | 1003| 11| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 22| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 11|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 11|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 0, False: 11] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 0, False: 11] | | | | ------------------ | | | | 70| 22| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 11|#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) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | 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| 11| vmbreak; ------------------ | | 16| 11|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 11|#define vmfetch() { \ | | | | 1139| 11| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 11|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 11|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 11] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 11| i = *(pc++); \ | | | | 1144| 11|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 11|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1493| 11| } 1494| 173k| vmcase(OP_BOR) { ------------------ | | 14| 173k|#define vmcase(l) L_##l: ------------------ 1495| 173k| op_bitwise(L, l_bor); ------------------ | | 998| 173k|#define op_bitwise(L,op) { \ | | 999| 173k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 173k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 173k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 173k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 173k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 173k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1000| 173k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 173k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 173k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 1001| 173k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 173k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 173k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 1002| 173k| lua_Integer i1; lua_Integer i2; \ | | 1003| 173k| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 347k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 173k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 173k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 173k, False: 242] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 173k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 173k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 173k, False: 0] | | | | ------------------ | | | | 70| 347k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 242|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 173k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 173k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 173k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 173k, False: 140] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 173k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 173k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 173k, False: 0] | | | | ------------------ | | | | 70| 173k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 140|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 1004| 173k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 173k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 173k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 173k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 1005| 173k| }} ------------------ 1496| 173k| vmbreak; ------------------ | | 16| 173k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 173k|#define vmfetch() { \ | | | | 1139| 173k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 173k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 173k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 173k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 173k| i = *(pc++); \ | | | | 1144| 173k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 173k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1497| 173k| } 1498| 173k| vmcase(OP_BXOR) { ------------------ | | 14| 42.2k|#define vmcase(l) L_##l: ------------------ 1499| 42.2k| op_bitwise(L, l_bxor); ------------------ | | 998| 42.2k|#define op_bitwise(L,op) { \ | | 999| 42.2k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 42.2k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 42.2k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 42.2k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 42.2k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 42.2k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1000| 42.2k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 42.2k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 42.2k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 1001| 42.2k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 42.2k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 42.2k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 1002| 42.2k| lua_Integer i1; lua_Integer i2; \ | | 1003| 42.2k| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 84.5k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 42.2k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 42.2k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 41.6k, False: 694] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 41.6k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 41.6k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 42.2k, False: 1] | | | | ------------------ | | | | 70| 84.5k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 694|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 42.2k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 42.2k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 42.2k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 3.45k, False: 38.8k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 3.45k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 3.45k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 42.2k, False: 0] | | | | ------------------ | | | | 70| 42.2k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 38.8k|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 1004| 42.2k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 42.2k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 42.2k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 42.2k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 1005| 42.2k| }} ------------------ 1500| 42.2k| vmbreak; ------------------ | | 16| 42.2k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 42.2k|#define vmfetch() { \ | | | | 1139| 42.2k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 42.2k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 42.2k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 42.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| 42.2k| i = *(pc++); \ | | | | 1144| 42.2k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 42.2k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1501| 42.2k| } 1502| 42.2k| 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) | | | | ------------------ | | ------------------ | | 1001| 0| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 0|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 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) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | 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) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | 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| 28.6k| vmcase(OP_SHL) { ------------------ | | 14| 28.6k|#define vmcase(l) L_##l: ------------------ 1507| 28.6k| op_bitwise(L, luaV_shiftl); ------------------ | | 998| 28.6k|#define op_bitwise(L,op) { \ | | 999| 28.6k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 28.6k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 28.6k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 28.6k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 28.6k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 28.6k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1000| 28.6k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1066| 28.6k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 28.6k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 1001| 28.6k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1069| 28.6k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 28.6k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 1002| 28.6k| lua_Integer i1; lua_Integer i2; \ | | 1003| 28.6k| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 57.2k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 28.6k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 28.6k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 1, False: 28.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 1|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 28.6k, False: 6] | | | | ------------------ | | | | 70| 57.2k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 28.6k|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 28.6k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 28.6k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 28.6k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 28.5k, False: 122] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 28.5k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 28.5k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 28.6k, False: 0] | | | | ------------------ | | | | 70| 28.6k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 122|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 1004| 28.6k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 28.6k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 28.6k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 28.6k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 1005| 28.6k| }} ------------------ 1508| 28.6k| vmbreak; ------------------ | | 16| 28.6k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 28.6k|#define vmfetch() { \ | | | | 1139| 28.6k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 28.6k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 28.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 28.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| 28.6k| i = *(pc++); \ | | | | 1144| 28.6k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 28.6k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1509| 28.6k| } 1510| 28.6k| vmcase(OP_MMBIN) { ------------------ | | 14| 21|#define vmcase(l) L_##l: ------------------ 1511| 21| StkId ra = RA(i); ------------------ | | 1064| 21|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 21|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 21|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 21|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 21|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1512| 21| Instruction pi = *(pc - 2); /* original arith. expression */ 1513| 21| TValue *rb = vRB(i); ------------------ | | 1066| 21|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 21|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1514| 21| TMS tm = (TMS)GETARG_C(i); ------------------ | | 132| 21|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 21|#define check_exp(c,e) (e) | | ------------------ ------------------ 1515| 21| StkId result = RA(pi); ------------------ | | 1064| 21|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 21|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 21|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 21|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 21|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1516| 21| lua_assert(OP_ADD <= GET_OPCODE(pi) && GET_OPCODE(pi) <= OP_SHR); ------------------ | | 114| 21|#define lua_assert(c) ((void)0) ------------------ 1517| 21| Protect(luaT_trybinTM(L, s2v(ra), rb, result, tm)); ------------------ | | 1119| 21|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 21|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 21|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 21|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1518| 21| vmbreak; ------------------ | | 16| 21|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 21|#define vmfetch() { \ | | | | 1139| 21| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 21|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 21|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 21] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 21| i = *(pc++); \ | | | | 1144| 21|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 21|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1519| 21| } 1520| 21| vmcase(OP_MMBINI) { ------------------ | | 14| 1|#define vmcase(l) L_##l: ------------------ 1521| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1522| 1| Instruction pi = *(pc - 2); /* original arith. expression */ 1523| 1| int imm = GETARG_sB(i); ------------------ | | 129| 1|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | ------------------ | | | | 101| 1|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 1|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 1|#define MAXARG_C ((1<>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 1|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1527| 1| Protect(luaT_trybiniTM(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) | | ------------------ ------------------ 1528| 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]; | | ------------------ ------------------ 1529| 1| } 1530| 4| vmcase(OP_MMBINK) { ------------------ | | 14| 4|#define vmcase(l) L_##l: ------------------ 1531| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1532| 4| Instruction pi = *(pc - 2); /* original arith. expression */ 1533| 4| TValue *imm = KB(i); ------------------ | | 1067| 4|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 4|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 115| 4|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1534| 4| TMS tm = (TMS)GETARG_C(i); ------------------ | | 132| 4|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 4|#define check_exp(c,e) (e) | | ------------------ ------------------ 1535| 4| int flip = GETARG_k(i); ------------------ | | 137| 4|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | ------------------ | | | | 115| 4|#define check_exp(c,e) (e) | | ------------------ ------------------ 1536| 4| StkId result = RA(pi); ------------------ | | 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1537| 4| Protect(luaT_trybinassocTM(L, s2v(ra), imm, flip, result, tm)); ------------------ | | 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) | | ------------------ ------------------ 1538| 4| 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]; | | ------------------ ------------------ 1539| 4| } 1540| 16.3k| vmcase(OP_UNM) { ------------------ | | 14| 16.3k|#define vmcase(l) L_##l: ------------------ 1541| 16.3k| StkId ra = RA(i); ------------------ | | 1064| 16.3k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 16.3k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 16.3k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 16.3k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 16.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1542| 16.3k| TValue *rb = vRB(i); ------------------ | | 1066| 16.3k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 16.3k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1543| 16.3k| lua_Number nb; 1544| 16.3k| if (ttisinteger(rb)) { ------------------ | | 328| 16.3k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 16.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 16.3k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 5.68k, False: 10.6k] | | | | ------------------ | | ------------------ ------------------ 1545| 5.68k| lua_Integer ib = ivalue(rb); ------------------ | | 333| 5.68k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 5.68k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1546| 5.68k| setivalue(s2v(ra), intop(-, 0, ib)); ------------------ | | 345| 5.68k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 5.68k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 5.68k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1547| 5.68k| } 1548| 10.6k| else if (tonumberns(rb, nb)) { ------------------ | | 57| 10.6k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 10.6k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 10.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 10.6k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 10.6k, False: 6] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 10.6k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 10.6k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 10.6k, False: 6] | | ------------------ | | 58| 10.6k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 6|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 6|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 6|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 6] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (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)) | | | | ------------------ | | ------------------ ------------------ 1549| 10.6k| setfltvalue(s2v(ra), luai_numunm(L, nb)); ------------------ | | 339| 10.6k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 10.6k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 10.6k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1550| 10.6k| } 1551| 6| else 1552| 6| Protect(luaT_trybinTM(L, rb, rb, ra, TM_UNM)); ------------------ | | 1119| 6|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 6|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 6|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 6|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1553| 16.3k| vmbreak; ------------------ | | 16| 16.3k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 16.3k|#define vmfetch() { \ | | | | 1139| 16.3k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 16.3k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 16.3k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 16.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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.3k| i = *(pc++); \ | | | | 1144| 16.3k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 16.3k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1554| 16.3k| } 1555| 16.3k| vmcase(OP_BNOT) { ------------------ | | 14| 5.06k|#define vmcase(l) L_##l: ------------------ 1556| 5.06k| StkId ra = RA(i); ------------------ | | 1064| 5.06k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 5.06k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 5.06k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 5.06k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 5.06k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1557| 5.06k| TValue *rb = vRB(i); ------------------ | | 1066| 5.06k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 5.06k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1558| 5.06k| lua_Integer ib; 1559| 5.06k| if (tointegerns(rb, &ib)) { ------------------ | | 69| 5.06k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 696| 5.06k|#define l_likely(x) luai_likely(x) | | | | ------------------ | | | | | | 684| 5.06k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | ------------------ | | | | | | | Branch (684:25): [True: 5.04k, False: 15] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 333| 5.04k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 5.04k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (69:3): [True: 5.04k, False: 15] | | ------------------ | | 70| 5.06k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | ------------------ | | | | 36| 15|#define LUA_FLOORN2I F2Ieq | | ------------------ ------------------ 1560| 5.04k| setivalue(s2v(ra), intop(^, ~l_castS2U(0), ib)); ------------------ | | 345| 5.04k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 5.04k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 5.04k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1561| 5.04k| } 1562| 15| else 1563| 15| Protect(luaT_trybinTM(L, rb, rb, ra, TM_BNOT)); ------------------ | | 1119| 15|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 15|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 15|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 15|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1564| 5.06k| vmbreak; ------------------ | | 16| 5.06k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 5.06k|#define vmfetch() { \ | | | | 1139| 5.06k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 5.06k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 5.06k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 5.06k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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.06k| i = *(pc++); \ | | | | 1144| 5.06k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 5.06k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1565| 5.06k| } 1566| 10.9k| vmcase(OP_NOT) { ------------------ | | 14| 10.9k|#define vmcase(l) L_##l: ------------------ 1567| 10.9k| StkId ra = RA(i); ------------------ | | 1064| 10.9k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 10.9k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 10.9k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 10.9k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 10.9k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1568| 10.9k| TValue *rb = vRB(i); ------------------ | | 1066| 10.9k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 10.9k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1569| 10.9k| if (l_isfalse(rb)) ------------------ | | 247| 10.9k|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 10.9k|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 21.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 10.9k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 276, False: 10.6k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 193| 10.6k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 10.6k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 10.6k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 10.6k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 5, False: 10.6k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1570| 10.9k| setbtvalue(s2v(ra)); ------------------ | | 251| 281|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 281|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1571| 10.6k| else 1572| 10.9k| setbfvalue(s2v(ra)); ------------------ | | 250| 10.6k|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 10.6k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1573| 10.9k| vmbreak; ------------------ | | 16| 10.9k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 10.9k|#define vmfetch() { \ | | | | 1139| 10.9k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 10.9k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 10.9k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 10.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| 10.9k| i = *(pc++); \ | | | | 1144| 10.9k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 10.9k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1574| 10.9k| } 1575| 18.8k| vmcase(OP_LEN) { ------------------ | | 14| 18.8k|#define vmcase(l) L_##l: ------------------ 1576| 18.8k| StkId ra = RA(i); ------------------ | | 1064| 18.8k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 18.8k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 18.8k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 18.8k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 18.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1577| 18.8k| Protect(luaV_objlen(L, ra, vRB(i))); ------------------ | | 1119| 18.8k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 18.8k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 18.8k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 18.8k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1578| 18.8k| vmbreak; ------------------ | | 16| 18.8k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 18.8k|#define vmfetch() { \ | | | | 1139| 18.8k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 18.8k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 18.8k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 18.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| 18.8k| i = *(pc++); \ | | | | 1144| 18.8k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 18.8k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1579| 18.8k| } 1580| 65.6k| vmcase(OP_CONCAT) { ------------------ | | 14| 65.6k|#define vmcase(l) L_##l: ------------------ 1581| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1582| 65.6k| int n = GETARG_B(i); /* number of elements to concatenate */ ------------------ | | 128| 65.6k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 65.6k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1583| 65.6k| L->top.p = ra + n; /* mark the end of concat operands */ 1584| 65.6k| ProtectNT(luaV_concat(L, n)); ------------------ | | 1122| 65.6k|#define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1105| 65.6k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ | | #define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 65.6k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1585| 65.6k| checkGC(L, L->top.p); /* 'luaV_concat' ensures correct top */ ------------------ | | 1132| 65.6k| { luaC_condGC(L, (savepc(L), L->top.p = (c)), \ | | ------------------ | | | | 168| 65.6k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 65.6k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 11, False: 65.5k] | | | | ------------------ | | | | 169| 65.6k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 65.6k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 1133| 65.6k| updatetrap(ci)); \ | | 1134| 65.6k| luai_threadyield(L); } | | ------------------ | | | | 273| 65.6k|#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 265| 65.6k|#define lua_unlock(L) ((void) 0) | | | | ------------------ | | | | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 264| 65.6k|#define lua_lock(L) ((void) 0) | | | | ------------------ | | ------------------ ------------------ 1586| 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: 1, False: 65.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 1| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 1| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 1|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 1| } \ | | | | 1143| 65.6k| i = *(pc++); \ | | | | 1144| 65.6k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 65.6k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1587| 65.6k| } 1588| 65.6k| vmcase(OP_CLOSE) { ------------------ | | 14| 3.14k|#define vmcase(l) L_##l: ------------------ 1589| 3.14k| StkId ra = RA(i); ------------------ | | 1064| 3.14k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 3.14k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 3.14k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 3.14k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 3.14k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1590| 3.14k| Protect(luaF_close(L, ra, LUA_OK, 1)); ------------------ | | 1119| 3.14k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 3.14k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 3.14k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 3.14k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1591| 3.14k| vmbreak; ------------------ | | 16| 3.14k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 3.14k|#define vmfetch() { \ | | | | 1139| 3.14k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 3.14k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 3.14k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 3.14k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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.14k| i = *(pc++); \ | | | | 1144| 3.14k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 3.14k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1592| 3.14k| } 1593| 3.14k| 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| 55.0k| vmcase(OP_JMP) { ------------------ | | 14| 55.0k|#define vmcase(l) L_##l: ------------------ 1600| 55.0k| dojump(ci, i, 0); ------------------ | | 1088| 55.0k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | ------------------ | | | | 151| 55.0k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | ------------------ | | | | | | 115| 55.0k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | ------------------ | | | | 1075| 55.0k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1601| 55.0k| vmbreak; ------------------ | | 16| 55.0k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 55.0k|#define vmfetch() { \ | | | | 1139| 55.0k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 55.0k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 55.0k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 55.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| 55.0k| i = *(pc++); \ | | | | 1144| 55.0k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 55.0k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1602| 55.0k| } 1603| 308k| vmcase(OP_EQ) { ------------------ | | 14| 308k|#define vmcase(l) L_##l: ------------------ 1604| 308k| StkId ra = RA(i); ------------------ | | 1064| 308k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 308k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 308k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 308k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 308k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1605| 308k| int cond; 1606| 308k| TValue *rb = vRB(i); ------------------ | | 1066| 308k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 308k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1607| 308k| Protect(cond = luaV_equalobj(L, s2v(ra), rb)); ------------------ | | 1119| 308k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 308k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 308k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 308k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1608| 308k| docondjump(); ------------------ | | 1099| 308k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 308k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 115| 308k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1092| 145k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1088| 145k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 145k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 115| 145k|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1075| 145k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1099:26): [True: 163k, False: 145k] | | ------------------ ------------------ 1609| 308k| vmbreak; ------------------ | | 16| 308k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 308k|#define vmfetch() { \ | | | | 1139| 308k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 308k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 308k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 308k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 308k| i = *(pc++); \ | | | | 1144| 308k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 308k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1610| 308k| } 1611| 308k| vmcase(OP_LT) { ------------------ | | 14| 300k|#define vmcase(l) L_##l: ------------------ 1612| 300k| op_order(L, l_lti, LTnum, lessthanothers); ------------------ | | 1013| 300k|#define op_order(L,opi,opn,other) { \ | | 1014| 300k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 300k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 300k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 300k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 300k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 300k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1015| 300k| int cond; \ | | 1016| 300k| TValue *rb = vRB(i); \ | | ------------------ | | | | 1066| 300k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 300k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 1017| 300k| if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 328| 300k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 601k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 300k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 298k, False: 2.30k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 328| 298k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 298k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 298k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 298k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1018| 298k| lua_Integer ia = ivalue(s2v(ra)); \ | | ------------------ | | | | 333| 298k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 298k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1019| 298k| lua_Integer ib = ivalue(rb); \ | | ------------------ | | | | 333| 298k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 298k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1020| 298k| cond = opi(ia, ib); \ | | ------------------ | | | | 1612| 298k| op_order(L, l_lti, LTnum, lessthanothers); | | | | ------------------ | | | | | | 895| 298k|#define l_lti(a,b) (a < b) | | | | ------------------ | | ------------------ | | 1021| 298k| } \ | | 1022| 300k| else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 326| 2.30k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 4.61k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 2.30k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 2.30k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 2.30k, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 326| 2.30k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 2.30k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 2.30k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 2.30k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 2.30k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1023| 2.30k| cond = opn(s2v(ra), rb); \ | | ------------------ | | | | 172| 2.30k|#define s2v(o) (&(o)->val) | | ------------------ | | 1024| 2.30k| else \ | | 1025| 2.30k| Protect(cond = other(L, s2v(ra), rb)); \ | | ------------------ | | | | 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) | | | | ------------------ | | ------------------ | | 1026| 300k| docondjump(); } | | ------------------ | | | | 1099| 300k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 300k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 115| 300k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1092| 50.2k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1088| 50.2k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 50.2k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 50.2k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1075| 50.2k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1099:26): [True: 250k, False: 50.2k] | | | | ------------------ | | ------------------ ------------------ 1613| 300k| vmbreak; ------------------ | | 16| 300k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 300k|#define vmfetch() { \ | | | | 1139| 300k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 300k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 300k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 300k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 300k| i = *(pc++); \ | | | | 1144| 300k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 300k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1614| 300k| } 1615| 300k| vmcase(OP_LE) { ------------------ | | 14| 137k|#define vmcase(l) L_##l: ------------------ 1616| 137k| op_order(L, l_lei, LEnum, lessequalothers); ------------------ | | 1013| 137k|#define op_order(L,opi,opn,other) { \ | | 1014| 137k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 137k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 137k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 137k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 137k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 137k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1015| 137k| int cond; \ | | 1016| 137k| TValue *rb = vRB(i); \ | | ------------------ | | | | 1066| 137k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 137k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 1017| 137k| if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 328| 137k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 275k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 137k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 2.59k, False: 134k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 328| 2.59k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 2.59k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 2.59k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 2.59k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1018| 0| lua_Integer ia = ivalue(s2v(ra)); \ | | ------------------ | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1019| 0| lua_Integer ib = ivalue(rb); \ | | ------------------ | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1020| 0| cond = opi(ia, ib); \ | | ------------------ | | | | 1616| 0| op_order(L, l_lei, LEnum, lessequalothers); | | | | ------------------ | | | | | | 896| 0|#define l_lei(a,b) (a <= b) | | | | ------------------ | | ------------------ | | 1021| 0| } \ | | 1022| 137k| else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 326| 137k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 275k|#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: 137k, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 326| 137k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 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: 137k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1023| 137k| cond = opn(s2v(ra), rb); \ | | ------------------ | | | | 172| 137k|#define s2v(o) (&(o)->val) | | ------------------ | | 1024| 137k| else \ | | 1025| 137k| Protect(cond = other(L, s2v(ra), rb)); \ | | ------------------ | | | | 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) | | | | ------------------ | | ------------------ | | 1026| 137k| docondjump(); } | | ------------------ | | | | 1099| 137k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 137k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 115| 137k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1092| 75.2k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1088| 75.2k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 75.2k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 75.2k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1075| 75.2k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1099:26): [True: 62.2k, False: 75.2k] | | | | ------------------ | | ------------------ ------------------ 1617| 137k| vmbreak; ------------------ | | 16| 137k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 137k|#define vmfetch() { \ | | | | 1139| 137k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 137k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 137k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 137k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 137k| i = *(pc++); \ | | | | 1144| 137k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 137k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1618| 137k| } 1619| 188k| vmcase(OP_EQK) { ------------------ | | 14| 188k|#define vmcase(l) L_##l: ------------------ 1620| 188k| StkId ra = RA(i); ------------------ | | 1064| 188k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 188k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 188k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 188k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 188k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1621| 188k| TValue *rb = KB(i); ------------------ | | 1067| 188k|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 188k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 115| 188k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1622| | /* basic types do not use '__eq'; we can use raw equality */ 1623| 188k| int cond = luaV_rawequalobj(s2v(ra), rb); ------------------ | | 75| 188k|#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2) ------------------ 1624| 188k| docondjump(); ------------------ | | 1099| 188k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 188k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 115| 188k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1092| 139k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1088| 139k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 139k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 115| 139k|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1075| 139k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1099:26): [True: 49.1k, False: 139k] | | ------------------ ------------------ 1625| 188k| vmbreak; ------------------ | | 16| 188k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 188k|#define vmfetch() { \ | | | | 1139| 188k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 188k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 188k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 188k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| 188k| i = *(pc++); \ | | | | 1144| 188k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 188k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1626| 188k| } 1627| 188k| vmcase(OP_EQI) { ------------------ | | 14| 95.7k|#define vmcase(l) L_##l: ------------------ 1628| 95.7k| StkId ra = RA(i); ------------------ | | 1064| 95.7k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 95.7k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 95.7k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 95.7k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 95.7k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1629| 95.7k| int cond; 1630| 95.7k| int im = GETARG_sB(i); ------------------ | | 129| 95.7k|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | ------------------ | | | | 101| 95.7k|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 95.7k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 95.7k|#define MAXARG_C ((1<tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 5.17k, False: 90.6k] | | | | ------------------ | | ------------------ ------------------ 1632| 5.17k| cond = (ivalue(s2v(ra)) == im); ------------------ | | 333| 5.17k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 5.17k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1633| 90.6k| else if (ttisfloat(s2v(ra))) ------------------ | | 327| 90.6k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 90.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 90.6k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 90.6k] | | | | ------------------ | | ------------------ ------------------ 1634| 0| cond = luai_numeq(fltvalue(s2v(ra)), cast_num(im)); ------------------ | | 350| 0|#define luai_numeq(a,b) ((a)==(b)) ------------------ 1635| 90.6k| else 1636| 90.6k| cond = 0; /* other types cannot be equal to a number */ 1637| 95.7k| docondjump(); ------------------ | | 1099| 95.7k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 95.7k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 115| 95.7k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1092| 5.17k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1088| 5.17k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 5.17k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 115| 5.17k|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1075| 5.17k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1099:26): [True: 90.6k, False: 5.17k] | | ------------------ ------------------ 1638| 95.7k| vmbreak; ------------------ | | 16| 95.7k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 95.7k|#define vmfetch() { \ | | | | 1139| 95.7k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 95.7k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 95.7k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 95.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| 95.7k| i = *(pc++); \ | | | | 1144| 95.7k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 95.7k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1639| 95.7k| } 1640| 95.7k| 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) | | | | ------------------ | | ------------------ | | 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) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 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)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 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)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #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) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #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| 75.0k| vmcase(OP_LEI) { ------------------ | | 14| 75.0k|#define vmcase(l) L_##l: ------------------ 1645| 75.0k| op_orderI(L, l_lei, luai_numle, 0, TM_LE); ------------------ | | 1033| 75.0k|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1034| 75.0k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 75.0k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 75.0k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 75.0k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 75.0k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 75.0k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 75.0k| int cond; \ | | 1036| 75.0k| int im = GETARG_sB(i); \ | | ------------------ | | | | 129| 75.0k|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | | | ------------------ | | | | | | 101| 75.0k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 75.0k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 75.0k|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 75.0k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1038| 75.0k| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1645| 75.0k| op_orderI(L, l_lei, luai_numle, 0, TM_LE); | | | | ------------------ | | | | | | 896| 75.0k|#define l_lei(a,b) (a <= b) | | | | ------------------ | | ------------------ | | 1039| 75.0k| 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) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 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)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 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| 75.0k| docondjump(); } | | ------------------ | | | | 1099| 75.0k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 75.0k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 115| 75.0k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1092| 44.0k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1088| 44.0k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 44.0k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 44.0k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1075| 44.0k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1099:26): [True: 31.0k, False: 44.0k] | | | | ------------------ | | ------------------ ------------------ 1646| 75.0k| vmbreak; ------------------ | | 16| 75.0k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 75.0k|#define vmfetch() { \ | | | | 1139| 75.0k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 75.0k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 75.0k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 75.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| 75.0k| i = *(pc++); \ | | | | 1144| 75.0k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 75.0k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1647| 75.0k| } 1648| 75.0k| vmcase(OP_GTI) { ------------------ | | 14| 76|#define vmcase(l) L_##l: ------------------ 1649| 76| op_orderI(L, l_gti, luai_numgt, 1, TM_LT); ------------------ | | 1033| 76|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1034| 76| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 76|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 76|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 76|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 76|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 76|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 76| int cond; \ | | 1036| 76| int im = GETARG_sB(i); \ | | ------------------ | | | | 129| 76|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | | | ------------------ | | | | | | 101| 76|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 76|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 76|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 76, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1038| 76| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1649| 76| op_orderI(L, l_gti, luai_numgt, 1, TM_LT); | | | | ------------------ | | | | | | 897| 76|#define l_gti(a,b) (a > b) | | | | ------------------ | | ------------------ | | 1039| 76| 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) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 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| 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)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 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| 76| docondjump(); } | | ------------------ | | | | 1099| 76|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 76|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 115| 76|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1092| 76|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1088| 76|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 76| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 76|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1075| 76|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1099:26): [True: 0, False: 76] | | | | ------------------ | | ------------------ ------------------ 1650| 76| vmbreak; ------------------ | | 16| 76|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 76|#define vmfetch() { \ | | | | 1139| 76| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 76|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 76|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 76] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| i = *(pc++); \ | | | | 1144| 76|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 76|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1651| 76| } 1652| 2.59k| vmcase(OP_GEI) { ------------------ | | 14| 2.59k|#define vmcase(l) L_##l: ------------------ 1653| 2.59k| op_orderI(L, l_gei, luai_numge, 1, TM_LE); ------------------ | | 1033| 2.59k|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1034| 2.59k| StkId ra = RA(i); \ | | ------------------ | | | | 1064| 2.59k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 2.59k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 2.59k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 2.59k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 2.59k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 2.59k| int cond; \ | | 1036| 2.59k| int im = GETARG_sB(i); \ | | ------------------ | | | | 129| 2.59k|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | | | ------------------ | | | | | | 101| 2.59k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 2.59k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 2.59k|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 2.59k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1038| 2.59k| 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) | | | | ------------------ | | ------------------ | | 1039| 2.59k| else if (ttisfloat(s2v(ra))) { \ | | ------------------ | | | | 327| 2.59k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 2.59k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 2.59k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 2.59k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1040| 2.59k| lua_Number fa = fltvalue(s2v(ra)); \ | | ------------------ | | | | 332| 2.59k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 2.59k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1041| 2.59k| lua_Number fim = cast_num(im); \ | | ------------------ | | | | 140| 2.59k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 2.59k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 1042| 2.59k| cond = opf(fa, fim); \ | | ------------------ | | | | 1653| 2.59k| op_orderI(L, l_gei, luai_numge, 1, TM_LE); | | | | ------------------ | | | | | | 354| 2.59k|#define luai_numge(a,b) ((a)>=(b)) | | | | ------------------ | | ------------------ | | 1043| 2.59k| } \ | | 1044| 2.59k| 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)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 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| 2.59k| docondjump(); } | | ------------------ | | | | 1099| 2.59k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 2.59k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 115| 2.59k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #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) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #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: 2.59k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1654| 2.59k| vmbreak; ------------------ | | 16| 2.59k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 2.59k|#define vmfetch() { \ | | | | 1139| 2.59k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 2.59k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 2.59k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 2.59k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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.59k| i = *(pc++); \ | | | | 1144| 2.59k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 2.59k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1655| 2.59k| } 1656| 5.35k| vmcase(OP_TEST) { ------------------ | | 14| 5.35k|#define vmcase(l) L_##l: ------------------ 1657| 5.35k| StkId ra = RA(i); ------------------ | | 1064| 5.35k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 5.35k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 5.35k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 5.35k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 5.35k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1658| 5.35k| int cond = !l_isfalse(s2v(ra)); ------------------ | | 247| 5.35k|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 5.35k|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 10.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 5.35k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 5.35k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 193| 5.35k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 5.35k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 5.35k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 5.35k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 2, False: 5.35k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1659| 5.35k| docondjump(); ------------------ | | 1099| 5.35k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 5.35k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 115| 5.35k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1092| 10|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1088| 10|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 10| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 115| 10|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1075| 10|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1099:26): [True: 5.34k, False: 10] | | ------------------ ------------------ 1660| 5.35k| vmbreak; ------------------ | | 16| 5.35k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 5.35k|#define vmfetch() { \ | | | | 1139| 5.35k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 5.35k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 5.35k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 5.35k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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.35k| i = *(pc++); \ | | | | 1144| 5.35k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 5.35k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1661| 5.35k| } 1662| 5.35k| vmcase(OP_TESTSET) { ------------------ | | 14| 2.59k|#define vmcase(l) L_##l: ------------------ 1663| 2.59k| StkId ra = RA(i); ------------------ | | 1064| 2.59k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 2.59k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 2.59k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 2.59k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 2.59k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1664| 2.59k| TValue *rb = vRB(i); ------------------ | | 1066| 2.59k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 2.59k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1665| 2.59k| if (l_isfalse(rb) == GETARG_k(i)) ------------------ | | 247| 2.59k|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 2.59k|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 5.18k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 2.59k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 2.59k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 193| 2.59k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 2.59k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 2.59k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 2.59k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 2.59k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (l_isfalse(rb) == GETARG_k(i)) ------------------ | | 137| 2.59k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | ------------------ | | | | 115| 2.59k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (1665:13): [True: 2.59k, False: 0] ------------------ 1666| 2.59k| pc++; 1667| 0| else { 1668| 0| setobj2s(L, ra, rb); ------------------ | | 131| 0|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1669| 0| 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) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | ------------------ | | | | | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ ------------------ 1670| 0| } 1671| 2.59k| vmbreak; ------------------ | | 16| 2.59k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 2.59k|#define vmfetch() { \ | | | | 1139| 2.59k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 2.59k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 2.59k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 2.59k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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.59k| i = *(pc++); \ | | | | 1144| 2.59k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 2.59k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1672| 2.59k| } 1673| 83.6k| vmcase(OP_CALL) { ------------------ | | 14| 83.6k|#define vmcase(l) L_##l: ------------------ 1674| 83.6k| StkId ra = RA(i); ------------------ | | 1064| 83.6k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 83.6k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 83.6k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 83.6k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 83.6k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1675| 83.6k| CallInfo *newci; 1676| 83.6k| int b = GETARG_B(i); ------------------ | | 128| 83.6k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 83.6k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1677| 83.6k| int nresults = GETARG_C(i) - 1; ------------------ | | 132| 83.6k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 83.6k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1678| 83.6k| if (b != 0) /* fixed number of arguments? */ ------------------ | Branch (1678:13): [True: 83.6k, False: 0] ------------------ 1679| 83.6k| L->top.p = ra + b; /* top signals number of arguments */ 1680| | /* else previous instruction set top */ 1681| 83.6k| savepc(L); /* in case of errors */ ------------------ | | 1105| 83.6k|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1682| 83.6k| if ((newci = luaD_precall(L, ra, nresults)) == NULL) ------------------ | Branch (1682:13): [True: 0, False: 83.6k] ------------------ 1683| 0| updatetrap(ci); /* C call; nothing else to be done */ ------------------ | | 1075| 0|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1684| 83.6k| else { /* Lua call: run function in this same C frame */ 1685| 83.6k| ci = newci; 1686| 83.6k| goto startfunc; 1687| 83.6k| } 1688| 83.6k| 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| 0| vmcase(OP_TAILCALL) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1691| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1692| 0| int b = GETARG_B(i); /* number of arguments + 1 (function) */ ------------------ | | 128| 0|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1693| 0| int n; /* number of results when calling a C function */ 1694| 0| int nparams1 = GETARG_C(i); ------------------ | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1695| | /* delta is virtual 'func' - real 'func' (vararg functions) */ 1696| 0| int delta = (nparams1) ? ci->u.l.nextraargs + nparams1 : 0; ------------------ | Branch (1696:21): [True: 0, False: 0] ------------------ 1697| 0| if (b != 0) ------------------ | Branch (1697:13): [True: 0, False: 0] ------------------ 1698| 0| 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| 0| savepc(ci); /* several calls here can raise errors */ ------------------ | | 1105| 0|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1702| 0| if (TESTARG_k(i)) { ------------------ | | 136| 0|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1703| 0| luaF_closeupval(L, base); /* close upvalues from current call */ 1704| 0| lua_assert(L->tbclist.p < base); /* no pending tbc variables */ ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 1705| 0| lua_assert(base == ci->func.p + 1); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 1706| 0| } 1707| 0| if ((n = luaD_pretailcall(L, ci, ra, b, delta)) < 0) /* Lua function? */ ------------------ | Branch (1707:13): [True: 0, False: 0] ------------------ 1708| 0| 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| 0| } 1716| 8.01k| vmcase(OP_RETURN) { ------------------ | | 14| 8.01k|#define vmcase(l) L_##l: ------------------ 1717| 8.01k| StkId ra = RA(i); ------------------ | | 1064| 8.01k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 8.01k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 8.01k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 8.01k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 8.01k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1718| 8.01k| int n = GETARG_B(i) - 1; /* number of results */ ------------------ | | 128| 8.01k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 8.01k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1719| 8.01k| int nparams1 = GETARG_C(i); ------------------ | | 132| 8.01k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 8.01k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1720| 8.01k| if (n < 0) /* not fixed? */ ------------------ | Branch (1720:13): [True: 0, False: 8.01k] ------------------ 1721| 0| n = cast_int(L->top.p - ra); /* get what is available */ ------------------ | | 141| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1722| 8.01k| savepc(ci); ------------------ | | 1105| 8.01k|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1723| 8.01k| if (TESTARG_k(i)) { /* may there be open upvalues? */ ------------------ | | 136| 8.01k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 115| 8.01k|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:25): [True: 3, False: 8.01k] | | | | ------------------ | | ------------------ ------------------ 1724| 3| ci->u2.nres = n; /* save number of returns */ 1725| 3| if (L->top.p < ci->top.p) ------------------ | Branch (1725:15): [True: 0, False: 3] ------------------ 1726| 0| L->top.p = ci->top.p; 1727| 3| luaF_close(L, base, CLOSEKTOP, 1); ------------------ | | 47| 3|#define CLOSEKTOP (-1) ------------------ 1728| 3| updatetrap(ci); ------------------ | | 1075| 3|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1729| 3| updatestack(ci); ------------------ | | 1081| 3| { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 697| 3|#define l_unlikely(x) luai_unlikely(x) | | | | ------------------ | | | | | | 685| 3|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | ------------------ | | | | | | | Branch (685:26): [True: 0, False: 3] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | { 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)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1730| 3| } 1731| 8.01k| if (nparams1) /* vararg function? */ ------------------ | Branch (1731:13): [True: 8.01k, False: 0] ------------------ 1732| 8.01k| ci->func.p -= ci->u.l.nextraargs + nparams1; 1733| 8.01k| L->top.p = ra + n; /* set call for 'luaD_poscall' */ 1734| 8.01k| luaD_poscall(L, ci, n); 1735| 8.01k| updatetrap(ci); /* 'luaD_poscall' can change hooks */ ------------------ | | 1075| 8.01k|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1736| 8.01k| goto ret; 1737| 0| } 1738| 75.0k| vmcase(OP_RETURN0) { ------------------ | | 14| 75.0k|#define vmcase(l) L_##l: ------------------ 1739| 75.0k| if (l_unlikely(L->hookmask)) { ------------------ | | 697| 75.0k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 75.0k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 75.0k] | | | | ------------------ | | ------------------ ------------------ 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| 75.0k| else { /* do the 'poscall' here */ 1747| 75.0k| int nres; 1748| 75.0k| L->ci = ci->previous; /* back to caller */ 1749| 75.0k| L->top.p = base - 1; 1750| 75.0k| for (nres = ci->nresults; l_unlikely(nres > 0); nres--) 1751| 75.0k| 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| 75.0k| } 1753| 75.0k| goto ret; 1754| 0| } 1755| 556| vmcase(OP_RETURN1) { ------------------ | | 14| 556|#define vmcase(l) L_##l: ------------------ 1756| 556| if (l_unlikely(L->hookmask)) { ------------------ | | 697| 556|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 556|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 556] | | | | ------------------ | | ------------------ ------------------ 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| 556| else { /* do the 'poscall' here */ 1764| 556| int nres = ci->nresults; 1765| 556| L->ci = ci->previous; /* back to caller */ 1766| 556| if (nres == 0) ------------------ | Branch (1766:15): [True: 0, False: 556] ------------------ 1767| 0| L->top.p = base - 1; /* asked for no results */ 1768| 556| else { 1769| 556| StkId ra = RA(i); ------------------ | | 1064| 556|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 556|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 556|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 556|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 556|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1770| 556| setobjs2s(L, base - 1, ra); /* at least this result */ ------------------ | | 129| 556|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 556| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 556| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 556|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 556| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 556| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 556|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 556| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 556|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1771| 556| L->top.p = base; 1772| 556| for (; l_unlikely(nres > 1); nres--) 1773| 556| setnilvalue(s2v(L->top.p++)); /* complete missing results */ ------------------ | | 200| 556|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 556|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1774| 556| } 1775| 556| } 1776| 83.6k| ret: /* return from a Lua function */ 1777| 83.6k| if (ci->callstatus & CIST_FRESH) ------------------ | | 212| 83.6k|#define CIST_FRESH (1<<2) /* call is on a fresh "luaV_execute" frame */ ------------------ | Branch (1777:13): [True: 8, False: 83.6k] ------------------ 1778| 8| return; /* end this frame */ 1779| 83.6k| else { 1780| 83.6k| ci = ci->previous; 1781| 83.6k| goto returning; /* continue running caller in this frame */ 1782| 83.6k| } 1783| 83.6k| } 1784| 13.5k| vmcase(OP_FORLOOP) { ------------------ | | 14| 13.5k|#define vmcase(l) L_##l: ------------------ 1785| 13.5k| StkId ra = RA(i); ------------------ | | 1064| 13.5k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 13.5k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 13.5k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 13.5k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 13.5k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1786| 13.5k| if (ttisinteger(s2v(ra + 2))) { /* integer loop? */ ------------------ | | 328| 13.5k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 13.5k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 13.5k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 13.5k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1787| 13.5k| lua_Unsigned count = l_castS2U(ivalue(s2v(ra + 1))); ------------------ | | 152| 13.5k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 1788| 13.5k| if (count > 0) { /* still more iterations? */ ------------------ | Branch (1788:15): [True: 13.5k, False: 8] ------------------ 1789| 13.5k| lua_Integer step = ivalue(s2v(ra + 2)); ------------------ | | 333| 13.5k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 13.5k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1790| 13.5k| lua_Integer idx = ivalue(s2v(ra)); /* internal index */ ------------------ | | 333| 13.5k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 13.5k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1791| 13.5k| chgivalue(s2v(ra + 1), count - 1); /* update counter */ ------------------ | | 348| 13.5k| { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 114| 13.5k|#define lua_assert(c) ((void)0) | | ------------------ | | { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 72| 13.5k|#define val_(o) ((o)->value_) | | ------------------ ------------------ 1792| 13.5k| idx = intop(+, idx, step); /* add step to index */ ------------------ | | 73| 13.5k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 13.5k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 1793| 13.5k| chgivalue(s2v(ra), idx); /* update internal index */ ------------------ | | 348| 13.5k| { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 114| 13.5k|#define lua_assert(c) ((void)0) | | ------------------ | | { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 72| 13.5k|#define val_(o) ((o)->value_) | | ------------------ ------------------ 1794| 13.5k| setivalue(s2v(ra + 3), idx); /* and control variable */ ------------------ | | 345| 13.5k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 13.5k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 13.5k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1795| 13.5k| pc -= GETARG_Bx(i); /* jump back */ ------------------ | | 140| 13.5k|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 115| 13.5k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1796| 13.5k| } 1797| 13.5k| } 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)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1800| 13.5k| updatetrap(ci); /* allows a signal to break the loop */ ------------------ | | 1075| 13.5k|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1801| 13.5k| vmbreak; ------------------ | | 16| 13.5k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 13.5k|#define vmfetch() { \ | | | | 1139| 13.5k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 13.5k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 13.5k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 13.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| 13.5k| i = *(pc++); \ | | | | 1144| 13.5k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 13.5k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1802| 13.5k| } 1803| 13.5k| vmcase(OP_FORPREP) { ------------------ | | 14| 17|#define vmcase(l) L_##l: ------------------ 1804| 17| StkId ra = RA(i); ------------------ | | 1064| 17|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 17|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 17|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 17|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 17|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1805| 17| savestate(L, ci); /* in case of errors */ ------------------ | | 1112| 17|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1105| 17|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1806| 17| if (forprep(L, ra)) ------------------ | Branch (1806:13): [True: 0, False: 17] ------------------ 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)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1808| 17| vmbreak; ------------------ | | 16| 17|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 17|#define vmfetch() { \ | | | | 1139| 17| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 17|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 17|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 17] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 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| i = *(pc++); \ | | | | 1144| 17|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 17|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1809| 17| } 1810| 17| 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)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1815| 0| i = *(pc++); /* go to next instruction */ 1816| 0| lua_assert(GET_OPCODE(i) == OP_TFORCALL && ra == RA(i)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 1817| 0| goto l_tforcall; 1818| 17| } 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) | | ------------------ ------------------ 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)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 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) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 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)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 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| 8.00k| vmcase(OP_SETLIST) { ------------------ | | 14| 8.00k|#define vmcase(l) L_##l: ------------------ 1846| 8.00k| StkId ra = RA(i); ------------------ | | 1064| 8.00k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 8.00k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 8.00k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 8.00k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 8.00k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1847| 8.00k| int n = GETARG_B(i); ------------------ | | 128| 8.00k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 8.00k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1848| 8.00k| unsigned int last = GETARG_C(i); ------------------ | | 132| 8.00k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 8.00k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1849| 8.00k| Table *h = hvalue(s2v(ra)); ------------------ | | 682| 8.00k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 8.00k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1850| 8.00k| if (n == 0) ------------------ | Branch (1850:13): [True: 8.00k, False: 0] ------------------ 1851| 8.00k| n = cast_int(L->top.p - ra) - 1; /* get up to the top */ ------------------ | | 141| 8.00k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 8.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| 8.00k| last += n; 1855| 8.00k| if (TESTARG_k(i)) { ------------------ | | 136| 8.00k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 115| 8.00k|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:25): [True: 0, False: 8.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)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ last += GETARG_Ax(*pc) * (MAXARG_C + 1); ------------------ | | 97| 0|#define MAXARG_C ((1< luaH_realasize(h)) /* needs more space? */ ------------------ | Branch (1859:13): [True: 8.00k, False: 0] ------------------ 1860| 8.00k| luaH_resizearray(L, h, last); /* preallocate it at once */ 1861| 176k| for (; n > 0; n--) { ------------------ | Branch (1861:16): [True: 168k, False: 8.00k] ------------------ 1862| 168k| TValue *val = s2v(ra + n); ------------------ | | 172| 168k|#define s2v(o) (&(o)->val) ------------------ 1863| 168k| setobj2t(L, &h->array[last - 1], val); ------------------ | | 137| 168k|#define setobj2t setobj | | ------------------ | | | | 119| 168k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 168k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 168k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 168k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 168k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 168k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 168k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 168k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1864| 168k| last--; 1865| 168k| luaC_barrierback(L, obj2gco(h), val); ------------------ | | 185| 168k|#define luaC_barrierback(L,p,v) ( \ | | 186| 168k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 168k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 168k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 168k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 8.00k, False: 160k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 182| 8.00k|#define luaC_objbarrierback(L,p,o) ( \ | | | | 183| 8.00k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 88| 8.00k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 8.00k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 16.0k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 8.00k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 138| 8.00k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 8.00k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 160k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 160k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1866| 168k| } 1867| 8.00k| vmbreak; ------------------ | | 16| 8.00k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 8.00k|#define vmfetch() { \ | | | | 1139| 8.00k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 8.00k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 8.00k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 8.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| 8.00k| i = *(pc++); \ | | | | 1144| 8.00k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 8.00k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1868| 8.00k| } 1869| 489k| vmcase(OP_CLOSURE) { ------------------ | | 14| 489k|#define vmcase(l) L_##l: ------------------ 1870| 489k| StkId ra = RA(i); ------------------ | | 1064| 489k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 489k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 489k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 489k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 489k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1871| 489k| Proto *p = cl->p->p[GETARG_Bx(i)]; ------------------ | | 140| 489k|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 115| 489k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1872| 489k| halfProtect(pushclosure(L, p, cl->upvals, base, ra)); ------------------ | | 1128| 489k|#define halfProtect(exp) (savestate(L,ci), (exp)) | | ------------------ | | | | 1112| 489k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 489k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ ------------------ 1873| 489k| checkGC(L, ra + 1); ------------------ | | 1132| 489k| { luaC_condGC(L, (savepc(L), L->top.p = (c)), \ | | ------------------ | | | | 168| 489k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 489k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 185, False: 489k] | | | | ------------------ | | | | 169| 489k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 489k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 1133| 489k| updatetrap(ci)); \ | | 1134| 489k| luai_threadyield(L); } | | ------------------ | | | | 273| 489k|#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 265| 489k|#define lua_unlock(L) ((void) 0) | | | | ------------------ | | | | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 264| 489k|#define lua_lock(L) ((void) 0) | | | | ------------------ | | ------------------ ------------------ 1874| 489k| vmbreak; ------------------ | | 16| 489k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 489k|#define vmfetch() { \ | | | | 1139| 489k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 489k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 489k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 1, False: 489k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 1| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 1| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 1|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 1| } \ | | | | 1143| 489k| i = *(pc++); \ | | | | 1144| 489k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 489k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1875| 489k| } 1876| 489k| vmcase(OP_VARARG) { ------------------ | | 14| 8.00k|#define vmcase(l) L_##l: ------------------ 1877| 8.00k| StkId ra = RA(i); ------------------ | | 1064| 8.00k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 8.00k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 8.00k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 8.00k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 8.00k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1878| 8.00k| int n = GETARG_C(i) - 1; /* required results */ ------------------ | | 132| 8.00k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 8.00k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1879| 8.00k| Protect(luaT_getvarargs(L, ci, ra, n)); ------------------ | | 1119| 8.00k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1112| 8.00k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1105| 8.00k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 8.00k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1880| 8.00k| vmbreak; ------------------ | | 16| 8.00k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 8.00k|#define vmfetch() { \ | | | | 1139| 8.00k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 8.00k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 8.00k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 8.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| 8.00k| i = *(pc++); \ | | | | 1144| 8.00k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 8.00k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1881| 8.00k| } 1882| 8.07k| vmcase(OP_VARARGPREP) { ------------------ | | 14| 8.07k|#define vmcase(l) L_##l: ------------------ 1883| 8.07k| ProtectNT(luaT_adjustvarargs(L, GETARG_A(i), ci, cl->p)); ------------------ | | 1122| 8.07k|#define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1105| 8.07k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ | | #define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1075| 8.07k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1884| 8.07k| if (l_unlikely(trap)) { /* previous "Protect" updated trap */ ------------------ | | 697| 8.07k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 8.07k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 2, False: 8.07k] | | | | ------------------ | | ------------------ ------------------ 1885| 2| luaD_hookcall(L, ci); 1886| 2| L->oldpc = 1; /* next opcode will be seen as a "new" line */ 1887| 2| } 1888| 8.07k| updatebase(ci); /* function has new base after adjustment */ ------------------ | | 1077| 8.07k|#define updatebase(ci) (base = ci->func.p + 1) ------------------ 1889| 8.07k| vmbreak; ------------------ | | 16| 8.07k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1138| 8.07k|#define vmfetch() { \ | | | | 1139| 8.07k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 8.07k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 8.07k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 2, False: 8.07k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1140| 2| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1141| 2| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1077| 2|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1142| 2| } \ | | | | 1143| 8.07k| i = *(pc++); \ | | | | 1144| 8.07k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 8.07k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1890| 8.07k| } 1891| 8.07k| vmcase(OP_EXTRAARG) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1892| 0| lua_assert(0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 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| 167k|} lvm.c:l_strton: 90| 19|static int l_strton (const TValue *obj, TValue *result) { 91| 19| lua_assert(obj != result); ------------------ | | 114| 19|#define lua_assert(c) ((void)0) ------------------ 92| 19| if (!cvt2num(obj)) /* is object not a string? */ ------------------ | | 24| 19|#define cvt2num(o) ttisstring(o) | | ------------------ | | | | 363| 19|#define ttisstring(o) checktype((o), LUA_TSTRING) | | | | ------------------ | | | | | | 92| 19|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 19|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 19|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (92:7): [True: 14, False: 5] ------------------ 93| 14| return 0; 94| 5| else { 95| 5| TString *st = tsvalue(obj); ------------------ | | 369| 5|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 5|#define check_exp(c,e) (e) | | ------------------ ------------------ 96| 5| return (luaO_str2num(getstr(st), result) == tsslen(st) + 1); ------------------ | | 404| 5|#define getstr(ts) ((ts)->contents) ------------------ return (luaO_str2num(getstr(st), result) == tsslen(st) + 1); ------------------ | | 411| 5| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 0, False: 5] | | ------------------ ------------------ 97| 5| } 98| 19|} lvm.c:LTnum: 480| 2.30k|l_sinline int LTnum (const TValue *l, const TValue *r) { 481| 2.30k| lua_assert(ttisnumber(l) && ttisnumber(r)); ------------------ | | 114| 2.30k|#define lua_assert(c) ((void)0) ------------------ 482| 2.30k| if (ttisinteger(l)) { ------------------ | | 328| 2.30k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 2.30k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 2.30k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 2.30k] | | | | ------------------ | | ------------------ ------------------ 483| 0| lua_Integer li = ivalue(l); ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 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) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 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) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 488| 0| } 489| 2.30k| else { 490| 2.30k| lua_Number lf = fltvalue(l); /* 'l' must be float */ ------------------ | | 332| 2.30k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 2.30k|#define check_exp(c,e) (e) | | ------------------ ------------------ 491| 2.30k| if (ttisfloat(r)) ------------------ | | 327| 2.30k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 2.30k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 2.30k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 2.30k] | | | | ------------------ | | ------------------ ------------------ 492| 0| return luai_numlt(lf, fltvalue(r)); /* both are float */ ------------------ | | 351| 0|#define luai_numlt(a,b) ((a)<(b)) ------------------ 493| 2.30k| else /* 'l' is float and 'r' is int */ 494| 2.30k| return LTfloatint(lf, ivalue(r)); ------------------ | | 333| 2.30k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 2.30k|#define check_exp(c,e) (e) | | ------------------ ------------------ 495| 2.30k| } 496| 2.30k|} lvm.c:LTfloatint: 447| 2.30k|l_sinline int LTfloatint (lua_Number f, lua_Integer i) { 448| 2.30k| if (l_intfitsf(i)) ------------------ | | 74| 2.30k|#define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 2.30k|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 2.30k|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 2.30k|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 152| 2.30k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 2.30k|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 2.30k|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 2.30k|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (74:23): [True: 1.39k, False: 910] | | ------------------ ------------------ 449| 1.39k| return luai_numlt(f, cast_num(i)); /* compare them as floats */ ------------------ | | 351| 1.39k|#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: 904, False: 6] ------------------ 453| 904| return fi < i; /* compare them as integers */ 454| 6| else /* 'f' is either greater or less than all integers */ 455| 6| return f < 0; /* less? */ 456| 910| } 457| 2.30k|} lvm.c:lessthanothers: 524| 1|static int lessthanothers (lua_State *L, const TValue *l, const TValue *r) { 525| 1| lua_assert(!ttisnumber(l) || !ttisnumber(r)); ------------------ | | 114| 1|#define lua_assert(c) ((void)0) ------------------ 526| 1| if (ttisstring(l) && ttisstring(r)) /* both are strings? */ ------------------ | | 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(l) && ttisstring(r)) /* both are strings? */ ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 527| 0| return l_strcmp(tsvalue(l), tsvalue(r)) < 0; ------------------ | | 369| 0|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ return l_strcmp(tsvalue(l), tsvalue(r)) < 0; ------------------ | | 369| 0|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 528| 1| else 529| 1| return luaT_callorderTM(L, l, r, TM_LT); 530| 1|} lvm.c:LEnum: 502| 137k|l_sinline int LEnum (const TValue *l, const TValue *r) { 503| 137k| lua_assert(ttisnumber(l) && ttisnumber(r)); ------------------ | | 114| 137k|#define lua_assert(c) ((void)0) ------------------ 504| 137k| if (ttisinteger(l)) { ------------------ | | 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: 2.59k, False: 134k] | | | | ------------------ | | ------------------ ------------------ 505| 2.59k| lua_Integer li = ivalue(l); ------------------ | | 333| 2.59k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 2.59k|#define check_exp(c,e) (e) | | ------------------ ------------------ 506| 2.59k| if (ttisinteger(r)) ------------------ | | 328| 2.59k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 2.59k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 2.59k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 2.59k] | | | | ------------------ | | ------------------ ------------------ 507| 0| return li <= ivalue(r); /* both are integers */ ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 508| 2.59k| else /* 'l' is int and 'r' is float */ 509| 2.59k| return LEintfloat(li, fltvalue(r)); /* l <= r ? */ ------------------ | | 332| 2.59k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 2.59k|#define check_exp(c,e) (e) | | ------------------ ------------------ 510| 2.59k| } 511| 134k| else { 512| 134k| lua_Number lf = fltvalue(l); /* 'l' must be float */ ------------------ | | 332| 134k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 134k|#define check_exp(c,e) (e) | | ------------------ ------------------ 513| 134k| if (ttisfloat(r)) ------------------ | | 327| 134k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 134k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 134k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 1, False: 134k] | | | | ------------------ | | ------------------ ------------------ 514| 1| return luai_numle(lf, fltvalue(r)); /* both are float */ ------------------ | | 352| 1|#define luai_numle(a,b) ((a)<=(b)) ------------------ 515| 134k| else /* 'l' is float and 'r' is int */ 516| 134k| return LEfloatint(lf, ivalue(r)); ------------------ | | 333| 134k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 134k|#define check_exp(c,e) (e) | | ------------------ ------------------ 517| 134k| } 518| 137k|} lvm.c:LEintfloat: 430| 2.59k|l_sinline int LEintfloat (lua_Integer i, lua_Number f) { 431| 2.59k| if (l_intfitsf(i)) ------------------ | | 74| 2.59k|#define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 2.59k|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 2.59k|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 2.59k|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 152| 2.59k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 2.59k|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 2.59k|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 2.59k|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (74:23): [True: 0, False: 2.59k] | | ------------------ ------------------ 432| 0| return luai_numle(cast_num(i), f); /* compare them as floats */ ------------------ | | 352| 0|#define luai_numle(a,b) ((a)<=(b)) ------------------ 433| 2.59k| else { /* i <= f <=> i <= floor(f) */ 434| 2.59k| lua_Integer fi; 435| 2.59k| if (luaV_flttointeger(f, &fi, F2Ifloor)) /* fi = floor(f) */ ------------------ | Branch (435:9): [True: 0, False: 2.59k] ------------------ 436| 0| return i <= fi; /* compare them as integers */ 437| 2.59k| else /* 'f' is either greater or less than all integers */ 438| 2.59k| return f > 0; /* greater? */ 439| 2.59k| } 440| 2.59k|} lvm.c:LEfloatint: 464| 134k|l_sinline int LEfloatint (lua_Number f, lua_Integer i) { 465| 134k| if (l_intfitsf(i)) ------------------ | | 74| 134k|#define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 134k|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 134k|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 134k|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 152| 134k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 134k|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 134k|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 134k|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (74:23): [True: 118k, False: 16.0k] | | ------------------ ------------------ 466| 118k| return luai_numle(f, cast_num(i)); /* compare them as floats */ ------------------ | | 352| 118k|#define luai_numle(a,b) ((a)<=(b)) ------------------ 467| 16.0k| else { /* f <= i <=> ceil(f) <= i */ 468| 16.0k| lua_Integer fi; 469| 16.0k| if (luaV_flttointeger(f, &fi, F2Iceil)) /* fi = ceil(f) */ ------------------ | Branch (469:9): [True: 16.0k, False: 0] ------------------ 470| 16.0k| 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| 16.0k| } 474| 134k|} lvm.c:lessequalothers: 546| 1|static int lessequalothers (lua_State *L, const TValue *l, const TValue *r) { 547| 1| lua_assert(!ttisnumber(l) || !ttisnumber(r)); ------------------ | | 114| 1|#define lua_assert(c) ((void)0) ------------------ 548| 1| if (ttisstring(l) && ttisstring(r)) /* both are strings? */ ------------------ | | 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(l) && ttisstring(r)) /* both are strings? */ ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 549| 0| return l_strcmp(tsvalue(l), tsvalue(r)) <= 0; ------------------ | | 369| 0|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ return l_strcmp(tsvalue(l), tsvalue(r)) <= 0; ------------------ | | 369| 0|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 550| 1| else 551| 1| return luaT_callorderTM(L, l, r, TM_LE); 552| 1|} lvm.c:copy2buff: 628| 65.7k|static void copy2buff (StkId top, int n, char *buff) { 629| 65.7k| size_t tl = 0; /* size already copied */ 630| 131k| do { 631| 131k| TString *st = tsvalue(s2v(top - n)); ------------------ | | 369| 131k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 131k|#define check_exp(c,e) (e) | | ------------------ ------------------ 632| 131k| size_t l = tsslen(st); /* length of string being copied */ ------------------ | | 411| 131k| ((s)->shrlen != 0xFF ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | Branch (411:3): [True: 131k, False: 204] | | ------------------ ------------------ 633| 131k| memcpy(buff + tl, getstr(st), l * sizeof(char)); ------------------ | | 404| 131k|#define getstr(ts) ((ts)->contents) ------------------ 634| 131k| tl += l; 635| 131k| } while (--n > 0); ------------------ | Branch (635:12): [True: 65.7k, False: 65.7k] ------------------ 636| 65.7k|} lvm.c:forprep: 208| 17|static int forprep (lua_State *L, StkId ra) { 209| 17| TValue *pinit = s2v(ra); ------------------ | | 172| 17|#define s2v(o) (&(o)->val) ------------------ 210| 17| TValue *plimit = s2v(ra + 1); ------------------ | | 172| 17|#define s2v(o) (&(o)->val) ------------------ 211| 17| TValue *pstep = s2v(ra + 2); ------------------ | | 172| 17|#define s2v(o) (&(o)->val) ------------------ 212| 17| if (ttisinteger(pinit) && ttisinteger(pstep)) { /* integer loop? */ ------------------ | | 328| 17|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 34|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 17|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 16, False: 1] | | | | ------------------ | | ------------------ ------------------ if (ttisinteger(pinit) && ttisinteger(pstep)) { /* integer loop? */ ------------------ | | 328| 16|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 16|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 16|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 16, False: 0] | | | | ------------------ | | ------------------ ------------------ 213| 16| lua_Integer init = ivalue(pinit); ------------------ | | 333| 16|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ 214| 16| lua_Integer step = ivalue(pstep); ------------------ | | 333| 16|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ 215| 16| lua_Integer limit; 216| 16| if (step == 0) ------------------ | Branch (216:9): [True: 0, False: 16] ------------------ 217| 0| luaG_runerror(L, "'for' step is zero"); 218| 16| setivalue(s2v(ra + 3), init); /* control variable */ ------------------ | | 345| 16| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 16|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 219| 16| if (forlimit(L, init, plimit, &limit, step)) ------------------ | Branch (219:9): [True: 0, False: 16] ------------------ 220| 0| return 1; /* skip the loop */ 221| 16| else { /* prepare loop counter */ 222| 16| lua_Unsigned count; 223| 16| if (step > 0) { /* ascending loop? */ ------------------ | Branch (223:11): [True: 14, False: 2] ------------------ 224| 14| count = l_castS2U(limit) - l_castS2U(init); ------------------ | | 152| 14|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ count = l_castS2U(limit) - l_castS2U(init); ------------------ | | 152| 14|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 225| 14| if (step != 1) /* avoid division in the too common case */ ------------------ | Branch (225:13): [True: 0, False: 14] ------------------ 226| 0| count /= l_castS2U(step); ------------------ | | 152| 0|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 227| 14| } 228| 2| else { /* step < 0; descending loop */ 229| 2| count = l_castS2U(init) - l_castS2U(limit); ------------------ | | 152| 2|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ count = l_castS2U(init) - l_castS2U(limit); ------------------ | | 152| 2|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 230| | /* 'step+1' avoids negating 'mininteger' */ 231| 2| count /= l_castS2U(-(step + 1)) + 1u; ------------------ | | 152| 2|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 232| 2| } 233| | /* store the counter in place of the limit (which won't be 234| | needed anymore) */ 235| 16| setivalue(plimit, l_castU2S(count)); ------------------ | | 345| 16| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 16|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 236| 16| } 237| 16| } 238| 1| else { /* try making all values floats */ 239| 1| lua_Number init; lua_Number limit; lua_Number step; 240| 1| if (l_unlikely(!tonumber(plimit, &limit))) ------------------ | | 697| 1|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 2|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 1, False: 0] | | | | | Branch (685:46): [True: 0, False: 1] | | | | ------------------ | | ------------------ ------------------ 241| 1| 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] | | | | ------------------ | | ------------------ ------------------ 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] | | | | ------------------ | | ------------------ ------------------ 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| 16| return 0; 260| 17|} lvm.c:forlimit: 179| 16| lua_Integer *p, lua_Integer step) { 180| 16| if (!luaV_tointeger(lim, p, (step < 0 ? F2Iceil : F2Ifloor))) { ------------------ | Branch (180:7): [True: 2, False: 14] | Branch (180:32): [True: 0, False: 16] ------------------ 181| | /* not coercible to in integer */ 182| 2| lua_Number flim; /* try to convert to float */ 183| 2| if (!tonumber(lim, &flim)) /* cannot convert to float? */ ------------------ | | 52| 2| (ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n)) | | ------------------ | | | | 327| 2|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 2|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 2|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n)) | | ------------------ | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ | Branch (183:9): [True: 2, False: 0] ------------------ 184| 2| 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| 14| return (step > 0 ? init > *p : init < *p); /* not to run? */ ------------------ | Branch (195:11): [True: 14, False: 0] ------------------ 196| 16|} lvm.c:pushclosure: 794| 489k| StkId ra) { 795| 489k| int nup = p->sizeupvalues; 796| 489k| Upvaldesc *uv = p->upvalues; 797| 489k| int i; 798| 489k| LClosure *ncl = luaF_newLclosure(L, nup); 799| 489k| ncl->p = p; 800| 489k| setclLvalue2s(L, ra, ncl); /* anchor new closure in stack */ ------------------ | | 613| 489k|#define setclLvalue2s(L,o,cl) setclLvalue(L,s2v(o),cl) | | ------------------ | | | | 609| 489k| { TValue *io = (obj); LClosure *x_ = (x); \ | | | | 610| 489k| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 72| 489k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 390| 489k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 489k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 114| 489k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 611| 489k| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 489k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 489k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 489k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 801| 576k| for (i = 0; i < nup; i++) { /* fill in its upvalues */ ------------------ | Branch (801:15): [True: 86.5k, False: 489k] ------------------ 802| 86.5k| if (uv[i].instack) /* upvalue refers to local variable? */ ------------------ | Branch (802:9): [True: 3.14k, False: 83.3k] ------------------ 803| 3.14k| ncl->upvals[i] = luaF_findupval(L, base + uv[i].idx); 804| 83.3k| else /* get upvalue from enclosing function */ 805| 83.3k| ncl->upvals[i] = encup[uv[i].idx]; 806| 86.5k| luaC_objbarrier(L, ncl, ncl->upvals[i]); ------------------ | | 175| 86.5k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 86.5k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 86.5k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 86.5k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 173k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 86.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| 86.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)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 86.5k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 86.5k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 807| 86.5k| } 808| 489k|} luaZ_fill: 23| 507|int luaZ_fill (ZIO *z) { 24| 507| size_t size; 25| 507| lua_State *L = z->L; 26| 507| const char *buff; 27| 507| lua_unlock(L); ------------------ | | 265| 507|#define lua_unlock(L) ((void) 0) ------------------ 28| 507| buff = z->reader(L, z->data, &size); 29| 507| lua_lock(L); ------------------ | | 264| 507|#define lua_lock(L) ((void) 0) ------------------ 30| 507| if (buff == NULL || size == 0) ------------------ | Branch (30:7): [True: 117, False: 390] | Branch (30:23): [True: 0, False: 390] ------------------ 31| 117| return EOZ; ------------------ | | 16| 117|#define EOZ (-1) /* end of stream */ ------------------ 32| 390| z->n = size - 1; /* discount char being returned */ 33| 390| z->p = buff; 34| 390| return cast_uchar(*(z->p++)); ------------------ | | 144| 390|#define cast_uchar(i) cast(unsigned char, (i)) | | ------------------ | | | | 136| 390|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 35| 507|} luaZ_init: 38| 390|void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) { 39| 390| z->L = L; 40| 390| z->reader = reader; 41| 390| z->data = data; 42| 390| z->n = 0; 43| 390| z->p = NULL; 44| 390|}