LLVMFuzzerTestOneInput: 145| 561|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 146| 561| lua_State *L = luaL_newstate(); 147| 561| if (L == NULL) { ------------------ | Branch (147:9): [True: 0, False: 561] ------------------ 148| 0| return 0; 149| 0| } 150| 561| dochunk(L, luaL_loadbufferx(L, (const char *)data, size, "test", "t")); 151| | 152| | 153| 561| lua_close(L); 154| 561| return 0; 155| 561|} fuzz_lua.c:dochunk: 134| 561|static int dochunk (lua_State *L, int status) { 135| 561| if (status == LUA_OK) status = docall(L, 0, 0); ------------------ | | 48| 561|#define LUA_OK 0 ------------------ | Branch (135:7): [True: 162, False: 399] ------------------ 136| 561| return report(L, status); 137| 561|} fuzz_lua.c:docall: 120| 162|static int docall (lua_State *L, int narg, int nres) { 121| 162| int status; 122| 162| int base = lua_gettop(L) - narg; /* function index */ 123| 162| lua_pushcfunction(L, msghandler); /* push message handler */ ------------------ | | 400| 162|#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0) ------------------ 124| 162| lua_insert(L, base); /* put it under function and args */ ------------------ | | 419| 162|#define lua_insert(L,idx) lua_rotate(L, (idx), 1) ------------------ 125| 162| globalL = L; /* to be available to 'laction' */ 126| 162| signal(SIGINT, laction); /* set C-signal handler */ 127| 162| status = lua_pcall(L, narg, nres, base); ------------------ | | 299| 162|#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) ------------------ 128| 162| signal(SIGINT, SIG_DFL); /* reset C-signal handler */ 129| 162| lua_remove(L, base); /* remove message handler from the stack */ ------------------ | | 421| 162|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 394| 162|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 130| 162| return status; 131| 162|} fuzz_lua.c:msghandler: 101| 153|static int msghandler (lua_State *L) { 102| 153| const char *msg = lua_tostring(L, 1); ------------------ | | 416| 153|#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) ------------------ 103| 153| if (msg == NULL) { /* is error object not a string? */ ------------------ | Branch (103:7): [True: 0, False: 153] ------------------ 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)); ------------------ | | 144| 0|#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) ------------------ 110| 0| } 111| 153| luaL_traceback(L, L, msg, 1); /* append a standard traceback */ 112| 153| return 1; /* return the traceback */ 113| 153|} fuzz_lua.c:report: 89| 561|static int report (lua_State *L, int status) { 90| 561| if (status != LUA_OK) { ------------------ | | 48| 561|#define LUA_OK 0 ------------------ | Branch (90:7): [True: 552, False: 9] ------------------ 91| 552| const char *msg = lua_tostring(L, -1); ------------------ | | 416| 552|#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) ------------------ 92| 552| l_message(progname, msg); 93| 552| lua_pop(L, 1); /* remove message */ ------------------ | | 394| 552|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 94| 552| } 95| 561| return status; 96| 561|} fuzz_lua.c:l_message: 78| 552|static void l_message (const char *pname, const char *msg) { 79| 552| if (pname) lua_writestringerror("%s: ", pname); ------------------ | | 273| 552| (fprintf(stderr, (s), (p)), fflush(stderr)) ------------------ | Branch (79:7): [True: 552, False: 0] ------------------ 80| 552| lua_writestringerror("%s\n", msg); ------------------ | | 273| 552| (fprintf(stderr, (s), (p)), fflush(stderr)) ------------------ 81| 552|} lua_checkstack: 121| 45|LUA_API int lua_checkstack (lua_State *L, int n) { 122| 45| int res; 123| 45| CallInfo *ci; 124| 45| lua_lock(L); ------------------ | | 267| 45|#define lua_lock(L) ((void) 0) ------------------ 125| 45| ci = L->ci; 126| 45| api_check(L, n >= 0, "negative 'n'"); ------------------ | | 129| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 127| 45| if (L->stack_last.p - L->top.p > n) /* stack large enough? */ ------------------ | Branch (127:7): [True: 45, False: 0] ------------------ 128| 45| res = 1; /* yes; check is OK */ 129| 0| else /* need to grow stack */ 130| 0| res = luaD_growstack(L, n, 0); 131| 45| if (res && ci->top.p < L->top.p + n) ------------------ | Branch (131:7): [True: 45, False: 0] | Branch (131:14): [True: 0, False: 45] ------------------ 132| 0| ci->top.p = L->top.p + n; /* adjust frame top */ 133| 45| lua_unlock(L); ------------------ | | 268| 45|#define lua_unlock(L) ((void) 0) ------------------ 134| 45| return res; 135| 45|} lua_atpanic: 154| 561|LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) { 155| 561| lua_CFunction old; 156| 561| lua_lock(L); ------------------ | | 267| 561|#define lua_lock(L) ((void) 0) ------------------ 157| 561| old = G(L)->panic; ------------------ | | 333| 561|#define G(L) (L->l_G) ------------------ 158| 561| G(L)->panic = panicf; ------------------ | | 333| 561|#define G(L) (L->l_G) ------------------ 159| 561| lua_unlock(L); ------------------ | | 268| 561|#define lua_unlock(L) ((void) 0) ------------------ 160| 561| return old; 161| 561|} lua_gettop: 186| 363|LUA_API int lua_gettop (lua_State *L) { 187| 363| return cast_int(L->top.p - (L->ci->func.p + 1)); ------------------ | | 144| 363|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 363|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 188| 363|} lua_settop: 191| 1.60k|LUA_API void lua_settop (lua_State *L, int idx) { 192| 1.60k| CallInfo *ci; 193| 1.60k| StkId func, newtop; 194| 1.60k| ptrdiff_t diff; /* difference for new top */ 195| 1.60k| lua_lock(L); ------------------ | | 267| 1.60k|#define lua_lock(L) ((void) 0) ------------------ 196| 1.60k| ci = L->ci; 197| 1.60k| func = ci->func.p; 198| 1.60k| if (idx >= 0) { ------------------ | Branch (198:7): [True: 201, False: 1.40k] ------------------ 199| 201| api_check(L, idx <= ci->top.p - (func + 1), "new top too large"); ------------------ | | 129| 201|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 201|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 200| 201| diff = ((func + 1) + idx) - L->top.p; 201| 201| for (; diff > 0; diff--) ------------------ | Branch (201:12): [True: 0, False: 201] ------------------ 202| 201| setnilvalue(s2v(L->top.p++)); /* clear new slots */ ------------------ | | 211| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 201|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 203| 201| } 204| 1.40k| else { 205| 1.40k| api_check(L, -(idx+1) <= (L->top.p - (func + 1)), "invalid new top"); ------------------ | | 129| 1.40k|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 1.40k|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 206| 1.40k| diff = idx + 1; /* will "subtract" index (as it is negative) */ 207| 1.40k| } 208| 1.60k| newtop = L->top.p + diff; 209| 1.60k| if (diff < 0 && L->tbclist.p >= newtop) { ------------------ | Branch (209:7): [True: 1.56k, False: 45] | Branch (209:19): [True: 0, False: 1.56k] ------------------ 210| 0| lua_assert(hastocloseCfunc(ci->nresults)); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ 211| 0| newtop = luaF_close(L, newtop, CLOSEKTOP, 0); ------------------ | | 47| 0|#define CLOSEKTOP (-1) ------------------ 212| 0| } 213| 1.60k| L->top.p = newtop; /* correct top only after closing any upvalue */ 214| 1.60k| lua_unlock(L); ------------------ | | 268| 1.60k|#define lua_unlock(L) ((void) 0) ------------------ 215| 1.60k|} lua_closeslot: 218| 45|LUA_API void lua_closeslot (lua_State *L, int idx) { 219| 45| StkId level; 220| 45| lua_lock(L); ------------------ | | 267| 45|#define lua_lock(L) ((void) 0) ------------------ 221| 45| level = index2stack(L, idx); 222| 45| api_check(L, hastocloseCfunc(L->ci->nresults) && L->tbclist.p == level, ------------------ | | 129| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 223| 45| "no variable to close at given level"); 224| 45| level = luaF_close(L, level, CLOSEKTOP, 0); ------------------ | | 47| 45|#define CLOSEKTOP (-1) ------------------ 225| 45| setnilvalue(s2v(level)); ------------------ | | 211| 45|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 226| 45| lua_unlock(L); ------------------ | | 268| 45|#define lua_unlock(L) ((void) 0) ------------------ 227| 45|} lua_rotate: 250| 567|LUA_API void lua_rotate (lua_State *L, int idx, int n) { 251| 567| StkId p, t, m; 252| 567| lua_lock(L); ------------------ | | 267| 567|#define lua_lock(L) ((void) 0) ------------------ 253| 567| t = L->top.p - 1; /* end of stack segment being rotated */ 254| 567| p = index2stack(L, idx); /* start of segment */ 255| 567| api_check(L, L->tbclist.p < p, "moving a to-be-closed slot"); ------------------ | | 129| 567|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 567|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 256| 567| api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'"); ------------------ | | 129| 567|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 567|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 257| 567| m = (n >= 0 ? t - n : p - n - 1); /* end of prefix */ ------------------ | Branch (257:8): [True: 207, False: 360] ------------------ 258| 567| reverse(L, p, m); /* reverse the prefix with length 'n' */ 259| 567| reverse(L, m + 1, t); /* reverse the suffix */ 260| 567| reverse(L, p, t); /* reverse the entire segment */ 261| 567| lua_unlock(L); ------------------ | | 268| 567|#define lua_unlock(L) ((void) 0) ------------------ 262| 567|} lua_pushvalue: 280| 45|LUA_API void lua_pushvalue (lua_State *L, int idx) { 281| 45| lua_lock(L); ------------------ | | 267| 45|#define lua_lock(L) ((void) 0) ------------------ 282| 45| setobj2s(L, L->top.p, index2value(L, idx)); ------------------ | | 131| 45|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 45| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 45| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 45| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 45| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 720|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 45| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 283| 45| api_incr_top(L); ------------------ | | 17| 45| (L->top.p++, api_check(L, L->top.p <= L->ci->top.p, "stack overflow")) | | ------------------ | | | | 129| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ ------------------ 284| 45| lua_unlock(L); ------------------ | | 268| 45|#define lua_unlock(L) ((void) 0) ------------------ 285| 45|} lua_type: 294| 201|LUA_API int lua_type (lua_State *L, int idx) { 295| 201| const TValue *o = index2value(L, idx); 296| 201| return (isvalid(L, o) ? ttype(o) : LUA_TNONE); ------------------ | | 46| 201|#define isvalid(L, o) (!ttisnil(o) || o != &G(L)->nilvalue) | | ------------------ | | | | 196| 201|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 402|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 201|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 201|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define isvalid(L, o) (!ttisnil(o) || o != &G(L)->nilvalue) | | ------------------ | | | | 333| 201|#define G(L) (L->l_G) | | ------------------ | | | Branch (46:24): [True: 0, False: 201] | | | Branch (46:39): [True: 201, False: 0] | | ------------------ ------------------ return (isvalid(L, o) ? ttype(o) : LUA_TNONE); ------------------ | | 87| 201|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 201|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ return (isvalid(L, o) ? ttype(o) : LUA_TNONE); ------------------ | | 62| 0|#define LUA_TNONE (-1) ------------------ 297| 201|} lua_tolstring: 415| 1.10k|LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) { 416| 1.10k| TValue *o; 417| 1.10k| lua_lock(L); ------------------ | | 267| 1.10k|#define lua_lock(L) ((void) 0) ------------------ 418| 1.10k| o = index2value(L, idx); 419| 1.10k| if (!ttisstring(o)) { ------------------ | | 376| 1.10k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 1.10k|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 1.10k|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 1.10k|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (419:7): [True: 0, False: 1.10k] ------------------ 420| 0| if (!cvt2str(o)) { /* not convertible? */ ------------------ | | 17| 0|#define cvt2str(o) ttisnumber(o) | | ------------------ | | | | 339| 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 (420:9): [True: 0, False: 0] ------------------ 421| 0| if (len != NULL) *len = 0; ------------------ | Branch (421:11): [True: 0, False: 0] ------------------ 422| 0| lua_unlock(L); ------------------ | | 268| 0|#define lua_unlock(L) ((void) 0) ------------------ 423| 0| return NULL; 424| 0| } 425| 0| luaO_tostring(L, o); 426| 0| luaC_checkGC(L); ------------------ | | 219| 0|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 215| 0| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 0|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 0, False: 0] | | | | ------------------ | | | | 216| 0| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 0|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 427| 0| o = index2value(L, idx); /* previous call may reallocate the stack */ 428| 0| } 429| 1.10k| lua_unlock(L); ------------------ | | 268| 1.10k|#define lua_unlock(L) ((void) 0) ------------------ 430| 1.10k| if (len != NULL) ------------------ | Branch (430:7): [True: 404, False: 705] ------------------ 431| 404| return getlstr(tsvalue(o), *len); ------------------ | | 440| 404| (strisshr(ts) \ | | ------------------ | | | | 420| 3.23k|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 404, False: 0] | | | | | Branch (420:24): [True: 0, False: 404] | | | | | Branch (420:24): [True: 404, False: 0] | | | | | Branch (420:24): [True: 0, False: 404] | | | | | Branch (420:24): [True: 404, False: 0] | | | | ------------------ | | ------------------ | | 441| 808| ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 141| 404|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 3.23k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (139:27): [True: 0, False: 404] | | | | | | | Branch (139:27): [True: 404, False: 0] | | | | | | | Branch (139:27): [True: 0, False: 404] | | | | | | | Branch (139:27): [True: 404, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 427| 404|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 404|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 3.23k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | | | | Branch (139:27): [True: 0, False: 404] | | | | | | | | | Branch (139:27): [True: 404, False: 0] | | | | | | | | | Branch (139:27): [True: 0, False: 404] | | | | | | | | | Branch (139:27): [True: 404, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 442| 404| : (cast_void((len) = (ts)->u.lnglen), (ts)->contents)) | | ------------------ | | | | 141| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (442:41): [True: 0, False: 0] | | | Branch (442:41): [True: 0, False: 0] | | | Branch (442:41): [True: 0, False: 0] | | | Branch (442:41): [True: 0, False: 0] | | ------------------ ------------------ 432| 705| else 433| 705| return getstr(tsvalue(o)); ------------------ | | 430| 5.48k|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 5.64k|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 19, False: 686] | | | | | Branch (420:24): [True: 0, False: 705] | | | | | Branch (420:24): [True: 705, False: 0] | | | | | Branch (420:24): [True: 0, False: 705] | | | | | Branch (420:24): [True: 705, False: 0] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 38|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 19|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 152|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | | | | Branch (139:27): [True: 0, False: 19] | | | | | | | | | Branch (139:27): [True: 19, False: 0] | | | | | | | | | Branch (139:27): [True: 0, False: 19] | | | | | | | | | Branch (139:27): [True: 19, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (430:57): [True: 0, False: 686] | | | Branch (430:57): [True: 686, False: 0] | | | Branch (430:57): [True: 0, False: 686] | | | Branch (430:57): [True: 686, False: 0] | | ------------------ ------------------ 434| 1.10k|} lua_touserdata: 467| 1.13k|LUA_API void *lua_touserdata (lua_State *L, int idx) { 468| 1.13k| const TValue *o = index2value(L, idx); 469| 1.13k| return touserdata(o); 470| 1.13k|} lua_pushlstring: 537| 108|LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) { 538| 108| TString *ts; 539| 108| lua_lock(L); ------------------ | | 267| 108|#define lua_lock(L) ((void) 0) ------------------ 540| 108| ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len); ------------------ | Branch (540:8): [True: 0, False: 108] ------------------ 541| 108| setsvalue2s(L, L->top.p, ts); ------------------ | | 390| 108|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 385| 108| { TValue *io = (obj); TString *x_ = (x); \ | | | | 386| 108| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 108|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 388| 108|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 108|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 108|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 108|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 387| 108| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 108| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 1.72k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 108|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 108] | | | | | | | | | Branch (115:29): [True: 108, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 108] | | | | | | | | | Branch (115:29): [True: 108, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 108] | | | | | | | | | Branch (115:29): [True: 108, False: 0] | | | | | | | | | Branch (115:29): [True: 108, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 108] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 108| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 542| 108| api_incr_top(L); ------------------ | | 17| 108| (L->top.p++, api_check(L, L->top.p <= L->ci->top.p, "stack overflow")) | | ------------------ | | | | 129| 108|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 108|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ ------------------ 543| 108| advancegc(L, len); 544| 108| luaC_checkGC(L); ------------------ | | 219| 108|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 215| 108| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 108|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 17, False: 91] | | | | ------------------ | | | | 216| 108| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 108|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 545| 108| lua_unlock(L); ------------------ | | 268| 108|#define lua_unlock(L) ((void) 0) ------------------ 546| 108| return getstr(ts); ------------------ | | 430| 108|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 108|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 0, False: 108] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 0|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 0|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 547| 108|} lua_pushextlstring: 551| 45| const char *s, size_t len, lua_Alloc falloc, void *ud) { 552| 45| TString *ts; 553| 45| lua_lock(L); ------------------ | | 267| 45|#define lua_lock(L) ((void) 0) ------------------ 554| 45| api_check(L, s[len] == '\0', "string not ending with zero"); ------------------ | | 129| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 555| 45| ts = luaS_newextlstr (L, s, len, falloc, ud); 556| 45| setsvalue2s(L, L->top.p, ts); ------------------ | | 390| 45|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 385| 45| { TValue *io = (obj); TString *x_ = (x); \ | | | | 386| 45| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 45|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 388| 45|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 45|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 387| 45| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 45| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 720|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 45| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 557| 45| api_incr_top(L); ------------------ | | 17| 45| (L->top.p++, api_check(L, L->top.p <= L->ci->top.p, "stack overflow")) | | ------------------ | | | | 129| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ ------------------ 558| 45| if (falloc != NULL) /* non-static string? */ ------------------ | Branch (558:7): [True: 45, False: 0] ------------------ 559| 45| advancegc(L, len); /* count its memory */ 560| 45| luaC_checkGC(L); ------------------ | | 219| 45|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 215| 45| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 45|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 41, False: 4] | | | | ------------------ | | | | 216| 45| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 45|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 561| 45| lua_unlock(L); ------------------ | | 268| 45|#define lua_unlock(L) ((void) 0) ------------------ 562| 45| return getstr(ts); ------------------ | | 430| 45|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 45|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 0, False: 45] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 0|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 0|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 563| 45|} lua_pushstring: 566| 198|LUA_API const char *lua_pushstring (lua_State *L, const char *s) { 567| 198| lua_lock(L); ------------------ | | 267| 198|#define lua_lock(L) ((void) 0) ------------------ 568| 198| if (s == NULL) ------------------ | Branch (568:7): [True: 0, False: 198] ------------------ 569| 198| setnilvalue(s2v(L->top.p)); ------------------ | | 211| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 570| 198| else { 571| 198| TString *ts; 572| 198| ts = luaS_new(L, s); 573| 198| setsvalue2s(L, L->top.p, ts); ------------------ | | 390| 198|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 385| 198| { TValue *io = (obj); TString *x_ = (x); \ | | | | 386| 198| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 198|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 388| 198|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 198|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 198|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 198|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 387| 198| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 198| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 3.16k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 198|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 198] | | | | | | | | | Branch (115:29): [True: 198, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 198] | | | | | | | | | Branch (115:29): [True: 198, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 198] | | | | | | | | | Branch (115:29): [True: 198, False: 0] | | | | | | | | | Branch (115:29): [True: 198, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 198] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 198| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 574| 198| s = getstr(ts); /* internal copy's address */ ------------------ | | 430| 198|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 198|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 198, False: 0] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 198|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 198|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 198|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 575| 198| } 576| 198| api_incr_top(L); ------------------ | | 17| 198| (L->top.p++, api_check(L, L->top.p <= L->ci->top.p, "stack overflow")) | | ------------------ | | | | 129| 198|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 198|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ ------------------ 577| 198| luaC_checkGC(L); ------------------ | | 219| 198|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 215| 198| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 198|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 3, False: 195] | | | | ------------------ | | | | 216| 198| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 198|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 578| 198| lua_unlock(L); ------------------ | | 268| 198|#define lua_unlock(L) ((void) 0) ------------------ 579| 198| return s; 580| 198|} lua_pushfstring: 594| 251|LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) { 595| 251| const char *ret; 596| 251| va_list argp; 597| 251| lua_lock(L); ------------------ | | 267| 251|#define lua_lock(L) ((void) 0) ------------------ 598| 251| va_start(argp, fmt); 599| 251| ret = luaO_pushvfstring(L, fmt, argp); 600| 251| va_end(argp); 601| 251| luaC_checkGC(L); ------------------ | | 219| 251|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 215| 251| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 251|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 6, False: 245] | | | | ------------------ | | | | 216| 251| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 251|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 602| 251| lua_unlock(L); ------------------ | | 268| 251|#define lua_unlock(L) ((void) 0) ------------------ 603| 251| return ret; 604| 251|} lua_pushcclosure: 607| 252|LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) { 608| 252| lua_lock(L); ------------------ | | 267| 252|#define lua_lock(L) ((void) 0) ------------------ 609| 252| if (n == 0) { ------------------ | Branch (609:7): [True: 252, False: 0] ------------------ 610| 252| setfvalue(s2v(L->top.p), fn); ------------------ | | 655| 252| { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_VLCF); } | | ------------------ | | | | 72| 252|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_VLCF); } | | ------------------ | | | | 114| 252|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 611| 252| api_incr_top(L); ------------------ | | 17| 252| (L->top.p++, api_check(L, L->top.p <= L->ci->top.p, "stack overflow")) | | ------------------ | | | | 129| 252|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 252|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ ------------------ 612| 252| } 613| 0| else { 614| 0| int i; 615| 0| CClosure *cl; 616| 0| api_checkpop(L, n); ------------------ | | 41| 0| api_check(L, (n) < L->top.p - L->ci->func.p && \ | | ------------------ | | | | 129| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 42| 0| L->tbclist.p < L->top.p - (n), \ | | 43| 0| "not enough free elements in the stack") ------------------ 617| 0| api_check(L, n <= MAXUPVAL, "upvalue index too large"); ------------------ | | 129| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 618| 0| cl = luaF_newCclosure(L, n); 619| 0| cl->f = fn; 620| 0| for (i = 0; i < n; i++) { ------------------ | Branch (620:17): [True: 0, False: 0] ------------------ 621| 0| setobj2n(L, &cl->upvalue[i], s2v(L->top.p - n + i)); ------------------ | | 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) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 622| | /* does not need barrier because closure is white */ 623| 0| lua_assert(iswhite(cl)); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ 624| 0| } 625| 0| L->top.p -= n; 626| 0| setclCvalue(L, s2v(L->top.p), cl); ------------------ | | 658| 0| { TValue *io = (obj); CClosure *x_ = (x); \ | | 659| 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)); \ | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VCCL)); \ | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 660| 0| checkliveness(L,io); } | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 627| 0| api_incr_top(L); ------------------ | | 17| 0| (L->top.p++, api_check(L, L->top.p <= L->ci->top.p, "stack overflow")) | | ------------------ | | | | 129| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ ------------------ 628| 0| luaC_checkGC(L); ------------------ | | 219| 0|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 215| 0| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 0|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 0, False: 0] | | | | ------------------ | | | | 216| 0| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 0|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 629| 0| } 630| 252| lua_unlock(L); ------------------ | | 268| 252|#define lua_unlock(L) ((void) 0) ------------------ 631| 252|} lua_pushlightuserdata: 645| 153|LUA_API void lua_pushlightuserdata (lua_State *L, void *p) { 646| 153| lua_lock(L); ------------------ | | 267| 153|#define lua_lock(L) ((void) 0) ------------------ 647| 153| setpvalue(s2v(L->top.p), p); ------------------ | | 471| 153| { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_VLIGHTUSERDATA); } | | ------------------ | | | | 72| 153|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_VLIGHTUSERDATA); } | | ------------------ | | | | 114| 153|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 648| 153| api_incr_top(L); ------------------ | | 17| 153| (L->top.p++, api_check(L, L->top.p <= L->ci->top.p, "stack overflow")) | | ------------------ | | | | 129| 153|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 153|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ ------------------ 649| 153| lua_unlock(L); ------------------ | | 268| 153|#define lua_unlock(L) ((void) 0) ------------------ 650| 153|} lua_getfield: 715| 246|LUA_API int lua_getfield (lua_State *L, int idx, const char *k) { 716| 246| lua_lock(L); ------------------ | | 267| 246|#define lua_lock(L) ((void) 0) ------------------ 717| 246| return auxgetstr(L, index2value(L, idx), k); 718| 246|} lua_createtable: 786| 45|LUA_API void lua_createtable (lua_State *L, unsigned narray, unsigned nrec) { 787| 45| Table *t; 788| 45| lua_lock(L); ------------------ | | 267| 45|#define lua_lock(L) ((void) 0) ------------------ 789| 45| t = luaH_new(L); 790| 45| sethvalue2s(L, L->top.p, t); ------------------ | | 728| 45|#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) | | ------------------ | | | | 724| 45| { TValue *io = (obj); Table *x_ = (x); \ | | | | 725| 45| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 72| 45|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 388| 45|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 45|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 726| 45| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 45| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 720|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 45| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 791| 45| api_incr_top(L); ------------------ | | 17| 45| (L->top.p++, api_check(L, L->top.p <= L->ci->top.p, "stack overflow")) | | ------------------ | | | | 129| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ ------------------ 792| 45| if (narray > 0 || nrec > 0) ------------------ | Branch (792:7): [True: 0, False: 45] | Branch (792:21): [True: 45, False: 0] ------------------ 793| 45| luaH_resize(L, t, narray, nrec); 794| 45| luaC_checkGC(L); ------------------ | | 219| 45|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 215| 45| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 45|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 0, False: 45] | | | | ------------------ | | | | 216| 45| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 45|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 795| 45| lua_unlock(L); ------------------ | | 268| 45|#define lua_unlock(L) ((void) 0) ------------------ 796| 45|} lua_setfield: 897| 180|LUA_API void lua_setfield (lua_State *L, int idx, const char *k) { 898| 180| lua_lock(L); /* unlock done in 'auxsetstr' */ ------------------ | | 267| 180|#define lua_lock(L) ((void) 0) ------------------ 899| 180| auxsetstr(L, index2value(L, idx), k); 900| 180|} lua_setmetatable: 959| 45|LUA_API int lua_setmetatable (lua_State *L, int objindex) { 960| 45| TValue *obj; 961| 45| Table *mt; 962| 45| lua_lock(L); ------------------ | | 267| 45|#define lua_lock(L) ((void) 0) ------------------ 963| 45| api_checkpop(L, 1); ------------------ | | 41| 45| api_check(L, (n) < L->top.p - L->ci->func.p && \ | | ------------------ | | | | 129| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 42| 45| L->tbclist.p < L->top.p - (n), \ | | 43| 45| "not enough free elements in the stack") ------------------ 964| 45| obj = index2value(L, objindex); 965| 45| if (ttisnil(s2v(L->top.p - 1))) ------------------ | | 196| 45|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 45|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 45|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 45|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 45] | | | | ------------------ | | ------------------ ------------------ 966| 0| mt = NULL; 967| 45| else { 968| 45| api_check(L, ttistable(s2v(L->top.p - 1)), "table expected"); ------------------ | | 129| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 969| 90| mt = hvalue(s2v(L->top.p - 1)); ------------------ | | 721| 45|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 113| 180|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 45] | | | | | Branch (113:42): [True: 45, False: 0] | | | | ------------------ | | ------------------ ------------------ 970| 90| } 971| 45| switch (ttype(obj)) { ------------------ | | 87| 45|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 45|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 972| 0| case LUA_TTABLE: { ------------------ | | 69| 0|#define LUA_TTABLE 5 ------------------ | Branch (972:5): [True: 0, False: 45] ------------------ 973| 0| hvalue(obj)->metatable = mt; ------------------ | | 721| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 974| 0| if (mt) { ------------------ | Branch (974:11): [True: 0, False: 0] ------------------ 975| 0| luaC_objbarrier(L, gcvalue(obj), mt); ------------------ | | 222| 0|#define luaC_objbarrier(L,p,o) ( \ | | 223| 0| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 91| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 70| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 224| 0| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 141| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 976| 0| luaC_checkfinalizer(L, gcvalue(obj), mt); ------------------ | | 318| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 977| 0| } 978| 0| break; 979| 0| } 980| 45| case LUA_TUSERDATA: { ------------------ | | 71| 45|#define LUA_TUSERDATA 7 ------------------ | Branch (980:5): [True: 45, False: 0] ------------------ 981| 90| uvalue(obj)->metatable = mt; ------------------ | | 466| 45|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 113| 180|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 45] | | | | | Branch (113:42): [True: 45, False: 0] | | | | ------------------ | | ------------------ ------------------ 982| 45| if (mt) { ------------------ | Branch (982:11): [True: 45, False: 0] ------------------ 983| 45| luaC_objbarrier(L, uvalue(obj), mt); ------------------ | | 222| 45|#define luaC_objbarrier(L,p,o) ( \ | | 223| 45| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 91| 45|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 70| 45|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 65| 360|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 45] | | | | | | | | | Branch (65:26): [True: 0, False: 45] | | | | | | | | | Branch (65:26): [True: 45, False: 0] | | | | | | | | | Branch (65:26): [True: 0, False: 45] | | | | | | | | | Branch (65:26): [True: 45, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 224| 45| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 141| 45|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 45|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 984| 45| luaC_checkfinalizer(L, gcvalue(obj), mt); ------------------ | | 318| 45|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 113| 45|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 985| 45| } 986| 45| break; 987| 90| } 988| 45| default: { ------------------ | Branch (988:5): [True: 0, False: 45] ------------------ 989| 0| G(L)->mt[ttype(obj)] = mt; ------------------ | | 333| 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) | | ------------------ ------------------ 990| 0| break; 991| 90| } 992| 45| } 993| 45| L->top.p--; 994| 45| lua_unlock(L); ------------------ | | 268| 45|#define lua_unlock(L) ((void) 0) ------------------ 995| 45| return 1; 996| 45|} lua_pcallk: 1070| 162| lua_KContext ctx, lua_KFunction k) { 1071| 162| struct CallS c; 1072| 162| int status; 1073| 162| ptrdiff_t func; 1074| 162| lua_lock(L); ------------------ | | 267| 162|#define lua_lock(L) ((void) 0) ------------------ 1075| 162| api_check(L, k == NULL || !isLua(L->ci), ------------------ | | 129| 162|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 162|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1076| 162| "cannot use continuations inside hooks"); 1077| 162| api_checkpop(L, nargs + 1); ------------------ | | 41| 162| api_check(L, (n) < L->top.p - L->ci->func.p && \ | | ------------------ | | | | 129| 162|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 162|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 42| 162| L->tbclist.p < L->top.p - (n), \ | | 43| 162| "not enough free elements in the stack") ------------------ 1078| 162| api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread"); ------------------ | | 129| 162|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 162|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1079| 162| checkresults(L, nargs, nresults); ------------------ | | 1025| 162| api_check(L, (nr) == LUA_MULTRET \ | | ------------------ | | | | 129| 162|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 162|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 1026| 162| || (L->ci->top.p - L->top.p >= (nr) - (na)), \ | | 1027| 162| "results from function overflow current stack size") ------------------ 1080| 162| if (errfunc == 0) ------------------ | Branch (1080:7): [True: 0, False: 162] ------------------ 1081| 0| func = 0; 1082| 162| else { 1083| 162| StkId o = index2stack(L, errfunc); 1084| 162| api_check(L, ttisfunction(s2v(o)), "error handler must be a function"); ------------------ | | 129| 162|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 162|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1085| 162| func = savestack(L, o); ------------------ | | 36| 162|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 162|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 162|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 162|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 162|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1086| 162| } 1087| 162| c.func = L->top.p - (nargs+1); /* function to be called */ 1088| 162| if (k == NULL || !yieldable(L)) { /* no continuation or no yieldable? */ ------------------ | | 104| 0|#define yieldable(L) (((L)->nCcalls & 0xffff0000) == 0) ------------------ | Branch (1088:7): [True: 162, False: 0] | Branch (1088:20): [True: 0, False: 0] ------------------ 1089| 162| c.nresults = nresults; /* do a 'conventional' protected call */ 1090| 162| status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func); ------------------ | | 36| 162|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 162|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 162|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 162|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 162|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1091| 162| } 1092| 0| else { /* prepare continuation (call is already protected by 'resume') */ 1093| 0| CallInfo *ci = L->ci; 1094| 0| ci->u.c.k = k; /* save continuation */ 1095| 0| ci->u.c.ctx = ctx; /* save context */ 1096| | /* save information for error recovery */ 1097| 0| ci->u2.funcidx = cast_int(savestack(L, c.func)); ------------------ | | 144| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1098| 0| ci->u.c.old_errfunc = L->errfunc; 1099| 0| L->errfunc = func; 1100| 0| setoah(ci->callstatus, L->allowhook); /* save value of 'allowhook' */ ------------------ | | 248| 0|#define setoah(st,v) ((st) = ((st) & ~CIST_OAH) | (v)) | | ------------------ | | | | 211| 0|#define CIST_OAH (1<<0) /* original value of 'allowhook' */ | | ------------------ ------------------ 1101| 0| ci->callstatus |= CIST_YPCALL; /* function can do error recovery */ ------------------ | | 215| 0|#define CIST_YPCALL (1<<4) /* doing a yieldable protected call */ ------------------ 1102| 0| luaD_call(L, c.func, nresults); /* do the call */ 1103| 0| ci->callstatus &= ~CIST_YPCALL; ------------------ | | 215| 0|#define CIST_YPCALL (1<<4) /* doing a yieldable protected call */ ------------------ 1104| 0| L->errfunc = ci->u.c.old_errfunc; 1105| 0| status = LUA_OK; /* if it is here, there were no errors */ ------------------ | | 48| 0|#define LUA_OK 0 ------------------ 1106| 0| } 1107| 162| adjustresults(L, nresults); ------------------ | | 26| 162| { if ((nres) <= LUA_MULTRET && L->ci->top.p < L->top.p) \ | | ------------------ | | | | 35| 324|#define LUA_MULTRET (-1) | | ------------------ | | | Branch (26:11): [True: 0, False: 162] | | | Branch (26:36): [True: 0, False: 0] | | ------------------ | | 27| 162| L->ci->top.p = L->top.p; } ------------------ 1108| 162| lua_unlock(L); ------------------ | | 268| 162|#define lua_unlock(L) ((void) 0) ------------------ 1109| 162| return status; 1110| 162|} lua_load: 1114| 561| const char *chunkname, const char *mode) { 1115| 561| ZIO z; 1116| 561| int status; 1117| 561| lua_lock(L); ------------------ | | 267| 561|#define lua_lock(L) ((void) 0) ------------------ 1118| 561| if (!chunkname) chunkname = "?"; ------------------ | Branch (1118:7): [True: 0, False: 561] ------------------ 1119| 561| luaZ_init(L, &z, reader, data); 1120| 561| status = luaD_protectedparser(L, &z, chunkname, mode); 1121| 561| if (status == LUA_OK) { /* no errors? */ ------------------ | | 48| 561|#define LUA_OK 0 ------------------ | Branch (1121:7): [True: 162, False: 399] ------------------ 1122| 324| LClosure *f = clLvalue(s2v(L->top.p - 1)); /* get new function */ ------------------ | | 641| 162|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | ------------------ | | | | 113| 648|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 162|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 162] | | | | | Branch (113:42): [True: 162, False: 0] | | | | ------------------ | | ------------------ ------------------ 1123| 162| if (f->nupvalues >= 1) { /* does it have an upvalue? */ ------------------ | Branch (1123:9): [True: 162, False: 0] ------------------ 1124| | /* get global table from registry */ 1125| 162| TValue gt; 1126| 162| getGlobalTable(L, >); 1127| | /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */ 1128| 162| setobj(L, f->upvals[0]->v.p, >); ------------------ | | 119| 162| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 162| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 162|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 162| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 162| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 2.59k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 162|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 162] | | | | | | | Branch (115:29): [True: 162, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 162] | | | | | | | Branch (115:29): [True: 162, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 162] | | | | | | | Branch (115:29): [True: 162, False: 0] | | | | | | | Branch (115:29): [True: 162, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 162] | | | | | | ------------------ | | | | ------------------ | | | | 108| 162| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 109| 162|#define lua_assert(c) assert(c) | | ------------------ ------------------ 1129| 162| luaC_barrier(L, f->upvals[0], >); ------------------ | | 226| 162|#define luaC_barrier(L,p,v) ( \ | | 227| 162| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 313| 162|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 162|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 311| 162|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (313:26): [True: 162, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 222| 162|#define luaC_objbarrier(L,p,o) ( \ | | | | 223| 162| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 91| 162|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 70| 162|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 65| 324|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (65:24): [True: 0, False: 162] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 224| 162| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 141| 162|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 139| 162|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 141| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1130| 162| } 1131| 324| } 1132| 561| lua_unlock(L); ------------------ | | 268| 561|#define lua_unlock(L) ((void) 0) ------------------ 1133| 561| return status; 1134| 561|} lua_toclose: 1276| 45|LUA_API void lua_toclose (lua_State *L, int idx) { 1277| 45| int nresults; 1278| 45| StkId o; 1279| 45| lua_lock(L); ------------------ | | 267| 45|#define lua_lock(L) ((void) 0) ------------------ 1280| 45| o = index2stack(L, idx); 1281| 45| nresults = L->ci->nresults; 1282| 45| api_check(L, L->tbclist.p < o, "given index below or equal a marked one"); ------------------ | | 129| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1283| 45| luaF_newtbcupval(L, o); /* create new to-be-closed upvalue */ 1284| 45| if (!hastocloseCfunc(nresults)) /* function not marked yet? */ ------------------ | | 55| 45|#define hastocloseCfunc(n) ((n) < LUA_MULTRET) | | ------------------ | | | | 35| 45|#define LUA_MULTRET (-1) | | ------------------ ------------------ | Branch (1284:7): [True: 45, False: 0] ------------------ 1285| 45| L->ci->nresults = codeNresults(nresults); /* mark it */ ------------------ | | 58| 45|#define codeNresults(n) (-(n) - 3) ------------------ 1286| 45| lua_assert(hastocloseCfunc(L->ci->nresults)); ------------------ | | 109| 45|#define lua_assert(c) assert(c) ------------------ 1287| 45| lua_unlock(L); ------------------ | | 268| 45|#define lua_unlock(L) ((void) 0) ------------------ 1288| 45|} lua_getallocf: 1316| 180|LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) { 1317| 180| lua_Alloc f; 1318| 180| lua_lock(L); ------------------ | | 267| 180|#define lua_lock(L) ((void) 0) ------------------ 1319| 180| if (ud) *ud = G(L)->ud; ------------------ | | 333| 180|#define G(L) (L->l_G) ------------------ | Branch (1319:7): [True: 180, False: 0] ------------------ 1320| 180| f = G(L)->frealloc; ------------------ | | 333| 180|#define G(L) (L->l_G) ------------------ 1321| 180| lua_unlock(L); ------------------ | | 268| 180|#define lua_unlock(L) ((void) 0) ------------------ 1322| 180| return f; 1323| 180|} lua_setwarnf: 1334| 561|void lua_setwarnf (lua_State *L, lua_WarnFunction f, void *ud) { 1335| 561| lua_lock(L); ------------------ | | 267| 561|#define lua_lock(L) ((void) 0) ------------------ 1336| 561| G(L)->ud_warn = ud; ------------------ | | 333| 561|#define G(L) (L->l_G) ------------------ 1337| 561| G(L)->warnf = f; ------------------ | | 333| 561|#define G(L) (L->l_G) ------------------ 1338| 561| lua_unlock(L); ------------------ | | 268| 561|#define lua_unlock(L) ((void) 0) ------------------ 1339| 561|} lua_newuserdatauv: 1350| 45|LUA_API void *lua_newuserdatauv (lua_State *L, size_t size, int nuvalue) { 1351| 45| Udata *u; 1352| 45| lua_lock(L); ------------------ | | 267| 45|#define lua_lock(L) ((void) 0) ------------------ 1353| 45| api_check(L, 0 <= nuvalue && nuvalue < USHRT_MAX, "invalid value"); ------------------ | | 129| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 1354| 45| u = luaS_newudata(L, size, nuvalue); 1355| 45| setuvalue(L, s2v(L->top.p), u); ------------------ | | 474| 45| { TValue *io = (obj); Udata *x_ = (x); \ | | 475| 45| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \ | | ------------------ | | | | 72| 45|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \ | | ------------------ | | | | 388| 45|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 45|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \ | | ------------------ | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 476| 45| checkliveness(L,io); } | | ------------------ | | | | 107| 45| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 720|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | ------------------ | | | | ------------------ | | | | 108| 45| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 1356| 45| api_incr_top(L); ------------------ | | 17| 45| (L->top.p++, api_check(L, L->top.p <= L->ci->top.p, "stack overflow")) | | ------------------ | | | | 129| 45|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 45|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ ------------------ 1357| 45| advancegc(L, size); 1358| 45| luaC_checkGC(L); ------------------ | | 219| 45|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 215| 45| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 45|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 0, False: 45] | | | | ------------------ | | | | 216| 45| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 45|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1359| 45| lua_unlock(L); ------------------ | | 268| 45|#define lua_unlock(L) ((void) 0) ------------------ 1360| 45| return getudatamem(u); ------------------ | | 524| 45|#define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 149| 45|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 45|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 520| 45| ((nuv) == 0 ? offsetof(Udata0, bindata) \ | | | | ------------------ | | | | | Branch (520:3): [True: 45, False: 0] | | | | ------------------ | | | | 521| 45| : offsetof(Udata, uv) + (sizeof(UValue) * (nuv))) | | ------------------ ------------------ 1361| 45|} lapi.c:index2stack: 105| 819|static StkId index2stack (lua_State *L, int idx) { 106| 819| CallInfo *ci = L->ci; 107| 819| if (idx > 0) { ------------------ | Branch (107:7): [True: 486, False: 333] ------------------ 108| 486| StkId o = ci->func.p + idx; 109| 486| api_check(L, o < L->top.p, "invalid index"); ------------------ | | 129| 486|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 486|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 110| 486| return o; 111| 486| } 112| 333| else { /* non-positive index */ 113| 333| api_check(L, idx != 0 && -idx <= L->top.p - (ci->func.p + 1), ------------------ | | 129| 333|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 333|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 114| 333| "invalid index"); 115| 333| api_check(L, !ispseudo(idx), "invalid index"); ------------------ | | 129| 333|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 333|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 116| 333| return L->top.p + idx; 117| 333| } 118| 819|} lapi.c:reverse: 236| 1.70k|static void reverse (lua_State *L, StkId from, StkId to) { 237| 2.16k| for (; from < to; from++, to--) { ------------------ | Branch (237:10): [True: 468, False: 1.70k] ------------------ 238| 468| TValue temp; 239| 468| setobj(L, &temp, s2v(from)); ------------------ | | 119| 468| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 468| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 468|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 468| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 468| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 2.89k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 468|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 162] | | | | | | | Branch (115:29): [True: 162, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 162] | | | | | | | Branch (115:29): [True: 162, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 162] | | | | | | | Branch (115:29): [True: 162, False: 0] | | | | | | | Branch (115:29): [True: 162, False: 0] | | | | | | | Branch (115:29): [True: 306, False: 162] | | | | | | ------------------ | | | | ------------------ | | | | 108| 468| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 109| 468|#define lua_assert(c) assert(c) | | ------------------ ------------------ 240| 468| setobjs2s(L, from, to); ------------------ | | 129| 468|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 468| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 468| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 468|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 468| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 468| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 5.05k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 468|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 306] | | | | | | | | | Branch (115:29): [True: 306, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 306] | | | | | | | | | Branch (115:29): [True: 306, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 306] | | | | | | | | | Branch (115:29): [True: 306, False: 0] | | | | | | | | | Branch (115:29): [True: 306, False: 0] | | | | | | | | | Branch (115:29): [True: 162, False: 306] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 468| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 468|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 241| 468| setobj2s(L, to, &temp); ------------------ | | 131| 468|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 468| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 468| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 468|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 468| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 468| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 2.89k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 468|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 162] | | | | | | | | | Branch (115:29): [True: 162, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 162] | | | | | | | | | Branch (115:29): [True: 162, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 162] | | | | | | | | | Branch (115:29): [True: 162, False: 0] | | | | | | | | | Branch (115:29): [True: 162, False: 0] | | | | | | | | | Branch (115:29): [True: 306, False: 162] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 468| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 468|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 242| 468| } 243| 1.70k|} lapi.c:index2value: 70| 2.95k|static TValue *index2value (lua_State *L, int idx) { 71| 2.95k| CallInfo *ci = L->ci; 72| 2.95k| if (idx > 0) { ------------------ | Branch (72:7): [True: 243, False: 2.71k] ------------------ 73| 243| StkId o = ci->func.p + idx; 74| 243| api_check(L, idx <= ci->top.p - (ci->func.p + 1), "unacceptable index"); ------------------ | | 129| 243|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 243|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 75| 243| if (o >= L->top.p) return &G(L)->nilvalue; ------------------ | | 333| 0|#define G(L) (L->l_G) ------------------ | Branch (75:9): [True: 0, False: 243] ------------------ 76| 243| else return s2v(o); ------------------ | | 172| 243|#define s2v(o) (&(o)->val) ------------------ 77| 243| } 78| 2.71k| else if (!ispseudo(idx)) { /* negative index */ ------------------ | | 50| 2.71k|#define ispseudo(i) ((i) <= LUA_REGISTRYINDEX) | | ------------------ | | | | 43| 2.71k|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | | | ------------------ | | | | | | 749| 2.71k|#define LUAI_MAXSTACK 1000000 | | | | ------------------ | | ------------------ ------------------ | Branch (78:12): [True: 2.42k, False: 291] ------------------ 79| 2.42k| api_check(L, idx != 0 && -idx <= L->top.p - (ci->func.p + 1), ------------------ | | 129| 2.42k|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 2.42k|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 80| 2.42k| "invalid index"); 81| 2.42k| return s2v(L->top.p + idx); ------------------ | | 172| 2.42k|#define s2v(o) (&(o)->val) ------------------ 82| 2.42k| } 83| 291| else if (idx == LUA_REGISTRYINDEX) ------------------ | | 43| 291|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 749| 291|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ | Branch (83:12): [True: 291, False: 0] ------------------ 84| 291| return &G(L)->l_registry; ------------------ | | 333| 291|#define G(L) (L->l_G) ------------------ 85| 0| else { /* upvalues */ 86| 0| idx = LUA_REGISTRYINDEX - idx; ------------------ | | 43| 0|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 749| 0|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ 87| 0| api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large"); ------------------ | | 129| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 88| 0| if (ttisCclosure(s2v(ci->func.p))) { /* C closure? */ ------------------ | | 634| 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] | | | | ------------------ | | ------------------ ------------------ 89| 0| CClosure *func = clCvalue(s2v(ci->func.p)); ------------------ | | 643| 0|#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 90| 0| return (idx <= func->nupvalues) ? &func->upvalue[idx-1] ------------------ | Branch (90:14): [True: 0, False: 0] ------------------ 91| 0| : &G(L)->nilvalue; ------------------ | | 333| 0|#define G(L) (L->l_G) ------------------ 92| 0| } 93| 0| else { /* light C function or Lua function (through a hook)?) */ 94| 0| api_check(L, ttislcf(s2v(ci->func.p)), "caller not a C function"); ------------------ | | 129| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 95| 0| return &G(L)->nilvalue; /* no upvalues */ ------------------ | | 333| 0|#define G(L) (L->l_G) ------------------ 96| 0| } 97| 0| } 98| 2.95k|} lapi.c:touserdata: 458| 1.13k|l_sinline void *touserdata (const TValue *o) { 459| 1.13k| switch (ttype(o)) { ------------------ | | 87| 1.13k|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 1.13k|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 460| 450| case LUA_TUSERDATA: return getudatamem(uvalue(o)); ------------------ | | 71| 450|#define LUA_TUSERDATA 7 ------------------ case LUA_TUSERDATA: return getudatamem(uvalue(o)); ------------------ | | 524| 450|#define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 149| 450|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 3.60k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (139:27): [True: 0, False: 450] | | | | | | | Branch (139:27): [True: 450, False: 0] | | | | | | | Branch (139:27): [True: 0, False: 450] | | | | | | | Branch (139:27): [True: 450, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 520| 3.60k| ((nuv) == 0 ? offsetof(Udata0, bindata) \ | | | | ------------------ | | | | | Branch (520:3): [True: 450, False: 0] | | | | | Branch (520:4): [True: 0, False: 450] | | | | | Branch (520:4): [True: 450, False: 0] | | | | | Branch (520:4): [True: 0, False: 450] | | | | | Branch (520:4): [True: 450, False: 0] | | | | ------------------ | | | | 521| 450| : offsetof(Udata, uv) + (sizeof(UValue) * (nuv))) | | | | ------------------ | | | | | Branch (521:64): [True: 0, False: 0] | | | | | Branch (521:64): [True: 0, False: 0] | | | | | Branch (521:64): [True: 0, False: 0] | | | | | Branch (521:64): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (460:5): [True: 450, False: 683] ------------------ 461| 683| case LUA_TLIGHTUSERDATA: return pvalue(o); ------------------ | | 66| 683|#define LUA_TLIGHTUSERDATA 2 ------------------ case LUA_TLIGHTUSERDATA: return pvalue(o); ------------------ | | 465| 683|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 113| 683|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 683|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (461:5): [True: 683, False: 450] ------------------ 462| 0| default: return NULL; ------------------ | Branch (462:5): [True: 0, False: 1.13k] ------------------ 463| 1.13k| } 464| 1.13k|} lapi.c:advancegc: 57| 198|static void advancegc (lua_State *L, size_t delta) { 58| 198| delta >>= 5; /* one object for each 32 bytes (empirical) */ 59| 198| if (delta > 0) { ------------------ | Branch (59:7): [True: 153, False: 45] ------------------ 60| 153| global_State *g = G(L); ------------------ | | 333| 153|#define G(L) (L->l_G) ------------------ 61| 153| luaE_setdebt(g, g->GCdebt - delta); 62| 153| } 63| 198|} lapi.c:getGlobalTable: 685| 162|static void getGlobalTable (lua_State *L, TValue *gt) { 686| 324| Table *registry = hvalue(&G(L)->l_registry); ------------------ | | 721| 162|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 113| 648|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 162|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 162] | | | | | Branch (113:42): [True: 162, False: 0] | | | | ------------------ | | ------------------ ------------------ 687| 162| int tag = luaH_getint(registry, LUA_RIDX_GLOBALS, gt); ------------------ | | 84| 162|#define LUA_RIDX_GLOBALS 2 ------------------ 688| 324| (void)tag; /* avoid not-used warnings when checks are off */ 689| 324| api_check(L, novariant(tag) == LUA_TTABLE, "global table must exist"); ------------------ | | 129| 162|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 727| 162|#define luai_apicheck(l,e) assert(e) | | ------------------ ------------------ 690| 324|} lapi.c:auxgetstr: 668| 246|static int auxgetstr (lua_State *L, const TValue *t, const char *k) { 669| 246| int tag; 670| 246| TString *str = luaS_new(L, k); 671| 246| luaV_fastget(t, str, s2v(L->top.p), luaH_getstr, tag); ------------------ | | 82| 492| (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 719| 246|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 246|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 246|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 192| 0|#define LUA_VNOTABLE makevariant(LUA_TNIL, 3) | | | | ------------------ | | | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 721| 246|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 113| 984|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 246|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 246] | | | | | | | Branch (113:42): [True: 246, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:11): [True: 0, False: 246] | | ------------------ ------------------ 672| 246| if (!tagisempty(tag)) { ------------------ | | 204| 246|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 80| 246|#define novariant(t) ((t) & 0x0F) | | ------------------ | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 64| 246|#define LUA_TNIL 0 | | ------------------ ------------------ | Branch (672:7): [True: 0, False: 246] ------------------ 673| 0| api_incr_top(L); ------------------ | | 17| 0| (L->top.p++, api_check(L, L->top.p <= L->ci->top.p, "stack overflow")) | | ------------------ | | | | 129| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 0|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ ------------------ 674| 0| } 675| 246| else { 676| 246| setsvalue2s(L, L->top.p, str); ------------------ | | 390| 246|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 385| 246| { TValue *io = (obj); TString *x_ = (x); \ | | | | 386| 246| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 246|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 388| 246|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 246|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 246|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 246|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 387| 246| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 246| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 3.93k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 246|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 246] | | | | | | | | | Branch (115:29): [True: 246, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 246] | | | | | | | | | Branch (115:29): [True: 246, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 246] | | | | | | | | | Branch (115:29): [True: 246, False: 0] | | | | | | | | | Branch (115:29): [True: 246, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 246] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 246| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 677| 246| api_incr_top(L); ------------------ | | 17| 246| (L->top.p++, api_check(L, L->top.p <= L->ci->top.p, "stack overflow")) | | ------------------ | | | | 129| 246|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 246|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ ------------------ 678| 246| tag = luaV_finishget(L, t, s2v(L->top.p - 1), L->top.p - 1, tag); ------------------ | | 172| 246|#define s2v(o) (&(o)->val) ------------------ 679| 246| } 680| 246| lua_unlock(L); ------------------ | | 268| 246|#define lua_unlock(L) ((void) 0) ------------------ 681| 246| return novariant(tag); ------------------ | | 80| 246|#define novariant(t) ((t) & 0x0F) ------------------ 682| 246|} lapi.c:auxsetstr: 853| 180|static void auxsetstr (lua_State *L, const TValue *t, const char *k) { 854| 180| int hres; 855| 180| TString *str = luaS_new(L, k); 856| 180| api_checkpop(L, 1); ------------------ | | 41| 180| api_check(L, (n) < L->top.p - L->ci->func.p && \ | | ------------------ | | | | 129| 180|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 180|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 42| 180| L->tbclist.p < L->top.p - (n), \ | | 43| 180| "not enough free elements in the stack") ------------------ 857| 180| luaV_fastset(t, str, s2v(L->top.p - 1), hres, luaH_psetstr); ------------------ | | 95| 360| (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 719| 180|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 180|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 180|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 69| 0|#define HNOTATABLE 2 | | ------------------ | | (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 721| 180|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 113| 720|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 180|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 180] | | | | | | | Branch (113:42): [True: 180, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (95:12): [True: 0, False: 180] | | ------------------ ------------------ 858| 180| if (hres == HOK) { ------------------ | | 67| 180|#define HOK 0 ------------------ | Branch (858:7): [True: 0, False: 180] ------------------ 859| 0| luaV_finishfastset(L, t, s2v(L->top.p - 1)); ------------------ | | 105| 0|#define luaV_finishfastset(L,t,v) luaC_barrierback(L, gcvalue(t), v) | | ------------------ | | | | 232| 0|#define luaC_barrierback(L,p,v) ( \ | | | | 233| 0| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 313| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 311| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (313:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 229| 0|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 230| 0| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 91| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 70| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 141| 0|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (230:51): [True: 0, False: 0] | | | | | | | Branch (230:51): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 141| 0|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 860| 0| L->top.p--; /* pop value */ 861| 0| } 862| 180| else { 863| 180| setsvalue2s(L, L->top.p, str); /* push 'str' (to make it a TValue) */ ------------------ | | 390| 180|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 385| 180| { TValue *io = (obj); TString *x_ = (x); \ | | | | 386| 180| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 180|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 388| 180|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 180|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 180|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 180|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 387| 180| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 180| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 2.88k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 180|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 180] | | | | | | | | | Branch (115:29): [True: 180, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 180] | | | | | | | | | Branch (115:29): [True: 180, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 180] | | | | | | | | | Branch (115:29): [True: 180, False: 0] | | | | | | | | | Branch (115:29): [True: 180, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 180] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 180| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 864| 180| api_incr_top(L); ------------------ | | 17| 180| (L->top.p++, api_check(L, L->top.p <= L->ci->top.p, "stack overflow")) | | ------------------ | | | | 129| 180|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 180|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ ------------------ 865| 180| luaV_finishset(L, t, s2v(L->top.p - 1), s2v(L->top.p - 2), hres); ------------------ | | 172| 180|#define s2v(o) (&(o)->val) ------------------ luaV_finishset(L, t, s2v(L->top.p - 1), s2v(L->top.p - 2), hres); ------------------ | | 172| 180|#define s2v(o) (&(o)->val) ------------------ 866| 180| L->top.p -= 2; /* pop value and key */ 867| 180| } 868| 180| lua_unlock(L); /* lock done by caller */ ------------------ | | 268| 180|#define lua_unlock(L) ((void) 0) ------------------ 869| 180|} lapi.c:f_call: 1062| 162|static void f_call (lua_State *L, void *ud) { 1063| 162| struct CallS *c = cast(struct CallS *, ud); ------------------ | | 139| 162|#define cast(t, exp) ((t)(exp)) ------------------ 1064| 162| luaD_callnoyield(L, c->func, c->nresults); 1065| 162|} luaL_traceback: 132| 153| const char *msg, int level) { 133| 153| luaL_Buffer b; 134| 153| lua_Debug ar; 135| 153| int last = lastlevel(L1); 136| 153| int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1; ------------------ | | 43| 153|#define LEVELS1 10 /* size of the first part of the stack */ ------------------ int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1; ------------------ | | 44| 153|#define LEVELS2 11 /* size of the second part of the stack */ ------------------ int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1; ------------------ | | 43| 2|#define LEVELS1 10 /* size of the first part of the stack */ ------------------ | Branch (136:20): [True: 2, False: 151] ------------------ 137| 153| luaL_buffinit(L, &b); 138| 153| if (msg) { ------------------ | Branch (138:7): [True: 153, False: 0] ------------------ 139| 153| luaL_addstring(&b, msg); 140| 153| luaL_addchar(&b, '\n'); ------------------ | | 210| 153| ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \ | | ------------------ | | | Branch (210:11): [True: 153, False: 0] | | | Branch (210:33): [True: 0, False: 0] | | ------------------ | | 211| 153| ((B)->b[(B)->n++] = (c))) ------------------ 141| 153| } 142| 153| luaL_addstring(&b, "stack traceback:"); 143| 356| while (lua_getstack(L1, level++, &ar)) { ------------------ | Branch (143:10): [True: 203, False: 153] ------------------ 144| 203| if (limit2show-- == 0) { /* too many levels? */ ------------------ | Branch (144:9): [True: 2, False: 201] ------------------ 145| 2| int n = last - level - LEVELS2 + 1; /* number of levels to skip */ ------------------ | | 44| 2|#define LEVELS2 11 /* size of the second part of the stack */ ------------------ 146| 2| lua_pushfstring(L, "\n\t...\t(skipping %d levels)", n); 147| 2| luaL_addvalue(&b); /* add warning about skip */ 148| 2| level += n; /* and skip to last levels */ 149| 2| } 150| 201| else { 151| 201| lua_getinfo(L1, "Slnt", &ar); 152| 201| if (ar.currentline <= 0) ------------------ | Branch (152:11): [True: 0, False: 201] ------------------ 153| 0| lua_pushfstring(L, "\n\t%s: in ", ar.short_src); 154| 201| else 155| 201| lua_pushfstring(L, "\n\t%s:%d: in ", ar.short_src, ar.currentline); 156| 201| luaL_addvalue(&b); 157| 201| pushfuncname(L, &ar); 158| 201| luaL_addvalue(&b); 159| 201| if (ar.istailcall) ------------------ | Branch (159:11): [True: 0, False: 201] ------------------ 160| 0| luaL_addstring(&b, "\n\t(...tail calls...)"); 161| 201| } 162| 203| } 163| 153| luaL_pushresult(&b); 164| 153|} luaL_newmetatable: 311| 45|LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) { 312| 45| if (luaL_getmetatable(L, tname) != LUA_TNIL) /* name already in use? */ ------------------ | | 152| 45|#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) | | ------------------ | | | | 43| 45|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | | | ------------------ | | | | | | 749| 45|#define LUAI_MAXSTACK 1000000 | | | | ------------------ | | ------------------ ------------------ if (luaL_getmetatable(L, tname) != LUA_TNIL) /* name already in use? */ ------------------ | | 64| 45|#define LUA_TNIL 0 ------------------ | Branch (312:7): [True: 0, False: 45] ------------------ 313| 0| return 0; /* leave previous value on top, but return 0 */ 314| 45| lua_pop(L, 1); ------------------ | | 394| 45|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 315| 45| lua_createtable(L, 0, 2); /* create metatable */ 316| 45| lua_pushstring(L, tname); 317| 45| lua_setfield(L, -2, "__name"); /* metatable.__name = tname */ 318| 45| lua_pushvalue(L, -1); 319| 45| lua_setfield(L, LUA_REGISTRYINDEX, tname); /* registry.name = metatable */ ------------------ | | 43| 45|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 749| 45|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ 320| 45| return 1; 321| 45|} luaL_checkstack: 380| 45|LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) { 381| 45| if (l_unlikely(!lua_checkstack(L, space))) { ------------------ | | 697| 45|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 45|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 45] | | | | ------------------ | | ------------------ ------------------ 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| 45|} luaL_addlstring: 589| 306|LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) { 590| 306| if (l > 0) { /* avoid 'memcpy' when 's' can be NULL */ ------------------ | Branch (590:7): [True: 306, False: 0] ------------------ 591| 306| char *b = prepbuffsize(B, l, -1); 592| 306| memcpy(b, s, l * sizeof(char)); 593| 306| luaL_addsize(B, l); ------------------ | | 213| 306|#define luaL_addsize(B,s) ((B)->n += (s)) ------------------ 594| 306| } 595| 306|} luaL_addstring: 598| 306|LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) { 599| 306| luaL_addlstring(B, s, strlen(s)); 600| 306|} luaL_pushresult: 603| 153|LUALIB_API void luaL_pushresult (luaL_Buffer *B) { 604| 153| lua_State *L = B->L; 605| 153| checkbufferlevel(B, -1); ------------------ | | 532| 153| lua_assert(buffonstack(B) ? lua_touserdata(B->L, idx) != NULL \ | | ------------------ | | | | 178| 153| #define lua_assert(c) assert(c) | | ------------------ | | 533| 153| : lua_touserdata(B->L, idx) == (void*)B) ------------------ 606| 153| if (!buffonstack(B)) /* using static buffer? */ ------------------ | | 524| 153|#define buffonstack(B) ((B)->b != (B)->init.b) ------------------ | Branch (606:7): [True: 108, False: 45] ------------------ 607| 108| lua_pushlstring(L, B->b, B->n); /* save result as regular string */ 608| 45| else { /* reuse buffer already allocated */ 609| 45| UBox *box = (UBox *)lua_touserdata(L, -1); 610| 45| void *ud; 611| 45| lua_Alloc allocf = lua_getallocf(L, &ud); /* function to free buffer */ 612| 45| size_t len = B->n; /* final string length */ 613| 45| char *s; 614| 45| resizebox(L, -1, len + 1); /* adjust box size to content size */ 615| 45| s = (char*)box->box; /* final buffer address */ 616| 45| s[len] = '\0'; /* add ending zero */ 617| | /* clear box, as 'lua_pushextlstring' will take control over buffer */ 618| 45| box->bsize = 0; box->box = NULL; 619| 45| lua_pushextlstring(L, s, len, allocf, ud); 620| 45| lua_closeslot(L, -2); /* close the box */ 621| 45| } 622| 153| lua_remove(L, -2); /* remove box or placeholder from the stack */ ------------------ | | 421| 153|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 394| 153|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 623| 153|} luaL_addvalue: 641| 404|LUALIB_API void luaL_addvalue (luaL_Buffer *B) { 642| 404| lua_State *L = B->L; 643| 404| size_t len; 644| 404| const char *s = lua_tolstring(L, -1, &len); 645| 404| char *b = prepbuffsize(B, len, -2); 646| 404| memcpy(b, s, len * sizeof(char)); 647| 404| luaL_addsize(B, len); ------------------ | | 213| 404|#define luaL_addsize(B,s) ((B)->n += (s)) ------------------ 648| 404| lua_pop(L, 1); /* pop string */ ------------------ | | 394| 404|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 649| 404|} luaL_buffinit: 652| 153|LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) { 653| 153| B->L = L; 654| 153| B->b = B->init.b; 655| 153| B->n = 0; 656| 153| B->size = LUAL_BUFFERSIZE; ------------------ | | 775| 153|#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number))) ------------------ 657| 153| lua_pushlightuserdata(L, (void*)B); /* push placeholder */ 658| 153|} luaL_loadbufferx: 853| 561| const char *name, const char *mode) { 854| 561| LoadS ls; 855| 561| ls.s = buff; 856| 561| ls.size = size; 857| 561| return lua_load(L, getS, &ls, name, mode); 858| 561|} luaL_setfuncs: 951| 45|LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) { 952| 45| luaL_checkstack(L, nup, "too many upvalues"); 953| 135| for (; l->name != NULL; l++) { /* fill the table with given functions */ ------------------ | Branch (953:10): [True: 90, False: 45] ------------------ 954| 90| if (l->func == NULL) /* place holder? */ ------------------ | Branch (954:9): [True: 0, False: 90] ------------------ 955| 0| lua_pushboolean(L, 0); 956| 90| else { 957| 90| int i; 958| 90| for (i = 0; i < nup; i++) /* copy upvalues to the top */ ------------------ | Branch (958:19): [True: 0, False: 90] ------------------ 959| 0| lua_pushvalue(L, -nup); 960| 90| lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */ 961| 90| } 962| 90| lua_setfield(L, -(nup + 2), l->name); 963| 90| } 964| 45| lua_pop(L, nup); /* remove upvalues */ ------------------ | | 394| 45|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 965| 45|} luaL_newstate: 1166| 561|LUALIB_API lua_State *luaL_newstate (void) { 1167| 561| lua_State *L = lua_newstate(l_alloc, NULL, luai_makeseed()); 1168| 561| if (l_likely(L)) { ------------------ | | 696| 561|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 684| 561|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (684:25): [True: 561, False: 0] | | | | ------------------ | | ------------------ ------------------ 1169| 561| lua_atpanic(L, &panic); 1170| 561| lua_setwarnf(L, warnfoff, L); /* default is warnings off */ 1171| 561| } 1172| 561| return L; 1173| 561|} lauxlib.c:lastlevel: 116| 153|static int lastlevel (lua_State *L) { 117| 153| lua_Debug ar; 118| 153| int li = 1, le = 1; 119| | /* find an upper bound */ 120| 324| while (lua_getstack(L, le, &ar)) { li = le; le *= 2; } ------------------ | Branch (120:10): [True: 171, False: 153] ------------------ 121| | /* do a binary search */ 122| 318| while (li < le) { ------------------ | Branch (122:10): [True: 165, False: 153] ------------------ 123| 165| int m = (li + le)/2; 124| 165| if (lua_getstack(L, m, &ar)) li = m + 1; ------------------ | Branch (124:9): [True: 159, False: 6] ------------------ 125| 6| else le = m; 126| 165| } 127| 153| return le - 1; 128| 153|} lauxlib.c:pushfuncname: 100| 201|static void pushfuncname (lua_State *L, lua_Debug *ar) { 101| 201| if (pushglobalfuncname(L, ar)) { /* try first a global name */ ------------------ | Branch (101:7): [True: 0, False: 201] ------------------ 102| 0| lua_pushfstring(L, "function '%s'", lua_tostring(L, -1)); ------------------ | | 416| 0|#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) ------------------ 103| 0| lua_remove(L, -2); /* remove name */ ------------------ | | 421| 0|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 394| 0|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 104| 0| } 105| 201| else if (*ar->namewhat != '\0') /* is there a name from code? */ ------------------ | Branch (105:12): [True: 48, False: 153] ------------------ 106| 48| lua_pushfstring(L, "%s '%s'", ar->namewhat, ar->name); /* use it */ 107| 153| else if (*ar->what == 'm') /* main? */ ------------------ | Branch (107:12): [True: 153, False: 0] ------------------ 108| 153| lua_pushliteral(L, "main chunk"); ------------------ | | 411| 153|#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, "?"); ------------------ | | 411| 0|#define lua_pushliteral(L, s) lua_pushstring(L, "" s) ------------------ 113| 201|} lauxlib.c:pushglobalfuncname: 79| 201|static int pushglobalfuncname (lua_State *L, lua_Debug *ar) { 80| 201| int top = lua_gettop(L); 81| 201| lua_getinfo(L, "f", ar); /* push function */ 82| 201| lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); ------------------ | | 43| 201|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 749| 201|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); ------------------ | | 31| 201|#define LUA_LOADED_TABLE "_LOADED" ------------------ 83| 201| if (findfield(L, top + 1, 2)) { ------------------ | Branch (83:7): [True: 0, False: 201] ------------------ 84| 0| const char *name = lua_tostring(L, -1); ------------------ | | 416| 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 */ ------------------ | | 421| 0|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 394| 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| 201| else { 94| 201| lua_settop(L, top); /* remove function and global table */ 95| 201| return 0; 96| 201| } 97| 201|} lauxlib.c:findfield: 52| 201|static int findfield (lua_State *L, int objidx, int level) { 53| 201| if (level == 0 || !lua_istable(L, -1)) ------------------ | | 403| 201|#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE) | | ------------------ | | | | 69| 201|#define LUA_TTABLE 5 | | ------------------ ------------------ | Branch (53:7): [True: 0, False: 201] | Branch (53:21): [True: 201, False: 0] ------------------ 54| 201| 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) */ ------------------ | | 394| 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 */ ------------------ | | 411| 0|#define lua_pushliteral(L, s) lua_pushstring(L, "" s) ------------------ 65| 0| lua_replace(L, -3); /* (in the slot occupied by table) */ ------------------ | | 423| 0|#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) | | ------------------ | | | | 394| 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 */ ------------------ | | 394| 0|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 71| 0| } 72| 0| return 0; /* not found */ 73| 0|} lauxlib.c:prepbuffsize: 556| 710|static char *prepbuffsize (luaL_Buffer *B, size_t sz, int boxidx) { 557| 710| checkbufferlevel(B, boxidx); ------------------ | | 532| 710| lua_assert(buffonstack(B) ? lua_touserdata(B->L, idx) != NULL \ | | ------------------ | | | | 178| 710| #define lua_assert(c) assert(c) | | ------------------ | | 533| 710| : lua_touserdata(B->L, idx) == (void*)B) ------------------ 558| 710| if (B->size - B->n >= sz) /* enough space? */ ------------------ | Branch (558:7): [True: 620, False: 90] ------------------ 559| 620| return B->b + B->n; 560| 90| else { 561| 90| lua_State *L = B->L; 562| 90| char *newbuff; 563| 90| size_t newsize = newbuffsize(B, sz); 564| | /* create larger buffer */ 565| 90| if (buffonstack(B)) /* buffer already has a box? */ ------------------ | | 524| 90|#define buffonstack(B) ((B)->b != (B)->init.b) | | ------------------ | | | Branch (524:24): [True: 45, False: 45] | | ------------------ ------------------ 566| 45| newbuff = (char *)resizebox(L, boxidx, newsize); /* resize it */ 567| 45| else { /* no box yet */ 568| 45| lua_remove(L, boxidx); /* remove placeholder */ ------------------ | | 421| 45|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 394| 45|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 569| 45| newbox(L); /* create a new box */ 570| 45| lua_insert(L, boxidx); /* move box to its intended position */ ------------------ | | 419| 45|#define lua_insert(L,idx) lua_rotate(L, (idx), 1) ------------------ 571| 45| lua_toclose(L, boxidx); 572| 45| newbuff = (char *)resizebox(L, boxidx, newsize); 573| 45| memcpy(newbuff, B->b, B->n * sizeof(char)); /* copy original content */ 574| 45| } 575| 90| B->b = newbuff; 576| 90| B->size = newsize; 577| 90| return newbuff + B->n; 578| 90| } 579| 710|} lauxlib.c:newbuffsize: 541| 90|static size_t newbuffsize (luaL_Buffer *B, size_t sz) { 542| 90| size_t newsize = (B->size / 2) * 3; /* buffer size * 1.5 */ 543| 90| if (l_unlikely(MAX_SIZET - sz - 1 < B->n)) /* overflow in (B->n + sz + 1)? */ ------------------ | | 697| 90|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 90|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 90] | | | | ------------------ | | ------------------ ------------------ 544| 0| return luaL_error(B->L, "buffer too large"); 545| 90| if (newsize < B->n + sz + 1) /* not big enough? */ ------------------ | Branch (545:7): [True: 45, False: 45] ------------------ 546| 45| newsize = B->n + sz + 1; 547| 90| return newsize; 548| 90|} lauxlib.c:newbox: 510| 45|static void newbox (lua_State *L) { 511| 45| UBox *box = (UBox *)lua_newuserdatauv(L, sizeof(UBox), 0); 512| 45| box->box = NULL; 513| 45| box->bsize = 0; 514| 45| if (luaL_newmetatable(L, "_UBOX*")) /* creating metatable? */ ------------------ | Branch (514:7): [True: 45, False: 0] ------------------ 515| 45| luaL_setfuncs(L, boxmt, 0); /* set its metamethods */ 516| 45| lua_setmetatable(L, -2); 517| 45|} lauxlib.c:boxgc: 497| 90|static int boxgc (lua_State *L) { 498| 90| resizebox(L, 1, 0); 499| 90| return 0; 500| 90|} lauxlib.c:resizebox: 478| 225|static void *resizebox (lua_State *L, int idx, size_t newsize) { 479| 225| UBox *box = (UBox *)lua_touserdata(L, idx); 480| 225| if (box->bsize == newsize) /* not changing size? */ ------------------ | Branch (480:7): [True: 90, False: 135] ------------------ 481| 90| return box->box; /* keep the buffer */ 482| 135| else { 483| 135| void *ud; 484| 135| lua_Alloc allocf = lua_getallocf(L, &ud); 485| 135| void *temp = allocf(ud, box->box, box->bsize, newsize); 486| 135| if (l_unlikely(temp == NULL && newsize > 0)) { /* allocation error? */ ------------------ | | 697| 135|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 135|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 135] | | | | | Branch (685:46): [True: 0, False: 135] | | | | | Branch (685:46): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 487| 0| lua_pushliteral(L, "not enough memory"); ------------------ | | 411| 0|#define lua_pushliteral(L, s) lua_pushstring(L, "" s) ------------------ 488| 0| lua_error(L); /* raise a memory error */ 489| 0| } 490| 135| box->box = temp; 491| 135| box->bsize = newsize; 492| 135| return temp; 493| 135| } 494| 225|} lauxlib.c:getS: 842| 803|static const char *getS (lua_State *L, void *ud, size_t *size) { 843| 803| LoadS *ls = (LoadS *)ud; 844| 803| (void)L; /* not used */ 845| 803| if (ls->size == 0) return NULL; ------------------ | Branch (845:7): [True: 242, False: 561] ------------------ 846| 561| *size = ls->size; 847| 561| ls->size = 0; 848| 561| return ls->s; 849| 803|} lauxlib.c:luai_makeseed: 1141| 561|static unsigned int luai_makeseed (void) { 1142| 561| unsigned int buff[BUFSEED]; 1143| 561| unsigned int res; 1144| 561| unsigned int i; 1145| 561| time_t t = time(NULL); 1146| 561| char *b = (char*)buff; 1147| 561| addbuff(b, b); /* local variable's address */ ------------------ | | 1138| 561|#define addbuff(b,v) (memcpy(&b[0], &(v), sizeof(v)), b += sizeof(v)) ------------------ 1148| 561| addbuff(b, t); /* time */ ------------------ | | 1138| 561|#define addbuff(b,v) (memcpy(&b[0], &(v), sizeof(v)), b += sizeof(v)) ------------------ 1149| | /* fill (rare but possible) remain of the buffer with zeros */ 1150| 561| memset(b, 0, sizeof(buff) - BUFSEEDB); ------------------ | | 1129| 561|#define BUFSEEDB (sizeof(void*) + sizeof(time_t)) ------------------ 1151| 561| res = buff[0]; 1152| 2.24k| for (i = 1; i < BUFSEED; i++) ------------------ | | 1132| 2.24k|#define BUFSEED ((BUFSEEDB + sizeof(int) - 1) / sizeof(int)) | | ------------------ | | | | 1129| 2.24k|#define BUFSEEDB (sizeof(void*) + sizeof(time_t)) | | ------------------ ------------------ | Branch (1152:15): [True: 1.68k, False: 561] ------------------ 1153| 1.68k| res ^= (res >> 3) + (res << 7) + buff[i]; 1154| 561| return res; 1155| 561|} lauxlib.c:l_alloc: 1035| 5.74M|static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) { 1036| 5.74M| (void)ud; (void)osize; /* not used */ 1037| 5.74M| if (nsize == 0) { ------------------ | Branch (1037:7): [True: 2.86M, False: 2.88M] ------------------ 1038| 2.86M| free(ptr); 1039| 2.86M| return NULL; 1040| 2.86M| } 1041| 2.88M| else 1042| 2.88M| return realloc(ptr, nsize); 1043| 5.74M|} luaK_semerror: 46| 1|l_noret luaK_semerror (LexState *ls, const char *msg) { 47| 1| ls->t.token = 0; /* remove "near " from final message */ 48| 1| luaX_syntaxerror(ls, msg); 49| 1|} luaK_exp2const: 84| 2.16k|int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v) { 85| 2.16k| if (hasjumps(e)) ------------------ | | 38| 2.16k|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 266, False: 1.90k] | | ------------------ ------------------ 86| 266| return 0; /* not a constant */ 87| 1.90k| switch (e->k) { 88| 17| case VFALSE: ------------------ | Branch (88:5): [True: 17, False: 1.88k] ------------------ 89| 17| setbfvalue(v); ------------------ | | 263| 17|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 17|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 90| 17| return 1; 91| 17| case VTRUE: ------------------ | Branch (91:5): [True: 17, False: 1.88k] ------------------ 92| 17| setbtvalue(v); ------------------ | | 264| 17|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 17|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 93| 17| return 1; 94| 556| case VNIL: ------------------ | Branch (94:5): [True: 556, False: 1.34k] ------------------ 95| 556| setnilvalue(v); ------------------ | | 211| 556|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 556|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 96| 556| return 1; 97| 2| case VKSTR: { ------------------ | Branch (97:5): [True: 2, False: 1.90k] ------------------ 98| 2| setsvalue(fs->ls->L, v, e->u.strval); ------------------ | | 385| 2| { TValue *io = (obj); TString *x_ = (x); \ | | 386| 2| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 2|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 388| 2|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 2|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 2|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 2|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 387| 2| checkliveness(L,io); } | | ------------------ | | | | 107| 2| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 32|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 2|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 2] | | | | | | | Branch (115:29): [True: 2, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 2] | | | | | | | Branch (115:29): [True: 2, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 2] | | | | | | | Branch (115:29): [True: 2, False: 0] | | | | | | | Branch (115:29): [True: 2, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 108| 2| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 99| 2| return 1; 100| 2| } 101| 77| case VCONST: { ------------------ | Branch (101:5): [True: 77, False: 1.82k] ------------------ 102| 77| setobj(fs->ls->L, v, const2val(fs, e)); ------------------ | | 119| 77| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 77| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 77|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 77| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 77| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 92|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 77|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 1] | | | | | | | Branch (115:29): [True: 1, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 1] | | | | | | | Branch (115:29): [True: 1, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 1] | | | | | | | Branch (115:29): [True: 1, False: 0] | | | | | | | Branch (115:29): [True: 1, False: 0] | | | | | | | Branch (115:29): [True: 76, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 108| 77| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 109| 77|#define lua_assert(c) assert(c) | | ------------------ ------------------ 103| 77| return 1; 104| 77| } 105| 1.23k| default: return tonumeral(e, v); ------------------ | Branch (105:5): [True: 1.23k, False: 669] ------------------ 106| 1.90k| } 107| 1.90k|} luaK_nil: 131| 116k|void luaK_nil (FuncState *fs, int from, int n) { 132| 116k| int l = from + n - 1; /* last register to set nil */ 133| 116k| Instruction *previous = previousinstruction(fs); 134| 116k| if (GET_OPCODE(*previous) == OP_LOADNIL) { /* previous is LOADNIL? */ ------------------ | | 114| 116k|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 139| 116k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (134:7): [True: 13, False: 116k] ------------------ 135| 13| int pfrom = GETARG_A(*previous); /* get previous range */ ------------------ | | 125| 13|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 13|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 144| 13|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 13|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 136| 13| int pl = pfrom + GETARG_B(*previous); ------------------ | | 128| 13|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 13|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 13|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 137| 13| if ((pfrom <= from && from <= pl + 1) || ------------------ | Branch (137:10): [True: 13, False: 0] | Branch (137:27): [True: 13, False: 0] ------------------ 138| 13| (from <= pfrom && pfrom <= l + 1)) { /* can connect both? */ ------------------ | Branch (138:10): [True: 0, False: 0] | Branch (138:27): [True: 0, False: 0] ------------------ 139| 13| if (pfrom < from) from = pfrom; /* from = min(from, pfrom) */ ------------------ | Branch (139:11): [True: 13, False: 0] ------------------ 140| 13| if (pl > l) l = pl; /* l = max(l, pl) */ ------------------ | Branch (140:11): [True: 0, False: 13] ------------------ 141| 13| SETARG_A(*previous, from); ------------------ | | 126| 13|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 13|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 13|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 13|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 13| ((cast(Instruction, v)<lasttarget = fs->pc; 234| 69.0M| return fs->pc; 235| 69.0M|} luaK_patchlist: 306| 17.3M|void luaK_patchlist (FuncState *fs, int list, int target) { 307| 17.3M| lua_assert(target <= fs->pc); ------------------ | | 109| 17.3M|#define lua_assert(c) assert(c) ------------------ 308| 17.3M| patchlistaux(fs, list, target, NO_REG, target); ------------------ | | 182| 17.3M|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 17.3M|#define MAXARG_A ((1<f; 384| | /* put new instruction in code array */ 385| 131M| luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction, ------------------ | | 69| 131M| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 139| 262M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 70| 131M| luaM_limitN(limit,t),e))) ------------------ 386| 131M| MAX_INT, "opcodes"); 387| 131M| f->code[fs->pc++] = i; 388| 131M| savelineinfo(fs, f, fs->ls->lastline); 389| 131M| return fs->pc - 1; /* index of new instruction */ 390| 131M|} luaK_codeABCk: 397| 104M|int luaK_codeABCk (FuncState *fs, OpCode o, int a, int b, int c, int k) { 398| 104M| lua_assert(getOpMode(o) == iABC); ------------------ | | 109| 104M|#define lua_assert(c) assert(c) ------------------ 399| 104M| lua_assert(a <= MAXARG_A && b <= MAXARG_B && ------------------ | | 109| 104M|#define lua_assert(c) assert(c) ------------------ 400| 104M| c <= MAXARG_C && (k & ~1) == 0); 401| 104M| return luaK_code(fs, CREATE_ABCk(o, a, b, c, k)); ------------------ | | 156| 104M|#define CREATE_ABCk(o,a,b,c,k) ((cast(Instruction, o)<freereg + n; 468| 70.8M| if (newstack > fs->f->maxstacksize) { ------------------ | Branch (468:7): [True: 55.5k, False: 70.7M] ------------------ 469| 55.5k| if (newstack >= MAXREGS) ------------------ | | 35| 55.5k|#define MAXREGS 255 ------------------ | Branch (469:9): [True: 0, False: 55.5k] ------------------ 470| 0| luaX_syntaxerror(fs->ls, 471| 0| "function or expression needs too many registers"); 472| 55.5k| fs->f->maxstacksize = cast_byte(newstack); ------------------ | | 146| 55.5k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 139| 55.5k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 473| 55.5k| } 474| 70.8M|} luaK_reserveregs: 480| 70.8M|void luaK_reserveregs (FuncState *fs, int n) { 481| 70.8M| luaK_checkstack(fs, n); 482| 70.8M| fs->freereg += n; 483| 70.8M|} luaK_int: 672| 310k|void luaK_int (FuncState *fs, int reg, lua_Integer i) { 673| 310k| if (fitsBx(i)) ------------------ | Branch (673:7): [True: 294k, False: 16.1k] ------------------ 674| 294k| codeAsBx(fs, OP_LOADI, reg, cast_int(i)); ------------------ | | 144| 294k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 294k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 675| 16.1k| else 676| 16.1k| luaK_codek(fs, reg, luaK_intK(fs, i)); 677| 310k|} luaK_setreturns: 721| 4.83k|void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) { 722| 4.83k| Instruction *pc = &getinstruction(fs, e); ------------------ | | 55| 4.83k|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 723| 4.83k| if (e->k == VCALL) /* expression is an open function call? */ ------------------ | Branch (723:7): [True: 3.92k, False: 910] ------------------ 724| 4.83k| SETARG_C(*pc, nresults + 1); ------------------ | | 134| 3.92k|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 3.92k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 3.92k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 3.92k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 3.92k| ((cast(Instruction, v)<k == VVARARG); ------------------ | | 109| 910|#define lua_assert(c) assert(c) ------------------ 727| 910| SETARG_C(*pc, nresults + 1); ------------------ | | 134| 910|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 910|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 910|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 910|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 910| ((cast(Instruction, v)<freereg); ------------------ | | 126| 910|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 910|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 910|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 910|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 910| ((cast(Instruction, v)<k == VCALL) { /* expression is an open function call? */ ------------------ | Branch (755:7): [True: 327k, False: 57.1k] ------------------ 756| | /* already returns 1 value */ 757| 327k| lua_assert(GETARG_C(getinstruction(fs, e)) == 2); ------------------ | | 109| 327k|#define lua_assert(c) assert(c) ------------------ 758| 327k| e->k = VNONRELOC; /* result has fixed position */ 759| 327k| e->u.info = GETARG_A(getinstruction(fs, e)); ------------------ | | 125| 327k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 327k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 144| 327k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 327k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 760| 327k| } 761| 57.1k| else if (e->k == VVARARG) { ------------------ | Branch (761:12): [True: 1.74k, False: 55.3k] ------------------ 762| 1.74k| SETARG_C(getinstruction(fs, e), 2); ------------------ | | 134| 1.74k|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 1.74k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 1.74k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 1.74k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 1.74k| ((cast(Instruction, v)<k = VRELOC; /* can relocate its simple result */ 764| 1.74k| } 765| 384k|} luaK_dischargevars: 772| 286M|void luaK_dischargevars (FuncState *fs, expdesc *e) { 773| 286M| switch (e->k) { 774| 1.18M| case VCONST: { ------------------ | Branch (774:5): [True: 1.18M, False: 285M] ------------------ 775| 1.18M| const2exp(const2val(fs, e), e); 776| 1.18M| break; 777| 0| } 778| 63.5k| case VLOCAL: { /* already in a register */ ------------------ | Branch (778:5): [True: 63.5k, False: 286M] ------------------ 779| 63.5k| e->u.info = e->u.var.ridx; 780| 63.5k| e->k = VNONRELOC; /* becomes a non-relocatable value */ 781| 63.5k| break; 782| 0| } 783| 8.62M| case VUPVAL: { /* move value to some (pending) register */ ------------------ | Branch (783:5): [True: 8.62M, False: 278M] ------------------ 784| 8.62M| e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0); ------------------ | | 48| 8.62M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 785| 8.62M| e->k = VRELOC; 786| 8.62M| break; 787| 0| } 788| 16.2M| case VINDEXUP: { ------------------ | Branch (788:5): [True: 16.2M, False: 270M] ------------------ 789| 16.2M| e->u.info = luaK_codeABC(fs, OP_GETTABUP, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 16.2M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 790| 16.2M| e->k = VRELOC; 791| 16.2M| break; 792| 0| } 793| 548| case VINDEXI: { ------------------ | Branch (793:5): [True: 548, False: 286M] ------------------ 794| 548| freereg(fs, e->u.ind.t); 795| 548| e->u.info = luaK_codeABC(fs, OP_GETI, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 548|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 796| 548| e->k = VRELOC; 797| 548| break; 798| 0| } 799| 1.14M| case VINDEXSTR: { ------------------ | Branch (799:5): [True: 1.14M, False: 285M] ------------------ 800| 1.14M| freereg(fs, e->u.ind.t); 801| 1.14M| e->u.info = luaK_codeABC(fs, OP_GETFIELD, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 1.14M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 802| 1.14M| e->k = VRELOC; 803| 1.14M| break; 804| 0| } 805| 8.59M| case VINDEXED: { ------------------ | Branch (805:5): [True: 8.59M, False: 278M] ------------------ 806| 8.59M| freeregs(fs, e->u.ind.t, e->u.ind.idx); 807| 8.59M| e->u.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 8.59M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 808| 8.59M| e->k = VRELOC; 809| 8.59M| break; 810| 0| } 811| 313k| case VVARARG: case VCALL: { ------------------ | Branch (811:5): [True: 1.74k, False: 286M] | Branch (811:19): [True: 311k, False: 286M] ------------------ 812| 313k| luaK_setoneret(fs, e); 813| 313k| break; 814| 1.74k| } 815| 250M| default: break; /* there is one value available (somewhere) */ ------------------ | Branch (815:5): [True: 250M, False: 36.1M] ------------------ 816| 286M| } 817| 286M|} luaK_exp2nextreg: 942| 70.7M|void luaK_exp2nextreg (FuncState *fs, expdesc *e) { 943| 70.7M| luaK_dischargevars(fs, e); 944| 70.7M| freeexp(fs, e); 945| 70.7M| luaK_reserveregs(fs, 1); 946| 70.7M| exp2reg(fs, e, fs->freereg - 1); 947| 70.7M|} luaK_exp2anyreg: 954| 93.5M|int luaK_exp2anyreg (FuncState *fs, expdesc *e) { 955| 93.5M| luaK_dischargevars(fs, e); 956| 93.5M| if (e->k == VNONRELOC) { /* expression already has a register? */ ------------------ | Branch (956:7): [True: 25.2M, False: 68.3M] ------------------ 957| 25.2M| if (!hasjumps(e)) /* no jumps? */ ------------------ | | 38| 25.2M|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (957:9): [True: 25.2M, False: 16.2k] ------------------ 958| 25.2M| return e->u.info; /* result is already in a register */ 959| 16.2k| if (e->u.info >= luaY_nvarstack(fs)) { /* reg. is not a local? */ ------------------ | Branch (959:9): [True: 15.5k, False: 675] ------------------ 960| 15.5k| exp2reg(fs, e, e->u.info); /* put final result in it */ 961| 15.5k| return e->u.info; 962| 15.5k| } 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| 16.2k| } 967| 68.3M| luaK_exp2nextreg(fs, e); /* default: use next available register */ 968| 68.3M| return e->u.info; 969| 93.5M|} luaK_exp2anyregup: 976| 26.1M|void luaK_exp2anyregup (FuncState *fs, expdesc *e) { 977| 26.1M| if (e->k != VUPVAL || hasjumps(e)) ------------------ | | 38| 24.9M|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 0, False: 24.9M] | | ------------------ ------------------ | Branch (977:7): [True: 1.17M, False: 24.9M] ------------------ 978| 1.17M| luaK_exp2anyreg(fs, e); 979| 26.1M|} luaK_exp2val: 986| 34.4k|void luaK_exp2val (FuncState *fs, expdesc *e) { 987| 34.4k| if (hasjumps(e)) ------------------ | | 38| 34.4k|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 52, False: 34.4k] | | ------------------ ------------------ 988| 52| luaK_exp2anyreg(fs, e); 989| 34.4k| else 990| 34.4k| luaK_dischargevars(fs, e); 991| 34.4k|} luaK_storevar: 1048| 102k|void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) { 1049| 102k| switch (var->k) { 1050| 4.43k| case VLOCAL: { ------------------ | Branch (1050:5): [True: 4.43k, False: 98.3k] ------------------ 1051| 4.43k| freeexp(fs, ex); 1052| 4.43k| exp2reg(fs, ex, var->u.var.ridx); /* compute 'ex' into proper place */ 1053| 4.43k| return; 1054| 0| } 1055| 8.48k| case VUPVAL: { ------------------ | Branch (1055:5): [True: 8.48k, False: 94.3k] ------------------ 1056| 8.48k| int e = luaK_exp2anyreg(fs, ex); 1057| 8.48k| luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0); ------------------ | | 48| 8.48k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1058| 8.48k| break; 1059| 0| } 1060| 63.1k| case VINDEXUP: { ------------------ | Branch (1060:5): [True: 63.1k, False: 39.6k] ------------------ 1061| 63.1k| codeABRK(fs, OP_SETTABUP, var->u.ind.t, var->u.ind.idx, ex); 1062| 63.1k| break; 1063| 0| } 1064| 264| case VINDEXI: { ------------------ | Branch (1064:5): [True: 264, False: 102k] ------------------ 1065| 264| codeABRK(fs, OP_SETI, var->u.ind.t, var->u.ind.idx, ex); 1066| 264| break; 1067| 0| } 1068| 6.54k| case VINDEXSTR: { ------------------ | Branch (1068:5): [True: 6.54k, False: 96.2k] ------------------ 1069| 6.54k| codeABRK(fs, OP_SETFIELD, var->u.ind.t, var->u.ind.idx, ex); 1070| 6.54k| break; 1071| 0| } 1072| 19.9k| case VINDEXED: { ------------------ | Branch (1072:5): [True: 19.9k, False: 82.9k] ------------------ 1073| 19.9k| codeABRK(fs, OP_SETTABLE, var->u.ind.t, var->u.ind.idx, ex); 1074| 19.9k| break; 1075| 0| } 1076| 0| default: lua_assert(0); /* invalid var kind to store */ ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ | Branch (1076:5): [True: 0, False: 102k] ------------------ 1077| 102k| } 1078| 98.3k| freeexp(fs, ex); 1079| 98.3k|} luaK_self: 1085| 313|void luaK_self (FuncState *fs, expdesc *e, expdesc *key) { 1086| 313| int ereg; 1087| 313| luaK_exp2anyreg(fs, e); 1088| 313| ereg = e->u.info; /* register where 'e' was placed */ 1089| 313| freeexp(fs, e); 1090| 313| e->u.info = fs->freereg; /* base register for op_self */ 1091| 313| e->k = VNONRELOC; /* self expression has a fixed register */ 1092| 313| luaK_reserveregs(fs, 2); /* function and 'self' produced by op_self */ 1093| 313| codeABRK(fs, OP_SELF, e->u.info, ereg, key); 1094| 313| freeexp(fs, key); 1095| 313|} luaK_goiftrue: 1133| 21.8k|void luaK_goiftrue (FuncState *fs, expdesc *e) { 1134| 21.8k| int pc; /* pc of new jump */ 1135| 21.8k| luaK_dischargevars(fs, e); 1136| 21.8k| switch (e->k) { 1137| 6.65k| case VJMP: { /* condition? */ ------------------ | Branch (1137:5): [True: 6.65k, False: 15.2k] ------------------ 1138| 6.65k| negatecondition(fs, e); /* jump when it is false */ 1139| 6.65k| pc = e->u.info; /* save jump position */ 1140| 6.65k| break; 1141| 0| } 1142| 1.49k| case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: { ------------------ | Branch (1142:5): [True: 0, False: 21.8k] | Branch (1142:14): [True: 589, False: 21.3k] | Branch (1142:26): [True: 870, False: 21.0k] | Branch (1142:38): [True: 0, False: 21.8k] | Branch (1142:50): [True: 34, False: 21.8k] ------------------ 1143| 1.49k| pc = NO_JUMP; /* always true; do nothing */ ------------------ | | 20| 1.49k|#define NO_JUMP (-1) ------------------ 1144| 1.49k| break; 1145| 1.45k| } 1146| 13.7k| default: { ------------------ | Branch (1146:5): [True: 13.7k, False: 8.14k] ------------------ 1147| 13.7k| pc = jumponcond(fs, e, 0); /* jump when false */ 1148| 13.7k| break; 1149| 1.45k| } 1150| 21.8k| } 1151| 21.8k| luaK_concat(fs, &e->f, pc); /* insert new jump in false list */ 1152| 21.8k| luaK_patchtohere(fs, e->t); /* true list jumps to here (to go through) */ 1153| 21.8k| e->t = NO_JUMP; ------------------ | | 20| 21.8k|#define NO_JUMP (-1) ------------------ 1154| 21.8k|} luaK_goiffalse: 1160| 84.6k|void luaK_goiffalse (FuncState *fs, expdesc *e) { 1161| 84.6k| int pc; /* pc of new jump */ 1162| 84.6k| luaK_dischargevars(fs, e); 1163| 84.6k| switch (e->k) { 1164| 53.2k| case VJMP: { ------------------ | Branch (1164:5): [True: 53.2k, False: 31.4k] ------------------ 1165| 53.2k| pc = e->u.info; /* already jump if true */ 1166| 53.2k| break; 1167| 0| } 1168| 553| case VNIL: case VFALSE: { ------------------ | Branch (1168:5): [True: 553, False: 84.1k] | Branch (1168:16): [True: 0, False: 84.6k] ------------------ 1169| 553| pc = NO_JUMP; /* always false; do nothing */ ------------------ | | 20| 553|#define NO_JUMP (-1) ------------------ 1170| 553| break; 1171| 553| } 1172| 30.9k| default: { ------------------ | Branch (1172:5): [True: 30.9k, False: 53.7k] ------------------ 1173| 30.9k| pc = jumponcond(fs, e, 1); /* jump if true */ 1174| 30.9k| break; 1175| 553| } 1176| 84.6k| } 1177| 84.6k| luaK_concat(fs, &e->t, pc); /* insert new jump in 't' list */ 1178| 84.6k| luaK_patchtohere(fs, e->f); /* false list jumps to here (to go through) */ 1179| 84.6k| e->f = NO_JUMP; ------------------ | | 20| 84.6k|#define NO_JUMP (-1) ------------------ 1180| 84.6k|} luaK_indexed: 1278| 26.1M|void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) { 1279| 26.1M| if (k->k == VKSTR) ------------------ | Branch (1279:7): [True: 26.0M, False: 34.4k] ------------------ 1280| 26.0M| str2K(fs, k); 1281| 26.1M| lua_assert(!hasjumps(t) && ------------------ | | 109| 26.1M|#define lua_assert(c) assert(c) ------------------ 1282| 26.1M| (t->k == VLOCAL || t->k == VNONRELOC || t->k == VUPVAL)); 1283| 26.1M| if (t->k == VUPVAL && !isKstr(fs, k)) /* upvalue indexed by non 'Kstr'? */ ------------------ | Branch (1283:7): [True: 24.9M, False: 1.17M] | Branch (1283:25): [True: 8.59M, False: 16.3M] ------------------ 1284| 8.59M| luaK_exp2anyreg(fs, t); /* put it in a register */ 1285| 26.1M| if (t->k == VUPVAL) { ------------------ | Branch (1285:7): [True: 16.3M, False: 9.77M] ------------------ 1286| 16.3M| lua_assert(isKstr(fs, k)); ------------------ | | 109| 16.3M|#define lua_assert(c) assert(c) ------------------ 1287| 16.3M| t->u.ind.t = t->u.info; /* upvalue index */ 1288| 16.3M| t->u.ind.idx = k->u.info; /* literal short string */ 1289| 16.3M| t->k = VINDEXUP; 1290| 16.3M| } 1291| 9.77M| else { 1292| | /* register index of the table */ 1293| 9.77M| t->u.ind.t = (t->k == VLOCAL) ? t->u.var.ridx: t->u.info; ------------------ | Branch (1293:18): [True: 0, False: 9.77M] ------------------ 1294| 9.77M| if (isKstr(fs, k)) { ------------------ | Branch (1294:9): [True: 1.15M, False: 8.61M] ------------------ 1295| 1.15M| t->u.ind.idx = k->u.info; /* literal short string */ 1296| 1.15M| t->k = VINDEXSTR; 1297| 1.15M| } 1298| 8.61M| else if (isCint(k)) { ------------------ | Branch (1298:14): [True: 812, False: 8.61M] ------------------ 1299| 812| t->u.ind.idx = cast_int(k->u.ival); /* int. constant in proper range */ ------------------ | | 144| 812|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 812|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1300| 812| t->k = VINDEXI; 1301| 812| } 1302| 8.61M| else { 1303| 8.61M| t->u.ind.idx = luaK_exp2anyreg(fs, k); /* register */ 1304| 8.61M| t->k = VINDEXED; 1305| 8.61M| } 1306| 9.77M| } 1307| 26.1M|} luaK_prefix: 1613| 204k|void luaK_prefix (FuncState *fs, UnOpr opr, expdesc *e, int line) { 1614| 204k| static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP}; ------------------ | | 20| 204k|#define NO_JUMP (-1) ------------------ static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP}; ------------------ | | 20| 204k|#define NO_JUMP (-1) ------------------ 1615| 204k| luaK_dischargevars(fs, e); 1616| 204k| switch (opr) { 1617| 188k| case OPR_MINUS: case OPR_BNOT: /* use 'ef' as fake 2nd operand */ ------------------ | Branch (1617:5): [True: 69.3k, False: 135k] | Branch (1617:21): [True: 119k, False: 85.7k] ------------------ 1618| 188k| if (constfolding(fs, opr + LUA_OPUNM, e, &ef)) ------------------ | | 227| 188k|#define LUA_OPUNM 12 ------------------ | Branch (1618:11): [True: 86.2k, False: 102k] ------------------ 1619| 86.2k| break; 1620| | /* else */ /* FALLTHROUGH */ 1621| 114k| case OPR_LEN: ------------------ | Branch (1621:5): [True: 12.6k, False: 192k] ------------------ 1622| 114k| codeunexpval(fs, unopr2op(opr), e, line); 1623| 114k| break; 1624| 3.66k| case OPR_NOT: codenot(fs, e); break; ------------------ | Branch (1624:5): [True: 3.66k, False: 201k] ------------------ 1625| 0| default: lua_assert(0); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ | Branch (1625:5): [True: 0, False: 204k] ------------------ 1626| 204k| } 1627| 204k|} luaK_infix: 1634| 25.6M|void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) { 1635| 25.6M| luaK_dischargevars(fs, v); 1636| 25.6M| switch (op) { 1637| 18.7k| case OPR_AND: { ------------------ | Branch (1637:5): [True: 18.7k, False: 25.6M] ------------------ 1638| 18.7k| luaK_goiftrue(fs, v); /* go ahead only if 'v' is true */ 1639| 18.7k| break; 1640| 0| } 1641| 76.5k| case OPR_OR: { ------------------ | Branch (1641:5): [True: 76.5k, False: 25.5M] ------------------ 1642| 76.5k| luaK_goiffalse(fs, v); /* go ahead only if 'v' is false */ 1643| 76.5k| break; 1644| 0| } 1645| 59.8k| case OPR_CONCAT: { ------------------ | Branch (1645:5): [True: 59.8k, False: 25.5M] ------------------ 1646| 59.8k| luaK_exp2nextreg(fs, v); /* operand must be on the stack */ 1647| 59.8k| break; 1648| 0| } 1649| 106k| case OPR_ADD: case OPR_SUB: ------------------ | Branch (1649:5): [True: 11.5k, False: 25.6M] | Branch (1649:19): [True: 95.1k, False: 25.5M] ------------------ 1650| 7.23M| case OPR_MUL: case OPR_DIV: case OPR_IDIV: ------------------ | Branch (1650:5): [True: 69.2k, False: 25.5M] | Branch (1650:19): [True: 7.01M, False: 18.6M] | Branch (1650:33): [True: 44.4k, False: 25.6M] ------------------ 1651| 7.68M| case OPR_MOD: case OPR_POW: ------------------ | Branch (1651:5): [True: 91.8k, False: 25.5M] | Branch (1651:19): [True: 360k, False: 25.2M] ------------------ 1652| 7.85M| case OPR_BAND: case OPR_BOR: case OPR_BXOR: ------------------ | Branch (1652:5): [True: 15.6k, False: 25.6M] | Branch (1652:20): [True: 10.5k, False: 25.6M] | Branch (1652:34): [True: 138k, False: 25.5M] ------------------ 1653| 8.22M| case OPR_SHL: case OPR_SHR: { ------------------ | Branch (1653:5): [True: 89.6k, False: 25.5M] | Branch (1653:19): [True: 282k, False: 25.3M] ------------------ 1654| 8.22M| if (!tonumeral(v, NULL)) ------------------ | Branch (1654:11): [True: 7.77M, False: 451k] ------------------ 1655| 7.77M| luaK_exp2anyreg(fs, v); 1656| | /* else keep numeral, which may be folded or used as an immediate 1657| | operand */ 1658| 8.22M| break; 1659| 7.94M| } 1660| 15.6k| case OPR_EQ: case OPR_NE: { ------------------ | Branch (1660:5): [True: 11.4k, False: 25.6M] | Branch (1660:18): [True: 4.13k, False: 25.6M] ------------------ 1661| 15.6k| if (!tonumeral(v, NULL)) ------------------ | Branch (1661:11): [True: 12.3k, False: 3.30k] ------------------ 1662| 12.3k| exp2RK(fs, v); 1663| | /* else keep numeral, which may be an immediate operand */ 1664| 15.6k| break; 1665| 11.4k| } 1666| 1.22M| case OPR_LT: case OPR_LE: ------------------ | Branch (1666:5): [True: 1.21M, False: 24.4M] | Branch (1666:18): [True: 7.66k, False: 25.6M] ------------------ 1667| 17.2M| case OPR_GT: case OPR_GE: { ------------------ | Branch (1667:5): [True: 16.0M, False: 9.61M] | Branch (1667:18): [True: 4.39k, False: 25.6M] ------------------ 1668| 17.2M| int dummy, dummy2; 1669| 17.2M| if (!isSCnumber(v, &dummy, &dummy2)) ------------------ | Branch (1669:11): [True: 17.2M, False: 6.59k] ------------------ 1670| 17.2M| luaK_exp2anyreg(fs, v); 1671| | /* else keep numeral, which may be an immediate operand */ 1672| 17.2M| break; 1673| 17.2M| } 1674| 0| default: lua_assert(0); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ | Branch (1674:5): [True: 0, False: 25.6M] ------------------ 1675| 25.6M| } 1676| 25.6M|} luaK_posfix: 1704| 25.6M| expdesc *e1, expdesc *e2, int line) { 1705| 25.6M| luaK_dischargevars(fs, e2); 1706| 25.6M| if (foldbinop(opr) && constfolding(fs, opr + LUA_OPADD, e1, e2)) ------------------ | | 45| 51.2M|#define foldbinop(op) ((op) <= OPR_SHR) | | ------------------ | | | Branch (45:23): [True: 8.22M, False: 17.4M] | | ------------------ ------------------ if (foldbinop(opr) && constfolding(fs, opr + LUA_OPADD, e1, e2)) ------------------ | | 215| 8.22M|#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ ------------------ | Branch (1706:25): [True: 168k, False: 8.05M] ------------------ 1707| 168k| return; /* done by folding */ 1708| 25.4M| switch (opr) { 1709| 18.0k| case OPR_AND: { ------------------ | Branch (1709:5): [True: 18.0k, False: 25.4M] ------------------ 1710| 18.0k| lua_assert(e1->t == NO_JUMP); /* list closed by 'luaK_infix' */ ------------------ | | 109| 18.0k|#define lua_assert(c) assert(c) ------------------ 1711| 18.0k| luaK_concat(fs, &e2->f, e1->f); 1712| 18.0k| *e1 = *e2; 1713| 18.0k| break; 1714| 18.0k| } 1715| 75.5k| case OPR_OR: { ------------------ | Branch (1715:5): [True: 75.5k, False: 25.4M] ------------------ 1716| 75.5k| lua_assert(e1->f == NO_JUMP); /* list closed by 'luaK_infix' */ ------------------ | | 109| 75.5k|#define lua_assert(c) assert(c) ------------------ 1717| 75.5k| luaK_concat(fs, &e2->t, e1->t); 1718| 75.5k| *e1 = *e2; 1719| 75.5k| break; 1720| 75.5k| } 1721| 59.7k| case OPR_CONCAT: { /* e1 .. e2 */ ------------------ | Branch (1721:5): [True: 59.7k, False: 25.4M] ------------------ 1722| 59.7k| luaK_exp2nextreg(fs, e2); 1723| 59.7k| codeconcat(fs, e1, e2, line); 1724| 59.7k| break; 1725| 75.5k| } 1726| 60.2k| case OPR_ADD: case OPR_MUL: { ------------------ | Branch (1726:5): [True: 7.61k, False: 25.4M] | Branch (1726:19): [True: 52.6k, False: 25.4M] ------------------ 1727| 60.2k| codecommutative(fs, opr, e1, e2, line); 1728| 60.2k| break; 1729| 7.61k| } 1730| 85.9k| case OPR_SUB: { ------------------ | Branch (1730:5): [True: 85.9k, False: 25.3M] ------------------ 1731| 85.9k| if (finishbinexpneg(fs, e1, e2, OP_ADDI, line, TM_SUB)) ------------------ | Branch (1731:11): [True: 51.1k, False: 34.8k] ------------------ 1732| 51.1k| break; /* coded as (r1 + -I) */ 1733| | /* ELSE */ 1734| 85.9k| } /* FALLTHROUGH */ 1735| 7.41M| case OPR_DIV: case OPR_IDIV: case OPR_MOD: case OPR_POW: { ------------------ | Branch (1735:5): [True: 7.00M, False: 18.4M] | Branch (1735:19): [True: 42.4k, False: 25.4M] | Branch (1735:34): [True: 78.0k, False: 25.3M] | Branch (1735:48): [True: 254k, False: 25.2M] ------------------ 1736| 7.41M| codearith(fs, opr, e1, e2, 0, line); 1737| 7.41M| break; 1738| 7.15M| } 1739| 159k| case OPR_BAND: case OPR_BOR: case OPR_BXOR: { ------------------ | Branch (1739:5): [True: 15.0k, False: 25.4M] | Branch (1739:20): [True: 10.4k, False: 25.4M] | Branch (1739:34): [True: 133k, False: 25.3M] ------------------ 1740| 159k| codebitwise(fs, opr, e1, e2, line); 1741| 159k| break; 1742| 25.5k| } 1743| 87.2k| case OPR_SHL: { ------------------ | Branch (1743:5): [True: 87.2k, False: 25.3M] ------------------ 1744| 87.2k| if (isSCint(e1)) { ------------------ | Branch (1744:11): [True: 5.76k, False: 81.4k] ------------------ 1745| 5.76k| swapexps(e1, e2); 1746| 5.76k| codebini(fs, OP_SHLI, e1, e2, 1, line, TM_SHL); /* I << r2 */ 1747| 5.76k| } 1748| 81.4k| else if (finishbinexpneg(fs, e1, e2, OP_SHRI, line, TM_SHL)) { ------------------ | Branch (1748:16): [True: 2.92k, False: 78.5k] ------------------ 1749| 2.92k| /* coded as (r1 >> -I) */; 1750| 2.92k| } 1751| 78.5k| else /* regular case (two registers) */ 1752| 78.5k| codebinexpval(fs, opr, e1, e2, line); 1753| 87.2k| break; 1754| 25.5k| } 1755| 280k| case OPR_SHR: { ------------------ | Branch (1755:5): [True: 280k, False: 25.1M] ------------------ 1756| 280k| if (isSCint(e2)) ------------------ | Branch (1756:11): [True: 78.3k, False: 202k] ------------------ 1757| 78.3k| codebini(fs, OP_SHRI, e1, e2, 0, line, TM_SHR); /* r1 >> I */ 1758| 202k| else /* regular case (two registers) */ 1759| 202k| codebinexpval(fs, opr, e1, e2, line); 1760| 280k| break; 1761| 25.5k| } 1762| 15.5k| case OPR_EQ: case OPR_NE: { ------------------ | Branch (1762:5): [True: 11.4k, False: 25.4M] | Branch (1762:18): [True: 4.03k, False: 25.4M] ------------------ 1763| 15.5k| codeeq(fs, opr, e1, e2); 1764| 15.5k| break; 1765| 11.4k| } 1766| 16.0M| case OPR_GT: case OPR_GE: { ------------------ | Branch (1766:5): [True: 16.0M, False: 9.44M] | Branch (1766:18): [True: 4.39k, False: 25.4M] ------------------ 1767| | /* '(a > b)' <=> '(b < a)'; '(a >= b)' <=> '(b <= a)' */ 1768| 16.0M| swapexps(e1, e2); 1769| 16.0M| opr = cast(BinOpr, (opr - OPR_GT) + OPR_LT); ------------------ | | 139| 16.0M|#define cast(t, exp) ((t)(exp)) ------------------ 1770| 16.0M| } /* FALLTHROUGH */ 1771| 17.2M| case OPR_LT: case OPR_LE: { ------------------ | Branch (1771:5): [True: 1.21M, False: 24.2M] | Branch (1771:18): [True: 7.38k, False: 25.4M] ------------------ 1772| 17.2M| codeorder(fs, opr, e1, e2); 1773| 17.2M| break; 1774| 17.2M| } 1775| 0| default: lua_assert(0); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ | Branch (1775:5): [True: 0, False: 25.4M] ------------------ 1776| 25.4M| } 1777| 25.4M|} luaK_fixline: 1784| 16.6M|void luaK_fixline (FuncState *fs, int line) { 1785| 16.6M| removelastlineinfo(fs); 1786| 16.6M| savelineinfo(fs, fs->f, line); 1787| 16.6M|} luaK_settablesize: 1790| 4.61k|void luaK_settablesize (FuncState *fs, int pc, int ra, int asize, int hsize) { 1791| 4.61k| Instruction *inst = &fs->f->code[pc]; 1792| 4.61k| int rb = (hsize != 0) ? luaO_ceillog2(hsize) + 1 : 0; /* hash size */ ------------------ | Branch (1792:12): [True: 8, False: 4.60k] ------------------ 1793| 4.61k| int extra = asize / (MAXARG_C + 1); /* higher bits of array size */ ------------------ | | 97| 4.61k|#define MAXARG_C ((1< 0); /* true iff needs extra argument */ 1796| 4.61k| *inst = CREATE_ABCk(OP_NEWTABLE, ra, rb, rc, k); ------------------ | | 156| 4.61k|#define CREATE_ABCk(o,a,b,c,k) ((cast(Instruction, o)<freereg = base + 1; /* free registers with list values */ 1821| 32.1k|} luaK_finish: 1844| 20.9k|void luaK_finish (FuncState *fs) { 1845| 20.9k| int i; 1846| 20.9k| Proto *p = fs->f; 1847| 53.6M| for (i = 0; i < fs->pc; i++) { ------------------ | Branch (1847:15): [True: 53.6M, False: 20.9k] ------------------ 1848| 53.6M| Instruction *pc = &p->code[i]; 1849| 53.6M| lua_assert(i == 0 || isOT(*(pc - 1)) == isIT(*pc)); ------------------ | | 109| 53.6M|#define lua_assert(c) assert(c) ------------------ 1850| 53.6M| switch (GET_OPCODE(*pc)) { ------------------ | | 114| 53.6M|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 139| 53.6M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1851| 23.6k| case OP_RETURN0: case OP_RETURN1: { ------------------ | Branch (1851:7): [True: 20.9k, False: 53.6M] | Branch (1851:24): [True: 2.65k, False: 53.6M] ------------------ 1852| 23.6k| if (!(fs->needclose || (p->flag & PF_ISVARARG))) ------------------ | | 582| 22.4k|#define PF_ISVARARG 1 ------------------ | Branch (1852:15): [True: 1.22k, False: 22.4k] | Branch (1852:32): [True: 352, False: 22.0k] ------------------ 1853| 22.0k| break; /* no extra work */ 1854| | /* else use OP_RETURN to do the extra work */ 1855| 1.57k| SET_OPCODE(*pc, OP_RETURN); ------------------ | | 115| 1.57k|#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ | | ------------------ | | | | 108| 1.57k|#define MASK0(n,p) (~MASK1(n,p)) | | | | ------------------ | | | | | | 105| 1.57k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | ------------------ | | ------------------ | | 116| 1.57k| ((cast(Instruction, o)<needclose) ------------------ | Branch (1858:13): [True: 2.43k, False: 686] ------------------ 1859| 3.11k| SETARG_k(*pc, 1); /* signal that it needs to close */ ------------------ | | 138| 2.43k|#define SETARG_k(i,v) setarg(i, v, POS_k, 1) | | ------------------ | | | | 122| 2.43k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 2.43k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 2.43k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 2.43k| ((cast(Instruction, v)<flag & PF_ISVARARG) ------------------ | | 582| 3.11k|#define PF_ISVARARG 1 ------------------ | Branch (1860:13): [True: 617, False: 2.50k] ------------------ 1861| 3.11k| SETARG_C(*pc, p->numparams + 1); /* signal that it is vararg */ ------------------ | | 134| 617|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 617|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 617|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 617|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 617| ((cast(Instruction, v)<code, i); 1866| 10.0M| fixjump(fs, i, target); 1867| 10.0M| break; 1868| 3.03k| } 1869| 43.5M| default: break; ------------------ | Branch (1869:7): [True: 43.5M, False: 10.1M] ------------------ 1870| 53.6M| } 1871| 53.6M| } 1872| 20.9k|} lcode.c:const2val: 74| 1.18M|static TValue *const2val (FuncState *fs, const expdesc *e) { 75| 1.18M| lua_assert(e->k == VCONST); ------------------ | | 109| 1.18M|#define lua_assert(c) assert(c) ------------------ 76| 1.18M| return &fs->ls->dyd->actvar.arr[e->u.info].k; 77| 1.18M|} lcode.c:tonumeral: 56| 24.7M|static int tonumeral (const expdesc *e, TValue *v) { 57| 24.7M| if (hasjumps(e)) ------------------ | | 38| 24.7M|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 16.0k, False: 24.7M] | | ------------------ ------------------ 58| 16.0k| return 0; /* not a numeral */ 59| 24.7M| switch (e->k) { 60| 1.35M| case VKINT: ------------------ | Branch (60:5): [True: 1.35M, False: 23.3M] ------------------ 61| 1.35M| if (v) setivalue(v, e->u.ival); ------------------ | | 358| 790k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 790k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 790k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ | Branch (61:11): [True: 790k, False: 563k] ------------------ 62| 1.35M| return 1; 63| 252k| case VKFLT: ------------------ | Branch (63:5): [True: 252k, False: 24.4M] ------------------ 64| 252k| if (v) setfltvalue(v, e->u.nval); ------------------ | | 352| 130k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 130k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 130k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ | Branch (64:11): [True: 130k, False: 121k] ------------------ 65| 252k| return 1; 66| 23.1M| default: return 0; ------------------ | Branch (66:5): [True: 23.1M, False: 1.60M] ------------------ 67| 24.7M| } 68| 24.7M|} lcode.c:previousinstruction: 116| 176k|static Instruction *previousinstruction (FuncState *fs) { 117| 176k| static const Instruction invalidinstruction = ~(Instruction)0; 118| 176k| if (fs->pc > fs->lasttarget) ------------------ | Branch (118:7): [True: 160k, False: 16.0k] ------------------ 119| 160k| return &fs->f->code[fs->pc - 1]; /* previous instruction */ 120| 16.0k| else 121| 16.0k| return cast(Instruction*, &invalidinstruction); ------------------ | | 139| 16.0k|#define cast(t, exp) ((t)(exp)) ------------------ 122| 176k|} lcode.c:getjump: 154| 24.8M|static int getjump (FuncState *fs, int pc) { 155| 24.8M| int offset = GETARG_sJ(fs->f->code[pc]); ------------------ | | 151| 24.8M| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | ------------------ | | | | 113| 24.8M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 24.8M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 156| 24.8M| if (offset == NO_JUMP) /* point to itself represents end of list */ ------------------ | | 20| 24.8M|#define NO_JUMP (-1) ------------------ | Branch (156:7): [True: 17.3M, False: 7.46M] ------------------ 157| 17.3M| return NO_JUMP; /* end of list */ ------------------ | | 20| 17.3M|#define NO_JUMP (-1) ------------------ 158| 7.46M| else 159| 7.46M| return (pc+1)+offset; /* turn offset into absolute position */ 160| 24.8M|} lcode.c:fixjump: 167| 27.4M|static void fixjump (FuncState *fs, int pc, int dest) { 168| 27.4M| Instruction *jmp = &fs->f->code[pc]; 169| 27.4M| int offset = dest - (pc + 1); 170| 27.4M| lua_assert(dest != NO_JUMP); ------------------ | | 109| 27.4M|#define lua_assert(c) assert(c) ------------------ 171| 27.4M| if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) ------------------ | | 92| 27.4M|#define OFFSET_sJ (MAXARG_sJ >> 1) | | ------------------ | | | | 87| 27.4M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | | | ------------------ | | | | | | 43| 27.4M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 40| 27.4M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 38| 27.4M|#define SIZE_C 8 | | | | | | | | ------------------ | | | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 39| 27.4M|#define SIZE_B 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 41| 27.4M|#define SIZE_A 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) ------------------ | | 87| 27.4M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | ------------------ | | | | 43| 27.4M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | ------------------ | | | | | | 40| 27.4M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | ------------------ | | | | | | | | 38| 27.4M|#define SIZE_C 8 | | | | | | ------------------ | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | ------------------ | | | | | | | | 39| 27.4M|#define SIZE_B 8 | | | | | | ------------------ | | | | ------------------ | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | ------------------ | | | | | | 41| 27.4M|#define SIZE_A 8 | | | | ------------------ | | ------------------ ------------------ if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) ------------------ | | 92| 27.4M|#define OFFSET_sJ (MAXARG_sJ >> 1) | | ------------------ | | | | 87| 27.4M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | | | ------------------ | | | | | | 43| 27.4M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 40| 27.4M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 38| 27.4M|#define SIZE_C 8 | | | | | | | | ------------------ | | | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 39| 27.4M|#define SIZE_B 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 41| 27.4M|#define SIZE_A 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (171:9): [True: 27.4M, False: 0] | Branch (171:33): [True: 27.4M, False: 0] ------------------ 172| 0| luaX_syntaxerror(fs->ls, "control structure too long"); 173| 27.4M| lua_assert(GET_OPCODE(*jmp) == OP_JMP); ------------------ | | 109| 27.4M|#define lua_assert(c) assert(c) ------------------ 174| 27.4M| SETARG_sJ(*jmp, offset); ------------------ | | 153| 27.4M| setarg(i, cast_uint((j)+OFFSET_sJ), POS_sJ, SIZE_sJ) | | ------------------ | | | | 122| 27.4M|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 27.4M|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 27.4M|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 27.4M| ((cast(Instruction, v)<>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 139| 17.3M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (261:7): [True: 17.3M, False: 38.7k] ------------------ 262| 17.3M| return 0; /* cannot patch other instructions */ 263| 38.7k| if (reg != NO_REG && reg != GETARG_B(*i)) ------------------ | | 182| 38.7k|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 77.4k|#define MAXARG_A ((1<f->code[pc]; 245| 34.6M| if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1)))) ------------------ | | 385| 34.6M|#define testTMode(m) (luaP_opmodes[m] & (1 << 4)) | | ------------------ | | | Branch (385:22): [True: 34.5M, False: 42.2k] | | ------------------ ------------------ | Branch (245:7): [True: 34.6M, False: 0] ------------------ 246| 34.5M| return pi-1; 247| 42.2k| else 248| 42.2k| return pi; 249| 34.6M|} lcode.c:savelineinfo: 329| 147M|static void savelineinfo (FuncState *fs, Proto *f, int line) { 330| 147M| int linedif = line - fs->previousline; 331| 147M| int pc = fs->pc - 1; /* last instruction coded */ 332| 147M| if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) { ------------------ | | 319| 295M|#define LIMLINEDIFF 0x80 ------------------ if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) { ------------------ | | 35| 147M|#define MAXIWTHABS 128 ------------------ | Branch (332:7): [True: 1.19k, False: 147M] | Branch (332:38): [True: 1.15M, False: 146M] ------------------ 333| 1.15M| luaM_growvector(fs->ls->L, f->abslineinfo, fs->nabslineinfo, ------------------ | | 69| 1.15M| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 139| 2.30M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 70| 1.15M| luaM_limitN(limit,t),e))) ------------------ 334| 1.15M| f->sizeabslineinfo, AbsLineInfo, MAX_INT, "lines"); 335| 1.15M| f->abslineinfo[fs->nabslineinfo].pc = pc; 336| 1.15M| f->abslineinfo[fs->nabslineinfo++].line = line; 337| 1.15M| linedif = ABSLINEINFO; /* signal that there is absolute information */ ------------------ | | 27| 1.15M|#define ABSLINEINFO (-0x80) ------------------ 338| 1.15M| fs->iwthabs = 1; /* restart counter */ 339| 1.15M| } 340| 147M| luaM_growvector(fs->ls->L, f->lineinfo, pc, f->sizelineinfo, ls_byte, ------------------ | | 69| 147M| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 139| 295M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 70| 147M| luaM_limitN(limit,t),e))) ------------------ 341| 147M| MAX_INT, "opcodes"); 342| 147M| f->lineinfo[pc] = linedif; 343| 147M| fs->previousline = line; /* last line saved */ 344| 147M|} lcode.c:codesJ: 429| 17.3M|static int codesJ (FuncState *fs, OpCode o, int sj, int k) { 430| 17.3M| unsigned int j = sj + OFFSET_sJ; ------------------ | | 92| 17.3M|#define OFFSET_sJ (MAXARG_sJ >> 1) | | ------------------ | | | | 87| 17.3M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | | | ------------------ | | | | | | 43| 17.3M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 40| 17.3M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 38| 17.3M|#define SIZE_C 8 | | | | | | | | ------------------ | | | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 39| 17.3M|#define SIZE_B 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 41| 17.3M|#define SIZE_A 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 431| 17.3M| lua_assert(getOpMode(o) == isJ); ------------------ | | 109| 17.3M|#define lua_assert(c) assert(c) ------------------ 432| 17.3M| lua_assert(j <= MAXARG_sJ && (k & ~1) == 0); ------------------ | | 109| 17.3M|#define lua_assert(c) assert(c) ------------------ 433| 17.3M| return luaK_code(fs, CREATE_sJ(o, j, k)); ------------------ | | 169| 17.3M|#define CREATE_sJ(o,j,k) ((cast(Instruction, o) << POS_OP) \ | | ------------------ | | | | 139| 17.3M|#define cast(t, exp) ((t)(exp)) | | ------------------ | | #define CREATE_sJ(o,j,k) ((cast(Instruction, o) << POS_OP) \ | | ------------------ | | | | 47| 17.3M|#define POS_OP 0 | | ------------------ | | 170| 17.3M| | (cast(Instruction, j) << POS_sJ) \ | | ------------------ | | | | 139| 17.3M|#define cast(t, exp) ((t)(exp)) | | ------------------ | | | (cast(Instruction, j) << POS_sJ) \ | | ------------------ | | | | 58| 17.3M|#define POS_sJ POS_A | | | | ------------------ | | | | | | 49| 17.3M|#define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 47| 17.3M|#define POS_OP 0 | | | | | | ------------------ | | | | | | #define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 45| 17.3M|#define SIZE_OP 7 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 171| 17.3M| | (cast(Instruction, k) << POS_k)) | | ------------------ | | | | 139| 17.3M|#define cast(t, exp) ((t)(exp)) | | ------------------ | | | (cast(Instruction, k) << POS_k)) | | ------------------ | | | | 50| 17.3M|#define POS_k (POS_A + SIZE_A) | | | | ------------------ | | | | | | 49| 17.3M|#define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 47| 17.3M|#define POS_OP 0 | | | | | | ------------------ | | | | | | #define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 45| 17.3M|#define SIZE_OP 7 | | | | | | ------------------ | | | | ------------------ | | | | #define POS_k (POS_A + SIZE_A) | | | | ------------------ | | | | | | 41| 17.3M|#define SIZE_A 8 | | | | ------------------ | | ------------------ ------------------ 434| 17.3M|} lcode.c:fitsBx: 667| 347k|static int fitsBx (lua_Integer i) { 668| 347k| return (-OFFSET_sBx <= i && i <= MAXARG_Bx - OFFSET_sBx); ------------------ | | 77| 347k|#define OFFSET_sBx (MAXARG_Bx>>1) /* 'sBx' is signed */ | | ------------------ | | | | 72| 347k|#define MAXARG_Bx ((1<>1) /* 'sBx' is signed */ | | ------------------ | | | | 72| 344k|#define MAXARG_Bx ((1<>1) /* 'sBx' is signed */ | | ------------------ | | | | 72| 323k|#define MAXARG_Bx ((1<value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 229k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 588| 229k| return addk(fs, &o, &o); /* use integer itself as key */ 589| 229k|} lcode.c:addk: 543| 26.7M|static int addk (FuncState *fs, TValue *key, TValue *v) { 544| 26.7M| TValue val; 545| 26.7M| lua_State *L = fs->ls->L; 546| 26.7M| Proto *f = fs->f; 547| 26.7M| int tag = luaH_get(fs->ls->h, key, &val); /* query scanner table */ 548| 26.7M| int k, oldsize; 549| 26.7M| if (tag == LUA_VNUMINT) { /* is there an index there? */ ------------------ | | 336| 26.7M|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 26.7M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (549:7): [True: 26.7M, False: 38.7k] ------------------ 550| 26.7M| k = cast_int(ivalue(&val)); ------------------ | | 144| 26.7M|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 106M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [True: 0, False: 26.7M] | | | | | Branch (139:27): [True: 26.7M, False: 0] | | | | ------------------ | | ------------------ ------------------ 551| | /* correct value? (warning: must distinguish floats from integers!) */ 552| 26.7M| if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) && ------------------ | | 84| 26.6M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 26.6M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) && ------------------ | | 84| 26.6M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 53.4M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ | Branch (552:9): [True: 26.6M, False: 69.9k] | Branch (552:23): [True: 26.6M, False: 1.35k] ------------------ 553| 26.7M| luaV_rawequalobj(&f->k[k], v)) ------------------ | | 75| 26.6M|#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2) | | ------------------ | | | Branch (75:34): [True: 26.6M, False: 52.5k] | | ------------------ ------------------ 554| 26.6M| return k; /* reuse index */ 555| 26.7M| } 556| | /* constant not found; create a new entry */ 557| 162k| oldsize = f->sizek; 558| 162k| 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| 162k| setivalue(&val, k); ------------------ | | 358| 162k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 162k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 162k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 562| 162k| luaH_set(L, fs->ls->h, key, &val); 563| 162k| luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants"); ------------------ | | 69| 162k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 139| 325k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 70| 162k| luaM_limitN(limit,t),e))) ------------------ 564| 412k| while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]); ------------------ | | 211| 249k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 412k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ | Branch (564:10): [True: 249k, False: 162k] ------------------ 565| 162k| setobj(L, &f->k[k], v); ------------------ | | 119| 162k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 162k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 162k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 162k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 162k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 1.82M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 162k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 110k] | | | | | | | Branch (115:29): [True: 110k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 110k] | | | | | | | Branch (115:29): [True: 110k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 110k] | | | | | | | Branch (115:29): [True: 110k, False: 0] | | | | | | | Branch (115:29): [True: 110k, False: 0] | | | | | | | Branch (115:29): [True: 51.6k, False: 110k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 162k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 109| 162k|#define lua_assert(c) assert(c) | | ------------------ ------------------ 566| 162k| fs->nk++; 567| 162k| luaC_barrier(L, f, v); ------------------ | | 226| 162k|#define luaC_barrier(L,p,v) ( \ | | 227| 162k| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 313| 162k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 162k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 311| 162k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (313:26): [True: 110k, False: 51.6k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 222| 110k|#define luaC_objbarrier(L,p,o) ( \ | | | | 223| 110k| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 91| 110k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 70| 110k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 65| 221k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (65:24): [True: 4.13k, False: 106k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 90| 4.13k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 16.5k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 73, False: 4.05k] | | | | | | | | | Branch (65:26): [True: 0, False: 4.13k] | | | | | | | | | Branch (65:26): [True: 4.13k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 224| 110k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 388| 73|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 73|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 73|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 388| 73|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 292|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 73|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (113:42): [True: 0, False: 73] | | | | | | | | | Branch (113:42): [True: 73, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 141| 110k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 139| 110k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 141| 51.6k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 51.6k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 568| 0| return k; 569| 162k|} lcode.c:const2exp: 692| 1.18M|static void const2exp (TValue *v, expdesc *e) { 693| 1.18M| switch (ttypetag(v)) { ------------------ | | 84| 1.18M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 1.18M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 694| 57.2k| case LUA_VNUMINT: ------------------ | | 336| 57.2k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 57.2k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (694:5): [True: 57.2k, False: 1.12M] ------------------ 695| 57.2k| e->k = VKINT; e->u.ival = ivalue(v); ------------------ | | 346| 57.2k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 57.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 57.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 696| 0| break; 697| 0| case LUA_VNUMFLT: ------------------ | | 337| 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: 1.18M] ------------------ 698| 0| e->k = VKFLT; e->u.nval = fltvalue(v); ------------------ | | 345| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 699| 0| break; 700| 1.03M| case LUA_VFALSE: ------------------ | | 250| 1.03M|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 1.03M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (700:5): [True: 1.03M, False: 153k] ------------------ 701| 1.03M| e->k = VFALSE; 702| 1.03M| break; 703| 691| case LUA_VTRUE: ------------------ | | 251| 691|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 691|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (703:5): [True: 691, False: 1.18M] ------------------ 704| 691| e->k = VTRUE; 705| 691| break; 706| 95.1k| case LUA_VNIL: ------------------ | | 183| 95.1k|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 95.1k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (706:5): [True: 95.1k, False: 1.08M] ------------------ 707| 95.1k| e->k = VNIL; 708| 95.1k| break; 709| 4| case LUA_VSHRSTR: case LUA_VLNGSTR: ------------------ | | 373| 4|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 4|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VSHRSTR: case LUA_VLNGSTR: ------------------ | | 374| 4|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 4|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (709:5): [True: 4, False: 1.18M] | Branch (709:24): [True: 0, False: 1.18M] ------------------ 710| 4| e->k = VKSTR; e->u.strval = tsvalue(v); ------------------ | | 382| 4|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 16|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 4|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 4] | | | | | Branch (113:42): [True: 4, False: 0] | | | | ------------------ | | ------------------ ------------------ 711| 0| break; 712| 0| default: lua_assert(0); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ | Branch (712:5): [True: 0, False: 1.18M] ------------------ 713| 1.18M| } 714| 1.18M|} lcode.c:freereg: 491| 69.6M|static void freereg (FuncState *fs, int reg) { 492| 69.6M| if (reg >= luaY_nvarstack(fs)) { ------------------ | Branch (492:7): [True: 68.8M, False: 786k] ------------------ 493| 68.8M| fs->freereg--; 494| 68.8M| lua_assert(reg == fs->freereg); ------------------ | | 109| 68.8M|#define lua_assert(c) assert(c) ------------------ 495| 68.8M| } 496| 69.6M|} lcode.c:freeregs: 502| 33.9M|static void freeregs (FuncState *fs, int r1, int r2) { 503| 33.9M| if (r1 > r2) { ------------------ | Branch (503:7): [True: 16.2M, False: 17.6M] ------------------ 504| 16.2M| freereg(fs, r1); 505| 16.2M| freereg(fs, r2); 506| 16.2M| } 507| 17.6M| else { 508| 17.6M| freereg(fs, r2); 509| 17.6M| freereg(fs, r1); 510| 17.6M| } 511| 33.9M|} lcode.c:freeexp: 517| 71.1M|static void freeexp (FuncState *fs, expdesc *e) { 518| 71.1M| if (e->k == VNONRELOC) ------------------ | Branch (518:7): [True: 609k, False: 70.4M] ------------------ 519| 609k| freereg(fs, e->u.info); 520| 71.1M|} lcode.c:exp2reg: 914| 70.8M|static void exp2reg (FuncState *fs, expdesc *e, int reg) { 915| 70.8M| discharge2reg(fs, e, reg); 916| 70.8M| if (e->k == VJMP) /* expression itself is a test? */ ------------------ | Branch (916:7): [True: 17.2M, False: 53.5M] ------------------ 917| 17.2M| luaK_concat(fs, &e->t, e->u.info); /* put this jump in 't' list */ 918| 70.8M| if (hasjumps(e)) { ------------------ | | 38| 70.8M|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 17.2M, False: 53.5M] | | ------------------ ------------------ 919| 17.2M| int final; /* position after whole expression */ 920| 17.2M| int p_f = NO_JUMP; /* position of an eventual LOAD false */ ------------------ | | 20| 17.2M|#define NO_JUMP (-1) ------------------ 921| 17.2M| int p_t = NO_JUMP; /* position of an eventual LOAD true */ ------------------ | | 20| 17.2M|#define NO_JUMP (-1) ------------------ 922| 17.2M| if (need_value(fs, e->t) || need_value(fs, e->f)) { ------------------ | Branch (922:9): [True: 17.2M, False: 23.9k] | Branch (922:33): [True: 3.31k, False: 20.6k] ------------------ 923| 17.2M| int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs); ------------------ | | 20| 17.2M|#define NO_JUMP (-1) ------------------ | Branch (923:16): [True: 17.2M, False: 15.9k] ------------------ 924| 17.2M| p_f = code_loadbool(fs, reg, OP_LFALSESKIP); /* skip next inst. */ 925| 17.2M| p_t = code_loadbool(fs, reg, OP_LOADTRUE); 926| | /* jump around these booleans if 'e' is not a test */ 927| 17.2M| luaK_patchtohere(fs, fj); 928| 17.2M| } 929| 17.2M| final = luaK_getlabel(fs); 930| 17.2M| patchlistaux(fs, e->f, final, reg, p_f); 931| 17.2M| patchlistaux(fs, e->t, final, reg, p_t); 932| 17.2M| } 933| 70.8M| e->f = e->t = NO_JUMP; ------------------ | | 20| 70.8M|#define NO_JUMP (-1) ------------------ 934| 70.8M| e->u.info = reg; 935| 70.8M| e->k = VNONRELOC; 936| 70.8M|} lcode.c:discharge2reg: 825| 70.8M|static void discharge2reg (FuncState *fs, expdesc *e, int reg) { 826| 70.8M| luaK_dischargevars(fs, e); 827| 70.8M| switch (e->k) { 828| 110k| case VNIL: { ------------------ | Branch (828:5): [True: 110k, False: 70.7M] ------------------ 829| 110k| luaK_nil(fs, reg, 1); 830| 110k| break; 831| 0| } 832| 1.03M| case VFALSE: { ------------------ | Branch (832:5): [True: 1.03M, False: 69.8M] ------------------ 833| 1.03M| luaK_codeABC(fs, OP_LOADFALSE, reg, 0, 0); ------------------ | | 48| 1.03M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 834| 1.03M| break; 835| 0| } 836| 4.44k| case VTRUE: { ------------------ | Branch (836:5): [True: 4.44k, False: 70.8M] ------------------ 837| 4.44k| luaK_codeABC(fs, OP_LOADTRUE, reg, 0, 0); ------------------ | | 48| 4.44k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 838| 4.44k| break; 839| 0| } 840| 347k| case VKSTR: { ------------------ | Branch (840:5): [True: 347k, False: 70.4M] ------------------ 841| 347k| str2K(fs, e); 842| 347k| } /* FALLTHROUGH */ 843| 8.93M| case VK: { ------------------ | Branch (843:5): [True: 8.58M, False: 62.2M] ------------------ 844| 8.93M| luaK_codek(fs, reg, e->u.info); 845| 8.93M| break; 846| 347k| } 847| 88.1k| case VKFLT: { ------------------ | Branch (847:5): [True: 88.1k, False: 70.7M] ------------------ 848| 88.1k| luaK_float(fs, reg, e->u.nval); 849| 88.1k| break; 850| 347k| } 851| 310k| case VKINT: { ------------------ | Branch (851:5): [True: 310k, False: 70.5M] ------------------ 852| 310k| luaK_int(fs, reg, e->u.ival); 853| 310k| break; 854| 347k| } 855| 42.8M| case VRELOC: { ------------------ | Branch (855:5): [True: 42.8M, False: 28.0M] ------------------ 856| 42.8M| Instruction *pc = &getinstruction(fs, e); ------------------ | | 55| 42.8M|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 857| 42.8M| SETARG_A(*pc, reg); /* instruction will put result in 'reg' */ ------------------ | | 126| 42.8M|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 42.8M|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 42.8M|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 42.8M|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 42.8M| ((cast(Instruction, v)<u.info) ------------------ | Branch (861:11): [True: 18.8k, False: 299k] ------------------ 862| 18.8k| luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0); ------------------ | | 48| 18.8k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 863| 318k| break; 864| 347k| } 865| 17.2M| default: { ------------------ | Branch (865:5): [True: 17.2M, False: 53.6M] ------------------ 866| 17.2M| lua_assert(e->k == VJMP); ------------------ | | 109| 17.2M|#define lua_assert(c) assert(c) ------------------ 867| 17.2M| return; /* nothing to do... */ 868| 17.2M| } 869| 70.8M| } 870| 53.6M| e->u.info = reg; 871| 53.6M| e->k = VNONRELOC; 872| 53.6M|} lcode.c:luaK_float: 680| 88.1k|static void luaK_float (FuncState *fs, int reg, lua_Number f) { 681| 88.1k| lua_Integer fi; 682| 88.1k| if (luaV_flttointeger(f, &fi, F2Ieq) && fitsBx(fi)) ------------------ | Branch (682:7): [True: 36.6k, False: 51.4k] | Branch (682:43): [True: 29.2k, False: 7.46k] ------------------ 683| 29.2k| codeAsBx(fs, OP_LOADF, reg, cast_int(fi)); ------------------ | | 144| 29.2k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 29.2k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 684| 58.9k| else 685| 58.9k| luaK_codek(fs, reg, luaK_numberK(fs, f)); 686| 88.1k|} lcode.c:luaK_numberK: 602| 127k|static int luaK_numberK (FuncState *fs, lua_Number r) { 603| 127k| TValue o; 604| 127k| lua_Integer ik; 605| 127k| setfltvalue(&o, r); ------------------ | | 352| 127k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 127k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 127k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 606| 127k| if (!luaV_flttointeger(r, &ik, F2Ieq)) /* not an integral value? */ ------------------ | Branch (606:7): [True: 72.0k, False: 55.7k] ------------------ 607| 72.0k| return addk(fs, &o, &o); /* use number itself as key */ 608| 55.7k| else { /* must build an alternative key */ 609| 55.7k| const int nbm = l_floatatt(MANT_DIG); ------------------ | | 475| 55.7k|#define l_floatatt(n) (DBL_##n) ------------------ 610| 55.7k| const lua_Number q = l_mathop(ldexp)(l_mathop(1.0), -nbm + 1); ------------------ | | 482| 55.7k|#define l_mathop(op) op ------------------ const lua_Number q = l_mathop(ldexp)(l_mathop(1.0), -nbm + 1); ------------------ | | 482| 55.7k|#define l_mathop(op) op ------------------ 611| 55.7k| const lua_Number k = (ik == 0) ? q : r + r*q; /* new key */ ------------------ | Branch (611:26): [True: 4.87k, False: 50.9k] ------------------ 612| 55.7k| TValue kv; 613| 55.7k| setfltvalue(&kv, k); ------------------ | | 352| 55.7k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 55.7k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 55.7k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 614| | /* result is not an integral value, unless value is too large */ 615| 55.7k| lua_assert(!luaV_flttointeger(k, &ik, F2Ieq) || ------------------ | | 109| 55.7k|#define lua_assert(c) assert(c) ------------------ 616| 55.7k| l_mathop(fabs)(r) >= l_mathop(1e6)); 617| 55.7k| return addk(fs, &kv, &o); 618| 55.7k| } 619| 127k|} lcode.c:need_value: 898| 17.2M|static int need_value (FuncState *fs, int list) { 899| 17.2M| for (; list != NO_JUMP; list = getjump(fs, list)) { ------------------ | | 20| 17.2M|#define NO_JUMP (-1) ------------------ | Branch (899:10): [True: 17.2M, False: 44.5k] ------------------ 900| 17.2M| Instruction i = *getjumpcontrol(fs, list); 901| 17.2M| if (GET_OPCODE(i) != OP_TESTSET) return 1; ------------------ | | 114| 17.2M|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 139| 17.2M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (901:9): [True: 17.2M, False: 24.8k] ------------------ 902| 17.2M| } 903| 44.5k| return 0; /* not found */ 904| 17.2M|} lcode.c:code_loadbool: 888| 34.4M|static int code_loadbool (FuncState *fs, int A, OpCode op) { 889| 34.4M| luaK_getlabel(fs); /* those instructions may be jump targets */ 890| 34.4M| return luaK_codeABC(fs, op, A, 0, 0); ------------------ | | 48| 34.4M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 891| 34.4M|} lcode.c:codeABRK: 1039| 90.2k| expdesc *ec) { 1040| 90.2k| int k = exp2RK(fs, ec); 1041| 90.2k| luaK_codeABCk(fs, o, a, b, ec->u.info, k); 1042| 90.2k|} lcode.c:negatecondition: 1101| 7.25k|static void negatecondition (FuncState *fs, expdesc *e) { 1102| 7.25k| Instruction *pc = getjumpcontrol(fs, e->u.info); 1103| 7.25k| lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET && ------------------ | | 109| 7.25k|#define lua_assert(c) assert(c) ------------------ 1104| 7.25k| GET_OPCODE(*pc) != OP_TEST); 1105| 14.5k| SETARG_k(*pc, (GETARG_k(*pc) ^ 1)); ------------------ | | 138| 7.25k|#define SETARG_k(i,v) setarg(i, v, POS_k, 1) | | ------------------ | | | | 122| 7.25k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 7.25k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 7.25k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 7.25k| ((cast(Instruction, v)<k == VRELOC) { ------------------ | Branch (1116:7): [True: 30.2k, False: 14.3k] ------------------ 1117| 30.2k| Instruction ie = getinstruction(fs, e); ------------------ | | 55| 30.2k|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 1118| 30.2k| if (GET_OPCODE(ie) == OP_NOT) { ------------------ | | 114| 30.2k|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 139| 30.2k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (1118:9): [True: 573, False: 29.7k] ------------------ 1119| 573| removelastinstruction(fs); /* remove previous OP_NOT */ 1120| 573| return condjump(fs, OP_TEST, GETARG_B(ie), 0, 0, !cond); ------------------ | | 128| 573|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 573|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 573|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1121| 573| } 1122| | /* else go through */ 1123| 30.2k| } 1124| 44.1k| discharge2anyreg(fs, e); 1125| 44.1k| freeexp(fs, e); 1126| 44.1k| return condjump(fs, OP_TESTSET, NO_REG, e->u.info, 0, cond); ------------------ | | 182| 44.1k|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 44.1k|#define MAXARG_A ((1<pc--; 375| 573|} lcode.c:condjump: 222| 17.3M|static int condjump (FuncState *fs, OpCode op, int A, int B, int C, int k) { 223| 17.3M| luaK_codeABCk(fs, op, A, B, C, k); 224| 17.3M| return luaK_jump(fs); 225| 17.3M|} lcode.c:discharge2anyreg: 880| 47.1k|static void discharge2anyreg (FuncState *fs, expdesc *e) { 881| 47.1k| if (e->k != VNONRELOC) { /* no fixed register yet? */ ------------------ | Branch (881:7): [True: 34.8k, False: 12.2k] ------------------ 882| 34.8k| luaK_reserveregs(fs, 1); /* get a register */ 883| 34.8k| discharge2reg(fs, e, fs->freereg-1); /* put value there */ 884| 34.8k| } 885| 47.1k|} lcode.c:str2K: 737| 26.4M|static void str2K (FuncState *fs, expdesc *e) { 738| 26.4M| lua_assert(e->k == VKSTR); ------------------ | | 109| 26.4M|#define lua_assert(c) assert(c) ------------------ 739| 26.4M| e->u.info = stringK(fs, e->u.strval); 740| 26.4M| e->k = VK; 741| 26.4M|} lcode.c:stringK: 575| 26.4M|static int stringK (FuncState *fs, TString *s) { 576| 26.4M| TValue o; 577| 26.4M| setsvalue(fs->ls->L, &o, s); ------------------ | | 385| 26.4M| { TValue *io = (obj); TString *x_ = (x); \ | | 386| 26.4M| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 26.4M|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 388| 26.4M|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 26.4M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 26.4M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 26.4M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 387| 26.4M| checkliveness(L,io); } | | ------------------ | | | | 107| 26.4M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 422M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 26.4M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 26.4M] | | | | | | | Branch (115:29): [True: 26.4M, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 26.4M] | | | | | | | Branch (115:29): [True: 26.4M, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 26.4M] | | | | | | | Branch (115:29): [True: 26.4M, False: 0] | | | | | | | Branch (115:29): [True: 26.4M, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 26.4M] | | | | | | ------------------ | | | | ------------------ | | | | 108| 26.4M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 578| 26.4M| return addk(fs, &o, &o); /* use string itself as key */ 579| 26.4M|} lcode.c:isKstr: 1220| 51.0M|static int isKstr (FuncState *fs, expdesc *e) { 1221| 51.0M| return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B && ------------------ | | 38| 102M|#define hasjumps(e) ((e)->t != (e)->f) ------------------ return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B && ------------------ | | 96| 102M|#define MAXARG_B ((1<f->k[e->u.info])); ------------------ | | 377| 33.8M|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | ------------------ | | | | 91| 33.8M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 33.8M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 33.8M, False: 18.7k] | | | | ------------------ | | ------------------ ------------------ 1223| 51.0M|} lcode.c:isCint: 1237| 8.61M|static int isCint (expdesc *e) { 1238| 8.61M| return isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C)); ------------------ | | 155| 861|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ return isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C)); ------------------ | | 155| 861|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (1238:10): [True: 861, False: 8.61M] | Branch (1238:23): [True: 812, False: 49] ------------------ 1239| 8.61M|} lcode.c:isKint: 1228| 9.16M|static int isKint (expdesc *e) { 1229| 9.16M| return (e->k == VKINT && !hasjumps(e)); ------------------ | | 38| 143k|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (1229:11): [True: 143k, False: 9.01M] | Branch (1229:28): [True: 143k, False: 258] ------------------ 1230| 9.16M|} lcode.c:constfolding: 1335| 8.41M| const expdesc *e2) { 1336| 8.41M| TValue v1, v2, res; 1337| 8.41M| if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2)) ------------------ | Branch (1337:7): [True: 7.86M, False: 549k] | Branch (1337:30): [True: 178k, False: 370k] | Branch (1337:53): [True: 15.3k, False: 355k] ------------------ 1338| 8.05M| return 0; /* non-numeric operands or not safe to fold */ 1339| 355k| luaO_rawarith(fs->ls->L, op, &v1, &v2, &res); /* does operation */ 1340| 355k| if (ttisinteger(&res)) { ------------------ | | 341| 355k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 355k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 355k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 115k, False: 239k] | | | | ------------------ | | ------------------ ------------------ 1341| 115k| e1->k = VKINT; 1342| 115k| e1->u.ival = ivalue(&res); ------------------ | | 346| 115k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 115k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 115k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1343| 115k| } 1344| 239k| else { /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */ 1345| 239k| lua_Number n = fltvalue(&res); ------------------ | | 345| 239k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 113| 239k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 239k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1346| 239k| if (luai_numisnan(n) || n == 0) ------------------ | | 358| 478k|#define luai_numisnan(a) (!luai_numeq((a), (a))) | | ------------------ | | | | 353| 239k|#define luai_numeq(a,b) ((a)==(b)) | | ------------------ | | | Branch (358:33): [True: 536, False: 238k] | | ------------------ ------------------ | Branch (1346:29): [True: 100k, False: 138k] ------------------ 1347| 100k| return 0; 1348| 138k| e1->k = VKFLT; 1349| 138k| e1->u.nval = n; 1350| 138k| } 1351| 254k| return 1; 1352| 355k|} lcode.c:validop: 1315| 370k|static int validop (int op, TValue *v1, TValue *v2) { 1316| 370k| switch (op) { 1317| 5.36k| case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 222| 480|#define LUA_OPBAND 7 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 223| 516|#define LUA_OPBOR 8 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 224| 5.36k|#define LUA_OPBXOR 9 ------------------ | Branch (1317:5): [True: 480, False: 370k] | Branch (1317:22): [True: 36, False: 370k] | Branch (1317:38): [True: 4.84k, False: 365k] ------------------ 1318| 83.3k| case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ ------------------ | | 225| 11.1k|#define LUA_OPSHL 10 ------------------ case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ ------------------ | | 226| 12.1k|#define LUA_OPSHR 11 ------------------ case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ ------------------ | | 228| 83.3k|#define LUA_OPBNOT 13 ------------------ | Branch (1318:5): [True: 5.74k, False: 365k] | Branch (1318:21): [True: 1.07k, False: 369k] | Branch (1318:37): [True: 71.1k, False: 299k] ------------------ 1319| 83.3k| lua_Integer i; 1320| 83.3k| return (luaV_tointegerns(v1, &i, LUA_FLOORN2I) && ------------------ | | 36| 83.3k|#define LUA_FLOORN2I F2Ieq ------------------ | Branch (1320:15): [True: 69.8k, False: 13.4k] ------------------ 1321| 83.3k| luaV_tointegerns(v2, &i, LUA_FLOORN2I)); ------------------ | | 36| 69.8k|#define LUA_FLOORN2I F2Ieq ------------------ | Branch (1321:15): [True: 68.0k, False: 1.80k] ------------------ 1322| 12.1k| } 1323| 36.9k| case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ ------------------ | | 220| 12.9k|#define LUA_OPDIV 5 ------------------ case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ ------------------ | | 221| 16.9k|#define LUA_OPIDIV 6 ------------------ case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ ------------------ | | 218| 36.9k|#define LUA_OPMOD 3 ------------------ | Branch (1323:5): [True: 12.9k, False: 357k] | Branch (1323:21): [True: 3.95k, False: 366k] | Branch (1323:38): [True: 19.9k, False: 350k] ------------------ 1324| 36.9k| return (nvalue(v2) != 0); ------------------ | | 343| 36.9k|#define nvalue(o) check_exp(ttisnumber(o), \ | | ------------------ | | | | 113| 258k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 36.9k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 24.3k] | | | | | Branch (113:42): [True: 24.3k, False: 0] | | | | | Branch (113:42): [True: 0, False: 12.5k] | | | | | Branch (113:42): [True: 12.5k, False: 0] | | | | | Branch (113:42): [True: 24.3k, False: 12.5k] | | | | ------------------ | | ------------------ | | 344| 36.9k| (ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o))) ------------------ 1325| 250k| default: return 1; /* everything else is valid */ ------------------ | Branch (1325:5): [True: 250k, False: 120k] ------------------ 1326| 370k| } 1327| 370k|} lcode.c:codeunexpval: 1389| 114k|static void codeunexpval (FuncState *fs, OpCode op, expdesc *e, int line) { 1390| 114k| int r = luaK_exp2anyreg(fs, e); /* opcodes operate only on registers */ 1391| 114k| freeexp(fs, e); 1392| 114k| e->u.info = luaK_codeABC(fs, op, 0, r, 0); /* generate opcode */ ------------------ | | 48| 114k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1393| 114k| e->k = VRELOC; /* all those operations are relocatable */ 1394| 114k| luaK_fixline(fs, line); 1395| 114k|} lcode.c:unopr2op: 1369| 114k|l_sinline OpCode unopr2op (UnOpr opr) { 1370| 114k| return cast(OpCode, (cast_int(opr) - cast_int(OPR_MINUS)) + ------------------ | | 139| 114k|#define cast(t, exp) ((t)(exp)) ------------------ 1371| 114k| cast_int(OP_UNM)); 1372| 114k|} lcode.c:codenot: 1186| 3.66k|static void codenot (FuncState *fs, expdesc *e) { 1187| 3.66k| switch (e->k) { 1188| 2| case VNIL: case VFALSE: { ------------------ | Branch (1188:5): [True: 0, False: 3.66k] | Branch (1188:16): [True: 2, False: 3.66k] ------------------ 1189| 2| e->k = VTRUE; /* true == not nil == not false */ 1190| 2| break; 1191| 0| } 1192| 52| case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: { ------------------ | Branch (1192:5): [True: 0, False: 3.66k] | Branch (1192:14): [True: 0, False: 3.66k] | Branch (1192:26): [True: 35, False: 3.63k] | Branch (1192:38): [True: 0, False: 3.66k] | Branch (1192:50): [True: 17, False: 3.65k] ------------------ 1193| 52| e->k = VFALSE; /* false == not "x" == not 0.5 == not 1 == not true */ 1194| 52| break; 1195| 35| } 1196| 600| case VJMP: { ------------------ | Branch (1196:5): [True: 600, False: 3.06k] ------------------ 1197| 600| negatecondition(fs, e); 1198| 600| break; 1199| 35| } 1200| 1.12k| case VRELOC: ------------------ | Branch (1200:5): [True: 1.12k, False: 2.54k] ------------------ 1201| 3.01k| case VNONRELOC: { ------------------ | Branch (1201:5): [True: 1.89k, False: 1.77k] ------------------ 1202| 3.01k| discharge2anyreg(fs, e); 1203| 3.01k| freeexp(fs, e); 1204| 3.01k| e->u.info = luaK_codeABC(fs, OP_NOT, 0, e->u.info, 0); ------------------ | | 48| 3.01k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1205| 3.01k| e->k = VRELOC; 1206| 3.01k| break; 1207| 1.12k| } 1208| 0| default: lua_assert(0); /* cannot happen */ ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ | Branch (1208:5): [True: 0, False: 3.66k] ------------------ 1209| 3.66k| } 1210| | /* interchange true and false lists */ 1211| 3.66k| { int temp = e->f; e->f = e->t; e->t = temp; } 1212| 3.66k| removevalues(fs, e->f); /* values are useless when negated */ 1213| 3.66k| removevalues(fs, e->t); 1214| 3.66k|} lcode.c:removevalues: 277| 7.33k|static void removevalues (FuncState *fs, int list) { 278| 11.3k| for (; list != NO_JUMP; list = getjump(fs, list)) ------------------ | | 20| 11.3k|#define NO_JUMP (-1) ------------------ | Branch (278:10): [True: 3.96k, False: 7.33k] ------------------ 279| 3.96k| patchtestreg(fs, list, NO_REG); ------------------ | | 182| 3.96k|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 3.96k|#define MAXARG_A ((1<t != (e)->f) ------------------ | Branch (999:7): [True: 377k, False: 6.37k] ------------------ 1000| 377k| int info; 1001| 377k| switch (e->k) { /* move constants to 'k' */ 1002| 988| case VTRUE: info = boolT(fs); break; ------------------ | Branch (1002:7): [True: 988, False: 376k] ------------------ 1003| 10| case VFALSE: info = boolF(fs); break; ------------------ | Branch (1003:7): [True: 10, False: 377k] ------------------ 1004| 413| case VNIL: info = nilK(fs); break; ------------------ | Branch (1004:7): [True: 413, False: 376k] ------------------ 1005| 213k| case VKINT: info = luaK_intK(fs, e->u.ival); break; ------------------ | Branch (1005:7): [True: 213k, False: 164k] ------------------ 1006| 68.9k| case VKFLT: info = luaK_numberK(fs, e->u.nval); break; ------------------ | Branch (1006:7): [True: 68.9k, False: 308k] ------------------ 1007| 3.01k| case VKSTR: info = stringK(fs, e->u.strval); break; ------------------ | Branch (1007:7): [True: 3.01k, False: 374k] ------------------ 1008| 37| case VK: info = e->u.info; break; ------------------ | Branch (1008:7): [True: 37, False: 377k] ------------------ 1009| 90.6k| default: return 0; /* not a constant */ ------------------ | Branch (1009:7): [True: 90.6k, False: 286k] ------------------ 1010| 377k| } 1011| 286k| if (info <= MAXINDEXRK) { /* does constant fit in 'argC'? */ ------------------ | | 175| 286k|#define MAXINDEXRK MAXARG_B | | ------------------ | | | | 96| 286k|#define MAXARG_B ((1<k = VK; /* make expression a 'K' expression */ 1013| 236k| e->u.info = info; 1014| 236k| return 1; 1015| 236k| } 1016| 286k| } 1017| | /* else, expression doesn't fit; leave it unchanged */ 1018| 56.1k| return 0; 1019| 383k|} lcode.c:boolT: 635| 988|static int boolT (FuncState *fs) { 636| 988| TValue o; 637| 988| setbtvalue(&o); ------------------ | | 264| 988|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 988|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 638| 988| return addk(fs, &o, &o); /* use boolean itself as key */ 639| 988|} lcode.c:boolF: 625| 10|static int boolF (FuncState *fs) { 626| 10| TValue o; 627| 10| setbfvalue(&o); ------------------ | | 263| 10|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 10|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 628| 10| return addk(fs, &o, &o); /* use boolean itself as key */ 629| 10|} lcode.c:nilK: 645| 413|static int nilK (FuncState *fs) { 646| 413| TValue k, v; 647| 413| setnilvalue(&v); ------------------ | | 211| 413|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 413|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 648| | /* cannot use nil as key; instead use table itself to represent nil */ 649| 413| sethvalue(fs->ls->L, &k, fs->ls->h); ------------------ | | 724| 413| { TValue *io = (obj); Table *x_ = (x); \ | | 725| 413| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 413|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 388| 413|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 413|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 413|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 413|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 726| 413| checkliveness(L,io); } | | ------------------ | | | | 107| 413| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 6.60k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 413|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 413] | | | | | | | Branch (115:29): [True: 413, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 413] | | | | | | | Branch (115:29): [True: 413, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 413] | | | | | | | Branch (115:29): [True: 413, False: 0] | | | | | | | Branch (115:29): [True: 413, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 413] | | | | | | ------------------ | | | | ------------------ | | | | 108| 413| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 650| 413| return addk(fs, &k, &v); 651| 413|} lcode.c:isSCnumber: 1255| 51.7M|static int isSCnumber (expdesc *e, int *pi, int *isfloat) { 1256| 51.7M| lua_Integer i; 1257| 51.7M| if (e->k == VKINT) ------------------ | Branch (1257:7): [True: 388k, False: 51.3M] ------------------ 1258| 388k| i = e->u.ival; 1259| 51.3M| else if (e->k == VKFLT && luaV_flttointeger(e->u.nval, &i, F2Ieq)) ------------------ | Branch (1259:12): [True: 16.4k, False: 51.3M] | Branch (1259:29): [True: 5.63k, False: 10.7k] ------------------ 1260| 5.63k| *isfloat = 1; 1261| 51.3M| else 1262| 51.3M| return 0; /* not a number */ 1263| 393k| if (!hasjumps(e) && fitsC(i)) { ------------------ | | 38| 787k|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (1263:7): [True: 387k, False: 6.09k] | Branch (1263:23): [True: 376k, False: 11.1k] ------------------ 1264| 376k| *pi = int2sC(cast_int(i)); ------------------ | | 100| 376k|#define int2sC(i) ((i) + OFFSET_sC) | | ------------------ | | | | 98| 376k|#define OFFSET_sC (MAXARG_C >> 1) | | | | ------------------ | | | | | | 97| 376k|#define MAXARG_C ((1<> 1) | | ------------------ | | | | 97| 584k|#define MAXARG_C ((1<>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 139| 59.7k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (1685:7): [True: 30.5k, False: 29.2k] ------------------ 1686| 30.5k| int n = GETARG_B(*ie2); /* # of elements concatenated in 'e2' */ ------------------ | | 128| 30.5k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 30.5k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 30.5k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1687| 30.5k| lua_assert(e1->u.info + 1 == GETARG_A(*ie2)); ------------------ | | 109| 30.5k|#define lua_assert(c) assert(c) ------------------ 1688| 30.5k| freeexp(fs, e2); 1689| 30.5k| SETARG_A(*ie2, e1->u.info); /* correct first element ('e1') */ ------------------ | | 126| 30.5k|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 30.5k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 30.5k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 30.5k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 30.5k| ((cast(Instruction, v)<u.info, 2, 0); /* new concat opcode */ ------------------ | | 48| 29.2k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1694| 29.2k| freeexp(fs, e2); 1695| 29.2k| luaK_fixline(fs, line); 1696| 29.2k| } 1697| 59.7k|} lcode.c:codecommutative: 1515| 60.2k| expdesc *e1, expdesc *e2, int line) { 1516| 60.2k| int flip = 0; 1517| 60.2k| if (tonumeral(e1, NULL)) { /* is first operand a numeric constant? */ ------------------ | Branch (1517:7): [True: 8.18k, False: 52.0k] ------------------ 1518| 8.18k| swapexps(e1, e2); /* change order */ 1519| 8.18k| flip = 1; 1520| 8.18k| } 1521| 60.2k| if (op == OPR_ADD && isSCint(e2)) /* immediate operand? */ ------------------ | Branch (1521:7): [True: 7.61k, False: 52.6k] | Branch (1521:24): [True: 531, False: 7.08k] ------------------ 1522| 531| codebini(fs, OP_ADDI, e1, e2, flip, line, TM_ADD); 1523| 59.6k| else 1524| 59.6k| codearith(fs, op, e1, e2, flip, line); 1525| 60.2k|} lcode.c:finishbinexpneg: 1462| 167k| OpCode op, int line, TMS event) { 1463| 167k| if (!isKint(e2)) ------------------ | Branch (1463:7): [True: 112k, False: 54.5k] ------------------ 1464| 112k| return 0; /* not an integer constant */ 1465| 54.5k| else { 1466| 54.5k| lua_Integer i2 = e2->u.ival; 1467| 54.5k| if (!(fitsC(i2) && fitsC(-i2))) ------------------ | Branch (1467:11): [True: 54.0k, False: 475] | Branch (1467:24): [True: 54.0k, False: 0] ------------------ 1468| 475| return 0; /* not in the proper range */ 1469| 54.0k| else { /* operating a small integer constant */ 1470| 54.0k| int v2 = cast_int(i2); ------------------ | | 144| 54.0k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 54.0k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1471| 54.0k| finishbinexpval(fs, e1, e2, op, int2sC(-v2), 0, line, OP_MMBINI, event); ------------------ | | 100| 54.0k|#define int2sC(i) ((i) + OFFSET_sC) | | ------------------ | | | | 98| 54.0k|#define OFFSET_sC (MAXARG_C >> 1) | | | | ------------------ | | | | | | 97| 54.0k|#define MAXARG_C ((1<f->code[fs->pc - 1], int2sC(v2)); ------------------ | | 130| 54.0k|#define SETARG_B(i,v) setarg(i, v, POS_B, SIZE_B) | | ------------------ | | | | 122| 54.0k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 54.0k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 54.0k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 54.0k| ((cast(Instruction, v)<u.info = pc; 1411| 8.05M| e1->k = VRELOC; /* all those operations are relocatable */ 1412| 8.05M| luaK_fixline(fs, line); 1413| 8.05M| luaK_codeABCk(fs, mmop, v1, v2, event, flip); /* to call metamethod */ 1414| 8.05M| luaK_fixline(fs, line); 1415| 8.05M|} lcode.c:freeexps: 527| 25.3M|static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) { 528| 25.3M| int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1; ------------------ | Branch (528:12): [True: 24.9M, False: 340k] ------------------ 529| 25.3M| int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1; ------------------ | Branch (529:12): [True: 24.9M, False: 390k] ------------------ 530| 25.3M| freeregs(fs, r1, r2); 531| 25.3M|} lcode.c:codearith: 1501| 7.47M| expdesc *e1, expdesc *e2, int flip, int line) { 1502| 7.47M| if (tonumeral(e2, NULL) && luaK_exp2K(fs, e2)) /* K operand? */ ------------------ | Branch (1502:7): [True: 222k, False: 7.25M] | Branch (1502:30): [True: 179k, False: 42.6k] ------------------ 1503| 179k| codebinK(fs, opr, e1, e2, flip, line); 1504| 7.29M| else /* 'e2' is neither an immediate nor a K operand */ 1505| 7.29M| codebinNoK(fs, opr, e1, e2, flip, line); 1506| 7.47M|} lcode.c:codebinK: 1450| 219k| expdesc *e1, expdesc *e2, int flip, int line) { 1451| 219k| TMS event = binopr2TM(opr); 1452| 219k| int v2 = e2->u.info; /* K index */ 1453| 219k| OpCode op = binopr2op(opr, OPR_ADD, OP_ADDK); 1454| 219k| finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINK, event); 1455| 219k|} lcode.c:binopr2TM: 1378| 7.91M|l_sinline TMS binopr2TM (BinOpr opr) { 1379| 7.91M| lua_assert(OPR_ADD <= opr && opr <= OPR_SHR); ------------------ | | 109| 7.91M|#define lua_assert(c) assert(c) ------------------ 1380| 7.91M| return cast(TMS, (cast_int(opr) - cast_int(OPR_ADD)) + cast_int(TM_ADD)); ------------------ | | 139| 7.91M|#define cast(t, exp) ((t)(exp)) ------------------ 1381| 7.91M|} lcode.c:binopr2op: 1358| 25.1M|l_sinline OpCode binopr2op (BinOpr opr, BinOpr baser, OpCode base) { 1359| 25.1M| lua_assert(baser <= opr && ------------------ | | 109| 25.1M|#define lua_assert(c) assert(c) ------------------ 1360| 25.1M| ((baser == OPR_ADD && opr <= OPR_SHR) || 1361| 25.1M| (baser == OPR_LT && opr <= OPR_LE))); 1362| 25.1M| return cast(OpCode, (cast_int(opr) - cast_int(baser)) + cast_int(base)); ------------------ | | 139| 25.1M|#define cast(t, exp) ((t)(exp)) ------------------ 1363| 25.1M|} lcode.c:codebinNoK: 1489| 7.41M| expdesc *e1, expdesc *e2, int flip, int line) { 1490| 7.41M| if (flip) ------------------ | Branch (1490:7): [True: 4.59k, False: 7.40M] ------------------ 1491| 4.59k| swapexps(e1, e2); /* back to original order */ 1492| 7.41M| codebinexpval(fs, opr, e1, e2, line); /* use standard operators */ 1493| 7.41M|} lcode.c:codebitwise: 1533| 159k| expdesc *e1, expdesc *e2, int line) { 1534| 159k| int flip = 0; 1535| 159k| if (e1->k == VKINT) { ------------------ | Branch (1535:7): [True: 13.2k, False: 146k] ------------------ 1536| 13.2k| swapexps(e1, e2); /* 'e2' will be the constant operand */ 1537| 13.2k| flip = 1; 1538| 13.2k| } 1539| 159k| if (e2->k == VKINT && luaK_exp2K(fs, e2)) /* K operand? */ ------------------ | Branch (1539:7): [True: 46.7k, False: 112k] | Branch (1539:25): [True: 40.2k, False: 6.44k] ------------------ 1540| 40.2k| codebinK(fs, opr, e1, e2, flip, line); 1541| 119k| else /* no constants */ 1542| 119k| codebinNoK(fs, opr, e1, e2, flip, line); 1543| 159k|} lcode.c:isSCint: 1246| 375k|static int isSCint (expdesc *e) { 1247| 375k| return isKint(e) && fitsC(e->u.ival); ------------------ | Branch (1247:10): [True: 88.3k, False: 287k] | Branch (1247:23): [True: 84.5k, False: 3.72k] ------------------ 1248| 375k|} lcode.c:swapexps: 1480| 16.0M|static void swapexps (expdesc *e1, expdesc *e2) { 1481| 16.0M| expdesc temp = *e1; *e1 = *e2; *e2 = temp; /* swap 'e1' and 'e2' */ 1482| 16.0M|} lcode.c:codebini: 1439| 84.5k| TMS event) { 1440| 84.5k| int v2 = int2sC(cast_int(e2->u.ival)); /* immediate operand */ ------------------ | | 100| 84.5k|#define int2sC(i) ((i) + OFFSET_sC) | | ------------------ | | | | 98| 84.5k|#define OFFSET_sC (MAXARG_C >> 1) | | | | ------------------ | | | | | | 97| 84.5k|#define MAXARG_C ((1<k == VKINT); ------------------ | | 109| 84.5k|#define lua_assert(c) assert(c) ------------------ 1442| 84.5k| finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINI, event); 1443| 84.5k|} lcode.c:codebinexpval: 1423| 7.69M| expdesc *e1, expdesc *e2, int line) { 1424| 7.69M| OpCode op = binopr2op(opr, OPR_ADD, OP_ADD); 1425| 7.69M| 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| 7.69M| lua_assert((VNIL <= e1->k && e1->k <= VKSTR) || ------------------ | | 109| 7.69M|#define lua_assert(c) assert(c) ------------------ 1428| 7.69M| e1->k == VNONRELOC || e1->k == VRELOC); 1429| 7.69M| lua_assert(OP_ADD <= op && op <= OP_SHR); ------------------ | | 109| 7.69M|#define lua_assert(c) assert(c) ------------------ 1430| 7.69M| finishbinexpval(fs, e1, e2, op, v2, 0, line, OP_MMBIN, binopr2TM(opr)); 1431| 7.69M|} lcode.c:codeeq: 1582| 15.5k|static void codeeq (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) { 1583| 15.5k| int r1, r2; 1584| 15.5k| int im; 1585| 15.5k| int isfloat = 0; /* not needed here, but kept for symmetry */ 1586| 15.5k| OpCode op; 1587| 15.5k| if (e1->k != VNONRELOC) { ------------------ | Branch (1587:7): [True: 3.34k, False: 12.1k] ------------------ 1588| 3.34k| lua_assert(e1->k == VK || e1->k == VKINT || e1->k == VKFLT); ------------------ | | 109| 3.34k|#define lua_assert(c) assert(c) ------------------ 1589| 3.34k| swapexps(e1, e2); 1590| 3.34k| } 1591| 15.5k| r1 = luaK_exp2anyreg(fs, e1); /* 1st expression must be in register */ 1592| 15.5k| if (isSCnumber(e2, &im, &isfloat)) { ------------------ | Branch (1592:7): [True: 3.57k, False: 11.9k] ------------------ 1593| 3.57k| op = OP_EQI; 1594| 3.57k| r2 = im; /* immediate operand */ 1595| 3.57k| } 1596| 11.9k| else if (exp2RK(fs, e2)) { /* 2nd expression is constant? */ ------------------ | Branch (1596:12): [True: 2.92k, False: 9.00k] ------------------ 1597| 2.92k| op = OP_EQK; 1598| 2.92k| r2 = e2->u.info; /* constant index */ 1599| 2.92k| } 1600| 9.00k| else { 1601| 9.00k| op = OP_EQ; /* will compare two registers */ 1602| 9.00k| r2 = luaK_exp2anyreg(fs, e2); 1603| 9.00k| } 1604| 15.5k| freeexps(fs, e1, e2); 1605| 15.5k| e1->u.info = condjump(fs, op, r1, r2, isfloat, (opr == OPR_EQ)); 1606| 15.5k| e1->k = VJMP; 1607| 15.5k|} lcode.c:codeorder: 1550| 17.2M|static void codeorder (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) { 1551| 17.2M| int r1, r2; 1552| 17.2M| int im; 1553| 17.2M| int isfloat = 0; 1554| 17.2M| OpCode op; 1555| 17.2M| if (isSCnumber(e2, &im, &isfloat)) { ------------------ | Branch (1555:7): [True: 25.4k, False: 17.2M] ------------------ 1556| | /* use immediate operand */ 1557| 25.4k| r1 = luaK_exp2anyreg(fs, e1); 1558| 25.4k| r2 = im; 1559| 25.4k| op = binopr2op(opr, OPR_LT, OP_LTI); 1560| 25.4k| } 1561| 17.2M| else if (isSCnumber(e1, &im, &isfloat)) { ------------------ | Branch (1561:12): [True: 340k, False: 16.8M] ------------------ 1562| | /* transform (A < B) to (B > A) and (A <= B) to (B >= A) */ 1563| 340k| r1 = luaK_exp2anyreg(fs, e2); 1564| 340k| r2 = im; 1565| 340k| op = binopr2op(opr, OPR_LT, OP_GTI); 1566| 340k| } 1567| 16.8M| else { /* regular case, compare two registers */ 1568| 16.8M| r1 = luaK_exp2anyreg(fs, e1); 1569| 16.8M| r2 = luaK_exp2anyreg(fs, e2); 1570| 16.8M| op = binopr2op(opr, OPR_LT, OP_LT); 1571| 16.8M| } 1572| 17.2M| freeexps(fs, e1, e2); 1573| 17.2M| e1->u.info = condjump(fs, op, r1, r2, isfloat, 1); 1574| 17.2M| e1->k = VJMP; 1575| 17.2M|} lcode.c:removelastlineinfo: 353| 16.6M|static void removelastlineinfo (FuncState *fs) { 354| 16.6M| Proto *f = fs->f; 355| 16.6M| int pc = fs->pc - 1; /* last instruction coded */ 356| 16.6M| if (f->lineinfo[pc] != ABSLINEINFO) { /* relative line info? */ ------------------ | | 27| 16.6M|#define ABSLINEINFO (-0x80) ------------------ | Branch (356:7): [True: 16.4M, False: 128k] ------------------ 357| 16.4M| fs->previousline -= f->lineinfo[pc]; /* correct last line saved */ 358| 16.4M| fs->iwthabs--; /* undo previous increment */ 359| 16.4M| } 360| 128k| else { /* absolute line information */ 361| 128k| lua_assert(f->abslineinfo[fs->nabslineinfo - 1].pc == pc); ------------------ | | 109| 128k|#define lua_assert(c) assert(c) ------------------ 362| 128k| fs->nabslineinfo--; /* remove it */ 363| 128k| fs->iwthabs = MAXIWTHABS + 1; /* force next line info to be absolute */ ------------------ | | 35| 128k|#define MAXIWTHABS 128 ------------------ 364| 128k| } 365| 16.6M|} lcode.c:codeextraarg: 440| 31.0k|static int codeextraarg (FuncState *fs, int a) { 441| 31.0k| lua_assert(a <= MAXARG_Ax); ------------------ | | 109| 31.0k|#define lua_assert(c) assert(c) ------------------ 442| 31.0k| return luaK_code(fs, CREATE_Ax(OP_EXTRAARG, a)); ------------------ | | 166| 31.0k|#define CREATE_Ax(o,a) ((cast(Instruction, o)<>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 139| 20.1M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (1831:9): [True: 10.0M, False: 10.0M] ------------------ 1832| 10.0M| break; 1833| 10.0M| else 1834| 10.0M| i += GETARG_sJ(pc) + 1; ------------------ | | 151| 10.0M| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | ------------------ | | | | 113| 10.0M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 10.0M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1835| 20.1M| } 1836| 10.0M| return i; 1837| 10.0M|} luaG_getfuncline: 83| 354|int luaG_getfuncline (const Proto *f, int pc) { 84| 354| if (f->lineinfo == NULL) /* no debug information? */ ------------------ | Branch (84:7): [True: 0, False: 354] ------------------ 85| 0| return -1; 86| 354| else { 87| 354| int basepc; 88| 354| int baseline = getbaseline(f, pc, &basepc); 89| 15.3k| while (basepc++ < pc) { /* walk until given instruction */ ------------------ | Branch (89:12): [True: 14.9k, False: 354] ------------------ 90| 14.9k| lua_assert(f->lineinfo[basepc] != ABSLINEINFO); ------------------ | | 109| 14.9k|#define lua_assert(c) assert(c) ------------------ 91| 14.9k| baseline += f->lineinfo[basepc]; /* correct line */ 92| 14.9k| } 93| 354| return baseline; 94| 354| } 95| 354|} lua_getstack: 160| 845|LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) { 161| 845| int status; 162| 845| CallInfo *ci; 163| 845| if (level < 0) return 0; /* invalid (negative) level */ ------------------ | Branch (163:7): [True: 0, False: 845] ------------------ 164| 845| lua_lock(L); ------------------ | | 267| 845|#define lua_lock(L) ((void) 0) ------------------ 165| 25.3k| for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous) ------------------ | Branch (165:20): [True: 24.4k, False: 839] | Branch (165:33): [True: 24.4k, False: 6] ------------------ 166| 24.4k| level--; 167| 845| if (level == 0 && ci != &L->base_ci) { /* level found? */ ------------------ | Branch (167:7): [True: 839, False: 6] | Branch (167:21): [True: 533, False: 306] ------------------ 168| 533| status = 1; 169| 533| ar->i_ci = ci; 170| 533| } 171| 312| else status = 0; /* no such level */ 172| 845| lua_unlock(L); ------------------ | | 268| 845|#define lua_unlock(L) ((void) 0) ------------------ 173| 845| return status; 174| 845|} lua_getinfo: 383| 402|LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) { 384| 402| int status; 385| 402| Closure *cl; 386| 402| CallInfo *ci; 387| 402| TValue *func; 388| 402| lua_lock(L); ------------------ | | 267| 402|#define lua_lock(L) ((void) 0) ------------------ 389| 402| if (*what == '>') { ------------------ | Branch (389:7): [True: 0, False: 402] ------------------ 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"); ------------------ | | 129| 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| 402| else { 397| 402| ci = ar->i_ci; 398| 402| func = s2v(ci->func.p); ------------------ | | 172| 402|#define s2v(o) (&(o)->val) ------------------ 399| 402| lua_assert(ttisfunction(func)); ------------------ | | 109| 402|#define lua_assert(c) assert(c) ------------------ 400| 402| } 401| 402| cl = ttisclosure(func) ? clvalue(func) : NULL; ------------------ | | 635| 402|#define ttisclosure(o) (ttisLclosure(o) || ttisCclosure(o)) | | ------------------ | | | | 632| 402|#define ttisLclosure(o) checktag((o), ctb(LUA_VLCL)) | | | | ------------------ | | | | | | 91| 804|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 402|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 402, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define ttisclosure(o) (ttisLclosure(o) || ttisCclosure(o)) | | ------------------ | | | | 634| 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; ------------------ | | 640| 402|#define clvalue(o) check_exp(ttisclosure(o), gco2cl(val_(o).gc)) | | ------------------ | | | | 113| 1.60k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 402|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 402] | | | | | Branch (113:42): [True: 402, False: 0] | | | | ------------------ | | ------------------ ------------------ 402| 0| status = auxgetinfo(L, what, ar, cl, ci); 403| 402| if (strchr(what, 'f')) { ------------------ | Branch (403:7): [True: 201, False: 201] ------------------ 404| 201| setobj2s(L, L->top.p, func); ------------------ | | 131| 201|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 201| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 201| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 201|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 201| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 201| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 3.21k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 201|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 201] | | | | | | | | | Branch (115:29): [True: 201, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 201] | | | | | | | | | Branch (115:29): [True: 201, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 201] | | | | | | | | | Branch (115:29): [True: 201, False: 0] | | | | | | | | | Branch (115:29): [True: 201, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 201] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 201| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 201|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 405| 201| api_incr_top(L); ------------------ | | 17| 201| (L->top.p++, api_check(L, L->top.p <= L->ci->top.p, "stack overflow")) | | ------------------ | | | | 129| 201|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 201|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ ------------------ 406| 201| } 407| 402| if (strchr(what, 'L')) ------------------ | Branch (407:7): [True: 0, False: 402] ------------------ 408| 0| collectvalidlines(L, cl); 409| 402| lua_unlock(L); ------------------ | | 268| 402|#define lua_unlock(L) ((void) 0) ------------------ 410| 402| return status; 411| 402|} luaG_typeerror: 751| 131|l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) { 752| 131| typeerror(L, o, op, varinfo(L, o)); 753| 131|} luaG_callerror: 761| 3|l_noret luaG_callerror (lua_State *L, const TValue *o) { 762| 3| CallInfo *ci = L->ci; 763| 3| const char *name = NULL; /* to avoid warnings */ 764| 3| const char *kind = funcnamefromcall(L, ci, &name); 765| 3| const char *extra = kind ? formatvarinfo(L, kind, name) : varinfo(L, o); ------------------ | Branch (765:23): [True: 3, False: 0] ------------------ 766| 3| typeerror(L, o, "call", extra); 767| 3|} luaG_forerror: 770| 1|l_noret luaG_forerror (lua_State *L, const TValue *o, const char *what) { 771| 1| luaG_runerror(L, "bad 'for' %s (number expected, got %s)", 772| 1| what, luaT_objtypename(L, o)); 773| 1|} luaG_opinterror: 783| 121| const TValue *p2, const char *msg) { 784| 121| if (!ttisnumber(p1)) /* first operand is wrong? */ ------------------ | | 339| 121|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | ------------------ | | | | 92| 121|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 121|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 121|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (784:7): [True: 109, False: 12] ------------------ 785| 109| p2 = p1; /* now second is wrong */ 786| 121| luaG_typeerror(L, p2, msg); 787| 121|} luaG_tointerror: 793| 1|l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) { 794| 1| lua_Integer temp; 795| 1| if (!luaV_tointegerns(p1, &temp, LUA_FLOORN2I)) ------------------ | | 36| 1|#define LUA_FLOORN2I F2Ieq ------------------ | Branch (795:7): [True: 0, False: 1] ------------------ 796| 0| p2 = p1; 797| 1| luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2)); 798| 1|} luaG_ordererror: 801| 16|l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) { 802| 16| const char *t1 = luaT_objtypename(L, p1); 803| 16| const char *t2 = luaT_objtypename(L, p2); 804| 16| if (strcmp(t1, t2) == 0) ------------------ | Branch (804:7): [True: 7, False: 9] ------------------ 805| 7| luaG_runerror(L, "attempt to compare two %s values", t1); 806| 9| else 807| 9| luaG_runerror(L, "attempt to compare %s with %s", t1, t2); 808| 16|} luaG_addinfo: 813| 546| int line) { 814| 546| char buff[LUA_IDSIZE]; 815| 546| if (src) { ------------------ | Branch (815:7): [True: 546, False: 0] ------------------ 816| 546| size_t idlen; 817| 546| const char *id = getlstr(src, idlen); ------------------ | | 440| 546| (strisshr(ts) \ | | ------------------ | | | | 420| 546|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 546, False: 0] | | | | ------------------ | | ------------------ | | 441| 546| ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 141| 546|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 546|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 427| 546|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 546|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 546|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 442| 546| : (cast_void((len) = (ts)->u.lnglen), (ts)->contents)) | | ------------------ | | | | 141| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 818| 546| luaO_chunkid(buff, id, idlen); 819| 546| } 820| 0| else { /* no source available; use "?" instead */ 821| 0| buff[0] = '?'; buff[1] = '\0'; 822| 0| } 823| 546| return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg); 824| 546|} luaG_errormsg: 827| 159|l_noret luaG_errormsg (lua_State *L) { 828| 159| if (L->errfunc != 0) { /* is there an error handling function? */ ------------------ | Branch (828:7): [True: 153, False: 6] ------------------ 829| 153| StkId errfunc = restorestack(L, L->errfunc); ------------------ | | 37| 153|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 139| 153|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 830| 153| lua_assert(ttisfunction(s2v(errfunc))); ------------------ | | 109| 153|#define lua_assert(c) assert(c) ------------------ 831| 153| setobjs2s(L, L->top.p, L->top.p - 1); /* move argument */ ------------------ | | 129| 153|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 153| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 153| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 153|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 153| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 153| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 2.44k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 153|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 153] | | | | | | | | | Branch (115:29): [True: 153, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 153] | | | | | | | | | Branch (115:29): [True: 153, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 153] | | | | | | | | | Branch (115:29): [True: 153, False: 0] | | | | | | | | | Branch (115:29): [True: 153, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 153] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 153| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 153|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 832| 153| setobjs2s(L, L->top.p - 1, errfunc); /* push function */ ------------------ | | 129| 153|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 153| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 153| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 153|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 153| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 153| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 153|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 153|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 153, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 153| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 153|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 833| 153| L->top.p++; /* assume EXTRA_STACK */ 834| 153| luaD_callnoyield(L, L->top.p - 2, 1); /* call it */ 835| 153| } 836| 159| luaD_throw(L, LUA_ERRRUN); ------------------ | | 50| 159|#define LUA_ERRRUN 2 ------------------ 837| 159|} luaG_runerror: 840| 159|l_noret luaG_runerror (lua_State *L, const char *fmt, ...) { 841| 159| CallInfo *ci = L->ci; 842| 159| const char *msg; 843| 159| va_list argp; 844| 159| luaC_checkGC(L); /* error message uses memory */ ------------------ | | 219| 159|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 215| 159| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 159|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 6, False: 153] | | | | ------------------ | | | | 216| 159| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 159|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 845| 159| va_start(argp, fmt); 846| 159| msg = luaO_pushvfstring(L, fmt, argp); /* format message */ 847| 159| va_end(argp); 848| 159| if (isLua(ci)) { /* if Lua function, add source:line information */ ------------------ | | 242| 159|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 212| 159|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (242:19): [True: 153, False: 6] | | ------------------ ------------------ 849| 306| luaG_addinfo(L, msg, ci_func(ci)->p->source, getcurrentline(ci)); ------------------ | | 18| 153|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 641| 153|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 113| 612|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 153|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 153] | | | | | | | Branch (113:42): [True: 153, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 850| 153| setobjs2s(L, L->top.p - 2, L->top.p - 1); /* remove 'msg' */ ------------------ | | 129| 153|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 153| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 153| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 153|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 153| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 153| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 2.44k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 153|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 153] | | | | | | | | | Branch (115:29): [True: 153, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 153] | | | | | | | | | Branch (115:29): [True: 153, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 153] | | | | | | | | | Branch (115:29): [True: 153, False: 0] | | | | | | | | | Branch (115:29): [True: 153, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 153] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 153| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 153|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 851| 153| L->top.p--; 852| 153| } 853| 159| luaG_errormsg(L); 854| 159|} luaG_traceexec: 920| 344|int luaG_traceexec (lua_State *L, const Instruction *pc) { 921| 344| CallInfo *ci = L->ci; 922| 344| lu_byte mask = L->hookmask; 923| 688| const Proto *p = ci_func(ci)->p; ------------------ | | 18| 344|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 641| 344|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 113| 1.37k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 344|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 344] | | | | | | | Branch (113:42): [True: 344, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 924| 0| int counthook; 925| 688| if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) { /* no hooks? */ ------------------ | | 471| 344|#define LUA_MASKLINE (1 << LUA_HOOKLINE) | | ------------------ | | | | 461| 344|#define LUA_HOOKLINE 2 | | ------------------ ------------------ if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) { /* no hooks? */ ------------------ | | 472| 344|#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) | | ------------------ | | | | 462| 344|#define LUA_HOOKCOUNT 3 | | ------------------ ------------------ | Branch (925:7): [True: 344, False: 0] ------------------ 926| 344| ci->u.l.trap = 0; /* don't need to stop again */ 927| 344| return 0; /* turn off 'trap' */ 928| 344| } 929| 0| pc++; /* reference is always next instruction */ 930| 0| ci->u.l.savedpc = pc; /* save 'pc' */ 931| 0| counthook = (mask & LUA_MASKCOUNT) && (--L->hookcount == 0); ------------------ | | 472| 0|#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) | | ------------------ | | | | 462| 0|#define LUA_HOOKCOUNT 3 | | ------------------ ------------------ | Branch (931:15): [True: 0, False: 0] | Branch (931:41): [True: 0, False: 0] ------------------ 932| 0| if (counthook) ------------------ | Branch (932:7): [True: 0, False: 0] ------------------ 933| 0| resethookcount(L); /* reset count */ ------------------ | | 21| 0|#define resethookcount(L) (L->hookcount = L->basehookcount) ------------------ 934| 0| else if (!(mask & LUA_MASKLINE)) ------------------ | | 471| 0|#define LUA_MASKLINE (1 << LUA_HOOKLINE) | | ------------------ | | | | 461| 0|#define LUA_HOOKLINE 2 | | ------------------ ------------------ | Branch (934:12): [True: 0, False: 0] ------------------ 935| 0| return 1; /* no line hook and count != 0; nothing to be done now */ 936| 0| if (ci->callstatus & CIST_HOOKYIELD) { /* hook yielded last time? */ ------------------ | | 217| 0|#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */ ------------------ | Branch (936:7): [True: 0, False: 0] ------------------ 937| 0| ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */ ------------------ | | 217| 0|#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */ ------------------ 938| 0| return 1; /* do not call hook again (VM yielded, so it did not move) */ 939| 0| } 940| 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)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (396:48): [True: 0, False: 0] | | ------------------ ------------------ 941| 0| L->top.p = ci->top.p; /* correct top */ 942| 0| if (counthook) ------------------ | Branch (942:7): [True: 0, False: 0] ------------------ 943| 0| luaD_hook(L, LUA_HOOKCOUNT, -1, 0, 0); /* call count hook */ ------------------ | | 462| 0|#define LUA_HOOKCOUNT 3 ------------------ 944| 0| if (mask & LUA_MASKLINE) { ------------------ | | 471| 0|#define LUA_MASKLINE (1 << LUA_HOOKLINE) | | ------------------ | | | | 461| 0|#define LUA_HOOKLINE 2 | | ------------------ ------------------ | Branch (944:7): [True: 0, False: 0] ------------------ 945| | /* 'L->oldpc' may be invalid; use zero in this case */ 946| 0| int oldpc = (L->oldpc < p->sizecode) ? L->oldpc : 0; ------------------ | Branch (946:17): [True: 0, False: 0] ------------------ 947| 0| int npci = pcRel(pc, p); ------------------ | | 14| 0|#define pcRel(pc, p) (cast_int((pc) - (p)->code) - 1) | | ------------------ | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 948| 0| if (npci <= oldpc || /* call hook when jump back (loop), */ ------------------ | Branch (948:9): [True: 0, False: 0] ------------------ 949| 0| changedline(p, oldpc, npci)) { /* or when enter new line */ ------------------ | Branch (949:9): [True: 0, False: 0] ------------------ 950| 0| int newline = luaG_getfuncline(p, npci); 951| 0| luaD_hook(L, LUA_HOOKLINE, newline, 0, 0); /* call line hook */ ------------------ | | 461| 0|#define LUA_HOOKLINE 2 ------------------ 952| 0| } 953| 0| L->oldpc = npci; /* 'pc' of last call to line hook */ 954| 0| } 955| 0| if (L->status == LUA_YIELD) { /* did hook yield? */ ------------------ | | 49| 0|#define LUA_YIELD 1 ------------------ | Branch (955:7): [True: 0, False: 0] ------------------ 956| 0| if (counthook) ------------------ | Branch (956:9): [True: 0, False: 0] ------------------ 957| 0| L->hookcount = 1; /* undo decrement to zero */ 958| 0| ci->callstatus |= CIST_HOOKYIELD; /* mark that it yielded */ ------------------ | | 217| 0|#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */ ------------------ 959| 0| luaD_throw(L, LUA_YIELD); ------------------ | | 49| 0|#define LUA_YIELD 1 ------------------ 960| 0| } 961| 0| return 1; /* keep 'trap' on */ 962| 0|} ldebug.c:getbaseline: 60| 354|static int getbaseline (const Proto *f, int pc, int *basepc) { 61| 354| if (f->sizeabslineinfo == 0 || pc < f->abslineinfo[0].pc) { ------------------ | Branch (61:7): [True: 100, False: 254] | Branch (61:34): [True: 50, False: 204] ------------------ 62| 150| *basepc = -1; /* start from the beginning */ 63| 150| return f->linedefined; 64| 150| } 65| 204| else { 66| 204| int i = cast_uint(pc) / MAXIWTHABS - 1; /* get an estimate */ ------------------ | | 145| 204|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 139| 204|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ int i = cast_uint(pc) / MAXIWTHABS - 1; /* get an estimate */ ------------------ | | 35| 204|#define MAXIWTHABS 128 ------------------ 67| | /* estimate must be a lower bound of the correct base */ 68| 204| lua_assert(i < 0 || ------------------ | | 109| 204|#define lua_assert(c) assert(c) ------------------ 69| 204| (i < f->sizeabslineinfo && f->abslineinfo[i].pc <= pc)); 70| 260| while (i + 1 < f->sizeabslineinfo && pc >= f->abslineinfo[i + 1].pc) ------------------ | Branch (70:12): [True: 133, False: 127] | Branch (70:42): [True: 56, False: 77] ------------------ 71| 56| i++; /* low estimate; adjust it */ 72| 204| *basepc = f->abslineinfo[i].pc; 73| 204| return f->abslineinfo[i].line; 74| 204| } 75| 354|} ldebug.c:currentpc: 41| 537|static int currentpc (CallInfo *ci) { 42| 537| lua_assert(isLua(ci)); ------------------ | | 109| 537|#define lua_assert(c) assert(c) ------------------ 43| 537| return pcRel(ci->u.l.savedpc, ci_func(ci)->p); ------------------ | | 14| 537|#define pcRel(pc, p) (cast_int((pc) - (p)->code) - 1) | | ------------------ | | | | 144| 537|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 139| 4.29k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (139:27): [True: 0, False: 537] | | | | | | | Branch (139:27): [True: 537, False: 0] | | | | | | | Branch (139:27): [True: 0, False: 537] | | | | | | | Branch (139:27): [True: 537, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 44| 537|} ldebug.c:auxgetinfo: 328| 402| Closure *f, CallInfo *ci) { 329| 402| int status = 1; 330| 1.40k| for (; *what; what++) { ------------------ | Branch (330:10): [True: 1.00k, False: 402] ------------------ 331| 1.00k| switch (*what) { 332| 201| case 'S': { ------------------ | Branch (332:7): [True: 201, False: 804] ------------------ 333| 201| funcinfo(ar, f); 334| 201| break; 335| 0| } 336| 201| case 'l': { ------------------ | Branch (336:7): [True: 201, False: 804] ------------------ 337| 201| ar->currentline = (ci && isLua(ci)) ? getcurrentline(ci) : -1; ------------------ | | 242| 201|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 212| 201|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (242:19): [True: 201, False: 0] | | ------------------ ------------------ | Branch (337:28): [True: 201, False: 0] ------------------ 338| 201| break; 339| 0| } 340| 0| case 'u': { ------------------ | Branch (340:7): [True: 0, False: 1.00k] ------------------ 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) | | ------------------ | | | | 629| 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->flag & PF_ISVARARG; ------------------ | | 582| 0|#define PF_ISVARARG 1 ------------------ 348| 0| ar->nparams = f->l.p->numparams; 349| 0| } 350| 0| break; 351| 0| } 352| 201| case 't': { ------------------ | Branch (352:7): [True: 201, False: 804] ------------------ 353| 201| ar->istailcall = (ci) ? ci->callstatus & CIST_TAIL : 0; ------------------ | | 216| 201|#define CIST_TAIL (1<<5) /* call was tail called */ ------------------ | Branch (353:26): [True: 201, False: 0] ------------------ 354| 201| break; 355| 0| } 356| 201| case 'n': { ------------------ | Branch (356:7): [True: 201, False: 804] ------------------ 357| 201| ar->namewhat = getfuncname(L, ci, &ar->name); 358| 201| if (ar->namewhat == NULL) { ------------------ | Branch (358:13): [True: 153, False: 48] ------------------ 359| 153| ar->namewhat = ""; /* not found */ 360| 153| ar->name = NULL; 361| 153| } 362| 201| break; 363| 0| } 364| 0| case 'r': { ------------------ | Branch (364:7): [True: 0, False: 1.00k] ------------------ 365| 0| if (ci == NULL || !(ci->callstatus & CIST_TRAN)) ------------------ | | 219| 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: 1.00k] ------------------ 374| 201| case 'f': /* handled by lua_getinfo */ ------------------ | Branch (374:7): [True: 201, False: 804] ------------------ 375| 201| break; 376| 0| default: status = 0; /* invalid option */ ------------------ | Branch (376:7): [True: 0, False: 1.00k] ------------------ 377| 1.00k| } 378| 1.00k| } 379| 402| return status; 380| 402|} ldebug.c:funcinfo: 257| 201|static void funcinfo (lua_Debug *ar, Closure *cl) { 258| 201| if (noLuaClosure(cl)) { ------------------ | | 34| 201|#define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_VCCL) | | ------------------ | | | | 629| 201|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | | | ------------------ | | | | | | 42| 201|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (34:27): [True: 0, False: 201] | | | Branch (34:42): [True: 0, False: 201] | | ------------------ ------------------ 259| 0| ar->source = "=[C]"; 260| 0| ar->srclen = LL("=[C]"); ------------------ | | 73| 0|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 261| 0| ar->linedefined = -1; 262| 0| ar->lastlinedefined = -1; 263| 0| ar->what = "C"; 264| 0| } 265| 201| else { 266| 201| const Proto *p = cl->l.p; 267| 201| if (p->source) { ------------------ | Branch (267:9): [True: 201, False: 0] ------------------ 268| 201| ar->source = getlstr(p->source, ar->srclen); ------------------ | | 440| 201| (strisshr(ts) \ | | ------------------ | | | | 420| 201|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 201, False: 0] | | | | ------------------ | | ------------------ | | 441| 201| ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 141| 201|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 201|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 427| 201|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 201|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 201|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 442| 201| : (cast_void((len) = (ts)->u.lnglen), (ts)->contents)) | | ------------------ | | | | 141| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 269| 201| } 270| 0| else { 271| 0| ar->source = "=?"; 272| 0| ar->srclen = LL("=?"); ------------------ | | 73| 0|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 273| 0| } 274| 201| ar->linedefined = p->linedefined; 275| 201| ar->lastlinedefined = p->lastlinedefined; 276| 201| ar->what = (ar->linedefined == 0) ? "main" : "Lua"; ------------------ | Branch (276:16): [True: 153, False: 48] ------------------ 277| 201| } 278| 201| luaO_chunkid(ar->short_src, ar->source, ar->srclen); 279| 201|} ldebug.c:getfuncname: 319| 201|static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) { 320| | /* calling function is a known function? */ 321| 201| if (ci != NULL && !(ci->callstatus & CIST_TAIL)) ------------------ | | 216| 201|#define CIST_TAIL (1<<5) /* call was tail called */ ------------------ | Branch (321:7): [True: 201, False: 0] | Branch (321:21): [True: 201, False: 0] ------------------ 322| 201| return funcnamefromcall(L, ci->previous, name); 323| 0| else return NULL; /* no way to find a name */ 324| 201|} ldebug.c:typeerror: 741| 134| const char *extra) { 742| 134| const char *t = luaT_objtypename(L, o); 743| 134| luaG_runerror(L, "attempt to %s a %s value%s", op, t, extra); 744| 134|} ldebug.c:varinfo: 721| 132|static const char *varinfo (lua_State *L, const TValue *o) { 722| 132| CallInfo *ci = L->ci; 723| 132| const char *name = NULL; /* to avoid warnings */ 724| 132| const char *kind = NULL; 725| 132| if (isLua(ci)) { ------------------ | | 242| 132|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 212| 132|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (242:19): [True: 132, False: 0] | | ------------------ ------------------ 726| 132| kind = getupvalname(ci, o, &name); /* check whether 'o' is an upvalue */ 727| 132| if (!kind) { /* not an upvalue? */ ------------------ | Branch (727:9): [True: 132, False: 0] ------------------ 728| 132| int reg = instack(ci, o); /* try a register */ 729| 132| if (reg >= 0) /* is 'o' a register? */ ------------------ | Branch (729:11): [True: 132, False: 0] ------------------ 730| 264| kind = getobjname(ci_func(ci)->p, currentpc(ci), reg, &name); ------------------ | | 18| 132|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 641| 132|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 113| 528|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 132|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 132] | | | | | | | Branch (113:42): [True: 132, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 731| 132| } 732| 132| } 733| 132| return formatvarinfo(L, kind, name); 734| 132|} ldebug.c:getupvalname: 696| 132| const char **name) { 697| 264| LClosure *c = ci_func(ci); ------------------ | | 18| 132|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 641| 132|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 113| 528|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 132|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 132] | | | | | | | Branch (113:42): [True: 132, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 698| 0| int i; 699| 268| for (i = 0; i < c->nupvalues; i++) { ------------------ | Branch (699:15): [True: 136, False: 132] ------------------ 700| 136| if (c->upvals[i]->v.p == o) { ------------------ | Branch (700:9): [True: 0, False: 136] ------------------ 701| 0| *name = upvalname(c->p, i); 702| 0| return "upvalue"; 703| 0| } 704| 136| } 705| 132| return NULL; 706| 264|} ldebug.c:upvalname: 177| 74|static const char *upvalname (const Proto *p, int uv) { 178| 74| TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name); ------------------ | | 113| 74|#define check_exp(c,e) (lua_assert(c), (e)) | | ------------------ | | | | 109| 74|#define lua_assert(c) assert(c) | | ------------------ ------------------ 179| 74| if (s == NULL) return "?"; ------------------ | Branch (179:7): [True: 0, False: 74] ------------------ 180| 74| else return getstr(s); ------------------ | | 430| 74|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 74|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 74, False: 0] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 74|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 74|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 74|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 181| 74|} ldebug.c:instack: 679| 132|static int instack (CallInfo *ci, const TValue *o) { 680| 132| int pos; 681| 132| StkId base = ci->func.p + 1; 682| 703| for (pos = 0; base + pos < ci->top.p; pos++) { ------------------ | Branch (682:17): [True: 703, False: 0] ------------------ 683| 703| if (o == s2v(base + pos)) ------------------ | | 172| 703|#define s2v(o) (&(o)->val) ------------------ | Branch (683:9): [True: 132, False: 571] ------------------ 684| 132| return pos; 685| 703| } 686| 0| return -1; /* not found */ 687| 132|} ldebug.c:getobjname: 565| 183| const char **name) { 566| 183| const char *kind = basicgetobjname(p, &lastpc, reg, name); 567| 183| if (kind != NULL) ------------------ | Branch (567:7): [True: 79, False: 104] ------------------ 568| 79| return kind; 569| 104| else if (lastpc != -1) { /* could find instruction? */ ------------------ | Branch (569:12): [True: 103, False: 1] ------------------ 570| 103| Instruction i = p->code[lastpc]; 571| 103| OpCode op = GET_OPCODE(i); ------------------ | | 114| 103|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 139| 103|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 572| 103| switch (op) { 573| 67| case OP_GETTABUP: { ------------------ | Branch (573:7): [True: 67, False: 36] ------------------ 574| 67| int k = GETARG_C(i); /* key index */ ------------------ | | 132| 67|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 113| 67|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 67|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 575| 0| kname(p, k, name); 576| 67| return isEnv(p, lastpc, i, 1); 577| 67| } 578| 4| case OP_GETTABLE: { ------------------ | Branch (578:7): [True: 4, False: 99] ------------------ 579| 4| int k = GETARG_C(i); /* key index */ ------------------ | | 132| 4|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 113| 4|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 4|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 580| 0| rname(p, lastpc, k, name); 581| 4| return isEnv(p, lastpc, i, 0); 582| 4| } 583| 0| case OP_GETI: { ------------------ | Branch (583:7): [True: 0, False: 103] ------------------ 584| 0| *name = "integer index"; 585| 0| return "field"; 586| 4| } 587| 0| case OP_GETFIELD: { ------------------ | Branch (587:7): [True: 0, False: 103] ------------------ 588| 0| int k = GETARG_C(i); /* key index */ ------------------ | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 589| 0| kname(p, k, name); 590| 0| return isEnv(p, lastpc, i, 0); 591| 0| } 592| 0| case OP_SELF: { ------------------ | Branch (592:7): [True: 0, False: 103] ------------------ 593| 0| rkname(p, lastpc, i, name); 594| 0| return "method"; 595| 0| } 596| 32| default: break; /* go through to return NULL */ ------------------ | Branch (596:7): [True: 32, False: 71] ------------------ 597| 103| } 598| 103| } 599| 33| return NULL; /* could not find reasonable name */ 600| 183|} ldebug.c:basicgetobjname: 494| 195| const char **name) { 495| 195| int pc = *ppc; 496| 195| *name = luaF_getlocalname(p, reg + 1, pc); 497| 195| if (*name) /* is a local? */ ------------------ | Branch (497:7): [True: 4, False: 191] ------------------ 498| 4| return "local"; 499| | /* else try symbolic execution */ 500| 191| *ppc = pc = findsetreg(p, pc, reg); 501| 191| if (pc != -1) { /* could find instruction? */ ------------------ | Branch (501:7): [True: 190, False: 1] ------------------ 502| 190| Instruction i = p->code[pc]; 503| 190| OpCode op = GET_OPCODE(i); ------------------ | | 114| 190|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 139| 190|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 504| 190| switch (op) { 505| 4| case OP_MOVE: { ------------------ | Branch (505:7): [True: 4, False: 186] ------------------ 506| 4| int b = GETARG_B(i); /* move from 'b' to 'a' */ ------------------ | | 128| 4|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 4|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 4|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 507| 4| if (b < 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))) | | | | ------------------ | | | | | | 144| 4|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 4|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (507:13): [True: 4, False: 0] ------------------ 508| 4| return basicgetobjname(p, ppc, b, name); /* get name for 'b' */ 509| 0| break; 510| 4| } 511| 7| case OP_GETUPVAL: { ------------------ | Branch (511:7): [True: 7, False: 183] ------------------ 512| 7| *name = upvalname(p, GETARG_B(i)); ------------------ | | 128| 7|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 7|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 7|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 513| 0| return "upvalue"; 514| 7| } 515| 76| case OP_LOADK: return kname(p, GETARG_Bx(i), name); ------------------ | | 140| 76|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 113| 76|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 76|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (515:7): [True: 76, False: 114] ------------------ 516| 0| case OP_LOADKX: return kname(p, GETARG_Ax(p->code[pc + 1]), name); ------------------ | | 143| 0|#define GETARG_Ax(i) check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (516:7): [True: 0, False: 190] ------------------ 517| 103| default: break; ------------------ | Branch (517:7): [True: 103, False: 87] ------------------ 518| 190| } 519| 190| } 520| 104| return NULL; /* could not find reasonable name */ 521| 191|} ldebug.c:findsetreg: 431| 191|static int findsetreg (const Proto *p, int lastpc, int reg) { 432| 191| int pc; 433| 191| int setreg = -1; /* keep last instruction that changed 'reg' */ 434| 191| int jmptarget = 0; /* any code before this address is conditional */ 435| 191| if (testMMMode(GET_OPCODE(p->code[lastpc]))) ------------------ | | 388| 191|#define testMMMode(m) (luaP_opmodes[m] & (1 << 7)) | | ------------------ | | | Branch (388:23): [True: 59, False: 132] | | ------------------ ------------------ 436| 59| lastpc--; /* previous instruction was not actually executed */ 437| 44.1M| for (pc = 0; pc < lastpc; pc++) { ------------------ | Branch (437:16): [True: 44.1M, False: 191] ------------------ 438| 44.1M| Instruction i = p->code[pc]; 439| 44.1M| OpCode op = GET_OPCODE(i); ------------------ | | 114| 44.1M|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 139| 44.1M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 440| 44.1M| int a = GETARG_A(i); ------------------ | | 125| 44.1M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 44.1M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 144| 44.1M|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 44.1M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 441| 44.1M| int change; /* true if current instruction changed 'reg' */ 442| 44.1M| switch (op) { 443| 3.31k| case OP_LOADNIL: { /* set registers from 'a' to 'a+b' */ ------------------ | Branch (443:7): [True: 3.31k, False: 44.1M] ------------------ 444| 3.31k| int b = GETARG_B(i); ------------------ | | 128| 3.31k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 3.31k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 3.31k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 445| 3.31k| change = (a <= reg && reg <= a + b); ------------------ | Branch (445:19): [True: 2.52k, False: 790] | Branch (445:31): [True: 2.52k, False: 7] ------------------ 446| 3.31k| break; 447| 3.31k| } 448| 0| case OP_TFORCALL: { /* affect all regs above its base */ ------------------ | Branch (448:7): [True: 0, False: 44.1M] ------------------ 449| 0| change = (reg >= a + 2); 450| 0| break; 451| 3.31k| } 452| 180k| case OP_CALL: ------------------ | Branch (452:7): [True: 180k, False: 44.0M] ------------------ 453| 180k| case OP_TAILCALL: { /* affect all registers above base */ ------------------ | Branch (453:7): [True: 0, False: 44.1M] ------------------ 454| 180k| change = (reg >= a); 455| 180k| break; 456| 180k| } 457| 8.40M| case OP_JMP: { /* doesn't change registers, but changes 'jmptarget' */ ------------------ | Branch (457:7): [True: 8.40M, False: 35.7M] ------------------ 458| 8.40M| int b = GETARG_sJ(i); ------------------ | | 151| 8.40M| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | ------------------ | | | | 113| 8.40M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 8.40M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 459| 0| int dest = pc + 1 + b; 460| | /* jump does not skip 'lastpc' and is larger than current one? */ 461| 8.40M| if (dest <= lastpc && dest > jmptarget) ------------------ | Branch (461:13): [True: 8.40M, False: 0] | Branch (461:31): [True: 34.7k, False: 8.37M] ------------------ 462| 34.7k| jmptarget = dest; /* update 'jmptarget' */ 463| 8.40M| change = 0; 464| 8.40M| break; 465| 8.40M| } 466| 35.5M| default: /* any instruction that sets A */ ------------------ | Branch (466:7): [True: 35.5M, False: 8.59M] ------------------ 467| 35.5M| change = (testAMode(op) && reg == a); ------------------ | | 384| 71.1M|#define testAMode(m) (luaP_opmodes[m] & (1 << 3)) | | ------------------ | | | Branch (384:22): [True: 26.6M, False: 8.95M] | | ------------------ ------------------ | Branch (467:36): [True: 16.5M, False: 10.1M] ------------------ 468| 35.5M| break; 469| 44.1M| } 470| 44.1M| if (change) ------------------ | Branch (470:9): [True: 16.5M, False: 27.6M] ------------------ 471| 16.5M| setreg = filterpc(pc, jmptarget); 472| 44.1M| } 473| 191| return setreg; 474| 191|} ldebug.c:filterpc: 421| 16.5M|static int filterpc (int pc, int jmptarget) { 422| 16.5M| if (pc < jmptarget) /* is code conditional (inside a jump)? */ ------------------ | Branch (422:7): [True: 16.4M, False: 33.4k] ------------------ 423| 16.4M| return -1; /* cannot know who sets that register */ 424| 33.4k| else return pc; /* current position sets that register */ 425| 16.5M|} ldebug.c:kname: 480| 143|static const char *kname (const Proto *p, int index, const char **name) { 481| 143| TValue *kvalue = &p->k[index]; 482| 143| if (ttisstring(kvalue)) { ------------------ | | 376| 143|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 143|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 143|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 143|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 143, False: 0] | | | | ------------------ | | ------------------ ------------------ 483| 143| *name = getstr(tsvalue(kvalue)); ------------------ | | 430| 408|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 1.14k|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 92, False: 51] | | | | | Branch (420:24): [True: 0, False: 143] | | | | | Branch (420:24): [True: 143, False: 0] | | | | | Branch (420:24): [True: 0, False: 143] | | | | | Branch (420:24): [True: 143, False: 0] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 184|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 92|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 736|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | | | | Branch (139:27): [True: 0, False: 92] | | | | | | | | | Branch (139:27): [True: 92, False: 0] | | | | | | | | | Branch (139:27): [True: 0, False: 92] | | | | | | | | | Branch (139:27): [True: 92, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (430:57): [True: 0, False: 51] | | | Branch (430:57): [True: 51, False: 0] | | | Branch (430:57): [True: 0, False: 51] | | | Branch (430:57): [True: 51, False: 0] | | ------------------ ------------------ 484| 0| return "constant"; 485| 143| } 486| 0| else { 487| 0| *name = "?"; 488| 0| return NULL; 489| 0| } 490| 143|} ldebug.c:isEnv: 550| 71|static const char *isEnv (const Proto *p, int pc, Instruction i, int isup) { 551| 71| int t = GETARG_B(i); /* table index */ ------------------ | | 128| 71|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 71|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 71|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 552| 0| const char *name; /* name of indexed variable */ 553| 71| if (isup) /* is 't' an upvalue? */ ------------------ | Branch (553:7): [True: 67, False: 4] ------------------ 554| 67| name = upvalname(p, t); 555| 4| else /* 't' is a register */ 556| 4| basicgetobjname(p, &pc, t, &name); 557| 71| return (name && strcmp(name, LUA_ENV) == 0) ? "global" : "field"; ------------------ | | 24| 71|#define LUA_ENV "_ENV" ------------------ | Branch (557:11): [True: 71, False: 0] | Branch (557:19): [True: 71, False: 0] ------------------ 558| 71|} ldebug.c:rname: 527| 4|static void rname (const Proto *p, int pc, int c, const char **name) { 528| 4| const char *what = basicgetobjname(p, &pc, c, name); /* search for 'c' */ 529| 4| if (!(what && *what == 'c')) /* did not find a constant name? */ ------------------ | Branch (529:9): [True: 4, False: 0] | Branch (529:17): [True: 4, False: 0] ------------------ 530| 0| *name = "?"; 531| 4|} ldebug.c:funcnamefromcall: 654| 204| const char **name) { 655| 204| if (ci->callstatus & CIST_HOOKED) { /* was it called inside a hook? */ ------------------ | | 214| 204|#define CIST_HOOKED (1<<3) /* call is running a debug hook */ ------------------ | Branch (655:7): [True: 0, False: 204] ------------------ 656| 0| *name = "?"; 657| 0| return "hook"; 658| 0| } 659| 204| else if (ci->callstatus & CIST_FIN) { /* was it called as a finalizer? */ ------------------ | | 218| 204|#define CIST_FIN (1<<7) /* function "called" a finalizer */ ------------------ | Branch (659:12): [True: 0, False: 204] ------------------ 660| 0| *name = "__gc"; 661| 0| return "metamethod"; /* report it as such */ 662| 0| } 663| 204| else if (isLua(ci)) ------------------ | | 242| 204|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 212| 204|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (242:19): [True: 51, False: 153] | | ------------------ ------------------ 664| 102| return funcnamefromcode(L, ci_func(ci)->p, currentpc(ci), name); ------------------ | | 18| 51|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 641| 51|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 113| 204|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 51|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 51] | | | | | | | Branch (113:42): [True: 51, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 665| 153| else 666| 153| return NULL; 667| 204|} ldebug.c:funcnamefromcode: 610| 51| int pc, const char **name) { 611| 51| TMS tm = (TMS)0; /* (initial value avoids warnings) */ 612| 51| Instruction i = p->code[pc]; /* calling instruction */ 613| 51| switch (GET_OPCODE(i)) { ------------------ | | 114| 51|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 139| 51|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 614| 51| case OP_CALL: ------------------ | Branch (614:5): [True: 51, False: 0] ------------------ 615| 51| case OP_TAILCALL: ------------------ | Branch (615:5): [True: 0, False: 51] ------------------ 616| 51| return getobjname(p, pc, GETARG_A(i), name); /* get function name */ ------------------ | | 125| 51|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 51|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 144| 51|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 51|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 617| 0| case OP_TFORCALL: { /* for iterator */ ------------------ | Branch (617:5): [True: 0, False: 51] ------------------ 618| 0| *name = "for iterator"; 619| 0| return "for iterator"; 620| 51| } 621| | /* other instructions can do calls through metamethods */ 622| 0| case OP_SELF: case OP_GETTABUP: case OP_GETTABLE: ------------------ | Branch (622:5): [True: 0, False: 51] | Branch (622:19): [True: 0, False: 51] | Branch (622:37): [True: 0, False: 51] ------------------ 623| 0| case OP_GETI: case OP_GETFIELD: ------------------ | Branch (623:5): [True: 0, False: 51] | Branch (623:19): [True: 0, False: 51] ------------------ 624| 0| tm = TM_INDEX; 625| 0| break; 626| 0| case OP_SETTABUP: case OP_SETTABLE: case OP_SETI: case OP_SETFIELD: ------------------ | Branch (626:5): [True: 0, False: 51] | Branch (626:23): [True: 0, False: 51] | Branch (626:41): [True: 0, False: 51] | Branch (626:55): [True: 0, False: 51] ------------------ 627| 0| tm = TM_NEWINDEX; 628| 0| break; 629| 0| case OP_MMBIN: case OP_MMBINI: case OP_MMBINK: { ------------------ | Branch (629:5): [True: 0, False: 51] | Branch (629:20): [True: 0, False: 51] | Branch (629:36): [True: 0, False: 51] ------------------ 630| 0| tm = cast(TMS, GETARG_C(i)); ------------------ | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ | | | Branch (139:27): [True: 0, False: 0] | | | Branch (139:27): [True: 0, False: 0] | | ------------------ ------------------ 631| 0| break; 632| 0| } 633| 0| case OP_UNM: tm = TM_UNM; break; ------------------ | Branch (633:5): [True: 0, False: 51] ------------------ 634| 0| case OP_BNOT: tm = TM_BNOT; break; ------------------ | Branch (634:5): [True: 0, False: 51] ------------------ 635| 0| case OP_LEN: tm = TM_LEN; break; ------------------ | Branch (635:5): [True: 0, False: 51] ------------------ 636| 0| case OP_CONCAT: tm = TM_CONCAT; break; ------------------ | Branch (636:5): [True: 0, False: 51] ------------------ 637| 0| case OP_EQ: tm = TM_EQ; break; ------------------ | Branch (637:5): [True: 0, False: 51] ------------------ 638| | /* no cases for OP_EQI and OP_EQK, as they don't call metamethods */ 639| 0| case OP_LT: case OP_LTI: case OP_GTI: tm = TM_LT; break; ------------------ | Branch (639:5): [True: 0, False: 51] | Branch (639:17): [True: 0, False: 51] | Branch (639:30): [True: 0, False: 51] ------------------ 640| 0| case OP_LE: case OP_LEI: case OP_GEI: tm = TM_LE; break; ------------------ | Branch (640:5): [True: 0, False: 51] | Branch (640:17): [True: 0, False: 51] | Branch (640:30): [True: 0, False: 51] ------------------ 641| 0| case OP_CLOSE: case OP_RETURN: tm = TM_CLOSE; break; ------------------ | Branch (641:5): [True: 0, False: 51] | Branch (641:20): [True: 0, False: 51] ------------------ 642| 0| default: ------------------ | Branch (642:5): [True: 0, False: 51] ------------------ 643| 0| return NULL; /* cannot find a reasonable name */ 644| 51| } 645| 0| *name = getshrstr(G(L)->tmname[tm]) + 2; ------------------ | | 428| 0|#define getshrstr(ts) check_exp(strisshr(ts), rawgetshrstr(ts)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 646| 0| return "metamethod"; 647| 0|} ldebug.c:formatvarinfo: 710| 135| const char *name) { 711| 135| if (kind == NULL) ------------------ | Branch (711:7): [True: 33, False: 102] ------------------ 712| 33| return ""; /* no information */ 713| 102| else 714| 102| return luaO_pushfstring(L, " (%s '%s')", kind, name); 715| 135|} ldebug.c:getcurrentline: 98| 354|static int getcurrentline (CallInfo *ci) { 99| 354| return luaG_getfuncline(ci_func(ci)->p, currentpc(ci)); ------------------ | | 18| 354|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 641| 354|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 113| 1.41k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 354|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 354] | | | | | | | Branch (113:42): [True: 354, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 100| 354|} luaD_seterrorobj: 91| 552|void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) { 92| 552| switch (errcode) { 93| 0| case LUA_ERRMEM: { /* memory error? */ ------------------ | | 52| 0|#define LUA_ERRMEM 4 ------------------ | Branch (93:5): [True: 0, False: 552] ------------------ 94| 0| setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */ ------------------ | | 390| 0|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 385| 0| { TValue *io = (obj); TString *x_ = (x); \ | | | | 386| 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)); \ | | | | ------------------ | | | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 387| 0| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 95| 0| break; 96| 0| } 97| 0| case LUA_ERRERR: { ------------------ | | 53| 0|#define LUA_ERRERR 5 ------------------ | Branch (97:5): [True: 0, False: 552] ------------------ 98| 0| setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling")); ------------------ | | 390| 0|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 385| 0| { TValue *io = (obj); TString *x_ = (x); \ | | | | 386| 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)); \ | | | | ------------------ | | | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 387| 0| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 99| 0| break; 100| 0| } 101| 0| case LUA_OK: { /* special case only for closing upvalues */ ------------------ | | 48| 0|#define LUA_OK 0 ------------------ | Branch (101:5): [True: 0, False: 552] ------------------ 102| 0| setnilvalue(s2v(oldtop)); /* no error message */ ------------------ | | 211| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 103| 0| break; 104| 0| } 105| 552| default: { ------------------ | Branch (105:5): [True: 552, False: 0] ------------------ 106| 552| lua_assert(errorstatus(errcode)); /* real error */ ------------------ | | 109| 552|#define lua_assert(c) assert(c) ------------------ 107| 552| setobjs2s(L, oldtop, L->top.p - 1); /* error message on current top */ ------------------ | | 129| 552|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 552| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 552| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 552|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 552| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 552| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 8.83k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 552|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 552] | | | | | | | | | Branch (115:29): [True: 552, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 552] | | | | | | | | | Branch (115:29): [True: 552, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 552] | | | | | | | | | Branch (115:29): [True: 552, False: 0] | | | | | | | | | Branch (115:29): [True: 552, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 552] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 552| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 552|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 108| 552| break; 109| 552| } 110| 552| } 111| 552| L->top.p = oldtop + 1; 112| 552|} luaD_throw: 115| 552|l_noret luaD_throw (lua_State *L, int errcode) { 116| 552| if (L->errorJmp) { /* thread has an error handler? */ ------------------ | Branch (116:7): [True: 552, False: 0] ------------------ 117| 552| L->errorJmp->status = errcode; /* set status */ 118| 552| LUAI_THROW(L, L->errorJmp); /* jump to it */ ------------------ | | 73| 552|#define LUAI_THROW(L,c) longjmp((c)->b, 1) ------------------ 119| 552| } 120| 0| else { /* thread has no error handler */ 121| 0| global_State *g = G(L); ------------------ | | 333| 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) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 125| 0| luaD_throw(g->mainthread, errcode); /* re-throw in main thread */ 126| 0| } 127| 0| else { /* no handler at all; abort */ 128| 0| if (g->panic) { /* panic function? */ ------------------ | Branch (128:11): [True: 0, False: 0] ------------------ 129| 0| lua_unlock(L); ------------------ | | 268| 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| 552|} luaD_rawrunprotected: 138| 2.48k|int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) { 139| 2.48k| l_uint32 oldnCcalls = L->nCcalls; 140| 2.48k| struct lua_longjmp lj; 141| 2.48k| lj.status = LUA_OK; ------------------ | | 48| 2.48k|#define LUA_OK 0 ------------------ 142| 2.48k| lj.previous = L->errorJmp; /* chain new error handler */ 143| 2.48k| L->errorJmp = &lj; 144| 2.48k| LUAI_TRY(L, &lj, ------------------ | | 74| 2.48k|#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a } | | ------------------ | | | Branch (74:30): [True: 2.48k, False: 0] | | ------------------ ------------------ 145| 2.48k| (*f)(L, ud); 146| 2.48k| ); 147| 2.48k| L->errorJmp = lj.previous; /* restore old error handler */ 148| 2.48k| L->nCcalls = oldnCcalls; 149| 2.48k| return lj.status; 150| 2.48k|} luaD_reallocstack: 212| 431|int luaD_reallocstack (lua_State *L, int newsize, int raiseerror) { 213| 431| int oldsize = stacksize(L); ------------------ | | 147| 431|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 144| 431|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 139| 431|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 214| 431| int i; 215| 431| StkId newstack; 216| 431| int oldgcstop = G(L)->gcstopem; ------------------ | | 333| 431|#define G(L) (L->l_G) ------------------ 217| 431| lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE); ------------------ | | 109| 431|#define lua_assert(c) assert(c) ------------------ 218| 431| relstack(L); /* change pointers to offsets */ 219| 431| G(L)->gcstopem = 1; /* stop emergency collection */ ------------------ | | 333| 431|#define G(L) (L->l_G) ------------------ 220| 431| newstack = luaM_reallocvector(L, L->stack.p, oldsize + EXTRA_STACK, ------------------ | | 73| 431| (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \ | | ------------------ | | | | 139| 431|#define cast(t, exp) ((t)(exp)) | | ------------------ | | 74| 431| cast_sizet(n) * sizeof(t)))) ------------------ 221| 431| newsize + EXTRA_STACK, StackValue); 222| 431| G(L)->gcstopem = oldgcstop; /* restore emergency collection */ ------------------ | | 333| 431|#define G(L) (L->l_G) ------------------ 223| 431| if (l_unlikely(newstack == NULL)) { /* reallocation failed? */ ------------------ | | 697| 431|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 431|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 431] | | | | ------------------ | | ------------------ ------------------ 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| 431| L->stack.p = newstack; 230| 431| correctstack(L); /* change offsets back to pointers */ 231| 431| L->stack_last.p = L->stack.p + newsize; 232| 1.01M| for (i = oldsize + EXTRA_STACK; i < newsize + EXTRA_STACK; i++) ------------------ | | 142| 431|#define EXTRA_STACK 5 ------------------ for (i = oldsize + EXTRA_STACK; i < newsize + EXTRA_STACK; i++) ------------------ | | 142| 1.01M|#define EXTRA_STACK 5 ------------------ | Branch (232:35): [True: 1.01M, False: 431] ------------------ 233| 1.01M| setnilvalue(s2v(newstack + i)); /* erase new segment */ ------------------ | | 211| 1.01M|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 1.01M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 234| 431| return 1; 235| 431|} luaD_growstack: 242| 234|int luaD_growstack (lua_State *L, int n, int raiseerror) { 243| 234| int size = stacksize(L); ------------------ | | 147| 234|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 144| 234|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 139| 234|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 244| 234| if (l_unlikely(size > LUAI_MAXSTACK)) { ------------------ | | 697| 234|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 234|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 234] | | | | ------------------ | | ------------------ ------------------ 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); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ 249| 0| if (raiseerror) ------------------ | Branch (249:9): [True: 0, False: 0] ------------------ 250| 0| luaD_throw(L, LUA_ERRERR); /* error inside message handler */ ------------------ | | 53| 0|#define LUA_ERRERR 5 ------------------ 251| 0| return 0; /* if not 'raiseerror', just signal it */ 252| 0| } 253| 234| else if (n < LUAI_MAXSTACK) { /* avoids arithmetic overflows */ ------------------ | | 749| 234|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (253:12): [True: 234, False: 0] ------------------ 254| 234| int newsize = 2 * size; /* tentative new size */ 255| 234| int needed = cast_int(L->top.p - L->stack.p) + n; ------------------ | | 144| 234|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 234|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 256| 234| if (newsize > LUAI_MAXSTACK) /* cannot cross the limit */ ------------------ | | 749| 234|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (256:9): [True: 2, False: 232] ------------------ 257| 2| newsize = LUAI_MAXSTACK; ------------------ | | 749| 2|#define LUAI_MAXSTACK 1000000 ------------------ 258| 234| if (newsize < needed) /* but must respect what was asked for */ ------------------ | Branch (258:9): [True: 14, False: 220] ------------------ 259| 14| newsize = needed; 260| 234| if (l_likely(newsize <= LUAI_MAXSTACK)) ------------------ | | 696| 234|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 684| 234|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (684:25): [True: 233, False: 1] | | | | ------------------ | | ------------------ ------------------ 261| 233| return luaD_reallocstack(L, newsize, raiseerror); 262| 234| } 263| | /* else stack overflow */ 264| | /* add extra size to be able to handle the error message */ 265| 1| luaD_reallocstack(L, ERRORSTACKSIZE, raiseerror); ------------------ | | 199| 1|#define ERRORSTACKSIZE (LUAI_MAXSTACK + 200) | | ------------------ | | | | 749| 1|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ 266| 1| if (raiseerror) ------------------ | Branch (266:7): [True: 1, False: 0] ------------------ 267| 1| luaG_runerror(L, "stack overflow"); 268| 0| return 0; 269| 1|} luaD_shrinkstack: 300| 5.29k|void luaD_shrinkstack (lua_State *L) { 301| 5.29k| int inuse = stackinuse(L); 302| 5.29k| int max = (inuse > LUAI_MAXSTACK / 3) ? LUAI_MAXSTACK : inuse * 3; ------------------ | | 749| 5.29k|#define LUAI_MAXSTACK 1000000 ------------------ int max = (inuse > LUAI_MAXSTACK / 3) ? LUAI_MAXSTACK : inuse * 3; ------------------ | | 749| 1|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (302:13): [True: 1, False: 5.29k] ------------------ 303| | /* if thread is currently not handling a stack overflow and its 304| | size is larger than maximum "reasonable" size, shrink it */ 305| 5.29k| if (inuse <= LUAI_MAXSTACK && stacksize(L) > max) { ------------------ | | 749| 10.5k|#define LUAI_MAXSTACK 1000000 ------------------ if (inuse <= LUAI_MAXSTACK && stacksize(L) > max) { ------------------ | | 147| 5.29k|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 144| 5.29k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 139| 5.29k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (305:7): [True: 5.29k, False: 0] | Branch (305:33): [True: 197, False: 5.09k] ------------------ 306| 197| int nsize = (inuse > LUAI_MAXSTACK / 2) ? LUAI_MAXSTACK : inuse * 2; ------------------ | | 749| 197|#define LUAI_MAXSTACK 1000000 ------------------ int nsize = (inuse > LUAI_MAXSTACK / 2) ? LUAI_MAXSTACK : inuse * 2; ------------------ | | 749| 1|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (306:17): [True: 1, False: 196] ------------------ 307| 197| luaD_reallocstack(L, nsize, 0); /* ok if that fails */ 308| 197| } 309| 5.09k| else /* don't change stack */ 310| 5.09k| condmovestack(L,{},{}); /* (change only for debugging) */ ------------------ | | 369| 5.09k|#define condmovestack(L,pre,pos) ((void)0) ------------------ 311| 5.29k| luaE_shrinkCI(L); /* shrink CI list */ 312| 5.29k|} luaD_inctop: 315| 1.12k|void luaD_inctop (lua_State *L) { 316| 1.12k| luaD_checkstack(L, 1); ------------------ | | 32| 1.12k|#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0) | | ------------------ | | | | 27| 1.12k| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 1.12k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.12k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1.12k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 1.12k| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 1.12k| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 369| 1.12k|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 317| 1.12k| L->top.p++; 318| 1.12k|} luaD_hookcall: 369| 14|void luaD_hookcall (lua_State *L, CallInfo *ci) { 370| 14| L->oldpc = 0; /* set 'oldpc' for new function */ 371| 14| if (L->hookmask & LUA_MASKCALL) { /* is call hook on? */ ------------------ | | 469| 14|#define LUA_MASKCALL (1 << LUA_HOOKCALL) | | ------------------ | | | | 459| 14|#define LUA_HOOKCALL 0 | | ------------------ ------------------ | Branch (371:7): [True: 0, False: 14] ------------------ 372| 0| int event = (ci->callstatus & CIST_TAIL) ? LUA_HOOKTAILCALL ------------------ | | 216| 0|#define CIST_TAIL (1<<5) /* call was tail called */ ------------------ int event = (ci->callstatus & CIST_TAIL) ? LUA_HOOKTAILCALL ------------------ | | 463| 0|#define LUA_HOOKTAILCALL 4 ------------------ | Branch (372:17): [True: 0, False: 0] ------------------ 373| 0| : LUA_HOOKCALL; ------------------ | | 459| 0|#define LUA_HOOKCALL 0 ------------------ 374| 0| Proto *p = ci_func(ci)->p; ------------------ | | 18| 0|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 641| 0|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 375| 0| ci->u.l.savedpc++; /* hooks assume 'pc' is already incremented */ 376| 0| luaD_hook(L, event, -1, 1, p->numparams); 377| 0| ci->u.l.savedpc--; /* correct 'pc' */ 378| 0| } 379| 14|} luaD_poscall: 485| 497k|void luaD_poscall (lua_State *L, CallInfo *ci, int nres) { 486| 497k| int wanted = ci->nresults; 487| 497k| if (l_unlikely(L->hookmask && !hastocloseCfunc(wanted))) ------------------ | | 697| 497k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 497k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 497k] | | | | | Branch (685:46): [True: 0, False: 497k] | | | | | Branch (685:46): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 488| 0| rethook(L, ci, nres); 489| | /* move results to proper place */ 490| 497k| moveresults(L, ci->func.p, nres, wanted); 491| | /* function cannot be in any of these cases when returning */ 492| 497k| lua_assert(!(ci->callstatus & ------------------ | | 109| 497k|#define lua_assert(c) assert(c) ------------------ 493| 497k| (CIST_HOOKED | CIST_YPCALL | CIST_FIN | CIST_TRAN | CIST_CLSRET))); 494| 497k| L->ci = ci->previous; /* back to caller (after closing variables) */ 495| 497k|} luaD_precall: 588| 561k|CallInfo *luaD_precall (lua_State *L, StkId func, int nresults) { 589| 561k| retry: 590| 561k| switch (ttypetag(s2v(func))) { ------------------ | | 84| 561k|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 561k|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 591| 0| case LUA_VCCL: /* C closure */ ------------------ | | 629| 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: 561k] ------------------ 592| 0| precallC(L, func, nresults, clCvalue(s2v(func))->f); ------------------ | | 643| 0|#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 593| 0| return NULL; 594| 243| case LUA_VLCF: /* light C function */ ------------------ | | 628| 243|#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */ | | ------------------ | | | | 42| 243|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (594:5): [True: 243, False: 560k] ------------------ 595| 243| precallC(L, func, nresults, fvalue(s2v(func))); ------------------ | | 642| 243|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 113| 243|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 243|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 596| 0| return NULL; 597| 560k| case LUA_VLCL: { /* Lua function */ ------------------ | | 627| 560k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 560k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (597:5): [True: 560k, False: 246] ------------------ 598| 560k| CallInfo *ci; 599| 1.12M| Proto *p = clLvalue(s2v(func))->p; ------------------ | | 641| 560k|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | ------------------ | | | | 113| 2.24M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 560k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 560k] | | | | | Branch (113:42): [True: 560k, False: 0] | | | | ------------------ | | ------------------ ------------------ 600| 560k| int narg = cast_int(L->top.p - func) - 1; /* number of real arguments */ ------------------ | | 144| 560k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 560k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 601| 1.12M| int nfixparams = p->numparams; 602| 1.12M| int fsize = p->maxstacksize; /* frame size */ 603| 1.12M| checkstackp(L, fsize, func); ------------------ | | 42| 560k| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 560k| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 560k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 560k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 190, False: 560k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 560k| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 560k| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 369| 560k|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 43| 560k| ptrdiff_t t__ = savestack(L, p), /* save 'p' */ \ | | 44| 560k| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 604| 1.12M| L->ci = ci = prepCallInfo(L, func, nresults, 0, func + 1 + fsize); 605| 1.12M| ci->u.l.savedpc = p->code; /* starting point */ 606| 1.34M| for (; narg < nfixparams; narg++) ------------------ | Branch (606:14): [True: 782k, False: 560k] ------------------ 607| 782k| setnilvalue(s2v(L->top.p++)); /* complete missing arguments */ ------------------ | | 211| 782k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 1.34M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 608| 1.12M| lua_assert(ci->top.p <= L->stack_last.p); ------------------ | | 109| 560k|#define lua_assert(c) assert(c) ------------------ 609| 560k| return ci; 610| 1.12M| } 611| 3| default: { /* not a function */ ------------------ | Branch (611:5): [True: 3, False: 561k] ------------------ 612| 3| func = tryfuncTM(L, func); /* try to get '__call' metamethod */ 613| | /* return luaD_precall(L, func, nresults); */ 614| 3| goto retry; /* try again with metamethod */ 615| 1.12M| } 616| 561k| } 617| 561k|} luaD_callnoyield: 654| 405|void luaD_callnoyield (lua_State *L, StkId func, int nResults) { 655| 405| ccall(L, func, nResults, nyci); ------------------ | | 117| 405|#define nyci (0x10000 | 1) ------------------ 656| 405|} luaD_closeprotected: 929| 1.11k|int luaD_closeprotected (lua_State *L, ptrdiff_t level, int status) { 930| 1.11k| CallInfo *old_ci = L->ci; 931| 1.11k| lu_byte old_allowhooks = L->allowhook; 932| 1.11k| for (;;) { /* keep closing upvalues until no more errors */ 933| 1.11k| struct CloseP pcl; 934| 1.11k| pcl.level = restorestack(L, level); pcl.status = status; ------------------ | | 37| 1.11k|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 139| 1.11k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 935| 1.11k| status = luaD_rawrunprotected(L, &closepaux, &pcl); 936| 1.11k| if (l_likely(status == LUA_OK)) /* no more errors? */ ------------------ | | 696| 1.11k|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 684| 1.11k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (684:25): [True: 1.11k, False: 0] | | | | ------------------ | | ------------------ ------------------ 937| 1.11k| return pcl.status; 938| 0| else { /* an error occurred; restore saved state and repeat */ 939| 0| L->ci = old_ci; 940| 0| L->allowhook = old_allowhooks; 941| 0| } 942| 1.11k| } 943| 1.11k|} luaD_pcall: 952| 768| ptrdiff_t old_top, ptrdiff_t ef) { 953| 768| int status; 954| 768| CallInfo *old_ci = L->ci; 955| 768| lu_byte old_allowhooks = L->allowhook; 956| 768| ptrdiff_t old_errfunc = L->errfunc; 957| 768| L->errfunc = ef; 958| 768| status = luaD_rawrunprotected(L, func, u); 959| 768| if (l_unlikely(status != LUA_OK)) { /* an error occurred? */ ------------------ | | 697| 768|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 768|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 552, False: 216] | | | | ------------------ | | ------------------ ------------------ 960| 552| L->ci = old_ci; 961| 552| L->allowhook = old_allowhooks; 962| 552| status = luaD_closeprotected(L, old_top, status); 963| 552| luaD_seterrorobj(L, status, restorestack(L, old_top)); ------------------ | | 37| 552|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 139| 552|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 964| 552| luaD_shrinkstack(L); /* restore stack size in case of overflow */ 965| 552| } 966| 768| L->errfunc = old_errfunc; 967| 768| return status; 968| 768|} luaD_protectedparser: 1016| 561| const char *mode) { 1017| 561| struct SParser p; 1018| 561| int status; 1019| 561| incnny(L); /* cannot yield during parsing */ ------------------ | | 111| 561|#define incnny(L) ((L)->nCcalls += 0x10000) ------------------ 1020| 561| p.z = z; p.name = name; p.mode = mode; 1021| 561| p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0; 1022| 561| p.dyd.gt.arr = NULL; p.dyd.gt.size = 0; 1023| 561| p.dyd.label.arr = NULL; p.dyd.label.size = 0; 1024| 561| luaZ_initbuffer(L, &p.buff); ------------------ | | 29| 561|#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0) ------------------ 1025| 561| status = luaD_pcall(L, f_parser, &p, savestack(L, L->top.p), L->errfunc); ------------------ | | 36| 561|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 561|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 561|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 561|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 561|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1026| 561| luaZ_freebuffer(L, &p.buff); ------------------ | | 44| 561|#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) | | ------------------ | | | | 40| 561| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | | | ------------------ | | | | | | 53| 561| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | | | ------------------ | | | | | | | | 149| 561|#define cast_charp(i) cast(char *, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 561|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 41| 561| (buff)->buffsize, size), \ | | | | 42| 561| (buff)->buffsize = size) | | ------------------ ------------------ 1027| 561| luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size); ------------------ | | 57| 561|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1028| 561| luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size); ------------------ | | 57| 561|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1029| 561| luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size); ------------------ | | 57| 561|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1030| 561| decnny(L); ------------------ | | 114| 561|#define decnny(L) ((L)->nCcalls -= 0x10000) ------------------ 1031| 561| return status; 1032| 561|} ldo.c:relstack: 165| 431|static void relstack (lua_State *L) { 166| 431| CallInfo *ci; 167| 431| UpVal *up; 168| 431| L->top.offset = savestack(L, L->top.p); ------------------ | | 36| 431|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 431|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 431|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 431|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 431|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 169| 431| L->tbclist.offset = savestack(L, L->tbclist.p); ------------------ | | 36| 431|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 431|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 431|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 431|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 431|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 170| 1.14k| for (up = L->openupval; up != NULL; up = up->u.open.next) ------------------ | Branch (170:27): [True: 714, False: 431] ------------------ 171| 714| up->v.offset = savestack(L, uplevel(up)); ------------------ | | 36| 714|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 714|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 2.85k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (139:27): [True: 0, False: 714] | | | | | | | Branch (139:27): [True: 714, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 714|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 714|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 172| 5.99k| for (ci = L->ci; ci != NULL; ci = ci->previous) { ------------------ | Branch (172:20): [True: 5.56k, False: 431] ------------------ 173| 5.56k| ci->top.offset = savestack(L, ci->top.p); ------------------ | | 36| 5.56k|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 5.56k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 5.56k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 5.56k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 5.56k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 174| 5.56k| ci->func.offset = savestack(L, ci->func.p); ------------------ | | 36| 5.56k|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 5.56k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 5.56k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 5.56k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 5.56k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 175| 5.56k| } 176| 431|} ldo.c:correctstack: 182| 431|static void correctstack (lua_State *L) { 183| 431| CallInfo *ci; 184| 431| UpVal *up; 185| 431| L->top.p = restorestack(L, L->top.offset); ------------------ | | 37| 431|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 139| 431|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 186| 431| L->tbclist.p = restorestack(L, L->tbclist.offset); ------------------ | | 37| 431|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 139| 431|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 187| 1.14k| for (up = L->openupval; up != NULL; up = up->u.open.next) ------------------ | Branch (187:27): [True: 714, False: 431] ------------------ 188| 714| up->v.p = s2v(restorestack(L, up->v.offset)); ------------------ | | 172| 714|#define s2v(o) (&(o)->val) ------------------ 189| 5.99k| for (ci = L->ci; ci != NULL; ci = ci->previous) { ------------------ | Branch (189:20): [True: 5.56k, False: 431] ------------------ 190| 5.56k| ci->top.p = restorestack(L, ci->top.offset); ------------------ | | 37| 5.56k|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 139| 5.56k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 191| 5.56k| ci->func.p = restorestack(L, ci->func.offset); ------------------ | | 37| 5.56k|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 139| 5.56k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 192| 5.56k| if (isLua(ci)) ------------------ | | 242| 5.56k|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 212| 5.56k|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (242:19): [True: 5.13k, False: 432] | | ------------------ ------------------ 193| 5.13k| ci->u.l.trap = 1; /* signal to update 'trap' in 'luaV_execute' */ 194| 5.56k| } 195| 431|} ldo.c:stackinuse: 276| 5.29k|static int stackinuse (lua_State *L) { 277| 5.29k| CallInfo *ci; 278| 5.29k| int res; 279| 5.29k| StkId lim = L->top.p; 280| 18.4k| for (ci = L->ci; ci != NULL; ci = ci->previous) { ------------------ | Branch (280:20): [True: 13.1k, False: 5.29k] ------------------ 281| 13.1k| if (lim < ci->top.p) lim = ci->top.p; ------------------ | Branch (281:9): [True: 6.06k, False: 7.10k] ------------------ 282| 13.1k| } 283| 5.29k| lua_assert(lim <= L->stack_last.p + EXTRA_STACK); ------------------ | | 109| 5.29k|#define lua_assert(c) assert(c) ------------------ 284| 5.29k| res = cast_int(lim - L->stack.p) + 1; /* part of stack in use */ ------------------ | | 144| 5.29k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 5.29k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 285| 5.29k| if (res < LUA_MINSTACK) ------------------ | | 79| 5.29k|#define LUA_MINSTACK 20 ------------------ | Branch (285:7): [True: 0, False: 5.29k] ------------------ 286| 0| res = LUA_MINSTACK; /* ensure a minimum size */ ------------------ | | 79| 0|#define LUA_MINSTACK 20 ------------------ 287| 5.29k| return res; 288| 5.29k|} ldo.c:moveresults: 433| 497k|l_sinline void moveresults (lua_State *L, StkId res, int nres, int wanted) { 434| 497k| StkId firstresult; 435| 497k| int i; 436| 497k| switch (wanted) { /* handle typical cases separately */ 437| 497k| case 0: /* no values needed */ ------------------ | Branch (437:5): [True: 497k, False: 153] ------------------ 438| 497k| L->top.p = res; 439| 497k| return; 440| 108| case 1: /* one value needed */ ------------------ | Branch (440:5): [True: 108, False: 497k] ------------------ 441| 108| if (nres == 0) /* no results? */ ------------------ | Branch (441:11): [True: 0, False: 108] ------------------ 442| 108| setnilvalue(s2v(res)); /* adjust with nil */ ------------------ | | 211| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 443| 108| else /* at least one result */ 444| 108| setobjs2s(L, res, L->top.p - nres); /* move it to proper place */ ------------------ | | 129| 108|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 108| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 108| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 108|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 108| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 108| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 1.72k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 108|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 108] | | | | | | | | | Branch (115:29): [True: 108, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 108] | | | | | | | | | Branch (115:29): [True: 108, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 108] | | | | | | | | | Branch (115:29): [True: 108, False: 0] | | | | | | | | | Branch (115:29): [True: 108, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 108] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 108| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 108|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 445| 108| L->top.p = res + 1; 446| 108| return; 447| 0| case LUA_MULTRET: ------------------ | | 35| 0|#define LUA_MULTRET (-1) ------------------ | Branch (447:5): [True: 0, False: 497k] ------------------ 448| 0| wanted = nres; /* we want all results */ 449| 0| break; 450| 45| default: /* two/more results and/or to-be-closed variables */ ------------------ | Branch (450:5): [True: 45, False: 497k] ------------------ 451| 45| if (hastocloseCfunc(wanted)) { /* to-be-closed variables? */ ------------------ | | 55| 45|#define hastocloseCfunc(n) ((n) < LUA_MULTRET) | | ------------------ | | | | 35| 45|#define LUA_MULTRET (-1) | | ------------------ | | | Branch (55:28): [True: 45, False: 0] | | ------------------ ------------------ 452| 45| L->ci->callstatus |= CIST_CLSRET; /* in case of yields */ ------------------ | | 220| 45|#define CIST_CLSRET (1<<9) /* function is closing tbc variables */ ------------------ 453| 45| L->ci->u2.nres = nres; 454| 45| res = luaF_close(L, res, CLOSEKTOP, 1); ------------------ | | 47| 45|#define CLOSEKTOP (-1) ------------------ 455| 45| L->ci->callstatus &= ~CIST_CLSRET; ------------------ | | 220| 45|#define CIST_CLSRET (1<<9) /* function is closing tbc variables */ ------------------ 456| 45| if (L->hookmask) { /* if needed, call hook after '__close's */ ------------------ | Branch (456:13): [True: 0, False: 45] ------------------ 457| 0| ptrdiff_t savedres = savestack(L, res); ------------------ | | 36| 0|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 0|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 0|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 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)) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 460| 0| } 461| 45| wanted = decodeNresults(wanted); ------------------ | | 59| 45|#define decodeNresults(n) (-(n) - 3) ------------------ 462| 45| if (wanted == LUA_MULTRET) ------------------ | | 35| 45|#define LUA_MULTRET (-1) ------------------ | Branch (462:13): [True: 0, False: 45] ------------------ 463| 0| wanted = nres; /* we want all results */ 464| 45| } 465| 45| break; 466| 497k| } 467| | /* generic case */ 468| 45| firstresult = L->top.p - nres; /* index of first result */ 469| 45| if (nres > wanted) /* extra results? */ ------------------ | Branch (469:7): [True: 0, False: 45] ------------------ 470| 0| nres = wanted; /* don't need them */ 471| 90| for (i = 0; i < nres; i++) /* move all results to correct place */ ------------------ | Branch (471:15): [True: 45, False: 45] ------------------ 472| 45| setobjs2s(L, res + i, firstresult + i); ------------------ | | 129| 45|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 90| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 90| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 90| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 45| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 720|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 45| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 473| 45| for (; i < wanted; i++) /* complete wanted number of results */ ------------------ | Branch (473:10): [True: 0, False: 45] ------------------ 474| 45| setnilvalue(s2v(res + i)); ------------------ | | 211| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 475| 45| L->top.p = res + wanted; /* top points after the last result */ 476| 45|} ldo.c:precallC: 517| 243| lua_CFunction f) { 518| 243| int n; /* number of returns */ 519| 243| CallInfo *ci; 520| 243| checkstackp(L, LUA_MINSTACK, func); /* ensure minimum stack size */ ------------------ | | 42| 243| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 243| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 243|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 243|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 15, False: 228] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 243| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 243| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 369| 228|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 43| 243| ptrdiff_t t__ = savestack(L, p), /* save 'p' */ \ | | 44| 243| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 521| 243| L->ci = ci = prepCallInfo(L, func, nresults, CIST_C, ------------------ | | 212| 243|#define CIST_C (1<<1) /* call is running a C function */ ------------------ 522| 243| L->top.p + LUA_MINSTACK); ------------------ | | 79| 243|#define LUA_MINSTACK 20 ------------------ 523| 243| lua_assert(ci->top.p <= L->stack_last.p); ------------------ | | 109| 243|#define lua_assert(c) assert(c) ------------------ 524| 243| if (l_unlikely(L->hookmask & LUA_MASKCALL)) { ------------------ | | 697| 243|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 243|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 243] | | | | ------------------ | | ------------------ ------------------ 525| 0| int narg = cast_int(L->top.p - func) - 1; ------------------ | | 144| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 526| 0| luaD_hook(L, LUA_HOOKCALL, -1, 1, narg); ------------------ | | 459| 0|#define LUA_HOOKCALL 0 ------------------ 527| 0| } 528| 243| lua_unlock(L); ------------------ | | 268| 243|#define lua_unlock(L) ((void) 0) ------------------ 529| 243| n = (*f)(L); /* do the actual call */ 530| 243| lua_lock(L); ------------------ | | 267| 243|#define lua_lock(L) ((void) 0) ------------------ 531| 243| api_checknelems(L, n); ------------------ | | 32| 243| api_check(L, (n) < (L->top.p - L->ci->func.p), \ | | ------------------ | | | | 129| 243|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 727| 243|#define luai_apicheck(l,e) assert(e) | | | | ------------------ | | ------------------ | | 33| 243| "not enough elements in the stack") ------------------ 532| 243| luaD_poscall(L, ci, n); 533| 243| return n; 534| 243|} ldo.c:tryfuncTM: 412| 3|static StkId tryfuncTM (lua_State *L, StkId func) { 413| 3| const TValue *tm; 414| 3| StkId p; 415| 3| checkstackp(L, 1, func); /* space for metamethod */ ------------------ | | 42| 3| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 3| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 3| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 3| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 369| 3|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 43| 3| ptrdiff_t t__ = savestack(L, p), /* save 'p' */ \ | | 44| 3| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 416| 3| tm = luaT_gettmbyobj(L, s2v(func), TM_CALL); /* (after previous GC) */ ------------------ | | 172| 3|#define s2v(o) (&(o)->val) ------------------ 417| 3| if (l_unlikely(ttisnil(tm))) ------------------ | | 697| 3|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 3|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 3, False: 0] | | | | ------------------ | | ------------------ ------------------ 418| 3| luaG_callerror(L, s2v(func)); /* nothing to call */ ------------------ | | 172| 3|#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) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 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) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 423| 0| return func; 424| 0|} ldo.c:prepCallInfo: 503| 561k| int mask, StkId top) { 504| 561k| CallInfo *ci = L->ci = next_ci(L); /* new frame */ ------------------ | | 499| 561k|#define next_ci(L) (L->ci->next ? L->ci->next : luaE_extendCI(L)) | | ------------------ | | | Branch (499:22): [True: 559k, False: 1.40k] | | ------------------ ------------------ 505| 561k| ci->func.p = func; 506| 561k| ci->nresults = nret; 507| 561k| ci->callstatus = mask; 508| 561k| ci->top.p = top; 509| 561k| return ci; 510| 561k|} ldo.c:ccall: 628| 405|l_sinline void ccall (lua_State *L, StkId func, int nResults, l_uint32 inc) { 629| 405| CallInfo *ci; 630| 405| L->nCcalls += inc; 631| 405| if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) { ------------------ | | 697| 405|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 405|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 405] | | | | ------------------ | | ------------------ ------------------ 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); } | | | | ------------------ | | | | | | 369| 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| 405| if ((ci = luaD_precall(L, func, nResults)) != NULL) { /* Lua function? */ ------------------ | Branch (635:7): [True: 162, False: 243] ------------------ 636| 162| ci->callstatus = CIST_FRESH; /* mark that it is a "fresh" execute */ ------------------ | | 213| 162|#define CIST_FRESH (1<<2) /* call is on a fresh "luaV_execute" frame */ ------------------ 637| 162| luaV_execute(L, ci); /* call it */ 638| 162| } 639| 405| L->nCcalls -= inc; 640| 405|} ldo.c:closepaux: 919| 1.11k|static void closepaux (lua_State *L, void *ud) { 920| 1.11k| struct CloseP *pcl = cast(struct CloseP *, ud); ------------------ | | 139| 1.11k|#define cast(t, exp) ((t)(exp)) ------------------ 921| 1.11k| luaF_close(L, pcl->level, pcl->status, 0); 922| 1.11k|} ldo.c:f_parser: 993| 561|static void f_parser (lua_State *L, void *ud) { 994| 561| LClosure *cl; 995| 561| struct SParser *p = cast(struct SParser *, ud); ------------------ | | 139| 561|#define cast(t, exp) ((t)(exp)) ------------------ 996| 561| const char *mode = p->mode ? p->mode : "bt"; ------------------ | Branch (996:22): [True: 561, False: 0] ------------------ 997| 561| int c = zgetc(p->z); /* read first character */ ------------------ | | 20| 561|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | ------------------ | | | | 147| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | | Branch (20:20): [True: 0, False: 561] | | ------------------ ------------------ 998| 561| if (c == LUA_SIGNATURE[0]) { ------------------ | | 32| 561|#define LUA_SIGNATURE "\x1bLua" ------------------ | Branch (998:7): [True: 0, False: 561] ------------------ 999| 0| int fixed = 0; 1000| 0| if (strchr(mode, 'B') != NULL) ------------------ | Branch (1000:9): [True: 0, False: 0] ------------------ 1001| 0| fixed = 1; 1002| 0| else 1003| 0| checkmode(L, mode, "binary"); 1004| 0| cl = luaU_undump(L, p->z, p->name, fixed); 1005| 0| } 1006| 561| else { 1007| 561| checkmode(L, mode, "text"); 1008| 561| cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c); 1009| 561| } 1010| 561| lua_assert(cl->nupvalues == cl->p->sizeupvalues); ------------------ | | 109| 561|#define lua_assert(c) assert(c) ------------------ 1011| 162| luaF_initupvals(L, cl); 1012| 162|} ldo.c:checkmode: 984| 561|static void checkmode (lua_State *L, const char *mode, const char *x) { 985| 561| if (strchr(mode, x[0]) == NULL) { ------------------ | Branch (985:7): [True: 0, False: 561] ------------------ 986| 0| luaO_pushfstring(L, 987| 0| "attempt to load a %s chunk (mode is '%s')", x, mode); 988| 0| luaD_throw(L, LUA_ERRSYNTAX); ------------------ | | 51| 0|#define LUA_ERRSYNTAX 3 ------------------ 989| 0| } 990| 561|} luaF_newLclosure: 35| 1.07M|LClosure *luaF_newLclosure (lua_State *L, int nupvals) { 36| 1.07M| GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals)); ------------------ | | 627| 1.07M|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 1.07M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals)); ------------------ | | 17| 1.07M|#define sizeLclosure(n) (cast_int(offsetof(LClosure, upvals)) + \ | | ------------------ | | | | 144| 1.07M|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 139| 1.07M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 18| 1.07M| cast_int(sizeof(TValue *)) * (n)) | | ------------------ | | | | 144| 1.07M|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 139| 1.07M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 37| 1.07M| LClosure *c = gco2lcl(o); ------------------ | | 374| 1.07M|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 113| 1.07M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 1.07M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 38| 0| c->p = NULL; 39| 1.07M| c->nupvalues = cast_byte(nupvals); ------------------ | | 146| 1.07M|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 139| 1.07M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 40| 4.24M| while (nupvals--) c->upvals[nupvals] = NULL; ------------------ | Branch (40:10): [True: 3.16M, False: 1.07M] ------------------ 41| 1.07M| return c; 42| 1.07M|} luaF_initupvals: 48| 162|void luaF_initupvals (lua_State *L, LClosure *cl) { 49| 162| int i; 50| 324| for (i = 0; i < cl->nupvalues; i++) { ------------------ | Branch (50:15): [True: 162, False: 162] ------------------ 51| 162| GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal)); ------------------ | | 623| 162|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 162|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 52| 162| UpVal *uv = gco2upv(o); ------------------ | | 381| 162|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 113| 162|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 162|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 53| 0| uv->v.p = &uv->u.value; /* make it closed */ 54| 162| setnilvalue(uv->v.p); ------------------ | | 211| 162|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 162|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 55| 162| cl->upvals[i] = uv; 56| 162| luaC_objbarrier(L, cl, uv); ------------------ | | 222| 162|#define luaC_objbarrier(L,p,o) ( \ | | 223| 162| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 91| 162|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 70| 162|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 65| 324|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 12, False: 150] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 90| 12|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 12|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 12, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 224| 162| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 12|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 12|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 12|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 12|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 12|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 12|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 141| 150|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 150|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 57| 162| } 58| 162|} luaF_findupval: 87| 1.57M|UpVal *luaF_findupval (lua_State *L, StkId level) { 88| 1.57M| UpVal **pp = &L->openupval; 89| 1.57M| UpVal *p; 90| 1.57M| lua_assert(isintwups(L) || L->openupval == NULL); ------------------ | | 109| 1.57M|#define lua_assert(c) assert(c) ------------------ 91| 60.2M| while ((p = *pp) != NULL && uplevel(p) >= level) { /* search for it */ ------------------ | | 35| 30.1M|#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p)) | | ------------------ | | | | 113| 30.1M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 30.1M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (91:10): [True: 30.1M, False: 14.5k] | Branch (91:31): [True: 29.1M, False: 1.00M] ------------------ 92| 29.1M| lua_assert(!isdead(G(L), p)); ------------------ | | 109| 29.1M|#define lua_assert(c) assert(c) ------------------ 93| 58.2M| if (uplevel(p) == level) /* corresponding upvalue? */ ------------------ | | 35| 29.1M|#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p)) | | ------------------ | | | | 113| 29.1M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 29.1M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (93:9): [True: 551k, False: 28.5M] ------------------ 94| 551k| return p; /* return it */ 95| 28.5M| pp = &p->u.open.next; 96| 28.5M| } 97| | /* not found: create a new upvalue after 'pp' */ 98| 1.02M| return newupval(L, level, pp); 99| 1.57M|} luaF_newtbcupval: 168| 45|void luaF_newtbcupval (lua_State *L, StkId level) { 169| 45| lua_assert(level > L->tbclist.p); ------------------ | | 109| 45|#define lua_assert(c) assert(c) ------------------ 170| 45| if (l_isfalse(s2v(level))) ------------------ | | 258| 45|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 254| 45|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 90|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 45|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 45] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 196| 45|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 45|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 45|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 45|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 45] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 171| 0| return; /* false doesn't need to be closed */ 172| 45| checkclosemth(L, level); /* value must have a close method */ 173| 45| while (cast_uint(level - L->tbclist.p) > MAXDELTA) { ------------------ | | 145| 45|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 139| 45|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ while (cast_uint(level - L->tbclist.p) > MAXDELTA) { ------------------ | | 162| 45| ((256ul << ((sizeof(L->stack.p->tbclist.delta) - 1) * 8)) - 1) ------------------ | Branch (173:10): [True: 0, False: 45] ------------------ 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| 45| level->tbclist.delta = cast(unsigned short, level - L->tbclist.p); ------------------ | | 139| 45|#define cast(t, exp) ((t)(exp)) ------------------ 178| 45| L->tbclist.p = level; 179| 45|} luaF_unlinkupval: 182| 1.02M|void luaF_unlinkupval (UpVal *uv) { 183| 1.02M| lua_assert(upisopen(uv)); ------------------ | | 109| 1.02M|#define lua_assert(c) assert(c) ------------------ 184| 1.02M| *uv->u.open.previous = uv->u.open.next; 185| 1.02M| if (uv->u.open.next) ------------------ | Branch (185:7): [True: 1.01M, False: 7.45k] ------------------ 186| 1.01M| uv->u.open.next->u.open.previous = uv->u.open.previous; 187| 1.02M|} luaF_closeupval: 193| 512k|void luaF_closeupval (lua_State *L, StkId level) { 194| 512k| UpVal *uv; 195| 512k| StkId upl; /* stack index pointed by 'uv' */ 196| 1.53M| while ((uv = L->openupval) != NULL && (upl = uplevel(uv)) >= level) { ------------------ | | 35| 1.52M|#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p)) | | ------------------ | | | | 113| 1.52M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 1.52M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (196:10): [True: 1.52M, False: 8.66k] | Branch (196:41): [True: 1.02M, False: 503k] ------------------ 197| 1.02M| TValue *slot = &uv->u.value; /* new position for value */ 198| 1.02M| lua_assert(uplevel(uv) < L->top.p); ------------------ | | 109| 1.02M|#define lua_assert(c) assert(c) ------------------ 199| 1.02M| luaF_unlinkupval(uv); /* remove upvalue from 'openupval' list */ 200| 1.02M| setobj(L, slot, uv->v.p); /* move value to upvalue slot */ ------------------ | | 119| 1.02M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 1.02M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 1.02M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 1.02M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 1.02M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 8.76M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 1.02M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 516k] | | | | | | | Branch (115:29): [True: 516k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 516k] | | | | | | | Branch (115:29): [True: 516k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 516k] | | | | | | | Branch (115:29): [True: 516k, False: 0] | | | | | | | Branch (115:29): [True: 516k, False: 0] | | | | | | | Branch (115:29): [True: 504k, False: 516k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 1.02M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 109| 1.02M|#define lua_assert(c) assert(c) | | ------------------ ------------------ 201| 1.02M| uv->v.p = slot; /* now current value lives here */ 202| 1.02M| if (!iswhite(uv)) { /* neither white nor dead? */ ------------------ | | 90| 1.02M|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 65| 1.02M|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (202:9): [True: 57.6k, False: 962k] ------------------ 203| 57.6k| nw2black(uv); /* closed upvalues cannot be gray */ ------------------ | | 103| 57.6k| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 113| 57.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 57.6k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 204| 57.6k| luaC_barrier(L, uv, slot); ------------------ | | 226| 57.6k|#define luaC_barrier(L,p,v) ( \ | | 227| 57.6k| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 313| 57.6k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 57.6k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 311| 57.6k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (313:26): [True: 56.8k, False: 848] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 222| 56.8k|#define luaC_objbarrier(L,p,o) ( \ | | | | 223| 56.8k| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 91| 56.8k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 70| 56.8k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 65| 113k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (65:24): [True: 56.8k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 90| 56.8k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 227k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 28, False: 56.7k] | | | | | | | | | Branch (65:26): [True: 0, False: 56.8k] | | | | | | | | | Branch (65:26): [True: 56.8k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 224| 56.8k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 388| 28|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 28|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 28|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 388| 28|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 112|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 28|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (113:42): [True: 0, False: 28] | | | | | | | | | Branch (113:42): [True: 28, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 141| 56.7k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 139| 56.7k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 141| 848|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 848|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 205| 57.6k| } 206| 1.02M| } 207| 512k|} luaF_close: 227| 512k|StkId luaF_close (lua_State *L, StkId level, int status, int yy) { 228| 512k| ptrdiff_t levelrel = savestack(L, level); ------------------ | | 36| 512k|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 512k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 512k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 512k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 512k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 229| 512k| luaF_closeupval(L, level); /* first, close the upvalues */ 230| 512k| while (L->tbclist.p >= level) { /* traverse tbc's down to that level */ ------------------ | Branch (230:10): [True: 45, False: 512k] ------------------ 231| 45| StkId tbc = L->tbclist.p; /* get variable index */ 232| 45| poptbclist(L); /* remove it from list */ 233| 45| prepcallclosemth(L, tbc, status, yy); /* close variable */ 234| 45| level = restorestack(L, levelrel); ------------------ | | 37| 45|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 139| 45|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 235| 45| } 236| 512k| return level; 237| 512k|} luaF_newproto: 240| 21.7k|Proto *luaF_newproto (lua_State *L) { 241| 21.7k| GCObject *o = luaC_newobj(L, LUA_VPROTO, sizeof(Proto)); ------------------ | | 538| 21.7k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 21.7k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 242| 21.7k| Proto *f = gco2p(o); ------------------ | | 379| 21.7k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 113| 21.7k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 21.7k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 243| 0| f->k = NULL; 244| 21.7k| f->sizek = 0; 245| 21.7k| f->p = NULL; 246| 21.7k| f->sizep = 0; 247| 21.7k| f->code = NULL; 248| 21.7k| f->sizecode = 0; 249| 21.7k| f->lineinfo = NULL; 250| 21.7k| f->sizelineinfo = 0; 251| 21.7k| f->abslineinfo = NULL; 252| 21.7k| f->sizeabslineinfo = 0; 253| 21.7k| f->upvalues = NULL; 254| 21.7k| f->sizeupvalues = 0; 255| 21.7k| f->numparams = 0; 256| 21.7k| f->flag = 0; 257| 21.7k| f->maxstacksize = 0; 258| 21.7k| f->locvars = NULL; 259| 21.7k| f->sizelocvars = 0; 260| 21.7k| f->linedefined = 0; 261| 21.7k| f->lastlinedefined = 0; 262| 21.7k| f->source = NULL; 263| 21.7k| return f; 264| 21.7k|} luaF_freeproto: 267| 21.7k|void luaF_freeproto (lua_State *L, Proto *f) { 268| 21.7k| if (!(f->flag & PF_FIXED)) { ------------------ | | 583| 21.7k|#define PF_FIXED 2 /* prototype has parts in fixed memory */ ------------------ | Branch (268:7): [True: 21.7k, False: 0] ------------------ 269| 21.7k| luaM_freearray(L, f->code, f->sizecode); ------------------ | | 57| 21.7k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 270| 21.7k| luaM_freearray(L, f->lineinfo, f->sizelineinfo); ------------------ | | 57| 21.7k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 271| 21.7k| luaM_freearray(L, f->abslineinfo, f->sizeabslineinfo); ------------------ | | 57| 21.7k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 272| 21.7k| } 273| 21.7k| luaM_freearray(L, f->p, f->sizep); ------------------ | | 57| 21.7k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 274| 21.7k| luaM_freearray(L, f->k, f->sizek); ------------------ | | 57| 21.7k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 275| 21.7k| luaM_freearray(L, f->locvars, f->sizelocvars); ------------------ | | 57| 21.7k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 276| 21.7k| luaM_freearray(L, f->upvalues, f->sizeupvalues); ------------------ | | 57| 21.7k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 277| 21.7k| luaM_free(L, f); ------------------ | | 56| 21.7k|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 278| 21.7k|} luaF_getlocalname: 285| 195|const char *luaF_getlocalname (const Proto *f, int local_number, int pc) { 286| 195| int i; 287| 11.5k| for (i = 0; isizelocvars && f->locvars[i].startpc <= pc; i++) { ------------------ | Branch (287:15): [True: 11.4k, False: 176] | Branch (287:35): [True: 11.3k, False: 15] ------------------ 288| 11.3k| if (pc < f->locvars[i].endpc) { /* is variable active? */ ------------------ | Branch (288:9): [True: 1.22k, False: 10.1k] ------------------ 289| 1.22k| local_number--; 290| 1.22k| if (local_number == 0) ------------------ | Branch (290:11): [True: 4, False: 1.22k] ------------------ 291| 4| return getstr(f->locvars[i].varname); ------------------ | | 430| 4|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 4|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 4, False: 0] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 4|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 4|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 4|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 292| 1.22k| } 293| 11.3k| } 294| 191| return NULL; /* not found */ 295| 195|} lfunc.c:newupval: 65| 1.02M|static UpVal *newupval (lua_State *L, StkId level, UpVal **prev) { 66| 1.02M| GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal)); ------------------ | | 623| 1.02M|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 1.02M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 67| 1.02M| UpVal *uv = gco2upv(o); ------------------ | | 381| 1.02M|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 113| 1.02M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 1.02M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 68| 0| UpVal *next = *prev; 69| 1.02M| uv->v.p = s2v(level); /* current value lives in the stack */ ------------------ | | 172| 1.02M|#define s2v(o) (&(o)->val) ------------------ 70| 1.02M| uv->u.open.next = next; /* link it to list of open upvalues */ 71| 1.02M| uv->u.open.previous = prev; 72| 1.02M| if (next) ------------------ | Branch (72:7): [True: 1.00M, False: 14.5k] ------------------ 73| 1.00M| next->u.open.previous = &uv->u.open.next; 74| 1.02M| *prev = uv; 75| 1.02M| if (!isintwups(L)) { /* thread not in list of threads with upvalues? */ ------------------ | | 22| 1.02M|#define isintwups(L) (L->twups != L) ------------------ | Branch (75:7): [True: 19, False: 1.02M] ------------------ 76| 19| L->twups = G(L)->twups; /* link it to the list */ ------------------ | | 333| 19|#define G(L) (L->l_G) ------------------ 77| 19| G(L)->twups = L; ------------------ | | 333| 19|#define G(L) (L->l_G) ------------------ 78| 19| } 79| 1.02M| return uv; 80| 1.02M|} lfunc.c:checkclosemth: 125| 45|static void checkclosemth (lua_State *L, StkId level) { 126| 45| const TValue *tm = luaT_gettmbyobj(L, s2v(level), TM_CLOSE); ------------------ | | 172| 45|#define s2v(o) (&(o)->val) ------------------ 127| 45| if (ttisnil(tm)) { /* no metamethod? */ ------------------ | | 196| 45|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 45|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 45|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 45|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 45] | | | | ------------------ | | ------------------ ------------------ 128| 0| int idx = cast_int(level - L->ci->func.p); /* variable index */ ------------------ | | 144| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 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| 45|} lfunc.c:poptbclist: 213| 45|static void poptbclist (lua_State *L) { 214| 45| StkId tbc = L->tbclist.p; 215| 45| lua_assert(tbc->tbclist.delta > 0); /* first element cannot be dummy */ ------------------ | | 109| 45|#define lua_assert(c) assert(c) ------------------ 216| 45| tbc -= tbc->tbclist.delta; 217| 45| while (tbc > L->stack.p && tbc->tbclist.delta == 0) ------------------ | Branch (217:10): [True: 0, False: 45] | Branch (217:30): [True: 0, False: 0] ------------------ 218| 0| tbc -= MAXDELTA; /* remove dummy nodes */ ------------------ | | 162| 45| ((256ul << ((sizeof(L->stack.p->tbclist.delta) - 1) * 8)) - 1) ------------------ 219| 45| L->tbclist.p = tbc; 220| 45|} lfunc.c:prepcallclosemth: 143| 45|static void prepcallclosemth (lua_State *L, StkId level, int status, int yy) { 144| 45| TValue *uv = s2v(level); /* value being closed */ ------------------ | | 172| 45|#define s2v(o) (&(o)->val) ------------------ 145| 45| TValue *errobj; 146| 45| if (status == CLOSEKTOP) ------------------ | | 47| 45|#define CLOSEKTOP (-1) ------------------ | Branch (146:7): [True: 45, False: 0] ------------------ 147| 45| errobj = &G(L)->nilvalue; /* error object is nil */ ------------------ | | 333| 45|#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| 45| callclosemethod(L, uv, errobj, yy); 153| 45|} lfunc.c:callclosemethod: 107| 45|static void callclosemethod (lua_State *L, TValue *obj, TValue *err, int yy) { 108| 45| StkId top = L->top.p; 109| 45| const TValue *tm = luaT_gettmbyobj(L, obj, TM_CLOSE); 110| 45| setobj2s(L, top, tm); /* will call metamethod... */ ------------------ | | 131| 45|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 45| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 45| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 45| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 45| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 45|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 45| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 111| 45| setobj2s(L, top + 1, obj); /* with 'self' as the 1st argument */ ------------------ | | 131| 45|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 45| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 45| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 45| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 45| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 720|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 45| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 112| 45| setobj2s(L, top + 2, err); /* and error msg. as 2nd argument */ ------------------ | | 131| 45|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 45| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 45| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 45| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 45| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 45|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 45| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 113| 45| L->top.p = top + 3; /* add function and arguments */ 114| 45| if (yy) ------------------ | Branch (114:7): [True: 0, False: 45] ------------------ 115| 0| luaD_call(L, top, 0); 116| 45| else 117| 45| luaD_callnoyield(L, top, 0); 118| 45|} luaC_barrier_: 198| 17.0k|void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v) { 199| 17.0k| global_State *g = G(L); ------------------ | | 333| 17.0k|#define G(L) (L->l_G) ------------------ 200| 17.0k| lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o)); ------------------ | | 109| 17.0k|#define lua_assert(c) assert(c) ------------------ 201| 17.0k| if (keepinvariant(g)) { /* must keep invariant? */ ------------------ | | 57| 17.0k|#define keepinvariant(g) ((g)->gcstate <= GCSatomic) | | ------------------ | | | | 36| 17.0k|#define GCSatomic 2 | | ------------------ | | | Branch (57:26): [True: 16.9k, False: 99] | | ------------------ ------------------ 202| 16.9k| reallymarkobject(g, v); /* restore invariant */ 203| 16.9k| if (isold(o)) { ------------------ | | 121| 16.9k|#define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 119| 16.9k|#define getage(o) ((o)->marked & AGEBITS) | | | | ------------------ | | | | | | 117| 16.9k|#define AGEBITS 7 /* all age bits (111) */ | | | | ------------------ | | ------------------ | | #define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 110| 16.9k|#define G_SURVIVAL 1 /* created in previous cycle */ | | ------------------ | | | Branch (121:18): [True: 0, False: 16.9k] | | ------------------ ------------------ 204| 0| lua_assert(!isold(v)); /* white object could not be old */ ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ 205| 0| setage(v, G_OLD0); /* restore generational invariant */ ------------------ | | 120| 0|#define setage(o,a) ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a)) | | ------------------ | | | | 146| 0|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 206| 0| } 207| 16.9k| } 208| 99| else { /* sweep phase */ 209| 99| lua_assert(issweepphase(g)); ------------------ | | 109| 99|#define lua_assert(c) assert(c) ------------------ 210| 99| if (g->gckind != KGC_GENMINOR) /* incremental mode? */ ------------------ | | 152| 99|#define KGC_GENMINOR 1 /* generational gc in minor (regular) mode */ ------------------ | Branch (210:9): [True: 99, False: 0] ------------------ 211| 99| makewhite(g, o); /* mark 'o' as white to avoid other barriers */ ------------------ | | 54| 99| (x->marked = cast_byte((x->marked & ~maskcolors) | luaC_white(g))) | | ------------------ | | | | 146| 99|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 99|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 212| 99| } 213| 17.0k|} luaC_barrierback_: 220| 1.15k|void luaC_barrierback_ (lua_State *L, GCObject *o) { 221| 1.15k| global_State *g = G(L); ------------------ | | 333| 1.15k|#define G(L) (L->l_G) ------------------ 222| 1.15k| lua_assert(isblack(o) && !isdead(g, o)); ------------------ | | 109| 1.15k|#define lua_assert(c) assert(c) ------------------ 223| 1.15k| lua_assert((g->gckind != KGC_GENMINOR) ------------------ | | 109| 1.15k|#define lua_assert(c) assert(c) ------------------ 224| 1.15k| || (isold(o) && getage(o) != G_TOUCHED1)); 225| 1.15k| if (getage(o) == G_TOUCHED2) /* already in gray list? */ ------------------ | | 119| 1.15k|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 117| 1.15k|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ if (getage(o) == G_TOUCHED2) /* already in gray list? */ ------------------ | | 115| 1.15k|#define G_TOUCHED2 6 /* old object touched in previous cycle */ ------------------ | Branch (225:7): [True: 0, False: 1.15k] ------------------ 226| 1.15k| set2gray(o); /* make it gray to become touched1 */ ------------------ | | 57| 0|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 63| 0|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 146| 0|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 227| 1.15k| else /* link it in 'grayagain' and paint it gray */ 228| 1.15k| linkobjgclist(o, g->grayagain); ------------------ | | 149| 1.15k|#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p)) | | ------------------ | | | | 388| 1.15k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 1.15k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 1.15k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 229| 1.15k| if (isold(o)) /* generational mode? */ ------------------ | | 121| 1.15k|#define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 119| 1.15k|#define getage(o) ((o)->marked & AGEBITS) | | | | ------------------ | | | | | | 117| 1.15k|#define AGEBITS 7 /* all age bits (111) */ | | | | ------------------ | | ------------------ | | #define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 110| 1.15k|#define G_SURVIVAL 1 /* created in previous cycle */ | | ------------------ | | | Branch (121:18): [True: 0, False: 1.15k] | | ------------------ ------------------ 230| 0| setage(o, G_TOUCHED1); /* touched in current cycle */ ------------------ | | 120| 0|#define setage(o,a) ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a)) | | ------------------ | | | | 146| 0|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 231| 1.15k|} luaC_fix: 234| 27.4k|void luaC_fix (lua_State *L, GCObject *o) { 235| 27.4k| global_State *g = G(L); ------------------ | | 333| 27.4k|#define G(L) (L->l_G) ------------------ 236| 27.4k| lua_assert(g->allgc == o); /* object must be 1st in 'allgc' list! */ ------------------ | | 109| 27.4k|#define lua_assert(c) assert(c) ------------------ 237| 27.4k| set2gray(o); /* they will be gray forever */ ------------------ | | 57| 27.4k|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 63| 27.4k|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 146| 27.4k|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 139| 27.4k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 238| 27.4k| setage(o, G_OLD); /* and old forever */ ------------------ | | 120| 27.4k|#define setage(o,a) ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a)) | | ------------------ | | | | 146| 27.4k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 27.4k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 239| 27.4k| g->allgc = o->next; /* remove object from 'allgc' list */ 240| 27.4k| o->next = g->fixedgc; /* link it to 'fixedgc' list */ 241| 27.4k| g->fixedgc = o; 242| 27.4k|} luaC_newobjdt: 249| 2.39M|GCObject *luaC_newobjdt (lua_State *L, int tt, size_t sz, size_t offset) { 250| 2.39M| global_State *g = G(L); ------------------ | | 333| 2.39M|#define G(L) (L->l_G) ------------------ 251| 2.39M| char *p = cast_charp(luaM_newobject(L, novariant(tt), sz)); ------------------ | | 149| 2.39M|#define cast_charp(i) cast(char *, (i)) | | ------------------ | | | | 139| 2.39M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 252| 2.39M| GCObject *o = cast(GCObject *, p + offset); ------------------ | | 139| 2.39M|#define cast(t, exp) ((t)(exp)) ------------------ 253| 2.39M| g->GCdebt--; 254| 2.39M| o->marked = luaC_white(g); ------------------ | | 105| 2.39M|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 146| 2.39M|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 2.39M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 255| 2.39M| o->tt = tt; 256| 2.39M| o->next = g->allgc; 257| 2.39M| g->allgc = o; 258| 2.39M| return o; 259| 2.39M|} luaC_newobj: 265| 2.39M|GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) { 266| 2.39M| return luaC_newobjdt(L, tt, sz, 0); 267| 2.39M|} luaC_checkfinalizer: 1015| 45|void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) { 1016| 45| global_State *g = G(L); ------------------ | | 333| 45|#define G(L) (L->l_G) ------------------ 1017| 45| if (tofinalize(o) || /* obj. is already marked... */ ------------------ | | 95| 45|#define tofinalize(x) testbit((x)->marked, FINALIZEDBIT) | | ------------------ | | | | 70| 45|#define testbit(x,b) testbits(x, bitmask(b)) | | | | ------------------ | | | | | | 65| 90|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 0, False: 45] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1018| 45| gfasttm(g, mt, TM_GC) == NULL || /* or has no finalizer... */ ------------------ | | 66| 45| (checknoTM(mt, e) ? NULL : luaT_gettm(mt, e, (g)->tmname[e])) | | ------------------ | | | | 63| 45|#define checknoTM(mt,e) ((mt) == NULL || (mt)->flags & (1u<<(e))) | | | | ------------------ | | | | | Branch (63:26): [True: 0, False: 45] | | | | | Branch (63:42): [True: 0, False: 45] | | | | ------------------ | | ------------------ ------------------ | Branch (1018:7): [True: 0, False: 45] ------------------ 1019| 45| (g->gcstp & GCSTPCLS)) /* or closing state? */ ------------------ | | 204| 45|#define GCSTPCLS 4 /* bit true when closing Lua state */ ------------------ | Branch (1019:7): [True: 0, False: 45] ------------------ 1020| 0| return; /* nothing to be done */ 1021| 45| else { /* move 'o' to 'finobj' list */ 1022| 45| GCObject **p; 1023| 45| if (issweepphase(g)) { ------------------ | | 46| 45| (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 37| 45|#define GCSswpallgc 3 | | ------------------ | | (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 40| 45|#define GCSswpend 6 | | ------------------ | | | Branch (46:3): [True: 45, False: 0] | | | Branch (46:34): [True: 0, False: 45] | | ------------------ ------------------ 1024| 0| makewhite(g, o); /* "sweep" object 'o' */ ------------------ | | 54| 0| (x->marked = cast_byte((x->marked & ~maskcolors) | luaC_white(g))) | | ------------------ | | | | 146| 0|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1025| 0| if (g->sweepgc == &o->next) /* should not remove 'sweepgc' object */ ------------------ | Branch (1025:11): [True: 0, False: 0] ------------------ 1026| 0| g->sweepgc = sweeptolive(L, g->sweepgc); /* change 'sweepgc' */ 1027| 0| } 1028| 45| else 1029| 45| correctpointers(g, o); 1030| | /* search for pointer pointing to 'o' */ 1031| 180| for (p = &g->allgc; *p != o; p = &(*p)->next) { /* empty */ } ------------------ | Branch (1031:25): [True: 135, False: 45] ------------------ 1032| 45| *p = o->next; /* remove 'o' from 'allgc' list */ 1033| 45| o->next = g->finobj; /* link it in 'finobj' list */ 1034| 45| g->finobj = o; 1035| 45| l_setbit(o->marked, FINALIZEDBIT); /* mark it as such */ ------------------ | | 68| 45|#define l_setbit(x,b) setbits(x, bitmask(b)) | | ------------------ | | | | 64| 45|#define setbits(x,m) ((x) |= (m)) | | ------------------ ------------------ 1036| 45| } 1037| 45|} luaC_changemode: 1374| 561|void luaC_changemode (lua_State *L, int newmode) { 1375| 561| global_State *g = G(L); ------------------ | | 333| 561|#define G(L) (L->l_G) ------------------ 1376| 561| if (g->gckind == KGC_GENMAJOR) /* doing major collections? */ ------------------ | | 153| 561|#define KGC_GENMAJOR 2 /* generational in major mode */ ------------------ | Branch (1376:7): [True: 0, False: 561] ------------------ 1377| 0| g->gckind = KGC_INC; /* already incremental but in name */ ------------------ | | 151| 0|#define KGC_INC 0 /* incremental gc */ ------------------ 1378| 561| if (newmode != g->gckind) { /* does it need to change? */ ------------------ | Branch (1378:7): [True: 0, False: 561] ------------------ 1379| 0| if (newmode == KGC_INC) /* entering incremental mode? */ ------------------ | | 151| 0|#define KGC_INC 0 /* incremental gc */ ------------------ | Branch (1379:9): [True: 0, False: 0] ------------------ 1380| 0| minor2inc(L, g, KGC_INC); /* entering incremental mode */ ------------------ | | 151| 0|#define KGC_INC 0 /* incremental gc */ ------------------ 1381| 0| else { 1382| 0| lua_assert(newmode == KGC_GENMINOR); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ 1383| 0| entergen(L, g); 1384| 0| } 1385| 0| } 1386| 561|} luaC_freeallobjects: 1463| 561|void luaC_freeallobjects (lua_State *L) { 1464| 561| global_State *g = G(L); ------------------ | | 333| 561|#define G(L) (L->l_G) ------------------ 1465| 561| g->gcstp = GCSTPCLS; /* no extra finalizers after here */ ------------------ | | 204| 561|#define GCSTPCLS 4 /* bit true when closing Lua state */ ------------------ 1466| 561| luaC_changemode(L, KGC_INC); ------------------ | | 151| 561|#define KGC_INC 0 /* incremental gc */ ------------------ 1467| 561| separatetobefnz(g, 1); /* separate all objects with finalizers */ 1468| 561| lua_assert(g->finobj == NULL); ------------------ | | 109| 561|#define lua_assert(c) assert(c) ------------------ 1469| 561| callallpendingfinalizers(L); 1470| 561| deletelist(L, g->allgc, obj2gco(g->mainthread)); ------------------ | | 388| 561|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 113| 561|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1471| 561| lua_assert(g->finobj == NULL); /* no new finalizers */ ------------------ | | 109| 561|#define lua_assert(c) assert(c) ------------------ 1472| 561| deletelist(L, g->fixedgc, NULL); /* collect fixed objects */ 1473| 561| lua_assert(g->strt.nuse == 0); ------------------ | | 109| 561|#define lua_assert(c) assert(c) ------------------ 1474| 561|} luaC_step: 1662| 13.5k|void luaC_step (lua_State *L) { 1663| 13.5k| global_State *g = G(L); ------------------ | | 333| 13.5k|#define G(L) (L->l_G) ------------------ 1664| 13.5k| lua_assert(!g->gcemergency); ------------------ | | 109| 13.5k|#define lua_assert(c) assert(c) ------------------ 1665| 13.5k| if (!gcrunning(g)) /* not running? */ ------------------ | | 205| 13.5k|#define gcrunning(g) ((g)->gcstp == 0) ------------------ | Branch (1665:7): [True: 0, False: 13.5k] ------------------ 1666| 0| luaE_setdebt(g, 2000); 1667| 13.5k| else { 1668| 13.5k| switch (g->gckind) { ------------------ | Branch (1668:13): [True: 0, False: 13.5k] ------------------ 1669| 13.5k| case KGC_INC: case KGC_GENMAJOR: ------------------ | | 151| 13.5k|#define KGC_INC 0 /* incremental gc */ ------------------ case KGC_INC: case KGC_GENMAJOR: ------------------ | | 153| 13.5k|#define KGC_GENMAJOR 2 /* generational in major mode */ ------------------ | Branch (1669:7): [True: 13.5k, False: 0] | Branch (1669:21): [True: 0, False: 13.5k] ------------------ 1670| 13.5k| incstep(L, g); 1671| 13.5k| break; 1672| 0| case KGC_GENMINOR: ------------------ | | 152| 0|#define KGC_GENMINOR 1 /* generational gc in minor (regular) mode */ ------------------ | Branch (1672:7): [True: 0, False: 13.5k] ------------------ 1673| 0| youngcollection(L, g); 1674| 0| setminordebt(g); 1675| 0| break; 1676| 13.5k| } 1677| 13.5k| } 1678| 13.5k|} lgc.c:linkgclist_: 138| 1.04M|static void linkgclist_ (GCObject *o, GCObject **pnext, GCObject **list) { 139| 1.04M| lua_assert(!isgray(o)); /* cannot be in a gray list */ ------------------ | | 109| 1.04M|#define lua_assert(c) assert(c) ------------------ 140| 1.04M| *pnext = *list; 141| 1.04M| *list = o; 142| 1.04M| set2gray(o); /* now it is */ ------------------ | | 57| 1.04M|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 63| 1.04M|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 146| 1.04M|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 139| 1.04M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 143| 1.04M|} lgc.c:getgclist: 115| 2.08M|static GCObject **getgclist (GCObject *o) { 116| 2.08M| switch (o->tt) { 117| 312k| case LUA_VTABLE: return &gco2t(o)->gclist; ------------------ | | 717| 312k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 312k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTABLE: return &gco2t(o)->gclist; ------------------ | | 378| 312k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 113| 312k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 312k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (117:5): [True: 312k, False: 1.77M] ------------------ 118| 345k| case LUA_VLCL: return &gco2lcl(o)->gclist; ------------------ | | 627| 345k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 345k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: return &gco2lcl(o)->gclist; ------------------ | | 374| 345k|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 113| 345k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 345k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (118:5): [True: 345k, False: 1.74M] ------------------ 119| 0| case LUA_VCCL: return &gco2ccl(o)->gclist; ------------------ | | 629| 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; ------------------ | | 375| 0|#define gco2ccl(o) check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (119:5): [True: 0, False: 2.08M] ------------------ 120| 14.2k| case LUA_VTHREAD: return &gco2th(o)->gclist; ------------------ | | 275| 14.2k|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 14.2k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: return &gco2th(o)->gclist; ------------------ | | 380| 14.2k|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 113| 14.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 14.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (120:5): [True: 14.2k, False: 2.07M] ------------------ 121| 1.41M| case LUA_VPROTO: return &gco2p(o)->gclist; ------------------ | | 538| 1.41M|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 1.41M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VPROTO: return &gco2p(o)->gclist; ------------------ | | 379| 1.41M|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 113| 1.41M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 1.41M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (121:5): [True: 1.41M, False: 672k] ------------------ 122| 0| case LUA_VUSERDATA: { ------------------ | | 460| 0|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (122:5): [True: 0, False: 2.08M] ------------------ 123| 0| Udata *u = gco2u(o); ------------------ | | 373| 0|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 124| 0| lua_assert(u->nuvalue > 0); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ 125| 0| return &u->gclist; 126| 0| } 127| 0| default: lua_assert(0); return 0; ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ | Branch (127:5): [True: 0, False: 2.08M] ------------------ 128| 2.08M| } 129| 2.08M|} lgc.c:reallymarkobject: 292| 1.56M|static void reallymarkobject (global_State *g, GCObject *o) { 293| 1.56M| g->marked++; 294| 1.56M| switch (o->tt) { 295| 140k| case LUA_VSHRSTR: ------------------ | | 373| 140k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 140k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (295:5): [True: 140k, False: 1.42M] ------------------ 296| 189k| case LUA_VLNGSTR: { ------------------ | | 374| 189k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 189k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (296:5): [True: 48.5k, False: 1.52M] ------------------ 297| 189k| set2black(o); /* nothing to visit */ ------------------ | | 62| 189k| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 146| 189k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 189k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 298| 189k| break; 299| 140k| } 300| 337k| case LUA_VUPVAL: { ------------------ | | 623| 337k|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 337k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (300:5): [True: 337k, False: 1.23M] ------------------ 301| 337k| UpVal *uv = gco2upv(o); ------------------ | | 381| 337k|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 113| 337k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 337k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 302| 337k| if (upisopen(uv)) ------------------ | | 32| 337k|#define upisopen(up) ((up)->v.p != &(up)->u.value) | | ------------------ | | | Branch (32:22): [True: 170k, False: 167k] | | ------------------ ------------------ 303| 337k| set2gray(uv); /* open upvalues are kept gray */ ------------------ | | 57| 170k|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 63| 170k|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 146| 170k|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 139| 170k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 304| 167k| else 305| 167k| set2black(uv); /* closed upvalues are visited here */ ------------------ | | 62| 167k| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 146| 167k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 167k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 306| 337k| markvalue(g, uv->v.p); /* mark its content */ ------------------ | | 83| 337k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 337k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 2.89M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 337k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 170k] | | | | | | | Branch (115:29): [True: 170k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 170k] | | | | | | | Branch (115:29): [True: 170k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 170k] | | | | | | | Branch (115:29): [True: 170k, False: 0] | | | | | | | Branch (115:29): [True: 170k, False: 0] | | | | | | | Branch (115:29): [True: 167k, False: 170k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 337k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 84| 337k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 65| 337k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 313| 675k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 337k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 311| 337k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (313:26): [True: 170k, False: 167k] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 90| 170k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 681k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 37, False: 170k] | | | | | | | | | Branch (65:26): [True: 0, False: 170k] | | | | | | | | | Branch (65:26): [True: 170k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 318| 37|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 113| 37|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 37|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 307| 337k| break; 308| 337k| } 309| 41| case LUA_VUSERDATA: { ------------------ | | 460| 41|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 41|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (309:5): [True: 41, False: 1.56M] ------------------ 310| 41| Udata *u = gco2u(o); ------------------ | | 373| 41|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 113| 41|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 41|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 311| 41| if (u->nuvalue == 0) { /* no user values? */ ------------------ | Branch (311:11): [True: 41, False: 0] ------------------ 312| 41| markobjectN(g, u->metatable); /* mark its metatable */ ------------------ | | 94| 41|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 88| 41|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 90| 41|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 41|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 41] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (94:32): [True: 41, False: 0] | | ------------------ ------------------ 313| 41| set2black(u); /* nothing else to mark */ ------------------ | | 62| 41| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 146| 41|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 41|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 314| 41| break; 315| 41| } 316| | /* else... */ 317| 41| } /* FALLTHROUGH */ 318| 328k| case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 627| 172k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 172k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 629| 172k|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 172k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 717| 328k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 328k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (318:5): [True: 172k, False: 1.39M] | Branch (318:20): [True: 0, False: 1.56M] | Branch (318:35): [True: 155k, False: 1.41M] ------------------ 319| 1.04M| case LUA_VTHREAD: case LUA_VPROTO: { ------------------ | | 275| 333k|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 333k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: case LUA_VPROTO: { ------------------ | | 538| 1.04M|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 1.04M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (319:5): [True: 4.74k, False: 1.56M] | Branch (319:23): [True: 708k, False: 860k] ------------------ 320| 1.04M| linkobjgclist(o, g->gray); /* to be visited later */ ------------------ | | 149| 1.04M|#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p)) | | ------------------ | | | | 388| 1.04M|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 1.04M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 1.04M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 321| 0| break; 322| 1.04M| } 323| 0| default: lua_assert(0); break; ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ | Branch (323:5): [True: 0, False: 1.56M] ------------------ 324| 1.56M| } 325| 1.56M|} lgc.c:sweeptolive: 862| 4.74k|static GCObject **sweeptolive (lua_State *L, GCObject **p) { 863| 4.74k| GCObject **old = p; 864| 7.82k| do { 865| 7.82k| p = sweeplist(L, p, 1); 866| 7.82k| } while (p == old); ------------------ | Branch (866:12): [True: 3.08k, False: 4.74k] ------------------ 867| 4.74k| return p; 868| 4.74k|} lgc.c:sweeplist: 838| 206k|static GCObject **sweeplist (lua_State *L, GCObject **p, l_obj countin) { 839| 206k| global_State *g = G(L); ------------------ | | 333| 206k|#define G(L) (L->l_G) ------------------ 840| 206k| int ow = otherwhite(g); ------------------ | | 97| 206k|#define otherwhite(g) ((g)->currentwhite ^ WHITEBITS) | | ------------------ | | | | 87| 206k|#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) | | | | ------------------ | | | | | | 67| 206k|#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 66| 206k|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | | | #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 66| 206k|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 841| 206k| l_obj i; 842| 206k| int white = luaC_white(g); /* current white */ ------------------ | | 105| 206k|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 146| 206k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 206k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 843| 3.94M| for (i = 0; *p != NULL && i < countin; i++) { ------------------ | Branch (843:15): [True: 3.92M, False: 14.1k] | Branch (843:29): [True: 3.73M, False: 191k] ------------------ 844| 3.73M| GCObject *curr = *p; 845| 3.73M| int marked = curr->marked; 846| 3.73M| if (isdeadm(ow, marked)) { /* is 'curr' dead? */ ------------------ | | 98| 3.73M|#define isdeadm(ow,m) ((m) & (ow)) | | ------------------ | | | Branch (98:23): [True: 2.21M, False: 1.51M] | | ------------------ ------------------ 847| 2.21M| *p = curr->next; /* remove 'curr' from list */ 848| 2.21M| freeobj(L, curr); /* erase 'curr' */ 849| 2.21M| } 850| 1.51M| else { /* change mark to 'white' and age to 'new' */ 851| 1.51M| curr->marked = cast_byte((marked & ~maskgcbits) | white | G_NEW); ------------------ | | 146| 1.51M|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 139| 1.51M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 852| 1.51M| p = &curr->next; /* go to next element */ 853| 1.51M| } 854| 3.73M| } 855| 206k| return (*p == NULL) ? NULL : p; ------------------ | Branch (855:10): [True: 14.1k, False: 191k] ------------------ 856| 206k|} lgc.c:freeobj: 783| 2.39M|static void freeobj (lua_State *L, GCObject *o) { 784| 2.39M| G(L)->totalobjs--; ------------------ | | 333| 2.39M|#define G(L) (L->l_G) ------------------ 785| 2.39M| switch (o->tt) { 786| 21.7k| case LUA_VPROTO: ------------------ | | 538| 21.7k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 21.7k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (786:5): [True: 21.7k, False: 2.37M] ------------------ 787| 21.7k| luaF_freeproto(L, gco2p(o)); ------------------ | | 379| 21.7k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 113| 21.7k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 21.7k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 788| 0| break; 789| 1.02M| case LUA_VUPVAL: ------------------ | | 623| 1.02M|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 1.02M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (789:5): [True: 1.02M, False: 1.37M] ------------------ 790| 1.02M| freeupval(L, gco2upv(o)); ------------------ | | 381| 1.02M|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 113| 1.02M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 1.02M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 791| 0| break; 792| 1.07M| case LUA_VLCL: { ------------------ | | 627| 1.07M|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 1.07M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (792:5): [True: 1.07M, False: 1.31M] ------------------ 793| 1.07M| LClosure *cl = gco2lcl(o); ------------------ | | 374| 1.07M|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 113| 1.07M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 1.07M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 794| 1.07M| luaM_freemem(L, cl, sizeLclosure(cl->nupvalues)); ------------------ | | 55| 1.07M|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 795| 1.07M| break; 796| 1.07M| } 797| 0| case LUA_VCCL: { ------------------ | | 629| 0|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (797:5): [True: 0, False: 2.39M] ------------------ 798| 0| CClosure *cl = gco2ccl(o); ------------------ | | 375| 0|#define gco2ccl(o) check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 799| 0| luaM_freemem(L, cl, sizeCclosure(cl->nupvalues)); ------------------ | | 55| 0|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 800| 0| break; 801| 0| } 802| 125k| case LUA_VTABLE: ------------------ | | 717| 125k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 125k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (802:5): [True: 125k, False: 2.27M] ------------------ 803| 125k| luaH_free(L, gco2t(o)); ------------------ | | 378| 125k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 113| 125k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 125k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 804| 0| break; 805| 0| case LUA_VTHREAD: ------------------ | | 275| 0|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (805:5): [True: 0, False: 2.39M] ------------------ 806| 0| luaE_freethread(L, gco2th(o)); ------------------ | | 380| 0|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 807| 0| break; 808| 45| case LUA_VUSERDATA: { ------------------ | | 460| 45|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 45|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (808:5): [True: 45, False: 2.39M] ------------------ 809| 45| Udata *u = gco2u(o); ------------------ | | 373| 45|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 113| 45|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 810| 45| luaM_freemem(L, o, sizeudata(u->nuvalue, u->len)); ------------------ | | 55| 90|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) | | ------------------ | | | Branch (55:51): [True: 45, False: 0] | | ------------------ ------------------ 811| 45| break; 812| 45| } 813| 67.6k| case LUA_VSHRSTR: { ------------------ | | 373| 67.6k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 67.6k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (813:5): [True: 67.6k, False: 2.32M] ------------------ 814| 67.6k| TString *ts = gco2ts(o); ------------------ | | 372| 67.6k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 113| 67.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 67.6k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 815| 0| luaS_remove(L, ts); /* remove it from hash table */ 816| 67.6k| luaM_freemem(L, ts, sizestrshr(ts->shrlen)); ------------------ | | 55| 67.6k|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 817| 67.6k| break; 818| 67.6k| } 819| 81.8k| case LUA_VLNGSTR: { ------------------ | | 374| 81.8k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 81.8k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (819:5): [True: 81.8k, False: 2.31M] ------------------ 820| 81.8k| TString *ts = gco2ts(o); ------------------ | | 372| 81.8k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 113| 81.8k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 81.8k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 821| 81.8k| if (ts->shrlen == LSTRMEM) /* must free external string? */ ------------------ | | 399| 81.8k|#define LSTRMEM -3 /* external long string with deallocation */ ------------------ | Branch (821:11): [True: 45, False: 81.8k] ------------------ 822| 45| (*ts->falloc)(ts->ud, ts->contents, ts->u.lnglen + 1, 0); 823| 81.8k| luaM_freemem(L, ts, luaS_sizelngstr(ts->u.lnglen, ts->shrlen)); ------------------ | | 55| 81.8k|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 824| 81.8k| break; 825| 81.8k| } 826| 0| default: lua_assert(0); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ | Branch (826:5): [True: 0, False: 2.39M] ------------------ 827| 2.39M| } 828| 2.39M|} lgc.c:freeupval: 776| 1.02M|static void freeupval (lua_State *L, UpVal *uv) { 777| 1.02M| if (upisopen(uv)) ------------------ | | 32| 1.02M|#define upisopen(up) ((up)->v.p != &(up)->u.value) | | ------------------ | | | Branch (32:22): [True: 0, False: 1.02M] | | ------------------ ------------------ 778| 0| luaF_unlinkupval(uv); 779| 1.02M| luaM_free(L, uv); ------------------ | | 56| 1.02M|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 780| 1.02M|} lgc.c:correctpointers: 1003| 45|static void correctpointers (global_State *g, GCObject *o) { 1004| 45| checkpointer(&g->survival, o); 1005| 45| checkpointer(&g->old1, o); 1006| 45| checkpointer(&g->reallyold, o); 1007| 45| checkpointer(&g->firstold1, o); 1008| 45|} lgc.c:checkpointer: 993| 180|static void checkpointer (GCObject **p, GCObject *o) { 994| 180| if (o == *p) ------------------ | Branch (994:7): [True: 0, False: 180] ------------------ 995| 0| *p = o->next; 996| 180|} lgc.c:entersweep: 1438| 4.74k|static void entersweep (lua_State *L) { 1439| 4.74k| global_State *g = G(L); ------------------ | | 333| 4.74k|#define G(L) (L->l_G) ------------------ 1440| 4.74k| g->gcstate = GCSswpallgc; ------------------ | | 37| 4.74k|#define GCSswpallgc 3 ------------------ 1441| 4.74k| lua_assert(g->sweepgc == NULL); ------------------ | | 109| 4.74k|#define lua_assert(c) assert(c) ------------------ 1442| 4.74k| g->sweepgc = sweeptolive(L, &g->allgc); 1443| 4.74k|} lgc.c:atomic: 1477| 4.74k|static l_obj atomic (lua_State *L) { 1478| 4.74k| l_obj work = 0; 1479| 4.74k| global_State *g = G(L); ------------------ | | 333| 4.74k|#define G(L) (L->l_G) ------------------ 1480| 4.74k| GCObject *origweak, *origall; 1481| 4.74k| GCObject *grayagain = g->grayagain; /* save original list */ 1482| 4.74k| g->grayagain = NULL; 1483| 4.74k| lua_assert(g->ephemeron == NULL && g->weak == NULL); ------------------ | | 109| 4.74k|#define lua_assert(c) assert(c) ------------------ 1484| 4.74k| lua_assert(!iswhite(g->mainthread)); ------------------ | | 109| 4.74k|#define lua_assert(c) assert(c) ------------------ 1485| 4.74k| g->gcstate = GCSatomic; ------------------ | | 36| 4.74k|#define GCSatomic 2 ------------------ 1486| 4.74k| markobject(g, L); /* mark running thread */ ------------------ | | 88| 4.74k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 90| 4.74k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 4.74k|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 0, False: 4.74k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1487| | /* registry and global metatables may be changed by API */ 1488| 4.74k| markvalue(g, &g->l_registry); ------------------ | | 83| 4.74k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 4.74k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 75.8k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 4.74k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 4.74k] | | | | | | | Branch (115:29): [True: 4.74k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 4.74k] | | | | | | | Branch (115:29): [True: 4.74k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 4.74k] | | | | | | | Branch (115:29): [True: 4.74k, False: 0] | | | | | | | Branch (115:29): [True: 4.74k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 4.74k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 4.74k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 84| 4.74k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 65| 4.74k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 313| 9.48k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 4.74k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 311| 4.74k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (313:26): [True: 4.74k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 90| 4.74k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 18.9k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 4.74k] | | | | | | | | | Branch (65:26): [True: 0, False: 4.74k] | | | | | | | | | Branch (65:26): [True: 4.74k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 318| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1489| 4.74k| markmt(g); /* mark global metatables */ 1490| 4.74k| work += propagateall(g); /* empties 'gray' list */ 1491| | /* remark occasional upvalues of (maybe) dead threads */ 1492| 4.74k| work += remarkupvals(g); 1493| 4.74k| work += propagateall(g); /* propagate changes */ 1494| 4.74k| g->gray = grayagain; 1495| 4.74k| work += propagateall(g); /* traverse 'grayagain' list */ 1496| 4.74k| work += convergeephemerons(g); 1497| | /* at this point, all strongly accessible objects are marked. */ 1498| | /* Clear values from weak tables, before checking finalizers */ 1499| 4.74k| work += clearbyvalues(g, g->weak, NULL); 1500| 4.74k| work += clearbyvalues(g, g->allweak, NULL); 1501| 4.74k| origweak = g->weak; origall = g->allweak; 1502| 4.74k| separatetobefnz(g, 0); /* separate objects to be finalized */ 1503| 4.74k| work += markbeingfnz(g); /* mark objects that will be finalized */ 1504| 4.74k| work += propagateall(g); /* remark, to propagate 'resurrection' */ 1505| 4.74k| work += convergeephemerons(g); 1506| | /* at this point, all resurrected objects are marked. */ 1507| | /* remove dead objects from weak tables */ 1508| 4.74k| work += clearbykeys(g, g->ephemeron); /* clear keys from all ephemeron */ 1509| 4.74k| work += clearbykeys(g, g->allweak); /* clear keys from all 'allweak' */ 1510| | /* clear values from resurrected weak tables */ 1511| 4.74k| work += clearbyvalues(g, g->weak, origweak); 1512| 4.74k| work += clearbyvalues(g, g->allweak, origall); 1513| 4.74k| luaS_clearcache(g); 1514| 4.74k| g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */ ------------------ | | 146| 4.74k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 139| 4.74k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1515| 4.74k| lua_assert(g->gray == NULL); ------------------ | | 109| 4.74k|#define lua_assert(c) assert(c) ------------------ 1516| 4.74k| return work; 1517| 4.74k|} lgc.c:markmt: 331| 9.48k|static void markmt (global_State *g) { 332| 9.48k| int i; 333| 94.8k| for (i=0; i < LUA_NUMTYPES; i++) ------------------ | | 74| 94.8k|#define LUA_NUMTYPES 9 ------------------ | Branch (333:13): [True: 85.3k, False: 9.48k] ------------------ 334| 85.3k| markobjectN(g, g->mt[i]); ------------------ | | 94| 85.3k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 88| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (94:32): [True: 0, False: 85.3k] | | ------------------ ------------------ 335| 9.48k|} lgc.c:propagateall: 677| 18.9k|static l_obj propagateall (global_State *g) { 678| 18.9k| l_obj work = 0; 679| 23.8k| while (g->gray) { ------------------ | Branch (679:10): [True: 4.91k, False: 18.9k] ------------------ 680| 4.91k| propagatemark(g); 681| 4.91k| work++; 682| 4.91k| } 683| 18.9k| return work; 684| 18.9k|} lgc.c:propagatemark: 661| 1.04M|static void propagatemark (global_State *g) { 662| 1.04M| GCObject *o = g->gray; 663| 1.04M| nw2black(o); ------------------ | | 103| 1.04M| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 113| 1.04M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 1.04M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 664| 0| g->gray = *getgclist(o); /* remove from 'gray' list */ 665| 1.04M| switch (o->tt) { 666| 155k| case LUA_VTABLE: traversetable(g, gco2t(o)); break; ------------------ | | 717| 155k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 155k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTABLE: traversetable(g, gco2t(o)); break; ------------------ | | 378| 155k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 113| 155k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 155k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (666:5): [True: 155k, False: 888k] ------------------ 667| 0| case LUA_VUSERDATA: traverseudata(g, gco2u(o)); break; ------------------ | | 460| 0|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VUSERDATA: traverseudata(g, gco2u(o)); break; ------------------ | | 373| 0|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (667:5): [True: 0, False: 1.04M] ------------------ 668| 172k| case LUA_VLCL: traverseLclosure(g, gco2lcl(o)); break; ------------------ | | 627| 172k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 172k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: traverseLclosure(g, gco2lcl(o)); break; ------------------ | | 374| 172k|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 113| 172k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 172k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (668:5): [True: 172k, False: 870k] ------------------ 669| 0| case LUA_VCCL: traverseCclosure(g, gco2ccl(o)); break; ------------------ | | 629| 0|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VCCL: traverseCclosure(g, gco2ccl(o)); break; ------------------ | | 375| 0|#define gco2ccl(o) check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (669:5): [True: 0, False: 1.04M] ------------------ 670| 705k| case LUA_VPROTO: traverseproto(g, gco2p(o)); break; ------------------ | | 538| 705k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 705k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VPROTO: traverseproto(g, gco2p(o)); break; ------------------ | | 379| 705k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 113| 705k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 705k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (670:5): [True: 705k, False: 337k] ------------------ 671| 9.48k| case LUA_VTHREAD: traversethread(g, gco2th(o)); break; ------------------ | | 275| 9.48k|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 9.48k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: traversethread(g, gco2th(o)); break; ------------------ | | 380| 9.48k|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 113| 9.48k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 9.48k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (671:5): [True: 9.48k, False: 1.03M] ------------------ 672| 0| default: lua_assert(0); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ | Branch (672:5): [True: 0, False: 1.04M] ------------------ 673| 1.04M| } 674| 1.04M|} lgc.c:traversetable: 549| 155k|static void traversetable (global_State *g, Table *h) { 550| 155k| const char *weakkey, *weakvalue; 551| 155k| const TValue *mode = gfasttm(g, h->metatable, TM_MODE); ------------------ | | 66| 155k| (checknoTM(mt, e) ? NULL : luaT_gettm(mt, e, (g)->tmname[e])) | | ------------------ | | | | 63| 155k|#define checknoTM(mt,e) ((mt) == NULL || (mt)->flags & (1u<<(e))) | | | | ------------------ | | | | | Branch (63:26): [True: 155k, False: 0] | | | | | Branch (63:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 552| 155k| TString *smode; 553| 155k| markobjectN(g, h->metatable); ------------------ | | 94| 155k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 88| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (94:32): [True: 0, False: 155k] | | ------------------ ------------------ 554| 155k| if (mode && ttisshrstring(mode) && /* is there a weak mode? */ ------------------ | | 377| 0|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | ------------------ | | | | 91| 155k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (554:7): [True: 0, False: 155k] ------------------ 555| 155k| (cast_void(smode = tsvalue(mode)), ------------------ | | 141| 0|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [True: 0, False: 0] | | | | | Branch (139:27): [True: 0, False: 0] | | | | | Branch (139:27): [True: 0, False: 0] | | | | | Branch (139:27): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (555:7): [True: 0, False: 0] ------------------ 556| 0| cast_void(weakkey = strchr(getshrstr(smode), 'k')), ------------------ | | 141| 0|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [True: 0, False: 0] | | | | | Branch (139:27): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 557| 0| cast_void(weakvalue = strchr(getshrstr(smode), 'v')), ------------------ | | 141| 0|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [True: 0, False: 0] | | | | | Branch (139:27): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 558| 0| (weakkey || weakvalue))) { /* is really weak? */ ------------------ | Branch (558:9): [True: 0, False: 0] | Branch (558:20): [True: 0, False: 0] ------------------ 559| 0| if (!weakkey) /* strong keys? */ ------------------ | Branch (559:9): [True: 0, False: 0] ------------------ 560| 0| traverseweakvalue(g, h); 561| 0| else if (!weakvalue) /* strong values? */ ------------------ | Branch (561:14): [True: 0, False: 0] ------------------ 562| 0| traverseephemeron(g, h, 0); 563| 0| else /* all weak */ 564| 0| linkgclist(h, g->allweak); /* nothing to traverse now */ ------------------ | | 136| 0|#define linkgclist(o,p) linkgclist_(obj2gco(o), &(o)->gclist, &(p)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 565| 0| } 566| 155k| else /* not weak */ 567| 155k| traversestrongtable(g, h); 568| 155k|} lgc.c:clearkey: 161| 236k|static void clearkey (Node *n) { 162| 236k| lua_assert(isempty(gval(n))); ------------------ | | 109| 236k|#define lua_assert(c) assert(c) ------------------ 163| 236k| if (keyiscollectable(n)) ------------------ | | 802| 236k|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 791| 236k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 311| 236k|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ | | | Branch (802:29): [True: 188, False: 236k] | | ------------------ ------------------ 164| 188| setdeadkey(n); /* unused key; remove it */ ------------------ | | 814| 188|#define setdeadkey(node) (keytt(node) = LUA_TDEADKEY) | | ------------------ | | | | 791| 188|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define setdeadkey(node) (keytt(node) = LUA_TDEADKEY) | | ------------------ | | | | 24| 188|#define LUA_TDEADKEY (LUA_NUMTYPES+2) /* removed keys in tables */ | | | | ------------------ | | | | | | 74| 188|#define LUA_NUMTYPES 9 | | | | ------------------ | | ------------------ ------------------ 165| 236k|} lgc.c:traversearray: 471| 155k|static int traversearray (global_State *g, Table *h) { 472| 155k| unsigned asize = luaH_realasize(h); 473| 155k| int marked = 0; /* true if some object is marked in this traversal */ 474| 155k| unsigned i; 475| 6.19M| for (i = 0; i < asize; i++) { ------------------ | Branch (475:15): [True: 6.04M, False: 155k] ------------------ 476| 6.04M| GCObject *o = gcvalarr(h, i); ------------------ | | 80| 6.04M| ((*getArrTag(t,i) & BIT_ISCOLLECTABLE) ? getArrVal(t,i)->gc : NULL) | | ------------------ | | | | 106| 6.04M|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | | | ------------------ | | | | | | 139| 6.04M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | ((*getArrTag(t,i) & BIT_ISCOLLECTABLE) ? getArrVal(t,i)->gc : NULL) | | ------------------ | | | | 311| 6.04M|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ | | ((*getArrTag(t,i) & BIT_ISCOLLECTABLE) ? getArrVal(t,i)->gc : NULL) | | ------------------ | | | | 109| 155k|#define getArrVal(t,k) ((t)->array - 1 - (k)) | | ------------------ | | | Branch (80:3): [True: 155k, False: 5.88M] | | ------------------ ------------------ 477| 6.04M| if (o != NULL && iswhite(o)) { ------------------ | | 90| 155k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 65| 155k|#define testbits(x,m) ((x) & (m)) | | | | ------------------ | | | | | Branch (65:24): [True: 137k, False: 17.8k] | | | | ------------------ | | ------------------ ------------------ | Branch (477:9): [True: 155k, False: 5.88M] ------------------ 478| 137k| marked = 1; 479| 137k| reallymarkobject(g, o); 480| 137k| } 481| 6.04M| } 482| 155k| return marked; 483| 155k|} lgc.c:genlink: 430| 155k|static void genlink (global_State *g, GCObject *o) { 431| 155k| lua_assert(isblack(o)); ------------------ | | 109| 155k|#define lua_assert(c) assert(c) ------------------ 432| 155k| if (getage(o) == G_TOUCHED1) { /* touched in this cycle? */ ------------------ | | 119| 155k|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 117| 155k|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ if (getage(o) == G_TOUCHED1) { /* touched in this cycle? */ ------------------ | | 114| 155k|#define G_TOUCHED1 5 /* old object touched this cycle */ ------------------ | Branch (432:7): [True: 0, False: 155k] ------------------ 433| 0| linkobjgclist(o, g->grayagain); /* link it back in 'grayagain' */ ------------------ | | 149| 0|#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 434| 0| } /* everything else do not need to be linked back */ 435| 155k| else if (getage(o) == G_TOUCHED2) ------------------ | | 119| 155k|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 117| 155k|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ else if (getage(o) == G_TOUCHED2) ------------------ | | 115| 155k|#define G_TOUCHED2 6 /* old object touched in previous cycle */ ------------------ | Branch (435:12): [True: 0, False: 155k] ------------------ 436| 0| setage(o, G_OLD); /* advance age */ ------------------ | | 120| 0|#define setage(o,a) ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a)) | | ------------------ | | | | 146| 0|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 437| 155k|} lgc.c:traversestrongtable: 533| 155k|static void traversestrongtable (global_State *g, Table *h) { 534| 155k| Node *n, *limit = gnodelast(h); ------------------ | | 112| 155k|#define gnodelast(h) gnode(h, cast_sizet(sizenode(h))) | | ------------------ | | | | 13| 155k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 535| 155k| traversearray(g, h); 536| 1.20M| for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */ ------------------ | | 13| 155k|#define gnode(t,i) (&(t)->node[i]) ------------------ | Branch (536:25): [True: 1.05M, False: 155k] ------------------ 537| 1.05M| if (isempty(gval(n))) /* entry is empty? */ ------------------ | | 228| 1.05M|#define isempty(v) ttisnil(v) | | ------------------ | | | | 196| 1.05M|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 1.05M|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 1.05M|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 1.05M|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 236k, False: 815k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 538| 236k| clearkey(n); /* clear its key */ 539| 815k| else { 540| 815k| lua_assert(!keyisnil(n)); ------------------ | | 109| 815k|#define lua_assert(c) assert(c) ------------------ 541| 815k| markkey(g, n); ------------------ | | 86| 815k|#define markkey(g, n) { if keyiswhite(n) reallymarkobject(g,gckey(n)); } | | ------------------ | | | | 67| 815k|#define keyiswhite(n) (keyiscollectable(n) && iswhite(gckey(n))) | | | | ------------------ | | | | | | 802| 1.63M|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 791| 815k|#define keytt(node) ((node)->u.key_tt) | | | | | | ------------------ | | | | | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 311| 815k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (802:29): [True: 548k, False: 267k] | | | | | | ------------------ | | | | ------------------ | | | | #define keyiswhite(n) (keyiscollectable(n) && iswhite(gckey(n))) | | | | ------------------ | | | | | | 90| 548k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 548k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 61.5k, False: 486k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markkey(g, n) { if keyiswhite(n) reallymarkobject(g,gckey(n)); } | | ------------------ | | | | 804| 61.5k|#define gckey(n) (keyval(n).gc) | | | | ------------------ | | | | | | 792| 61.5k|#define keyval(node) ((node)->u.key_val) | | | | ------------------ | | ------------------ ------------------ 542| 815k| markvalue(g, gval(n)); ------------------ | | 83| 815k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 815k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 4.63M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 815k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 254k] | | | | | | | Branch (115:29): [True: 254k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 254k] | | | | | | | Branch (115:29): [True: 254k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 254k] | | | | | | | Branch (115:29): [True: 254k, False: 0] | | | | | | | Branch (115:29): [True: 254k, False: 0] | | | | | | | Branch (115:29): [True: 560k, False: 254k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 815k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 84| 815k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 65| 815k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 313| 1.63M|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 815k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 311| 815k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (313:26): [True: 254k, False: 560k] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 90| 254k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 1.01M|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 10.4k, False: 244k] | | | | | | | | | Branch (65:26): [True: 0, False: 254k] | | | | | | | | | Branch (65:26): [True: 254k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 318| 10.4k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 113| 10.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 10.4k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 543| 815k| } 544| 1.05M| } 545| 155k| genlink(g, obj2gco(h)); ------------------ | | 388| 155k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 113| 155k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 155k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 546| 155k|} lgc.c:traverseLclosure: 609| 172k|static void traverseLclosure (global_State *g, LClosure *cl) { 610| 172k| int i; 611| 172k| markobjectN(g, cl->p); /* mark its prototype */ ------------------ | | 94| 172k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 88| 172k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 90| 172k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 172k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 172k, False: 447] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 388| 172k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 172k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 172k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (94:32): [True: 172k, False: 0] | | ------------------ ------------------ 612| 680k| for (i = 0; i < cl->nupvalues; i++) { /* visit its upvalues */ ------------------ | Branch (612:15): [True: 507k, False: 172k] ------------------ 613| 507k| UpVal *uv = cl->upvals[i]; 614| 507k| markobjectN(g, uv); /* mark upvalue */ ------------------ | | 94| 507k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 88| 506k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 90| 506k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 506k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 167k, False: 339k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 388| 167k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 167k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 167k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (94:32): [True: 506k, False: 1.18k] | | ------------------ ------------------ 615| 507k| } 616| 172k|} lgc.c:traverseproto: 585| 705k|static void traverseproto (global_State *g, Proto *f) { 586| 705k| int i; 587| 705k| markobjectN(g, f->source); ------------------ | | 94| 705k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 88| 705k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 90| 705k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 705k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 4.74k, False: 701k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 388| 4.74k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 4.74k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 4.74k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (94:32): [True: 705k, False: 0] | | ------------------ ------------------ 588| 5.48M| for (i = 0; i < f->sizek; i++) /* mark literals */ ------------------ | Branch (588:15): [True: 4.78M, False: 705k] ------------------ 589| 4.78M| markvalue(g, &f->k[i]); ------------------ | | 83| 5.48M|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 4.78M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 70.4M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 4.78M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 4.37M] | | | | | | | Branch (115:29): [True: 4.37M, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 4.37M] | | | | | | | Branch (115:29): [True: 4.37M, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 4.37M] | | | | | | | Branch (115:29): [True: 4.37M, False: 0] | | | | | | | Branch (115:29): [True: 4.37M, False: 0] | | | | | | | Branch (115:29): [True: 404k, False: 4.37M] | | | | | | ------------------ | | | | ------------------ | | | | 108| 4.78M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 84| 5.48M| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 65| 4.78M|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 313| 9.56M|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 4.78M|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 311| 4.78M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (313:26): [True: 4.37M, False: 404k] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 90| 4.37M|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 17.5M|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 93.1k, False: 4.28M] | | | | | | | | | Branch (65:26): [True: 0, False: 4.37M] | | | | | | | | | Branch (65:26): [True: 4.37M, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 318| 93.1k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 113| 93.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 93.1k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 590| 2.76M| for (i = 0; i < f->sizeupvalues; i++) /* mark upvalue names */ ------------------ | Branch (590:15): [True: 2.05M, False: 705k] ------------------ 591| 2.05M| markobjectN(g, f->upvalues[i].name); ------------------ | | 94| 2.76M|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 88| 2.05M|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 90| 2.05M|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 2.05M|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 7.14k, False: 2.04M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 388| 7.14k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 7.14k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 7.14k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (94:32): [True: 2.05M, False: 4.22k] | | ------------------ ------------------ 592| 1.41M| for (i = 0; i < f->sizep; i++) /* mark nested protos */ ------------------ | Branch (592:15): [True: 706k, False: 705k] ------------------ 593| 706k| markobjectN(g, f->p[i]); ------------------ | | 94| 1.41M|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 88| 698k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 90| 698k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 698k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 531k, False: 167k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 388| 531k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 531k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 531k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (94:32): [True: 698k, False: 7.25k] | | ------------------ ------------------ 594| 1.79M| for (i = 0; i < f->sizelocvars; i++) /* mark local-variable names */ ------------------ | Branch (594:15): [True: 1.08M, False: 705k] ------------------ 595| 1.08M| markobjectN(g, f->locvars[i].varname); ------------------ | | 94| 1.79M|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 88| 1.08M|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 90| 1.08M|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 1.08M|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 10.0k, False: 1.07M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 388| 10.0k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 10.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 10.0k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (94:32): [True: 1.08M, False: 3.68k] | | ------------------ ------------------ 596| 705k|} lgc.c:traversethread: 631| 9.48k|static void traversethread (global_State *g, lua_State *th) { 632| 9.48k| UpVal *uv; 633| 9.48k| StkId o = th->stack.p; 634| 9.48k| if (isold(th) || g->gcstate == GCSpropagate) ------------------ | | 121| 18.9k|#define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 119| 9.48k|#define getage(o) ((o)->marked & AGEBITS) | | | | ------------------ | | | | | | 117| 9.48k|#define AGEBITS 7 /* all age bits (111) */ | | | | ------------------ | | ------------------ | | #define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 110| 9.48k|#define G_SURVIVAL 1 /* created in previous cycle */ | | ------------------ | | | Branch (121:18): [True: 0, False: 9.48k] | | ------------------ ------------------ if (isold(th) || g->gcstate == GCSpropagate) ------------------ | | 34| 9.48k|#define GCSpropagate 0 ------------------ | Branch (634:20): [True: 4.74k, False: 4.74k] ------------------ 635| 4.74k| linkgclist(th, g->grayagain); /* insert into 'grayagain' list */ ------------------ | | 136| 4.74k|#define linkgclist(o,p) linkgclist_(obj2gco(o), &(o)->gclist, &(p)) | | ------------------ | | | | 388| 4.74k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 4.74k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 4.74k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 636| 9.48k| if (o == NULL) ------------------ | Branch (636:7): [True: 0, False: 9.48k] ------------------ 637| 0| return; /* stack not completely built yet */ 638| 9.48k| lua_assert(g->gcstate == GCSatomic || ------------------ | | 109| 9.48k|#define lua_assert(c) assert(c) ------------------ 639| 9.48k| th->openupval == NULL || isintwups(th)); 640| 2.64M| for (; o < th->top.p; o++) /* mark live elements in the stack */ ------------------ | Branch (640:10): [True: 2.63M, False: 9.48k] ------------------ 641| 2.63M| markvalue(g, s2v(o)); ------------------ | | 83| 2.64M|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 2.63M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 8.25M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 2.63M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 374k] | | | | | | | Branch (115:29): [True: 374k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 374k] | | | | | | | Branch (115:29): [True: 374k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 374k] | | | | | | | Branch (115:29): [True: 374k, False: 0] | | | | | | | Branch (115:29): [True: 374k, False: 0] | | | | | | | Branch (115:29): [True: 2.25M, False: 374k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 2.63M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 84| 2.64M| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 65| 2.63M|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 313| 5.26M|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 2.63M|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 311| 2.63M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (313:26): [True: 374k, False: 2.25M] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 90| 374k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 1.49M|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 176k, False: 198k] | | | | | | | | | Branch (65:26): [True: 0, False: 374k] | | | | | | | | | Branch (65:26): [True: 374k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 318| 176k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 113| 176k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 176k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 642| 350k| for (uv = th->openupval; uv != NULL; uv = uv->u.open.next) ------------------ | Branch (642:28): [True: 341k, False: 9.48k] ------------------ 643| 341k| markobject(g, uv); /* open upvalues cannot be collected */ ------------------ | | 88| 350k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 90| 341k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 341k|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 170k, False: 170k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 388| 170k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 170k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 170k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 644| 9.48k| if (g->gcstate == GCSatomic) { /* final traversal? */ ------------------ | | 36| 9.48k|#define GCSatomic 2 ------------------ | Branch (644:7): [True: 4.74k, False: 4.74k] ------------------ 645| 4.74k| if (!g->gcemergency) ------------------ | Branch (645:9): [True: 4.74k, False: 0] ------------------ 646| 4.74k| luaD_shrinkstack(th); /* do not change stack in emergency cycle */ 647| 704k| for (o = th->top.p; o < th->stack_last.p + EXTRA_STACK; o++) ------------------ | | 142| 704k|#define EXTRA_STACK 5 ------------------ | Branch (647:25): [True: 700k, False: 4.74k] ------------------ 648| 700k| setnilvalue(s2v(o)); /* clear dead stack slice */ ------------------ | | 211| 700k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 700k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 649| | /* 'remarkupvals' may have removed thread from 'twups' list */ 650| 4.74k| if (!isintwups(th) && th->openupval != NULL) { ------------------ | | 22| 9.48k|#define isintwups(L) (L->twups != L) ------------------ | Branch (650:9): [True: 1.41k, False: 3.33k] | Branch (650:27): [True: 0, False: 1.41k] ------------------ 651| 0| th->twups = g->twups; /* link it back to the list */ 652| 0| g->twups = th; 653| 0| } 654| 4.74k| } 655| 9.48k|} lgc.c:remarkupvals: 363| 4.74k|static l_obj remarkupvals (global_State *g) { 364| 4.74k| l_obj work = 0; 365| 4.74k| lua_State *thread; 366| 4.74k| lua_State **p = &g->twups; 367| 8.07k| while ((thread = *p) != NULL) { ------------------ | Branch (367:10): [True: 3.33k, False: 4.74k] ------------------ 368| 3.33k| if (!iswhite(thread) && thread->openupval != NULL) ------------------ | | 90| 3.33k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 65| 6.67k|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (368:9): [True: 3.33k, False: 0] | Branch (368:29): [True: 3.33k, False: 7] ------------------ 369| 3.33k| p = &thread->twups; /* keep marked thread with upvalues in the list */ 370| 7| else { /* thread is not marked or without upvalues */ 371| 7| UpVal *uv; 372| 7| lua_assert(!isold(thread) || thread->openupval == NULL); ------------------ | | 109| 7|#define lua_assert(c) assert(c) ------------------ 373| 7| *p = thread->twups; /* remove thread from the list */ 374| 7| thread->twups = thread; /* mark that it is out of list */ 375| 7| for (uv = thread->openupval; uv != NULL; uv = uv->u.open.next) { ------------------ | Branch (375:36): [True: 0, False: 7] ------------------ 376| 0| lua_assert(getage(uv) <= getage(thread)); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ 377| 0| if (!iswhite(uv)) { /* upvalue already visited? */ ------------------ | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (377:13): [True: 0, False: 0] ------------------ 378| 0| lua_assert(upisopen(uv) && isgray(uv)); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ 379| 0| markvalue(g, uv->v.p); /* mark its value */ ------------------ | | 83| 0|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 84| 0| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 65| 0|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 313| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 311| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (313:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 318| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 380| 0| } 381| 0| } 382| 7| } 383| 3.33k| work++; 384| 3.33k| } 385| 4.74k| return work; 386| 4.74k|} lgc.c:convergeephemerons: 693| 9.48k|static l_obj convergeephemerons (global_State *g) { 694| 9.48k| int changed; 695| 9.48k| l_obj work = 0; 696| 9.48k| int dir = 0; 697| 9.48k| do { 698| 9.48k| GCObject *w; 699| 9.48k| GCObject *next = g->ephemeron; /* get ephemeron list */ 700| 9.48k| g->ephemeron = NULL; /* tables may return to this list when traversed */ 701| 9.48k| changed = 0; 702| 9.48k| while ((w = next) != NULL) { /* for each ephemeron table */ ------------------ | Branch (702:12): [True: 0, False: 9.48k] ------------------ 703| 0| Table *h = gco2t(w); ------------------ | | 378| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 704| 0| next = h->gclist; /* list is rebuilt during loop */ 705| 0| nw2black(h); /* out of the list (for now) */ ------------------ | | 103| 0| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 706| 0| if (traverseephemeron(g, h, dir)) { /* marked some value? */ ------------------ | Branch (706:11): [True: 0, False: 0] ------------------ 707| 0| propagateall(g); /* propagate changes */ 708| 0| changed = 1; /* will have to revisit all ephemeron tables */ 709| 0| } 710| 0| work++; 711| 0| } 712| 9.48k| dir = !dir; /* invert direction next time */ 713| 9.48k| } while (changed); /* repeat until no more changes */ ------------------ | Branch (713:12): [True: 0, False: 9.48k] ------------------ 714| 9.48k| return work; 715| 9.48k|} lgc.c:clearbyvalues: 752| 18.9k|static l_obj clearbyvalues (global_State *g, GCObject *l, GCObject *f) { 753| 18.9k| l_obj work = 0; 754| 18.9k| for (; l != f; l = gco2t(l)->gclist) { ------------------ | | 378| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (754:10): [True: 0, False: 18.9k] ------------------ 755| 0| Table *h = gco2t(l); ------------------ | | 378| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 756| 0| Node *n, *limit = gnodelast(h); ------------------ | | 112| 0|#define gnodelast(h) gnode(h, cast_sizet(sizenode(h))) | | ------------------ | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 757| 0| unsigned int i; 758| 0| unsigned int asize = luaH_realasize(h); 759| 0| for (i = 0; i < asize; i++) { ------------------ | Branch (759:17): [True: 0, False: 0] ------------------ 760| 0| GCObject *o = gcvalarr(h, i); ------------------ | | 80| 0| ((*getArrTag(t,i) & BIT_ISCOLLECTABLE) ? getArrVal(t,i)->gc : NULL) | | ------------------ | | | | 106| 0|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | ((*getArrTag(t,i) & BIT_ISCOLLECTABLE) ? getArrVal(t,i)->gc : NULL) | | ------------------ | | | | 311| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ | | ((*getArrTag(t,i) & BIT_ISCOLLECTABLE) ? getArrVal(t,i)->gc : NULL) | | ------------------ | | | | 109| 0|#define getArrVal(t,k) ((t)->array - 1 - (k)) | | ------------------ | | | Branch (80:3): [True: 0, False: 0] | | ------------------ ------------------ 761| 0| if (iscleared(g, o)) /* value was collected? */ ------------------ | Branch (761:11): [True: 0, False: 0] ------------------ 762| 0| *getArrTag(h, i) = LUA_VEMPTY; /* remove entry */ ------------------ | | 106| 0|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ *getArrTag(h, i) = LUA_VEMPTY; /* remove entry */ ------------------ | | 186| 0|#define LUA_VEMPTY makevariant(LUA_TNIL, 1) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 763| 0| } 764| 0| for (n = gnode(h, 0); n < limit; n++) { ------------------ | | 13| 0|#define gnode(t,i) (&(t)->node[i]) ------------------ | Branch (764:27): [True: 0, False: 0] ------------------ 765| 0| if (iscleared(g, gcvalueN(gval(n)))) /* unmarked value? */ ------------------ | | 73| 0|#define gcvalueN(o) (iscollectable(o) ? gcvalue(o) : NULL) | | ------------------ | | | | 313| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 311| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (313:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define gcvalueN(o) (iscollectable(o) ? gcvalue(o) : NULL) | | ------------------ | | | | 318| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (765:11): [True: 0, False: 0] ------------------ 766| 0| setempty(gval(n)); /* remove entry */ ------------------ | | 236| 0|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 767| 0| if (isempty(gval(n))) /* is entry empty? */ ------------------ | | 228| 0|#define isempty(v) ttisnil(v) | | ------------------ | | | | 196| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 768| 0| clearkey(n); /* clear its key */ 769| 0| } 770| 0| work++; 771| 0| } 772| 18.9k| return work; 773| 18.9k|} lgc.c:markbeingfnz: 341| 9.48k|static l_obj markbeingfnz (global_State *g) { 342| 9.48k| GCObject *o; 343| 9.48k| l_obj count = 0; 344| 9.48k| for (o = g->tobefnz; o != NULL; o = o->next) { ------------------ | Branch (344:24): [True: 0, False: 9.48k] ------------------ 345| 0| count++; 346| 0| markobject(g, o); ------------------ | | 88| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 347| 0| } 348| 9.48k| return count; 349| 9.48k|} lgc.c:clearbykeys: 730| 9.48k|static l_obj clearbykeys (global_State *g, GCObject *l) { 731| 9.48k| l_obj work = 0; 732| 9.48k| for (; l; l = gco2t(l)->gclist) { ------------------ | | 378| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (732:10): [True: 0, False: 9.48k] ------------------ 733| 0| Table *h = gco2t(l); ------------------ | | 378| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 734| 0| Node *limit = gnodelast(h); ------------------ | | 112| 0|#define gnodelast(h) gnode(h, cast_sizet(sizenode(h))) | | ------------------ | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 735| 0| Node *n; 736| 0| for (n = gnode(h, 0); n < limit; n++) { ------------------ | | 13| 0|#define gnode(t,i) (&(t)->node[i]) ------------------ | Branch (736:27): [True: 0, False: 0] ------------------ 737| 0| if (iscleared(g, gckeyN(n))) /* unmarked key? */ ------------------ | | 805| 0|#define gckeyN(n) (keyiscollectable(n) ? gckey(n) : NULL) | | ------------------ | | | | 802| 0|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 791| 0|#define keytt(node) ((node)->u.key_tt) | | | | ------------------ | | | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 311| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (802:29): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define gckeyN(n) (keyiscollectable(n) ? gckey(n) : NULL) | | ------------------ | | | | 804| 0|#define gckey(n) (keyval(n).gc) | | | | ------------------ | | | | | | 792| 0|#define keyval(node) ((node)->u.key_val) | | | | ------------------ | | ------------------ ------------------ | Branch (737:11): [True: 0, False: 0] ------------------ 738| 0| setempty(gval(n)); /* remove entry */ ------------------ | | 236| 0|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 739| 0| if (isempty(gval(n))) /* is entry empty? */ ------------------ | | 228| 0|#define isempty(v) ttisnil(v) | | ------------------ | | | | 196| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 740| 0| clearkey(n); /* clear its key */ 741| 0| } 742| 0| work++; 743| 0| } 744| 9.48k| return work; 745| 9.48k|} lgc.c:cleargraylists: 389| 4.74k|static void cleargraylists (global_State *g) { 390| 4.74k| g->gray = g->grayagain = NULL; 391| 4.74k| g->weak = g->allweak = g->ephemeron = NULL; 392| 4.74k|} lgc.c:checkSizes: 882| 4.70k|static void checkSizes (lua_State *L, global_State *g) { 883| 4.70k| if (!g->gcemergency) { ------------------ | Branch (883:7): [True: 4.70k, False: 0] ------------------ 884| 4.70k| if (g->strt.nuse < g->strt.size / 4) /* string table too big? */ ------------------ | Branch (884:9): [True: 0, False: 4.70k] ------------------ 885| 0| luaS_resize(L, g->strt.size / 2); 886| 4.70k| } 887| 4.70k|} lgc.c:separatetobefnz: 970| 5.30k|static void separatetobefnz (global_State *g, int all) { 971| 5.30k| GCObject *curr; 972| 5.30k| GCObject **p = &g->finobj; 973| 5.30k| GCObject **lastnext = findlast(&g->tobefnz); 974| 5.38k| while ((curr = *p) != g->finobjold1) { /* traverse all finalizable objects */ ------------------ | Branch (974:10): [True: 86, False: 5.30k] ------------------ 975| 86| lua_assert(tofinalize(curr)); ------------------ | | 109| 86|#define lua_assert(c) assert(c) ------------------ 976| 86| if (!(iswhite(curr) || all)) /* not being collected? */ ------------------ | | 90| 86|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 65| 172|#define testbits(x,m) ((x) & (m)) | | | | ------------------ | | | | | Branch (65:24): [True: 45, False: 41] | | | | ------------------ | | ------------------ ------------------ | Branch (976:28): [True: 0, False: 41] ------------------ 977| 41| p = &curr->next; /* don't bother with it */ 978| 45| else { 979| 45| if (curr == g->finobjsur) /* removing 'finobjsur'? */ ------------------ | Branch (979:11): [True: 0, False: 45] ------------------ 980| 0| g->finobjsur = curr->next; /* correct it */ 981| 45| *p = curr->next; /* remove 'curr' from 'finobj' list */ 982| 45| curr->next = *lastnext; /* link at the end of 'tobefnz' list */ 983| 45| *lastnext = curr; 984| 45| lastnext = &curr->next; 985| 45| } 986| 86| } 987| 5.30k|} lgc.c:findlast: 956| 5.30k|static GCObject **findlast (GCObject **p) { 957| 5.30k| while (*p != NULL) ------------------ | Branch (957:10): [True: 0, False: 5.30k] ------------------ 958| 0| p = &(*p)->next; 959| 5.30k| return p; 960| 5.30k|} lgc.c:callallpendingfinalizers: 946| 561|static void callallpendingfinalizers (lua_State *L) { 947| 561| global_State *g = G(L); ------------------ | | 333| 561|#define G(L) (L->l_G) ------------------ 948| 606| while (g->tobefnz) ------------------ | Branch (948:10): [True: 45, False: 561] ------------------ 949| 45| GCTM(L); 950| 561|} lgc.c:GCTM: 915| 45|static void GCTM (lua_State *L) { 916| 45| global_State *g = G(L); ------------------ | | 333| 45|#define G(L) (L->l_G) ------------------ 917| 45| const TValue *tm; 918| 45| TValue v; 919| 45| lua_assert(!g->gcemergency); ------------------ | | 109| 45|#define lua_assert(c) assert(c) ------------------ 920| 45| setgcovalue(L, &v, udata2finalize(g)); ------------------ | | 323| 45| { TValue *io = (obj); GCObject *i_g=(x); \ | | 324| 45| val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); } | | ------------------ | | | | 72| 45|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); } | | ------------------ | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 921| 45| tm = luaT_gettmbyobj(L, &v, TM_GC); 922| 45| if (!notm(tm)) { /* is there a finalizer? */ ------------------ | | 61| 45|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 196| 45|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 45|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 45|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 45|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (922:7): [True: 45, False: 0] ------------------ 923| 45| int status; 924| 45| lu_byte oldah = L->allowhook; 925| 45| int oldgcstp = g->gcstp; 926| 45| g->gcstp |= GCSTPGC; /* avoid GC steps */ ------------------ | | 203| 45|#define GCSTPGC 2 /* bit true when GC stopped by itself */ ------------------ 927| 45| L->allowhook = 0; /* stop debug hooks during GC metamethod */ 928| 45| setobj2s(L, L->top.p++, tm); /* push finalizer... */ ------------------ | | 131| 45|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 45| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 45| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 45| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 45| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 45|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 45| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 929| 45| setobj2s(L, L->top.p++, &v); /* ... and its argument */ ------------------ | | 131| 45|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 45| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 45| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 45| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 45| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 720|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 45, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 45] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 45| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 930| 45| L->ci->callstatus |= CIST_FIN; /* will run a finalizer */ ------------------ | | 218| 45|#define CIST_FIN (1<<7) /* function "called" a finalizer */ ------------------ 931| 45| status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top.p - 2), 0); ------------------ | | 36| 45|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 45|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 45|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 149| 45|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 139| 45|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 932| 45| L->ci->callstatus &= ~CIST_FIN; /* not running a finalizer anymore */ ------------------ | | 218| 45|#define CIST_FIN (1<<7) /* function "called" a finalizer */ ------------------ 933| 45| L->allowhook = oldah; /* restore hooks */ 934| 45| g->gcstp = oldgcstp; /* restore state */ 935| 45| if (l_unlikely(status != LUA_OK)) { /* error while running __gc? */ ------------------ | | 697| 45|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 45|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 45] | | | | ------------------ | | ------------------ ------------------ 936| 0| luaE_warnerror(L, "__gc"); 937| 0| L->top.p--; /* pops error object */ 938| 0| } 939| 45| } 940| 45|} lgc.c:udata2finalize: 894| 45|static GCObject *udata2finalize (global_State *g) { 895| 45| GCObject *o = g->tobefnz; /* get first element */ 896| 45| lua_assert(tofinalize(o)); ------------------ | | 109| 45|#define lua_assert(c) assert(c) ------------------ 897| 45| g->tobefnz = o->next; /* remove it from 'tobefnz' list */ 898| 45| o->next = g->allgc; /* return it to 'allgc' list */ 899| 45| g->allgc = o; 900| 45| resetbit(o->marked, FINALIZEDBIT); /* object is "normal" again */ ------------------ | | 69| 45|#define resetbit(x,b) resetbits(x, bitmask(b)) | | ------------------ | | | | 63| 45|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 146| 45|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 139| 45|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 901| 45| if (issweepphase(g)) ------------------ | | 46| 45| (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 37| 45|#define GCSswpallgc 3 | | ------------------ | | (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 40| 45|#define GCSswpend 6 | | ------------------ | | | Branch (46:3): [True: 45, False: 0] | | | Branch (46:34): [True: 0, False: 45] | | ------------------ ------------------ 902| 0| makewhite(g, o); /* "sweep" object */ ------------------ | | 54| 0| (x->marked = cast_byte((x->marked & ~maskcolors) | luaC_white(g))) | | ------------------ | | | | 146| 0|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 903| 45| else if (getage(o) == G_OLD1) ------------------ | | 119| 45|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 117| 45|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ else if (getage(o) == G_OLD1) ------------------ | | 112| 45|#define G_OLD1 3 /* first full cycle as old */ ------------------ | Branch (903:12): [True: 0, False: 45] ------------------ 904| 0| g->firstold1 = o; /* it is the first OLD1 object in the list */ 905| 45| return o; 906| 45|} lgc.c:dothecall: 909| 45|static void dothecall (lua_State *L, void *ud) { 910| 45| UNUSED(ud); ------------------ | | 134| 45|#define UNUSED(x) ((void)(x)) ------------------ 911| 45| luaD_callnoyield(L, L->top.p - 2, 0); 912| 45|} lgc.c:deletelist: 1450| 1.12k|static void deletelist (lua_State *L, GCObject *p, GCObject *limit) { 1451| 179k| while (p != limit) { ------------------ | Branch (1451:10): [True: 178k, False: 1.12k] ------------------ 1452| 178k| GCObject *next = p->next; 1453| 178k| freeobj(L, p); 1454| 178k| p = next; 1455| 178k| } 1456| 1.12k|} lgc.c:singlestep: 1547| 1.27M|static l_obj singlestep (lua_State *L, int fast) { 1548| 1.27M| global_State *g = G(L); ------------------ | | 333| 1.27M|#define G(L) (L->l_G) ------------------ 1549| 1.27M| l_obj work; 1550| 1.27M| lua_assert(!g->gcstopem); /* collector is not reentrant */ ------------------ | | 109| 1.27M|#define lua_assert(c) assert(c) ------------------ 1551| 1.27M| g->gcstopem = 1; /* no emergency collections while collecting */ 1552| 1.27M| switch (g->gcstate) { 1553| 4.74k| case GCSpause: { ------------------ | | 42| 4.74k|#define GCSpause 8 ------------------ | Branch (1553:5): [True: 4.74k, False: 1.27M] ------------------ 1554| 4.74k| restartcollection(g); 1555| 4.74k| g->gcstate = GCSpropagate; ------------------ | | 34| 4.74k|#define GCSpropagate 0 ------------------ 1556| 4.74k| work = 1; 1557| 4.74k| break; 1558| 0| } 1559| 1.04M| case GCSpropagate: { ------------------ | | 34| 1.04M|#define GCSpropagate 0 ------------------ | Branch (1559:5): [True: 1.04M, False: 231k] ------------------ 1560| 1.04M| if (fast || g->gray == NULL) { ------------------ | Branch (1560:11): [True: 0, False: 1.04M] | Branch (1560:19): [True: 4.74k, False: 1.03M] ------------------ 1561| 4.74k| g->gcstate = GCSenteratomic; /* finish propagate phase */ ------------------ | | 35| 4.74k|#define GCSenteratomic 1 ------------------ 1562| 4.74k| work = 0; 1563| 4.74k| } 1564| 1.03M| else { 1565| 1.03M| propagatemark(g); /* traverse one gray object */ 1566| 1.03M| work = 1; 1567| 1.03M| } 1568| 1.04M| break; 1569| 0| } 1570| 4.74k| case GCSenteratomic: { ------------------ | | 35| 4.74k|#define GCSenteratomic 1 ------------------ | Branch (1570:5): [True: 4.74k, False: 1.27M] ------------------ 1571| 4.74k| work = atomic(L); 1572| 4.74k| if (checkmajorminor(L, g)) ------------------ | Branch (1572:11): [True: 4.74k, False: 0] ------------------ 1573| 4.74k| entersweep(L); 1574| 4.74k| break; 1575| 0| } 1576| 193k| case GCSswpallgc: { /* sweep "regular" objects */ ------------------ | | 37| 193k|#define GCSswpallgc 3 ------------------ | Branch (1576:5): [True: 193k, False: 1.08M] ------------------ 1577| 193k| sweepstep(L, g, GCSswpfinobj, &g->finobj, fast); ------------------ | | 38| 193k|#define GCSswpfinobj 4 ------------------ 1578| 193k| work = GCSWEEPMAX; ------------------ | | 42| 193k|#define GCSWEEPMAX 20 ------------------ 1579| 193k| break; 1580| 0| } 1581| 9.42k| case GCSswpfinobj: { /* sweep objects with finalizers */ ------------------ | | 38| 9.42k|#define GCSswpfinobj 4 ------------------ | Branch (1581:5): [True: 9.42k, False: 1.26M] ------------------ 1582| 9.42k| sweepstep(L, g, GCSswptobefnz, &g->tobefnz, fast); ------------------ | | 39| 9.42k|#define GCSswptobefnz 5 ------------------ 1583| 9.42k| work = GCSWEEPMAX; ------------------ | | 42| 9.42k|#define GCSWEEPMAX 20 ------------------ 1584| 9.42k| break; 1585| 0| } 1586| 9.41k| case GCSswptobefnz: { /* sweep objects to be finalized */ ------------------ | | 39| 9.41k|#define GCSswptobefnz 5 ------------------ | Branch (1586:5): [True: 9.41k, False: 1.26M] ------------------ 1587| 9.41k| sweepstep(L, g, GCSswpend, NULL, fast); ------------------ | | 40| 9.41k|#define GCSswpend 6 ------------------ 1588| 9.41k| work = GCSWEEPMAX; ------------------ | | 42| 9.41k|#define GCSWEEPMAX 20 ------------------ 1589| 9.41k| break; 1590| 0| } 1591| 4.70k| case GCSswpend: { /* finish sweeps */ ------------------ | | 40| 4.70k|#define GCSswpend 6 ------------------ | Branch (1591:5): [True: 4.70k, False: 1.27M] ------------------ 1592| 4.70k| checkSizes(L, g); 1593| 4.70k| g->gcstate = GCScallfin; ------------------ | | 41| 4.70k|#define GCScallfin 7 ------------------ 1594| 4.70k| work = 0; 1595| 4.70k| break; 1596| 0| } 1597| 4.70k| case GCScallfin: { /* call finalizers */ ------------------ | | 41| 4.70k|#define GCScallfin 7 ------------------ | Branch (1597:5): [True: 4.70k, False: 1.27M] ------------------ 1598| 4.70k| if (g->tobefnz && !g->gcemergency) { ------------------ | Branch (1598:11): [True: 0, False: 4.70k] | Branch (1598:25): [True: 0, False: 0] ------------------ 1599| 0| g->gcstopem = 0; /* ok collections during finalizers */ 1600| 0| GCTM(L); /* call one finalizer */ 1601| 0| work = 1; 1602| 0| } 1603| 4.70k| else { /* emergency mode or no more finalizers */ 1604| 4.70k| g->gcstate = GCSpause; /* finish collection */ ------------------ | | 42| 4.70k|#define GCSpause 8 ------------------ 1605| 4.70k| work = 0; 1606| 4.70k| } 1607| 4.70k| break; 1608| 0| } 1609| 0| default: lua_assert(0); return 0; ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ | Branch (1609:5): [True: 0, False: 1.27M] ------------------ 1610| 1.27M| } 1611| 1.27M| g->gcstopem = 0; 1612| 1.27M| return work; 1613| 1.27M|} lgc.c:restartcollection: 402| 4.74k|static void restartcollection (global_State *g) { 403| 4.74k| cleargraylists(g); 404| 4.74k| g->marked = NFIXED; ------------------ | | 34| 4.74k|#define NFIXED (TM_N + NUM_RESERVED + 2) | | ------------------ | | | | 46| 4.74k|#define NUM_RESERVED (cast_int(TK_WHILE-FIRST_RESERVED + 1)) | | | | ------------------ | | | | | | 144| 4.74k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 4.74k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 405| 4.74k| markobject(g, g->mainthread); ------------------ | | 88| 4.74k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 90| 4.74k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 4.74k|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 4.74k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 388| 4.74k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 4.74k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 4.74k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 406| 4.74k| markvalue(g, &g->l_registry); ------------------ | | 83| 4.74k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 4.74k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 75.9k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 4.74k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 4.74k] | | | | | | | Branch (115:29): [True: 4.74k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 4.74k] | | | | | | | Branch (115:29): [True: 4.74k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 4.74k] | | | | | | | Branch (115:29): [True: 4.74k, False: 0] | | | | | | | Branch (115:29): [True: 4.74k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 4.74k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 4.74k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 84| 4.74k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 65| 4.74k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 313| 9.49k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 4.74k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 311| 4.74k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (313:26): [True: 4.74k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 90| 4.74k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 18.9k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 4.74k, False: 0] | | | | | | | | | Branch (65:26): [True: 0, False: 4.74k] | | | | | | | | | Branch (65:26): [True: 4.74k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 318| 4.74k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 113| 4.74k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 4.74k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 407| 4.74k| markmt(g); 408| 4.74k| markbeingfnz(g); /* mark any finalizing object left from previous cycle */ 409| 4.74k|} lgc.c:checkmajorminor: 1405| 4.74k|static int checkmajorminor (lua_State *L, global_State *g) { 1406| 4.74k| if (g->gckind == KGC_GENMAJOR) { /* generational mode? */ ------------------ | | 153| 4.74k|#define KGC_GENMAJOR 2 /* generational in major mode */ ------------------ | Branch (1406:7): [True: 0, False: 4.74k] ------------------ 1407| 0| l_obj numobjs = gettotalobjs(g); ------------------ | | 392| 0|#define gettotalobjs(g) ((g)->totalobjs - (g)->GCdebt) ------------------ 1408| 0| l_obj addedobjs = numobjs - g->GCmajorminor; 1409| 0| l_obj limit = applygcparam(g, MAJORMINOR, addedobjs); ------------------ | | 197| 0|#define applygcparam(g,p,x) luaO_applyparam(g->gcparams[LUA_GCP##p], x) ------------------ 1410| 0| l_obj tobecollected = numobjs - g->marked; 1411| 0| if (tobecollected > limit) { ------------------ | Branch (1411:9): [True: 0, False: 0] ------------------ 1412| 0| atomic2gen(L, g); /* return to generational mode */ 1413| 0| setminordebt(g); 1414| 0| return 0; /* exit incremental collection */ 1415| 0| } 1416| 0| } 1417| 4.74k| g->GCmajorminor = g->marked; /* prepare for next collection */ 1418| 4.74k| return 1; /* stay doing incremental collections */ 1419| 4.74k|} lgc.c:sweepstep: 1525| 212k| int nextstate, GCObject **nextlist, int fast) { 1526| 212k| if (g->sweepgc) ------------------ | Branch (1526:7): [True: 198k, False: 14.1k] ------------------ 1527| 198k| g->sweepgc = sweeplist(L, g->sweepgc, fast ? MAX_LOBJ : GCSWEEPMAX); ------------------ | | 37| 0| cast(l_obj, (cast(lu_mem, 1) << (sizeof(l_obj) * CHAR_BIT - 1)) - 1) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ g->sweepgc = sweeplist(L, g->sweepgc, fast ? MAX_LOBJ : GCSWEEPMAX); ------------------ | | 42| 198k|#define GCSWEEPMAX 20 ------------------ | Branch (1527:43): [True: 0, False: 198k] ------------------ 1528| 14.1k| else { /* enter next state */ 1529| 14.1k| g->gcstate = nextstate; 1530| 14.1k| g->sweepgc = nextlist; 1531| 14.1k| } 1532| 212k|} lgc.c:incstep: 1637| 13.5k|static void incstep (lua_State *L, global_State *g) { 1638| 13.5k| l_obj stepsize = applygcparam(g, STEPSIZE, 100); ------------------ | | 197| 13.5k|#define applygcparam(g,p,x) luaO_applyparam(g->gcparams[LUA_GCP##p], x) ------------------ 1639| 13.5k| l_obj work2do = applygcparam(g, STEPMUL, stepsize); ------------------ | | 197| 13.5k|#define applygcparam(g,p,x) luaO_applyparam(g->gcparams[LUA_GCP##p], x) ------------------ 1640| 13.5k| int fast = 0; 1641| 13.5k| if (work2do == 0) { /* special case: do a full collection */ ------------------ | Branch (1641:7): [True: 0, False: 13.5k] ------------------ 1642| 0| work2do = MAX_LOBJ; /* do unlimited work */ ------------------ | | 37| 0| cast(l_obj, (cast(lu_mem, 1) << (sizeof(l_obj) * CHAR_BIT - 1)) - 1) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1643| 0| fast = 1; 1644| 0| } 1645| 1.27M| do { /* repeat until pause or enough work */ 1646| 1.27M| l_obj work = singlestep(L, fast); /* perform one single step */ 1647| 1.27M| if (g->gckind == KGC_GENMINOR) /* returned to minor collections? */ ------------------ | | 152| 1.27M|#define KGC_GENMINOR 1 /* generational gc in minor (regular) mode */ ------------------ | Branch (1647:9): [True: 0, False: 1.27M] ------------------ 1648| 0| return; /* nothing else to be done here */ 1649| 1.27M| work2do -= work; 1650| 1.27M| } while (work2do > 0 && g->gcstate != GCSpause); ------------------ | | 42| 1.26M|#define GCSpause 8 ------------------ | Branch (1650:12): [True: 1.26M, False: 8.86k] | Branch (1650:27): [True: 1.26M, False: 4.70k] ------------------ 1651| 13.5k| if (g->gcstate == GCSpause) ------------------ | | 42| 13.5k|#define GCSpause 8 ------------------ | Branch (1651:7): [True: 4.70k, False: 8.86k] ------------------ 1652| 4.70k| setpause(g); /* pause until next cycle */ 1653| 8.86k| else 1654| 8.86k| luaE_setdebt(g, stepsize); 1655| 13.5k|} lgc.c:setpause: 1054| 4.70k|static void setpause (global_State *g) { 1055| 4.70k| l_obj threshold = applygcparam(g, PAUSE, g->marked); ------------------ | | 197| 4.70k|#define applygcparam(g,p,x) luaO_applyparam(g->gcparams[LUA_GCP##p], x) ------------------ 1056| 4.70k| l_obj debt = threshold - gettotalobjs(g); ------------------ | | 392| 4.70k|#define gettotalobjs(g) ((g)->totalobjs - (g)->GCdebt) ------------------ 1057| 4.70k| if (debt < 0) debt = 0; ------------------ | Branch (1057:7): [True: 3.12k, False: 1.57k] ------------------ 1058| 4.70k| luaE_setdebt(g, debt); 1059| 4.70k|} luaX_init: 70| 561|void luaX_init (lua_State *L) { 71| 561| int i; 72| 561| TString *e = luaS_newliteral(L, LUA_ENV); /* create env name */ ------------------ | | 30| 561|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 31| 561| (sizeof(s)/sizeof(char))-1)) ------------------ 73| 561| luaC_fix(L, obj2gco(e)); /* never collect this name */ ------------------ | | 388| 561|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 113| 561|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 74| 12.9k| for (i=0; itt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 113| 12.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 12.3k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 77| 12.3k| ts->extra = cast_byte(i+1); /* reserved word */ ------------------ | | 146| 12.3k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 139| 12.3k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 78| 12.3k| } 79| 561|} luaX_token2str: 82| 343|const char *luaX_token2str (LexState *ls, int token) { 83| 343| if (token < FIRST_RESERVED) { /* single-byte symbols? */ ------------------ | | 20| 343|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ | Branch (83:7): [True: 225, False: 118] ------------------ 84| 225| if (lisprint(token)) ------------------ | | 61| 225|#define lisprint(c) testprop(c, MASK(PRINTBIT)) | | ------------------ | | | | 52| 225|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 163, False: 62] | | | | ------------------ | | ------------------ ------------------ 85| 163| return luaO_pushfstring(ls->L, "'%c'", token); 86| 62| else /* control character */ 87| 62| return luaO_pushfstring(ls->L, "'<\\%d>'", token); 88| 225| } 89| 118| else { 90| 118| const char *s = luaX_tokens[token - FIRST_RESERVED]; ------------------ | | 20| 118|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ 91| 118| if (token < TK_EOS) /* fixed format (symbols and reserved words)? */ ------------------ | Branch (91:9): [True: 50, False: 68] ------------------ 92| 50| return luaO_pushfstring(ls->L, "'%s'", s); 93| 68| else /* names, strings, and numerals */ 94| 68| return s; 95| 118| } 96| 343|} luaX_syntaxerror: 119| 234|l_noret luaX_syntaxerror (LexState *ls, const char *msg) { 120| 234| lexerror(ls, msg, ls->t.token); 121| 234|} luaX_newstring: 134| 26.8M|TString *luaX_newstring (LexState *ls, const char *str, size_t l) { 135| 26.8M| lua_State *L = ls->L; 136| 26.8M| TString *ts = luaS_newlstr(L, str, l); /* create new string */ 137| 26.8M| TString *oldts = luaH_getstrkey(ls->h, ts); 138| 26.8M| if (oldts != NULL) /* string already present? */ ------------------ | Branch (138:7): [True: 26.8M, False: 32.1k] ------------------ 139| 26.8M| return oldts; /* use it */ 140| 32.1k| else { /* create a new entry */ 141| 32.1k| TValue *stv = s2v(L->top.p++); /* reserve stack space for string */ ------------------ | | 172| 32.1k|#define s2v(o) (&(o)->val) ------------------ 142| 32.1k| setsvalue(L, stv, ts); /* temporarily anchor the string */ ------------------ | | 385| 32.1k| { TValue *io = (obj); TString *x_ = (x); \ | | 386| 32.1k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 32.1k|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 388| 32.1k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 32.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 32.1k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 32.1k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 387| 32.1k| checkliveness(L,io); } | | ------------------ | | | | 107| 32.1k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 513k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 32.1k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 32.1k] | | | | | | | Branch (115:29): [True: 32.1k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 32.1k] | | | | | | | Branch (115:29): [True: 32.1k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 32.1k] | | | | | | | Branch (115:29): [True: 32.1k, False: 0] | | | | | | | Branch (115:29): [True: 32.1k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 32.1k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 32.1k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 143| 32.1k| luaH_set(L, ls->h, stv, stv); /* t[string] = string */ 144| | /* table is not a metatable, so it does not need to invalidate cache */ 145| 32.1k| luaC_checkGC(L); ------------------ | | 219| 32.1k|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 215| 32.1k| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 32.1k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 1.11k, False: 31.0k] | | | | ------------------ | | | | 216| 32.1k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 32.1k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 146| 32.1k| L->top.p--; /* remove string from stack */ 147| 32.1k| } 148| 32.1k| return ts; 149| 26.8M|} luaX_setinput: 168| 561| int firstchar) { 169| 561| ls->t.token = 0; 170| 561| ls->L = L; 171| 561| ls->current = firstchar; 172| 561| ls->lookahead.token = TK_EOS; /* no look-ahead token */ 173| 561| ls->z = z; 174| 561| ls->fs = NULL; 175| 561| ls->linenumber = 1; 176| 561| ls->lastline = 1; 177| 561| ls->source = source; 178| 561| ls->envn = luaS_newliteral(L, LUA_ENV); /* get env name */ ------------------ | | 30| 561|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 31| 561| (sizeof(s)/sizeof(char))-1)) ------------------ 179| 561| luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */ ------------------ | | 40| 561| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | ------------------ | | | | 53| 561| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | ------------------ | | | | | | 149| 561|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 561|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 41| 561| (buff)->buffsize, size), \ | | 42| 561| (buff)->buffsize = size) ------------------ 180| 561|} luaX_next: 565| 56.0M|void luaX_next (LexState *ls) { 566| 56.0M| ls->lastline = ls->linenumber; 567| 56.0M| if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */ ------------------ | Branch (567:7): [True: 1.54M, False: 54.4M] ------------------ 568| 1.54M| ls->t = ls->lookahead; /* use this one */ 569| 1.54M| ls->lookahead.token = TK_EOS; /* and discharge it */ 570| 1.54M| } 571| 54.4M| else 572| 54.4M| ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */ 573| 56.0M|} luaX_lookahead: 576| 1.54M|int luaX_lookahead (LexState *ls) { 577| 1.54M| lua_assert(ls->lookahead.token == TK_EOS); ------------------ | | 109| 1.54M|#define lua_assert(c) assert(c) ------------------ 578| 1.54M| ls->lookahead.token = llex(ls, &ls->lookahead.seminfo); 579| 1.54M| return ls->lookahead.token; 580| 1.54M|} llex.c:lexerror: 111| 393|static l_noret lexerror (LexState *ls, const char *msg, int token) { 112| 393| msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber); 113| 393| if (token) ------------------ | Branch (113:7): [True: 385, False: 8] ------------------ 114| 385| luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token)); 115| 393| luaD_throw(ls->L, LUA_ERRSYNTAX); ------------------ | | 51| 393|#define LUA_ERRSYNTAX 3 ------------------ 116| 393|} llex.c:txtToken: 99| 385|static const char *txtToken (LexState *ls, int token) { 100| 385| switch (token) { 101| 103| case TK_NAME: case TK_STRING: ------------------ | Branch (101:5): [True: 33, False: 352] | Branch (101:19): [True: 70, False: 315] ------------------ 102| 161| case TK_FLT: case TK_INT: ------------------ | Branch (102:5): [True: 50, False: 335] | Branch (102:18): [True: 8, False: 377] ------------------ 103| 161| save(ls, '\0'); 104| 161| return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff)); ------------------ | | 31| 161|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 105| 224| default: ------------------ | Branch (105:5): [True: 224, False: 161] ------------------ 106| 224| return luaX_token2str(ls, token); 107| 385| } 108| 385|} llex.c:save: 57| 89.8M|static void save (LexState *ls, int c) { 58| 89.8M| Mbuffer *b = ls->buff; 59| 89.8M| if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { ------------------ | | 33| 89.8M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { ------------------ | | 32| 89.8M|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ | Branch (59:7): [True: 3.19k, False: 89.8M] ------------------ 60| 3.19k| size_t newsize; 61| 3.19k| if (luaZ_sizebuffer(b) >= MAX_SIZE/2) ------------------ | | 32| 3.19k|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ if (luaZ_sizebuffer(b) >= MAX_SIZE/2) ------------------ | | 52| 3.19k|#define MAX_SIZE (sizeof(size_t) < sizeof(lua_Integer) ? MAX_SIZET \ | | ------------------ | | | | 46| 0|#define MAX_SIZET ((size_t)(~(size_t)0)) | | ------------------ | | | Branch (52:19): [Folded - Ignored] | | ------------------ | | 53| 3.19k| : (size_t)(LUA_MAXINTEGER)) | | ------------------ | | | | 554| 3.19k|#define LUA_MAXINTEGER LLONG_MAX | | ------------------ ------------------ | Branch (61:9): [True: 0, False: 3.19k] ------------------ 62| 0| lexerror(ls, "lexical element too long", 0); 63| 3.19k| newsize = luaZ_sizebuffer(b) * 2; ------------------ | | 32| 3.19k|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ 64| 3.19k| luaZ_resizebuffer(ls->L, b, newsize); ------------------ | | 40| 3.19k| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | ------------------ | | | | 53| 3.19k| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | ------------------ | | | | | | 149| 3.19k|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 3.19k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 41| 3.19k| (buff)->buffsize, size), \ | | 42| 3.19k| (buff)->buffsize = size) ------------------ 65| 3.19k| } 66| 89.8M| b->buffer[luaZ_bufflen(b)++] = cast_char(c); ------------------ | | 33| 89.8M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ b->buffer[luaZ_bufflen(b)++] = cast_char(c); ------------------ | | 148| 89.8M|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 139| 89.8M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 67| 89.8M|} llex.c:llex: 445| 56.0M|static int llex (LexState *ls, SemInfo *seminfo) { 446| 56.0M| luaZ_resetbuffer(ls->buff); ------------------ | | 36| 56.0M|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 447| 58.1M| for (;;) { 448| 58.1M| switch (ls->current) { 449| 489k| case '\n': case '\r': { /* line breaks */ ------------------ | Branch (449:7): [True: 201k, False: 57.9M] | Branch (449:18): [True: 287k, False: 57.8M] ------------------ 450| 489k| inclinenumber(ls); 451| 489k| break; 452| 201k| } 453| 1.57M| case ' ': case '\f': case '\t': case '\v': { /* spaces */ ------------------ | Branch (453:7): [True: 1.44M, False: 56.7M] | Branch (453:17): [True: 17.6k, False: 58.1M] | Branch (453:28): [True: 42.3k, False: 58.1M] | Branch (453:39): [True: 73.5k, False: 58.0M] ------------------ 454| 1.57M| next(ls); ------------------ | | 32| 1.57M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 1.57M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 1.57M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 1.57M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 1.57M, False: 0] | | | | ------------------ | | ------------------ ------------------ 455| 1.57M| break; 456| 1.50M| } 457| 218k| case '-': { /* '-' or '--' (comment) */ ------------------ | Branch (457:7): [True: 218k, False: 57.9M] ------------------ 458| 218k| next(ls); ------------------ | | 32| 218k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 218k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 218k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 218k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 218k, False: 1] | | | | ------------------ | | ------------------ ------------------ 459| 218k| if (ls->current != '-') return '-'; ------------------ | Branch (459:13): [True: 164k, False: 53.9k] ------------------ 460| | /* else is a comment */ 461| 53.9k| next(ls); ------------------ | | 32| 53.9k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 53.9k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 53.9k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 53.9k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 53.9k, False: 0] | | | | ------------------ | | ------------------ ------------------ 462| 53.9k| if (ls->current == '[') { /* long comment? */ ------------------ | Branch (462:13): [True: 416, False: 53.5k] ------------------ 463| 416| size_t sep = skip_sep(ls); 464| 416| luaZ_resetbuffer(ls->buff); /* 'skip_sep' may dirty the buffer */ ------------------ | | 36| 416|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 465| 416| if (sep >= 2) { ------------------ | Branch (465:15): [True: 172, False: 244] ------------------ 466| 172| read_long_string(ls, NULL, sep); /* skip long comment */ 467| 172| luaZ_resetbuffer(ls->buff); /* previous call may dirty the buff. */ ------------------ | | 36| 172|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 468| 172| break; 469| 172| } 470| 416| } 471| | /* else short comment */ 472| 7.04M| while (!currIsNewline(ls) && ls->current != EOZ) ------------------ | | 36| 14.0M|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 17.8k, False: 7.02M] | | | Branch (36:51): [True: 35.8k, False: 6.98M] | | ------------------ ------------------ while (!currIsNewline(ls) && ls->current != EOZ) ------------------ | | 16| 6.98M|#define EOZ (-1) /* end of stream */ ------------------ | Branch (472:38): [True: 6.98M, False: 19] ------------------ 473| 6.98M| next(ls); /* skip until end of line (or end of file) */ ------------------ | | 32| 7.04M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 6.98M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 6.98M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 6.98M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 6.98M, False: 19] | | | | ------------------ | | ------------------ ------------------ 474| 53.7k| break; 475| 53.9k| } 476| 244k| case '[': { /* long string or simply '[' */ ------------------ | Branch (476:7): [True: 244k, False: 57.9M] ------------------ 477| 244k| size_t sep = skip_sep(ls); 478| 244k| if (sep >= 2) { ------------------ | Branch (478:13): [True: 209k, False: 34.5k] ------------------ 479| 209k| read_long_string(ls, seminfo, sep); 480| 209k| return TK_STRING; 481| 209k| } 482| 34.5k| else if (sep == 0) /* '[=...' missing second bracket? */ ------------------ | Branch (482:18): [True: 0, False: 34.5k] ------------------ 483| 0| lexerror(ls, "invalid long string delimiter", TK_STRING); 484| 34.5k| return '['; 485| 244k| } 486| 104k| case '=': { ------------------ | Branch (486:7): [True: 104k, False: 58.0M] ------------------ 487| 104k| next(ls); ------------------ | | 32| 104k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 104k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 104k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 104k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 104k, False: 0] | | | | ------------------ | | ------------------ ------------------ 488| 104k| if (check_next1(ls, '=')) return TK_EQ; /* '==' */ ------------------ | Branch (488:13): [True: 11.4k, False: 92.7k] ------------------ 489| 92.7k| else return '='; 490| 104k| } 491| 1.31M| case '<': { ------------------ | Branch (491:7): [True: 1.31M, False: 56.8M] ------------------ 492| 1.31M| next(ls); ------------------ | | 32| 1.31M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 1.31M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 1.31M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 1.31M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 1.31M, False: 4] | | | | ------------------ | | ------------------ ------------------ 493| 1.31M| if (check_next1(ls, '=')) return TK_LE; /* '<=' */ ------------------ | Branch (493:13): [True: 7.66k, False: 1.30M] ------------------ 494| 1.30M| else if (check_next1(ls, '<')) return TK_SHL; /* '<<' */ ------------------ | Branch (494:18): [True: 89.6k, False: 1.21M] ------------------ 495| 1.21M| else return '<'; 496| 1.31M| } 497| 16.3M| case '>': { ------------------ | Branch (497:7): [True: 16.3M, False: 41.8M] ------------------ 498| 16.3M| next(ls); ------------------ | | 32| 16.3M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 16.3M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 16.3M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 16.3M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 16.3M, False: 1] | | | | ------------------ | | ------------------ ------------------ 499| 16.3M| if (check_next1(ls, '=')) return TK_GE; /* '>=' */ ------------------ | Branch (499:13): [True: 4.39k, False: 16.3M] ------------------ 500| 16.3M| else if (check_next1(ls, '>')) return TK_SHR; /* '>>' */ ------------------ | Branch (500:18): [True: 282k, False: 16.0M] ------------------ 501| 16.0M| else return '>'; 502| 16.3M| } 503| 7.05M| case '/': { ------------------ | Branch (503:7): [True: 7.05M, False: 51.1M] ------------------ 504| 7.05M| next(ls); ------------------ | | 32| 7.05M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 7.05M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 7.05M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 7.05M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 7.05M, False: 1] | | | | ------------------ | | ------------------ ------------------ 505| 7.05M| if (check_next1(ls, '/')) return TK_IDIV; /* '//' */ ------------------ | Branch (505:13): [True: 44.4k, False: 7.01M] ------------------ 506| 7.01M| else return '/'; 507| 7.05M| } 508| 262k| case '~': { ------------------ | Branch (508:7): [True: 262k, False: 57.9M] ------------------ 509| 262k| next(ls); ------------------ | | 32| 262k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 262k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 262k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 262k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 262k, False: 0] | | | | ------------------ | | ------------------ ------------------ 510| 262k| if (check_next1(ls, '=')) return TK_NE; /* '~=' */ ------------------ | Branch (510:13): [True: 4.13k, False: 257k] ------------------ 511| 257k| else return '~'; 512| 262k| } 513| 394| case ':': { ------------------ | Branch (513:7): [True: 394, False: 58.1M] ------------------ 514| 394| next(ls); ------------------ | | 32| 394|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 394|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 394|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 394|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 394, False: 0] | | | | ------------------ | | ------------------ ------------------ 515| 394| if (check_next1(ls, ':')) return TK_DBCOLON; /* '::' */ ------------------ | Branch (515:13): [True: 62, False: 332] ------------------ 516| 332| else return ':'; 517| 394| } 518| 139k| case '"': case '\'': { /* short literal strings */ ------------------ | Branch (518:7): [True: 88.0k, False: 58.0M] | Branch (518:17): [True: 51.8k, False: 58.1M] ------------------ 519| 139k| read_string(ls, ls->current, seminfo); 520| 139k| return TK_STRING; 521| 88.0k| } 522| 84.6k| case '.': { /* '.', '..', '...', or number */ ------------------ | Branch (522:7): [True: 84.6k, False: 58.0M] ------------------ 523| 84.6k| save_and_next(ls); ------------------ | | 51| 84.6k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 84.6k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 84.6k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 84.6k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 84.6k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 84.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 524| 84.6k| if (check_next1(ls, '.')) { ------------------ | Branch (524:13): [True: 62.8k, False: 21.8k] ------------------ 525| 62.8k| if (check_next1(ls, '.')) ------------------ | Branch (525:15): [True: 3.02k, False: 59.8k] ------------------ 526| 3.02k| return TK_DOTS; /* '...' */ 527| 59.8k| else return TK_CONCAT; /* '..' */ 528| 62.8k| } 529| 21.8k| else if (!lisdigit(ls->current)) return '.'; ------------------ | | 59| 21.8k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 21.8k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ | Branch (529:18): [True: 13.7k, False: 8.10k] ------------------ 530| 8.10k| else return read_numeral(ls, seminfo); 531| 84.6k| } 532| 986k| case '0': case '1': case '2': case '3': case '4': ------------------ | Branch (532:7): [True: 668k, False: 57.4M] | Branch (532:17): [True: 162k, False: 58.0M] | Branch (532:27): [True: 101k, False: 58.0M] | Branch (532:37): [True: 29.5k, False: 58.1M] | Branch (532:47): [True: 23.4k, False: 58.1M] ------------------ 533| 1.24M| case '5': case '6': case '7': case '8': case '9': { ------------------ | Branch (533:7): [True: 84.5k, False: 58.0M] | Branch (533:17): [True: 11.3k, False: 58.1M] | Branch (533:27): [True: 15.8k, False: 58.1M] | Branch (533:37): [True: 49.7k, False: 58.1M] | Branch (533:47): [True: 99.0k, False: 58.0M] ------------------ 534| 1.24M| return read_numeral(ls, seminfo); 535| 1.14M| } 536| 180| case EOZ: { ------------------ | | 16| 180|#define EOZ (-1) /* end of stream */ ------------------ | Branch (536:7): [True: 180, False: 58.1M] ------------------ 537| 180| return TK_EOS; 538| 1.14M| } 539| 29.1M| default: { ------------------ | Branch (539:7): [True: 29.1M, False: 29.0M] ------------------ 540| 29.1M| if (lislalpha(ls->current)) { /* identifier or reserved word? */ ------------------ | | 57| 29.1M|#define lislalpha(c) testprop(c, MASK(ALPHABIT)) | | ------------------ | | | | 52| 29.1M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 26.5M, False: 2.56M] | | | | ------------------ | | ------------------ ------------------ 541| 26.5M| TString *ts; 542| 33.2M| do { 543| 33.2M| save_and_next(ls); ------------------ | | 51| 33.2M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 33.2M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 33.2M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 33.2M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 33.2M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 33.2M, False: 47] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 544| 33.2M| } while (lislalnum(ls->current)); ------------------ | | 58| 33.2M|#define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT))) | | ------------------ | | | | 52| 33.2M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 6.74M, False: 26.5M] | | | | ------------------ | | ------------------ ------------------ 545| 26.5M| ts = luaX_newstring(ls, luaZ_buffer(ls->buff), ------------------ | | 31| 26.5M|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 546| 26.5M| luaZ_bufflen(ls->buff)); ------------------ | | 33| 26.5M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ 547| 26.5M| seminfo->ts = ts; 548| 26.5M| if (isreserved(ts)) /* reserved word? */ ------------------ | | 37| 26.5M|#define isreserved(s) ((s)->tt == LUA_VSHRSTR && (s)->extra > 0) | | ------------------ | | | | 373| 26.5M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | ------------------ | | | | | | 42| 53.0M|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (37:24): [True: 26.5M, False: 9.64k] | | | Branch (37:50): [True: 251k, False: 26.2M] | | ------------------ ------------------ 549| 251k| return ts->extra - 1 + FIRST_RESERVED; ------------------ | | 20| 251k|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ 550| 26.2M| else { 551| 26.2M| return TK_NAME; 552| 26.2M| } 553| 26.5M| } 554| 2.56M| else { /* single-char tokens ('+', '*', '%', '{', '}', ...) */ 555| 2.56M| int c = ls->current; 556| 2.56M| next(ls); ------------------ | | 32| 2.56M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 2.56M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 2.56M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 2.56M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 2.56M, False: 48] | | | | ------------------ | | ------------------ ------------------ 557| 2.56M| return c; 558| 2.56M| } 559| 29.1M| } 560| 58.1M| } 561| 58.1M| } 562| 56.0M|} llex.c:inclinenumber: 156| 9.07M|static void inclinenumber (LexState *ls) { 157| 9.07M| int old = ls->current; 158| 9.07M| lua_assert(currIsNewline(ls)); ------------------ | | 109| 9.07M|#define lua_assert(c) assert(c) ------------------ 159| 9.07M| next(ls); /* skip '\n' or '\r' */ ------------------ | | 32| 9.07M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 9.07M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 9.07M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 9.07M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 9.07M, False: 2] | | | | ------------------ | | ------------------ ------------------ 160| 9.07M| if (currIsNewline(ls) && ls->current != old) ------------------ | | 36| 18.1M|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 8.13M, False: 943k] | | | Branch (36:51): [True: 334k, False: 608k] | | ------------------ ------------------ | Branch (160:28): [True: 92.0k, False: 8.37M] ------------------ 161| 92.0k| next(ls); /* skip '\n\r' or '\r\n' */ ------------------ | | 32| 92.0k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 92.0k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 92.0k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 92.0k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 92.0k, False: 0] | | | | ------------------ | | ------------------ ------------------ 162| 9.07M| if (++ls->linenumber >= MAX_INT) ------------------ | | 56| 9.07M|#define MAX_INT INT_MAX /* maximum value of an int */ ------------------ | Branch (162:7): [True: 0, False: 9.07M] ------------------ 163| 0| lexerror(ls, "chunk has too many lines", 0); 164| 9.07M|} llex.c:skip_sep: 265| 466k|static size_t skip_sep (LexState *ls) { 266| 466k| size_t count = 0; 267| 466k| int s = ls->current; 268| 466k| lua_assert(s == '[' || s == ']'); ------------------ | | 109| 466k|#define lua_assert(c) assert(c) ------------------ 269| 466k| save_and_next(ls); ------------------ | | 51| 466k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 466k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 466k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 466k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 466k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 466k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 270| 474k| while (ls->current == '=') { ------------------ | Branch (270:10): [True: 7.73k, False: 466k] ------------------ 271| 7.73k| save_and_next(ls); ------------------ | | 51| 7.73k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 7.73k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 7.73k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 7.73k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 7.73k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 7.73k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 272| 7.73k| count++; 273| 7.73k| } 274| 466k| return (ls->current == s) ? count + 2 ------------------ | Branch (274:10): [True: 421k, False: 45.2k] ------------------ 275| 466k| : (count == 0) ? 1 ------------------ | Branch (275:12): [True: 43.8k, False: 1.36k] ------------------ 276| 45.2k| : 0; 277| 466k|} llex.c:read_long_string: 280| 209k|static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) { 281| 209k| int line = ls->linenumber; /* initial line (for error message) */ 282| 209k| save_and_next(ls); /* skip 2nd '[' */ ------------------ | | 51| 209k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 209k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 209k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 209k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 209k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 209k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 283| 209k| if (currIsNewline(ls)) /* string starts with a newline? */ ------------------ | | 36| 209k|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 183k, False: 26.2k] | | | Branch (36:51): [True: 18.4k, False: 7.81k] | | ------------------ ------------------ 284| 202k| inclinenumber(ls); /* skip it */ 285| 20.8M| for (;;) { 286| 20.8M| switch (ls->current) { 287| 26| case EOZ: { /* error */ ------------------ | | 16| 26|#define EOZ (-1) /* end of stream */ ------------------ | Branch (287:7): [True: 26, False: 20.8M] ------------------ 288| 26| const char *what = (seminfo ? "string" : "comment"); ------------------ | Branch (288:29): [True: 21, False: 5] ------------------ 289| 26| const char *msg = luaO_pushfstring(ls->L, 290| 26| "unfinished long %s (starting at line %d)", what, line); 291| 26| lexerror(ls, msg, TK_EOS); 292| 0| break; /* to avoid warnings */ 293| 0| } 294| 221k| case ']': { ------------------ | Branch (294:7): [True: 221k, False: 20.6M] ------------------ 295| 221k| if (skip_sep(ls) == sep) { ------------------ | Branch (295:13): [True: 209k, False: 11.6k] ------------------ 296| 209k| save_and_next(ls); /* skip 2nd ']' */ ------------------ | | 51| 209k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 209k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 209k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 209k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 209k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 209k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 297| 209k| goto endloop; 298| 209k| } 299| 11.6k| break; 300| 221k| } 301| 8.38M| case '\n': case '\r': { ------------------ | Branch (301:7): [True: 8.24M, False: 12.6M] | Branch (301:18): [True: 138k, False: 20.7M] ------------------ 302| 8.38M| save(ls, '\n'); 303| 8.38M| inclinenumber(ls); 304| 8.38M| if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */ ------------------ | | 36| 5.37k|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ | Branch (304:13): [True: 5.37k, False: 8.37M] ------------------ 305| 8.38M| break; 306| 8.24M| } 307| 12.2M| default: { ------------------ | Branch (307:7): [True: 12.2M, False: 8.60M] ------------------ 308| 12.2M| if (seminfo) save_and_next(ls); ------------------ | | 51| 11.0M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 11.0M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 11.0M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 11.0M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 11.0M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 11.0M, False: 19] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (308:13): [True: 11.0M, False: 1.17M] ------------------ 309| 1.17M| else next(ls); ------------------ | | 32| 1.17M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 1.17M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 1.17M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 1.17M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 1.17M, False: 5] | | | | ------------------ | | ------------------ ------------------ 310| 12.2M| } 311| 20.8M| } 312| 20.8M| } endloop: 313| 209k| if (seminfo) ------------------ | Branch (313:7): [True: 209k, False: 167] ------------------ 314| 209k| seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep, ------------------ | | 31| 209k|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 315| 209k| luaZ_bufflen(ls->buff) - 2 * sep); ------------------ | | 33| 209k|#define luaZ_bufflen(buff) ((buff)->n) ------------------ 316| 209k|} llex.c:check_next1: 191| 42.8M|static int check_next1 (LexState *ls, int c) { 192| 42.8M| if (ls->current == c) { ------------------ | Branch (192:7): [True: 509k, False: 42.3M] ------------------ 193| 509k| next(ls); ------------------ | | 32| 509k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 509k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 509k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 509k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 509k, False: 2] | | | | ------------------ | | ------------------ ------------------ 194| 509k| return 1; 195| 509k| } 196| 42.3M| else return 0; 197| 42.8M|} llex.c:read_string: 382| 139k|static void read_string (LexState *ls, int del, SemInfo *seminfo) { 383| 139k| save_and_next(ls); /* keep delimiter (for error messages) */ ------------------ | | 51| 139k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 139k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 139k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 139k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 139k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 139k, False: 2] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 384| 26.5M| while (ls->current != del) { ------------------ | Branch (384:10): [True: 26.4M, False: 139k] ------------------ 385| 26.4M| switch (ls->current) { 386| 21| case EOZ: ------------------ | | 16| 21|#define EOZ (-1) /* end of stream */ ------------------ | Branch (386:7): [True: 21, False: 26.4M] ------------------ 387| 21| lexerror(ls, "unfinished string", TK_EOS); 388| 0| break; /* to avoid warnings */ 389| 14| case '\n': ------------------ | Branch (389:7): [True: 14, False: 26.4M] ------------------ 390| 25| case '\r': ------------------ | Branch (390:7): [True: 11, False: 26.4M] ------------------ 391| 25| lexerror(ls, "unfinished string", TK_STRING); 392| 0| break; /* to avoid warnings */ 393| 137k| case '\\': { /* escape sequences */ ------------------ | Branch (393:7): [True: 137k, False: 26.2M] ------------------ 394| 137k| int c; /* final character to be saved */ 395| 137k| save_and_next(ls); /* keep '\\' for error messages */ ------------------ | | 51| 137k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 137k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 137k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 137k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 137k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 137k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 396| 137k| switch (ls->current) { 397| 1| case 'a': c = '\a'; goto read_save; ------------------ | Branch (397:11): [True: 1, False: 137k] ------------------ 398| 973| case 'b': c = '\b'; goto read_save; ------------------ | Branch (398:11): [True: 973, False: 136k] ------------------ 399| 854| case 'f': c = '\f'; goto read_save; ------------------ | Branch (399:11): [True: 854, False: 136k] ------------------ 400| 281| case 'n': c = '\n'; goto read_save; ------------------ | Branch (400:11): [True: 281, False: 137k] ------------------ 401| 281| case 'r': c = '\r'; goto read_save; ------------------ | Branch (401:11): [True: 281, False: 137k] ------------------ 402| 6| case 't': c = '\t'; goto read_save; ------------------ | Branch (402:11): [True: 6, False: 137k] ------------------ 403| 42.2k| case 'v': c = '\v'; goto read_save; ------------------ | Branch (403:11): [True: 42.2k, False: 95.3k] ------------------ 404| 4.72k| case 'x': c = readhexaesc(ls); goto read_save; ------------------ | Branch (404:11): [True: 4.72k, False: 132k] ------------------ 405| 39.8k| case 'u': utf8esc(ls); goto no_save; ------------------ | Branch (405:11): [True: 39.8k, False: 97.6k] ------------------ 406| 1.46k| case '\n': case '\r': ------------------ | Branch (406:11): [True: 0, False: 137k] | Branch (406:22): [True: 1.46k, False: 136k] ------------------ 407| 1.46k| inclinenumber(ls); c = '\n'; goto only_save; 408| 4.62k| case '\\': case '\"': case '\'': ------------------ | Branch (408:11): [True: 4.25k, False: 133k] | Branch (408:22): [True: 194, False: 137k] | Branch (408:33): [True: 174, False: 137k] ------------------ 409| 4.62k| 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: 137k] ------------------ 411| 8.38k| case 'z': { /* zap following span of spaces */ ------------------ | Branch (411:11): [True: 8.38k, False: 129k] ------------------ 412| 8.38k| luaZ_buffremove(ls->buff, 1); /* remove '\\' */ ------------------ | | 35| 8.38k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 413| 8.38k| next(ls); /* skip the 'z' */ ------------------ | | 32| 8.38k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 8.38k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 8.38k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 8.38k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 8.38k, False: 0] | | | | ------------------ | | ------------------ ------------------ 414| 8.38k| while (lisspace(ls->current)) { 415| 1.22k| if (currIsNewline(ls)) inclinenumber(ls); ------------------ | | 36| 1.22k|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 278, False: 942] | | | Branch (36:51): [True: 10, False: 932] | | ------------------ ------------------ 416| 932| else next(ls); ------------------ | | 32| 932|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 932|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 932|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 932|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 932, False: 0] | | | | ------------------ | | ------------------ ------------------ 417| 1.22k| } 418| 8.38k| goto no_save; 419| 4.44k| } 420| 33.8k| default: { ------------------ | Branch (420:11): [True: 33.8k, False: 103k] ------------------ 421| 33.8k| esccheck(ls, lisdigit(ls->current), "invalid escape sequence"); ------------------ | | 59| 33.8k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 33.8k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ 422| 33.8k| c = readdecesc(ls); /* digital escape '\ddd' */ 423| 33.8k| goto only_save; 424| 4.44k| } 425| 137k| } 426| 53.9k| read_save: 427| 53.9k| next(ls); ------------------ | | 32| 53.9k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 53.9k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 53.9k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 53.9k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 53.9k, False: 0] | | | | ------------------ | | ------------------ ------------------ 428| | /* go through */ 429| 89.2k| only_save: 430| 89.2k| luaZ_buffremove(ls->buff, 1); /* remove '\\' */ ------------------ | | 35| 89.2k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 431| 89.2k| save(ls, c); 432| | /* go through */ 433| 137k| no_save: break; 434| 89.2k| } 435| 26.2M| default: ------------------ | Branch (435:7): [True: 26.2M, False: 137k] ------------------ 436| 26.2M| save_and_next(ls); ------------------ | | 51| 26.2M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 26.2M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 26.2M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 26.2M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 26.2M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 26.2M, False: 19] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 437| 26.4M| } 438| 26.4M| } 439| 139k| save_and_next(ls); /* skip delimiter */ ------------------ | | 51| 139k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 139k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 139k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 139k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 139k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 139k, False: 42] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 440| 139k| seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1, ------------------ | | 31| 139k|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 441| 139k| luaZ_bufflen(ls->buff) - 2); ------------------ | | 33| 139k|#define luaZ_bufflen(buff) ((buff)->n) ------------------ 442| 139k|} llex.c:readhexaesc: 335| 4.72k|static int readhexaesc (LexState *ls) { 336| 4.72k| int r = gethexa(ls); 337| 4.72k| r = (r << 4) + gethexa(ls); 338| 4.72k| luaZ_buffremove(ls->buff, 2); /* remove saved chars from buffer */ ------------------ | | 35| 4.72k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 339| 4.72k| return r; 340| 4.72k|} llex.c:gethexa: 328| 49.3k|static int gethexa (LexState *ls) { 329| 49.3k| save_and_next(ls); ------------------ | | 51| 49.3k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 49.3k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 49.3k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 49.3k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 49.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 49.3k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 330| 49.3k| esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected"); ------------------ | | 62| 49.3k|#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) | | ------------------ | | | | 52| 49.3k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ 331| 49.3k| return luaO_hexavalue(ls->current); 332| 49.3k|} llex.c:utf8esc: 361| 39.8k|static void utf8esc (LexState *ls) { 362| 39.8k| char buff[UTF8BUFFSZ]; 363| 39.8k| int n = luaO_utf8esc(buff, readutf8esc(ls)); 364| 85.4k| for (; n > 0; n--) /* add 'buff' to string */ ------------------ | Branch (364:10): [True: 45.5k, False: 39.8k] ------------------ 365| 45.5k| save(ls, buff[UTF8BUFFSZ - n]); ------------------ | | 833| 45.5k|#define UTF8BUFFSZ 8 ------------------ 366| 39.8k|} llex.c:readutf8esc: 343| 39.8k|static unsigned long readutf8esc (LexState *ls) { 344| 39.8k| unsigned long r; 345| 39.8k| int i = 4; /* chars to be removed: '\', 'u', '{', and first digit */ 346| 39.8k| save_and_next(ls); /* skip 'u' */ ------------------ | | 51| 39.8k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 39.8k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 39.8k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 39.8k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 39.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 39.8k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 347| 39.8k| esccheck(ls, ls->current == '{', "missing '{'"); 348| 39.8k| r = gethexa(ls); /* must have at least one digit */ 349| 58.9k| while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) { ------------------ | | 141| 58.9k|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 139| 117k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [True: 58.9k, False: 18] | | | | ------------------ | | ------------------ ------------------ while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) { ------------------ | | 62| 58.9k|#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) | | ------------------ | | | | 52| 58.9k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ | Branch (349:10): [True: 19.0k, False: 39.8k] ------------------ 350| 19.0k| i++; 351| 19.0k| esccheck(ls, r <= (0x7FFFFFFFu >> 4), "UTF-8 value too large"); 352| 19.0k| r = (r << 4) + luaO_hexavalue(ls->current); 353| 19.0k| } 354| 39.8k| esccheck(ls, ls->current == '}', "missing '}'"); 355| 39.8k| next(ls); /* skip '}' */ ------------------ | | 32| 39.8k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 39.8k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 147| 39.8k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 139| 39.8k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 39.8k, False: 26] | | | | ------------------ | | ------------------ ------------------ 356| 39.8k| luaZ_buffremove(ls->buff, i); /* remove saved chars from buffer */ ------------------ | | 35| 39.8k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 357| 39.8k| return r; 358| 39.8k|} llex.c:esccheck: 319| 215k|static void esccheck (LexState *ls, int c, const char *msg) { 320| 215k| if (!c) { ------------------ | Branch (320:7): [True: 41, False: 215k] ------------------ 321| 41| if (ls->current != EOZ) ------------------ | | 16| 41|#define EOZ (-1) /* end of stream */ ------------------ | Branch (321:9): [True: 41, False: 0] ------------------ 322| 41| save_and_next(ls); /* add current to buffer for error message */ ------------------ | | 51| 41|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 41|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 41|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 41|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 41|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 41, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 323| 41| lexerror(ls, msg, TK_STRING); 324| 41| } 325| 215k|} llex.c:readdecesc: 369| 33.8k|static int readdecesc (LexState *ls) { 370| 33.8k| int i; 371| 33.8k| int r = 0; /* result accumulator */ 372| 72.4k| for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */ ------------------ | | 59| 70.2k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 70.2k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 38.5k, False: 31.6k] | | | | ------------------ | | ------------------ ------------------ | Branch (372:15): [True: 70.2k, False: 2.18k] ------------------ 373| 38.5k| r = 10*r + ls->current - '0'; 374| 38.5k| save_and_next(ls); ------------------ | | 51| 38.5k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 38.5k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 38.5k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 38.5k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 38.5k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 38.5k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 375| 38.5k| } 376| 33.8k| esccheck(ls, r <= UCHAR_MAX, "decimal escape too large"); 377| 33.8k| luaZ_buffremove(ls->buff, i); /* remove read digits from buffer */ ------------------ | | 35| 33.8k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 378| 33.8k| return r; 379| 33.8k|} llex.c:read_numeral: 227| 1.25M|static int read_numeral (LexState *ls, SemInfo *seminfo) { 228| 1.25M| TValue obj; 229| 1.25M| const char *expo = "Ee"; 230| 1.25M| int first = ls->current; 231| 1.25M| lua_assert(lisdigit(ls->current)); ------------------ | | 109| 1.25M|#define lua_assert(c) assert(c) ------------------ 232| 1.25M| save_and_next(ls); ------------------ | | 51| 1.25M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 1.25M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 1.25M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 1.25M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 1.25M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 1.25M, False: 15] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 233| 1.25M| if (first == '0' && check_next2(ls, "xX")) /* hexadecimal? */ ------------------ | Branch (233:7): [True: 670k, False: 584k] | Branch (233:23): [True: 8, False: 670k] ------------------ 234| 8| expo = "Pp"; 235| 7.88M| for (;;) { 236| 7.88M| if (check_next2(ls, expo)) /* exponent mark? */ ------------------ | Branch (236:9): [True: 145k, False: 7.74M] ------------------ 237| 145k| check_next2(ls, "-+"); /* optional exponent sign */ 238| 7.74M| else if (lisxdigit(ls->current) || ls->current == '.') /* '%x|%.' */ ------------------ | | 62| 7.74M|#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) | | ------------------ | | | | 52| 15.4M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 6.45M, False: 1.29M] | | | | ------------------ | | ------------------ ------------------ | Branch (238:40): [True: 36.9k, False: 1.25M] ------------------ 239| 6.48M| save_and_next(ls); ------------------ | | 51| 6.48M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 6.48M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 6.48M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 6.48M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 6.48M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 6.48M, False: 10] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 240| 1.25M| else break; 241| 7.88M| } 242| 1.25M| if (lislalpha(ls->current)) /* is numeral touching a letter? */ ------------------ | | 57| 1.25M|#define lislalpha(c) testprop(c, MASK(ALPHABIT)) | | ------------------ | | | | 52| 1.25M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 42, False: 1.25M] | | | | ------------------ | | ------------------ ------------------ 243| 42| save_and_next(ls); /* force an error */ ------------------ | | 51| 42|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 42|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 42|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 38|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 38|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 38, False: 4] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 244| 1.25M| save(ls, '\0'); 245| 1.25M| if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0) /* format error? */ ------------------ | | 31| 1.25M|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ | Branch (245:7): [True: 46, False: 1.25M] ------------------ 246| 46| lexerror(ls, "malformed number", TK_FLT); 247| 1.25M| if (ttisinteger(&obj)) { ------------------ | | 341| 1.25M|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 1.25M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 1.25M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 1.18M, False: 70.3k] | | | | ------------------ | | ------------------ ------------------ 248| 1.18M| seminfo->i = ivalue(&obj); ------------------ | | 346| 1.18M|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 1.18M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 1.18M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 249| 0| return TK_INT; 250| 1.18M| } 251| 70.3k| else { 252| 70.3k| lua_assert(ttisfloat(&obj)); ------------------ | | 109| 70.3k|#define lua_assert(c) assert(c) ------------------ 253| 70.3k| seminfo->r = fltvalue(&obj); ------------------ | | 345| 70.3k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 113| 70.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 70.3k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 254| 0| return TK_FLT; 255| 70.3k| } 256| 1.25M|} llex.c:check_next2: 204| 8.70M|static int check_next2 (LexState *ls, const char *set) { 205| 8.70M| lua_assert(set[2] == '\0'); ------------------ | | 109| 8.70M|#define lua_assert(c) assert(c) ------------------ 206| 8.70M| if (ls->current == set[0] || ls->current == set[1]) { ------------------ | Branch (206:7): [True: 139k, False: 8.56M] | Branch (206:32): [True: 5.89k, False: 8.55M] ------------------ 207| 145k| save_and_next(ls); ------------------ | | 51| 145k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 145k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 145k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 147| 145k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 145k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 145k, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 208| 145k| return 1; 209| 145k| } 210| 8.55M| else return 0; 211| 8.70M|} luaM_growaux_: 98| 280M| int size_elems, int limit, const char *what) { 99| 280M| void *newblock; 100| 280M| int size = *psize; 101| 280M| if (nelems + 1 <= size) /* does one extra element still fit? */ ------------------ | Branch (101:7): [True: 280M, False: 142k] ------------------ 102| 280M| return block; /* nothing to be done */ 103| 142k| if (size >= limit / 2) { /* cannot double it? */ ------------------ | Branch (103:7): [True: 1, False: 142k] ------------------ 104| 1| if (l_unlikely(size >= limit)) /* cannot grow even a little? */ ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 105| 0| luaG_runerror(L, "too many %s (limit is %d)", what, limit); 106| 1| size = limit; /* still have at least one free place */ 107| 1| } 108| 142k| else { 109| 142k| size *= 2; 110| 142k| if (size < MINSIZEARRAY) ------------------ | | 94| 142k|#define MINSIZEARRAY 4 ------------------ | Branch (110:9): [True: 90.9k, False: 52.0k] ------------------ 111| 90.9k| size = MINSIZEARRAY; /* minimum size */ ------------------ | | 94| 90.9k|#define MINSIZEARRAY 4 ------------------ 112| 142k| } 113| 142k| lua_assert(nelems + 1 <= size && size <= limit); ------------------ | | 109| 142k|#define lua_assert(c) assert(c) ------------------ 114| | /* 'limit' ensures that multiplication will not overflow */ 115| 142k| newblock = luaM_saferealloc_(L, block, cast_sizet(*psize) * size_elems, ------------------ | | 150| 142k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 139| 142k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 116| 142k| cast_sizet(size) * size_elems); ------------------ | | 150| 142k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 139| 142k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 117| 142k| *psize = size; /* update only when everything else is OK */ 118| 142k| return newblock; 119| 142k|} luaM_shrinkvector_: 129| 146k| int final_n, int size_elem) { 130| 146k| void *newblock; 131| 146k| size_t oldsize = cast_sizet((*size) * size_elem); ------------------ | | 150| 146k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 139| 146k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 132| 146k| size_t newsize = cast_sizet(final_n * size_elem); ------------------ | | 150| 146k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 139| 146k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 133| 146k| lua_assert(newsize <= oldsize); ------------------ | | 109| 146k|#define lua_assert(c) assert(c) ------------------ 134| 146k| newblock = luaM_saferealloc_(L, block, oldsize, newsize); 135| 146k| *size = final_n; 136| 146k| return newblock; 137| 146k|} luaM_free_: 150| 2.80M|void luaM_free_ (lua_State *L, void *block, size_t osize) { 151| 2.80M| global_State *g = G(L); ------------------ | | 333| 2.80M|#define G(L) (L->l_G) ------------------ 152| 2.80M| lua_assert((osize == 0) == (block == NULL)); ------------------ | | 109| 2.80M|#define lua_assert(c) assert(c) ------------------ 153| 2.80M| callfrealloc(g, block, osize, 0); ------------------ | | 47| 2.80M|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) ------------------ 154| 2.80M| g->totalbytes -= osize; 155| 2.80M|} luaM_realloc_: 176| 394k|void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) { 177| 394k| void *newblock; 178| 394k| global_State *g = G(L); ------------------ | | 333| 394k|#define G(L) (L->l_G) ------------------ 179| 394k| lua_assert((osize == 0) == (block == NULL)); ------------------ | | 109| 394k|#define lua_assert(c) assert(c) ------------------ 180| 394k| newblock = firsttry(g, block, osize, nsize); ------------------ | | 76| 394k|#define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns) | | ------------------ | | | | 47| 394k|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) | | ------------------ ------------------ 181| 394k| if (l_unlikely(newblock == NULL && nsize > 0)) { ------------------ | | 697| 394k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 455k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 394k] | | | | | Branch (685:46): [True: 61.0k, False: 333k] | | | | | Branch (685:46): [True: 0, False: 61.0k] | | | | ------------------ | | ------------------ ------------------ 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 'totalbytes' */ 185| 0| } 186| 394k| lua_assert((nsize == 0) == (newblock == NULL)); ------------------ | | 109| 394k|#define lua_assert(c) assert(c) ------------------ 187| 394k| g->totalbytes += nsize - osize; 188| 394k| return newblock; 189| 394k|} luaM_saferealloc_: 193| 294k| size_t nsize) { 194| 294k| void *newblock = luaM_realloc_(L, block, osize, nsize); 195| 294k| if (l_unlikely(newblock == NULL && nsize > 0)) /* allocation failed? */ ------------------ | | 697| 294k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 355k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 294k] | | | | | Branch (685:46): [True: 61.0k, False: 233k] | | | | | Branch (685:46): [True: 0, False: 61.0k] | | | | ------------------ | | ------------------ ------------------ 196| 0| luaM_error(L); ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 52| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 197| 294k| return newblock; 198| 294k|} luaM_malloc_: 201| 2.54M|void *luaM_malloc_ (lua_State *L, size_t size, int tag) { 202| 2.54M| if (size == 0) ------------------ | Branch (202:7): [True: 0, False: 2.54M] ------------------ 203| 0| return NULL; /* that's all */ 204| 2.54M| else { 205| 2.54M| global_State *g = G(L); ------------------ | | 333| 2.54M|#define G(L) (L->l_G) ------------------ 206| 2.54M| void *newblock = firsttry(g, NULL, tag, size); ------------------ | | 76| 2.54M|#define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns) | | ------------------ | | | | 47| 2.54M|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) | | ------------------ ------------------ 207| 2.54M| if (l_unlikely(newblock == NULL)) { ------------------ | | 697| 2.54M|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 2.54M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 2.54M] | | | | ------------------ | | ------------------ ------------------ 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| 2.54M| g->totalbytes += size; 213| 2.54M| return newblock; 214| 2.54M| } 215| 2.54M|} luaO_ceillog2: 35| 306k|int luaO_ceillog2 (unsigned int x) { 36| 306k| static const lu_byte log_2[256] = { /* log_2[i - 1] = ceil(log2(i)) */ 37| 306k| 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| 306k| 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| 306k| 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| 306k| 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| 306k| 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| 306k| 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| 306k| 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| 306k| 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| 306k| }; 46| 306k| int l = 0; 47| 306k| x--; 48| 423k| while (x >= 256) { l += 8; x >>= 8; } ------------------ | Branch (48:10): [True: 116k, False: 306k] ------------------ 49| 306k| return l + log_2[x]; 50| 306k|} luaO_codeparam: 60| 3.36k|unsigned int luaO_codeparam (unsigned int p) { 61| 3.36k| if (p >= (cast(lu_mem, 0x1F) << (0xF - 7 - 1)) * 100u) /* overflow? */ ------------------ | | 139| 3.36k|#define cast(t, exp) ((t)(exp)) ------------------ | Branch (61:7): [True: 0, False: 3.36k] ------------------ 62| 0| return 0xFF; /* return maximum value */ 63| 3.36k| else { 64| 3.36k| p = (cast(l_uint32, p) * 128 + 99) / 100; /* round up the division */ ------------------ | | 139| 3.36k|#define cast(t, exp) ((t)(exp)) ------------------ 65| 3.36k| if (p < 0x10) /* subnormal number? */ ------------------ | Branch (65:9): [True: 0, False: 3.36k] ------------------ 66| 0| return p; /* exponent bits are already zero; nothing else to do */ 67| 3.36k| else { 68| 3.36k| int log = luaO_ceillog2(p + 1) - 5; /* preserve 5 bits */ 69| 3.36k| return ((p >> log) - 0x10) | ((log + 1) << 4); 70| 3.36k| } 71| 3.36k| } 72| 3.36k|} luaO_applyparam: 84| 31.8k|l_obj luaO_applyparam (unsigned int p, l_obj x) { 85| 31.8k| unsigned int m = p & 0xF; /* mantissa */ 86| 31.8k| int e = (p >> 4); /* exponent */ 87| 31.8k| if (e > 0) { /* normalized? */ ------------------ | Branch (87:7): [True: 31.8k, False: 0] ------------------ 88| 31.8k| e--; /* correct exponent */ 89| 31.8k| m += 0x10; /* correct mantissa; maximum value is 0x1F */ 90| 31.8k| } 91| 31.8k| e -= 7; /* correct excess-7 */ 92| 31.8k| if (e >= 0) { ------------------ | Branch (92:7): [True: 0, False: 31.8k] ------------------ 93| 0| if (x < (MAX_LOBJ / 0x1F) >> e) /* no overflow? */ ------------------ | | 37| 0| cast(l_obj, (cast(lu_mem, 1) << (sizeof(l_obj) * CHAR_BIT - 1)) - 1) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (93:9): [True: 0, False: 0] ------------------ 94| 0| return (x * m) << e; /* order doesn't matter here */ 95| 0| else /* real overflow */ 96| 0| return MAX_LOBJ; ------------------ | | 37| 0| cast(l_obj, (cast(lu_mem, 1) << (sizeof(l_obj) * CHAR_BIT - 1)) - 1) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 97| 0| } 98| 31.8k| else { /* negative exponent */ 99| 31.8k| e = -e; 100| 31.8k| if (x < MAX_LOBJ / 0x1F) /* multiplication cannot overflow? */ ------------------ | | 37| 31.8k| cast(l_obj, (cast(lu_mem, 1) << (sizeof(l_obj) * CHAR_BIT - 1)) - 1) | | ------------------ | | | | 139| 31.8k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (100:9): [True: 31.8k, False: 0] ------------------ 101| 31.8k| return (x * m) >> e; /* multiplying first gives more precision */ 102| 0| else if ((x >> e) < MAX_LOBJ / 0x1F) /* cannot overflow after shift? */ ------------------ | | 37| 0| cast(l_obj, (cast(lu_mem, 1) << (sizeof(l_obj) * CHAR_BIT - 1)) - 1) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (102:14): [True: 0, False: 0] ------------------ 103| 0| return (x >> e) * m; 104| 0| else /* real overflow */ 105| 0| return MAX_LOBJ; ------------------ | | 37| 0| cast(l_obj, (cast(lu_mem, 1) << (sizeof(l_obj) * CHAR_BIT - 1)) - 1) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 106| 31.8k| } 107| 31.8k|} luaO_rawarith: 147| 355k| TValue *res) { 148| 355k| switch (op) { 149| 5.28k| case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 222| 480|#define LUA_OPBAND 7 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 223| 512|#define LUA_OPBOR 8 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 224| 5.28k|#define LUA_OPBXOR 9 ------------------ | Branch (149:5): [True: 480, False: 354k] | Branch (149:22): [True: 32, False: 355k] | Branch (149:38): [True: 4.77k, False: 350k] ------------------ 150| 8.69k| case LUA_OPSHL: case LUA_OPSHR: ------------------ | | 225| 7.62k|#define LUA_OPSHL 10 ------------------ case LUA_OPSHL: case LUA_OPSHR: ------------------ | | 226| 8.69k|#define LUA_OPSHR 11 ------------------ | Branch (150:5): [True: 2.33k, False: 353k] | Branch (150:21): [True: 1.06k, False: 354k] ------------------ 151| 68.0k| case LUA_OPBNOT: { /* operate only on integers */ ------------------ | | 228| 68.0k|#define LUA_OPBNOT 13 ------------------ | Branch (151:5): [True: 59.3k, False: 296k] ------------------ 152| 68.0k| lua_Integer i1; lua_Integer i2; 153| 68.0k| if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) { ------------------ | | 69| 136k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 696| 68.0k|#define l_likely(x) luai_likely(x) | | | | ------------------ | | | | | | 684| 68.0k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | ------------------ | | | | | | | Branch (684:25): [True: 61.7k, False: 6.27k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 346| 61.7k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 113| 61.7k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 61.7k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (69:3): [True: 68.0k, False: 0] | | ------------------ | | 70| 136k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | ------------------ | | | | 36| 6.27k|#define LUA_FLOORN2I F2Ieq | | ------------------ ------------------ if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) { ------------------ | | 69| 68.0k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 696| 68.0k|#define l_likely(x) luai_likely(x) | | | | ------------------ | | | | | | 684| 68.0k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | ------------------ | | | | | | | Branch (684:25): [True: 66.5k, False: 1.48k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 346| 66.5k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 113| 66.5k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 66.5k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (69:3): [True: 68.0k, False: 0] | | ------------------ | | 70| 68.0k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | ------------------ | | | | 36| 1.48k|#define LUA_FLOORN2I F2Ieq | | ------------------ ------------------ 154| 68.0k| setivalue(res, intarith(L, op, i1, i2)); ------------------ | | 358| 68.0k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 68.0k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 68.0k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 155| 68.0k| return 1; 156| 68.0k| } 157| 0| else return 0; /* fail */ 158| 68.0k| } 159| 205k| case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */ ------------------ | | 220| 12.9k|#define LUA_OPDIV 5 ------------------ case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */ ------------------ | | 219| 205k|#define LUA_OPPOW 4 ------------------ | Branch (159:5): [True: 12.9k, False: 342k] | Branch (159:21): [True: 192k, False: 162k] ------------------ 160| 205k| lua_Number n1; lua_Number n2; 161| 205k| if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 410k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 340| 205k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 205k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 205k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 22.6k, False: 182k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 345| 22.6k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 113| 22.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 22.6k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 205k, False: 0] | | ------------------ | | 58| 410k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 341| 182k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 182k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 182k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 182k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 143| 182k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 139| 730k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (139:27): [True: 0, False: 182k] | | | | | | | Branch (139:27): [True: 182k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 205k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 340| 205k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 205k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 205k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 33.4k, False: 171k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 345| 33.4k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 113| 33.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 33.4k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 205k, False: 0] | | ------------------ | | 58| 205k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 341| 171k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 171k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 171k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 171k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 143| 171k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 139| 687k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (139:27): [True: 0, False: 171k] | | | | | | | Branch (139:27): [True: 171k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 162| 205k| setfltvalue(res, numarith(L, op, n1, n2)); ------------------ | | 352| 205k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 205k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 205k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 163| 205k| return 1; 164| 205k| } 165| 0| else return 0; /* fail */ 166| 205k| } 167| 82.0k| default: { /* other operations */ ------------------ | Branch (167:5): [True: 82.0k, False: 273k] ------------------ 168| 82.0k| lua_Number n1; lua_Number n2; 169| 82.0k| if (ttisinteger(p1) && ttisinteger(p2)) { ------------------ | | 341| 82.0k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 164k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 82.0k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 58.6k, False: 23.3k] | | | | ------------------ | | ------------------ ------------------ if (ttisinteger(p1) && ttisinteger(p2)) { ------------------ | | 341| 58.6k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 58.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 58.6k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 47.9k, False: 10.7k] | | | | ------------------ | | ------------------ ------------------ 170| 47.9k| setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2))); ------------------ | | 358| 383k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 47.9k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 47.9k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | | Branch (358:35): [True: 0, False: 47.9k] | | | Branch (358:35): [True: 47.9k, False: 0] | | | Branch (358:35): [True: 0, False: 47.9k] | | | Branch (358:35): [True: 47.9k, False: 0] | | ------------------ ------------------ 171| 47.9k| return 1; 172| 47.9k| } 173| 34.0k| else if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 68.1k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 340| 34.0k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 34.0k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 34.0k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 23.3k, False: 10.7k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 345| 23.3k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 113| 23.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 23.3k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 34.0k, False: 0] | | ------------------ | | 58| 68.1k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 341| 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)) | | ------------------ | | | | 143| 10.7k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 139| 42.9k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (139:27): [True: 0, False: 10.7k] | | | | | | | Branch (139:27): [True: 10.7k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ else if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 34.0k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 340| 34.0k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 34.0k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 34.0k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 15.2k, False: 18.8k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 345| 15.2k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 113| 15.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 15.2k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 34.0k, False: 0] | | ------------------ | | 58| 34.0k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 341| 18.8k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 18.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 18.8k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 18.8k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 143| 18.8k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 139| 75.3k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (139:27): [True: 0, False: 18.8k] | | | | | | | Branch (139:27): [True: 18.8k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 174| 34.0k| setfltvalue(res, numarith(L, op, n1, n2)); ------------------ | | 352| 34.0k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 34.0k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 34.0k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 175| 34.0k| return 1; 176| 34.0k| } 177| 0| else return 0; /* fail */ 178| 82.0k| } 179| 355k| } 180| 355k|} luaO_hexavalue: 192| 68.4k|int luaO_hexavalue (int c) { 193| 68.4k| if (lisdigit(c)) return c - '0'; ------------------ | | 59| 68.4k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 68.4k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 64.1k, False: 4.30k] | | | | ------------------ | | ------------------ ------------------ 194| 4.30k| else return (ltolower(c) - 'a') + 10; ------------------ | | 72| 4.30k| check_exp(('A' <= (c) && (c) <= 'Z') || (c) == ((c) | ('A' ^ 'a')), \ | | ------------------ | | | | 113| 4.30k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 4.30k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ | | 73| 4.30k| (c) | ('A' ^ 'a')) ------------------ 195| 68.4k|} luaO_str2num: 365| 1.25M|size_t luaO_str2num (const char *s, TValue *o) { 366| 1.25M| lua_Integer i; lua_Number n; 367| 1.25M| const char *e; 368| 1.25M| if ((e = l_str2int(s, &i)) != NULL) { /* try as an integer */ ------------------ | Branch (368:7): [True: 1.18M, False: 70.4k] ------------------ 369| 1.18M| setivalue(o, i); ------------------ | | 358| 1.18M| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 1.18M|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 1.18M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 370| 1.18M| } 371| 70.4k| else if ((e = l_str2d(s, &n)) != NULL) { /* else try as a float */ ------------------ | Branch (371:12): [True: 70.3k, False: 48] ------------------ 372| 70.3k| setfltvalue(o, n); ------------------ | | 352| 70.3k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 70.3k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 70.3k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 373| 70.3k| } 374| 48| else 375| 48| return 0; /* conversion failed */ 376| 1.25M| return (e - s) + 1; /* success; return string size */ 377| 1.25M|} luaO_utf8esc: 380| 39.8k|int luaO_utf8esc (char *buff, unsigned long x) { 381| 39.8k| int n = 1; /* number of bytes put in buffer (backwards) */ 382| 39.8k| lua_assert(x <= 0x7FFFFFFFu); ------------------ | | 109| 39.8k|#define lua_assert(c) assert(c) ------------------ 383| 39.8k| if (x < 0x80) /* ascii? */ ------------------ | Branch (383:7): [True: 37.9k, False: 1.88k] ------------------ 384| 37.9k| buff[UTF8BUFFSZ - 1] = cast_char(x); ------------------ | | 833| 37.9k|#define UTF8BUFFSZ 8 ------------------ buff[UTF8BUFFSZ - 1] = cast_char(x); ------------------ | | 148| 37.9k|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 139| 37.9k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 385| 1.88k| else { /* need continuation bytes */ 386| 1.88k| unsigned int mfb = 0x3f; /* maximum that fits in first byte */ 387| 5.74k| do { /* add continuation bytes */ 388| 5.74k| buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f)); ------------------ | | 833| 5.74k|#define UTF8BUFFSZ 8 ------------------ buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f)); ------------------ | | 148| 5.74k|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 139| 5.74k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 389| 5.74k| x >>= 6; /* remove added bits */ 390| 5.74k| mfb >>= 1; /* now there is one less bit available in first byte */ 391| 5.74k| } while (x > mfb); /* still needs continuation byte? */ ------------------ | Branch (391:14): [True: 3.85k, False: 1.88k] ------------------ 392| 1.88k| buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x); /* add first byte */ ------------------ | | 833| 1.88k|#define UTF8BUFFSZ 8 ------------------ buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x); /* add first byte */ ------------------ | | 148| 1.88k|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 139| 1.88k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 393| 1.88k| } 394| 39.8k| return n; 395| 39.8k|} luaO_tostring: 431| 67.2k|void luaO_tostring (lua_State *L, TValue *obj) { 432| 67.2k| char buff[MAXNUMBER2STR]; 433| 67.2k| int len = tostringbuff(obj, buff); 434| 67.2k| setsvalue(L, obj, luaS_newlstr(L, buff, len)); ------------------ | | 385| 67.2k| { TValue *io = (obj); TString *x_ = (x); \ | | 386| 67.2k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 67.2k|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 388| 67.2k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 67.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 67.2k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 67.2k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 387| 67.2k| checkliveness(L,io); } | | ------------------ | | | | 107| 67.2k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 1.07M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 67.2k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 67.2k] | | | | | | | Branch (115:29): [True: 67.2k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 67.2k] | | | | | | | Branch (115:29): [True: 67.2k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 67.2k] | | | | | | | Branch (115:29): [True: 67.2k, False: 0] | | | | | | | Branch (115:29): [True: 67.2k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 67.2k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 67.2k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 435| 67.2k|} luaO_pushvfstring: 537| 1.98k|const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) { 538| 1.98k| BuffFS buff; /* holds last part of the result */ 539| 1.98k| const char *e; /* points to next '%' */ 540| 1.98k| buff.pushed = buff.blen = 0; 541| 1.98k| buff.L = L; 542| 6.19k| while ((e = strchr(fmt, '%')) != NULL) { ------------------ | Branch (542:10): [True: 4.21k, False: 1.98k] ------------------ 543| 4.21k| addstr2buff(&buff, fmt, e - fmt); /* add 'fmt' up to '%' */ 544| 4.21k| switch (*(e + 1)) { /* conversion specifier */ 545| 3.16k| case 's': { /* zero-terminated string */ ------------------ | Branch (545:7): [True: 3.16k, False: 1.05k] ------------------ 546| 3.16k| const char *s = va_arg(argp, char *); 547| 3.16k| if (s == NULL) s = "(null)"; ------------------ | Branch (547:13): [True: 0, False: 3.16k] ------------------ 548| 3.16k| addstr2buff(&buff, s, strlen(s)); 549| 3.16k| break; 550| 0| } 551| 163| case 'c': { /* an 'int' as a character */ ------------------ | Branch (551:7): [True: 163, False: 4.04k] ------------------ 552| 163| char c = cast_uchar(va_arg(argp, int)); ------------------ | | 147| 163|#define cast_uchar(i) cast(unsigned char, (i)) | | ------------------ | | | | 139| 163|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 553| 163| addstr2buff(&buff, &c, sizeof(char)); 554| 163| break; 555| 0| } 556| 887| case 'd': { /* an 'int' */ ------------------ | Branch (556:7): [True: 887, False: 3.32k] ------------------ 557| 887| TValue num; 558| 887| setivalue(&num, va_arg(argp, int)); ------------------ | | 358| 887| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 887|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 887|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 559| 887| addnum2buff(&buff, &num); 560| 887| break; 561| 0| } 562| 0| case 'I': { /* a 'lua_Integer' */ ------------------ | Branch (562:7): [True: 0, False: 4.21k] ------------------ 563| 0| TValue num; 564| 0| setivalue(&num, cast(lua_Integer, va_arg(argp, l_uacInt))); ------------------ | | 358| 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)) | | ------------------ ------------------ 565| 0| addnum2buff(&buff, &num); 566| 0| break; 567| 0| } 568| 0| case 'f': { /* a 'lua_Number' */ ------------------ | Branch (568:7): [True: 0, False: 4.21k] ------------------ 569| 0| TValue num; 570| 0| setfltvalue(&num, cast_num(va_arg(argp, l_uacNumber))); ------------------ | | 352| 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)) | | ------------------ ------------------ 571| 0| addnum2buff(&buff, &num); 572| 0| break; 573| 0| } 574| 0| case 'p': { /* a pointer */ ------------------ | Branch (574:7): [True: 0, False: 4.21k] ------------------ 575| 0| const int sz = 3 * sizeof(void*) + 8; /* enough space for '%p' */ 576| 0| char *bf = getbuff(&buff, sz); 577| 0| void *p = va_arg(argp, void *); 578| 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) | | ------------------ ------------------ 579| 0| addsize(&buff, len); ------------------ | | 503| 0|#define addsize(b,sz) ((b)->blen += (sz)) ------------------ 580| 0| break; 581| 0| } 582| 0| case 'U': { /* a 'long' as a UTF-8 sequence */ ------------------ | Branch (582:7): [True: 0, False: 4.21k] ------------------ 583| 0| char bf[UTF8BUFFSZ]; 584| 0| int len = luaO_utf8esc(bf, va_arg(argp, long)); 585| 0| addstr2buff(&buff, bf + UTF8BUFFSZ - len, len); ------------------ | | 833| 0|#define UTF8BUFFSZ 8 ------------------ 586| 0| break; 587| 0| } 588| 0| case '%': { ------------------ | Branch (588:7): [True: 0, False: 4.21k] ------------------ 589| 0| addstr2buff(&buff, "%", 1); 590| 0| break; 591| 0| } 592| 0| default: { ------------------ | Branch (592:7): [True: 0, False: 4.21k] ------------------ 593| 0| luaG_runerror(L, "invalid option '%%%c' to 'lua_pushfstring'", 594| 0| *(e + 1)); 595| 0| } 596| 4.21k| } 597| 4.21k| fmt = e + 2; /* skip '%' and the specifier */ 598| 4.21k| } 599| 1.98k| addstr2buff(&buff, fmt, strlen(fmt)); /* rest of 'fmt' */ 600| 1.98k| clearbuff(&buff); /* empty buffer into the stack */ 601| 1.98k| lua_assert(buff.pushed == 1); ------------------ | | 109| 1.98k|#define lua_assert(c) assert(c) ------------------ 602| 1.98k| return getstr(tsvalue(s2v(L->top.p - 1))); ------------------ | | 430| 7.46k|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 15.9k|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 1.05k, False: 933] | | | | | Branch (420:24): [True: 0, False: 1.98k] | | | | | Branch (420:24): [True: 1.98k, False: 0] | | | | | Branch (420:24): [True: 0, False: 1.98k] | | | | | Branch (420:24): [True: 1.98k, False: 0] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 2.11k|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 1.05k|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 8.44k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | | | | Branch (139:27): [True: 0, False: 1.05k] | | | | | | | | | Branch (139:27): [True: 1.05k, False: 0] | | | | | | | | | Branch (139:27): [True: 0, False: 1.05k] | | | | | | | | | Branch (139:27): [True: 1.05k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (430:57): [True: 0, False: 933] | | | Branch (430:57): [True: 933, False: 0] | | | Branch (430:57): [True: 0, False: 933] | | | Branch (430:57): [True: 933, False: 0] | | ------------------ ------------------ 603| 1.98k|} luaO_pushfstring: 606| 1.57k|const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) { 607| 1.57k| const char *msg; 608| 1.57k| va_list argp; 609| 1.57k| va_start(argp, fmt); 610| 1.57k| msg = luaO_pushvfstring(L, fmt, argp); 611| 1.57k| va_end(argp); 612| 1.57k| return msg; 613| 1.57k|} luaO_chunkid: 624| 747|void luaO_chunkid (char *out, const char *source, size_t srclen) { 625| 747| size_t bufflen = LUA_IDSIZE; /* free space in buffer */ ------------------ | | 768| 747|#define LUA_IDSIZE 60 ------------------ 626| 747| if (*source == '=') { /* 'literal' source */ ------------------ | Branch (626:7): [True: 0, False: 747] ------------------ 627| 0| if (srclen <= bufflen) /* small enough? */ ------------------ | Branch (627:9): [True: 0, False: 0] ------------------ 628| 0| memcpy(out, source + 1, srclen * sizeof(char)); 629| 0| else { /* truncate it */ 630| 0| addstr(out, source + 1, bufflen - 1); ------------------ | | 622| 0|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 631| 0| *out = '\0'; 632| 0| } 633| 0| } 634| 747| else if (*source == '@') { /* file name */ ------------------ | Branch (634:12): [True: 0, False: 747] ------------------ 635| 0| if (srclen <= bufflen) /* small enough? */ ------------------ | Branch (635:9): [True: 0, False: 0] ------------------ 636| 0| memcpy(out, source + 1, srclen * sizeof(char)); 637| 0| else { /* add '...' before rest of name */ 638| 0| addstr(out, RETS, LL(RETS)); ------------------ | | 622| 0|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 639| 0| bufflen -= LL(RETS); ------------------ | | 73| 0|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 640| 0| memcpy(out, source + 1 + srclen - bufflen, bufflen * sizeof(char)); 641| 0| } 642| 0| } 643| 747| else { /* string; format as [string "source"] */ 644| 747| const char *nl = strchr(source, '\n'); /* find first new line (if any) */ 645| 747| addstr(out, PRE, LL(PRE)); /* add prefix */ ------------------ | | 622| 747|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 646| 747| bufflen -= LL(PRE RETS POS) + 1; /* save space for prefix+suffix+'\0' */ ------------------ | | 73| 747|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 647| 747| if (srclen < bufflen && nl == NULL) { /* small one-line source? */ ------------------ | Branch (647:9): [True: 747, False: 0] | Branch (647:29): [True: 747, False: 0] ------------------ 648| 747| addstr(out, source, srclen); /* keep it */ ------------------ | | 622| 747|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 649| 747| } 650| 0| else { 651| 0| if (nl != NULL) srclen = nl - source; /* stop at first newline */ ------------------ | Branch (651:11): [True: 0, False: 0] ------------------ 652| 0| if (srclen > bufflen) srclen = bufflen; ------------------ | Branch (652:11): [True: 0, False: 0] ------------------ 653| 0| addstr(out, source, srclen); ------------------ | | 622| 0|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 654| 0| addstr(out, RETS, LL(RETS)); ------------------ | | 622| 0|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 655| 0| } 656| 747| memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); ------------------ | | 620| 747|#define POS "\"]" ------------------ memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); ------------------ | | 73| 747|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 657| 747| } 658| 747|} lobject.c:intarith: 111| 115k| lua_Integer v2) { 112| 115k| switch (op) { 113| 428| case LUA_OPADD: return intop(+, v1, v2); ------------------ | | 215| 428|#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ ------------------ case LUA_OPADD: return intop(+, v1, v2); ------------------ | | 73| 428|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 164| 428|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (113:5): [True: 428, False: 115k] ------------------ 114| 4.40k| case LUA_OPSUB:return intop(-, v1, v2); ------------------ | | 216| 4.40k|#define LUA_OPSUB 1 ------------------ case LUA_OPSUB:return intop(-, v1, v2); ------------------ | | 73| 4.40k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 164| 4.40k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (114:5): [True: 4.40k, False: 111k] ------------------ 115| 10.7k| case LUA_OPMUL:return intop(*, v1, v2); ------------------ | | 217| 10.7k|#define LUA_OPMUL 2 ------------------ case LUA_OPMUL:return intop(*, v1, v2); ------------------ | | 73| 10.7k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 164| 10.7k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (115:5): [True: 10.7k, False: 105k] ------------------ 116| 11.4k| case LUA_OPMOD: return luaV_mod(L, v1, v2); ------------------ | | 218| 11.4k|#define LUA_OPMOD 3 ------------------ | Branch (116:5): [True: 11.4k, False: 104k] ------------------ 117| 1.93k| case LUA_OPIDIV: return luaV_idiv(L, v1, v2); ------------------ | | 221| 1.93k|#define LUA_OPIDIV 6 ------------------ | Branch (117:5): [True: 1.93k, False: 114k] ------------------ 118| 480| case LUA_OPBAND: return intop(&, v1, v2); ------------------ | | 222| 480|#define LUA_OPBAND 7 ------------------ case LUA_OPBAND: return intop(&, v1, v2); ------------------ | | 73| 480|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 164| 480|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (118:5): [True: 480, False: 115k] ------------------ 119| 32| case LUA_OPBOR: return intop(|, v1, v2); ------------------ | | 223| 32|#define LUA_OPBOR 8 ------------------ case LUA_OPBOR: return intop(|, v1, v2); ------------------ | | 73| 32|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 164| 32|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (119:5): [True: 32, False: 115k] ------------------ 120| 4.77k| case LUA_OPBXOR: return intop(^, v1, v2); ------------------ | | 224| 4.77k|#define LUA_OPBXOR 9 ------------------ case LUA_OPBXOR: return intop(^, v1, v2); ------------------ | | 73| 4.77k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 164| 4.77k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (120:5): [True: 4.77k, False: 111k] ------------------ 121| 2.33k| case LUA_OPSHL: return luaV_shiftl(v1, v2); ------------------ | | 225| 2.33k|#define LUA_OPSHL 10 ------------------ | Branch (121:5): [True: 2.33k, False: 113k] ------------------ 122| 1.06k| case LUA_OPSHR: return luaV_shiftr(v1, v2); ------------------ | | 226| 1.06k|#define LUA_OPSHR 11 ------------------ case LUA_OPSHR: return luaV_shiftr(v1, v2); ------------------ | | 111| 1.06k|#define luaV_shiftr(x,y) luaV_shiftl(x,intop(-, 0, y)) | | ------------------ | | | | 73| 1.06k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | | | ------------------ | | | | | | 164| 1.06k|#define l_castU2S(i) ((lua_Integer)(i)) | | | | ------------------ | | ------------------ ------------------ | Branch (122:5): [True: 1.06k, False: 114k] ------------------ 123| 18.9k| case LUA_OPUNM: return intop(-, 0, v1); ------------------ | | 227| 18.9k|#define LUA_OPUNM 12 ------------------ case LUA_OPUNM: return intop(-, 0, v1); ------------------ | | 73| 18.9k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 164| 18.9k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (123:5): [True: 18.9k, False: 97.0k] ------------------ 124| 59.3k| case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1); ------------------ | | 228| 59.3k|#define LUA_OPBNOT 13 ------------------ case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1); ------------------ | | 73| 59.3k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 164| 59.3k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (124:5): [True: 59.3k, False: 56.6k] ------------------ 125| 0| default: lua_assert(0); return 0; ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ | Branch (125:5): [True: 0, False: 115k] ------------------ 126| 115k| } 127| 115k|} lobject.c:numarith: 131| 239k| lua_Number v2) { 132| 239k| switch (op) { 133| 3.47k| case LUA_OPADD: return luai_numadd(L, v1, v2); ------------------ | | 215| 3.47k|#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ ------------------ case LUA_OPADD: return luai_numadd(L, v1, v2); ------------------ | | 349| 3.47k|#define luai_numadd(L,a,b) ((a)+(b)) ------------------ | Branch (133:5): [True: 3.47k, False: 235k] ------------------ 134| 5.13k| case LUA_OPSUB: return luai_numsub(L, v1, v2); ------------------ | | 216| 5.13k|#define LUA_OPSUB 1 ------------------ case LUA_OPSUB: return luai_numsub(L, v1, v2); ------------------ | | 350| 5.13k|#define luai_numsub(L,a,b) ((a)-(b)) ------------------ | Branch (134:5): [True: 5.13k, False: 234k] ------------------ 135| 6.94k| case LUA_OPMUL: return luai_nummul(L, v1, v2); ------------------ | | 217| 6.94k|#define LUA_OPMUL 2 ------------------ case LUA_OPMUL: return luai_nummul(L, v1, v2); ------------------ | | 351| 6.94k|#define luai_nummul(L,a,b) ((a)*(b)) ------------------ | Branch (135:5): [True: 6.94k, False: 232k] ------------------ 136| 12.9k| case LUA_OPDIV: return luai_numdiv(L, v1, v2); ------------------ | | 220| 12.9k|#define LUA_OPDIV 5 ------------------ case LUA_OPDIV: return luai_numdiv(L, v1, v2); ------------------ | | 321| 12.9k|#define luai_numdiv(L,a,b) ((a)/(b)) ------------------ | Branch (136:5): [True: 12.9k, False: 226k] ------------------ 137| 192k| case LUA_OPPOW: return luai_numpow(L, v1, v2); ------------------ | | 219| 192k|#define LUA_OPPOW 4 ------------------ case LUA_OPPOW: return luai_numpow(L, v1, v2); ------------------ | | 344| 192k| ((void)L, (b == 2) ? (a)*(a) : l_mathop(pow)(a,b)) | | ------------------ | | | | 482| 134k|#define l_mathop(op) op | | ------------------ | | | Branch (344:13): [True: 57.7k, False: 134k] | | ------------------ ------------------ | Branch (137:5): [True: 192k, False: 47.0k] ------------------ 138| 2.02k| case LUA_OPIDIV: return luai_numidiv(L, v1, v2); ------------------ | | 221| 2.02k|#define LUA_OPIDIV 6 ------------------ case LUA_OPIDIV: return luai_numidiv(L, v1, v2); ------------------ | | 316| 2.02k|#define luai_numidiv(L,a,b) ((void)L, l_floor(luai_numdiv(L,a,b))) | | ------------------ | | | | 418| 2.02k|#define l_floor(x) (l_mathop(floor)(x)) | | | | ------------------ | | | | | | 482| 2.02k|#define l_mathop(op) op | | | | ------------------ | | ------------------ ------------------ | Branch (138:5): [True: 2.02k, False: 237k] ------------------ 139| 8.03k| case LUA_OPUNM: return luai_numunm(L, v1); ------------------ | | 227| 8.03k|#define LUA_OPUNM 12 ------------------ case LUA_OPUNM: return luai_numunm(L, v1); ------------------ | | 352| 8.03k|#define luai_numunm(L,a) (-(a)) ------------------ | Branch (139:5): [True: 8.03k, False: 231k] ------------------ 140| 8.46k| case LUA_OPMOD: return luaV_modf(L, v1, v2); ------------------ | | 218| 8.46k|#define LUA_OPMOD 3 ------------------ | Branch (140:5): [True: 8.46k, False: 230k] ------------------ 141| 0| default: lua_assert(0); return 0; ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ | Branch (141:5): [True: 0, False: 239k] ------------------ 142| 239k| } 143| 239k|} lobject.c:l_str2int: 333| 1.25M|static const char *l_str2int (const char *s, lua_Integer *result) { 334| 1.25M| lua_Unsigned a = 0; 335| 1.25M| int empty = 1; 336| 1.25M| int neg; 337| 1.25M| while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */ 338| 1.25M| neg = isneg(&s); 339| 1.25M| if (s[0] == '0' && ------------------ | Branch (339:7): [True: 668k, False: 585k] ------------------ 340| 1.25M| (s[1] == 'x' || s[1] == 'X')) { /* hex? */ ------------------ | Branch (340:8): [True: 0, False: 668k] | Branch (340:23): [True: 8, False: 668k] ------------------ 341| 8| s += 2; /* skip '0x' */ 342| 8| for (; lisxdigit(cast_uchar(*s)); s++) { 343| 4| a = a * 16 + luaO_hexavalue(*s); 344| 4| empty = 0; 345| 4| } 346| 8| } 347| 1.25M| else { /* decimal */ 348| 2.30M| for (; lisdigit(cast_uchar(*s)); s++) { 349| 2.30M| int d = *s - '0'; 350| 2.30M| if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 330| 2.30M|#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) | | ------------------ | | | | 139| 4.60M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 330| 20.9k|#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) | | ------------------ | | | | 139| 41.8k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 331| 3.02k|#define MAXLASTD cast_int(LUA_MAXINTEGER % 10) | | ------------------ | | | | 144| 3.02k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 139| 3.02k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (350:11): [True: 20.9k, False: 2.28M] | Branch (350:28): [True: 17.9k, False: 3.02k] | Branch (350:43): [True: 1.64k, False: 1.37k] ------------------ 351| 19.5k| return NULL; /* do not accept it (as integer) */ 352| 2.28M| a = a * 10 + d; 353| 2.28M| empty = 0; 354| 2.28M| } 355| 1.25M| } 356| 1.23M| while (lisspace(cast_uchar(*s))) s++; /* skip trailing spaces */ 357| 1.23M| if (empty || *s != '\0') return NULL; /* something wrong in the numeral */ ------------------ | Branch (357:7): [True: 8.10k, False: 1.22M] | Branch (357:16): [True: 42.7k, False: 1.18M] ------------------ 358| 1.18M| else { 359| 1.18M| *result = l_castU2S((neg) ? 0u - a : a); ------------------ | | 164| 2.36M|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ | | | Branch (164:37): [True: 0, False: 1.18M] | | ------------------ ------------------ 360| 1.18M| return s; 361| 1.18M| } 362| 1.23M|} lobject.c:isneg: 198| 1.25M|static int isneg (const char **s) { 199| 1.25M| if (**s == '-') { (*s)++; return 1; } ------------------ | Branch (199:7): [True: 2, False: 1.25M] ------------------ 200| 1.25M| else if (**s == '+') (*s)++; ------------------ | Branch (200:12): [True: 0, False: 1.25M] ------------------ 201| 1.25M| return 0; 202| 1.25M|} lobject.c:l_str2d: 308| 70.4k|static const char *l_str2d (const char *s, lua_Number *result) { 309| 70.4k| const char *endptr; 310| 70.4k| const char *pmode = strpbrk(s, ".xXnN"); /* look for special chars */ 311| 70.4k| int mode = pmode ? ltolower(cast_uchar(*pmode)) : 0; ------------------ | | 72| 45.0k| check_exp(('A' <= (c) && (c) <= 'Z') || (c) == ((c) | ('A' ^ 'a')), \ | | ------------------ | | | | 113| 45.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 45.0k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ | | 73| 70.4k| (c) | ('A' ^ 'a')) ------------------ | Branch (311:14): [True: 45.0k, False: 25.3k] ------------------ 312| 70.4k| if (mode == 'n') /* reject 'inf' and 'nan' */ ------------------ | Branch (312:7): [True: 23, False: 70.3k] ------------------ 313| 23| return NULL; 314| 70.3k| endptr = l_str2dloc(s, result, mode); /* try to convert */ 315| 70.3k| if (endptr == NULL) { /* failed? may be a different locale */ ------------------ | Branch (315:7): [True: 25, False: 70.3k] ------------------ 316| 25| char buff[L_MAXLENNUM + 1]; 317| 25| const char *pdot = strchr(s, '.'); 318| 25| if (pdot == NULL || strlen(s) > L_MAXLENNUM) ------------------ | | 277| 8|#define L_MAXLENNUM 200 ------------------ | Branch (318:9): [True: 17, False: 8] | Branch (318:25): [True: 7, False: 1] ------------------ 319| 24| return NULL; /* string too long or no dot; fail */ 320| 1| strcpy(buff, s); /* copy string to buffer */ 321| 1| buff[pdot - s] = lua_getlocaledecpoint(); /* correct decimal point */ ------------------ | | 671| 1|#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) ------------------ 322| 1| endptr = l_str2dloc(buff, result, mode); /* try again */ 323| 1| if (endptr != NULL) ------------------ | Branch (323:9): [True: 0, False: 1] ------------------ 324| 0| endptr = s + (endptr - buff); /* make relative to 's' */ 325| 1| } 326| 70.3k| return endptr; 327| 70.3k|} lobject.c:l_str2dloc: 285| 70.3k|static const char *l_str2dloc (const char *s, lua_Number *result, int mode) { 286| 70.3k| char *endptr; 287| | *result = (mode == 'x') ? lua_strx2number(s, &endptr) /* try to convert */ ------------------ | | 610| 5|#define lua_strx2number(s,p) lua_str2number(s,p) | | ------------------ | | | | 484| 5|#define lua_str2number(s,p) strtod((s), (p)) | | ------------------ ------------------ | Branch (287:13): [True: 5, False: 70.3k] ------------------ 288| 70.3k| : lua_str2number(s, &endptr); ------------------ | | 484| 140k|#define lua_str2number(s,p) strtod((s), (p)) ------------------ 289| 70.3k| if (endptr == s) return NULL; /* nothing recognized? */ ------------------ | Branch (289:7): [True: 2, False: 70.3k] ------------------ 290| 70.3k| while (lisspace(cast_uchar(*endptr))) endptr++; /* skip trailing spaces */ 291| 70.3k| return (*endptr == '\0') ? endptr : NULL; /* OK iff no trailing chars */ ------------------ | Branch (291:10): [True: 70.3k, False: 24] ------------------ 292| 70.3k|} lobject.c:tostringbuff: 412| 68.1k|static int tostringbuff (TValue *obj, char *buff) { 413| 68.1k| int len; 414| 68.1k| lua_assert(ttisnumber(obj)); ------------------ | | 109| 68.1k|#define lua_assert(c) assert(c) ------------------ 415| 68.1k| if (ttisinteger(obj)) ------------------ | | 341| 68.1k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 68.1k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 68.1k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 11.4k, False: 56.7k] | | | | ------------------ | | ------------------ ------------------ 416| 11.4k| len = lua_integer2str(buff, MAXNUMBER2STR, ivalue(obj)); ------------------ | | 514| 11.4k| l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) | | ------------------ | | | | 597| 45.6k|#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) | | | | ------------------ | | | | | Branch (597:45): [True: 0, False: 11.4k] | | | | | Branch (597:45): [True: 11.4k, False: 0] | | | | ------------------ | | ------------------ ------------------ 417| 56.7k| else { 418| 56.7k| len = lua_number2str(buff, MAXNUMBER2STR, fltvalue(obj)); ------------------ | | 421| 56.7k| l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) | | ------------------ | | | | 597| 227k|#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) | | | | ------------------ | | | | | Branch (597:45): [True: 0, False: 56.7k] | | | | | Branch (597:45): [True: 56.7k, False: 0] | | | | ------------------ | | ------------------ ------------------ 419| 56.7k| if (buff[strspn(buff, "-0123456789")] == '\0') { /* looks like an int? */ ------------------ | Branch (419:9): [True: 28.5k, False: 28.1k] ------------------ 420| 28.5k| buff[len++] = lua_getlocaledecpoint(); ------------------ | | 671| 28.5k|#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) ------------------ 421| 28.5k| buff[len++] = '0'; /* adds '.0' to result */ 422| 28.5k| } 423| 56.7k| } 424| 68.1k| return len; 425| 68.1k|} lobject.c:addstr2buff: 510| 9.52k|static void addstr2buff (BuffFS *buff, const char *str, size_t slen) { 511| 9.52k| if (slen <= BUFVFS) { /* does string fit into buffer? */ ------------------ | | 451| 9.52k|#define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 768| 9.52k|#define LUA_IDSIZE 60 | | ------------------ | | #define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 406| 9.52k|#define MAXNUMBER2STR 44 | | ------------------ ------------------ | Branch (511:7): [True: 9.28k, False: 233] ------------------ 512| 9.28k| char *bf = getbuff(buff, cast_int(slen)); ------------------ | | 144| 9.28k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 9.28k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 513| 9.28k| memcpy(bf, str, slen); /* add string to buffer */ 514| 9.28k| addsize(buff, cast_int(slen)); ------------------ | | 503| 9.28k|#define addsize(b,sz) ((b)->blen += (sz)) ------------------ 515| 9.28k| } 516| 233| else { /* string larger than buffer */ 517| 233| clearbuff(buff); /* string comes after buffer's content */ 518| 233| pushstr(buff, str, slen); /* push string */ 519| 233| } 520| 9.52k|} lobject.c:pushstr: 471| 2.45k|static void pushstr (BuffFS *buff, const char *str, size_t lstr) { 472| 2.45k| lua_State *L = buff->L; 473| 2.45k| setsvalue2s(L, L->top.p, luaS_newlstr(L, str, lstr)); ------------------ | | 390| 2.45k|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 385| 2.45k| { TValue *io = (obj); TString *x_ = (x); \ | | | | 386| 2.45k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 2.45k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 388| 2.45k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 2.45k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 2.45k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 2.45k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 387| 2.45k| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 2.45k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 39.3k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 2.45k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 2.45k] | | | | | | | | | Branch (115:29): [True: 2.45k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 2.45k] | | | | | | | | | Branch (115:29): [True: 2.45k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 2.45k] | | | | | | | | | Branch (115:29): [True: 2.45k, False: 0] | | | | | | | | | Branch (115:29): [True: 2.45k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 2.45k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 2.45k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 474| 2.45k| L->top.p++; /* may use one slot from EXTRA_STACK */ 475| 2.45k| if (!buff->pushed) /* no previous string on the stack? */ ------------------ | Branch (475:7): [True: 1.98k, False: 469] ------------------ 476| 1.98k| buff->pushed = 1; /* now there is one */ 477| 469| else /* join previous string with new one */ 478| 469| luaV_concat(L, 2); 479| 2.45k|} lobject.c:addnum2buff: 526| 887|static void addnum2buff (BuffFS *buff, TValue *num) { 527| 887| char *numbuff = getbuff(buff, MAXNUMBER2STR); ------------------ | | 406| 887|#define MAXNUMBER2STR 44 ------------------ 528| 887| int len = tostringbuff(num, numbuff); /* format number into 'numbuff' */ 529| 887| addsize(buff, len); ------------------ | | 503| 887|#define addsize(b,sz) ((b)->blen += (sz)) ------------------ 530| 887|} lobject.c:getbuff: 495| 10.1k|static char *getbuff (BuffFS *buff, int sz) { 496| 10.1k| lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS); ------------------ | | 109| 10.1k|#define lua_assert(c) assert(c) ------------------ lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS); ------------------ | | 109| 10.1k|#define lua_assert(c) assert(c) ------------------ 497| 10.1k| if (sz > BUFVFS - buff->blen) /* not enough space? */ ------------------ | | 451| 10.1k|#define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 768| 10.1k|#define LUA_IDSIZE 60 | | ------------------ | | #define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 406| 10.1k|#define MAXNUMBER2STR 44 | | ------------------ ------------------ | Branch (497:7): [True: 3, False: 10.1k] ------------------ 498| 3| clearbuff(buff); 499| 10.1k| return buff->space + buff->blen; 500| 10.1k|} lobject.c:clearbuff: 485| 2.22k|static void clearbuff (BuffFS *buff) { 486| 2.22k| pushstr(buff, buff->space, buff->blen); /* push buffer contents */ 487| 2.22k| buff->blen = 0; /* space now is empty */ 488| 2.22k|} luaY_nvarstack: 251| 70.1M|int luaY_nvarstack (FuncState *fs) { 252| 70.1M| return reglevel(fs, fs->nactvar); 253| 70.1M|} luaY_parser: 1952| 561| Dyndata *dyd, const char *name, int firstchar) { 1953| 561| LexState lexstate; 1954| 561| FuncState funcstate; 1955| 561| LClosure *cl = luaF_newLclosure(L, 1); /* create main closure */ 1956| 561| setclLvalue2s(L, L->top.p, cl); /* anchor it (to avoid being collected) */ ------------------ | | 652| 561|#define setclLvalue2s(L,o,cl) setclLvalue(L,s2v(o),cl) | | ------------------ | | | | 648| 561| { TValue *io = (obj); LClosure *x_ = (x); \ | | | | 649| 561| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 72| 561|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 388| 561|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 561|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 114| 561|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 650| 561| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 561| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 8.97k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 561| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1957| 561| luaD_inctop(L); 1958| 561| lexstate.h = luaH_new(L); /* create table for scanner */ 1959| 561| sethvalue2s(L, L->top.p, lexstate.h); /* anchor it */ ------------------ | | 728| 561|#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) | | ------------------ | | | | 724| 561| { TValue *io = (obj); Table *x_ = (x); \ | | | | 725| 561| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 72| 561|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 388| 561|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 561|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 114| 561|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 726| 561| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 561| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 8.97k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 561| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1960| 561| luaD_inctop(L); 1961| 561| funcstate.f = cl->p = luaF_newproto(L); 1962| 561| luaC_objbarrier(L, cl, cl->p); ------------------ | | 222| 561|#define luaC_objbarrier(L,p,o) ( \ | | 223| 561| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 91| 561|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 70| 561|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 65| 1.12k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 561] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 224| 561| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 141| 561|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 561|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1963| 0| funcstate.f->source = luaS_new(L, name); /* create and anchor TString */ 1964| 561| luaC_objbarrier(L, funcstate.f, funcstate.f->source); ------------------ | | 222| 561|#define luaC_objbarrier(L,p,o) ( \ | | 223| 561| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 91| 561|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 70| 561|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 65| 1.12k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 561] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 224| 561| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 141| 561|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 561|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1965| 0| lexstate.buff = buff; 1966| 561| lexstate.dyd = dyd; 1967| 561| dyd->actvar.n = dyd->gt.n = dyd->label.n = 0; 1968| 561| luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar); 1969| 561| mainfunc(&lexstate, &funcstate); 1970| 561| lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs); ------------------ | | 109| 561|#define lua_assert(c) assert(c) ------------------ 1971| | /* all scopes should be correctly finished */ 1972| 162| lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0); ------------------ | | 109| 162|#define lua_assert(c) assert(c) ------------------ 1973| 162| L->top.p--; /* remove scanner's table */ 1974| 162| return cl; /* closure is on the stack, too */ 1975| 162|} lparser.c:reglevel: 237| 70.2M|static int reglevel (FuncState *fs, int nvar) { 238| 83.8M| while (nvar-- > 0) { ------------------ | Branch (238:10): [True: 29.4M, False: 54.4M] ------------------ 239| 29.4M| Vardesc *vd = getlocalvardesc(fs, nvar); /* get previous variable */ 240| 29.4M| if (vd->vd.kind != RDKCTC) /* is in a register? */ ------------------ | | 93| 29.4M|#define RDKCTC 3 /* compile-time constant */ ------------------ | Branch (240:9): [True: 15.7M, False: 13.6M] ------------------ 241| 15.7M| return vd->vd.ridx + 1; 242| 29.4M| } 243| 54.4M| return 0; /* no variables in registers */ 244| 70.2M|} lparser.c:getlocalvardesc: 227| 300M|static Vardesc *getlocalvardesc (FuncState *fs, int vidx) { 228| 300M| return &fs->ls->dyd->actvar.arr[fs->firstlocal + vidx]; 229| 300M|} lparser.c:mainfunc: 1933| 561|static void mainfunc (LexState *ls, FuncState *fs) { 1934| 561| BlockCnt bl; 1935| 561| Upvaldesc *env; 1936| 561| open_func(ls, fs, &bl); 1937| 561| setvararg(fs, 0); /* main function is always declared vararg */ 1938| 561| env = allocupvalue(fs); /* ...set environment upvalue */ 1939| 561| env->instack = 1; 1940| 561| env->idx = 0; 1941| 561| env->kind = VDKREG; ------------------ | | 90| 561|#define VDKREG 0 /* regular */ ------------------ 1942| 561| env->name = ls->envn; 1943| 561| luaC_objbarrier(ls->L, fs->f, env->name); ------------------ | | 222| 561|#define luaC_objbarrier(L,p,o) ( \ | | 223| 561| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 91| 561|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 70| 561|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 65| 1.12k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 561] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 224| 561| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 141| 561|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 561|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1944| 0| luaX_next(ls); /* read first token */ 1945| 561| statlist(ls); /* parse main body */ 1946| 561| check(ls, TK_EOS); 1947| 561| close_func(ls); 1948| 561|} lparser.c:open_func: 738| 21.7k|static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) { 739| 21.7k| Proto *f = fs->f; 740| 21.7k| fs->prev = ls->fs; /* linked list of funcstates */ 741| 21.7k| fs->ls = ls; 742| 21.7k| ls->fs = fs; 743| 21.7k| fs->pc = 0; 744| 21.7k| fs->previousline = f->linedefined; 745| 21.7k| fs->iwthabs = 0; 746| 21.7k| fs->lasttarget = 0; 747| 21.7k| fs->freereg = 0; 748| 21.7k| fs->nk = 0; 749| 21.7k| fs->nabslineinfo = 0; 750| 21.7k| fs->np = 0; 751| 21.7k| fs->nups = 0; 752| 21.7k| fs->ndebugvars = 0; 753| 21.7k| fs->nactvar = 0; 754| 21.7k| fs->needclose = 0; 755| 21.7k| fs->firstlocal = ls->dyd->actvar.n; 756| 21.7k| fs->firstlabel = ls->dyd->label.n; 757| 21.7k| fs->bl = NULL; 758| 21.7k| f->source = ls->source; 759| 21.7k| luaC_objbarrier(ls->L, f, f->source); ------------------ | | 222| 21.7k|#define luaC_objbarrier(L,p,o) ( \ | | 223| 21.7k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 91| 21.7k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 70| 21.7k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 65| 43.5k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 21.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 224| 21.7k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 141| 21.7k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 21.7k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 760| 0| f->maxstacksize = 2; /* registers 0/1 are always valid */ 761| 21.7k| enterblock(fs, bl, 0); 762| 21.7k|} lparser.c:enterblock: 651| 43.6k|static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) { 652| 43.6k| bl->isloop = isloop; 653| 43.6k| bl->nactvar = fs->nactvar; 654| 43.6k| bl->firstlabel = fs->ls->dyd->label.n; 655| 43.6k| bl->firstgoto = fs->ls->dyd->gt.n; 656| 43.6k| bl->upval = 0; 657| 43.6k| bl->insidetbc = (fs->bl != NULL && fs->bl->insidetbc); ------------------ | Branch (657:20): [True: 21.9k, False: 21.7k] | Branch (657:38): [True: 14.9k, False: 6.96k] ------------------ 658| 43.6k| bl->previous = fs->bl; 659| 43.6k| fs->bl = bl; 660| 43.6k| lua_assert(fs->freereg == luaY_nvarstack(fs)); ------------------ | | 109| 43.6k|#define lua_assert(c) assert(c) ------------------ 661| 43.6k|} lparser.c:setvararg: 962| 926|static void setvararg (FuncState *fs, int nparams) { 963| 926| fs->f->flag |= PF_ISVARARG; ------------------ | | 582| 926|#define PF_ISVARARG 1 ------------------ 964| 926| luaK_codeABC(fs, OP_VARARGPREP, nparams, 0, 0); ------------------ | | 48| 926|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 965| 926|} lparser.c:allocupvalue: 360| 29.6k|static Upvaldesc *allocupvalue (FuncState *fs) { 361| 29.6k| Proto *f = fs->f; 362| 29.6k| int oldsize = f->sizeupvalues; 363| 29.6k| checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues"); ------------------ | | 29| 29.6k|#define MAXUPVAL 255 ------------------ 364| 29.6k| luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues, ------------------ | | 69| 29.6k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 139| 59.2k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 70| 29.6k| luaM_limitN(limit,t),e))) ------------------ 365| 29.6k| Upvaldesc, MAXUPVAL, "upvalues"); 366| 112k| while (oldsize < f->sizeupvalues) ------------------ | Branch (366:10): [True: 82.9k, False: 29.6k] ------------------ 367| 82.9k| f->upvalues[oldsize++].name = NULL; 368| 29.6k| return &f->upvalues[fs->nups++]; 369| 29.6k|} lparser.c:checklimit: 87| 61.4k|static void checklimit (FuncState *fs, int v, int l, const char *what) { 88| 61.4k| if (v > l) errorlimit(fs, l, what); ------------------ | Branch (88:7): [True: 5, False: 61.4k] ------------------ 89| 61.4k|} lparser.c:errorlimit: 74| 5|static l_noret errorlimit (FuncState *fs, int limit, const char *what) { 75| 5| lua_State *L = fs->ls->L; 76| 5| const char *msg; 77| 5| int line = fs->f->linedefined; 78| 5| const char *where = (line == 0) ------------------ | Branch (78:23): [True: 4, False: 1] ------------------ 79| 5| ? "main function" 80| 5| : luaO_pushfstring(L, "function at line %d", line); 81| 5| msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s", 82| 5| what, limit, where); 83| 5| luaX_syntaxerror(fs->ls, msg); 84| 5|} lparser.c:statlist: 808| 31.8k|static void statlist (LexState *ls) { 809| | /* statlist -> { stat [';'] } */ 810| 245k| while (!block_follow(ls, 1)) { ------------------ | Branch (810:10): [True: 221k, False: 23.8k] ------------------ 811| 221k| if (ls->t.token == TK_RETURN) { ------------------ | Branch (811:9): [True: 7.96k, False: 213k] ------------------ 812| 7.96k| statement(ls); 813| 7.96k| return; /* 'return' must be last statement */ 814| 7.96k| } 815| 213k| statement(ls); 816| 213k| } 817| 31.8k|} lparser.c:block_follow: 797| 259k|static int block_follow (LexState *ls, int withuntil) { 798| 259k| switch (ls->t.token) { 799| 5.03k| case TK_ELSE: case TK_ELSEIF: ------------------ | Branch (799:5): [True: 0, False: 259k] | Branch (799:19): [True: 5.03k, False: 254k] ------------------ 800| 27.6k| case TK_END: case TK_EOS: ------------------ | Branch (800:5): [True: 22.4k, False: 236k] | Branch (800:18): [True: 171, False: 259k] ------------------ 801| 27.6k| return 1; 802| 32| case TK_UNTIL: return withuntil; ------------------ | Branch (802:5): [True: 32, False: 259k] ------------------ 803| 231k| default: return 0; ------------------ | Branch (803:5): [True: 231k, False: 27.7k] ------------------ 804| 259k| } 805| 259k|} lparser.c:statement: 1854| 221k|static void statement (LexState *ls) { 1855| 221k| int line = ls->linenumber; /* may be needed for error messages */ 1856| 221k| enterlevel(ls); ------------------ | | 512| 221k|#define enterlevel(ls) luaE_incCstack(ls->L) ------------------ 1857| 221k| switch (ls->t.token) { 1858| 59.3k| case ';': { /* stat -> ';' (empty statement) */ ------------------ | Branch (1858:5): [True: 59.3k, False: 161k] ------------------ 1859| 59.3k| luaX_next(ls); /* skip ';' */ 1860| 59.3k| break; 1861| 0| } 1862| 3.15k| case TK_IF: { /* stat -> ifstat */ ------------------ | Branch (1862:5): [True: 3.15k, False: 218k] ------------------ 1863| 3.15k| ifstat(ls, line); 1864| 3.15k| break; 1865| 0| } 1866| 2.96k| case TK_WHILE: { /* stat -> whilestat */ ------------------ | Branch (1866:5): [True: 2.96k, False: 218k] ------------------ 1867| 2.96k| whilestat(ls, line); 1868| 2.96k| break; 1869| 0| } 1870| 2.87k| case TK_DO: { /* stat -> DO block END */ ------------------ | Branch (1870:5): [True: 2.87k, False: 218k] ------------------ 1871| 2.87k| luaX_next(ls); /* skip DO */ 1872| 2.87k| block(ls); 1873| 2.87k| check_match(ls, TK_END, TK_DO, line); 1874| 2.87k| break; 1875| 0| } 1876| 1.53k| case TK_FOR: { /* stat -> forstat */ ------------------ | Branch (1876:5): [True: 1.53k, False: 219k] ------------------ 1877| 1.53k| forstat(ls, line); 1878| 1.53k| break; 1879| 0| } 1880| 166| case TK_REPEAT: { /* stat -> repeatstat */ ------------------ | Branch (1880:5): [True: 166, False: 221k] ------------------ 1881| 166| repeatstat(ls, line); 1882| 166| break; 1883| 0| } 1884| 3.16k| case TK_FUNCTION: { /* stat -> funcstat */ ------------------ | Branch (1884:5): [True: 3.16k, False: 218k] ------------------ 1885| 3.16k| funcstat(ls, line); 1886| 3.16k| break; 1887| 0| } 1888| 8.57k| case TK_LOCAL: { /* stat -> localstat */ ------------------ | Branch (1888:5): [True: 8.57k, False: 212k] ------------------ 1889| 8.57k| luaX_next(ls); /* skip LOCAL */ 1890| 8.57k| if (testnext(ls, TK_FUNCTION)) /* local function? */ ------------------ | Branch (1890:11): [True: 1.97k, False: 6.59k] ------------------ 1891| 1.97k| localfunc(ls); 1892| 6.59k| else 1893| 6.59k| localstat(ls); 1894| 8.57k| break; 1895| 0| } 1896| 31| case TK_DBCOLON: { /* stat -> label */ ------------------ | Branch (1896:5): [True: 31, False: 221k] ------------------ 1897| 31| luaX_next(ls); /* skip double colon */ 1898| 31| labelstat(ls, str_checkname(ls), line); 1899| 31| break; 1900| 0| } 1901| 7.96k| case TK_RETURN: { /* stat -> retstat */ ------------------ | Branch (1901:5): [True: 7.96k, False: 213k] ------------------ 1902| 7.96k| luaX_next(ls); /* skip RETURN */ 1903| 7.96k| retstat(ls); 1904| 7.96k| break; 1905| 0| } 1906| 128| case TK_BREAK: { /* stat -> breakstat */ ------------------ | Branch (1906:5): [True: 128, False: 221k] ------------------ 1907| 128| breakstat(ls); 1908| 128| break; 1909| 0| } 1910| 25.3k| case TK_GOTO: { /* stat -> 'goto' NAME */ ------------------ | Branch (1910:5): [True: 25.3k, False: 195k] ------------------ 1911| 25.3k| luaX_next(ls); /* skip 'goto' */ 1912| 25.3k| gotostat(ls); 1913| 25.3k| break; 1914| 0| } 1915| 105k| default: { /* stat -> func | assignment */ ------------------ | Branch (1915:5): [True: 105k, False: 115k] ------------------ 1916| 105k| exprstat(ls); 1917| 105k| break; 1918| 0| } 1919| 221k| } 1920| 219k| lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg && ------------------ | | 109| 219k|#define lua_assert(c) assert(c) ------------------ 1921| 219k| ls->fs->freereg >= luaY_nvarstack(ls->fs)); 1922| 219k| ls->fs->freereg = luaY_nvarstack(ls->fs); /* free registers */ 1923| 219k| leavelevel(ls); ------------------ | | 515| 219k|#define leavelevel(ls) ((ls)->L->nCcalls--) ------------------ 1924| 219k|} lparser.c:ifstat: 1683| 3.15k|static void ifstat (LexState *ls, int line) { 1684| | /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */ 1685| 3.15k| FuncState *fs = ls->fs; 1686| 3.15k| int escapelist = NO_JUMP; /* exit list for finished parts */ ------------------ | | 20| 3.15k|#define NO_JUMP (-1) ------------------ 1687| 3.15k| test_then_block(ls, &escapelist); /* IF cond THEN block */ 1688| 8.18k| while (ls->t.token == TK_ELSEIF) ------------------ | Branch (1688:10): [True: 5.03k, False: 3.15k] ------------------ 1689| 5.03k| test_then_block(ls, &escapelist); /* ELSEIF cond THEN block */ 1690| 3.15k| if (testnext(ls, TK_ELSE)) ------------------ | Branch (1690:7): [True: 0, False: 3.15k] ------------------ 1691| 0| block(ls); /* 'else' part */ 1692| 3.15k| check_match(ls, TK_END, TK_IF, line); 1693| 3.15k| luaK_patchtohere(fs, escapelist); /* patch escape list to 'if' end */ 1694| 3.15k|} lparser.c:test_then_block: 1646| 8.18k|static void test_then_block (LexState *ls, int *escapelist) { 1647| | /* test_then_block -> [IF | ELSEIF] cond THEN block */ 1648| 8.18k| BlockCnt bl; 1649| 8.18k| FuncState *fs = ls->fs; 1650| 8.18k| expdesc v; 1651| 8.18k| int jf; /* instruction to skip 'then' code (if condition is false) */ 1652| 8.18k| luaX_next(ls); /* skip IF or ELSEIF */ 1653| 8.18k| expr(ls, &v); /* read condition */ 1654| 8.18k| checknext(ls, TK_THEN); 1655| 8.18k| if (ls->t.token == TK_BREAK) { /* 'if x then break' ? */ ------------------ | Branch (1655:7): [True: 8.18k, False: 3] ------------------ 1656| 8.18k| int line = ls->linenumber; 1657| 8.18k| luaK_goiffalse(ls->fs, &v); /* will jump if condition is true */ 1658| 8.18k| luaX_next(ls); /* skip 'break' */ 1659| 8.18k| enterblock(fs, &bl, 0); /* must enter block before 'goto' */ 1660| 8.18k| newgotoentry(ls, luaS_newliteral(ls->L, "break"), line, v.t); ------------------ | | 30| 8.18k|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 31| 8.18k| (sizeof(s)/sizeof(char))-1)) ------------------ 1661| 8.18k| while (testnext(ls, ';')) {} /* skip semicolons */ ------------------ | Branch (1661:12): [True: 1, False: 8.18k] ------------------ 1662| 8.18k| if (block_follow(ls, 0)) { /* jump is the entire block? */ ------------------ | Branch (1662:9): [True: 5.58k, False: 2.59k] ------------------ 1663| 5.58k| leaveblock(fs); 1664| 5.58k| return; /* and that is it */ 1665| 5.58k| } 1666| 2.59k| else /* must skip over 'then' part if condition is false */ 1667| 2.59k| jf = luaK_jump(fs); 1668| 8.18k| } 1669| 3| else { /* regular case (not a break) */ 1670| 3| luaK_goiftrue(ls->fs, &v); /* skip over block if condition is false */ 1671| 3| enterblock(fs, &bl, 0); 1672| 3| jf = v.f; 1673| 3| } 1674| 2.60k| statlist(ls); /* 'then' part */ 1675| 2.60k| leaveblock(fs); 1676| 2.60k| if (ls->t.token == TK_ELSE || ------------------ | Branch (1676:7): [True: 312, False: 2.28k] ------------------ 1677| 2.60k| ls->t.token == TK_ELSEIF) /* followed by 'else'/'elseif'? */ ------------------ | Branch (1677:7): [True: 649, False: 1.64k] ------------------ 1678| 649| luaK_concat(fs, escapelist, luaK_jump(fs)); /* must jump over it */ 1679| 2.60k| luaK_patchtohere(fs, jf); 1680| 2.60k|} lparser.c:expr: 1299| 1.84M|static void expr (LexState *ls, expdesc *v) { 1300| 1.84M| subexpr(ls, v, 0); 1301| 1.84M|} lparser.c:subexpr: 1269| 27.7M|static BinOpr subexpr (LexState *ls, expdesc *v, int limit) { 1270| 27.7M| BinOpr op; 1271| 27.7M| UnOpr uop; 1272| 27.7M| enterlevel(ls); ------------------ | | 512| 27.7M|#define enterlevel(ls) luaE_incCstack(ls->L) ------------------ 1273| 27.7M| uop = getunopr(ls->t.token); 1274| 27.7M| if (uop != OPR_NOUNOPR) { /* prefix (unary) operator? */ ------------------ | Branch (1274:7): [True: 205k, False: 27.4M] ------------------ 1275| 205k| int line = ls->linenumber; 1276| 205k| luaX_next(ls); /* skip operator */ 1277| 205k| subexpr(ls, v, UNARY_PRIORITY); ------------------ | | 1262| 205k|#define UNARY_PRIORITY 12 /* priority for unary operators */ ------------------ 1278| 205k| luaK_prefix(ls->fs, uop, v, line); 1279| 205k| } 1280| 27.4M| else simpleexp(ls, v); 1281| | /* expand while operators have priorities higher than 'limit' */ 1282| 27.7M| op = getbinopr(ls->t.token); 1283| 53.3M| while (op != OPR_NOBINOPR && priority[op].left > limit) { ------------------ | Branch (1283:10): [True: 51.3M, False: 2.02M] | Branch (1283:32): [True: 25.6M, False: 25.6M] ------------------ 1284| 25.6M| expdesc v2; 1285| 25.6M| BinOpr nextop; 1286| 25.6M| int line = ls->linenumber; 1287| 25.6M| luaX_next(ls); /* skip operator */ 1288| 25.6M| luaK_infix(ls->fs, op, v); 1289| | /* read sub-expression with higher priority */ 1290| 25.6M| nextop = subexpr(ls, &v2, priority[op].right); 1291| 25.6M| luaK_posfix(ls->fs, op, v, &v2, line); 1292| 25.6M| op = nextop; 1293| 25.6M| } 1294| 27.7M| leavelevel(ls); ------------------ | | 515| 27.7M|#define leavelevel(ls) ((ls)->L->nCcalls--) ------------------ 1295| 27.7M| return op; /* return first untreated operator */ 1296| 27.7M|} lparser.c:getunopr: 1204| 27.7M|static UnOpr getunopr (int op) { 1205| 27.7M| switch (op) { 1206| 3.90k| case TK_NOT: return OPR_NOT; ------------------ | Branch (1206:5): [True: 3.90k, False: 27.6M] ------------------ 1207| 69.4k| case '-': return OPR_MINUS; ------------------ | Branch (1207:5): [True: 69.4k, False: 27.6M] ------------------ 1208| 119k| case '~': return OPR_BNOT; ------------------ | Branch (1208:5): [True: 119k, False: 27.5M] ------------------ 1209| 12.7k| case '#': return OPR_LEN; ------------------ | Branch (1209:5): [True: 12.7k, False: 27.6M] ------------------ 1210| 27.4M| default: return OPR_NOUNOPR; ------------------ | Branch (1210:5): [True: 27.4M, False: 205k] ------------------ 1211| 27.7M| } 1212| 27.7M|} lparser.c:simpleexp: 1149| 27.4M|static void simpleexp (LexState *ls, expdesc *v) { 1150| | /* simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... | 1151| | constructor | FUNCTION body | suffixedexp */ 1152| 27.4M| switch (ls->t.token) { 1153| 70.3k| case TK_FLT: { ------------------ | Branch (1153:5): [True: 70.3k, False: 27.4M] ------------------ 1154| 70.3k| init_exp(v, VKFLT, 0); 1155| 70.3k| v->u.nval = ls->t.seminfo.r; 1156| 70.3k| break; 1157| 0| } 1158| 1.18M| case TK_INT: { ------------------ | Branch (1158:5): [True: 1.18M, False: 26.3M] ------------------ 1159| 1.18M| init_exp(v, VKINT, 0); 1160| 1.18M| v->u.ival = ls->t.seminfo.i; 1161| 1.18M| break; 1162| 0| } 1163| 41.6k| case TK_STRING: { ------------------ | Branch (1163:5): [True: 41.6k, False: 27.4M] ------------------ 1164| 41.6k| codestring(v, ls->t.seminfo.ts); 1165| 41.6k| break; 1166| 0| } 1167| 17.2k| case TK_NIL: { ------------------ | Branch (1167:5): [True: 17.2k, False: 27.4M] ------------------ 1168| 17.2k| init_exp(v, VNIL, 0); 1169| 17.2k| break; 1170| 0| } 1171| 4.30k| case TK_TRUE: { ------------------ | Branch (1171:5): [True: 4.30k, False: 27.4M] ------------------ 1172| 4.30k| init_exp(v, VTRUE, 0); 1173| 4.30k| break; 1174| 0| } 1175| 62| case TK_FALSE: { ------------------ | Branch (1175:5): [True: 62, False: 27.4M] ------------------ 1176| 62| init_exp(v, VFALSE, 0); 1177| 62| break; 1178| 0| } 1179| 2.66k| case TK_DOTS: { /* vararg */ ------------------ | Branch (1179:5): [True: 2.66k, False: 27.4M] ------------------ 1180| 2.66k| FuncState *fs = ls->fs; 1181| 2.66k| check_condition(ls, fs->f->flag & PF_ISVARARG, ------------------ | | 122| 2.66k|#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } | | ------------------ | | | Branch (122:41): [True: 2, False: 2.65k] | | ------------------ ------------------ 1182| 2.66k| "cannot use '...' outside a vararg function"); 1183| 2.65k| init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 0, 1)); ------------------ | | 48| 2.65k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1184| 2.65k| break; 1185| 2.66k| } 1186| 2.24k| case '{': { /* constructor */ ------------------ | Branch (1186:5): [True: 2.24k, False: 27.4M] ------------------ 1187| 2.24k| constructor(ls, v); 1188| 2.24k| return; 1189| 2.66k| } 1190| 16.0k| case TK_FUNCTION: { ------------------ | Branch (1190:5): [True: 16.0k, False: 27.4M] ------------------ 1191| 16.0k| luaX_next(ls); 1192| 16.0k| body(ls, v, 0, ls->linenumber); 1193| 16.0k| return; 1194| 2.66k| } 1195| 26.1M| default: { ------------------ | Branch (1195:5): [True: 26.1M, False: 1.33M] ------------------ 1196| 26.1M| suffixedexp(ls, v); 1197| 26.1M| return; 1198| 2.66k| } 1199| 27.4M| } 1200| 1.32M| luaX_next(ls); 1201| 1.32M|} lparser.c:init_exp: 152| 53.9M|static void init_exp (expdesc *e, expkind k, int i) { 153| 53.9M| e->f = e->t = NO_JUMP; ------------------ | | 20| 53.9M|#define NO_JUMP (-1) ------------------ 154| 53.9M| e->k = k; 155| 53.9M| e->u.info = i; 156| 53.9M|} lparser.c:codestring: 159| 26.4M|static void codestring (expdesc *e, TString *s) { 160| 26.4M| e->f = e->t = NO_JUMP; ------------------ | | 20| 26.4M|#define NO_JUMP (-1) ------------------ 161| 26.4M| e->k = VKSTR; 162| 26.4M| e->u.strval = s; 163| 26.4M|} lparser.c:constructor: 934| 4.80k|static void constructor (LexState *ls, expdesc *t) { 935| | /* constructor -> '{' [ field { sep field } [sep] ] '}' 936| | sep -> ',' | ';' */ 937| 4.80k| FuncState *fs = ls->fs; 938| 4.80k| int line = ls->linenumber; 939| 4.80k| int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0); ------------------ | | 48| 4.80k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 940| 4.80k| ConsControl cc; 941| 4.80k| luaK_code(fs, 0); /* space for extra arg. */ 942| 4.80k| cc.na = cc.nh = cc.tostore = 0; 943| 4.80k| cc.t = t; 944| 4.80k| init_exp(t, VNONRELOC, fs->freereg); /* table will be at stack top */ 945| 4.80k| luaK_reserveregs(fs, 1); 946| 4.80k| init_exp(&cc.v, VVOID, 0); /* no value (yet) */ 947| 4.80k| checknext(ls, '{'); 948| 1.56M| do { 949| 1.56M| lua_assert(cc.v.k == VVOID || cc.tostore > 0); ------------------ | | 109| 1.56M|#define lua_assert(c) assert(c) ------------------ 950| 1.56M| if (ls->t.token == '}') break; ------------------ | Branch (950:9): [True: 3.57k, False: 1.55M] ------------------ 951| 1.55M| closelistfield(fs, &cc); 952| 1.55M| field(ls, &cc); 953| 1.55M| } while (testnext(ls, ',') || testnext(ls, ';')); ------------------ | Branch (953:12): [True: 1.55M, False: 3.51k] | Branch (953:33): [True: 2.47k, False: 1.04k] ------------------ 954| 4.80k| check_match(ls, '}', '{', line); 955| 4.80k| lastlistfield(fs, &cc); 956| 4.80k| luaK_settablesize(fs, pc, t->u.info, cc.na, cc.nh); 957| 4.80k|} lparser.c:closelistfield: 877| 1.55M|static void closelistfield (FuncState *fs, ConsControl *cc) { 878| 1.55M| if (cc->v.k == VVOID) return; /* there is no list item */ ------------------ | Branch (878:7): [True: 1.23k, False: 1.55M] ------------------ 879| 1.55M| luaK_exp2nextreg(fs, &cc->v); 880| 1.55M| cc->v.k = VVOID; 881| 1.55M| if (cc->tostore == LFIELDS_PER_FLUSH) { ------------------ | | 403| 1.55M|#define LFIELDS_PER_FLUSH 50 ------------------ | Branch (881:7): [True: 31.1k, False: 1.52M] ------------------ 882| 31.1k| luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); /* flush */ 883| 31.1k| cc->na += cc->tostore; 884| 31.1k| cc->tostore = 0; /* no more items pending */ 885| 31.1k| } 886| 1.55M|} lparser.c:field: 912| 1.55M|static void field (LexState *ls, ConsControl *cc) { 913| | /* field -> listfield | recfield */ 914| 1.55M| switch(ls->t.token) { 915| 1.54M| case TK_NAME: { /* may be 'listfield' or 'recfield' */ ------------------ | Branch (915:5): [True: 1.54M, False: 9.06k] ------------------ 916| 1.54M| if (luaX_lookahead(ls) != '=') /* expression? */ ------------------ | Branch (916:11): [True: 1.54M, False: 10] ------------------ 917| 1.54M| listfield(ls, cc); 918| 10| else 919| 10| recfield(ls, cc); 920| 1.54M| break; 921| 0| } 922| 1| case '[': { ------------------ | Branch (922:5): [True: 1, False: 1.55M] ------------------ 923| 1| recfield(ls, cc); 924| 1| break; 925| 0| } 926| 9.06k| default: { ------------------ | Branch (926:5): [True: 9.06k, False: 1.54M] ------------------ 927| 9.06k| listfield(ls, cc); 928| 9.06k| break; 929| 0| } 930| 1.55M| } 931| 1.55M|} lparser.c:listfield: 905| 1.55M|static void listfield (LexState *ls, ConsControl *cc) { 906| | /* listfield -> exp */ 907| 1.55M| expr(ls, &cc->v); 908| 1.55M| cc->tostore++; 909| 1.55M|} lparser.c:recfield: 856| 11|static void recfield (LexState *ls, ConsControl *cc) { 857| | /* recfield -> (NAME | '['exp']') = exp */ 858| 11| FuncState *fs = ls->fs; 859| 11| int reg = ls->fs->freereg; 860| 11| expdesc tab, key, val; 861| 11| if (ls->t.token == TK_NAME) { ------------------ | Branch (861:7): [True: 10, False: 1] ------------------ 862| 10| checklimit(fs, cc->nh, MAX_INT, "items in a constructor"); ------------------ | | 56| 10|#define MAX_INT INT_MAX /* maximum value of an int */ ------------------ 863| 10| codename(ls, &key); 864| 10| } 865| 1| else /* ls->t.token == '[' */ 866| 1| yindex(ls, &key); 867| 11| cc->nh++; 868| 11| checknext(ls, '='); 869| 11| tab = *cc->t; 870| 11| luaK_indexed(fs, &tab, &key); 871| 11| expr(ls, &val); 872| 11| luaK_storevar(fs, &tab, &val); 873| 11| fs->freereg = reg; /* free registers */ 874| 11|} lparser.c:codename: 166| 14.0k|static void codename (LexState *ls, expdesc *e) { 167| 14.0k| codestring(e, str_checkname(ls)); 168| 14.0k|} lparser.c:yindex: 831| 34.5k|static void yindex (LexState *ls, expdesc *v) { 832| | /* index -> '[' expr ']' */ 833| 34.5k| luaX_next(ls); /* skip the '[' */ 834| 34.5k| expr(ls, v); 835| 34.5k| luaK_exp2val(ls->fs, v); 836| 34.5k| checknext(ls, ']'); 837| 34.5k|} lparser.c:lastlistfield: 889| 4.61k|static void lastlistfield (FuncState *fs, ConsControl *cc) { 890| 4.61k| if (cc->tostore == 0) return; ------------------ | Branch (890:7): [True: 3.57k, False: 1.03k] ------------------ 891| 1.03k| if (hasmultret(cc->v.k)) { ------------------ | | 38| 1.03k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 0, False: 1.03k] | | | Branch (38:41): [True: 408, False: 625] | | ------------------ ------------------ 892| 408| luaK_setmultret(fs, &cc->v); ------------------ | | 58| 408|#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) | | ------------------ | | | | 35| 408|#define LUA_MULTRET (-1) | | ------------------ ------------------ 893| 408| luaK_setlist(fs, cc->t->u.info, cc->na, LUA_MULTRET); ------------------ | | 35| 408|#define LUA_MULTRET (-1) ------------------ 894| 408| cc->na--; /* do not count last expression (unknown number of elements) */ 895| 408| } 896| 625| else { 897| 625| if (cc->v.k != VVOID) ------------------ | Branch (897:9): [True: 625, False: 0] ------------------ 898| 625| luaK_exp2nextreg(fs, &cc->v); 899| 625| luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); 900| 625| } 901| 1.03k| cc->na += cc->tostore; 902| 1.03k|} lparser.c:body: 999| 21.1k|static void body (LexState *ls, expdesc *e, int ismethod, int line) { 1000| | /* body -> '(' parlist ')' block END */ 1001| 21.1k| FuncState new_fs; 1002| 21.1k| BlockCnt bl; 1003| 21.1k| new_fs.f = addprototype(ls); 1004| 21.1k| new_fs.f->linedefined = line; 1005| 21.1k| open_func(ls, &new_fs, &bl); 1006| 21.1k| checknext(ls, '('); 1007| 21.1k| if (ismethod) { ------------------ | Branch (1007:7): [True: 18, False: 21.1k] ------------------ 1008| 18| new_localvarliteral(ls, "self"); /* create 'self' parameter */ ------------------ | | 217| 18| new_localvar(ls, \ | | 218| 18| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1009| 18| adjustlocalvars(ls, 1); 1010| 18| } 1011| 21.1k| parlist(ls); 1012| 21.1k| checknext(ls, ')'); 1013| 21.1k| statlist(ls); 1014| 21.1k| new_fs.f->lastlinedefined = ls->linenumber; 1015| 21.1k| check_match(ls, TK_END, TK_FUNCTION, line); 1016| 21.1k| codeclosure(ls, e); 1017| 21.1k| close_func(ls); 1018| 21.1k|} lparser.c:addprototype: 707| 21.1k|static Proto *addprototype (LexState *ls) { 708| 21.1k| Proto *clp; 709| 21.1k| lua_State *L = ls->L; 710| 21.1k| FuncState *fs = ls->fs; 711| 21.1k| Proto *f = fs->f; /* prototype of current function */ 712| 21.1k| if (fs->np >= f->sizep) { ------------------ | Branch (712:7): [True: 2.86k, False: 18.3k] ------------------ 713| 2.86k| int oldsize = f->sizep; 714| 2.86k| luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions"); ------------------ | | 69| 2.86k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 139| 5.72k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 70| 2.86k| luaM_limitN(limit,t),e))) ------------------ 715| 39.4k| while (oldsize < f->sizep) ------------------ | Branch (715:12): [True: 36.5k, False: 2.86k] ------------------ 716| 36.5k| f->p[oldsize++] = NULL; 717| 2.86k| } 718| 21.1k| f->p[fs->np++] = clp = luaF_newproto(L); 719| 21.1k| luaC_objbarrier(L, f, clp); ------------------ | | 222| 21.1k|#define luaC_objbarrier(L,p,o) ( \ | | 223| 21.1k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 91| 21.1k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 70| 21.1k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 65| 42.3k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 4.43k, False: 16.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 90| 4.43k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 4.43k|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 4.43k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 224| 21.1k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 4.43k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 4.43k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 4.43k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 4.43k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 4.43k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 4.43k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 141| 16.7k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 16.7k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 720| 0| return clp; 721| 21.1k|} lparser.c:new_localvar: 212| 17.6k|static int new_localvar (LexState *ls, TString *name) { 213| 17.6k| return new_localvarkind(ls, name, VDKREG); ------------------ | | 90| 17.6k|#define VDKREG 0 /* regular */ ------------------ 214| 17.6k|} lparser.c:new_localvarkind: 193| 31.8k|static int new_localvarkind (LexState *ls, TString *name, int kind) { 194| 31.8k| lua_State *L = ls->L; 195| 31.8k| FuncState *fs = ls->fs; 196| 31.8k| Dyndata *dyd = ls->dyd; 197| 31.8k| Vardesc *var; 198| 31.8k| checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal, 199| 31.8k| MAXVARS, "local variables"); ------------------ | | 35| 31.8k|#define MAXVARS 200 ------------------ 200| 31.8k| luaM_growvector(L, dyd->actvar.arr, dyd->actvar.n + 1, ------------------ | | 69| 31.8k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 139| 63.6k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 70| 31.8k| luaM_limitN(limit,t),e))) ------------------ 201| 31.8k| dyd->actvar.size, Vardesc, USHRT_MAX, "local variables"); 202| 31.8k| var = &dyd->actvar.arr[dyd->actvar.n++]; 203| 31.8k| var->vd.kind = kind; /* default */ 204| 31.8k| var->vd.name = name; 205| 31.8k| return dyd->actvar.n - 1 - fs->firstlocal; 206| 31.8k|} lparser.c:adjustlocalvars: 319| 32.8k|static void adjustlocalvars (LexState *ls, int nvars) { 320| 32.8k| FuncState *fs = ls->fs; 321| 32.8k| int reglevel = luaY_nvarstack(fs); 322| 32.8k| int i; 323| 63.5k| for (i = 0; i < nvars; i++) { ------------------ | Branch (323:15): [True: 30.7k, False: 32.8k] ------------------ 324| 30.7k| int vidx = fs->nactvar++; 325| 30.7k| Vardesc *var = getlocalvardesc(fs, vidx); 326| 30.7k| var->vd.ridx = reglevel++; 327| 30.7k| var->vd.pidx = registerlocalvar(ls, fs, var->vd.name); 328| 30.7k| } 329| 32.8k|} lparser.c:registerlocalvar: 175| 30.7k|static int registerlocalvar (LexState *ls, FuncState *fs, TString *varname) { 176| 30.7k| Proto *f = fs->f; 177| 30.7k| int oldsize = f->sizelocvars; 178| 30.7k| luaM_growvector(ls->L, f->locvars, fs->ndebugvars, f->sizelocvars, ------------------ | | 69| 30.7k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 139| 61.4k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 70| 30.7k| luaM_limitN(limit,t),e))) ------------------ 179| 30.7k| LocVar, SHRT_MAX, "local variables"); 180| 78.3k| while (oldsize < f->sizelocvars) ------------------ | Branch (180:10): [True: 47.6k, False: 30.7k] ------------------ 181| 47.6k| f->locvars[oldsize++].varname = NULL; 182| 30.7k| f->locvars[fs->ndebugvars].varname = varname; 183| 30.7k| f->locvars[fs->ndebugvars].startpc = fs->pc; 184| 30.7k| luaC_objbarrier(ls->L, f, varname); ------------------ | | 222| 30.7k|#define luaC_objbarrier(L,p,o) ( \ | | 223| 30.7k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 91| 30.7k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 70| 30.7k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 65| 61.4k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 30, False: 30.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 90| 30|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 30|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 6, False: 24] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 224| 30.7k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 6|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 6|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 6|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 6|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 6|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 6|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 141| 30.7k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 30.7k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 185| 0| return fs->ndebugvars++; 186| 30.7k|} lparser.c:parlist: 968| 21.1k|static void parlist (LexState *ls) { 969| | /* parlist -> [ {NAME ','} (NAME | '...') ] */ 970| 21.1k| FuncState *fs = ls->fs; 971| 21.1k| Proto *f = fs->f; 972| 21.1k| int nparams = 0; 973| 21.1k| int isvararg = 0; 974| 21.1k| if (ls->t.token != ')') { /* is 'parlist' not empty? */ ------------------ | Branch (974:7): [True: 3.04k, False: 18.1k] ------------------ 975| 11.5k| do { 976| 11.5k| switch (ls->t.token) { 977| 11.1k| case TK_NAME: { ------------------ | Branch (977:9): [True: 11.1k, False: 367] ------------------ 978| 11.1k| new_localvar(ls, str_checkname(ls)); 979| 11.1k| nparams++; 980| 11.1k| break; 981| 0| } 982| 365| case TK_DOTS: { ------------------ | Branch (982:9): [True: 365, False: 11.1k] ------------------ 983| 365| luaX_next(ls); 984| 365| isvararg = 1; 985| 365| break; 986| 0| } 987| 2| default: luaX_syntaxerror(ls, " or '...' expected"); ------------------ | Branch (987:9): [True: 2, False: 11.5k] ------------------ 988| 11.5k| } 989| 11.5k| } while (!isvararg && testnext(ls, ',')); ------------------ | Branch (989:14): [True: 11.1k, False: 365] | Branch (989:27): [True: 8.51k, False: 2.68k] ------------------ 990| 3.04k| } 991| 21.1k| adjustlocalvars(ls, nparams); 992| 21.1k| f->numparams = cast_byte(fs->nactvar); ------------------ | | 146| 21.1k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 139| 21.1k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 993| 21.1k| if (isvararg) ------------------ | Branch (993:7): [True: 365, False: 20.8k] ------------------ 994| 365| setvararg(fs, f->numparams); /* declared vararg */ 995| 21.1k| luaK_reserveregs(fs, fs->nactvar); /* reserve registers for parameters */ 996| 21.1k|} lparser.c:codeclosure: 731| 20.8k|static void codeclosure (LexState *ls, expdesc *v) { 732| 20.8k| FuncState *fs = ls->fs->prev; 733| 20.8k| init_exp(v, VRELOC, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1)); 734| 20.8k| luaK_exp2nextreg(fs, v); /* fix it at the last register */ 735| 20.8k|} lparser.c:suffixedexp: 1112| 26.2M|static void suffixedexp (LexState *ls, expdesc *v) { 1113| | /* suffixedexp -> 1114| | primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */ 1115| 26.2M| FuncState *fs = ls->fs; 1116| 26.2M| primaryexp(ls, v); 1117| 26.6M| for (;;) { 1118| 26.6M| switch (ls->t.token) { 1119| 13.6k| case '.': { /* fieldsel */ ------------------ | Branch (1119:7): [True: 13.6k, False: 26.6M] ------------------ 1120| 13.6k| fieldsel(ls, v); 1121| 13.6k| break; 1122| 0| } 1123| 34.5k| case '[': { /* '[' exp ']' */ ------------------ | Branch (1123:7): [True: 34.5k, False: 26.6M] ------------------ 1124| 34.5k| expdesc key; 1125| 34.5k| luaK_exp2anyregup(fs, v); 1126| 34.5k| yindex(ls, &key); 1127| 34.5k| luaK_indexed(fs, v, &key); 1128| 34.5k| break; 1129| 0| } 1130| 313| case ':': { /* ':' NAME funcargs */ ------------------ | Branch (1130:7): [True: 313, False: 26.6M] ------------------ 1131| 313| expdesc key; 1132| 313| luaX_next(ls); 1133| 313| codename(ls, &key); 1134| 313| luaK_self(fs, v, &key); 1135| 313| funcargs(ls, v); 1136| 313| break; 1137| 0| } 1138| 350k| case '(': case TK_STRING: case '{': { /* funcargs */ ------------------ | Branch (1138:7): [True: 39.6k, False: 26.6M] | Branch (1138:17): [True: 308k, False: 26.3M] | Branch (1138:33): [True: 2.56k, False: 26.6M] ------------------ 1139| 350k| luaK_exp2nextreg(fs, v); 1140| 350k| funcargs(ls, v); 1141| 350k| break; 1142| 347k| } 1143| 26.2M| default: return; ------------------ | Branch (1143:7): [True: 26.2M, False: 398k] ------------------ 1144| 26.6M| } 1145| 26.6M| } 1146| 26.2M|} lparser.c:primaryexp: 1090| 26.2M|static void primaryexp (LexState *ls, expdesc *v) { 1091| | /* primaryexp -> NAME | '(' expr ')' */ 1092| 26.2M| switch (ls->t.token) { 1093| 62.5k| case '(': { ------------------ | Branch (1093:5): [True: 62.5k, False: 26.2M] ------------------ 1094| 62.5k| int line = ls->linenumber; 1095| 62.5k| luaX_next(ls); 1096| 62.5k| expr(ls, v); 1097| 62.5k| check_match(ls, ')', '(', line); 1098| 62.5k| luaK_dischargevars(ls->fs, v); 1099| 62.5k| return; 1100| 0| } 1101| 26.2M| case TK_NAME: { ------------------ | Branch (1101:5): [True: 26.2M, False: 62.6k] ------------------ 1102| 26.2M| singlevar(ls, v); 1103| 26.2M| return; 1104| 0| } 1105| 123| default: { ------------------ | Branch (1105:5): [True: 123, False: 26.2M] ------------------ 1106| 123| luaX_syntaxerror(ls, "unexpected symbol"); 1107| 0| } 1108| 26.2M| } 1109| 26.2M|} lparser.c:singlevar: 471| 26.2M|static void singlevar (LexState *ls, expdesc *var) { 472| 26.2M| TString *varname = str_checkname(ls); 473| 26.2M| FuncState *fs = ls->fs; 474| 26.2M| singlevaraux(fs, varname, var, 1); 475| 26.2M| if (var->k == VVOID) { /* global name? */ ------------------ | Branch (475:7): [True: 26.0M, False: 163k] ------------------ 476| 26.0M| expdesc key; 477| 26.0M| singlevaraux(fs, ls->envn, var, 1); /* get environment variable */ 478| 26.0M| lua_assert(var->k != VVOID); /* this one must exist */ ------------------ | | 109| 26.0M|#define lua_assert(c) assert(c) ------------------ 479| 26.0M| luaK_exp2anyregup(fs, var); /* but could be a constant */ 480| 26.0M| codestring(&key, varname); /* key is variable name */ 481| 26.0M| luaK_indexed(fs, var, &key); /* env[varname] */ 482| 26.0M| } 483| 26.2M|} lparser.c:singlevaraux: 443| 79.2M|static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { 444| 79.2M| if (fs == NULL) /* no more levels? */ ------------------ | Branch (444:7): [True: 26.0M, False: 53.1M] ------------------ 445| 26.0M| init_exp(var, VVOID, 0); /* default is global */ 446| 53.1M| else { 447| 53.1M| int v = searchvar(fs, n, var); /* look up locals at current level */ 448| 53.1M| if (v >= 0) { /* found? */ ------------------ | Branch (448:9): [True: 1.25M, False: 51.8M] ------------------ 449| 1.25M| if (v == VLOCAL && !base) ------------------ | Branch (449:11): [True: 74.7k, False: 1.18M] | Branch (449:26): [True: 6.66k, False: 68.0k] ------------------ 450| 6.66k| markupval(fs, var->u.var.vidx); /* local will be used as an upval */ 451| 1.25M| } 452| 51.8M| else { /* not found as local at current level; try upvalues */ 453| 51.8M| int idx = searchupvalue(fs, n); /* try existing upvalues */ 454| 51.8M| if (idx < 0) { /* not found? */ ------------------ | Branch (454:11): [True: 26.9M, False: 24.9M] ------------------ 455| 26.9M| singlevaraux(fs->prev, n, var, 0); /* try upper levels */ 456| 26.9M| if (var->k == VLOCAL || var->k == VUPVAL) /* local or upvalue? */ ------------------ | Branch (456:13): [True: 6.66k, False: 26.9M] | Branch (456:33): [True: 22.3k, False: 26.9M] ------------------ 457| 29.0k| idx = newupvalue(fs, n, var); /* will be a new upvalue */ 458| 26.9M| else /* it is a global or a constant */ 459| 26.9M| return; /* don't need to do anything at this level */ 460| 26.9M| } 461| 24.9M| init_exp(var, VUPVAL, idx); /* new or old upvalue */ 462| 24.9M| } 463| 53.1M| } 464| 79.2M|} lparser.c:searchvar: 398| 53.1M|static int searchvar (FuncState *fs, TString *n, expdesc *var) { 399| 53.1M| int i; 400| 323M| for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) { ------------------ | | 144| 53.1M|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 53.1M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (400:39): [True: 271M, False: 51.8M] ------------------ 401| 271M| Vardesc *vd = getlocalvardesc(fs, i); 402| 271M| if (eqstr(n, vd->vd.name)) { /* found? */ ------------------ | | 43| 271M|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 1.25M, False: 270M] | | ------------------ ------------------ 403| 1.25M| if (vd->vd.kind == RDKCTC) /* compile-time constant? */ ------------------ | | 93| 1.25M|#define RDKCTC 3 /* compile-time constant */ ------------------ | Branch (403:11): [True: 1.18M, False: 74.7k] ------------------ 404| 1.18M| init_exp(var, VCONST, fs->firstlocal + i); 405| 74.7k| else /* real variable */ 406| 74.7k| init_var(fs, var, i); 407| 1.25M| return var->k; 408| 1.25M| } 409| 271M| } 410| 51.8M| return -1; /* not found */ 411| 53.1M|} lparser.c:init_var: 274| 74.7k|static void init_var (FuncState *fs, expdesc *e, int vidx) { 275| 74.7k| e->f = e->t = NO_JUMP; ------------------ | | 20| 74.7k|#define NO_JUMP (-1) ------------------ 276| 74.7k| e->k = VLOCAL; 277| 74.7k| e->u.var.vidx = vidx; 278| 74.7k| e->u.var.ridx = getlocalvardesc(fs, vidx)->vd.ridx; 279| 74.7k|} lparser.c:markupval: 418| 6.66k|static void markupval (FuncState *fs, int level) { 419| 6.66k| BlockCnt *bl = fs->bl; 420| 16.2k| while (bl->nactvar > level) ------------------ | Branch (420:10): [True: 9.62k, False: 6.66k] ------------------ 421| 9.62k| bl = bl->previous; 422| 6.66k| bl->upval = 1; 423| 6.66k| fs->needclose = 1; 424| 6.66k|} lparser.c:searchupvalue: 350| 51.8M|static int searchupvalue (FuncState *fs, TString *name) { 351| 51.8M| int i; 352| 51.8M| Upvaldesc *up = fs->f->upvalues; 353| 80.9M| for (i = 0; i < fs->nups; i++) { ------------------ | Branch (353:15): [True: 54.0M, False: 26.9M] ------------------ 354| 54.0M| if (eqstr(up[i].name, name)) return i; ------------------ | | 43| 54.0M|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 24.9M, False: 29.0M] | | ------------------ ------------------ 355| 54.0M| } 356| 26.9M| return -1; /* not found */ 357| 51.8M|} lparser.c:newupvalue: 372| 29.0k|static int newupvalue (FuncState *fs, TString *name, expdesc *v) { 373| 29.0k| Upvaldesc *up = allocupvalue(fs); 374| 29.0k| FuncState *prev = fs->prev; 375| 29.0k| if (v->k == VLOCAL) { ------------------ | Branch (375:7): [True: 6.66k, False: 22.3k] ------------------ 376| 6.66k| up->instack = 1; 377| 6.66k| up->idx = v->u.var.ridx; 378| 6.66k| up->kind = getlocalvardesc(prev, v->u.var.vidx)->vd.kind; 379| 6.66k| lua_assert(eqstr(name, getlocalvardesc(prev, v->u.var.vidx)->vd.name)); ------------------ | | 109| 6.66k|#define lua_assert(c) assert(c) ------------------ 380| 6.66k| } 381| 22.3k| else { 382| 22.3k| up->instack = 0; 383| 22.3k| up->idx = cast_byte(v->u.info); ------------------ | | 146| 22.3k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 139| 22.3k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 384| 22.3k| up->kind = prev->f->upvalues[v->u.info].kind; 385| 22.3k| lua_assert(eqstr(name, prev->f->upvalues[v->u.info].name)); ------------------ | | 109| 22.3k|#define lua_assert(c) assert(c) ------------------ 386| 22.3k| } 387| 29.0k| up->name = name; 388| 29.0k| luaC_objbarrier(fs->ls->L, fs->f, name); ------------------ | | 222| 29.0k|#define luaC_objbarrier(L,p,o) ( \ | | 223| 29.0k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 91| 29.0k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 70| 29.0k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 65| 58.1k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 3, False: 29.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 90| 3|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 3|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 0, False: 3] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 224| 29.0k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 141| 29.0k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 29.0k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 389| 0| return fs->nups - 1; 390| 29.0k|} lparser.c:fieldsel: 820| 13.7k|static void fieldsel (LexState *ls, expdesc *v) { 821| | /* fieldsel -> ['.' | ':'] NAME */ 822| 13.7k| FuncState *fs = ls->fs; 823| 13.7k| expdesc key; 824| 13.7k| luaK_exp2anyregup(fs, v); 825| 13.7k| luaX_next(ls); /* skip the dot or colon */ 826| 13.7k| codename(ls, &key); 827| 13.7k| luaK_indexed(fs, v, &key); 828| 13.7k|} lparser.c:funcargs: 1034| 350k|static void funcargs (LexState *ls, expdesc *f) { 1035| 350k| FuncState *fs = ls->fs; 1036| 350k| expdesc args; 1037| 350k| int base, nparams; 1038| 350k| int line = ls->linenumber; 1039| 350k| switch (ls->t.token) { 1040| 39.9k| case '(': { /* funcargs -> '(' [ explist ] ')' */ ------------------ | Branch (1040:5): [True: 39.9k, False: 310k] ------------------ 1041| 39.9k| luaX_next(ls); 1042| 39.9k| if (ls->t.token == ')') /* arg list is empty? */ ------------------ | Branch (1042:11): [True: 20.7k, False: 19.2k] ------------------ 1043| 20.7k| args.k = VVOID; 1044| 19.2k| else { 1045| 19.2k| explist(ls, &args); 1046| 19.2k| if (hasmultret(args.k)) ------------------ | | 38| 19.2k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 511, False: 18.7k] | | | Branch (38:41): [True: 14, False: 18.7k] | | ------------------ ------------------ 1047| 378| luaK_setmultret(fs, &args); ------------------ | | 58| 378|#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) | | ------------------ | | | | 35| 378|#define LUA_MULTRET (-1) | | ------------------ ------------------ 1048| 19.2k| } 1049| 39.9k| check_match(ls, ')', '(', line); 1050| 39.9k| break; 1051| 0| } 1052| 2.56k| case '{': { /* funcargs -> constructor */ ------------------ | Branch (1052:5): [True: 2.56k, False: 347k] ------------------ 1053| 2.56k| constructor(ls, &args); 1054| 2.56k| break; 1055| 0| } 1056| 308k| case TK_STRING: { /* funcargs -> STRING */ ------------------ | Branch (1056:5): [True: 308k, False: 42.5k] ------------------ 1057| 308k| codestring(&args, ls->t.seminfo.ts); 1058| 308k| luaX_next(ls); /* must use 'seminfo' before 'next' */ 1059| 308k| break; 1060| 0| } 1061| 2| default: { ------------------ | Branch (1061:5): [True: 2, False: 350k] ------------------ 1062| 2| luaX_syntaxerror(ls, "function arguments expected"); 1063| 0| } 1064| 350k| } 1065| 350k| lua_assert(f->k == VNONRELOC); ------------------ | | 109| 350k|#define lua_assert(c) assert(c) ------------------ 1066| 350k| base = f->u.info; /* base register for call */ 1067| 350k| if (hasmultret(args.k)) ------------------ | | 38| 350k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 364, False: 349k] | | | Branch (38:41): [True: 14, False: 349k] | | ------------------ ------------------ 1068| 378| nparams = LUA_MULTRET; /* open call */ ------------------ | | 35| 378|#define LUA_MULTRET (-1) ------------------ 1069| 349k| else { 1070| 349k| if (args.k != VVOID) ------------------ | Branch (1070:9): [True: 329k, False: 20.7k] ------------------ 1071| 329k| luaK_exp2nextreg(fs, &args); /* close last argument */ 1072| 349k| nparams = fs->freereg - (base+1); 1073| 349k| } 1074| 350k| init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2)); ------------------ | | 48| 350k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1075| 350k| luaK_fixline(fs, line); 1076| 350k| fs->freereg = base+1; /* call removes function and arguments and leaves 1077| | one result (unless changed later) */ 1078| 350k|} lparser.c:explist: 1021| 120k|static int explist (LexState *ls, expdesc *v) { 1022| | /* explist -> expr { ',' expr } */ 1023| 120k| int n = 1; /* at least one expression */ 1024| 120k| expr(ls, v); 1025| 176k| while (testnext(ls, ',')) { ------------------ | Branch (1025:10): [True: 56.7k, False: 120k] ------------------ 1026| 56.7k| luaK_exp2nextreg(ls->fs, v); 1027| 56.7k| expr(ls, v); 1028| 56.7k| n++; 1029| 56.7k| } 1030| 120k| return n; 1031| 120k|} lparser.c:getbinopr: 1215| 27.6M|static BinOpr getbinopr (int op) { 1216| 27.6M| switch (op) { 1217| 13.8k| case '+': return OPR_ADD; ------------------ | Branch (1217:5): [True: 13.8k, False: 27.6M] ------------------ 1218| 104k| case '-': return OPR_SUB; ------------------ | Branch (1218:5): [True: 104k, False: 27.5M] ------------------ 1219| 117k| case '*': return OPR_MUL; ------------------ | Branch (1219:5): [True: 117k, False: 27.5M] ------------------ 1220| 97.4k| case '%': return OPR_MOD; ------------------ | Branch (1220:5): [True: 97.4k, False: 27.6M] ------------------ 1221| 360k| case '^': return OPR_POW; ------------------ | Branch (1221:5): [True: 360k, False: 27.3M] ------------------ 1222| 7.02M| case '/': return OPR_DIV; ------------------ | Branch (1222:5): [True: 7.02M, False: 20.6M] ------------------ 1223| 47.8k| case TK_IDIV: return OPR_IDIV; ------------------ | Branch (1223:5): [True: 47.8k, False: 27.6M] ------------------ 1224| 19.2k| case '&': return OPR_BAND; ------------------ | Branch (1224:5): [True: 19.2k, False: 27.6M] ------------------ 1225| 13.6k| case '|': return OPR_BOR; ------------------ | Branch (1225:5): [True: 13.6k, False: 27.6M] ------------------ 1226| 150k| case '~': return OPR_BXOR; ------------------ | Branch (1226:5): [True: 150k, False: 27.5M] ------------------ 1227| 110k| case TK_SHL: return OPR_SHL; ------------------ | Branch (1227:5): [True: 110k, False: 27.5M] ------------------ 1228| 283k| case TK_SHR: return OPR_SHR; ------------------ | Branch (1228:5): [True: 283k, False: 27.4M] ------------------ 1229| 69.7k| case TK_CONCAT: return OPR_CONCAT; ------------------ | Branch (1229:5): [True: 69.7k, False: 27.6M] ------------------ 1230| 5.09k| case TK_NE: return OPR_NE; ------------------ | Branch (1230:5): [True: 5.09k, False: 27.6M] ------------------ 1231| 12.0k| case TK_EQ: return OPR_EQ; ------------------ | Branch (1231:5): [True: 12.0k, False: 27.6M] ------------------ 1232| 1.23M| case '<': return OPR_LT; ------------------ | Branch (1232:5): [True: 1.23M, False: 26.4M] ------------------ 1233| 9.45k| case TK_LE: return OPR_LE; ------------------ | Branch (1233:5): [True: 9.45k, False: 27.6M] ------------------ 1234| 16.0M| case '>': return OPR_GT; ------------------ | Branch (1234:5): [True: 16.0M, False: 11.6M] ------------------ 1235| 4.40k| case TK_GE: return OPR_GE; ------------------ | Branch (1235:5): [True: 4.40k, False: 27.6M] ------------------ 1236| 24.1k| case TK_AND: return OPR_AND; ------------------ | Branch (1236:5): [True: 24.1k, False: 27.6M] ------------------ 1237| 78.9k| case TK_OR: return OPR_OR; ------------------ | Branch (1237:5): [True: 78.9k, False: 27.6M] ------------------ 1238| 1.86M| default: return OPR_NOBINOPR; ------------------ | Branch (1238:5): [True: 1.86M, False: 25.8M] ------------------ 1239| 27.6M| } 1240| 27.6M|} lparser.c:checknext: 116| 186k|static void checknext (LexState *ls, int c) { 117| 186k| check(ls, c); 118| 186k| luaX_next(ls); 119| 186k|} lparser.c:newgotoentry: 584| 33.7k|static int newgotoentry (LexState *ls, TString *name, int line, int pc) { 585| 33.7k| return newlabelentry(ls, &ls->dyd->gt, name, line, pc); 586| 33.7k|} lparser.c:newlabelentry: 570| 37.7k| int line, int pc) { 571| 37.7k| int n = l->n; 572| 37.7k| luaM_growvector(ls->L, l->arr, n, l->size, ------------------ | | 69| 37.7k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 139| 75.4k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 70| 37.7k| luaM_limitN(limit,t),e))) ------------------ 573| 37.7k| Labeldesc, SHRT_MAX, "labels/gotos"); 574| 37.7k| l->arr[n].name = name; 575| 37.7k| l->arr[n].line = line; 576| 37.7k| l->arr[n].nactvar = ls->fs->nactvar; 577| 37.7k| l->arr[n].close = 0; 578| 37.7k| l->arr[n].pc = pc; 579| 37.7k| l->n = n + 1; 580| 37.7k| return n; 581| 37.7k|} lparser.c:leaveblock: 681| 40.2k|static void leaveblock (FuncState *fs) { 682| 40.2k| BlockCnt *bl = fs->bl; 683| 40.2k| LexState *ls = fs->ls; 684| 40.2k| int hasclose = 0; 685| 40.2k| int stklevel = reglevel(fs, bl->nactvar); /* level outside the block */ 686| 40.2k| removevars(fs, bl->nactvar); /* remove block locals */ 687| 40.2k| lua_assert(bl->nactvar == fs->nactvar); /* back to level on entry */ ------------------ | | 109| 40.2k|#define lua_assert(c) assert(c) ------------------ 688| 40.2k| if (bl->isloop) /* has to fix pending breaks? */ ------------------ | Branch (688:7): [True: 3.97k, False: 36.3k] ------------------ 689| 3.97k| hasclose = createlabel(ls, luaS_newliteral(ls->L, "break"), 0, 0); ------------------ | | 30| 3.97k|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 31| 3.97k| (sizeof(s)/sizeof(char))-1)) ------------------ 690| 40.2k| if (!hasclose && bl->previous && bl->upval) /* still need a 'close'? */ ------------------ | Branch (690:7): [True: 40.1k, False: 108] | Branch (690:20): [True: 19.2k, False: 20.9k] | Branch (690:36): [True: 880, False: 18.3k] ------------------ 691| 880| luaK_codeABC(fs, OP_CLOSE, stklevel, 0, 0); ------------------ | | 48| 880|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 692| 40.2k| fs->freereg = stklevel; /* free registers */ 693| 40.2k| ls->dyd->label.n = bl->firstlabel; /* remove local labels */ 694| 40.2k| fs->bl = bl->previous; /* current block now is previous one */ 695| 40.2k| if (bl->previous) /* was it a nested block? */ ------------------ | Branch (695:7): [True: 19.3k, False: 20.9k] ------------------ 696| 19.3k| movegotosout(fs, bl); /* update pending gotos to enclosing block */ 697| 20.9k| else { 698| 20.9k| if (bl->firstgoto < ls->dyd->gt.n) /* still pending gotos? */ ------------------ | Branch (698:9): [True: 1, False: 20.9k] ------------------ 699| 1| undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */ 700| 20.9k| } 701| 40.2k|} lparser.c:removevars: 336| 40.2k|static void removevars (FuncState *fs, int tolevel) { 337| 40.2k| fs->ls->dyd->actvar.n -= (fs->nactvar - tolevel); 338| 58.7k| while (fs->nactvar > tolevel) { ------------------ | Branch (338:10): [True: 18.4k, False: 40.2k] ------------------ 339| 18.4k| LocVar *var = localdebuginfo(fs, --fs->nactvar); 340| 18.4k| if (var) /* does it have debug information? */ ------------------ | Branch (340:9): [True: 18.0k, False: 431] ------------------ 341| 18.0k| var->endpc = fs->pc; 342| 18.4k| } 343| 40.2k|} lparser.c:localdebuginfo: 259| 20.4k|static LocVar *localdebuginfo (FuncState *fs, int vidx) { 260| 20.4k| Vardesc *vd = getlocalvardesc(fs, vidx); 261| 20.4k| if (vd->vd.kind == RDKCTC) ------------------ | | 93| 20.4k|#define RDKCTC 3 /* compile-time constant */ ------------------ | Branch (261:7): [True: 431, False: 20.0k] ------------------ 262| 431| return NULL; /* no debug info. for constants */ 263| 20.0k| else { 264| 20.0k| int idx = vd->vd.pidx; 265| 20.0k| lua_assert(idx < fs->ndebugvars); ------------------ | | 109| 20.0k|#define lua_assert(c) assert(c) ------------------ 266| 20.0k| return &fs->f->locvars[idx]; 267| 20.0k| } 268| 20.4k|} lparser.c:createlabel: 618| 4.01k| int last) { 619| 4.01k| FuncState *fs = ls->fs; 620| 4.01k| Labellist *ll = &ls->dyd->label; 621| 4.01k| int l = newlabelentry(ls, ll, name, line, luaK_getlabel(fs)); 622| 4.01k| if (last) { /* label is last no-op statement in the block? */ ------------------ | Branch (622:7): [True: 2, False: 4.00k] ------------------ 623| | /* assume that locals are already out of scope */ 624| 2| ll->arr[l].nactvar = fs->bl->nactvar; 625| 2| } 626| 4.01k| if (solvegotos(ls, &ll->arr[l])) { /* need close? */ ------------------ | Branch (626:7): [True: 108, False: 3.90k] ------------------ 627| 108| luaK_codeABC(fs, OP_CLOSE, luaY_nvarstack(fs), 0, 0); ------------------ | | 48| 108|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 628| 108| return 1; 629| 108| } 630| 3.90k| return 0; 631| 4.01k|} lparser.c:solvegotos: 594| 4.01k|static int solvegotos (LexState *ls, Labeldesc *lb) { 595| 4.01k| Labellist *gl = &ls->dyd->gt; 596| 4.01k| int i = ls->fs->bl->firstgoto; 597| 4.01k| int needsclose = 0; 598| 28.7k| while (i < gl->n) { ------------------ | Branch (598:10): [True: 24.7k, False: 4.01k] ------------------ 599| 24.7k| if (eqstr(gl->arr[i].name, lb->name)) { ------------------ | | 43| 24.7k|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 23.4k, False: 1.29k] | | ------------------ ------------------ 600| 23.4k| needsclose |= gl->arr[i].close; 601| 23.4k| solvegoto(ls, i, lb); /* will remove 'i' from the list */ 602| 23.4k| } 603| 1.29k| else 604| 1.29k| i++; 605| 24.7k| } 606| 4.01k| return needsclose; 607| 4.01k|} lparser.c:solvegoto: 536| 23.4k|static void solvegoto (LexState *ls, int g, Labeldesc *label) { 537| 23.4k| int i; 538| 23.4k| Labellist *gl = &ls->dyd->gt; /* list of gotos */ 539| 23.4k| Labeldesc *gt = &gl->arr[g]; /* goto to be resolved */ 540| 23.4k| lua_assert(eqstr(gt->name, label->name)); ------------------ | | 109| 23.4k|#define lua_assert(c) assert(c) ------------------ 541| 23.4k| if (l_unlikely(gt->nactvar < label->nactvar)) /* enter some scope? */ ------------------ | | 697| 23.4k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 23.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 23.4k] | | | | ------------------ | | ------------------ ------------------ 542| 0| jumpscopeerror(ls, gt); 543| 23.4k| luaK_patchlist(ls->fs, gt->pc, label->pc); 544| 141M| for (i = g; i < gl->n - 1; i++) /* remove goto from pending list */ ------------------ | Branch (544:15): [True: 141M, False: 23.4k] ------------------ 545| 141M| gl->arr[i] = gl->arr[i + 1]; 546| 23.4k| gl->n--; 547| 23.4k|} lparser.c:movegotosout: 637| 19.3k|static void movegotosout (FuncState *fs, BlockCnt *bl) { 638| 19.3k| int i; 639| 19.3k| Labellist *gl = &fs->ls->dyd->gt; 640| | /* correct pending gotos to current block */ 641| 51.3k| for (i = bl->firstgoto; i < gl->n; i++) { /* for each pending goto */ ------------------ | Branch (641:27): [True: 32.0k, False: 19.3k] ------------------ 642| 32.0k| Labeldesc *gt = &gl->arr[i]; 643| | /* leaving a variable scope? */ 644| 32.0k| if (reglevel(fs, gt->nactvar) > reglevel(fs, bl->nactvar)) ------------------ | Branch (644:9): [True: 12.2k, False: 19.7k] ------------------ 645| 12.2k| gt->close |= bl->upval; /* jump may need a close */ 646| 32.0k| gt->nactvar = bl->nactvar; /* update goto level */ 647| 32.0k| } 648| 19.3k|} lparser.c:undefgoto: 667| 1|static l_noret undefgoto (LexState *ls, Labeldesc *gt) { 668| 1| const char *msg; 669| 1| if (eqstr(gt->name, luaS_newliteral(ls->L, "break"))) { ------------------ | | 43| 1|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 0, False: 1] | | ------------------ ------------------ 670| 0| msg = "break outside loop at line %d"; 671| 0| msg = luaO_pushfstring(ls->L, msg, gt->line); 672| 0| } 673| 1| else { 674| 1| msg = "no visible label '%s' for at line %d"; 675| 1| msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line); ------------------ | | 430| 1|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 1|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 1|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 1|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 1|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 676| 1| } 677| 1| luaK_semerror(ls, msg); 678| 1|} lparser.c:whilestat: 1477| 2.96k|static void whilestat (LexState *ls, int line) { 1478| | /* whilestat -> WHILE cond DO block END */ 1479| 2.96k| FuncState *fs = ls->fs; 1480| 2.96k| int whileinit; 1481| 2.96k| int condexit; 1482| 2.96k| BlockCnt bl; 1483| 2.96k| luaX_next(ls); /* skip WHILE */ 1484| 2.96k| whileinit = luaK_getlabel(fs); 1485| 2.96k| condexit = cond(ls); 1486| 2.96k| enterblock(fs, &bl, 1); 1487| 2.96k| checknext(ls, TK_DO); 1488| 2.96k| block(ls); 1489| 2.96k| luaK_jumpto(fs, whileinit); ------------------ | | 60| 2.96k|#define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t) ------------------ 1490| 2.96k| check_match(ls, TK_END, TK_WHILE, line); 1491| 2.96k| leaveblock(fs); 1492| 2.96k| luaK_patchtohere(fs, condexit); /* false conditions finish the loop */ 1493| 2.96k|} lparser.c:cond: 1415| 3.12k|static int cond (LexState *ls) { 1416| | /* cond -> exp */ 1417| 3.12k| expdesc v; 1418| 3.12k| expr(ls, &v); /* read condition */ 1419| 3.12k| if (v.k == VNIL) v.k = VFALSE; /* 'falses' are all equal here */ ------------------ | Branch (1419:7): [True: 246, False: 2.87k] ------------------ 1420| 3.12k| luaK_goiftrue(ls->fs, &v); 1421| 3.12k| return v.f; 1422| 3.12k|} lparser.c:block: 1314| 7.36k|static void block (LexState *ls) { 1315| | /* block -> statlist */ 1316| 7.36k| FuncState *fs = ls->fs; 1317| 7.36k| BlockCnt bl; 1318| 7.36k| enterblock(fs, &bl, 0); 1319| 7.36k| statlist(ls); 1320| 7.36k| leaveblock(fs); 1321| 7.36k|} lparser.c:check_match: 130| 134k|static void check_match (LexState *ls, int what, int who, int where) { 131| 134k| if (l_unlikely(!testnext(ls, what))) { ------------------ | | 697| 134k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 134k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 62, False: 134k] | | | | ------------------ | | ------------------ ------------------ 132| 62| if (where == ls->linenumber) /* all in the same line? */ ------------------ | Branch (132:9): [True: 19, False: 43] ------------------ 133| 19| error_expected(ls, what); /* do not need a complex message */ 134| 43| else { 135| 43| luaX_syntaxerror(ls, luaO_pushfstring(ls->L, 136| 43| "%s expected (to close %s at line %d)", 137| 43| luaX_token2str(ls, what), luaX_token2str(ls, who), where)); 138| 43| } 139| 62| } 140| 134k|} lparser.c:error_expected: 68| 33|static l_noret error_expected (LexState *ls, int token) { 69| 33| luaX_syntaxerror(ls, 70| 33| luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token))); 71| 33|} lparser.c:forstat: 1628| 1.53k|static void forstat (LexState *ls, int line) { 1629| | /* forstat -> FOR (fornum | forlist) END */ 1630| 1.53k| FuncState *fs = ls->fs; 1631| 1.53k| TString *varname; 1632| 1.53k| BlockCnt bl; 1633| 1.53k| enterblock(fs, &bl, 1); /* scope for loop and control variables */ 1634| 1.53k| luaX_next(ls); /* skip 'for' */ 1635| 1.53k| varname = str_checkname(ls); /* first variable name */ 1636| 1.53k| switch (ls->t.token) { 1637| 594| case '=': fornum(ls, varname, line); break; ------------------ | Branch (1637:5): [True: 594, False: 939] ------------------ 1638| 937| case ',': case TK_IN: forlist(ls, varname); break; ------------------ | Branch (1638:5): [True: 345, False: 1.18k] | Branch (1638:15): [True: 592, False: 941] ------------------ 1639| 0| default: luaX_syntaxerror(ls, "'=' or 'in' expected"); ------------------ | Branch (1639:5): [True: 0, False: 1.53k] ------------------ 1640| 1.53k| } 1641| 966| check_match(ls, TK_END, TK_FOR, line); 1642| 966| leaveblock(fs); /* loop scope ('break' jumps to this point) */ 1643| 966|} lparser.c:fornum: 1579| 594|static void fornum (LexState *ls, TString *varname, int line) { 1580| | /* fornum -> NAME = exp,exp[,exp] forbody */ 1581| 594| FuncState *fs = ls->fs; 1582| 594| int base = fs->freereg; 1583| 594| new_localvarliteral(ls, "(for state)"); ------------------ | | 217| 594| new_localvar(ls, \ | | 218| 594| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1584| 594| new_localvarliteral(ls, "(for state)"); ------------------ | | 217| 594| new_localvar(ls, \ | | 218| 594| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1585| 594| new_localvarkind(ls, varname, RDKCONST); /* control variable */ ------------------ | | 91| 594|#define RDKCONST 1 /* constant */ ------------------ 1586| 594| checknext(ls, '='); 1587| 594| exp1(ls); /* initial value */ 1588| 594| checknext(ls, ','); 1589| 594| exp1(ls); /* limit */ 1590| 594| if (testnext(ls, ',')) ------------------ | Branch (1590:7): [True: 210, False: 384] ------------------ 1591| 210| exp1(ls); /* optional step */ 1592| 384| else { /* default step = 1 */ 1593| 384| luaK_int(fs, fs->freereg, 1); 1594| 384| luaK_reserveregs(fs, 1); 1595| 384| } 1596| 594| adjustlocalvars(ls, 2); /* start scope for internal variables */ 1597| 594| forbody(ls, base, line, 1, 0); 1598| 594|} lparser.c:exp1: 1526| 1.39k|static void exp1 (LexState *ls) { 1527| 1.39k| expdesc e; 1528| 1.39k| expr(ls, &e); 1529| 1.39k| luaK_exp2nextreg(ls->fs, &e); 1530| 1.39k| lua_assert(e.k == VNONRELOC); ------------------ | | 109| 1.39k|#define lua_assert(c) assert(c) ------------------ 1531| 1.39k|} lparser.c:forbody: 1553| 1.52k|static void forbody (LexState *ls, int base, int line, int nvars, int isgen) { 1554| | /* forbody -> DO block */ 1555| 1.52k| static const OpCode forprep[2] = {OP_FORPREP, OP_TFORPREP}; 1556| 1.52k| static const OpCode forloop[2] = {OP_FORLOOP, OP_TFORLOOP}; 1557| 1.52k| BlockCnt bl; 1558| 1.52k| FuncState *fs = ls->fs; 1559| 1.52k| int prep, endfor; 1560| 1.52k| checknext(ls, TK_DO); 1561| 1.52k| prep = luaK_codeABx(fs, forprep[isgen], base, 0); 1562| 1.52k| fs->freereg--; /* both 'forprep' remove one register from the stack */ 1563| 1.52k| enterblock(fs, &bl, 0); /* scope for declared variables */ 1564| 1.52k| adjustlocalvars(ls, nvars); 1565| 1.52k| luaK_reserveregs(fs, nvars); 1566| 1.52k| block(ls); 1567| 1.52k| leaveblock(fs); /* end of scope for declared variables */ 1568| 1.52k| fixforjump(fs, prep, luaK_getlabel(fs), 0); 1569| 1.52k| if (isgen) { /* generic for? */ ------------------ | Branch (1569:7): [True: 741, False: 787] ------------------ 1570| 741| luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars); ------------------ | | 48| 741|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1571| 741| luaK_fixline(fs, line); 1572| 741| } 1573| 1.52k| endfor = luaK_codeABx(fs, forloop[isgen], base, 0); 1574| 1.52k| fixforjump(fs, endfor, prep + 1, 1); 1575| 1.52k| luaK_fixline(fs, line); 1576| 1.52k|} lparser.c:fixforjump: 1539| 1.93k|static void fixforjump (FuncState *fs, int pc, int dest, int back) { 1540| 1.93k| Instruction *jmp = &fs->f->code[pc]; 1541| 1.93k| int offset = dest - (pc + 1); 1542| 1.93k| if (back) ------------------ | Branch (1542:7): [True: 966, False: 968] ------------------ 1543| 966| offset = -offset; 1544| 1.93k| if (l_unlikely(offset > MAXARG_Bx)) ------------------ | | 697| 1.93k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 1.93k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 2, False: 1.93k] | | | | ------------------ | | ------------------ ------------------ 1545| 2| luaX_syntaxerror(fs->ls, "control structure too long"); 1546| 1.93k| SETARG_Bx(*jmp, offset); ------------------ | | 141| 1.93k|#define SETARG_Bx(i,v) setarg(i, v, POS_Bx, SIZE_Bx) | | ------------------ | | | | 122| 1.93k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 1.93k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 1.93k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 1.93k| ((cast(Instruction, v)< NAME {,NAME} IN explist forbody */ 1603| 937| FuncState *fs = ls->fs; 1604| 937| expdesc e; 1605| 937| int nvars = 4; /* function, state, closing, control */ 1606| 937| int line; 1607| 937| int base = fs->freereg; 1608| | /* create internal variables */ 1609| 937| new_localvarliteral(ls, "(for state)"); /* iterator function */ ------------------ | | 217| 937| new_localvar(ls, \ | | 218| 937| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1610| 937| new_localvarliteral(ls, "(for state)"); /* state */ ------------------ | | 217| 937| new_localvar(ls, \ | | 218| 937| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1611| 937| new_localvarliteral(ls, "(for state)"); /* closing var. (after swap) */ ------------------ | | 217| 937| new_localvar(ls, \ | | 218| 937| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1612| 937| new_localvarkind(ls, indexname, RDKCONST); /* control variable */ ------------------ | | 91| 937|#define RDKCONST 1 /* constant */ ------------------ 1613| | /* other declared variables */ 1614| 1.44k| while (testnext(ls, ',')) { ------------------ | Branch (1614:10): [True: 506, False: 937] ------------------ 1615| 506| new_localvar(ls, str_checkname(ls)); 1616| 506| nvars++; 1617| 506| } 1618| 937| checknext(ls, TK_IN); 1619| 937| line = ls->linenumber; 1620| 937| adjust_assign(ls, 4, explist(ls, &e), &e); 1621| 937| adjustlocalvars(ls, 3); /* start scope for internal variables */ 1622| 937| marktobeclosed(fs); /* last internal var. must be closed */ 1623| 937| luaK_checkstack(fs, 2); /* extra space to call iterator */ 1624| 937| forbody(ls, base, line, nvars - 3, 1); 1625| 937|} lparser.c:adjust_assign: 490| 21.9k|static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) { 491| 21.9k| FuncState *fs = ls->fs; 492| 21.9k| int needed = nvars - nexps; /* extra values needed */ 493| 21.9k| if (hasmultret(e->k)) { /* last expression has multiple returns? */ ------------------ | | 38| 21.9k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 110, False: 21.8k] | | | Branch (38:41): [True: 488, False: 21.3k] | | ------------------ ------------------ 494| 598| int extra = needed + 1; /* discount last expression itself */ 495| 598| if (extra < 0) ------------------ | Branch (495:9): [True: 117, False: 481] ------------------ 496| 117| extra = 0; 497| 598| luaK_setreturns(fs, e, extra); /* last exp. provides the difference */ 498| 598| } 499| 21.3k| else { 500| 21.3k| if (e->k != VVOID) /* at least one expression? */ ------------------ | Branch (500:9): [True: 20.1k, False: 1.18k] ------------------ 501| 20.1k| luaK_exp2nextreg(fs, e); /* close last expression */ 502| 21.3k| if (needed > 0) /* missing values? */ ------------------ | Branch (502:9): [True: 5.94k, False: 15.4k] ------------------ 503| 5.94k| luaK_nil(fs, fs->freereg, needed); /* complete with nils */ 504| 21.3k| } 505| 21.9k| if (needed > 0) ------------------ | Branch (505:7): [True: 6.02k, False: 15.9k] ------------------ 506| 6.02k| luaK_reserveregs(fs, needed); /* registers for extra values */ 507| 15.9k| else /* adding 'needed' is actually a subtraction */ 508| 15.9k| fs->freereg += needed; /* remove extra values */ 509| 21.9k|} lparser.c:marktobeclosed: 430| 1.15k|static void marktobeclosed (FuncState *fs) { 431| 1.15k| BlockCnt *bl = fs->bl; 432| 1.15k| bl->upval = 1; 433| 1.15k| bl->insidetbc = 1; 434| 1.15k| fs->needclose = 1; 435| 1.15k|} lparser.c:repeatstat: 1496| 166|static void repeatstat (LexState *ls, int line) { 1497| | /* repeatstat -> REPEAT block UNTIL cond */ 1498| 166| int condexit; 1499| 166| FuncState *fs = ls->fs; 1500| 166| int repeat_init = luaK_getlabel(fs); 1501| 166| BlockCnt bl1, bl2; 1502| 166| enterblock(fs, &bl1, 1); /* loop block */ 1503| 166| enterblock(fs, &bl2, 0); /* scope block */ 1504| 166| luaX_next(ls); /* skip REPEAT */ 1505| 166| statlist(ls); 1506| 166| check_match(ls, TK_UNTIL, TK_REPEAT, line); 1507| 166| condexit = cond(ls); /* read condition (inside scope block) */ 1508| 166| leaveblock(fs); /* finish scope */ 1509| 166| if (bl2.upval) { /* upvalues? */ ------------------ | Branch (1509:7): [True: 108, False: 58] ------------------ 1510| 108| int exit = luaK_jump(fs); /* normal exit must jump over fix */ 1511| 108| luaK_patchtohere(fs, condexit); /* repetition must close upvalues */ 1512| 108| luaK_codeABC(fs, OP_CLOSE, reglevel(fs, bl2.nactvar), 0, 0); ------------------ | | 48| 108|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1513| 108| condexit = luaK_jump(fs); /* repeat after closing upvalues */ 1514| 108| luaK_patchtohere(fs, exit); /* normal exit comes to here */ 1515| 108| } 1516| 166| luaK_patchlist(fs, condexit, repeat_init); /* close the loop */ 1517| 166| leaveblock(fs); /* finish loop */ 1518| 166|} lparser.c:funcstat: 1791| 3.16k|static void funcstat (LexState *ls, int line) { 1792| | /* funcstat -> FUNCTION funcname body */ 1793| 3.16k| int ismethod; 1794| 3.16k| expdesc v, b; 1795| 3.16k| luaX_next(ls); /* skip FUNCTION */ 1796| 3.16k| ismethod = funcname(ls, &v); 1797| 3.16k| body(ls, &b, ismethod, line); 1798| 3.16k| check_readonly(ls, &v); 1799| 3.16k| luaK_storevar(ls->fs, &v, &b); 1800| 3.16k| luaK_fixline(ls->fs, line); /* definition "happens" in the first line */ 1801| 3.16k|} lparser.c:funcname: 1777| 3.16k|static int funcname (LexState *ls, expdesc *v) { 1778| | /* funcname -> NAME {fieldsel} [':' NAME] */ 1779| 3.16k| int ismethod = 0; 1780| 3.16k| singlevar(ls, v); 1781| 3.19k| while (ls->t.token == '.') ------------------ | Branch (1781:10): [True: 32, False: 3.16k] ------------------ 1782| 32| fieldsel(ls, v); 1783| 3.16k| if (ls->t.token == ':') { ------------------ | Branch (1783:7): [True: 18, False: 3.14k] ------------------ 1784| 18| ismethod = 1; 1785| 18| fieldsel(ls, v); 1786| 18| } 1787| 3.16k| return ismethod; 1788| 3.16k|} lparser.c:check_readonly: 285| 103k|static void check_readonly (LexState *ls, expdesc *e) { 286| 103k| FuncState *fs = ls->fs; 287| 103k| TString *varname = NULL; /* to be set if variable is const */ 288| 103k| switch (e->k) { 289| 0| case VCONST: { ------------------ | Branch (289:5): [True: 0, False: 103k] ------------------ 290| 0| varname = ls->dyd->actvar.arr[e->u.info].vd.name; 291| 0| break; 292| 0| } 293| 4.44k| case VLOCAL: { ------------------ | Branch (293:5): [True: 4.44k, False: 98.6k] ------------------ 294| 4.44k| Vardesc *vardesc = getlocalvardesc(fs, e->u.var.vidx); 295| 4.44k| if (vardesc->vd.kind != VDKREG) /* not a regular variable? */ ------------------ | | 90| 4.44k|#define VDKREG 0 /* regular */ ------------------ | Branch (295:11): [True: 0, False: 4.44k] ------------------ 296| 0| varname = vardesc->vd.name; 297| 4.44k| break; 298| 0| } 299| 8.54k| case VUPVAL: { ------------------ | Branch (299:5): [True: 8.54k, False: 94.5k] ------------------ 300| 8.54k| Upvaldesc *up = &fs->f->upvalues[e->u.info]; 301| 8.54k| if (up->kind != VDKREG) ------------------ | | 90| 8.54k|#define VDKREG 0 /* regular */ ------------------ | Branch (301:11): [True: 0, False: 8.54k] ------------------ 302| 0| varname = up->name; 303| 8.54k| break; 304| 0| } 305| 90.0k| default: ------------------ | Branch (305:5): [True: 90.0k, False: 12.9k] ------------------ 306| 90.0k| return; /* other cases cannot be read-only */ 307| 103k| } 308| 12.9k| if (varname) { ------------------ | Branch (308:7): [True: 0, False: 12.9k] ------------------ 309| 0| const char *msg = luaO_pushfstring(ls->L, 310| 0| "attempt to assign to const variable '%s'", getstr(varname)); ------------------ | | 430| 0|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 0|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 0|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 0|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 311| 0| luaK_semerror(ls, msg); /* error */ 312| 0| } 313| 12.9k|} lparser.c:testnext: 95| 2.04M|static int testnext (LexState *ls, int c) { 96| 2.04M| if (ls->t.token == c) { ------------------ | Branch (96:7): [True: 1.79M, False: 255k] ------------------ 97| 1.79M| luaX_next(ls); 98| 1.79M| return 1; 99| 1.79M| } 100| 255k| else return 0; 101| 2.04M|} lparser.c:localfunc: 1697| 1.97k|static void localfunc (LexState *ls) { 1698| 1.97k| expdesc b; 1699| 1.97k| FuncState *fs = ls->fs; 1700| 1.97k| int fvar = fs->nactvar; /* function's variable index */ 1701| 1.97k| new_localvar(ls, str_checkname(ls)); /* new local variable */ 1702| 1.97k| adjustlocalvars(ls, 1); /* enter its scope */ 1703| 1.97k| body(ls, &b, 0, ls->linenumber); /* function created in next register */ 1704| | /* debug information will only see the variable after this point! */ 1705| 1.97k| localdebuginfo(fs, fvar)->startpc = fs->pc; 1706| 1.97k|} lparser.c:localstat: 1735| 6.59k|static void localstat (LexState *ls) { 1736| | /* stat -> LOCAL NAME ATTRIB { ',' NAME ATTRIB } ['=' explist] */ 1737| 6.59k| FuncState *fs = ls->fs; 1738| 6.59k| int toclose = -1; /* index of to-be-closed variable (if any) */ 1739| 6.59k| Vardesc *var; /* last variable */ 1740| 6.59k| int vidx; /* index of last variable */ 1741| 6.59k| int nvars = 0; 1742| 6.59k| int nexps; 1743| 6.59k| expdesc e; 1744| 12.6k| do { 1745| 12.6k| TString *vname = str_checkname(ls); 1746| 12.6k| int kind = getlocalattribute(ls); 1747| 12.6k| vidx = new_localvarkind(ls, vname, kind); 1748| 12.6k| if (kind == RDKTOCLOSE) { /* to-be-closed? */ ------------------ | | 92| 12.6k|#define RDKTOCLOSE 2 /* to-be-closed */ ------------------ | Branch (1748:9): [True: 224, False: 12.4k] ------------------ 1749| 224| if (toclose != -1) /* one already present? */ ------------------ | Branch (1749:11): [True: 0, False: 224] ------------------ 1750| 0| luaK_semerror(ls, "multiple to-be-closed variables in local list"); 1751| 224| toclose = fs->nactvar + nvars; 1752| 224| } 1753| 12.6k| nvars++; 1754| 12.6k| } while (testnext(ls, ',')); ------------------ | Branch (1754:12): [True: 6.03k, False: 6.59k] ------------------ 1755| 6.59k| if (testnext(ls, '=')) ------------------ | Branch (1755:7): [True: 5.40k, False: 1.19k] ------------------ 1756| 5.40k| nexps = explist(ls, &e); 1757| 1.19k| else { 1758| 1.19k| e.k = VVOID; 1759| 1.19k| nexps = 0; 1760| 1.19k| } 1761| 6.59k| var = getlocalvardesc(fs, vidx); /* get last variable */ 1762| 6.59k| if (nvars == nexps && /* no adjustments? */ ------------------ | Branch (1762:7): [True: 3.46k, False: 3.12k] ------------------ 1763| 6.59k| var->vd.kind == RDKCONST && /* last variable is const? */ ------------------ | | 91| 10.0k|#define RDKCONST 1 /* constant */ ------------------ | Branch (1763:7): [True: 2.16k, False: 1.30k] ------------------ 1764| 6.59k| luaK_exp2const(fs, &e, &var->k)) { /* compile-time constant? */ ------------------ | Branch (1764:7): [True: 1.09k, False: 1.07k] ------------------ 1765| 1.09k| var->vd.kind = RDKCTC; /* variable is a compile-time constant */ ------------------ | | 93| 1.09k|#define RDKCTC 3 /* compile-time constant */ ------------------ 1766| 1.09k| adjustlocalvars(ls, nvars - 1); /* exclude last variable */ 1767| 1.09k| fs->nactvar++; /* but count it */ 1768| 1.09k| } 1769| 5.50k| else { 1770| 5.50k| adjust_assign(ls, nvars, nexps, &e); 1771| 5.50k| adjustlocalvars(ls, nvars); 1772| 5.50k| } 1773| 6.59k| checktoclose(fs, toclose); 1774| 6.59k|} lparser.c:getlocalattribute: 1709| 12.6k|static int getlocalattribute (LexState *ls) { 1710| | /* ATTRIB -> ['<' Name '>'] */ 1711| 12.6k| if (testnext(ls, '<')) { ------------------ | Branch (1711:7): [True: 3.02k, False: 9.60k] ------------------ 1712| 3.02k| TString *ts = str_checkname(ls); 1713| 3.02k| const char *attr = getstr(ts); ------------------ | | 430| 3.02k|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 3.02k|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 3.02k, False: 0] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 3.02k|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 3.02k|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 3.02k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1714| 3.02k| checknext(ls, '>'); 1715| 3.02k| if (strcmp(attr, "const") == 0) ------------------ | Branch (1715:9): [True: 2.80k, False: 224] ------------------ 1716| 2.80k| return RDKCONST; /* read-only variable */ ------------------ | | 91| 2.80k|#define RDKCONST 1 /* constant */ ------------------ 1717| 224| else if (strcmp(attr, "close") == 0) ------------------ | Branch (1717:14): [True: 224, False: 0] ------------------ 1718| 224| return RDKTOCLOSE; /* to-be-closed variable */ ------------------ | | 92| 224|#define RDKTOCLOSE 2 /* to-be-closed */ ------------------ 1719| 0| else 1720| 0| luaK_semerror(ls, 1721| 0| luaO_pushfstring(ls->L, "unknown attribute '%s'", attr)); 1722| 3.02k| } 1723| 9.60k| return VDKREG; /* regular variable */ ------------------ | | 90| 9.60k|#define VDKREG 0 /* regular */ ------------------ 1724| 12.6k|} lparser.c:checktoclose: 1727| 6.57k|static void checktoclose (FuncState *fs, int level) { 1728| 6.57k| if (level != -1) { /* is there a to-be-closed variable? */ ------------------ | Branch (1728:7): [True: 224, False: 6.35k] ------------------ 1729| 224| marktobeclosed(fs); 1730| 224| luaK_codeABC(fs, OP_TBC, reglevel(fs, level), 0, 0); ------------------ | | 48| 224|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1731| 224| } 1732| 6.57k|} lparser.c:labelstat: 1467| 31|static void labelstat (LexState *ls, TString *name, int line) { 1468| | /* label -> '::' NAME '::' */ 1469| 31| checknext(ls, TK_DBCOLON); /* skip double colon */ 1470| 31| while (ls->t.token == ';' || ls->t.token == TK_DBCOLON) ------------------ | Branch (1470:10): [True: 0, False: 31] | Branch (1470:32): [True: 0, False: 31] ------------------ 1471| 0| statement(ls); /* skip other no-op statements */ 1472| 31| checkrepeated(ls, name); /* check for repeated labels */ 1473| 31| createlabel(ls, name, line, block_follow(ls, 0)); 1474| 31|} lparser.c:checkrepeated: 1457| 31|static void checkrepeated (LexState *ls, TString *name) { 1458| 31| Labeldesc *lb = findlabel(ls, name); 1459| 31| if (l_unlikely(lb != NULL)) { /* already defined? */ ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 1460| 0| const char *msg = "label '%s' already defined on line %d"; 1461| 0| msg = luaO_pushfstring(ls->L, msg, getstr(name), lb->line); ------------------ | | 430| 0|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 0|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 0|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 0|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1462| 0| luaK_semerror(ls, msg); /* error */ 1463| 0| } 1464| 31|} lparser.c:findlabel: 553| 25.4k|static Labeldesc *findlabel (LexState *ls, TString *name) { 554| 25.4k| int i; 555| 25.4k| Dyndata *dyd = ls->dyd; 556| | /* check labels in current function for a match */ 557| 26.1k| for (i = ls->fs->firstlabel; i < dyd->label.n; i++) { ------------------ | Branch (557:32): [True: 681, False: 25.4k] ------------------ 558| 681| Labeldesc *lb = &dyd->label.arr[i]; 559| 681| if (eqstr(lb->name, name)) /* correct label? */ ------------------ | | 43| 681|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 0, False: 681] | | ------------------ ------------------ 560| 0| return lb; 561| 681| } 562| 25.4k| return NULL; /* label not found */ 563| 25.4k|} lparser.c:str_checkname: 143| 26.2M|static TString *str_checkname (LexState *ls) { 144| 26.2M| TString *ts; 145| 26.2M| check(ls, TK_NAME); 146| 26.2M| ts = ls->t.seminfo.ts; 147| 26.2M| luaX_next(ls); 148| 26.2M| return ts; 149| 26.2M|} lparser.c:retstat: 1822| 7.96k|static void retstat (LexState *ls) { 1823| | /* stat -> RETURN [explist] [';'] */ 1824| 7.96k| FuncState *fs = ls->fs; 1825| 7.96k| expdesc e; 1826| 7.96k| int nret; /* number of values being returned */ 1827| 7.96k| int first = luaY_nvarstack(fs); /* first slot to be returned */ 1828| 7.96k| if (block_follow(ls, 1) || ls->t.token == ';') ------------------ | Branch (1828:7): [True: 304, False: 7.66k] | Branch (1828:30): [True: 0, False: 7.66k] ------------------ 1829| 304| nret = 0; /* return no values */ 1830| 7.66k| else { 1831| 7.66k| nret = explist(ls, &e); /* optional return values */ 1832| 7.66k| if (hasmultret(e.k)) { ------------------ | | 38| 7.66k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 3.45k, False: 4.20k] | | | Branch (38:41): [True: 0, False: 4.20k] | | ------------------ ------------------ 1833| 3.45k| luaK_setmultret(fs, &e); ------------------ | | 58| 3.45k|#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) | | ------------------ | | | | 35| 3.45k|#define LUA_MULTRET (-1) | | ------------------ ------------------ 1834| 3.45k| if (e.k == VCALL && nret == 1 && !fs->bl->insidetbc) { /* tail call? */ ------------------ | Branch (1834:11): [True: 3.45k, False: 0] | Branch (1834:27): [True: 3.35k, False: 103] | Branch (1834:40): [True: 654, False: 2.69k] ------------------ 1835| 654| SET_OPCODE(getinstruction(fs,&e), OP_TAILCALL); ------------------ | | 115| 654|#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ | | ------------------ | | | | 108| 654|#define MASK0(n,p) (~MASK1(n,p)) | | | | ------------------ | | | | | | 105| 654|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | ------------------ | | ------------------ | | 116| 654| ((cast(Instruction, o)<freereg - first); ------------------ | | 109| 1.33k|#define lua_assert(c) assert(c) ------------------ 1846| 1.33k| } 1847| 4.20k| } 1848| 7.66k| } 1849| 7.96k| luaK_ret(fs, first, nret); 1850| 7.96k| testnext(ls, ';'); /* skip optional semicolon */ 1851| 7.96k|} lparser.c:breakstat: 1447| 128|static void breakstat (LexState *ls) { 1448| 128| int line = ls->linenumber; 1449| 128| luaX_next(ls); /* skip break */ 1450| 128| newgotoentry(ls, luaS_newliteral(ls->L, "break"), line, luaK_jump(ls->fs)); ------------------ | | 30| 128|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 31| 128| (sizeof(s)/sizeof(char))-1)) ------------------ 1451| 128|} lparser.c:gotostat: 1425| 25.3k|static void gotostat (LexState *ls) { 1426| 25.3k| FuncState *fs = ls->fs; 1427| 25.3k| int line = ls->linenumber; 1428| 25.3k| TString *name = str_checkname(ls); /* label's name */ 1429| 25.3k| Labeldesc *lb = findlabel(ls, name); 1430| 25.3k| if (lb == NULL) /* no label? */ ------------------ | Branch (1430:7): [True: 25.3k, False: 0] ------------------ 1431| | /* forward jump; will be resolved when the label is declared */ 1432| 25.3k| newgotoentry(ls, name, line, luaK_jump(fs)); 1433| 0| else { /* found a label */ 1434| | /* backward jump; will be resolved here */ 1435| 0| int lblevel = reglevel(fs, lb->nactvar); /* label level */ 1436| 0| if (luaY_nvarstack(fs) > lblevel) /* leaving the scope of a variable? */ ------------------ | Branch (1436:9): [True: 0, False: 0] ------------------ 1437| 0| luaK_codeABC(fs, OP_CLOSE, lblevel, 0, 0); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1438| | /* create jump and link it to the label */ 1439| 0| luaK_patchlist(fs, luaK_jump(fs), lb->pc); 1440| 0| } 1441| 25.3k|} lparser.c:exprstat: 1804| 105k|static void exprstat (LexState *ls) { 1805| | /* stat -> func | assignment */ 1806| 105k| FuncState *fs = ls->fs; 1807| 105k| struct LHS_assign v; 1808| 105k| suffixedexp(ls, &v.v); 1809| 105k| if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */ ------------------ | Branch (1809:7): [True: 82.8k, False: 23.1k] | Branch (1809:29): [True: 3.97k, False: 19.1k] ------------------ 1810| 86.7k| v.prev = NULL; 1811| 86.7k| restassign(ls, &v, 1); 1812| 86.7k| } 1813| 19.2k| else { /* stat -> func */ 1814| 19.2k| Instruction *inst; 1815| 19.2k| check_condition(ls, v.v.k == VCALL, "syntax error"); ------------------ | | 122| 19.2k|#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } | | ------------------ | | | Branch (122:41): [True: 20, False: 19.2k] | | ------------------ ------------------ 1816| 19.2k| inst = &getinstruction(fs, &v.v); ------------------ | | 55| 19.2k|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 1817| 19.2k| SETARG_C(*inst, 1); /* call statement uses no results */ ------------------ | | 134| 19.2k|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 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)<v.k), "syntax error"); ------------------ | | 122| 200k|#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } | | ------------------ | | | Branch (122:43): [True: 100k, False: 0] | | | Branch (122:43): [True: 100k, False: 1] | | ------------------ ------------------ 1387| 100k| check_readonly(ls, &lh->v); 1388| 100k| if (testnext(ls, ',')) { /* restassign -> ',' suffixedexp restassign */ ------------------ | Branch (1388:7): [True: 13.4k, False: 86.7k] ------------------ 1389| 13.4k| struct LHS_assign nv; 1390| 13.4k| nv.prev = lh; 1391| 13.4k| suffixedexp(ls, &nv.v); 1392| 13.4k| if (!vkisindexed(nv.v.k)) ------------------ | | 65| 13.4k|#define vkisindexed(k) (VINDEXED <= (k) && (k) <= VINDEXSTR) | | ------------------ | | | Branch (65:25): [True: 11.1k, False: 2.31k] | | | Branch (65:44): [True: 11.1k, False: 0] | | ------------------ ------------------ 1393| 2.31k| check_conflict(ls, lh, &nv.v); 1394| 13.4k| enterlevel(ls); /* control recursion depth */ ------------------ | | 512| 13.4k|#define enterlevel(ls) luaE_incCstack(ls->L) ------------------ 1395| 13.4k| restassign(ls, &nv, nvars+1); 1396| 13.4k| leavelevel(ls); ------------------ | | 515| 13.4k|#define leavelevel(ls) ((ls)->L->nCcalls--) ------------------ 1397| 13.4k| } 1398| 86.7k| else { /* restassign -> '=' explist */ 1399| 86.7k| int nexps; 1400| 86.7k| checknext(ls, '='); 1401| 86.7k| nexps = explist(ls, &e); 1402| 86.7k| if (nexps != nvars) ------------------ | Branch (1402:9): [True: 15.5k, False: 71.1k] ------------------ 1403| 15.5k| adjust_assign(ls, nvars, nexps, &e); 1404| 71.1k| else { 1405| 71.1k| luaK_setoneret(ls->fs, &e); /* close last expression */ 1406| 71.1k| luaK_storevar(ls->fs, &lh->v, &e); 1407| 71.1k| return; /* avoid default */ 1408| 71.1k| } 1409| 86.7k| } 1410| 29.0k| init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */ 1411| 29.0k| luaK_storevar(ls->fs, &lh->v, &e); 1412| 29.0k|} lparser.c:check_conflict: 1340| 2.31k|static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) { 1341| 2.31k| FuncState *fs = ls->fs; 1342| 2.31k| int extra = fs->freereg; /* eventual position to save local variable */ 1343| 2.31k| int conflict = 0; 1344| 25.0k| for (; lh; lh = lh->prev) { /* check all previous assignments */ ------------------ | Branch (1344:10): [True: 22.7k, False: 2.31k] ------------------ 1345| 22.7k| if (vkisindexed(lh->v.k)) { /* assignment to table field? */ ------------------ | | 65| 22.7k|#define vkisindexed(k) (VINDEXED <= (k) && (k) <= VINDEXSTR) | | ------------------ | | | Branch (65:25): [True: 10.4k, False: 12.2k] | | | Branch (65:44): [True: 10.4k, False: 0] | | ------------------ ------------------ 1346| 10.4k| if (lh->v.k == VINDEXUP) { /* is table an upvalue? */ ------------------ | Branch (1346:11): [True: 3.06k, False: 7.41k] ------------------ 1347| 3.06k| if (v->k == VUPVAL && lh->v.u.ind.t == v->u.info) { ------------------ | Branch (1347:13): [True: 2.91k, False: 148] | Branch (1347:31): [True: 1.62k, False: 1.28k] ------------------ 1348| 1.62k| conflict = 1; /* table is the upvalue being assigned now */ 1349| 1.62k| lh->v.k = VINDEXSTR; 1350| 1.62k| lh->v.u.ind.t = extra; /* assignment will use safe copy */ 1351| 1.62k| } 1352| 3.06k| } 1353| 7.41k| else { /* table is a register */ 1354| 7.41k| if (v->k == VLOCAL && lh->v.u.ind.t == v->u.var.ridx) { ------------------ | Branch (1354:13): [True: 6.59k, False: 821] | Branch (1354:31): [True: 851, False: 5.74k] ------------------ 1355| 851| conflict = 1; /* table is the local being assigned now */ 1356| 851| lh->v.u.ind.t = extra; /* assignment will use safe copy */ 1357| 851| } 1358| | /* is index the local being assigned? */ 1359| 7.41k| if (lh->v.k == VINDEXED && v->k == VLOCAL && ------------------ | Branch (1359:13): [True: 3.20k, False: 4.21k] | Branch (1359:36): [True: 2.82k, False: 379] ------------------ 1360| 7.41k| lh->v.u.ind.idx == v->u.var.ridx) { ------------------ | Branch (1360:13): [True: 231, False: 2.59k] ------------------ 1361| 231| conflict = 1; 1362| 231| lh->v.u.ind.idx = extra; /* previous assignment will use safe copy */ 1363| 231| } 1364| 7.41k| } 1365| 10.4k| } 1366| 22.7k| } 1367| 2.31k| if (conflict) { ------------------ | Branch (1367:7): [True: 1.90k, False: 409] ------------------ 1368| | /* copy upvalue/local value to a temporary (in position 'extra') */ 1369| 1.90k| if (v->k == VLOCAL) ------------------ | Branch (1369:9): [True: 495, False: 1.40k] ------------------ 1370| 495| luaK_codeABC(fs, OP_MOVE, extra, v->u.var.ridx, 0); ------------------ | | 48| 495|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1371| 1.40k| else 1372| 1.40k| luaK_codeABC(fs, OP_GETUPVAL, extra, v->u.info, 0); ------------------ | | 48| 1.40k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1373| 1.90k| luaK_reserveregs(fs, 1); 1374| 1.90k| } 1375| 2.31k|} lparser.c:check: 107| 26.4M|static void check (LexState *ls, int c) { 108| 26.4M| if (ls->t.token != c) ------------------ | Branch (108:7): [True: 14, False: 26.4M] ------------------ 109| 14| error_expected(ls, c); 110| 26.4M|} lparser.c:close_func: 765| 20.9k|static void close_func (LexState *ls) { 766| 20.9k| lua_State *L = ls->L; 767| 20.9k| FuncState *fs = ls->fs; 768| 20.9k| Proto *f = fs->f; 769| 20.9k| luaK_ret(fs, luaY_nvarstack(fs), 0); /* final return */ 770| 20.9k| leaveblock(fs); 771| 20.9k| lua_assert(fs->bl == NULL); ------------------ | | 109| 20.9k|#define lua_assert(c) assert(c) ------------------ 772| 20.9k| luaK_finish(fs); 773| 20.9k| luaM_shrinkvector(L, f->code, f->sizecode, fs->pc, Instruction); ------------------ | | 77| 20.9k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 139| 20.9k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 774| 20.9k| luaM_shrinkvector(L, f->lineinfo, f->sizelineinfo, fs->pc, ls_byte); ------------------ | | 77| 20.9k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 139| 20.9k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 775| 20.9k| luaM_shrinkvector(L, f->abslineinfo, f->sizeabslineinfo, ------------------ | | 77| 20.9k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 139| 20.9k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 776| 20.9k| fs->nabslineinfo, AbsLineInfo); 777| 20.9k| luaM_shrinkvector(L, f->k, f->sizek, fs->nk, TValue); ------------------ | | 77| 20.9k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 139| 20.9k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 778| 20.9k| luaM_shrinkvector(L, f->p, f->sizep, fs->np, Proto *); ------------------ | | 77| 20.9k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 139| 20.9k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 779| 20.9k| luaM_shrinkvector(L, f->locvars, f->sizelocvars, fs->ndebugvars, LocVar); ------------------ | | 77| 20.9k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 139| 20.9k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 780| 20.9k| luaM_shrinkvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc); ------------------ | | 77| 20.9k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 139| 20.9k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 781| 20.9k| ls->fs = fs->prev; 782| 20.9k| luaC_checkGC(L); ------------------ | | 219| 20.9k|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 215| 20.9k| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 20.9k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 145, False: 20.8k] | | | | ------------------ | | | | 216| 20.9k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 20.9k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 783| 20.9k|} luaE_setdebt: 59| 13.7k|void luaE_setdebt (global_State *g, l_obj debt) { 60| 13.7k| l_obj tb = gettotalobjs(g); ------------------ | | 392| 13.7k|#define gettotalobjs(g) ((g)->totalobjs - (g)->GCdebt) ------------------ 61| 13.7k| lua_assert(tb > 0); ------------------ | | 109| 13.7k|#define lua_assert(c) assert(c) ------------------ 62| 13.7k| if (debt > MAX_LOBJ - tb) ------------------ | | 37| 13.7k| cast(l_obj, (cast(lu_mem, 1) << (sizeof(l_obj) * CHAR_BIT - 1)) - 1) | | ------------------ | | | | 139| 13.7k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (62:7): [True: 0, False: 13.7k] ------------------ 63| 0| debt = MAX_LOBJ - tb; /* will make 'totalobjs == MAX_LMEM' */ ------------------ | | 37| 0| cast(l_obj, (cast(lu_mem, 1) << (sizeof(l_obj) * CHAR_BIT - 1)) - 1) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 64| 13.7k| g->totalobjs = tb + debt; 65| 13.7k| g->GCdebt = debt; 66| 13.7k|} luaE_extendCI: 69| 1.40k|CallInfo *luaE_extendCI (lua_State *L) { 70| 1.40k| CallInfo *ci; 71| 1.40k| lua_assert(L->ci->next == NULL); ------------------ | | 109| 1.40k|#define lua_assert(c) assert(c) ------------------ 72| 1.40k| ci = luaM_new(L, CallInfo); ------------------ | | 59| 1.40k|#define luaM_new(L,t) cast(t*, luaM_malloc_(L, sizeof(t), 0)) | | ------------------ | | | | 139| 1.40k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 73| 1.40k| lua_assert(L->ci->next == NULL); ------------------ | | 109| 1.40k|#define lua_assert(c) assert(c) ------------------ 74| 1.40k| L->ci->next = ci; 75| 1.40k| ci->previous = L->ci; 76| 1.40k| ci->next = NULL; 77| 1.40k| ci->u.l.trap = 0; 78| 1.40k| L->nci++; 79| 1.40k| return ci; 80| 1.40k|} luaE_shrinkCI: 102| 5.29k|void luaE_shrinkCI (lua_State *L) { 103| 5.29k| CallInfo *ci = L->ci->next; /* first free CallInfo */ 104| 5.29k| CallInfo *next; 105| 5.29k| if (ci == NULL) ------------------ | Branch (105:7): [True: 2.53k, False: 2.76k] ------------------ 106| 2.53k| return; /* no extra elements */ 107| 3.32k| while ((next = ci->next) != NULL) { /* two extra elements? */ ------------------ | Branch (107:10): [True: 673, False: 2.65k] ------------------ 108| 673| CallInfo *next2 = next->next; /* next's next */ 109| 673| ci->next = next2; /* remove next from the list */ 110| 673| L->nci--; 111| 673| luaM_free(L, next); /* free next */ ------------------ | | 56| 673|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 112| 673| if (next2 == NULL) ------------------ | Branch (112:9): [True: 107, False: 566] ------------------ 113| 107| break; /* no more elements */ 114| 566| else { 115| 566| next2->previous = ci; 116| 566| ci = next2; /* continue */ 117| 566| } 118| 673| } 119| 2.76k|} luaE_checkcstack: 129| 6|void luaE_checkcstack (lua_State *L) { 130| 6| if (getCcalls(L) == LUAI_MAXCCALLS) ------------------ | | 107| 6|#define getCcalls(L) ((L)->nCcalls & 0xffff) ------------------ if (getCcalls(L) == LUAI_MAXCCALLS) ------------------ | | 258| 6|#define LUAI_MAXCCALLS 200 ------------------ | Branch (130:7): [True: 6, False: 0] ------------------ 131| 6| luaG_runerror(L, "C stack overflow"); 132| 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)) ------------------ | | 258| 0|#define LUAI_MAXCCALLS 200 ------------------ | Branch (132:12): [True: 0, False: 0] ------------------ 133| 0| luaD_throw(L, LUA_ERRERR); /* error while handling stack error */ ------------------ | | 53| 0|#define LUA_ERRERR 5 ------------------ 134| 6|} luaE_incCstack: 137| 27.9M|LUAI_FUNC void luaE_incCstack (lua_State *L) { 138| 27.9M| L->nCcalls++; 139| 27.9M| if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) ------------------ | | 697| 27.9M|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 27.9M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 6, False: 27.9M] | | | | ------------------ | | ------------------ ------------------ 140| 6| luaE_checkcstack(L); 141| 27.9M|} lua_newstate: 323| 561|LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud, unsigned seed) { 324| 561| int i; 325| 561| lua_State *L; 326| 561| global_State *g; 327| 561| LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG))); ------------------ | | 139| 561|#define cast(t, exp) ((t)(exp)) ------------------ 328| 561| if (l == NULL) return NULL; ------------------ | Branch (328:7): [True: 0, False: 561] ------------------ 329| 561| L = &l->l.l; 330| 561| g = &l->g; 331| 561| L->tt = LUA_VTHREAD; ------------------ | | 275| 561|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 561|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 332| 561| g->currentwhite = bitmask(WHITE0BIT); ------------------ | | 66| 561|#define bitmask(b) (1<<(b)) ------------------ 333| 561| L->marked = luaC_white(g); ------------------ | | 105| 561|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 146| 561|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 561|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 334| 561| preinit_thread(L, g); 335| 561| g->allgc = obj2gco(L); /* by now, only object is the main thread */ ------------------ | | 388| 561|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 113| 561|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 336| 0| L->next = NULL; 337| 561| incnny(L); /* main thread is always non yieldable */ ------------------ | | 111| 561|#define incnny(L) ((L)->nCcalls += 0x10000) ------------------ 338| 561| g->frealloc = f; 339| 561| g->ud = ud; 340| 561| g->warnf = NULL; 341| 561| g->ud_warn = NULL; 342| 561| g->mainthread = L; 343| 561| g->seed = seed; 344| 561| g->gcstp = GCSTPGC; /* no GC while building state */ ------------------ | | 203| 561|#define GCSTPGC 2 /* bit true when GC stopped by itself */ ------------------ 345| 561| g->strt.size = g->strt.nuse = 0; 346| 561| g->strt.hash = NULL; 347| 561| setnilvalue(&g->l_registry); ------------------ | | 211| 561|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 561|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 348| 561| g->panic = NULL; 349| 561| g->gcstate = GCSpause; ------------------ | | 42| 561|#define GCSpause 8 ------------------ 350| 561| g->gckind = KGC_INC; ------------------ | | 151| 561|#define KGC_INC 0 /* incremental gc */ ------------------ 351| 561| g->gcstopem = 0; 352| 561| g->gcemergency = 0; 353| 561| g->finobj = g->tobefnz = g->fixedgc = NULL; 354| 561| g->firstold1 = g->survival = g->old1 = g->reallyold = NULL; 355| 561| g->finobjsur = g->finobjold1 = g->finobjrold = NULL; 356| 561| g->sweepgc = NULL; 357| 561| g->gray = g->grayagain = NULL; 358| 561| g->weak = g->ephemeron = g->allweak = NULL; 359| 561| g->twups = NULL; 360| 561| g->totalbytes = sizeof(LG); 361| 561| g->totalobjs = 1; 362| 561| g->marked = 0; 363| 561| g->GCdebt = 0; 364| 561| setivalue(&g->nilvalue, 0); /* to signal that state is not yet built */ ------------------ | | 358| 561| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 561|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 561|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 365| 561| setgcparam(g, PAUSE, LUAI_GCPAUSE); ------------------ | | 196| 561|#define setgcparam(g,p,v) (g->gcparams[LUA_GCP##p] = luaO_codeparam(v)) ------------------ 366| 561| setgcparam(g, STEPMUL, LUAI_GCMUL); ------------------ | | 196| 561|#define setgcparam(g,p,v) (g->gcparams[LUA_GCP##p] = luaO_codeparam(v)) ------------------ 367| 561| setgcparam(g, STEPSIZE, LUAI_GCSTEPSIZE); ------------------ | | 196| 561|#define setgcparam(g,p,v) (g->gcparams[LUA_GCP##p] = luaO_codeparam(v)) ------------------ 368| 561| setgcparam(g, MINORMUL, LUAI_GENMINORMUL); ------------------ | | 196| 561|#define setgcparam(g,p,v) (g->gcparams[LUA_GCP##p] = luaO_codeparam(v)) ------------------ 369| 561| setgcparam(g, MINORMAJOR, LUAI_MINORMAJOR); ------------------ | | 196| 561|#define setgcparam(g,p,v) (g->gcparams[LUA_GCP##p] = luaO_codeparam(v)) ------------------ 370| 561| setgcparam(g, MAJORMINOR, LUAI_MAJORMINOR); ------------------ | | 196| 561|#define setgcparam(g,p,v) (g->gcparams[LUA_GCP##p] = luaO_codeparam(v)) ------------------ 371| 5.61k| for (i=0; i < LUA_NUMTYPES; i++) g->mt[i] = NULL; ------------------ | | 74| 5.61k|#define LUA_NUMTYPES 9 ------------------ | Branch (371:13): [True: 5.04k, False: 561] ------------------ 372| 561| if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) { ------------------ | | 48| 561|#define LUA_OK 0 ------------------ | Branch (372:7): [True: 0, False: 561] ------------------ 373| | /* memory allocation error: free partial state */ 374| 0| close_state(L); 375| 0| L = NULL; 376| 0| } 377| 561| return L; 378| 561|} lua_close: 381| 561|LUA_API void lua_close (lua_State *L) { 382| 561| lua_lock(L); ------------------ | | 267| 561|#define lua_lock(L) ((void) 0) ------------------ 383| 561| L = G(L)->mainthread; /* only the main thread can be closed */ ------------------ | | 333| 561|#define G(L) (L->l_G) ------------------ 384| 561| close_state(L); 385| 561|} lstate.c:preinit_thread: 219| 561|static void preinit_thread (lua_State *L, global_State *g) { 220| 561| G(L) = g; ------------------ | | 333| 561|#define G(L) (L->l_G) ------------------ 221| 561| L->stack.p = NULL; 222| 561| L->ci = NULL; 223| 561| L->nci = 0; 224| 561| L->twups = L; /* thread has no upvalues */ 225| 561| L->nCcalls = 0; 226| 561| L->errorJmp = NULL; 227| 561| L->hook = NULL; 228| 561| L->hookmask = 0; 229| 561| L->basehookcount = 0; 230| 561| L->allowhook = 1; 231| 561| resethookcount(L); ------------------ | | 21| 561|#define resethookcount(L) (L->hookcount = L->basehookcount) ------------------ 232| 561| L->openupval = NULL; 233| 561| L->status = LUA_OK; ------------------ | | 48| 561|#define LUA_OK 0 ------------------ 234| 561| L->errfunc = 0; 235| 561| L->oldpc = 0; 236| 561|} lstate.c:stack_init: 144| 561|static void stack_init (lua_State *L1, lua_State *L) { 145| 561| int i; CallInfo *ci; 146| | /* initialize stack array */ 147| 561| L1->stack.p = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, StackValue); ------------------ | | 60| 561|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 139| 561|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 148| 561| L1->tbclist.p = L1->stack.p; 149| 25.8k| for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++) ------------------ | | 145| 25.8k|#define BASIC_STACK_SIZE (2*LUA_MINSTACK) | | ------------------ | | | | 79| 25.8k|#define LUA_MINSTACK 20 | | ------------------ ------------------ for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++) ------------------ | | 142| 25.8k|#define EXTRA_STACK 5 ------------------ | Branch (149:15): [True: 25.2k, False: 561] ------------------ 150| 25.2k| setnilvalue(s2v(L1->stack.p + i)); /* erase new stack */ ------------------ | | 211| 25.2k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 25.2k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 151| 561| L1->top.p = L1->stack.p; 152| 561| L1->stack_last.p = L1->stack.p + BASIC_STACK_SIZE; ------------------ | | 145| 561|#define BASIC_STACK_SIZE (2*LUA_MINSTACK) | | ------------------ | | | | 79| 561|#define LUA_MINSTACK 20 | | ------------------ ------------------ 153| | /* initialize first ci */ 154| 561| ci = &L1->base_ci; 155| 561| ci->next = ci->previous = NULL; 156| 561| ci->callstatus = CIST_C; ------------------ | | 212| 561|#define CIST_C (1<<1) /* call is running a C function */ ------------------ 157| 561| ci->func.p = L1->top.p; 158| 561| ci->u.c.k = NULL; 159| 561| ci->nresults = 0; 160| 561| setnilvalue(s2v(L1->top.p)); /* 'function' entry for this 'ci' */ ------------------ | | 211| 561|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 561|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 161| 561| L1->top.p++; 162| 561| ci->top.p = L1->top.p + LUA_MINSTACK; ------------------ | | 79| 561|#define LUA_MINSTACK 20 ------------------ 163| 561| L1->ci = ci; 164| 561|} lstate.c:freestack: 167| 561|static void freestack (lua_State *L) { 168| 561| if (L->stack.p == NULL) ------------------ | Branch (168:7): [True: 0, False: 561] ------------------ 169| 0| return; /* stack not completely built yet */ 170| 561| L->ci = &L->base_ci; /* free the entire 'ci' list */ 171| 561| freeCI(L); 172| 561| lua_assert(L->nci == 0); ------------------ | | 109| 561|#define lua_assert(c) assert(c) ------------------ 173| 561| luaM_freearray(L, L->stack.p, stacksize(L) + EXTRA_STACK); /* free stack */ ------------------ | | 57| 561|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 174| 561|} lstate.c:freeCI: 86| 561|static void freeCI (lua_State *L) { 87| 561| CallInfo *ci = L->ci; 88| 561| CallInfo *next = ci->next; 89| 561| ci->next = NULL; 90| 1.29k| while ((ci = next) != NULL) { ------------------ | Branch (90:10): [True: 735, False: 561] ------------------ 91| 735| next = ci->next; 92| 735| luaM_free(L, ci); ------------------ | | 56| 735|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 93| 735| L->nci--; 94| 735| } 95| 561|} lstate.c:f_luaopen: 201| 561|static void f_luaopen (lua_State *L, void *ud) { 202| 561| global_State *g = G(L); ------------------ | | 333| 561|#define G(L) (L->l_G) ------------------ 203| 561| UNUSED(ud); ------------------ | | 134| 561|#define UNUSED(x) ((void)(x)) ------------------ 204| 561| stack_init(L, L); /* init stack */ 205| 561| init_registry(L, g); 206| 561| luaS_init(L); 207| 561| luaT_init(L); 208| 561| luaX_init(L); 209| 561| g->gcstp = 0; /* allow gc */ 210| 561| setnilvalue(&g->nilvalue); /* now state is complete */ ------------------ | | 211| 561|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 561|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 211| 561| luai_userstateopen(L); ------------------ | | 285| 561|#define luai_userstateopen(L) ((void)L) ------------------ 212| 561|} lstate.c:init_registry: 180| 561|static void init_registry (lua_State *L, global_State *g) { 181| | /* create registry */ 182| 561| TValue aux; 183| 561| Table *registry = luaH_new(L); 184| 561| sethvalue(L, &g->l_registry, registry); ------------------ | | 724| 561| { TValue *io = (obj); Table *x_ = (x); \ | | 725| 561| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 561|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 388| 561|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 561|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 561|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 726| 561| checkliveness(L,io); } | | ------------------ | | | | 107| 561| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 8.97k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | ------------------ | | | | ------------------ | | | | 108| 561| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 185| 561| luaH_resize(L, registry, LUA_RIDX_LAST, 0); ------------------ | | 86| 561|#define LUA_RIDX_LAST 3 ------------------ 186| | /* registry[1] = false */ 187| 561| setbfvalue(&aux); ------------------ | | 263| 561|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 561|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 188| 561| luaH_setint(L, registry, 1, &aux); 189| | /* registry[LUA_RIDX_MAINTHREAD] = L */ 190| 561| setthvalue(L, &aux, L); ------------------ | | 282| 561| { TValue *io = (obj); lua_State *x_ = (x); \ | | 283| 561| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 72| 561|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 388| 561|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 561|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 114| 561|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 284| 561| checkliveness(L,io); } | | ------------------ | | | | 107| 561| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 8.97k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | ------------------ | | | | ------------------ | | | | 108| 561| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 191| 561| luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &aux); ------------------ | | 85| 561|#define LUA_RIDX_MAINTHREAD 3 ------------------ 192| | /* registry[LUA_RIDX_GLOBALS] = new table (table of globals) */ 193| 561| sethvalue(L, &aux, luaH_new(L)); ------------------ | | 724| 561| { TValue *io = (obj); Table *x_ = (x); \ | | 725| 561| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 561|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 388| 561|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 561|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 561|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 726| 561| checkliveness(L,io); } | | ------------------ | | | | 107| 561| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 8.97k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | Branch (115:29): [True: 561, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 561] | | | | | | ------------------ | | | | ------------------ | | | | 108| 561| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 194| 561| luaH_setint(L, registry, LUA_RIDX_GLOBALS, &aux); ------------------ | | 84| 561|#define LUA_RIDX_GLOBALS 2 ------------------ 195| 561|} lstate.c:close_state: 239| 561|static void close_state (lua_State *L) { 240| 561| global_State *g = G(L); ------------------ | | 333| 561|#define G(L) (L->l_G) ------------------ 241| 561| if (!completestate(g)) /* closing a partially built state? */ ------------------ | | 339| 561|#define completestate(g) ttisnil(&g->nilvalue) | | ------------------ | | | | 196| 561|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 561|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 561|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 561|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (241:7): [True: 0, False: 561] ------------------ 242| 0| luaC_freeallobjects(L); /* just collect its objects */ 243| 561| else { /* closing a fully built state */ 244| 561| L->ci = &L->base_ci; /* unwind CallInfo list */ 245| 561| luaD_closeprotected(L, 1, LUA_OK); /* close all upvalues */ ------------------ | | 48| 561|#define LUA_OK 0 ------------------ 246| 561| luaC_freeallobjects(L); /* collect all objects */ 247| 561| luai_userstateclose(L); ------------------ | | 289| 561|#define luai_userstateclose(L) ((void)L) ------------------ 248| 561| } 249| 561| luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size); ------------------ | | 57| 561|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 250| 561| freestack(L); 251| 561| lua_assert(g->totalbytes == sizeof(LG)); ------------------ | | 109| 561|#define lua_assert(c) assert(c) ------------------ 252| 561| lua_assert(gettotalobjs(g) == 1); ------------------ | | 109| 561|#define lua_assert(c) assert(c) ------------------ 253| 561| (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0); /* free main block */ ------------------ | | 51| 561|#define fromstate(L) (cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l))) | | ------------------ | | | | 139| 561|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 254| 561|} luaS_eqlngstr: 34| 274k|int luaS_eqlngstr (TString *a, TString *b) { 35| 274k| size_t len = a->u.lnglen; 36| 274k| lua_assert(a->tt == LUA_VLNGSTR && b->tt == LUA_VLNGSTR); ------------------ | | 109| 274k|#define lua_assert(c) assert(c) ------------------ 37| 274k| return (a == b) || /* same instance or... */ ------------------ | Branch (37:10): [True: 160k, False: 113k] ------------------ 38| 274k| ((len == b->u.lnglen) && /* equal length and ... */ ------------------ | Branch (38:6): [True: 82.2k, False: 31.1k] ------------------ 39| 113k| (memcmp(getlngstr(a), getlngstr(b), len) == 0)); /* equal contents */ ------------------ | | 429| 82.2k|#define getlngstr(ts) check_exp(!strisshr(ts), (ts)->contents) | | ------------------ | | | | 113| 82.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 82.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ (memcmp(getlngstr(a), getlngstr(b), len) == 0)); /* equal contents */ ------------------ | | 429| 82.2k|#define getlngstr(ts) check_exp(!strisshr(ts), (ts)->contents) | | ------------------ | | | | 113| 82.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 82.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (39:6): [True: 74.2k, False: 7.95k] ------------------ 40| 274k|} luaS_hash: 43| 27.0M|unsigned luaS_hash (const char *str, size_t l, unsigned seed) { 44| 27.0M| unsigned int h = seed ^ cast_uint(l); ------------------ | | 145| 27.0M|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 139| 27.0M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 45| 95.5M| for (; l > 0; l--) ------------------ | Branch (45:10): [True: 68.4M, False: 27.0M] ------------------ 46| 68.4M| h ^= ((h<<5) + (h>>2) + cast_byte(str[l - 1])); ------------------ | | 146| 68.4M|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 139| 68.4M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 47| 27.0M| return h; 48| 27.0M|} luaS_hashlongstr: 51| 203k|unsigned luaS_hashlongstr (TString *ts) { 52| 203k| lua_assert(ts->tt == LUA_VLNGSTR); ------------------ | | 109| 203k|#define lua_assert(c) assert(c) ------------------ 53| 203k| if (ts->extra == 0) { /* no hash? */ ------------------ | Branch (53:7): [True: 80.3k, False: 123k] ------------------ 54| 80.3k| size_t len = ts->u.lnglen; 55| 80.3k| ts->hash = luaS_hash(getlngstr(ts), len, ts->hash); ------------------ | | 429| 80.3k|#define getlngstr(ts) check_exp(!strisshr(ts), (ts)->contents) | | ------------------ | | | | 113| 80.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 80.3k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 56| 0| ts->extra = 1; /* now it has its hash */ 57| 80.3k| } 58| 203k| return ts->hash; 59| 203k|} luaS_resize: 85| 131|void luaS_resize (lua_State *L, int nsize) { 86| 131| stringtable *tb = &G(L)->strt; ------------------ | | 333| 131|#define G(L) (L->l_G) ------------------ 87| 131| int osize = tb->size; 88| 131| TString **newvect; 89| 131| if (nsize < osize) /* shrinking table? */ ------------------ | Branch (89:7): [True: 0, False: 131] ------------------ 90| 0| tablerehash(tb->hash, osize, nsize); /* depopulate shrinking part */ 91| 131| newvect = luaM_reallocvector(L, tb->hash, osize, nsize, TString*); ------------------ | | 73| 131| (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \ | | ------------------ | | | | 139| 131|#define cast(t, exp) ((t)(exp)) | | ------------------ | | 74| 131| cast_sizet(n) * sizeof(t)))) ------------------ 92| 131| if (l_unlikely(newvect == NULL)) { /* reallocation failed? */ ------------------ | | 697| 131|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 131|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 131] | | | | ------------------ | | ------------------ ------------------ 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| 131| else { /* allocation succeeded */ 98| 131| tb->hash = newvect; 99| 131| tb->size = nsize; 100| 131| if (nsize > osize) ------------------ | Branch (100:9): [True: 131, False: 0] ------------------ 101| 131| tablerehash(newvect, osize, nsize); /* rehash for new size */ 102| 131| } 103| 131|} luaS_clearcache: 110| 4.74k|void luaS_clearcache (global_State *g) { 111| 4.74k| int i, j; 112| 255k| for (i = 0; i < STRCACHE_N; i++) ------------------ | | 240| 255k|#define STRCACHE_N 53 ------------------ | Branch (112:15): [True: 251k, False: 4.74k] ------------------ 113| 753k| for (j = 0; j < STRCACHE_M; j++) { ------------------ | | 241| 753k|#define STRCACHE_M 2 ------------------ | Branch (113:17): [True: 502k, False: 251k] ------------------ 114| 502k| if (iswhite(g->strcache[i][j])) /* will entry be collected? */ ------------------ | | 90| 502k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 65| 502k|#define testbits(x,m) ((x) & (m)) | | | | ------------------ | | | | | Branch (65:24): [True: 120, False: 502k] | | | | ------------------ | | ------------------ ------------------ 115| 120| g->strcache[i][j] = g->memerrmsg; /* replace it with something fixed */ 116| 502k| } 117| 4.74k|} luaS_init: 123| 561|void luaS_init (lua_State *L) { 124| 561| global_State *g = G(L); ------------------ | | 333| 561|#define G(L) (L->l_G) ------------------ 125| 561| int i, j; 126| 561| stringtable *tb = &G(L)->strt; ------------------ | | 333| 561|#define G(L) (L->l_G) ------------------ 127| 561| tb->hash = luaM_newvector(L, MINSTRTABSIZE, TString*); ------------------ | | 60| 561|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 139| 561|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 128| 561| tablerehash(tb->hash, 0, MINSTRTABSIZE); /* clear array */ ------------------ | | 230| 561|#define MINSTRTABSIZE 128 ------------------ 129| 561| tb->size = MINSTRTABSIZE; ------------------ | | 230| 561|#define MINSTRTABSIZE 128 ------------------ 130| | /* pre-create memory-error message */ 131| 561| g->memerrmsg = luaS_newliteral(L, MEMERRMSG); ------------------ | | 30| 561|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 31| 561| (sizeof(s)/sizeof(char))-1)) ------------------ 132| 561| luaC_fix(L, obj2gco(g->memerrmsg)); /* it should never be collected */ ------------------ | | 388| 561|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 113| 561|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 561|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 133| 30.2k| for (i = 0; i < STRCACHE_N; i++) /* fill cache with valid strings */ ------------------ | | 240| 30.2k|#define STRCACHE_N 53 ------------------ | Branch (133:15): [True: 29.7k, False: 561] ------------------ 134| 89.1k| for (j = 0; j < STRCACHE_M; j++) ------------------ | | 241| 89.1k|#define STRCACHE_M 2 ------------------ | Branch (134:17): [True: 59.4k, False: 29.7k] ------------------ 135| 59.4k| g->strcache[i][j] = g->memerrmsg; 136| 561|} luaS_sizelngstr: 139| 163k|size_t luaS_sizelngstr (size_t len, int kind) { 140| 163k| switch (kind) { 141| 163k| case LSTRREG: /* regular long string */ ------------------ | | 397| 163k|#define LSTRREG -1 /* regular long string */ ------------------ | Branch (141:5): [True: 163k, False: 90] ------------------ 142| | /* don't need 'falloc'/'ud', but need space for content */ 143| 163k| return offsetof(TString, falloc) + (len + 1) * sizeof(char); 144| 0| case LSTRFIX: /* fixed external long string */ ------------------ | | 398| 0|#define LSTRFIX -2 /* fixed external long string */ ------------------ | Branch (144:5): [True: 0, False: 163k] ------------------ 145| | /* don't need 'falloc'/'ud' */ 146| 0| return offsetof(TString, falloc); 147| 90| default: /* external long string with deallocation */ ------------------ | Branch (147:5): [True: 90, False: 163k] ------------------ 148| 90| lua_assert(kind == LSTRMEM); ------------------ | | 109| 90|#define lua_assert(c) assert(c) ------------------ 149| 90| return sizeof(TString); 150| 163k| } 151| 163k|} luaS_createlngstrobj: 169| 81.8k|TString *luaS_createlngstrobj (lua_State *L, size_t l) { 170| 81.8k| size_t totalsize = luaS_sizelngstr(l, LSTRREG); ------------------ | | 397| 81.8k|#define LSTRREG -1 /* regular long string */ ------------------ 171| 81.8k| TString *ts = createstrobj(L, totalsize, LUA_VLNGSTR, G(L)->seed); ------------------ | | 374| 81.8k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 81.8k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ TString *ts = createstrobj(L, totalsize, LUA_VLNGSTR, G(L)->seed); ------------------ | | 333| 81.8k|#define G(L) (L->l_G) ------------------ 172| 81.8k| ts->u.lnglen = l; 173| 81.8k| ts->shrlen = LSTRREG; /* signals that it is a regular long string */ ------------------ | | 397| 81.8k|#define LSTRREG -1 /* regular long string */ ------------------ 174| 81.8k| ts->contents = cast_charp(ts) + offsetof(TString, falloc); ------------------ | | 149| 81.8k|#define cast_charp(i) cast(char *, (i)) | | ------------------ | | | | 139| 81.8k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 175| 81.8k| ts->contents[l] = '\0'; /* ending 0 */ 176| 81.8k| return ts; 177| 81.8k|} luaS_remove: 180| 67.6k|void luaS_remove (lua_State *L, TString *ts) { 181| 67.6k| stringtable *tb = &G(L)->strt; ------------------ | | 333| 67.6k|#define G(L) (L->l_G) ------------------ 182| 67.6k| TString **p = &tb->hash[lmod(ts->hash, tb->size)]; ------------------ | | 825| 67.6k| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 113| 67.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 67.6k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 183| 73.2k| while (*p != ts) /* find previous element */ ------------------ | Branch (183:10): [True: 5.60k, False: 67.6k] ------------------ 184| 5.60k| p = &(*p)->u.hnext; 185| 67.6k| *p = (*p)->u.hnext; /* remove element from its list */ 186| 67.6k| tb->nuse--; 187| 67.6k|} luaS_newlstr: 239| 27.0M|TString *luaS_newlstr (lua_State *L, const char *str, size_t l) { 240| 27.0M| if (l <= LUAI_MAXSHORTLEN) /* short string? */ ------------------ | | 219| 27.0M|#define LUAI_MAXSHORTLEN 40 ------------------ | Branch (240:7): [True: 26.9M, False: 81.4k] ------------------ 241| 26.9M| return internshrstr(L, str, l); 242| 81.4k| else { 243| 81.4k| TString *ts; 244| 81.4k| if (l_unlikely(l * sizeof(char) >= (MAX_SIZE - sizeof(TString)))) ------------------ | | 697| 81.4k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 162k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 81.4k] | | | | | Branch (685:46): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 245| 0| luaM_toobig(L); 246| 81.4k| ts = luaS_createlngstrobj(L, l); 247| 81.4k| memcpy(getlngstr(ts), str, l * sizeof(char)); ------------------ | | 429| 81.4k|#define getlngstr(ts) check_exp(!strisshr(ts), (ts)->contents) | | ------------------ | | | | 113| 81.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 81.4k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 248| 0| return ts; 249| 81.4k| } 250| 27.0M|} luaS_new: 259| 27.5k|TString *luaS_new (lua_State *L, const char *str) { 260| 27.5k| unsigned int i = point2uint(str) % STRCACHE_N; /* hash */ ------------------ | | 94| 27.5k|#define point2uint(p) cast_uint((L_P2I)(p) & UINT_MAX) | | ------------------ | | | | 145| 27.5k|#define cast_uint(i) cast(unsigned int, (i)) | | | | ------------------ | | | | | | 139| 27.5k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ unsigned int i = point2uint(str) % STRCACHE_N; /* hash */ ------------------ | | 240| 27.5k|#define STRCACHE_N 53 ------------------ 261| 27.5k| int j; 262| 27.5k| TString **p = G(L)->strcache[i]; ------------------ | | 333| 27.5k|#define G(L) (L->l_G) ------------------ 263| 82.3k| for (j = 0; j < STRCACHE_M; j++) { ------------------ | | 241| 82.3k|#define STRCACHE_M 2 ------------------ | Branch (263:15): [True: 54.9k, False: 27.3k] ------------------ 264| 54.9k| if (strcmp(str, getstr(p[j])) == 0) /* hit? */ ------------------ | | 430| 54.9k|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 54.9k|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 54.9k, False: 0] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 54.9k|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 54.9k|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 54.9k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (264:9): [True: 182, False: 54.7k] ------------------ 265| 182| return p[j]; /* that is it */ 266| 54.9k| } 267| | /* normal route */ 268| 54.7k| for (j = STRCACHE_M - 1; j > 0; j--) ------------------ | | 241| 27.3k|#define STRCACHE_M 2 ------------------ | Branch (268:28): [True: 27.3k, False: 27.3k] ------------------ 269| 27.3k| p[j] = p[j - 1]; /* move out last element */ 270| | /* new element is first in the list */ 271| 27.3k| p[0] = luaS_newlstr(L, str, strlen(str)); 272| 27.3k| return p[0]; 273| 27.5k|} luaS_newudata: 276| 45|Udata *luaS_newudata (lua_State *L, size_t s, int nuvalue) { 277| 45| Udata *u; 278| 45| int i; 279| 45| GCObject *o; 280| 45| if (l_unlikely(s > MAX_SIZE - udatamemoffset(nuvalue))) ------------------ | | 697| 45|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 180|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 45] | | | | | Branch (685:46): [Folded - Ignored] | | | | | Branch (685:46): [True: 45, False: 0] | | | | ------------------ | | ------------------ ------------------ 281| 0| luaM_toobig(L); 282| 45| o = luaC_newobj(L, LUA_VUSERDATA, sizeudata(nuvalue, s)); ------------------ | | 460| 45|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 45|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ o = luaC_newobj(L, LUA_VUSERDATA, sizeudata(nuvalue, s)); ------------------ | | 527| 45|#define sizeudata(nuv,nb) (udatamemoffset(nuv) + (nb)) | | ------------------ | | | | 520| 45| ((nuv) == 0 ? offsetof(Udata0, bindata) \ | | | | ------------------ | | | | | Branch (520:3): [True: 45, False: 0] | | | | ------------------ | | | | 521| 45| : offsetof(Udata, uv) + (sizeof(UValue) * (nuv))) | | ------------------ ------------------ 283| 45| u = gco2u(o); ------------------ | | 373| 45|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 113| 45|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 45|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 284| 0| u->len = s; 285| 45| u->nuvalue = nuvalue; 286| 45| u->metatable = NULL; 287| 45| for (i = 0; i < nuvalue; i++) ------------------ | Branch (287:15): [True: 0, False: 45] ------------------ 288| 45| setnilvalue(&u->uv[i].uv); ------------------ | | 211| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 45|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 289| 45| return u; 290| 45|} luaS_newextlstr: 315| 45| const char *s, size_t len, lua_Alloc falloc, void *ud) { 316| 45| struct NewExt ne; 317| 45| if (len <= LUAI_MAXSHORTLEN) { /* short string? */ ------------------ | | 219| 45|#define LUAI_MAXSHORTLEN 40 ------------------ | Branch (317:7): [True: 0, False: 45] ------------------ 318| 0| ne.s = s; ne.len = len; 319| 0| if (!falloc) ------------------ | Branch (319:9): [True: 0, False: 0] ------------------ 320| 0| f_pintern(L, &ne); /* just internalize string */ 321| 0| else { 322| 0| int status = luaD_rawrunprotected(L, f_pintern, &ne); 323| 0| (*falloc)(ud, cast_voidp(s), len + 1, 0); /* free external string */ ------------------ | | 142| 0|#define cast_voidp(i) cast(void *, (i)) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 324| 0| if (status != LUA_OK) /* memory error? */ ------------------ | | 48| 0|#define LUA_OK 0 ------------------ | Branch (324:11): [True: 0, False: 0] ------------------ 325| 0| luaM_error(L); /* re-raise memory error */ ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 52| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 326| 0| } 327| 0| return ne.ts; 328| 0| } 329| | /* "normal" case: long strings */ 330| 45| if (!falloc) { ------------------ | Branch (330:7): [True: 0, False: 45] ------------------ 331| 0| ne.kind = LSTRFIX; ------------------ | | 398| 0|#define LSTRFIX -2 /* fixed external long string */ ------------------ 332| 0| f_newext(L, &ne); /* just create header */ 333| 0| } 334| 45| else { 335| 45| ne.kind = LSTRMEM; ------------------ | | 399| 45|#define LSTRMEM -3 /* external long string with deallocation */ ------------------ 336| 45| if (luaD_rawrunprotected(L, f_newext, &ne) != LUA_OK) { /* mem. error? */ ------------------ | | 48| 45|#define LUA_OK 0 ------------------ | Branch (336:9): [True: 0, False: 45] ------------------ 337| 0| (*falloc)(ud, cast_voidp(s), len + 1, 0); /* free external string */ ------------------ | | 142| 0|#define cast_voidp(i) cast(void *, (i)) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 338| 0| luaM_error(L); /* re-raise memory error */ ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 52| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 339| 0| } 340| 45| ne.ts->falloc = falloc; 341| 45| ne.ts->ud = ud; 342| 45| } 343| 45| ne.ts->shrlen = ne.kind; 344| 45| ne.ts->u.lnglen = len; 345| 45| ne.ts->contents = cast_charp(s); ------------------ | | 149| 45|#define cast_charp(i) cast(char *, (i)) | | ------------------ | | | | 139| 45|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 346| 45| return ne.ts; 347| 45|} lstring.c:tablerehash: 62| 692|static void tablerehash (TString **vect, int osize, int nsize) { 63| 692| int i; 64| 92.8k| for (i = osize; i < nsize; i++) /* clear new elements */ ------------------ | Branch (64:19): [True: 92.1k, False: 692] ------------------ 65| 92.1k| vect[i] = NULL; 66| 21.0k| for (i = 0; i < osize; i++) { /* rehash old part of the array */ ------------------ | Branch (66:15): [True: 20.3k, False: 692] ------------------ 67| 20.3k| TString *p = vect[i]; 68| 20.3k| vect[i] = NULL; 69| 40.7k| while (p) { /* for each string in the list */ ------------------ | Branch (69:12): [True: 20.3k, False: 20.3k] ------------------ 70| 20.3k| TString *hnext = p->u.hnext; /* save next */ 71| 20.3k| unsigned int h = lmod(p->hash, nsize); /* new position */ ------------------ | | 825| 20.3k| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 113| 20.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 20.3k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 72| 0| p->u.hnext = vect[h]; /* chain it into array */ 73| 20.3k| vect[h] = p; 74| 20.3k| p = hnext; 75| 20.3k| } 76| 20.3k| } 77| 692|} lstring.c:createstrobj: 158| 149k| unsigned h) { 159| 149k| TString *ts; 160| 149k| GCObject *o; 161| 149k| o = luaC_newobj(L, tag, totalsize); 162| 149k| ts = gco2ts(o); ------------------ | | 372| 149k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 113| 149k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 149k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 163| 0| ts->hash = h; 164| 149k| ts->extra = 0; 165| 149k| return ts; 166| 149k|} lstring.c:internshrstr: 204| 26.9M|static TString *internshrstr (lua_State *L, const char *str, size_t l) { 205| 26.9M| TString *ts; 206| 26.9M| global_State *g = G(L); ------------------ | | 333| 26.9M|#define G(L) (L->l_G) ------------------ 207| 26.9M| stringtable *tb = &g->strt; 208| 26.9M| unsigned int h = luaS_hash(str, l, g->seed); 209| 26.9M| TString **list = &tb->hash[lmod(h, tb->size)]; ------------------ | | 825| 26.9M| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 113| 26.9M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 26.9M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 210| 26.9M| lua_assert(str != NULL); /* otherwise 'memcmp'/'memcpy' are undefined */ ------------------ | | 109| 26.9M|#define lua_assert(c) assert(c) ------------------ 211| 34.7M| for (ts = *list; ts != NULL; ts = ts->u.hnext) { ------------------ | Branch (211:20): [True: 34.6M, False: 67.6k] ------------------ 212| 34.6M| if (l == cast_uint(ts->shrlen) && ------------------ | | 145| 34.6M|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 139| 69.2M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (212:9): [True: 26.9M, False: 7.67M] ------------------ 213| 34.6M| (memcmp(str, getshrstr(ts), l * sizeof(char)) == 0)) { ------------------ | | 428| 26.9M|#define getshrstr(ts) check_exp(strisshr(ts), rawgetshrstr(ts)) | | ------------------ | | | | 113| 26.9M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 26.9M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (213:9): [True: 26.8M, False: 78.1k] ------------------ 214| | /* found! */ 215| 26.8M| if (isdead(g, ts)) /* dead (but not collected yet)? */ ------------------ | | 99| 26.8M|#define isdead(g,v) isdeadm(otherwhite(g), (v)->marked) | | ------------------ | | | | 98| 26.8M|#define isdeadm(ow,m) ((m) & (ow)) | | | | ------------------ | | | | | Branch (98:23): [True: 191, False: 26.8M] | | | | ------------------ | | ------------------ ------------------ 216| 191| changewhite(ts); /* resurrect it */ ------------------ | | 101| 191|#define changewhite(x) ((x)->marked ^= WHITEBITS) | | ------------------ | | | | 87| 191|#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) | | | | ------------------ | | | | | | 67| 191|#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 66| 191|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | | | #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 66| 191|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 217| 26.8M| return ts; 218| 26.8M| } 219| 34.6M| } 220| | /* else must create a new string */ 221| 67.6k| if (tb->nuse >= tb->size) { /* need to grow string table? */ ------------------ | Branch (221:7): [True: 131, False: 67.5k] ------------------ 222| 131| growstrtab(L, tb); 223| 131| list = &tb->hash[lmod(h, tb->size)]; /* rehash with new size */ ------------------ | | 825| 131| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 113| 131|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 131|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 224| 131| } 225| 67.6k| ts = createstrobj(L, sizestrshr(l), LUA_VSHRSTR, h); ------------------ | | 27| 67.6k| (offsetof(TString, contents) + ((l) + 1) * sizeof(char)) ------------------ ts = createstrobj(L, sizestrshr(l), LUA_VSHRSTR, h); ------------------ | | 373| 67.6k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 67.6k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 226| 67.6k| ts->shrlen = cast_byte(l); ------------------ | | 146| 67.6k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 139| 67.6k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 227| 67.6k| getshrstr(ts)[l] = '\0'; /* ending 0 */ ------------------ | | 428| 67.6k|#define getshrstr(ts) check_exp(strisshr(ts), rawgetshrstr(ts)) | | ------------------ | | | | 113| 67.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 67.6k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 228| 67.6k| memcpy(getshrstr(ts), str, l * sizeof(char)); ------------------ | | 428| 67.6k|#define getshrstr(ts) check_exp(strisshr(ts), rawgetshrstr(ts)) | | ------------------ | | | | 113| 67.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 67.6k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 229| 0| ts->u.hnext = *list; 230| 67.6k| *list = ts; 231| 67.6k| tb->nuse++; 232| 67.6k| return ts; 233| 67.6k|} lstring.c:growstrtab: 190| 131|static void growstrtab (lua_State *L, stringtable *tb) { 191| 131| if (l_unlikely(tb->nuse == MAX_INT)) { /* too many strings? */ ------------------ | | 697| 131|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 131|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 131] | | | | ------------------ | | ------------------ ------------------ 192| 0| luaC_fullgc(L, 1); /* try to free some... */ 193| 0| if (tb->nuse == MAX_INT) /* still too many? */ ------------------ | | 56| 0|#define MAX_INT INT_MAX /* maximum value of an int */ ------------------ | Branch (193:9): [True: 0, False: 0] ------------------ 194| 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 | | ------------------ ------------------ 195| 0| } 196| 131| if (tb->size <= MAXSTRTB / 2) /* can grow string table? */ ------------------ | | 28| 131|#define MAXSTRTB cast_int(luaM_limitN(MAX_INT, TString*)) | | ------------------ | | | | 144| 131|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 139| 262|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (139:27): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (196:7): [True: 131, False: 0] ------------------ 197| 131| luaS_resize(L, tb->size * 2); 198| 131|} lstring.c:f_newext: 301| 45|static void f_newext (lua_State *L, void *ud) { 302| 45| struct NewExt *ne = cast(struct NewExt *, ud); ------------------ | | 139| 45|#define cast(t, exp) ((t)(exp)) ------------------ 303| 45| size_t size = luaS_sizelngstr(0, ne->kind); 304| 45| ne->ts = createstrobj(L, size, LUA_VLNGSTR, G(L)->seed); ------------------ | | 374| 45|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 45|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ ne->ts = createstrobj(L, size, LUA_VLNGSTR, G(L)->seed); ------------------ | | 333| 45|#define G(L) (L->l_G) ------------------ 305| 45|} luaH_realasize: 281| 1.55M|LUAI_FUNC unsigned int luaH_realasize (const Table *t) { 282| 1.55M| if (limitequalsasize(t)) ------------------ | | 275| 1.55M|#define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 771| 3.10M|#define isrealasize(t) (!((t)->flags & BITRAS)) | | | | ------------------ | | | | | | 770| 1.55M|#define BITRAS (1 << 7) | | | | ------------------ | | | | | Branch (771:25): [True: 1.17M, False: 380k] | | | | ------------------ | | ------------------ | | #define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 69| 380k|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | | | ------------------ | | | | | Branch (69:19): [True: 33.0k, False: 347k] | | | | ------------------ | | ------------------ ------------------ 283| 1.20M| return t->alimit; /* this is the size */ 284| 347k| else { 285| 347k| unsigned int size = t->alimit; 286| | /* compute the smallest power of 2 not smaller than 'size' */ 287| 347k| size |= (size >> 1); 288| 347k| size |= (size >> 2); 289| 347k| size |= (size >> 4); 290| 347k| size |= (size >> 8); 291| 347k|#if (UINT_MAX >> 14) > 3 /* unsigned int has more than 16 bits */ 292| 347k| size |= (size >> 16); 293| |#if (UINT_MAX >> 30) > 3 294| | size |= (size >> 32); /* unsigned int has more than 32 bits */ 295| |#endif 296| 347k|#endif 297| 347k| size++; 298| 347k| lua_assert(ispow2(size) && size/2 < t->alimit && t->alimit < size); ------------------ | | 109| 347k|#define lua_assert(c) assert(c) ------------------ 299| 347k| return size; 300| 347k| } 301| 1.55M|} luaH_resize: 726| 204k| unsigned nhsize) { 727| 204k| Table newt; /* to keep the new hash part */ 728| 204k| unsigned int oldasize = setlimittosize(t); 729| 204k| Value *newarray; 730| 204k| if (newasize > MAXASIZE) ------------------ | | 85| 204k| (((1u << MAXABITS) < MAXASIZEB) ? (1u << MAXABITS) : cast_uint(MAXASIZEB)) | | ------------------ | | | | 70| 204k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | | | ------------------ | | | | | | 144| 204k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 204k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (((1u << MAXABITS) < MAXASIZEB) ? (1u << MAXABITS) : cast_uint(MAXASIZEB)) | | ------------------ | | | | 77| 204k|#define MAXASIZEB (MAX_SIZET/(sizeof(Value) + 1)) | | | | ------------------ | | | | | | 46| 204k|#define MAX_SIZET ((size_t)(~(size_t)0)) | | | | ------------------ | | ------------------ | | (((1u << MAXABITS) < MAXASIZEB) ? (1u << MAXABITS) : cast_uint(MAXASIZEB)) | | ------------------ | | | | 70| 204k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | | | ------------------ | | | | | | 144| 204k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 204k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (((1u << MAXABITS) < MAXASIZEB) ? (1u << MAXABITS) : cast_uint(MAXASIZEB)) | | ------------------ | | | | 145| 0|#define cast_uint(i) cast(unsigned int, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | | Branch (85:6): [Folded - Ignored] | | ------------------ ------------------ | Branch (730:7): [True: 0, False: 204k] ------------------ 731| 0| luaG_runerror(L, "table overflow"); 732| | /* create new hash part with appropriate size into 'newt' */ 733| 204k| newt.flags = 0; 734| 204k| setnodevector(L, &newt, nhsize); 735| 204k| if (newasize < oldasize) { /* will array shrink? */ ------------------ | Branch (735:7): [True: 44.1k, False: 160k] ------------------ 736| | /* re-insert into the new hash the elements from vanishing slice */ 737| 44.1k| exchangehashpart(t, &newt); /* pretend table has new hash */ 738| 44.1k| reinsertOldSlice(L, t, oldasize, newasize); 739| 44.1k| exchangehashpart(t, &newt); /* restore old hash (in case of errors) */ 740| 44.1k| } 741| | /* allocate new array */ 742| 204k| newarray = resizearray(L, t, oldasize, newasize); 743| 204k| if (l_unlikely(newarray == NULL && newasize > 0)) { /* allocation failed? */ ------------------ | | 697| 204k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 207k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 204k] | | | | | Branch (685:46): [True: 2.95k, False: 201k] | | | | | Branch (685:46): [True: 0, False: 2.95k] | | | | ------------------ | | ------------------ ------------------ 744| 0| freehash(L, &newt); /* release new hash part */ 745| 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 | | ------------------ ------------------ 746| 0| } 747| | /* allocation ok; initialize new part of the array */ 748| 204k| exchangehashpart(t, &newt); /* 't' has the new hash ('newt' has the old) */ 749| 204k| t->array = newarray; /* set new array part */ 750| 204k| t->alimit = newasize; 751| 204k| clearNewSlice(t, oldasize, newasize); 752| | /* re-insert elements from old hash part into new parts */ 753| 204k| reinsert(L, &newt, t); /* 'newt' now has the old hash */ 754| 204k| freehash(L, &newt); /* free old hash part */ 755| 204k|} luaH_resizearray: 758| 10.1k|void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize) { 759| 10.1k| int nsize = allocsizenode(t); ------------------ | | 41| 10.1k|#define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 33| 10.1k|#define isdummy(t) ((t)->flags & BITDUMMY) | | | | ------------------ | | | | | | 31| 10.1k|#define BITDUMMY (1 << 6) | | | | ------------------ | | | | | Branch (33:21): [True: 10.1k, False: 0] | | | | ------------------ | | ------------------ | | #define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 829| 0|#define sizenode(t) (twoto((t)->lsizenode)) | | | | ------------------ | | | | | | 828| 0|#define twoto(x) (1<<(x)) | | | | ------------------ | | ------------------ ------------------ 760| 10.1k| luaH_resize(L, t, nasize, nsize); 761| 10.1k|} luaH_new: 794| 125k|Table *luaH_new (lua_State *L) { 795| 125k| GCObject *o = luaC_newobj(L, LUA_VTABLE, sizeof(Table)); ------------------ | | 717| 125k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 125k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 796| 125k| Table *t = gco2t(o); ------------------ | | 378| 125k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 113| 125k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 125k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 797| 0| t->metatable = NULL; 798| 125k| t->flags = cast_byte(maskflags); /* table has no metamethod fields */ ------------------ | | 146| 125k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 139| 125k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 799| 125k| t->array = NULL; 800| 125k| t->alimit = 0; 801| 125k| setnodevector(L, t, 0); 802| 125k| return t; 803| 125k|} luaH_free: 809| 125k|void luaH_free (lua_State *L, Table *t) { 810| 125k| unsigned int realsize = luaH_realasize(t); 811| 125k| freehash(L, t); 812| 125k| resizearray(L, t, realsize, 0); 813| 125k| luaM_free(L, t); ------------------ | | 56| 125k|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 814| 125k|} luaH_getint: 936| 314k|int luaH_getint (Table *t, lua_Integer key, TValue *res) { 937| 314k| if (keyinarray(t, key)) { ------------------ | Branch (937:7): [True: 116k, False: 197k] ------------------ 938| 116k| int tag = *getArrTag(t, key - 1); ------------------ | | 106| 116k|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | ------------------ | | | | 139| 116k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 939| 116k| if (!tagisempty(tag)) ------------------ | | 204| 116k|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 80| 116k|#define novariant(t) ((t) & 0x0F) | | ------------------ | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 64| 116k|#define LUA_TNIL 0 | | ------------------ ------------------ | Branch (939:9): [True: 116k, False: 16] ------------------ 940| 116k| farr2val(t, key, tag, res); ------------------ | | 128| 116k| ((res)->tt_ = tag, (res)->value_ = *getArrVal(h,(k)-1u)) | | ------------------ | | | | 109| 116k|#define getArrVal(t,k) ((t)->array - 1 - (k)) | | ------------------ ------------------ 941| 116k| return tag; 942| 116k| } 943| 197k| else 944| 197k| return finishnodeget(getintfromhash(t, key), res); 945| 314k|} luaH_Hgetshortstr: 951| 58.1M|const TValue *luaH_Hgetshortstr (Table *t, TString *key) { 952| 58.1M| Node *n = hashstr(t, key); ------------------ | | 115| 58.1M|#define hashstr(t,str) hashpow2(t, (str)->hash) | | ------------------ | | | | 106| 58.1M|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 232M|#define gnode(t,i) (&(t)->node[i]) | | | | | | ------------------ | | | | | | | Branch (13:32): [True: 0, False: 58.1M] | | | | | | | Branch (13:32): [True: 58.1M, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 953| 58.1M| lua_assert(key->tt == LUA_VSHRSTR); ------------------ | | 109| 58.1M|#define lua_assert(c) assert(c) ------------------ 954| 70.2M| for (;;) { /* check whether 'key' is somewhere in the chain */ 955| 70.2M| if (keyisshrstr(n) && eqshrstr(keystrval(n), key)) ------------------ | | 797| 140M|#define keyisshrstr(node) (keytt(node) == ctb(LUA_VSHRSTR)) | | ------------------ | | | | 791| 70.2M|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisshrstr(node) (keytt(node) == ctb(LUA_VSHRSTR)) | | ------------------ | | | | 316| 70.2M|#define ctb(t) ((t) | BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 311| 70.2M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | ------------------ | | | Branch (797:27): [True: 64.6M, False: 5.54M] | | ------------------ ------------------ if (keyisshrstr(n) && eqshrstr(keystrval(n), key)) ------------------ | | 43| 64.6M|#define eqshrstr(a,b) check_exp((a)->tt == LUA_VSHRSTR, (a) == (b)) | | ------------------ | | | | 113| 258M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 64.6M|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:25): [True: 56.1M, False: 8.53M] | | | | | Branch (113:42): [True: 0, False: 64.6M] | | | | | Branch (113:42): [True: 64.6M, False: 0] | | | | ------------------ | | ------------------ ------------------ 956| 56.1M| return gval(n); /* that's it */ ------------------ | | 14| 56.1M|#define gval(n) (&(n)->i_val) ------------------ 957| 14.0M| else { 958| 14.0M| int nx = gnext(n); ------------------ | | 15| 14.0M|#define gnext(n) ((n)->u.next) ------------------ 959| 14.0M| if (nx == 0) ------------------ | Branch (959:11): [True: 2.01M, False: 12.0M] ------------------ 960| 2.01M| return &absentkey; /* not found */ 961| 12.0M| n += nx; 962| 12.0M| } 963| 70.2M| } 964| 58.1M|} luaH_getshortstr: 967| 2.23M|int luaH_getshortstr (Table *t, TString *key, TValue *res) { 968| 2.23M| return finishnodeget(luaH_Hgetshortstr(t, key), res); 969| 2.23M|} luaH_getstr: 983| 246|int luaH_getstr (Table *t, TString *key, TValue *res) { 984| 246| return finishnodeget(Hgetstr(t, key), res); 985| 246|} luaH_getstrkey: 988| 26.8M|TString *luaH_getstrkey (Table *t, TString *key) { 989| 26.8M| const TValue *o = Hgetstr(t, key); 990| 26.8M| if (!isabstkey(o)) /* string already present? */ ------------------ | | 214| 26.8M|#define isabstkey(v) checktag((v), LUA_VABSTKEY) | | ------------------ | | | | 91| 26.8M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 26.8M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | ------------------ ------------------ | Branch (990:7): [True: 26.8M, False: 32.1k] ------------------ 991| 26.8M| return keystrval(nodefromval(o)); /* get saved copy */ ------------------ | | 798| 26.8M|#define keystrval(node) (gco2ts(keyval(node).gc)) | | ------------------ | | | | 372| 26.8M| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | | | ------------------ | | | | | | 113| 26.8M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 26.8M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 992| 32.1k| else 993| 32.1k| return NULL; 994| 26.8M|} luaH_get: 1000| 26.8M|int luaH_get (Table *t, const TValue *key, TValue *res) { 1001| 26.8M| const TValue *slot; 1002| 26.8M| switch (ttypetag(key)) { ------------------ | | 84| 26.8M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 26.8M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 1003| 26.3M| case LUA_VSHRSTR: ------------------ | | 373| 26.3M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 26.3M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (1003:5): [True: 26.3M, False: 469k] ------------------ 1004| 26.3M| slot = luaH_Hgetshortstr(t, tsvalue(key)); ------------------ | | 382| 26.3M|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 105M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 26.3M|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 26.3M] | | | | | Branch (113:42): [True: 26.3M, False: 0] | | | | ------------------ | | ------------------ ------------------ 1005| 0| break; 1006| 229k| case LUA_VNUMINT: ------------------ | | 336| 229k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 229k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (1006:5): [True: 229k, False: 26.5M] ------------------ 1007| 229k| return luaH_getint(t, ivalue(key), res); ------------------ | | 346| 229k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 229k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 229k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1008| 30.3k| case LUA_VNIL: ------------------ | | 183| 30.3k|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 30.3k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (1008:5): [True: 30.3k, False: 26.7M] ------------------ 1009| 30.3k| slot = &absentkey; 1010| 30.3k| break; 1011| 127k| case LUA_VNUMFLT: { ------------------ | | 337| 127k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 127k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (1011:5): [True: 127k, False: 26.6M] ------------------ 1012| 127k| lua_Integer k; 1013| 127k| if (luaV_flttointeger(fltvalue(key), &k, F2Ieq)) /* integral index? */ ------------------ | | 345| 127k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 113| 127k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 127k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (1013:11): [True: 8.53k, False: 119k] ------------------ 1014| 8.53k| return luaH_getint(t, k, res); /* use specialized version */ 1015| | /* else... */ 1016| 127k| } /* FALLTHROUGH */ 1017| 201k| default: ------------------ | Branch (1017:5): [True: 81.7k, False: 26.7M] ------------------ 1018| 201k| slot = getgeneric(t, key, 0); 1019| 201k| break; 1020| 26.8M| } 1021| 26.5M| return finishnodeget(slot, res); 1022| 26.8M|} luaH_psetint: 1047| 573k|int luaH_psetint (Table *t, lua_Integer key, TValue *val) { 1048| 573k| if (keyinarray(t, key)) { ------------------ | Branch (1048:7): [True: 10.3k, False: 563k] ------------------ 1049| 10.3k| lu_byte *tag = getArrTag(t, key - 1); ------------------ | | 106| 10.3k|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | ------------------ | | | | 139| 10.3k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1050| 10.3k| if (!tagisempty(*tag) || checknoTM(t->metatable, TM_NEWINDEX)) { ------------------ | | 204| 20.6k|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 80| 10.3k|#define novariant(t) ((t) & 0x0F) | | ------------------ | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 64| 10.3k|#define LUA_TNIL 0 | | ------------------ ------------------ if (!tagisempty(*tag) || checknoTM(t->metatable, TM_NEWINDEX)) { ------------------ | | 63| 1.59k|#define checknoTM(mt,e) ((mt) == NULL || (mt)->flags & (1u<<(e))) | | ------------------ | | | Branch (63:26): [True: 1.59k, False: 0] | | | Branch (63:42): [True: 0, False: 0] | | ------------------ ------------------ | Branch (1050:9): [True: 8.71k, False: 1.59k] ------------------ 1051| 10.3k| fval2arr(t, key, tag, val); ------------------ | | 131| 10.3k| (*tag = (val)->tt_, *getArrVal(h,(k)-1u) = (val)->value_) | | ------------------ | | | | 109| 10.3k|#define getArrVal(t,k) ((t)->array - 1 - (k)) | | ------------------ ------------------ 1052| 10.3k| return HOK; /* success */ ------------------ | | 67| 10.3k|#define HOK 0 ------------------ 1053| 10.3k| } 1054| 0| else 1055| 0| return ~cast_int(key); /* empty slot in the array part */ ------------------ | | 144| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1056| 10.3k| } 1057| 563k| else 1058| 563k| return finishnodeset(t, getintfromhash(t, key), val); 1059| 573k|} luaH_psetshortstr: 1062| 2.75M|int luaH_psetshortstr (Table *t, TString *key, TValue *val) { 1063| 2.75M| return finishnodeset(t, luaH_Hgetshortstr(t, key), val); 1064| 2.75M|} luaH_psetstr: 1067| 180|int luaH_psetstr (Table *t, TString *key, TValue *val) { 1068| 180| return finishnodeset(t, Hgetstr(t, key), val); 1069| 180|} luaH_pset: 1072| 715k|int luaH_pset (Table *t, const TValue *key, TValue *val) { 1073| 715k| switch (ttypetag(key)) { ------------------ | | 84| 715k|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 715k|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 1074| 378k| case LUA_VSHRSTR: return luaH_psetshortstr(t, tsvalue(key), val); ------------------ | | 373| 378k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 378k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VSHRSTR: return luaH_psetshortstr(t, tsvalue(key), val); ------------------ | | 382| 378k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 1.51M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 378k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 378k] | | | | | Branch (113:42): [True: 378k, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (1074:5): [True: 378k, False: 336k] ------------------ 1075| 209k| case LUA_VNUMINT: return luaH_psetint(t, ivalue(key), val); ------------------ | | 336| 209k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 209k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNUMINT: return luaH_psetint(t, ivalue(key), val); ------------------ | | 346| 209k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 209k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 209k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (1075:5): [True: 209k, False: 505k] ------------------ 1076| 0| case LUA_VNIL: return HNOTFOUND; ------------------ | | 183| 0|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: return HNOTFOUND; ------------------ | | 68| 0|#define HNOTFOUND 1 ------------------ | Branch (1076:5): [True: 0, False: 715k] ------------------ 1077| 103k| case LUA_VNUMFLT: { ------------------ | | 337| 103k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 103k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (1077:5): [True: 103k, False: 611k] ------------------ 1078| 103k| lua_Integer k; 1079| 103k| if (luaV_flttointeger(fltvalue(key), &k, F2Ieq)) /* integral index? */ ------------------ | | 345| 103k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 113| 103k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 103k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (1079:11): [True: 49.4k, False: 54.1k] ------------------ 1080| 49.4k| return luaH_psetint(t, k, val); /* use specialized version */ 1081| | /* else... */ 1082| 103k| } /* FALLTHROUGH */ 1083| 77.3k| default: ------------------ | Branch (1083:5): [True: 23.1k, False: 691k] ------------------ 1084| 77.3k| return finishnodeset(t, getgeneric(t, key, 0), val); 1085| 715k| } 1086| 715k|} luaH_finishset: 1097| 1.23M| TValue *value, int hres) { 1098| 1.23M| lua_assert(hres != HOK); ------------------ | | 109| 1.23M|#define lua_assert(c) assert(c) ------------------ 1099| 1.23M| if (hres == HNOTFOUND) { ------------------ | | 68| 1.23M|#define HNOTFOUND 1 ------------------ | Branch (1099:7): [True: 1.10M, False: 133k] ------------------ 1100| 1.10M| luaH_newkey(L, t, key, value); 1101| 1.10M| } 1102| 133k| else if (hres > 0) { /* regular Node? */ ------------------ | Branch (1102:12): [True: 104k, False: 28.8k] ------------------ 1103| 104k| setobj2t(L, gval(gnode(t, hres - HFIRSTNODE)), value); ------------------ | | 137| 104k|#define setobj2t setobj | | ------------------ | | | | 119| 104k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 104k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 104k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 104k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 104k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 242k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 104k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 9.24k] | | | | | | | | | Branch (115:29): [True: 9.24k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 9.24k] | | | | | | | | | Branch (115:29): [True: 9.24k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 9.24k] | | | | | | | | | Branch (115:29): [True: 9.24k, False: 0] | | | | | | | | | Branch (115:29): [True: 9.24k, False: 0] | | | | | | | | | Branch (115:29): [True: 94.9k, False: 9.24k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 104k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 104k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1104| 104k| } 1105| 28.8k| else { /* array entry */ 1106| 28.8k| hres = ~hres; /* real index */ 1107| 28.8k| obj2arr(t, hres, value); ------------------ | | 119| 28.8k| (*getArrTag(h,(k)-1u) = (val)->tt_, *getArrVal(h,(k)-1u) = (val)->value_) | | ------------------ | | | | 106| 28.8k|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | | | ------------------ | | | | | | 139| 28.8k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | (*getArrTag(h,(k)-1u) = (val)->tt_, *getArrVal(h,(k)-1u) = (val)->value_) | | ------------------ | | | | 109| 28.8k|#define getArrVal(t,k) ((t)->array - 1 - (k)) | | ------------------ ------------------ 1108| 28.8k| } 1109| 1.23M|} luaH_set: 1116| 662k|void luaH_set (lua_State *L, Table *t, const TValue *key, TValue *value) { 1117| 662k| int hres = luaH_pset(t, key, value); 1118| 662k| if (hres != HOK) ------------------ | | 67| 662k|#define HOK 0 ------------------ | Branch (1118:7): [True: 508k, False: 153k] ------------------ 1119| 508k| luaH_finishset(L, t, key, value, hres); 1120| 662k|} luaH_setint: 1127| 1.72k|void luaH_setint (lua_State *L, Table *t, lua_Integer key, TValue *value) { 1128| 1.72k| if (keyinarray(t, key)) ------------------ | Branch (1128:7): [True: 1.68k, False: 42] ------------------ 1129| 1.68k| obj2arr(t, key, value); ------------------ | | 119| 1.68k| (*getArrTag(h,(k)-1u) = (val)->tt_, *getArrVal(h,(k)-1u) = (val)->value_) | | ------------------ | | | | 106| 1.68k|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | | | ------------------ | | | | | | 139| 1.68k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | (*getArrTag(h,(k)-1u) = (val)->tt_, *getArrVal(h,(k)-1u) = (val)->value_) | | ------------------ | | | | 109| 1.68k|#define getArrVal(t,k) ((t)->array - 1 - (k)) | | ------------------ ------------------ 1130| 42| else { 1131| 42| int ok = rawfinishnodeset(getintfromhash(t, key), value); 1132| 42| if (!ok) { ------------------ | Branch (1132:9): [True: 42, False: 0] ------------------ 1133| 42| TValue k; 1134| 42| setivalue(&k, key); ------------------ | | 358| 42| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 42|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 42|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1135| 42| luaH_newkey(L, t, &k, value); 1136| 42| } 1137| 42| } 1138| 1.72k|} luaH_getn: 1221| 187k|lua_Unsigned luaH_getn (Table *t) { 1222| 187k| unsigned int limit = t->alimit; 1223| 187k| if (limit > 0 && arraykeyisempty(t, limit)) { /* (1)? */ ------------------ | Branch (1223:7): [True: 151k, False: 36.6k] | Branch (1223:20): [True: 100k, False: 50.7k] ------------------ 1224| | /* there must be a boundary before 'limit' */ 1225| 100k| if (limit >= 2 && !arraykeyisempty(t, limit - 1)) { ------------------ | Branch (1225:9): [True: 100k, False: 0] | Branch (1225:23): [True: 85.2k, False: 15.2k] ------------------ 1226| | /* 'limit - 1' is a boundary; can it be a new limit? */ 1227| 85.2k| if (ispow2realasize(t) && !ispow2(limit - 1)) { ------------------ | | 69| 85.1k|#define ispow2(x) (((x) & ((x) - 1)) == 0) ------------------ | Branch (1227:11): [True: 85.1k, False: 26] | Branch (1227:33): [True: 85.1k, False: 0] ------------------ 1228| 85.1k| t->alimit = limit - 1; 1229| 85.1k| setnorealasize(t); /* now 'alimit' is not the real size */ ------------------ | | 773| 85.1k|#define setnorealasize(t) ((t)->flags |= BITRAS) | | ------------------ | | | | 770| 85.1k|#define BITRAS (1 << 7) | | ------------------ ------------------ 1230| 85.1k| } 1231| 85.2k| return limit - 1; 1232| 85.2k| } 1233| 15.2k| else { /* must search for a boundary in [0, limit] */ 1234| 15.2k| unsigned int boundary = binsearch(t, 0, limit); 1235| | /* can this boundary represent the real size of the array? */ 1236| 15.2k| if (ispow2realasize(t) && boundary > luaH_realasize(t) / 2) { ------------------ | Branch (1236:11): [True: 1.86k, False: 13.4k] | Branch (1236:33): [True: 19, False: 1.84k] ------------------ 1237| 19| t->alimit = boundary; /* use it as the new limit */ 1238| 19| setnorealasize(t); ------------------ | | 773| 19|#define setnorealasize(t) ((t)->flags |= BITRAS) | | ------------------ | | | | 770| 19|#define BITRAS (1 << 7) | | ------------------ ------------------ 1239| 19| } 1240| 15.2k| return boundary; 1241| 15.2k| } 1242| 100k| } 1243| | /* 'limit' is zero or present in table */ 1244| 87.4k| if (!limitequalsasize(t)) { /* (2)? */ ------------------ | | 275| 87.4k|#define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 771| 174k|#define isrealasize(t) (!((t)->flags & BITRAS)) | | | | ------------------ | | | | | | 770| 87.4k|#define BITRAS (1 << 7) | | | | ------------------ | | | | | Branch (771:25): [True: 37.2k, False: 50.1k] | | | | ------------------ | | ------------------ | | #define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 69| 50.1k|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | | | ------------------ | | | | | Branch (69:19): [True: 1.90k, False: 48.2k] | | | | ------------------ | | ------------------ ------------------ 1245| | /* 'limit' > 0 and array has more elements after 'limit' */ 1246| 48.2k| if (arraykeyisempty(t, limit + 1)) /* 'limit + 1' is empty? */ ------------------ | Branch (1246:9): [True: 48.2k, False: 0] ------------------ 1247| 48.2k| return limit; /* this is the boundary */ 1248| | /* else, try last element in the array */ 1249| 0| limit = luaH_realasize(t); 1250| 0| if (arraykeyisempty(t, limit)) { /* empty? */ ------------------ | Branch (1250:9): [True: 0, False: 0] ------------------ 1251| | /* there must be a boundary in the array after old limit, 1252| | and it must be a valid new limit */ 1253| 0| unsigned int boundary = binsearch(t, t->alimit, limit); 1254| 0| t->alimit = boundary; 1255| 0| return boundary; 1256| 0| } 1257| | /* else, new limit is present in the table; check the hash part */ 1258| 0| } 1259| | /* (3) 'limit' is the last element and either is zero or present in table */ 1260| 39.1k| lua_assert(limit == luaH_realasize(t) && ------------------ | | 109| 39.1k|#define lua_assert(c) assert(c) ------------------ 1261| 39.1k| (limit == 0 || !arraykeyisempty(t, limit))); 1262| 39.1k| if (isdummy(t) || hashkeyisempty(t, cast(lua_Integer, limit + 1))) ------------------ | | 33| 78.2k|#define isdummy(t) ((t)->flags & BITDUMMY) | | ------------------ | | | | 31| 39.1k|#define BITDUMMY (1 << 6) | | ------------------ | | | Branch (33:21): [True: 36.5k, False: 2.62k] | | ------------------ ------------------ if (isdummy(t) || hashkeyisempty(t, cast(lua_Integer, limit + 1))) ------------------ | | 139| 2.62k|#define cast(t, exp) ((t)(exp)) ------------------ | Branch (1262:21): [True: 624, False: 1.99k] ------------------ 1263| 37.1k| return limit; /* 'limit + 1' is absent */ 1264| 1.99k| else /* 'limit + 1' is also present */ 1265| 1.99k| return hash_search(t, limit); 1266| 39.1k|} ltable.c:arrayindex: 349| 200k|static unsigned int arrayindex (lua_Integer k) { 350| 200k| if (l_castS2U(k) - 1u < MAXASIZE) /* 'k' in [1, MAXASIZE]? */ ------------------ | | 155| 200k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ if (l_castS2U(k) - 1u < MAXASIZE) /* 'k' in [1, MAXASIZE]? */ ------------------ | | 85| 200k| (((1u << MAXABITS) < MAXASIZEB) ? (1u << MAXABITS) : cast_uint(MAXASIZEB)) | | ------------------ | | | | 70| 200k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | | | ------------------ | | | | | | 144| 200k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 200k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (((1u << MAXABITS) < MAXASIZEB) ? (1u << MAXABITS) : cast_uint(MAXASIZEB)) | | ------------------ | | | | 77| 200k|#define MAXASIZEB (MAX_SIZET/(sizeof(Value) + 1)) | | | | ------------------ | | | | | | 46| 200k|#define MAX_SIZET ((size_t)(~(size_t)0)) | | | | ------------------ | | ------------------ | | (((1u << MAXABITS) < MAXASIZEB) ? (1u << MAXABITS) : cast_uint(MAXASIZEB)) | | ------------------ | | | | 70| 200k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | | | ------------------ | | | | | | 144| 200k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 200k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (((1u << MAXABITS) < MAXASIZEB) ? (1u << MAXABITS) : cast_uint(MAXASIZEB)) | | ------------------ | | | | 145| 0|#define cast_uint(i) cast(unsigned int, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | | Branch (85:6): [Folded - Ignored] | | ------------------ ------------------ | Branch (350:7): [True: 154k, False: 46.1k] ------------------ 351| 154k| return cast_uint(k); /* 'key' is an appropriate array index */ ------------------ | | 145| 154k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 139| 154k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 352| 46.1k| else 353| 46.1k| return 0; 354| 200k|} ltable.c:setlimittosize: 314| 353k|static unsigned int setlimittosize (Table *t) { 315| 353k| t->alimit = luaH_realasize(t); 316| 353k| setrealasize(t); ------------------ | | 772| 353k|#define setrealasize(t) ((t)->flags &= cast_byte(~BITRAS)) | | ------------------ | | | | 146| 353k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 353k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 317| 353k| return t->alimit; 318| 353k|} ltable.c:setnodevector: 613| 330k|static void setnodevector (lua_State *L, Table *t, unsigned size) { 614| 330k| if (size == 0) { /* no elements to hash part? */ ------------------ | Branch (614:7): [True: 180k, False: 149k] ------------------ 615| 180k| t->node = cast(Node *, dummynode); /* use common 'dummynode' */ ------------------ | | 139| 180k|#define cast(t, exp) ((t)(exp)) ------------------ 616| 180k| t->lsizenode = 0; 617| 180k| setdummy(t); /* signal that it is using dummy node */ ------------------ | | 36| 180k|#define setdummy(t) ((t)->flags |= BITDUMMY) | | ------------------ | | | | 31| 180k|#define BITDUMMY (1 << 6) | | ------------------ ------------------ 618| 180k| } 619| 149k| else { 620| 149k| int i; 621| 149k| int lsize = luaO_ceillog2(size); 622| 149k| if (lsize > MAXHBITS || (1u << lsize) > MAXHSIZE) ------------------ | | 91| 298k|#define MAXHBITS (MAXABITS - 1) | | ------------------ | | | | 70| 149k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | | | ------------------ | | | | | | 144| 149k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 149k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (lsize > MAXHBITS || (1u << lsize) > MAXHSIZE) ------------------ | | 99| 149k|#define MAXHSIZE luaM_limitN(1u << MAXHBITS, Node) | | ------------------ | | | | 45| 149k| ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 150| 149k|#define cast_sizet(i) cast(size_t, (i)) | | | | | | ------------------ | | | | | | | | 139| 149k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 46| 149k|#define MAX_SIZET ((size_t)(~(size_t)0)) | | | | ------------------ | | | | | Branch (45:4): [Folded - Ignored] | | | | ------------------ | | | | 46| 149k| cast_uint((MAX_SIZET/sizeof(t)))) | | | | ------------------ | | | | | | 145| 0|#define cast_uint(i) cast(unsigned int, (i)) | | | | | | ------------------ | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (622:9): [True: 0, False: 149k] | Branch (622:29): [True: 0, False: 149k] ------------------ 623| 0| luaG_runerror(L, "table overflow"); 624| 149k| size = twoto(lsize); ------------------ | | 828| 149k|#define twoto(x) (1<<(x)) ------------------ 625| 149k| if (lsize <= LIMFORLAST) /* no 'lastfree' field? */ ------------------ | | 49| 149k|#define LIMFORLAST 2 /* log2 of real limit */ ------------------ | Branch (625:9): [True: 119k, False: 30.3k] ------------------ 626| 119k| t->node = luaM_newvector(L, size, Node); ------------------ | | 60| 119k|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 139| 119k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 627| 30.3k| else { 628| 30.3k| size_t bsize = size * sizeof(Node) + sizeof(Limbox); 629| 30.3k| char *node = luaM_newblock(L, bsize); ------------------ | | 66| 30.3k|#define luaM_newblock(L, size) luaM_newvector(L, size, char) | | ------------------ | | | | 60| 30.3k|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | | | ------------------ | | | | | | 139| 30.3k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 630| 30.3k| t->node = cast(Node *, node + sizeof(Limbox)); ------------------ | | 139| 30.3k|#define cast(t, exp) ((t)(exp)) ------------------ 631| 30.3k| getlastfree(t) = gnode(t, size); /* all positions are free */ ------------------ | | 63| 30.3k|#define getlastfree(t) ((cast(Limbox *, (t)->node) - 1)->lastfree) | | ------------------ | | | | 139| 30.3k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ getlastfree(t) = gnode(t, size); /* all positions are free */ ------------------ | | 13| 30.3k|#define gnode(t,i) (&(t)->node[i]) ------------------ 632| 30.3k| } 633| 149k| t->lsizenode = cast_byte(lsize); ------------------ | | 146| 149k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 139| 149k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 634| 149k| setnodummy(t); ------------------ | | 35| 149k|#define setnodummy(t) ((t)->flags &= NOTBITDUMMY) | | ------------------ | | | | 32| 149k|#define NOTBITDUMMY cast_byte(~BITDUMMY) | | | | ------------------ | | | | | | 146| 149k|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 139| 149k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 635| 807k| for (i = 0; i < cast_int(size); i++) { ------------------ | | 144| 807k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 807k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (635:17): [True: 658k, False: 149k] ------------------ 636| 658k| Node *n = gnode(t, i); ------------------ | | 13| 658k|#define gnode(t,i) (&(t)->node[i]) ------------------ 637| 658k| gnext(n) = 0; ------------------ | | 15| 658k|#define gnext(n) ((n)->u.next) ------------------ 638| 658k| setnilkey(n); ------------------ | | 800| 658k|#define setnilkey(node) (keytt(node) = LUA_TNIL) | | ------------------ | | | | 791| 658k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define setnilkey(node) (keytt(node) = LUA_TNIL) | | ------------------ | | | | 64| 658k|#define LUA_TNIL 0 | | ------------------ ------------------ 639| 658k| setempty(gval(n)); ------------------ | | 236| 658k|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 658k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 640| 658k| } 641| 149k| } 642| 330k|} ltable.c:exchangehashpart: 670| 292k|static void exchangehashpart (Table *t1, Table *t2) { 671| 292k| lu_byte lsizenode = t1->lsizenode; 672| 292k| Node *node = t1->node; 673| 292k| int bitdummy1 = t1->flags & BITDUMMY; ------------------ | | 31| 292k|#define BITDUMMY (1 << 6) ------------------ 674| 292k| t1->lsizenode = t2->lsizenode; 675| 292k| t1->node = t2->node; 676| 292k| t1->flags = (t1->flags & NOTBITDUMMY) | (t2->flags & BITDUMMY); ------------------ | | 32| 292k|#define NOTBITDUMMY cast_byte(~BITDUMMY) | | ------------------ | | | | 146| 292k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 292k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ t1->flags = (t1->flags & NOTBITDUMMY) | (t2->flags & BITDUMMY); ------------------ | | 31| 292k|#define BITDUMMY (1 << 6) ------------------ 677| 292k| t2->lsizenode = lsizenode; 678| 292k| t2->node = node; 679| 292k| t2->flags = (t2->flags & NOTBITDUMMY) | bitdummy1; ------------------ | | 32| 292k|#define NOTBITDUMMY cast_byte(~BITDUMMY) | | ------------------ | | | | 146| 292k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 139| 292k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 680| 292k|} ltable.c:reinsertOldSlice: 688| 44.1k| unsigned newasize) { 689| 44.1k| unsigned i; 690| 44.1k| t->alimit = newasize; /* pretend array has new size... */ 691| 88.3k| for (i = newasize; i < oldasize; i++) { /* traverse vanishing slice */ ------------------ | Branch (691:22): [True: 44.1k, False: 44.1k] ------------------ 692| 44.1k| int tag = *getArrTag(t, i); ------------------ | | 106| 44.1k|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | ------------------ | | | | 139| 44.1k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 693| 44.1k| if (!tagisempty(tag)) { /* a non-empty entry? */ ------------------ | | 204| 44.1k|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 80| 44.1k|#define novariant(t) ((t) & 0x0F) | | ------------------ | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 64| 44.1k|#define LUA_TNIL 0 | | ------------------ ------------------ | Branch (693:9): [True: 42, False: 44.1k] ------------------ 694| 42| TValue aux; 695| 42| farr2val(t, i + 1, tag, &aux); /* copy entry into 'aux' */ ------------------ | | 128| 42| ((res)->tt_ = tag, (res)->value_ = *getArrVal(h,(k)-1u)) | | ------------------ | | | | 109| 42|#define getArrVal(t,k) ((t)->array - 1 - (k)) | | ------------------ ------------------ 696| 42| luaH_setint(L, t, i + 1, &aux); /* re-insert it into the table */ 697| 42| } 698| 44.1k| } 699| 44.1k| t->alimit = oldasize; /* restore current size... */ 700| 44.1k|} ltable.c:resizearray: 577| 330k| unsigned newasize) { 578| 330k| if (oldasize == newasize) ------------------ | Branch (578:7): [True: 175k, False: 154k] ------------------ 579| 175k| return t->array; /* nothing to be done */ 580| 154k| else if (newasize == 0) { /* erasing array? */ ------------------ | Branch (580:12): [True: 55.1k, False: 99.5k] ------------------ 581| 55.1k| Value *op = t->array - oldasize; /* original array's real address */ 582| 55.1k| luaM_freemem(L, op, concretesize(oldasize)); /* free it */ ------------------ | | 55| 55.1k|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 583| 55.1k| return NULL; 584| 55.1k| } 585| 99.5k| else { 586| 99.5k| size_t newasizeb = concretesize(newasize); 587| 99.5k| Value *np = cast(Value *, ------------------ | | 139| 99.5k|#define cast(t, exp) ((t)(exp)) ------------------ 588| 99.5k| luaM_reallocvector(L, NULL, 0, newasizeb, lu_byte)); 589| 99.5k| if (np == NULL) /* allocation error? */ ------------------ | Branch (589:9): [True: 0, False: 99.5k] ------------------ 590| 0| return NULL; 591| 99.5k| if (oldasize > 0) { ------------------ | Branch (591:9): [True: 44.3k, False: 55.1k] ------------------ 592| 44.3k| Value *op = t->array - oldasize; /* real original array */ 593| 44.3k| unsigned tomove = (oldasize < newasize) ? oldasize : newasize; ------------------ | Branch (593:25): [True: 159, False: 44.1k] ------------------ 594| 44.3k| lua_assert(tomove > 0); ------------------ | | 109| 44.3k|#define lua_assert(c) assert(c) ------------------ 595| | /* move common elements to new position */ 596| 44.3k| memcpy(np + newasize - tomove, 597| 44.3k| op + oldasize - tomove, 598| 44.3k| concretesize(tomove)); 599| 44.3k| luaM_freemem(L, op, concretesize(oldasize)); ------------------ | | 55| 44.3k|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 600| 44.3k| } 601| 99.5k| return np + newasize; /* shift pointer to the end of value segment */ 602| 99.5k| } 603| 330k|} ltable.c:concretesize: 558| 243k|static size_t concretesize (unsigned int size) { 559| 243k| return size * sizeof(Value) + size; /* space for the two arrays */ 560| 243k|} ltable.c:freehash: 403| 330k|static void freehash (lua_State *L, Table *t) { 404| 330k| if (!isdummy(t)) { ------------------ | | 33| 330k|#define isdummy(t) ((t)->flags & BITDUMMY) | | ------------------ | | | | 31| 330k|#define BITDUMMY (1 << 6) | | ------------------ ------------------ | Branch (404:7): [True: 149k, False: 180k] ------------------ 405| 149k| size_t bsize = sizenode(t) * sizeof(Node); /* 'node' size in bytes */ ------------------ | | 829| 149k|#define sizenode(t) (twoto((t)->lsizenode)) | | ------------------ | | | | 828| 149k|#define twoto(x) (1<<(x)) | | ------------------ ------------------ 406| 149k| char *arr = cast_charp(t->node); ------------------ | | 149| 149k|#define cast_charp(i) cast(char *, (i)) | | ------------------ | | | | 139| 149k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 407| 149k| if (haslastfree(t)) { ------------------ | | 62| 149k|#define haslastfree(t) ((t)->lsizenode > LIMFORLAST) | | ------------------ | | | | 49| 149k|#define LIMFORLAST 2 /* log2 of real limit */ | | ------------------ | | | Branch (62:28): [True: 30.3k, False: 119k] | | ------------------ ------------------ 408| 30.3k| bsize += sizeof(Limbox); 409| 30.3k| arr -= sizeof(Limbox); 410| 30.3k| } 411| 149k| luaM_freearray(L, arr, bsize); ------------------ | | 57| 149k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 412| 149k| } 413| 330k|} ltable.c:clearNewSlice: 706| 204k|static void clearNewSlice (Table *t, unsigned oldasize, unsigned newasize) { 707| 2.11M| for (; oldasize < newasize; oldasize++) ------------------ | Branch (707:10): [True: 1.90M, False: 204k] ------------------ 708| 1.90M| *getArrTag(t, oldasize) = LUA_VEMPTY; ------------------ | | 106| 1.90M|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | ------------------ | | | | 139| 1.90M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ *getArrTag(t, oldasize) = LUA_VEMPTY; ------------------ | | 186| 1.90M|#define LUA_VEMPTY makevariant(LUA_TNIL, 1) | | ------------------ | | | | 42| 1.90M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 709| 204k|} ltable.c:reinsert: 648| 204k|static void reinsert (lua_State *L, Table *ot, Table *t) { 649| 204k| int j; 650| 204k| int size = sizenode(ot); ------------------ | | 829| 204k|#define sizenode(t) (twoto((t)->lsizenode)) | | ------------------ | | | | 828| 204k|#define twoto(x) (1<<(x)) | | ------------------ ------------------ 651| 622k| for (j = 0; j < size; j++) { ------------------ | Branch (651:15): [True: 418k, False: 204k] ------------------ 652| 418k| Node *old = gnode(ot, j); ------------------ | | 13| 418k|#define gnode(t,i) (&(t)->node[i]) ------------------ 653| 418k| if (!isempty(gval(old))) { ------------------ | | 228| 418k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 196| 418k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 418k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 418k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 418k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (653:9): [True: 318k, False: 99.7k] ------------------ 654| | /* doesn't need barrier/invalidate cache, as entry was 655| | already present in the table */ 656| 318k| TValue k; 657| 318k| getnodekey(L, &k, old); ------------------ | | 758| 318k| { TValue *io_=(obj); const Node *n_=(node); \ | | 759| 318k| io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \ | | 760| 318k| checkliveness(L,io_); } | | ------------------ | | | | 107| 318k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 2.92M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 318k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 173k] | | | | | | | Branch (115:29): [True: 173k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 173k] | | | | | | | Branch (115:29): [True: 173k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 173k] | | | | | | | Branch (115:29): [True: 173k, False: 0] | | | | | | | Branch (115:29): [True: 173k, False: 0] | | | | | | | Branch (115:29): [True: 144k, False: 173k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 318k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 658| 318k| luaH_set(L, t, &k, gval(old)); ------------------ | | 14| 318k|#define gval(n) (&(n)->i_val) ------------------ 659| 318k| } 660| 418k| } 661| 204k|} ltable.c:keyinarray: 438| 889k|static int keyinarray (Table *t, lua_Integer key) { 439| 889k| lua_Unsigned alimit = t->alimit; 440| 889k| if (l_castS2U(key) - 1u < alimit) /* 'key' in [1, t->alimit]? */ ------------------ | | 155| 889k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (440:7): [True: 127k, False: 761k] ------------------ 441| 127k| return 1; 442| 761k| else if (!isrealasize(t) && /* key still may be in the array part? */ ------------------ | | 771| 1.52M|#define isrealasize(t) (!((t)->flags & BITRAS)) | | ------------------ | | | | 770| 761k|#define BITRAS (1 << 7) | | ------------------ ------------------ | Branch (442:12): [True: 137k, False: 624k] ------------------ 443| 761k| (((l_castS2U(key) - 1u) & ~(alimit - 1u)) < alimit)) { ------------------ | | 155| 137k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (443:12): [True: 547, False: 136k] ------------------ 444| 547| t->alimit = cast_uint(key); /* probably '#t' is here now */ ------------------ | | 145| 547|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 139| 547|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 445| 547| return 1; 446| 547| } 447| 761k| else 448| 761k| return 0; 449| 889k|} ltable.c:finishnodeget: 928| 29.0M|static int finishnodeget (const TValue *val, TValue *res) { 929| 29.0M| if (!ttisnil(val)) { ------------------ | | 196| 29.0M|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 29.0M|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 29.0M|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 29.0M|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (929:7): [True: 27.7M, False: 1.24M] ------------------ 930| 27.7M| setobj(((lua_State*)NULL), res, val); ------------------ | | 119| 27.7M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 27.7M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 27.7M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 27.7M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 27.7M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 28.4M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 27.7M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 79.3k] | | | | | | | Branch (115:29): [True: 79.3k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [Folded - Ignored] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 79.3k, False: 0] | | | | | | | Branch (115:29): [True: 27.6M, False: 79.3k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 27.7M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 109| 27.7M|#define lua_assert(c) assert(c) | | ------------------ ------------------ 931| 27.7M| } 932| 29.0M| return ttypetag(val); ------------------ | | 84| 29.0M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 29.0M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 933| 29.0M|} ltable.c:getintfromhash: 906| 776k|static const TValue *getintfromhash (Table *t, lua_Integer key) { 907| 776k| Node *n = hashint(t, key); 908| 776k| lua_assert(l_castS2U(key) - 1u >= luaH_realasize(t)); ------------------ | | 109| 776k|#define lua_assert(c) assert(c) ------------------ 909| 961k| for (;;) { /* check whether 'key' is somewhere in the chain */ 910| 961k| if (keyisinteger(n) && keyival(n) == key) ------------------ | | 795| 1.92M|#define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 791| 961k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 336| 961k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | | | ------------------ | | | | | | 42| 961k|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (795:28): [True: 641k, False: 319k] | | ------------------ ------------------ if (keyisinteger(n) && keyival(n) == key) ------------------ | | 796| 641k|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 792| 641k|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ | Branch (910:28): [True: 475k, False: 165k] ------------------ 911| 475k| return gval(n); /* that's it */ ------------------ | | 14| 475k|#define gval(n) (&(n)->i_val) ------------------ 912| 485k| else { 913| 485k| int nx = gnext(n); ------------------ | | 15| 485k|#define gnext(n) ((n)->u.next) ------------------ 914| 485k| if (nx == 0) break; ------------------ | Branch (914:11): [True: 300k, False: 184k] ------------------ 915| 184k| n += nx; 916| 184k| } 917| 961k| } 918| 300k| return &absentkey; 919| 776k|} ltable.c:hashint: 139| 1.14M|static Node *hashint (const Table *t, lua_Integer i) { 140| 1.14M| lua_Unsigned ui = l_castS2U(i); ------------------ | | 155| 1.14M|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 141| 1.14M| if (ui <= cast_uint(INT_MAX)) ------------------ | | 145| 1.14M|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 139| 1.14M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (141:7): [True: 751k, False: 394k] ------------------ 142| 751k| return hashmod(t, cast_int(ui)); ------------------ | | 112| 751k|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | ------------------ | | | | 13| 751k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 143| 394k| else 144| 394k| return hashmod(t, ui); ------------------ | | 112| 394k|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | ------------------ | | | | 13| 394k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 145| 1.14M|} ltable.c:Hgetstr: 972| 26.8M|static const TValue *Hgetstr (Table *t, TString *key) { 973| 26.8M| if (key->tt == LUA_VSHRSTR) ------------------ | | 373| 26.8M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 26.8M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (973:7): [True: 26.8M, False: 80.3k] ------------------ 974| 26.8M| return luaH_Hgetshortstr(t, key); 975| 80.3k| else { /* for long strings, use generic case */ 976| 80.3k| TValue ko; 977| 80.3k| setsvalue(cast(lua_State *, NULL), &ko, key); ------------------ | | 385| 80.3k| { TValue *io = (obj); TString *x_ = (x); \ | | 386| 80.3k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 80.3k|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 388| 80.3k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 80.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 80.3k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 80.3k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 387| 80.3k| checkliveness(L,io); } | | ------------------ | | | | 107| 80.3k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 803k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 80.3k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 80.3k] | | | | | | | Branch (115:29): [True: 80.3k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [Folded - Ignored] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 80.3k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 80.3k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 80.3k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 978| 80.3k| return getgeneric(t, &ko, 0); 979| 80.3k| } 980| 26.8M|} ltable.c:getgeneric: 330| 358k|static const TValue *getgeneric (Table *t, const TValue *key, int deadok) { 331| 358k| Node *n = mainpositionTV(t, key); 332| 512k| for (;;) { /* check whether 'key' is somewhere in the chain */ 333| 512k| if (equalkey(key, n, deadok)) ------------------ | Branch (333:9): [True: 320k, False: 191k] ------------------ 334| 320k| return gval(n); /* that's it */ ------------------ | | 14| 320k|#define gval(n) (&(n)->i_val) ------------------ 335| 191k| else { 336| 191k| int nx = gnext(n); ------------------ | | 15| 191k|#define gnext(n) ((n)->u.next) ------------------ 337| 191k| if (nx == 0) ------------------ | Branch (337:11): [True: 38.1k, False: 153k] ------------------ 338| 38.1k| return &absentkey; /* not found */ 339| 153k| n += nx; 340| 153k| } 341| 512k| } 342| 358k|} ltable.c:mainpositionTV: 182| 1.31M|static Node *mainpositionTV (const Table *t, const TValue *key) { 183| 1.31M| switch (ttypetag(key)) { ------------------ | | 84| 1.31M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 1.31M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 184| 370k| case LUA_VNUMINT: { ------------------ | | 336| 370k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 370k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (184:5): [True: 370k, False: 948k] ------------------ 185| 370k| lua_Integer i = ivalue(key); ------------------ | | 346| 370k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 370k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 370k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 186| 0| return hashint(t, i); 187| 370k| } 188| 192k| case LUA_VNUMFLT: { ------------------ | | 337| 192k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 192k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (188:5): [True: 192k, False: 1.12M] ------------------ 189| 192k| lua_Number n = fltvalue(key); ------------------ | | 345| 192k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 113| 192k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 192k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 190| 192k| return hashmod(t, l_hashfloat(n)); ------------------ | | 112| 192k|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | ------------------ | | | | 13| 192k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 191| 192k| } 192| 549k| case LUA_VSHRSTR: { ------------------ | | 373| 549k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 549k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (192:5): [True: 549k, False: 769k] ------------------ 193| 1.09M| TString *ts = tsvalue(key); ------------------ | | 382| 549k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 2.19M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 549k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 549k] | | | | | Branch (113:42): [True: 549k, False: 0] | | | | ------------------ | | ------------------ ------------------ 194| 1.09M| return hashstr(t, ts); ------------------ | | 115| 549k|#define hashstr(t,str) hashpow2(t, (str)->hash) | | ------------------ | | | | 106| 549k|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 2.19M|#define gnode(t,i) (&(t)->node[i]) | | | | | | ------------------ | | | | | | | Branch (13:32): [True: 0, False: 549k] | | | | | | | Branch (13:32): [True: 549k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 195| 1.09M| } 196| 203k| case LUA_VLNGSTR: { ------------------ | | 374| 203k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 203k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (196:5): [True: 203k, False: 1.11M] ------------------ 197| 407k| TString *ts = tsvalue(key); ------------------ | | 382| 203k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 815k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 203k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 203k] | | | | | Branch (113:42): [True: 203k, False: 0] | | | | ------------------ | | ------------------ ------------------ 198| 407k| return hashpow2(t, luaS_hashlongstr(ts)); ------------------ | | 106| 203k|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | ------------------ | | | | 13| 815k|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | | | | Branch (13:32): [True: 0, False: 203k] | | | | | Branch (13:32): [True: 203k, False: 0] | | | | ------------------ | | ------------------ ------------------ 199| 407k| } 200| 21| case LUA_VFALSE: ------------------ | | 250| 21|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 21|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (200:5): [True: 21, False: 1.31M] ------------------ 201| 21| return hashboolean(t, 0); ------------------ | | 116| 21|#define hashboolean(t,p) hashpow2(t, p) | | ------------------ | | | | 106| 21|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 84|#define gnode(t,i) (&(t)->node[i]) | | | | | | ------------------ | | | | | | | Branch (13:32): [True: 0, False: 21] | | | | | | | Branch (13:32): [True: 21, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 202| 1.87k| case LUA_VTRUE: ------------------ | | 251| 1.87k|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 1.87k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (202:5): [True: 1.87k, False: 1.31M] ------------------ 203| 1.87k| return hashboolean(t, 1); ------------------ | | 116| 1.87k|#define hashboolean(t,p) hashpow2(t, p) | | ------------------ | | | | 106| 1.87k|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 7.50k|#define gnode(t,i) (&(t)->node[i]) | | | | | | ------------------ | | | | | | | Branch (13:32): [True: 0, False: 1.87k] | | | | | | | Branch (13:32): [True: 1.87k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 204| 0| case LUA_VLIGHTUSERDATA: { ------------------ | | 458| 0|#define LUA_VLIGHTUSERDATA makevariant(LUA_TLIGHTUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (204:5): [True: 0, False: 1.31M] ------------------ 205| 0| void *p = pvalue(key); ------------------ | | 465| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 206| 0| return hashpointer(t, p); ------------------ | | 119| 0|#define hashpointer(t,p) hashmod(t, point2uint(p)) | | ------------------ | | | | 112| 0|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | | | ------------------ | | | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 207| 0| } 208| 0| case LUA_VLCF: { ------------------ | | 628| 0|#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (208:5): [True: 0, False: 1.31M] ------------------ 209| 0| lua_CFunction f = fvalue(key); ------------------ | | 642| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 210| 0| return hashpointer(t, f); ------------------ | | 119| 0|#define hashpointer(t,p) hashmod(t, point2uint(p)) | | ------------------ | | | | 112| 0|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | | | ------------------ | | | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 211| 0| } 212| 517| default: { ------------------ | Branch (212:5): [True: 517, False: 1.31M] ------------------ 213| 517| GCObject *o = gcvalue(key); ------------------ | | 318| 517|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 113| 517|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 517|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 214| 517| return hashpointer(t, o); ------------------ | | 119| 517|#define hashpointer(t,p) hashmod(t, point2uint(p)) | | ------------------ | | | | 112| 517|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | | | ------------------ | | | | | | 13| 517|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 215| 517| } 216| 1.31M| } 217| 1.31M|} ltable.c:l_hashfloat: 162| 192k|static int l_hashfloat (lua_Number n) { 163| 192k| int i; 164| 192k| lua_Integer ni; 165| 192k| n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN); ------------------ | | 482| 192k|#define l_mathop(op) op ------------------ n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN); ------------------ | | 143| 192k|#define cast_num(i) cast(lua_Number, (i)) | | ------------------ | | | | 139| 192k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 166| 192k| if (!lua_numbertointeger(n, &ni)) { /* is 'n' inf/-inf/NaN? */ ------------------ | | 433| 192k| ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 555| 192k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (433:4): [True: 192k, False: 476] | | ------------------ | | 434| 192k| (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 555| 192k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (434:4): [True: 181k, False: 10.8k] | | ------------------ | | 435| 192k| (*(p) = (LUA_INTEGER)(n), 1)) | | ------------------ | | | Branch (435:7): [True: 181k, False: 0] | | ------------------ ------------------ 167| 11.2k| lua_assert(luai_numisnan(n) || l_mathop(fabs)(n) == cast_num(HUGE_VAL)); ------------------ | | 109| 11.2k|#define lua_assert(c) assert(c) ------------------ 168| 11.2k| return 0; 169| 11.2k| } 170| 181k| else { /* normal case */ 171| 181k| unsigned int u = cast_uint(i) + cast_uint(ni); ------------------ | | 145| 181k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 139| 181k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ unsigned int u = cast_uint(i) + cast_uint(ni); ------------------ | | 145| 181k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 139| 181k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 172| 181k| return cast_int(u <= cast_uint(INT_MAX) ? u : ~u); ------------------ | | 144| 181k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 363k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [True: 166k, False: 15.1k] | | | | ------------------ | | ------------------ ------------------ 173| 181k| } 174| 192k|} ltable.c:equalkey: 247| 512k|static int equalkey (const TValue *k1, const Node *n2, int deadok) { 248| 512k| if ((rawtt(k1) != keytt(n2)) && /* not the same variants? */ ------------------ | | 77| 512k|#define rawtt(o) ((o)->tt_) ------------------ if ((rawtt(k1) != keytt(n2)) && /* not the same variants? */ ------------------ | | 791| 512k|#define keytt(node) ((node)->u.key_tt) ------------------ | Branch (248:7): [True: 128k, False: 384k] ------------------ 249| 512k| !(deadok && keyisdead(n2) && iscollectable(k1))) ------------------ | | 815| 128k|#define keyisdead(node) (keytt(node) == LUA_TDEADKEY) | | ------------------ | | | | 791| 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 (815:26): [True: 0, False: 0] | | ------------------ ------------------ !(deadok && keyisdead(n2) && iscollectable(k1))) ------------------ | | 313| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | ------------------ | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 311| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ | | | Branch (313:26): [True: 0, False: 0] | | ------------------ ------------------ | Branch (249:10): [True: 0, False: 128k] ------------------ 250| 128k| return 0; /* cannot be same key */ 251| 384k| switch (keytt(n2)) { ------------------ | | 791| 384k|#define keytt(node) ((node)->u.key_tt) ------------------ 252| 980| 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: ------------------ | | 250| 18|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 18|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: ------------------ | | 251| 980|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 980|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (252:5): [True: 0, False: 384k] | Branch (252:20): [True: 18, False: 384k] | Branch (252:37): [True: 962, False: 383k] ------------------ 253| 980| return 1; 254| 0| case LUA_VNUMINT: ------------------ | | 336| 0|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (254:5): [True: 0, False: 384k] ------------------ 255| 0| return (ivalue(k1) == keyival(n2)); ------------------ | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ return (ivalue(k1) == keyival(n2)); ------------------ | | 796| 0|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 792| 0|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ 256| 181k| case LUA_VNUMFLT: ------------------ | | 337| 181k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 181k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (256:5): [True: 181k, False: 203k] ------------------ 257| 181k| return luai_numeq(fltvalue(k1), fltvalueraw(keyval(n2))); ------------------ | | 353| 724k|#define luai_numeq(a,b) ((a)==(b)) | | ------------------ | | | Branch (353:35): [True: 0, False: 181k] | | | Branch (353:35): [True: 181k, False: 0] | | ------------------ ------------------ 258| 0| case LUA_VLIGHTUSERDATA: ------------------ | | 458| 0|#define LUA_VLIGHTUSERDATA makevariant(LUA_TLIGHTUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (258:5): [True: 0, False: 384k] ------------------ 259| 0| return pvalue(k1) == pvalueraw(keyval(n2)); ------------------ | | 465| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ return pvalue(k1) == pvalueraw(keyval(n2)); ------------------ | | 468| 0|#define pvalueraw(v) ((v).p) ------------------ 260| 0| case LUA_VLCF: ------------------ | | 628| 0|#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (260:5): [True: 0, False: 384k] ------------------ 261| 0| return fvalue(k1) == fvalueraw(keyval(n2)); ------------------ | | 642| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ return fvalue(k1) == fvalueraw(keyval(n2)); ------------------ | | 645| 0|#define fvalueraw(v) ((v).f) ------------------ 262| 201k| case ctb(LUA_VLNGSTR): ------------------ | | 316| 201k|#define ctb(t) ((t) | BIT_ISCOLLECTABLE) | | ------------------ | | | | 311| 201k|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ ------------------ | Branch (262:5): [True: 201k, False: 182k] ------------------ 263| 403k| return luaS_eqlngstr(tsvalue(k1), keystrval(n2)); ------------------ | | 382| 201k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 807k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 201k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 201k] | | | | | Branch (113:42): [True: 201k, False: 0] | | | | ------------------ | | ------------------ ------------------ return luaS_eqlngstr(tsvalue(k1), keystrval(n2)); ------------------ | | 798| 201k|#define keystrval(node) (gco2ts(keyval(node).gc)) | | ------------------ | | | | 372| 201k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | | | ------------------ | | | | | | 113| 201k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 201k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 264| 463| default: ------------------ | Branch (264:5): [True: 463, False: 383k] ------------------ 265| 463| return gcvalue(k1) == gcvalueraw(keyval(n2)); ------------------ | | 318| 463|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 113| 463|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 463|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ return gcvalue(k1) == gcvalueraw(keyval(n2)); ------------------ | | 320| 463|#define gcvalueraw(v) ((v).gc) ------------------ 266| 384k| } 267| 384k|} ltable.c:finishnodeset: 1025| 3.39M|static int finishnodeset (Table *t, const TValue *slot, TValue *val) { 1026| 3.39M| if (!ttisnil(slot)) { ------------------ | | 196| 3.39M|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 3.39M|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 3.39M|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 3.39M|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1026:7): [True: 2.18M, False: 1.20M] ------------------ 1027| 2.18M| setobj(((lua_State*)NULL), cast(TValue*, slot), val); ------------------ | | 119| 2.18M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 2.18M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 2.18M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 2.18M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 2.18M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 7.12M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 2.18M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 548k] | | | | | | | Branch (115:29): [True: 548k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [Folded - Ignored] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 548k, False: 0] | | | | | | | Branch (115:29): [True: 1.63M, False: 548k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 2.18M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 109| 2.18M|#define lua_assert(c) assert(c) | | ------------------ ------------------ 1028| 2.18M| return HOK; /* success */ ------------------ | | 67| 2.18M|#define HOK 0 ------------------ 1029| 2.18M| } 1030| 1.20M| else if (isabstkey(slot)) ------------------ | | 214| 1.20M|#define isabstkey(v) checktag((v), LUA_VABSTKEY) | | ------------------ | | | | 91| 1.20M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 1.20M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 1.10M, False: 104k] | | | | ------------------ | | ------------------ ------------------ 1031| 1.10M| return HNOTFOUND; /* no slot with that key */ ------------------ | | 68| 1.10M|#define HNOTFOUND 1 ------------------ 1032| 104k| else /* return node encoded */ 1033| 104k| return cast_int((cast(Node*, slot) - t->node)) + HFIRSTNODE; ------------------ | | 144| 104k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 104k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ return cast_int((cast(Node*, slot) - t->node)) + HFIRSTNODE; ------------------ | | 70| 104k|#define HFIRSTNODE 3 ------------------ 1034| 3.39M|} ltable.c:luaH_newkey: 849| 1.10M| TValue *value) { 850| 1.10M| Node *mp; 851| 1.10M| TValue aux; 852| 1.10M| if (l_unlikely(ttisnil(key))) ------------------ | | 697| 1.10M|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 1.10M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 1.10M] | | | | ------------------ | | ------------------ ------------------ 853| 0| luaG_runerror(L, "table index is nil"); 854| 1.10M| else if (ttisfloat(key)) { ------------------ | | 340| 1.10M|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 1.10M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 1.10M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 37.4k, False: 1.06M] | | | | ------------------ | | ------------------ ------------------ 855| 37.4k| lua_Number f = fltvalue(key); ------------------ | | 345| 37.4k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 113| 37.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 37.4k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 856| 0| lua_Integer k; 857| 37.4k| if (luaV_flttointeger(f, &k, F2Ieq)) { /* does key fit in an integer? */ ------------------ | Branch (857:9): [True: 24.1k, False: 13.2k] ------------------ 858| 24.1k| setivalue(&aux, k); ------------------ | | 358| 24.1k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 24.1k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 24.1k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 859| 24.1k| key = &aux; /* insert it as an integer */ 860| 24.1k| } 861| 13.2k| else if (l_unlikely(luai_numisnan(f))) ------------------ | | 697| 13.2k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 13.2k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 13.2k] | | | | ------------------ | | ------------------ ------------------ 862| 0| luaG_runerror(L, "table index is NaN"); 863| 37.4k| } 864| 1.10M| if (ttisnil(value)) ------------------ | | 196| 1.10M|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 1.10M|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 1.10M|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 1.10M|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 375k, False: 729k] | | | | ------------------ | | ------------------ ------------------ 865| 375k| return; /* do not insert nil values */ 866| 729k| mp = mainpositionTV(t, key); 867| 729k| if (!isempty(gval(mp)) || isdummy(t)) { /* main position is taken? */ ------------------ | | 228| 729k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 196| 729k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 1.45M|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 729k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 729k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!isempty(gval(mp)) || isdummy(t)) { /* main position is taken? */ ------------------ | | 33| 394k|#define isdummy(t) ((t)->flags & BITDUMMY) | | ------------------ | | | | 31| 394k|#define BITDUMMY (1 << 6) | | ------------------ | | | Branch (33:21): [True: 44.7k, False: 349k] | | ------------------ ------------------ | Branch (867:7): [True: 335k, False: 394k] ------------------ 868| 380k| Node *othern; 869| 380k| Node *f = getfreepos(t); /* get a free place */ 870| 380k| if (f == NULL) { /* cannot find a free place? */ ------------------ | Branch (870:9): [True: 149k, False: 230k] ------------------ 871| 149k| rehash(L, t, key); /* grow table */ 872| | /* whatever called 'newkey' takes care of TM cache */ 873| 149k| luaH_set(L, t, key, value); /* insert key into grown table */ 874| 149k| return; 875| 149k| } 876| 230k| lua_assert(!isdummy(t)); ------------------ | | 109| 230k|#define lua_assert(c) assert(c) ------------------ 877| 230k| othern = mainpositionfromnode(t, mp); 878| 230k| if (othern != mp) { /* is colliding node out of its main position? */ ------------------ | Branch (878:9): [True: 43.0k, False: 187k] ------------------ 879| | /* yes; move colliding node into free position */ 880| 55.2k| while (othern + gnext(othern) != mp) /* find previous */ ------------------ | | 15| 55.2k|#define gnext(n) ((n)->u.next) ------------------ | Branch (880:14): [True: 12.1k, False: 43.0k] ------------------ 881| 12.1k| othern += gnext(othern); ------------------ | | 15| 12.1k|#define gnext(n) ((n)->u.next) ------------------ 882| 43.0k| gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */ ------------------ | | 15| 43.0k|#define gnext(n) ((n)->u.next) ------------------ gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */ ------------------ | | 144| 43.0k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 43.0k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 883| 43.0k| *f = *mp; /* copy colliding node into free pos. (mp->next also goes) */ 884| 43.0k| if (gnext(mp) != 0) { ------------------ | | 15| 43.0k|#define gnext(n) ((n)->u.next) ------------------ | Branch (884:11): [True: 5.77k, False: 37.3k] ------------------ 885| 5.77k| gnext(f) += cast_int(mp - f); /* correct 'next' */ ------------------ | | 15| 5.77k|#define gnext(n) ((n)->u.next) ------------------ gnext(f) += cast_int(mp - f); /* correct 'next' */ ------------------ | | 144| 5.77k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 5.77k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 886| 5.77k| gnext(mp) = 0; /* now 'mp' is free */ ------------------ | | 15| 5.77k|#define gnext(n) ((n)->u.next) ------------------ 887| 5.77k| } 888| 43.0k| setempty(gval(mp)); ------------------ | | 236| 43.0k|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 43.0k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 889| 43.0k| } 890| 187k| else { /* colliding node is in its own main position */ 891| | /* new node will go into free position */ 892| 187k| if (gnext(mp) != 0) ------------------ | | 15| 187k|#define gnext(n) ((n)->u.next) ------------------ | Branch (892:11): [True: 37.4k, False: 150k] ------------------ 893| 37.4k| gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */ ------------------ | | 15| 37.4k|#define gnext(n) ((n)->u.next) ------------------ gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */ ------------------ | | 144| 37.4k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 37.4k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 894| 187k| else lua_assert(gnext(f) == 0); ------------------ | | 109| 187k|#define lua_assert(c) assert(c) ------------------ 895| 187k| gnext(mp) = cast_int(f - mp); ------------------ | | 15| 187k|#define gnext(n) ((n)->u.next) ------------------ gnext(mp) = cast_int(f - mp); ------------------ | | 144| 187k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 187k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 896| 187k| mp = f; 897| 187k| } 898| 230k| } 899| 580k| setnodekey(L, mp, key); ------------------ | | 751| 580k| { Node *n_=(node); const TValue *io_=(obj); \ | | 752| 580k| n_->u.key_val = io_->value_; n_->u.key_tt = io_->tt_; \ | | 753| 580k| checkliveness(L,io_); } | | ------------------ | | | | 107| 580k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 5.88M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 580k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 353k] | | | | | | | Branch (115:29): [True: 353k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 353k] | | | | | | | Branch (115:29): [True: 353k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 353k] | | | | | | | Branch (115:29): [True: 353k, False: 0] | | | | | | | Branch (115:29): [True: 353k, False: 0] | | | | | | | Branch (115:29): [True: 226k, False: 353k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 580k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 900| 580k| luaC_barrierback(L, obj2gco(t), key); ------------------ | | 232| 580k|#define luaC_barrierback(L,p,v) ( \ | | 233| 580k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 313| 580k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 580k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 311| 580k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (313:26): [True: 353k, False: 226k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 229| 353k|#define luaC_objbarrierback(L,p,o) ( \ | | | | 230| 353k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 91| 353k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 70| 353k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 65| 1.41M|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (65:24): [True: 1.47k, False: 352k] | | | | | | | | | | | Branch (65:26): [True: 0, False: 353k] | | | | | | | | | | | Branch (65:26): [True: 353k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 90| 1.47k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 5.91k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 49, False: 1.43k] | | | | | | | | | Branch (65:26): [True: 0, False: 1.47k] | | | | | | | | | Branch (65:26): [True: 1.47k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 141| 353k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 139| 353k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (230:51): [True: 0, False: 49] | | | | | Branch (230:51): [True: 49, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 141| 226k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 226k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 901| 580k| lua_assert(isempty(gval(mp))); ------------------ | | 109| 580k|#define lua_assert(c) assert(c) ------------------ 902| 580k| setobj2t(L, gval(mp), value); ------------------ | | 137| 580k|#define setobj2t setobj | | ------------------ | | | | 119| 580k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 580k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 580k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 580k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 580k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 2.41M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 580k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 122k] | | | | | | | | | Branch (115:29): [True: 122k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 122k] | | | | | | | | | Branch (115:29): [True: 122k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 122k] | | | | | | | | | Branch (115:29): [True: 122k, False: 0] | | | | | | | | | Branch (115:29): [True: 122k, False: 0] | | | | | | | | | Branch (115:29): [True: 458k, False: 122k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 580k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 580k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 903| 580k|} ltable.c:getfreepos: 817| 380k|static Node *getfreepos (Table *t) { 818| 380k| if (haslastfree(t)) { /* does it have 'lastfree' information? */ ------------------ | | 62| 380k|#define haslastfree(t) ((t)->lsizenode > LIMFORLAST) | | ------------------ | | | | 49| 380k|#define LIMFORLAST 2 /* log2 of real limit */ | | ------------------ | | | Branch (62:28): [True: 143k, False: 236k] | | ------------------ ------------------ 819| | /* look for a spot before 'lastfree', updating 'lastfree' */ 820| 246k| while (getlastfree(t) > t->node) { ------------------ | | 63| 246k|#define getlastfree(t) ((cast(Limbox *, (t)->node) - 1)->lastfree) | | ------------------ | | | | 139| 246k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (820:12): [True: 241k, False: 4.83k] ------------------ 821| 241k| Node *free = --getlastfree(t); ------------------ | | 63| 241k|#define getlastfree(t) ((cast(Limbox *, (t)->node) - 1)->lastfree) | | ------------------ | | | | 139| 241k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 822| 241k| if (keyisnil(free)) ------------------ | | 794| 241k|#define keyisnil(node) (keytt(node) == LUA_TNIL) | | ------------------ | | | | 791| 241k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisnil(node) (keytt(node) == LUA_TNIL) | | ------------------ | | | | 64| 241k|#define LUA_TNIL 0 | | ------------------ | | | Branch (794:25): [True: 138k, False: 102k] | | ------------------ ------------------ 823| 138k| return free; 824| 241k| } 825| 143k| } 826| 236k| else { /* no 'lastfree' information */ 827| 236k| if (!isdummy(t)) { ------------------ | | 33| 236k|#define isdummy(t) ((t)->flags & BITDUMMY) | | ------------------ | | | | 31| 236k|#define BITDUMMY (1 << 6) | | ------------------ ------------------ | Branch (827:9): [True: 191k, False: 44.7k] ------------------ 828| 191k| int i = sizenode(t); ------------------ | | 829| 191k|#define sizenode(t) (twoto((t)->lsizenode)) | | ------------------ | | | | 828| 191k|#define twoto(x) (1<<(x)) | | ------------------ ------------------ 829| 448k| while (i--) { /* do a linear search */ ------------------ | Branch (829:14): [True: 348k, False: 99.7k] ------------------ 830| 348k| Node *free = gnode(t, i); ------------------ | | 13| 348k|#define gnode(t,i) (&(t)->node[i]) ------------------ 831| 348k| if (keyisnil(free)) ------------------ | | 794| 348k|#define keyisnil(node) (keytt(node) == LUA_TNIL) | | ------------------ | | | | 791| 348k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisnil(node) (keytt(node) == LUA_TNIL) | | ------------------ | | | | 64| 348k|#define LUA_TNIL 0 | | ------------------ | | | Branch (794:25): [True: 92.2k, False: 256k] | | ------------------ ------------------ 832| 92.2k| return free; 833| 348k| } 834| 191k| } 835| 236k| } 836| 149k| return NULL; /* could not find a free place */ 837| 380k|} ltable.c:rehash: 766| 149k|static void rehash (lua_State *L, Table *t, const TValue *ek) { 767| 149k| unsigned int asize; /* optimal size for array part */ 768| 149k| unsigned int na; /* number of keys in the array part */ 769| 149k| unsigned int nums[MAXABITS + 1]; 770| 149k| int i; 771| 149k| int totaluse; 772| 4.92M| for (i = 0; i <= MAXABITS; i++) nums[i] = 0; /* reset counts */ ------------------ | | 70| 4.92M|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | ------------------ | | | | 144| 4.92M|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 139| 4.92M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (772:15): [True: 4.78M, False: 149k] ------------------ 773| 149k| setlimittosize(t); 774| 149k| na = numusearray(t, nums); /* count keys in array part */ 775| 149k| totaluse = na; /* all those keys are integer keys */ 776| 149k| totaluse += numusehash(t, nums, &na); /* count keys in hash part */ 777| | /* count extra key */ 778| 149k| if (ttisinteger(ek)) ------------------ | | 341| 149k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 149k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 149k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 64.6k, False: 84.7k] | | | | ------------------ | | ------------------ ------------------ 779| 64.6k| na += countint(ivalue(ek), nums); ------------------ | | 346| 64.6k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 64.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 64.6k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 780| 149k| totaluse++; 781| | /* compute new size for array part */ 782| 149k| asize = computesizes(nums, &na); 783| | /* resize the table to new computed sizes */ 784| 149k| luaH_resize(L, t, asize, totaluse - na); 785| 149k|} ltable.c:numusearray: 510| 149k|static unsigned numusearray (const Table *t, unsigned *nums) { 511| 149k| int lg; 512| 149k| unsigned int ttlg; /* 2^lg */ 513| 149k| unsigned int ause = 0; /* summation of 'nums' */ 514| 149k| unsigned int i = 1; /* count to traverse all array keys */ 515| 149k| unsigned int asize = limitasasize(t); /* real array size */ ------------------ | | 321| 149k|#define limitasasize(t) check_exp(isrealasize(t), t->alimit) | | ------------------ | | | | 113| 149k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 149k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 516| | /* traverse each slice */ 517| 631k| for (lg = 0, ttlg = 1; lg <= MAXABITS; lg++, ttlg *= 2) { ------------------ | | 70| 631k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | ------------------ | | | | 144| 631k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 139| 631k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (517:26): [True: 631k, False: 0] ------------------ 518| 631k| unsigned int lc = 0; /* counter */ 519| 631k| unsigned int lim = ttlg; 520| 631k| if (lim > asize) { ------------------ | Branch (520:9): [True: 193k, False: 438k] ------------------ 521| 193k| lim = asize; /* adjust upper limit */ 522| 193k| if (i > lim) ------------------ | Branch (522:11): [True: 149k, False: 44.2k] ------------------ 523| 149k| break; /* no more elements to count */ 524| 193k| } 525| | /* count elements in range (2^(lg - 1), 2^lg] */ 526| 1.12M| for (; i <= lim; i++) { ------------------ | Branch (526:12): [True: 641k, False: 482k] ------------------ 527| 641k| if (!arraykeyisempty(t, i)) ------------------ | Branch (527:11): [True: 451k, False: 190k] ------------------ 528| 451k| lc++; 529| 641k| } 530| 482k| nums[lg] += lc; 531| 482k| ause += lc; 532| 482k| } 533| 149k| return ause; 534| 149k|} ltable.c:numusehash: 537| 149k|static int numusehash (const Table *t, unsigned *nums, unsigned *pna) { 538| 149k| int totaluse = 0; /* total number of elements */ 539| 149k| int ause = 0; /* elements added to 'nums' (can go to array part) */ 540| 149k| int i = sizenode(t); ------------------ | | 829| 149k|#define sizenode(t) (twoto((t)->lsizenode)) | | ------------------ | | | | 828| 149k|#define twoto(x) (1<<(x)) | | ------------------ ------------------ 541| 512k| while (i--) { ------------------ | Branch (541:10): [True: 363k, False: 149k] ------------------ 542| 363k| Node *n = &t->node[i]; 543| 363k| if (!isempty(gval(n))) { ------------------ | | 228| 363k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 196| 363k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 363k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 363k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 363k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (543:9): [True: 318k, False: 44.7k] ------------------ 544| 318k| if (keyisinteger(n)) ------------------ | | 795| 318k|#define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 791| 318k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 336| 318k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | | | ------------------ | | | | | | 42| 318k|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (795:28): [True: 135k, False: 182k] | | ------------------ ------------------ 545| 135k| ause += countint(keyival(n), nums); ------------------ | | 796| 135k|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 792| 135k|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ 546| 318k| totaluse++; 547| 318k| } 548| 363k| } 549| 149k| *pna += ause; 550| 149k| return totaluse; 551| 149k|} ltable.c:countint: 488| 200k|static int countint (lua_Integer key, unsigned int *nums) { 489| 200k| unsigned int k = arrayindex(key); 490| 200k| if (k != 0) { /* is 'key' an appropriate array index? */ ------------------ | Branch (490:7): [True: 154k, False: 46.1k] ------------------ 491| 154k| nums[luaO_ceillog2(k)]++; /* count as such */ 492| 154k| return 1; 493| 154k| } 494| 46.1k| else 495| 46.1k| return 0; 496| 200k|} ltable.c:computesizes: 466| 149k|static unsigned computesizes (unsigned nums[], unsigned *pna) { 467| 149k| int i; 468| 149k| unsigned int twotoi; /* 2^i (candidate for optimal size) */ 469| 149k| unsigned int a = 0; /* number of elements smaller than 2^i */ 470| 149k| unsigned int na = 0; /* number of elements to go to array part */ 471| 149k| unsigned int optimal = 0; /* optimal size for array part */ 472| | /* loop while keys can fill more than half of total size */ 473| 149k| for (i = 0, twotoi = 1; 474| 592k| twotoi > 0 && *pna > twotoi / 2; ------------------ | Branch (474:8): [True: 592k, False: 0] | Branch (474:22): [True: 443k, False: 149k] ------------------ 475| 443k| i++, twotoi *= 2) { 476| 443k| a += nums[i]; 477| 443k| if (a > twotoi/2) { /* more than half elements present? */ ------------------ | Branch (477:9): [True: 439k, False: 4.00k] ------------------ 478| 439k| optimal = twotoi; /* optimal size (till now) */ 479| 439k| na = a; /* all elements up to 'optimal' will go to array part */ 480| 439k| } 481| 443k| } 482| 149k| lua_assert((optimal == 0 || optimal / 2 < na) && na <= optimal); ------------------ | | 109| 149k|#define lua_assert(c) assert(c) ------------------ 483| 149k| *pna = na; 484| 149k| return optimal; 485| 149k|} ltable.c:mainpositionfromnode: 220| 230k|l_sinline Node *mainpositionfromnode (const Table *t, Node *nd) { 221| 230k| TValue key; 222| 230k| getnodekey(cast(lua_State *, NULL), &key, nd); ------------------ | | 758| 230k| { TValue *io_=(obj); const Node *n_=(node); \ | | 759| 230k| io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \ | | 760| 230k| checkliveness(L,io_); } | | ------------------ | | | | 107| 230k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 1.41M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 230k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 131k] | | | | | | | Branch (115:29): [True: 131k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [Folded - Ignored] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 131k, False: 0] | | | | | | | Branch (115:29): [True: 99.0k, False: 131k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 230k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 223| 230k| return mainpositionTV(t, &key); 224| 230k|} ltable.c:rawfinishnodeset: 1037| 42|static int rawfinishnodeset (const TValue *slot, TValue *val) { 1038| 42| if (isabstkey(slot)) ------------------ | | 214| 42|#define isabstkey(v) checktag((v), LUA_VABSTKEY) | | ------------------ | | | | 91| 42|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 42|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 42, False: 0] | | | | ------------------ | | ------------------ ------------------ 1039| 42| return 0; /* no slot with that key */ 1040| 0| else { 1041| 0| setobj(((lua_State*)NULL), cast(TValue*, slot), val); ------------------ | | 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) || \ | | | | ------------------ | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [Folded - Ignored] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 109| 0|#define lua_assert(c) assert(c) | | ------------------ ------------------ 1042| 0| return 1; /* success */ 1043| 0| } 1044| 42|} ltable.c:arraykeyisempty: 499| 1.00M|l_sinline int arraykeyisempty (const Table *t, lua_Integer key) { 500| 1.00M| int tag = *getArrTag(t, key - 1); ------------------ | | 106| 1.00M|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | ------------------ | | | | 139| 1.00M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 501| 1.00M| return tagisempty(tag); ------------------ | | 204| 1.00M|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 80| 1.00M|#define novariant(t) ((t) & 0x0F) | | ------------------ | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 64| 1.00M|#define LUA_TNIL 0 | | ------------------ ------------------ 502| 1.00M|} ltable.c:ispow2realasize: 309| 100k|static int ispow2realasize (const Table *t) { 310| 100k| return (!isrealasize(t) || ispow2(t->alimit)); ------------------ | | 771| 201k|#define isrealasize(t) (!((t)->flags & BITRAS)) | | ------------------ | | | | 770| 100k|#define BITRAS (1 << 7) | | ------------------ ------------------ return (!isrealasize(t) || ispow2(t->alimit)); ------------------ | | 69| 100k|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | ------------------ | | | Branch (69:19): [True: 87.0k, False: 13.4k] | | ------------------ ------------------ | Branch (310:11): [True: 0, False: 100k] ------------------ 311| 100k|} ltable.c:binsearch: 1179| 15.2k|static unsigned int binsearch (Table *array, unsigned int i, unsigned int j) { 1180| 74.0k| while (j - i > 1u) { /* binary search */ ------------------ | Branch (1180:10): [True: 58.8k, False: 15.2k] ------------------ 1181| 58.8k| unsigned int m = (i + j) / 2; 1182| 58.8k| if (arraykeyisempty(array, m)) j = m; ------------------ | Branch (1182:9): [True: 48.4k, False: 10.3k] ------------------ 1183| 10.3k| else i = m; 1184| 58.8k| } 1185| 15.2k| return i; 1186| 15.2k|} ltable.c:hashkeyisempty: 922| 14.7k|static int hashkeyisempty (Table *t, lua_Integer key) { 923| 14.7k| const TValue *val = getintfromhash(t, key); 924| 14.7k| return isempty(val); ------------------ | | 228| 14.7k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 196| 14.7k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 14.7k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 14.7k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 14.7k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 925| 14.7k|} ltable.c:hash_search: 1154| 1.99k|static lua_Unsigned hash_search (Table *t, lua_Unsigned j) { 1155| 1.99k| lua_Unsigned i; 1156| 1.99k| if (j == 0) j++; /* the caller ensures 'j + 1' is present */ ------------------ | Branch (1156:7): [True: 57, False: 1.94k] ------------------ 1157| 2.26k| do { 1158| 2.26k| i = j; /* 'i' is a present index */ 1159| 2.26k| if (j <= l_castS2U(LUA_MAXINTEGER) / 2) ------------------ | | 155| 2.26k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (1159:9): [True: 2.26k, False: 0] ------------------ 1160| 2.26k| j *= 2; 1161| 0| else { 1162| 0| j = LUA_MAXINTEGER; ------------------ | | 554| 0|#define LUA_MAXINTEGER LLONG_MAX ------------------ 1163| 0| if (hashkeyisempty(t, j)) /* t[j] not present? */ ------------------ | Branch (1163:11): [True: 0, False: 0] ------------------ 1164| 0| break; /* 'j' now is an absent index */ 1165| 0| else /* weird case */ 1166| 0| return j; /* well, max integer is a boundary... */ 1167| 0| } 1168| 2.26k| } while (!hashkeyisempty(t, j)); /* repeat until an absent t[j] */ ------------------ | Branch (1168:12): [True: 261, False: 1.99k] ------------------ 1169| | /* i < j && t[i] present && t[j] absent */ 1170| 11.9k| while (j - i > 1u) { /* do a binary search between them */ ------------------ | Branch (1170:10): [True: 9.90k, False: 1.99k] ------------------ 1171| 9.90k| lua_Unsigned m = (i + j) / 2; 1172| 9.90k| if (hashkeyisempty(t, m)) j = m; ------------------ | Branch (1172:9): [True: 6.61k, False: 3.29k] ------------------ 1173| 3.29k| else i = m; 1174| 9.90k| } 1175| 1.99k| return i; 1176| 1.99k|} luaT_init: 38| 561|void luaT_init (lua_State *L) { 39| 561| static const char *const luaT_eventname[] = { /* ORDER TM */ 40| 561| "__index", "__newindex", 41| 561| "__gc", "__mode", "__len", "__eq", 42| 561| "__add", "__sub", "__mul", "__mod", "__pow", 43| 561| "__div", "__idiv", 44| 561| "__band", "__bor", "__bxor", "__shl", "__shr", 45| 561| "__unm", "__bnot", "__lt", "__le", 46| 561| "__concat", "__call", "__close" 47| 561| }; 48| 561| int i; 49| 14.5k| for (i=0; itmname[i] = luaS_new(L, luaT_eventname[i]); ------------------ | | 333| 14.0k|#define G(L) (L->l_G) ------------------ 51| 14.0k| luaC_fix(L, obj2gco(G(L)->tmname[i])); /* never collect these names */ ------------------ | | 388| 14.0k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 113| 14.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 14.0k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 52| 14.0k| } 53| 561|} luaT_gettm: 60| 45|const TValue *luaT_gettm (Table *events, TMS event, TString *ename) { 61| 45| const TValue *tm = luaH_Hgetshortstr(events, ename); 62| 45| lua_assert(event <= TM_EQ); ------------------ | | 109| 45|#define lua_assert(c) assert(c) ------------------ 63| 45| if (notm(tm)) { /* no tag method? */ ------------------ | | 61| 45|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 196| 45|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 45|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 45|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 45|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 45] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 64| 0| events->flags |= cast_byte(1u<metatable; ------------------ | | 721| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 76| 0| break; 77| 135| case LUA_TUSERDATA: ------------------ | | 71| 135|#define LUA_TUSERDATA 7 ------------------ | Branch (77:5): [True: 135, False: 289] ------------------ 78| 135| mt = uvalue(o)->metatable; ------------------ | | 466| 135|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 113| 540|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 135|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 135] | | | | | Branch (113:42): [True: 135, False: 0] | | | | ------------------ | | ------------------ ------------------ 79| 0| break; 80| 289| default: ------------------ | Branch (80:5): [True: 289, False: 135] ------------------ 81| 289| mt = G(L)->mt[ttype(o)]; ------------------ | | 333| 289|#define G(L) (L->l_G) ------------------ mt = G(L)->mt[ttype(o)]; ------------------ | | 87| 289|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 289|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 82| 424| } 83| 424| return (mt ? luaH_Hgetshortstr(mt, G(L)->tmname[event]) : &G(L)->nilvalue); ------------------ | | 333| 135|#define G(L) (L->l_G) ------------------ return (mt ? luaH_Hgetshortstr(mt, G(L)->tmname[event]) : &G(L)->nilvalue); ------------------ | | 333| 289|#define G(L) (L->l_G) ------------------ | Branch (83:11): [True: 135, False: 289] ------------------ 84| 424|} luaT_objtypename: 91| 167|const char *luaT_objtypename (lua_State *L, const TValue *o) { 92| 167| Table *mt; 93| 167| if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) || ------------------ | | 719| 167|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | ------------------ | | | | 91| 334|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 167|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 167] | | | | ------------------ | | ------------------ ------------------ if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) || ------------------ | | 721| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (93:24): [True: 0, False: 0] ------------------ 94| 167| (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) { ------------------ | | 463| 167|#define ttisfulluserdata(o) checktag((o), ctb(LUA_VUSERDATA)) | | ------------------ | | | | 91| 334|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 167|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 167] | | | | ------------------ | | ------------------ ------------------ (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) { ------------------ | | 466| 0|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (94:31): [True: 0, False: 0] ------------------ 95| 0| const TValue *name = luaH_Hgetshortstr(mt, luaS_new(L, "__name")); 96| 0| if (ttisstring(name)) /* is '__name' a string? */ ------------------ | | 376| 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 */ ------------------ | | 430| 0|#define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 420| 0|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 0, False: 0] | | | | | Branch (420:24): [True: 0, False: 0] | | | | | Branch (420:24): [True: 0, False: 0] | | | | | Branch (420:24): [True: 0, False: 0] | | | | | Branch (420:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define getstr(ts) (strisshr(ts) ? rawgetshrstr(ts) : (ts)->contents) | | ------------------ | | | | 427| 0|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 0|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (430:57): [True: 0, False: 0] | | | Branch (430:57): [True: 0, False: 0] | | | Branch (430:57): [True: 0, False: 0] | | | Branch (430:57): [True: 0, False: 0] | | ------------------ ------------------ 98| 0| } 99| 167| return ttypename(ttype(o)); /* else use standard type name */ ------------------ | | 70| 167|#define ttypename(x) luaT_typenames_[(x) + 1] ------------------ 100| 167|} luaT_trybinTM: 151| 122| StkId res, TMS event) { 152| 122| if (l_unlikely(callbinTM(L, p1, p2, res, event) < 0)) { ------------------ | | 697| 122|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 122|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 122, False: 0] | | | | ------------------ | | ------------------ ------------------ 153| 122| switch (event) { 154| 33| case TM_BAND: case TM_BOR: case TM_BXOR: ------------------ | Branch (154:7): [True: 31, False: 91] | Branch (154:21): [True: 2, False: 120] | Branch (154:34): [True: 0, False: 122] ------------------ 155| 95| case TM_SHL: case TM_SHR: case TM_BNOT: { ------------------ | Branch (155:7): [True: 4, False: 118] | Branch (155:20): [True: 0, False: 122] | Branch (155:33): [True: 58, False: 64] ------------------ 156| 95| if (ttisnumber(p1) && ttisnumber(p2)) ------------------ | | 339| 95|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | ------------------ | | | | 92| 190|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 95|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 95|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 1, False: 94] | | | | ------------------ | | ------------------ ------------------ if (ttisnumber(p1) && ttisnumber(p2)) ------------------ | | 339| 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] | | | | ------------------ | | ------------------ ------------------ 157| 1| luaG_tointerror(L, p1, p2); 158| 94| else 159| 94| luaG_opinterror(L, p1, p2, "perform bitwise operation on"); 160| 95| } 161| | /* calls never return, but to avoid warnings: *//* FALLTHROUGH */ 162| 27| default: ------------------ | Branch (162:7): [True: 27, False: 95] ------------------ 163| 27| luaG_opinterror(L, p1, p2, "perform arithmetic on"); 164| 122| } 165| 122| } 166| 122|} luaT_trybinassocTM: 181| 3| int flip, StkId res, TMS event) { 182| 3| if (flip) ------------------ | Branch (182:7): [True: 0, False: 3] ------------------ 183| 0| luaT_trybinTM(L, p2, p1, res, event); 184| 3| else 185| 3| luaT_trybinTM(L, p1, p2, res, event); 186| 3|} luaT_callorderTM: 207| 16| TMS event) { 208| 16| int tag = callbinTM(L, p1, p2, L->top.p, event); /* try original event */ 209| 16| if (tag >= 0) /* found tag method? */ ------------------ | Branch (209:7): [True: 0, False: 16] ------------------ 210| 0| return !tagisfalse(tag); ------------------ | | 259| 0|#define tagisfalse(t) ((t) == LUA_VFALSE || novariant(t) == LUA_TNIL) | | ------------------ | | | | 250| 0|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | | | ------------------ | | | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | #define tagisfalse(t) ((t) == LUA_VFALSE || novariant(t) == LUA_TNIL) | | ------------------ | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | ------------------ | | #define tagisfalse(t) ((t) == LUA_VFALSE || novariant(t) == LUA_TNIL) | | ------------------ | | | | 64| 0|#define LUA_TNIL 0 | | ------------------ | | | Branch (259:24): [True: 0, False: 0] | | | Branch (259:45): [True: 0, False: 0] | | ------------------ ------------------ 211| |#if defined(LUA_COMPAT_LT_LE) 212| | else if (event == TM_LE) { 213| | /* try '!(p2 < p1)' for '(p1 <= p2)' */ 214| | L->ci->callstatus |= CIST_LEQ; /* mark it is doing 'lt' for 'le' */ 215| | tag = callbinTM(L, p2, p1, L->top.p, TM_LT); 216| | L->ci->callstatus ^= CIST_LEQ; /* clear mark */ 217| | if (tag >= 0) /* found tag method? */ 218| | return tagisfalse(tag); 219| | } 220| |#endif 221| 16| luaG_ordererror(L, p1, p2); /* no metamethod found */ 222| 0| return 0; /* to avoid warnings */ 223| 16|} luaT_callorderiTM: 227| 1| int flip, int isfloat, TMS event) { 228| 1| TValue aux; const TValue *p2; 229| 1| if (isfloat) { ------------------ | Branch (229:7): [True: 0, False: 1] ------------------ 230| 0| setfltvalue(&aux, cast_num(v2)); ------------------ | | 352| 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)) | | ------------------ ------------------ 231| 0| } 232| 1| else 233| 1| setivalue(&aux, v2); ------------------ | | 358| 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)) | | ------------------ ------------------ 234| 1| if (flip) { /* arguments were exchanged? */ ------------------ | Branch (234:7): [True: 1, False: 0] ------------------ 235| 1| p2 = p1; p1 = &aux; /* correct them */ 236| 1| } 237| 0| else 238| 0| p2 = &aux; 239| 1| return luaT_callorderTM(L, p1, p2, event); 240| 1|} luaT_adjustvarargs: 244| 1.19k| const Proto *p) { 245| 1.19k| int i; 246| 1.19k| int actual = cast_int(L->top.p - ci->func.p) - 1; /* number of arguments */ ------------------ | | 144| 1.19k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 1.19k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 247| 1.19k| int nextra = actual - nfixparams; /* number of extra arguments */ 248| 1.19k| ci->u.l.nextraargs = nextra; 249| 1.19k| luaD_checkstack(L, p->maxstacksize + 1); ------------------ | | 32| 1.19k|#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0) | | ------------------ | | | | 27| 1.19k| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 1.19k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.19k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 14, False: 1.18k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 1.19k| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 1.19k| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 369| 1.18k|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 250| | /* copy function to the top of the stack */ 251| 1.19k| setobjs2s(L, L->top.p++, ci->func.p); ------------------ | | 129| 1.19k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 1.19k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 1.19k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 1.19k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 1.19k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 1.19k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 19.1k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.19k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 1.19k] | | | | | | | | | Branch (115:29): [True: 1.19k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 1.19k] | | | | | | | | | Branch (115:29): [True: 1.19k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 1.19k] | | | | | | | | | Branch (115:29): [True: 1.19k, False: 0] | | | | | | | | | Branch (115:29): [True: 1.19k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 1.19k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 1.19k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 1.19k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 252| | /* move fixed parameters to the top of the stack */ 253| 2.23k| for (i = 1; i <= nfixparams; i++) { ------------------ | Branch (253:15): [True: 1.03k, False: 1.19k] ------------------ 254| 1.03k| setobjs2s(L, L->top.p++, ci->func.p + i); ------------------ | | 129| 1.03k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 1.03k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 1.03k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 1.03k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 1.03k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 1.03k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 1.12k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.03k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 6] | | | | | | | | | Branch (115:29): [True: 6, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 6] | | | | | | | | | Branch (115:29): [True: 6, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 6] | | | | | | | | | Branch (115:29): [True: 6, False: 0] | | | | | | | | | Branch (115:29): [True: 6, False: 0] | | | | | | | | | Branch (115:29): [True: 1.03k, False: 6] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 1.03k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 1.03k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 255| 1.03k| setnilvalue(s2v(ci->func.p + i)); /* erase original parameter (for GC) */ ------------------ | | 211| 1.03k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 1.03k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 256| 1.03k| } 257| 1.19k| ci->func.p += actual + 1; 258| 1.19k| ci->top.p += actual + 1; 259| 1.19k| lua_assert(L->top.p <= ci->top.p && ci->top.p <= L->stack_last.p); ------------------ | | 109| 1.19k|#define lua_assert(c) assert(c) ------------------ 260| 1.19k|} luaT_getvarargs: 263| 75.4k|void luaT_getvarargs (lua_State *L, CallInfo *ci, StkId where, int wanted) { 264| 75.4k| int i; 265| 75.4k| int nextra = ci->u.l.nextraargs; 266| 75.4k| if (wanted < 0) { ------------------ | Branch (266:7): [True: 47.6k, False: 27.7k] ------------------ 267| 47.6k| wanted = nextra; /* get all extra arguments available */ 268| 47.6k| checkstackp(L, nextra, where); /* ensure stack space */ ------------------ | | 42| 47.6k| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 47.6k| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 697| 47.6k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 47.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 15, False: 47.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 47.6k| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 47.6k| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 369| 47.6k|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 43| 47.6k| ptrdiff_t t__ = savestack(L, p), /* save 'p' */ \ | | 44| 47.6k| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 269| 47.6k| L->top.p = where + nextra; /* next instruction will need top */ 270| 47.6k| } 271| 1.43M| for (i = 0; i < wanted && i < nextra; i++) ------------------ | Branch (271:15): [True: 1.36M, False: 71.1k] | Branch (271:29): [True: 1.36M, False: 4.26k] ------------------ 272| 1.36M| setobjs2s(L, where + i, ci->func.p - nextra + i); ------------------ | | 129| 1.36M|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 1.36M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 1.36M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 1.36M|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 1.36M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 1.36M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 1.36M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.36M|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 1.36M, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 1.36M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 1.36M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 273| 79.6k| for (; i < wanted; i++) /* complete required results with nil */ ------------------ | Branch (273:10): [True: 4.26k, False: 75.4k] ------------------ 274| 75.4k| setnilvalue(s2v(where + i)); ------------------ | | 211| 4.26k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 79.6k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 275| 75.4k|} ltm.c:callbinTM: 139| 138| StkId res, TMS event) { 140| 138| const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */ 141| 138| if (notm(tm)) ------------------ | | 61| 138|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 196| 138|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 138|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 138|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 138|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 138, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 142| 138| tm = luaT_gettmbyobj(L, p2, event); /* try second operand */ 143| 138| if (notm(tm)) ------------------ | | 61| 138|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 196| 138|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 138|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 138|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 138|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 138, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 144| 138| return -1; /* tag method not found */ 145| 0| else /* call tag method and return the tag of the result */ 146| 0| return luaT_callTMres(L, tm, p1, p2, res); 147| 138|} luaV_tonumber_: 107| 1|int luaV_tonumber_ (const TValue *obj, lua_Number *n) { 108| 1| TValue v; 109| 1| if (ttisinteger(obj)) { ------------------ | | 341| 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] | | | | ------------------ | | ------------------ ------------------ 110| 0| *n = cast_num(ivalue(obj)); ------------------ | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [True: 0, False: 0] | | | | | Branch (139:27): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 111| 0| return 1; 112| 0| } 113| 1| else if (l_strton(obj, &v)) { /* string coercible to number? */ ------------------ | Branch (113:12): [True: 0, False: 1] ------------------ 114| 0| *n = nvalue(&v); /* convert result of 'luaO_str2num' to a float */ ------------------ | | 343| 0|#define nvalue(o) check_exp(ttisnumber(o), \ | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 344| 0| (ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o))) ------------------ 115| 0| return 1; 116| 0| } 117| 1| else 118| 1| return 0; /* conversion failed */ 119| 1|} luaV_flttointeger: 125| 788k|int luaV_flttointeger (lua_Number n, lua_Integer *p, F2Imod mode) { 126| 788k| lua_Number f = l_floor(n); ------------------ | | 418| 788k|#define l_floor(x) (l_mathop(floor)(x)) | | ------------------ | | | | 482| 788k|#define l_mathop(op) op | | ------------------ ------------------ 127| 788k| if (n != f) { /* not an integral value? */ ------------------ | Branch (127:7): [True: 295k, False: 493k] ------------------ 128| 295k| if (mode == F2Ieq) return 0; /* fails if mode demands integral value */ ------------------ | Branch (128:9): [True: 288k, False: 6.93k] ------------------ 129| 6.93k| else if (mode == F2Iceil) /* needs ceil? */ ------------------ | Branch (129:14): [True: 1.21k, False: 5.71k] ------------------ 130| 1.21k| f += 1; /* convert floor to ceil (remember: n != f) */ 131| 295k| } 132| 500k| return lua_numbertointeger(f, p); ------------------ | | 433| 500k| ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 555| 500k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (433:4): [True: 410k, False: 90.3k] | | ------------------ | | 434| 500k| (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 555| 410k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (434:4): [True: 235k, False: 175k] | | ------------------ | | 435| 500k| (*(p) = (LUA_INTEGER)(n), 1)) | | ------------------ | | | Branch (435:7): [True: 235k, False: 0] | | ------------------ ------------------ 133| 788k|} luaV_tointegerns: 141| 353k|int luaV_tointegerns (const TValue *obj, lua_Integer *p, F2Imod mode) { 142| 353k| if (ttisfloat(obj)) ------------------ | | 340| 353k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 353k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 353k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 223k, False: 130k] | | | | ------------------ | | ------------------ ------------------ 143| 223k| return luaV_flttointeger(fltvalue(obj), p, mode); ------------------ | | 345| 223k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 113| 223k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 223k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 144| 130k| else if (ttisinteger(obj)) { ------------------ | | 341| 130k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 130k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 130k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 130k, False: 95] | | | | ------------------ | | ------------------ ------------------ 145| 130k| *p = ivalue(obj); ------------------ | | 346| 130k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 130k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 130k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 146| 0| return 1; 147| 130k| } 148| 95| else 149| 95| return 0; 150| 353k|} luaV_tointeger: 156| 174k|int luaV_tointeger (const TValue *obj, lua_Integer *p, F2Imod mode) { 157| 174k| TValue v; 158| 174k| if (l_strton(obj, &v)) /* does 'obj' point to a numerical string? */ ------------------ | Branch (158:7): [True: 0, False: 174k] ------------------ 159| 0| obj = &v; /* change it to point to its corresponding number */ 160| 174k| return luaV_tointegerns(obj, p, mode); 161| 174k|} luaV_finishget: 291| 1.23M| int tag) { 292| 1.23M| int loop; /* counter to avoid infinite loops */ 293| 1.23M| const TValue *tm; /* metamethod */ 294| 1.23M| for (loop = 0; loop < MAXTAGLOOP; loop++) { ------------------ | | 49| 1.23M|#define MAXTAGLOOP 2000 ------------------ | Branch (294:18): [True: 1.23M, False: 0] ------------------ 295| 1.23M| if (tag == LUA_VNOTABLE) { /* 't' is not a table? */ ------------------ | | 192| 1.23M|#define LUA_VNOTABLE makevariant(LUA_TNIL, 3) | | ------------------ | | | | 42| 1.23M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (295:9): [True: 6, False: 1.23M] ------------------ 296| 6| lua_assert(!ttistable(t)); ------------------ | | 109| 6|#define lua_assert(c) assert(c) ------------------ 297| 6| tm = luaT_gettmbyobj(L, t, TM_INDEX); 298| 6| if (l_unlikely(notm(tm))) ------------------ | | 697| 6|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 6|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 6, False: 0] | | | | ------------------ | | ------------------ ------------------ 299| 6| luaG_typeerror(L, t, "index"); /* no metamethod */ 300| | /* else will try the metamethod */ 301| 6| } 302| 1.23M| else { /* 't' is a table */ 303| 1.23M| tm = fasttm(L, hvalue(t)->metatable, TM_INDEX); /* table's metamethod */ ------------------ | | 68| 1.23M|#define fasttm(l,mt,e) gfasttm(G(l), mt, e) | | ------------------ | | | | 66| 1.23M| (checknoTM(mt, e) ? NULL : luaT_gettm(mt, e, (g)->tmname[e])) | | | | ------------------ | | | | | | 63| 9.88M|#define checknoTM(mt,e) ((mt) == NULL || (mt)->flags & (1u<<(e))) | | | | | | ------------------ | | | | | | | Branch (63:26): [True: 1.23M, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 1.23M] | | | | | | | Branch (63:27): [True: 1.23M, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 1.23M] | | | | | | | Branch (63:27): [True: 1.23M, False: 0] | | | | | | | Branch (63:42): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 304| 1.23M| if (tm == NULL) { /* no metamethod? */ ------------------ | Branch (304:11): [True: 1.23M, False: 0] ------------------ 305| 1.23M| setnilvalue(s2v(val)); /* result is nil */ ------------------ | | 211| 1.23M|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 1.23M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 306| 1.23M| return LUA_VNIL; ------------------ | | 183| 1.23M|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 1.23M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 307| 1.23M| } 308| | /* else will try the metamethod */ 309| 1.23M| } 310| 0| if (ttisfunction(tm)) { /* is metamethod a function? */ ------------------ | | 631| 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| tag = luaT_callTMres(L, tm, t, key, val); /* call it */ 312| 0| return tag; /* return tag of the result */ 313| 0| } 314| 0| t = tm; /* else try to access 'tm[key]' */ 315| 0| luaV_fastget(t, key, s2v(val), luaH_get, tag); ------------------ | | 82| 0| (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 719| 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_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 192| 0|#define LUA_VNOTABLE makevariant(LUA_TNIL, 3) | | | | ------------------ | | | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 721| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:11): [True: 0, False: 0] | | ------------------ ------------------ 316| 0| if (!tagisempty(tag)) ------------------ | | 204| 0|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | ------------------ | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 64| 0|#define LUA_TNIL 0 | | ------------------ ------------------ | Branch (316:9): [True: 0, False: 0] ------------------ 317| 0| return tag; /* done */ 318| | /* else repeat (tail call 'luaV_finishget') */ 319| 0| } 320| 0| luaG_runerror(L, "'__index' chain too long; possible loop"); 321| 0| return 0; /* to avoid warnings */ 322| 1.23M|} luaV_finishset: 329| 729k| TValue *val, int hres) { 330| 729k| int loop; /* counter to avoid infinite loops */ 331| 729k| for (loop = 0; loop < MAXTAGLOOP; loop++) { ------------------ | | 49| 729k|#define MAXTAGLOOP 2000 ------------------ | Branch (331:18): [True: 729k, False: 0] ------------------ 332| 729k| const TValue *tm; /* '__newindex' metamethod */ 333| 729k| if (hres != HNOTATABLE) { /* is 't' a table? */ ------------------ | | 69| 729k|#define HNOTATABLE 2 ------------------ | Branch (333:9): [True: 729k, False: 4] ------------------ 334| 1.45M| Table *h = hvalue(t); /* save 't' table */ ------------------ | | 721| 729k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 113| 2.91M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 729k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 729k] | | | | | Branch (113:42): [True: 729k, False: 0] | | | | ------------------ | | ------------------ ------------------ 335| 729k| tm = fasttm(L, h->metatable, TM_NEWINDEX); /* get metamethod */ ------------------ | | 68| 729k|#define fasttm(l,mt,e) gfasttm(G(l), mt, e) | | ------------------ | | | | 66| 729k| (checknoTM(mt, e) ? NULL : luaT_gettm(mt, e, (g)->tmname[e])) | | | | ------------------ | | | | | | 63| 729k|#define checknoTM(mt,e) ((mt) == NULL || (mt)->flags & (1u<<(e))) | | | | | | ------------------ | | | | | | | Branch (63:26): [True: 729k, False: 0] | | | | | | | Branch (63:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 336| 1.45M| if (tm == NULL) { /* no metamethod? */ ------------------ | Branch (336:11): [True: 729k, False: 0] ------------------ 337| 729k| luaH_finishset(L, h, key, val, hres); /* set new value */ 338| 729k| invalidateTMcache(h); ------------------ | | 23| 729k|#define invalidateTMcache(t) ((t)->flags &= ~maskflags) | | ------------------ | | | | 54| 729k|#define maskflags (~(~0u << (TM_EQ + 1))) | | ------------------ ------------------ 339| 729k| luaC_barrierback(L, obj2gco(h), val); ------------------ | | 232| 729k|#define luaC_barrierback(L,p,v) ( \ | | 233| 729k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 313| 729k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 729k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 311| 729k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (313:26): [True: 57.6k, False: 671k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 229| 57.6k|#define luaC_objbarrierback(L,p,o) ( \ | | | | 230| 57.6k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 91| 57.6k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 70| 57.6k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 65| 230k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (65:24): [True: 199, False: 57.5k] | | | | | | | | | | | Branch (65:26): [True: 0, False: 57.6k] | | | | | | | | | | | Branch (65:26): [True: 57.6k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 90| 199|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 796|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 4, False: 195] | | | | | | | | | Branch (65:26): [True: 0, False: 199] | | | | | | | | | Branch (65:26): [True: 199, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 141| 57.6k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 139| 57.6k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (230:51): [True: 0, False: 4] | | | | | Branch (230:51): [True: 4, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 141| 671k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 671k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 340| 0| return; 341| 729k| } 342| | /* else will try the metamethod */ 343| 1.45M| } 344| 4| else { /* not a table; check metamethod */ 345| 4| tm = luaT_gettmbyobj(L, t, TM_NEWINDEX); 346| 4| if (l_unlikely(notm(tm))) ------------------ | | 697| 4|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 4|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 4, False: 0] | | | | ------------------ | | ------------------ ------------------ 347| 4| luaG_typeerror(L, t, "index"); 348| 4| } 349| | /* try the metamethod */ 350| 0| if (ttisfunction(tm)) { ------------------ | | 631| 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] | | | | ------------------ | | ------------------ ------------------ 351| 0| luaT_callTM(L, tm, t, key, val); 352| 0| return; 353| 0| } 354| 0| t = tm; /* else repeat assignment over 'tm' */ 355| 0| luaV_fastset(t, key, val, hres, luaH_pset); ------------------ | | 95| 0| (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 719| 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_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 69| 0|#define HNOTATABLE 2 | | ------------------ | | (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 721| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (95:12): [True: 0, False: 0] | | ------------------ ------------------ 356| 0| if (hres == HOK) ------------------ | | 67| 0|#define HOK 0 ------------------ | Branch (356:9): [True: 0, False: 0] ------------------ 357| 0| return; /* done */ 358| | /* else 'return luaV_finishset(L, t, key, val, slot)' (loop) */ 359| 0| } 360| 0| luaG_runerror(L, "'__newindex' chain too long; possible loop"); 361| 729k|} luaV_equalobj: 563| 26.6M|int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) { 564| 26.6M| const TValue *tm; 565| 26.6M| if (ttypetag(t1) != ttypetag(t2)) { /* not the same variant? */ ------------------ | | 84| 26.6M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 26.6M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ if (ttypetag(t1) != ttypetag(t2)) { /* not the same variant? */ ------------------ | | 84| 26.6M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 26.6M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ | Branch (565:7): [True: 22.6k, False: 26.6M] ------------------ 566| 22.6k| if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 87| 22.6k|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 22.6k|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 87| 45.3k|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 22.6k|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 87| 13.0k|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 13.0k|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 67| 13.0k|#define LUA_TNUMBER 3 ------------------ | Branch (566:9): [True: 9.63k, False: 13.0k] | Branch (566:35): [True: 0, False: 13.0k] ------------------ 567| 9.63k| return 0; /* only numbers can be equal with different variants */ 568| 13.0k| else { /* two numbers with different variants */ 569| | /* One of them is an integer. If the other does not have an 570| | integer value, they cannot be equal; otherwise, compare their 571| | integer values. */ 572| 13.0k| lua_Integer i1, i2; 573| 13.0k| return (luaV_tointegerns(t1, &i1, F2Ieq) && ------------------ | Branch (573:15): [True: 8, False: 13.0k] ------------------ 574| 13.0k| luaV_tointegerns(t2, &i2, F2Ieq) && ------------------ | Branch (574:15): [True: 8, False: 0] ------------------ 575| 13.0k| i1 == i2); ------------------ | Branch (575:15): [True: 0, False: 8] ------------------ 576| 13.0k| } 577| 22.6k| } 578| | /* values have same type and same variant */ 579| 26.6M| switch (ttypetag(t1)) { ------------------ | | 84| 26.6M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 26.6M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 580| 1.22k| case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1; ------------------ | | 183| 349|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 349|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1; ------------------ | | 250| 349|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 349|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1; ------------------ | | 251| 1.22k|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 1.22k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (580:5): [True: 349, False: 26.6M] | Branch (580:20): [True: 0, False: 26.6M] | Branch (580:37): [True: 876, False: 26.6M] ------------------ 581| 219k| case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2)); ------------------ | | 336| 219k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 219k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2)); ------------------ | | 346| 219k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 219k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 219k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2)); ------------------ | | 346| 219k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 219k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 219k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (581:5): [True: 219k, False: 26.4M] ------------------ 582| 122k| case LUA_VNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2)); ------------------ | | 337| 122k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 122k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2)); ------------------ | | 353| 489k|#define luai_numeq(a,b) ((a)==(b)) | | ------------------ | | | Branch (353:35): [True: 0, False: 122k] | | | Branch (353:35): [True: 122k, False: 0] | | | Branch (353:40): [True: 0, False: 122k] | | | Branch (353:40): [True: 122k, False: 0] | | ------------------ ------------------ | Branch (582:5): [True: 122k, False: 26.5M] ------------------ 583| 0| case LUA_VLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); ------------------ | | 458| 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); ------------------ | | 465| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ case LUA_VLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); ------------------ | | 465| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (583:5): [True: 0, False: 26.6M] ------------------ 584| 0| case LUA_VLCF: return fvalue(t1) == fvalue(t2); ------------------ | | 628| 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); ------------------ | | 642| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ case LUA_VLCF: return fvalue(t1) == fvalue(t2); ------------------ | | 642| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (584:5): [True: 0, False: 26.6M] ------------------ 585| 105M| case LUA_VSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 373| 26.2M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 26.2M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 43| 26.2M|#define eqshrstr(a,b) check_exp((a)->tt == LUA_VSHRSTR, (a) == (b)) | | ------------------ | | | | 113| 420M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 26.2M|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 26.2M] | | | | | Branch (113:42): [True: 26.2M, False: 0] | | | | | Branch (113:42): [True: 0, False: 26.2M] | | | | | Branch (113:42): [True: 26.2M, False: 0] | | | | | Branch (113:42): [True: 0, False: 26.2M] | | | | | Branch (113:42): [True: 26.2M, False: 0] | | | | | Branch (113:42): [True: 0, False: 26.2M] | | | | | Branch (113:42): [True: 26.2M, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (585:5): [True: 26.2M, False: 415k] ------------------ 586| 144k| case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 374| 72.2k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 72.2k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 382| 72.2k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 289k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 72.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 72.2k] | | | | | Branch (113:42): [True: 72.2k, False: 0] | | | | ------------------ | | ------------------ ------------------ case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 382| 72.2k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 289k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 72.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 72.2k] | | | | | Branch (113:42): [True: 72.2k, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (586:5): [True: 72.2k, False: 26.5M] ------------------ 587| 0| case LUA_VUSERDATA: { ------------------ | | 460| 0|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (587:5): [True: 0, False: 26.6M] ------------------ 588| 0| if (uvalue(t1) == uvalue(t2)) return 1; ------------------ | | 466| 0|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ if (uvalue(t1) == uvalue(t2)) return 1; ------------------ | | 466| 0|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (588:11): [True: 0, False: 0] ------------------ 589| 0| else if (L == NULL) return 0; ------------------ | Branch (589:16): [True: 0, False: 0] ------------------ 590| 0| tm = fasttm(L, uvalue(t1)->metatable, TM_EQ); ------------------ | | 68| 0|#define fasttm(l,mt,e) gfasttm(G(l), mt, e) | | ------------------ | | | | 66| 0| (checknoTM(mt, e) ? NULL : luaT_gettm(mt, e, (g)->tmname[e])) | | | | ------------------ | | | | | | 63| 0|#define checknoTM(mt,e) ((mt) == NULL || (mt)->flags & (1u<<(e))) | | | | | | ------------------ | | | | | | | Branch (63:26): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:42): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 591| 0| if (tm == NULL) ------------------ | Branch (591:11): [True: 0, False: 0] ------------------ 592| 0| tm = fasttm(L, uvalue(t2)->metatable, TM_EQ); ------------------ | | 68| 0|#define fasttm(l,mt,e) gfasttm(G(l), mt, e) | | ------------------ | | | | 66| 0| (checknoTM(mt, e) ? NULL : luaT_gettm(mt, e, (g)->tmname[e])) | | | | ------------------ | | | | | | 63| 0|#define checknoTM(mt,e) ((mt) == NULL || (mt)->flags & (1u<<(e))) | | | | | | ------------------ | | | | | | | Branch (63:26): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:42): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 593| 0| break; /* will try TM */ 594| 0| } 595| 0| case LUA_VTABLE: { ------------------ | | 717| 0|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (595:5): [True: 0, False: 26.6M] ------------------ 596| 0| if (hvalue(t1) == hvalue(t2)) return 1; ------------------ | | 721| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ if (hvalue(t1) == hvalue(t2)) return 1; ------------------ | | 721| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (596:11): [True: 0, False: 0] ------------------ 597| 0| else if (L == NULL) return 0; ------------------ | Branch (597:16): [True: 0, False: 0] ------------------ 598| 0| tm = fasttm(L, hvalue(t1)->metatable, TM_EQ); ------------------ | | 68| 0|#define fasttm(l,mt,e) gfasttm(G(l), mt, e) | | ------------------ | | | | 66| 0| (checknoTM(mt, e) ? NULL : luaT_gettm(mt, e, (g)->tmname[e])) | | | | ------------------ | | | | | | 63| 0|#define checknoTM(mt,e) ((mt) == NULL || (mt)->flags & (1u<<(e))) | | | | | | ------------------ | | | | | | | Branch (63:26): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:42): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 599| 0| if (tm == NULL) ------------------ | Branch (599:11): [True: 0, False: 0] ------------------ 600| 0| tm = fasttm(L, hvalue(t2)->metatable, TM_EQ); ------------------ | | 68| 0|#define fasttm(l,mt,e) gfasttm(G(l), mt, e) | | ------------------ | | | | 66| 0| (checknoTM(mt, e) ? NULL : luaT_gettm(mt, e, (g)->tmname[e])) | | | | ------------------ | | | | | | 63| 0|#define checknoTM(mt,e) ((mt) == NULL || (mt)->flags & (1u<<(e))) | | | | | | ------------------ | | | | | | | Branch (63:26): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:27): [True: 0, False: 0] | | | | | | | Branch (63:42): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | | Branch (63:43): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | | Branch (66:41): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 601| 0| break; /* will try TM */ 602| 0| } 603| 0| default: ------------------ | Branch (603:5): [True: 0, False: 26.6M] ------------------ 604| 26.6M| return gcvalue(t1) == gcvalue(t2); ------------------ | | 318| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ return gcvalue(t1) == gcvalue(t2); ------------------ | | 318| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 605| 26.6M| } 606| 0| if (tm == NULL) /* no TM? */ ------------------ | Branch (606:7): [True: 0, False: 0] ------------------ 607| 0| return 0; /* objects are different */ 608| 0| else { 609| 0| int tag = luaT_callTMres(L, tm, t1, t2, L->top.p); /* call TM */ 610| 0| return !tagisfalse(tag); ------------------ | | 259| 0|#define tagisfalse(t) ((t) == LUA_VFALSE || novariant(t) == LUA_TNIL) | | ------------------ | | | | 250| 0|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | | | ------------------ | | | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | #define tagisfalse(t) ((t) == LUA_VFALSE || novariant(t) == LUA_TNIL) | | ------------------ | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | ------------------ | | #define tagisfalse(t) ((t) == LUA_VFALSE || novariant(t) == LUA_TNIL) | | ------------------ | | | | 64| 0|#define LUA_TNIL 0 | | ------------------ | | | Branch (259:24): [True: 0, False: 0] | | | Branch (259:45): [True: 0, False: 0] | | ------------------ ------------------ 611| 0| } 612| 0|} luaV_concat: 638| 39.3k|void luaV_concat (lua_State *L, int total) { 639| 39.3k| if (total == 1) ------------------ | Branch (639:7): [True: 0, False: 39.3k] ------------------ 640| 0| return; /* "all" values already concatenated */ 641| 39.3k| do { 642| 39.3k| StkId top = L->top.p; 643| 39.3k| int n = 2; /* number of elements handled in this pass (at least 2) */ 644| 39.3k| if (!(ttisstring(s2v(top - 2)) || cvt2str(s2v(top - 2))) || ------------------ | | 376| 39.3k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 78.7k|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 39.3k|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 39.3k|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 4.04k, False: 35.3k] | | | | ------------------ | | ------------------ ------------------ if (!(ttisstring(s2v(top - 2)) || cvt2str(s2v(top - 2))) || ------------------ | | 17| 39.3k|#define cvt2str(o) ttisnumber(o) | | ------------------ | | | | 339| 35.3k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 35.3k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 35.3k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 35.3k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 35.3k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 645| 39.3k| !tostring(L, s2v(top - 1))) ------------------ | | 617| 39.3k| (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 376| 39.3k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | | | ------------------ | | | | | | 92| 78.7k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 39.3k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 39.3k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 7.39k, False: 31.9k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 17| 31.9k|#define cvt2str(o) ttisnumber(o) | | | | ------------------ | | | | | | 339| 31.9k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | | | ------------------ | | | | | | | | 92| 63.9k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 31.9k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 31.9k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (92:25): [True: 31.9k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (617:35): [True: 31.9k, False: 0] | | ------------------ ------------------ 646| 0| luaT_tryconcatTM(L); /* may invalidate 'top' */ 647| 39.3k| else if (isemptystr(s2v(top - 1))) /* second operand is empty? */ ------------------ | | 619| 117k|#define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 377| 39.3k|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | | | ------------------ | | | | | | 91| 78.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 39.3k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 39.1k, False: 236] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 382| 39.1k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | | | ------------------ | | | | | | 113| 156k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 39.1k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 39.1k] | | | | | | | Branch (113:42): [True: 39.1k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (619:44): [True: 144, False: 38.9k] | | ------------------ ------------------ 648| 39.3k| cast_void(tostring(L, s2v(top - 2))); /* result is first operand */ ------------------ | | 141| 144|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 139| 153|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (139:27): [True: 3, False: 0] | | | | | Branch (139:27): [True: 3, False: 0] | | | | | Branch (139:27): [True: 141, False: 3] | | | | ------------------ | | ------------------ ------------------ 649| 39.2k| else if (isemptystr(s2v(top - 2))) { /* first operand is empty string? */ ------------------ | | 619| 39.2k|#define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 377| 39.2k|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | | | ------------------ | | | | | | 91| 78.4k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 39.2k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 3.72k, False: 35.4k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 382| 3.72k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | | | ------------------ | | | | | | 113| 14.9k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 3.72k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 3.72k] | | | | | | | Branch (113:42): [True: 3.72k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (619:44): [True: 0, False: 3.72k] | | ------------------ ------------------ 650| 0| setobjs2s(L, top - 2, top - 1); /* result is second op. */ ------------------ | | 129| 0|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 651| 0| } 652| 39.2k| else { 653| | /* at least two non-empty string values; get as many as possible */ 654| 39.2k| size_t tl = tsslen(tsvalue(s2v(top - 1))); ------------------ | | 435| 39.2k| (strisshr(ts) ? cast_uint((ts)->shrlen) : (ts)->u.lnglen) | | ------------------ | | | | 420| 313k|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 38.9k, False: 236] | | | | | Branch (420:24): [True: 0, False: 39.2k] | | | | | Branch (420:24): [True: 39.2k, False: 0] | | | | | Branch (420:24): [True: 0, False: 39.2k] | | | | | Branch (420:24): [True: 39.2k, False: 0] | | | | ------------------ | | ------------------ | | (strisshr(ts) ? cast_uint((ts)->shrlen) : (ts)->u.lnglen) | | ------------------ | | | | 145| 38.9k|#define cast_uint(i) cast(unsigned int, (i)) | | | | ------------------ | | | | | | 139| 311k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (139:27): [True: 0, False: 38.9k] | | | | | | | Branch (139:27): [True: 38.9k, False: 0] | | | | | | | Branch (139:27): [True: 0, False: 38.9k] | | | | | | | Branch (139:27): [True: 38.9k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (435:45): [True: 0, False: 236] | | | Branch (435:45): [True: 236, False: 0] | | | Branch (435:45): [True: 0, False: 236] | | | Branch (435:45): [True: 236, False: 0] | | ------------------ ------------------ 655| 0| TString *ts; 656| | /* collect total length and number of strings */ 657| 78.4k| for (n = 1; n < total && tostring(L, s2v(top - n - 1)); n++) { ------------------ | | 617| 39.2k| (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 376| 39.2k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | | | ------------------ | | | | | | 92| 78.4k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 39.2k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 39.2k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 3.90k, False: 35.3k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 17| 35.3k|#define cvt2str(o) ttisnumber(o) | | | | ------------------ | | | | | | 339| 35.3k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | | | ------------------ | | | | | | | | 92| 70.6k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 35.3k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 35.3k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (92:25): [True: 35.3k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (617:35): [True: 35.3k, False: 0] | | ------------------ ------------------ | Branch (657:19): [True: 39.2k, False: 39.2k] ------------------ 658| 39.2k| size_t l = tsslen(tsvalue(s2v(top - n - 1))); ------------------ | | 435| 39.2k| (strisshr(ts) ? cast_uint((ts)->shrlen) : (ts)->u.lnglen) | | ------------------ | | | | 420| 313k|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 39.0k, False: 178] | | | | | Branch (420:24): [True: 0, False: 39.2k] | | | | | Branch (420:24): [True: 39.2k, False: 0] | | | | | Branch (420:24): [True: 0, False: 39.2k] | | | | | Branch (420:24): [True: 39.2k, False: 0] | | | | ------------------ | | ------------------ | | (strisshr(ts) ? cast_uint((ts)->shrlen) : (ts)->u.lnglen) | | ------------------ | | | | 145| 39.0k|#define cast_uint(i) cast(unsigned int, (i)) | | | | ------------------ | | | | | | 139| 312k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (139:27): [True: 0, False: 39.0k] | | | | | | | Branch (139:27): [True: 39.0k, False: 0] | | | | | | | Branch (139:27): [True: 0, False: 39.0k] | | | | | | | Branch (139:27): [True: 39.0k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (435:45): [True: 0, False: 178] | | | Branch (435:45): [True: 178, False: 0] | | | Branch (435:45): [True: 0, False: 178] | | | Branch (435:45): [True: 178, False: 0] | | ------------------ ------------------ 659| 39.2k| if (l_unlikely(l >= MAX_SIZE - sizeof(TString) - tl)) { ------------------ | | 697| 39.2k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 78.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 39.2k] | | | | | Branch (685:46): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 660| 0| L->top.p = top - total; /* pop strings to avoid wasting stack */ 661| 0| luaG_runerror(L, "string length overflow"); 662| 0| } 663| 39.2k| tl += l; 664| 39.2k| } 665| 39.2k| if (tl <= LUAI_MAXSHORTLEN) { /* is result a short string? */ ------------------ | | 219| 39.2k|#define LUAI_MAXSHORTLEN 40 ------------------ | Branch (665:11): [True: 38.8k, False: 328] ------------------ 666| 38.8k| char buff[LUAI_MAXSHORTLEN]; 667| 38.8k| copy2buff(top, n, buff); /* copy strings to buffer */ 668| 38.8k| ts = luaS_newlstr(L, buff, tl); 669| 38.8k| } 670| 328| else { /* long string; copy strings directly to final result */ 671| 328| ts = luaS_createlngstrobj(L, tl); 672| 328| copy2buff(top, n, getlngstr(ts)); ------------------ | | 429| 328|#define getlngstr(ts) check_exp(!strisshr(ts), (ts)->contents) | | ------------------ | | | | 113| 328|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 328|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 673| 328| } 674| 78.4k| setsvalue2s(L, top - n, ts); /* create result */ ------------------ | | 390| 39.2k|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 385| 39.2k| { TValue *io = (obj); TString *x_ = (x); \ | | | | 386| 39.2k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 39.2k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 388| 39.2k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 39.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 39.2k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 39.2k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 387| 39.2k| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 39.2k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 627k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 39.2k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 39.2k] | | | | | | | | | Branch (115:29): [True: 39.2k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 39.2k] | | | | | | | | | Branch (115:29): [True: 39.2k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 39.2k] | | | | | | | | | Branch (115:29): [True: 39.2k, False: 0] | | | | | | | | | Branch (115:29): [True: 39.2k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 39.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 39.2k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 675| 78.4k| } 676| 39.3k| total -= n - 1; /* got 'n' strings to create one new */ 677| 39.3k| L->top.p -= n - 1; /* popped 'n' strings and pushed one */ 678| 39.3k| } while (total > 1); /* repeat until only 1 result left */ ------------------ | Branch (678:12): [True: 0, False: 39.3k] ------------------ 679| 39.3k|} luaV_objlen: 685| 187k|void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) { 686| 187k| const TValue *tm; 687| 187k| switch (ttypetag(rb)) { ------------------ | | 84| 187k|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 187k|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 688| 187k| case LUA_VTABLE: { ------------------ | | 717| 187k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 187k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (688:5): [True: 187k, False: 6] ------------------ 689| 375k| Table *h = hvalue(rb); ------------------ | | 721| 187k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 113| 751k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 187k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 187k] | | | | | Branch (113:42): [True: 187k, False: 0] | | | | ------------------ | | ------------------ ------------------ 690| 187k| tm = fasttm(L, h->metatable, TM_LEN); ------------------ | | 68| 187k|#define fasttm(l,mt,e) gfasttm(G(l), mt, e) | | ------------------ | | | | 66| 187k| (checknoTM(mt, e) ? NULL : luaT_gettm(mt, e, (g)->tmname[e])) | | | | ------------------ | | | | | | 63| 187k|#define checknoTM(mt,e) ((mt) == NULL || (mt)->flags & (1u<<(e))) | | | | | | ------------------ | | | | | | | Branch (63:26): [True: 187k, False: 0] | | | | | | | Branch (63:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 691| 375k| if (tm) break; /* metamethod? break switch to call it */ ------------------ | Branch (691:11): [True: 0, False: 187k] ------------------ 692| 187k| setivalue(s2v(ra), luaH_getn(h)); /* else primitive len */ ------------------ | | 358| 187k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 187k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 187k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 693| 187k| return; 694| 375k| } 695| 6| case LUA_VSHRSTR: { ------------------ | | 373| 6|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 6|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (695:5): [True: 6, False: 187k] ------------------ 696| 6| setivalue(s2v(ra), tsvalue(rb)->shrlen); ------------------ | | 358| 48| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 6|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 6|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | | Branch (358:35): [True: 0, False: 6] | | | Branch (358:35): [True: 6, False: 0] | | | Branch (358:35): [True: 0, False: 6] | | | Branch (358:35): [True: 6, False: 0] | | ------------------ ------------------ 697| 6| return; 698| 6| } 699| 0| case LUA_VLNGSTR: { ------------------ | | 374| 0|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (699:5): [True: 0, False: 187k] ------------------ 700| 0| setivalue(s2v(ra), tsvalue(rb)->u.lnglen); ------------------ | | 358| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 0|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | | Branch (358:35): [True: 0, False: 0] | | | Branch (358:35): [True: 0, False: 0] | | | Branch (358:35): [True: 0, False: 0] | | | Branch (358:35): [True: 0, False: 0] | | ------------------ ------------------ 701| 0| return; 702| 0| } 703| 0| default: { /* try metamethod */ ------------------ | Branch (703:5): [True: 0, False: 187k] ------------------ 704| 0| tm = luaT_gettmbyobj(L, rb, TM_LEN); 705| 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] | | | | ------------------ | | ------------------ ------------------ 706| 0| luaG_typeerror(L, rb, "get length of"); 707| 0| break; 708| 0| } 709| 187k| } 710| 0| luaT_callTMres(L, tm, rb, rb, ra); 711| 0|} luaV_idiv: 720| 5.06k|lua_Integer luaV_idiv (lua_State *L, lua_Integer m, lua_Integer n) { 721| 5.06k| if (l_unlikely(l_castS2U(n) + 1u <= 1u)) { /* special cases: -1 or 0 */ ------------------ | | 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] | | | | ------------------ | | ------------------ ------------------ 722| 0| if (n == 0) ------------------ | Branch (722:9): [True: 0, False: 0] ------------------ 723| 0| luaG_runerror(L, "attempt to divide by zero"); 724| 0| return intop(-, 0, m); /* n==-1; avoid overflow with 0x80000...//-1 */ ------------------ | | 73| 0|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 164| 0|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 725| 0| } 726| 5.06k| else { 727| 5.06k| lua_Integer q = m / n; /* perform C division */ 728| 5.06k| if ((m ^ n) < 0 && m % n != 0) /* 'm/n' would be negative non-integer? */ ------------------ | Branch (728:9): [True: 1.49k, False: 3.56k] | Branch (728:24): [True: 1.07k, False: 422] ------------------ 729| 1.07k| q -= 1; /* correct result for different rounding */ 730| 5.06k| return q; 731| 5.06k| } 732| 5.06k|} luaV_mod: 740| 13.4k|lua_Integer luaV_mod (lua_State *L, lua_Integer m, lua_Integer n) { 741| 13.4k| if (l_unlikely(l_castS2U(n) + 1u <= 1u)) { /* special cases: -1 or 0 */ ------------------ | | 697| 13.4k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 13.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 360, False: 13.1k] | | | | ------------------ | | ------------------ ------------------ 742| 360| if (n == 0) ------------------ | Branch (742:9): [True: 0, False: 360] ------------------ 743| 0| luaG_runerror(L, "attempt to perform 'n%%0'"); 744| 360| return 0; /* m % -1 == 0; avoid overflow with 0x80000...%-1 */ 745| 360| } 746| 13.1k| else { 747| 13.1k| lua_Integer r = m % n; 748| 13.1k| if (r != 0 && (r ^ n) < 0) /* 'm/n' would be non-integer negative? */ ------------------ | Branch (748:9): [True: 4.68k, False: 8.42k] | Branch (748:19): [True: 1.15k, False: 3.52k] ------------------ 749| 1.15k| r += n; /* correct result for different rounding */ 750| 13.1k| return r; 751| 13.1k| } 752| 13.4k|} luaV_modf: 758| 36.9k|lua_Number luaV_modf (lua_State *L, lua_Number m, lua_Number n) { 759| 36.9k| lua_Number r; 760| 36.9k| luai_nummod(L, m, n, r); ------------------ | | 337| 36.9k| { (void)L; (m) = l_mathop(fmod)(a,b); \ | | ------------------ | | | | 482| 36.9k|#define l_mathop(op) op | | ------------------ | | 338| 36.9k| if (((m) > 0) ? (b) < 0 : ((m) < 0 && (b) > 0)) (m) += (b); } | | ------------------ | | | Branch (338:9): [True: 29.2k, False: 7.64k] | | | Branch (338:9): [True: 1.45k, False: 35.4k] | | | Branch (338:32): [True: 1.45k, False: 6.18k] | | | Branch (338:43): [True: 1.45k, False: 0] | | ------------------ ------------------ 761| 36.9k| return r; 762| 36.9k|} luaV_shiftl: 772| 43.9k|lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) { 773| 43.9k| if (y < 0) { /* shift right? */ ------------------ | Branch (773:7): [True: 3.65k, False: 40.2k] ------------------ 774| 3.65k| if (y <= -NBITS) return 0; ------------------ | | 766| 3.65k|#define NBITS cast_int(sizeof(lua_Integer) * CHAR_BIT) | | ------------------ | | | | 144| 3.65k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 139| 3.65k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (774:9): [True: 519, False: 3.13k] ------------------ 775| 3.13k| else return intop(>>, x, -y); ------------------ | | 73| 3.13k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 164| 3.13k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 776| 3.65k| } 777| 40.2k| else { /* shift left */ 778| 40.2k| if (y >= NBITS) return 0; ------------------ | | 766| 40.2k|#define NBITS cast_int(sizeof(lua_Integer) * CHAR_BIT) | | ------------------ | | | | 144| 40.2k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 139| 40.2k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (778:9): [True: 263, False: 40.0k] ------------------ 779| 40.0k| else return intop(<<, x, y); ------------------ | | 73| 40.0k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 164| 40.0k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 780| 40.2k| } 781| 43.9k|} luaV_execute: 1146| 162|void luaV_execute (lua_State *L, CallInfo *ci) { 1147| 162| LClosure *cl; 1148| 162| TValue *k; 1149| 162| StkId base; 1150| 162| const Instruction *pc; 1151| 162| int trap; 1152| 162|#if LUA_USE_JUMPTABLE 1153| 162|#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| 162|#undef vmdispatch | | 9| 162|#undef vmcase | | 10| 162|#undef vmbreak | | 11| | | | 12| 162|#define vmdispatch(x) goto *disptab[x]; | | 13| | | | 14| 162|#define vmcase(l) L_##l: | | 15| | | | 16| 162|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | 17| | | | 18| | | | 19| 162|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| 162|&&L_OP_MOVE, | | 29| 162|&&L_OP_LOADI, | | 30| 162|&&L_OP_LOADF, | | 31| 162|&&L_OP_LOADK, | | 32| 162|&&L_OP_LOADKX, | | 33| 162|&&L_OP_LOADFALSE, | | 34| 162|&&L_OP_LFALSESKIP, | | 35| 162|&&L_OP_LOADTRUE, | | 36| 162|&&L_OP_LOADNIL, | | 37| 162|&&L_OP_GETUPVAL, | | 38| 162|&&L_OP_SETUPVAL, | | 39| 162|&&L_OP_GETTABUP, | | 40| 162|&&L_OP_GETTABLE, | | 41| 162|&&L_OP_GETI, | | 42| 162|&&L_OP_GETFIELD, | | 43| 162|&&L_OP_SETTABUP, | | 44| 162|&&L_OP_SETTABLE, | | 45| 162|&&L_OP_SETI, | | 46| 162|&&L_OP_SETFIELD, | | 47| 162|&&L_OP_NEWTABLE, | | 48| 162|&&L_OP_SELF, | | 49| 162|&&L_OP_ADDI, | | 50| 162|&&L_OP_ADDK, | | 51| 162|&&L_OP_SUBK, | | 52| 162|&&L_OP_MULK, | | 53| 162|&&L_OP_MODK, | | 54| 162|&&L_OP_POWK, | | 55| 162|&&L_OP_DIVK, | | 56| 162|&&L_OP_IDIVK, | | 57| 162|&&L_OP_BANDK, | | 58| 162|&&L_OP_BORK, | | 59| 162|&&L_OP_BXORK, | | 60| 162|&&L_OP_SHRI, | | 61| 162|&&L_OP_SHLI, | | 62| 162|&&L_OP_ADD, | | 63| 162|&&L_OP_SUB, | | 64| 162|&&L_OP_MUL, | | 65| 162|&&L_OP_MOD, | | 66| 162|&&L_OP_POW, | | 67| 162|&&L_OP_DIV, | | 68| 162|&&L_OP_IDIV, | | 69| 162|&&L_OP_BAND, | | 70| 162|&&L_OP_BOR, | | 71| 162|&&L_OP_BXOR, | | 72| 162|&&L_OP_SHL, | | 73| 162|&&L_OP_SHR, | | 74| 162|&&L_OP_MMBIN, | | 75| 162|&&L_OP_MMBINI, | | 76| 162|&&L_OP_MMBINK, | | 77| 162|&&L_OP_UNM, | | 78| 162|&&L_OP_BNOT, | | 79| 162|&&L_OP_NOT, | | 80| 162|&&L_OP_LEN, | | 81| 162|&&L_OP_CONCAT, | | 82| 162|&&L_OP_CLOSE, | | 83| 162|&&L_OP_TBC, | | 84| 162|&&L_OP_JMP, | | 85| 162|&&L_OP_EQ, | | 86| 162|&&L_OP_LT, | | 87| 162|&&L_OP_LE, | | 88| 162|&&L_OP_EQK, | | 89| 162|&&L_OP_EQI, | | 90| 162|&&L_OP_LTI, | | 91| 162|&&L_OP_LEI, | | 92| 162|&&L_OP_GTI, | | 93| 162|&&L_OP_GEI, | | 94| 162|&&L_OP_TEST, | | 95| 162|&&L_OP_TESTSET, | | 96| 162|&&L_OP_CALL, | | 97| 162|&&L_OP_TAILCALL, | | 98| 162|&&L_OP_RETURN, | | 99| 162|&&L_OP_RETURN0, | | 100| 162|&&L_OP_RETURN1, | | 101| 162|&&L_OP_FORLOOP, | | 102| 162|&&L_OP_FORPREP, | | 103| 162|&&L_OP_TFORPREP, | | 104| 162|&&L_OP_TFORCALL, | | 105| 162|&&L_OP_TFORLOOP, | | 106| 162|&&L_OP_SETLIST, | | 107| 162|&&L_OP_CLOSURE, | | 108| 162|&&L_OP_VARARG, | | 109| 162|&&L_OP_VARARGPREP, | | 110| 162|&&L_OP_EXTRAARG | | 111| | | | 112| 162|}; ------------------ 1154| 162|#endif 1155| 560k| startfunc: 1156| 560k| trap = L->hookmask; 1157| 1.12M| returning: /* trap already set */ 1158| 2.24M| cl = ci_func(ci); ------------------ | | 18| 1.12M|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 641| 1.12M|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 113| 4.48M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 1.12M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 1.12M] | | | | | | | Branch (113:42): [True: 1.12M, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1159| 0| k = cl->p->k; 1160| 2.24M| pc = ci->u.l.savedpc; 1161| 2.24M| if (l_unlikely(trap)) ------------------ | | 697| 1.12M|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 1.12M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 1.12M] | | | | ------------------ | | ------------------ ------------------ 1162| 0| trap = luaG_tracecall(L); 1163| 2.24M| base = ci->func.p + 1; 1164| | /* main loop of interpreter */ 1165| 2.24M| for (;;) { 1166| 1.12M| Instruction i; /* instruction being executed */ 1167| 1.12M| vmfetch(); ------------------ | | 1133| 1.12M|#define vmfetch() { \ | | 1134| 1.12M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | ------------------ | | | | 697| 1.12M|#define l_unlikely(x) luai_unlikely(x) | | | | ------------------ | | | | | | 685| 1.12M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | ------------------ | | | | | | | Branch (685:26): [True: 0, False: 1.12M] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | 1136| 0| updatebase(ci); /* correct stack */ \ | | ------------------ | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | ------------------ | | 1137| 0| } \ | | 1138| 1.12M| i = *(pc++); \ | | 1139| 1.12M|} ------------------ 1168| | #if 0 1169| | /* low-level line tracing for debugging Lua */ 1170| | printf("line: %d\n", luaG_getfuncline(cl->p, pcRel(pc, cl->p))); 1171| | #endif 1172| 1.12M| lua_assert(base == ci->func.p + 1); ------------------ | | 109| 1.12M|#define lua_assert(c) assert(c) ------------------ 1173| 1.12M| lua_assert(base <= L->top.p && L->top.p <= L->stack_last.p); ------------------ | | 109| 1.12M|#define lua_assert(c) assert(c) ------------------ 1174| | /* invalidate top for instructions not expecting it */ 1175| 1.12M| lua_assert(isIT(i) || (cast_void(L->top.p = base), 1)); ------------------ | | 109| 1.12M|#define lua_assert(c) assert(c) ------------------ 1176| 1.12M| vmdispatch (GET_OPCODE(i)) { ------------------ | | 12| 1.12M|#define vmdispatch(x) goto *disptab[x]; ------------------ 1177| 1.21M| vmcase(OP_MOVE) { ------------------ | | 14| 1.21M|#define vmcase(l) L_##l: ------------------ 1178| 1.21M| StkId ra = RA(i); ------------------ | | 1059| 1.21M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1.21M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1.21M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 1.21M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 1.21M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1179| 1.21M| setobjs2s(L, ra, RB(i)); ------------------ | | 129| 1.21M|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 4.84M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | ------------------ | | | | | Branch (119:43): [True: 0, False: 1.21M] | | | | | Branch (119:43): [True: 1.21M, False: 0] | | | | ------------------ | | | | 120| 1.21M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 1.21M|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 1.21M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 1.21M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 9.73M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.21M|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 568k] | | | | | | | | | Branch (115:29): [True: 568k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 568k] | | | | | | | | | Branch (115:29): [True: 568k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 568k] | | | | | | | | | Branch (115:29): [True: 568k, False: 0] | | | | | | | | | Branch (115:29): [True: 568k, False: 0] | | | | | | | | | Branch (115:29): [True: 642k, False: 568k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 1.21M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 1.21M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1180| 1.21M| vmbreak; ------------------ | | 16| 1.21M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 1.21M|#define vmfetch() { \ | | | | 1134| 1.21M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.21M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.21M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1.21M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 1.21M| i = *(pc++); \ | | | | 1139| 1.21M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.21M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1181| 1.21M| } 1182| 640k| vmcase(OP_LOADI) { ------------------ | | 14| 640k|#define vmcase(l) L_##l: ------------------ 1183| 640k| StkId ra = RA(i); ------------------ | | 1059| 640k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 640k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 640k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 640k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 640k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1184| 640k| lua_Integer b = GETARG_sBx(i); ------------------ | | 147| 640k| check_exp(checkopm(i, iAsBx), getarg(i, POS_Bx, SIZE_Bx) - OFFSET_sBx) | | ------------------ | | | | 113| 640k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 640k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1185| 640k| setivalue(s2v(ra), b); ------------------ | | 358| 640k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 640k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 640k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1186| 640k| vmbreak; ------------------ | | 16| 640k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 640k|#define vmfetch() { \ | | | | 1134| 640k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 640k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 640k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 640k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 640k| i = *(pc++); \ | | | | 1139| 640k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 640k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1187| 640k| } 1188| 6.29k| vmcase(OP_LOADF) { ------------------ | | 14| 6.29k|#define vmcase(l) L_##l: ------------------ 1189| 6.29k| StkId ra = RA(i); ------------------ | | 1059| 6.29k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 6.29k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 6.29k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 6.29k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 6.29k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1190| 6.29k| int b = GETARG_sBx(i); ------------------ | | 147| 6.29k| check_exp(checkopm(i, iAsBx), getarg(i, POS_Bx, SIZE_Bx) - OFFSET_sBx) | | ------------------ | | | | 113| 6.29k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 6.29k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1191| 6.29k| setfltvalue(s2v(ra), cast_num(b)); ------------------ | | 352| 6.29k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 6.29k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 6.29k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1192| 6.29k| vmbreak; ------------------ | | 16| 6.29k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 6.29k|#define vmfetch() { \ | | | | 1134| 6.29k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 6.29k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 6.29k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 6.29k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 6.29k| i = *(pc++); \ | | | | 1139| 6.29k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 6.29k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1193| 6.29k| } 1194| 1.20M| vmcase(OP_LOADK) { ------------------ | | 14| 1.20M|#define vmcase(l) L_##l: ------------------ 1195| 1.20M| StkId ra = RA(i); ------------------ | | 1059| 1.20M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1.20M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1.20M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 1.20M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 1.20M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1196| 1.20M| TValue *rb = k + GETARG_Bx(i); ------------------ | | 140| 1.20M|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 113| 1.20M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 1.20M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1197| 1.20M| setobj2s(L, ra, rb); ------------------ | | 131| 1.20M|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 1.20M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 1.20M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 1.20M|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 1.20M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 1.20M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 17.5M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.20M|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 1.08M] | | | | | | | | | Branch (115:29): [True: 1.08M, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 1.08M] | | | | | | | | | Branch (115:29): [True: 1.08M, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 1.08M] | | | | | | | | | Branch (115:29): [True: 1.08M, False: 0] | | | | | | | | | Branch (115:29): [True: 1.08M, False: 0] | | | | | | | | | Branch (115:29): [True: 122k, False: 1.08M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 1.20M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 1.20M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1198| 1.20M| vmbreak; ------------------ | | 16| 1.20M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 1.20M|#define vmfetch() { \ | | | | 1134| 1.20M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.20M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.20M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1.20M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 1.20M| i = *(pc++); \ | | | | 1139| 1.20M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.20M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1199| 1.20M| } 1200| 0| vmcase(OP_LOADKX) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1201| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1202| 0| TValue *rb; 1203| 0| rb = k + GETARG_Ax(*pc); pc++; ------------------ | | 143| 0|#define GETARG_Ax(i) check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1204| 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) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1205| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1206| 0| } 1207| 0| vmcase(OP_LOADFALSE) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1208| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1209| 0| setbfvalue(s2v(ra)); ------------------ | | 263| 0|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1210| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1211| 0| } 1212| 89.1k| vmcase(OP_LFALSESKIP) { ------------------ | | 14| 89.1k|#define vmcase(l) L_##l: ------------------ 1213| 89.1k| StkId ra = RA(i); ------------------ | | 1059| 89.1k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 89.1k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 89.1k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 89.1k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 89.1k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1214| 89.1k| setbfvalue(s2v(ra)); ------------------ | | 263| 89.1k|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 89.1k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1215| 89.1k| pc++; /* skip next instruction */ 1216| 89.1k| vmbreak; ------------------ | | 16| 89.1k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 89.1k|#define vmfetch() { \ | | | | 1134| 89.1k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 89.1k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 89.1k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 89.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 89.1k| i = *(pc++); \ | | | | 1139| 89.1k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 89.1k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1217| 89.1k| } 1218| 89.1k| vmcase(OP_LOADTRUE) { ------------------ | | 14| 58.3k|#define vmcase(l) L_##l: ------------------ 1219| 58.3k| StkId ra = RA(i); ------------------ | | 1059| 58.3k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 58.3k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 58.3k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 58.3k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 58.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1220| 58.3k| setbtvalue(s2v(ra)); ------------------ | | 264| 58.3k|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 58.3k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1221| 58.3k| vmbreak; ------------------ | | 16| 58.3k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 58.3k|#define vmfetch() { \ | | | | 1134| 58.3k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 58.3k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 58.3k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 58.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 58.3k| i = *(pc++); \ | | | | 1139| 58.3k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 58.3k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1222| 58.3k| } 1223| 75.4k| vmcase(OP_LOADNIL) { ------------------ | | 14| 75.4k|#define vmcase(l) L_##l: ------------------ 1224| 75.4k| StkId ra = RA(i); ------------------ | | 1059| 75.4k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 75.4k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 75.4k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 75.4k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 75.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1225| 75.4k| int b = GETARG_B(i); ------------------ | | 128| 75.4k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 75.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 75.4k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1226| 380k| do { 1227| 380k| setnilvalue(s2v(ra++)); ------------------ | | 211| 380k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 380k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1228| 380k| } while (b--); ------------------ | Branch (1228:18): [True: 305k, False: 75.4k] ------------------ 1229| 75.4k| vmbreak; ------------------ | | 16| 75.4k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 75.4k|#define vmfetch() { \ | | | | 1134| 75.4k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 75.4k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 75.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 75.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 75.4k| i = *(pc++); \ | | | | 1139| 75.4k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 75.4k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1230| 75.4k| } 1231| 1.37M| vmcase(OP_GETUPVAL) { ------------------ | | 14| 1.37M|#define vmcase(l) L_##l: ------------------ 1232| 1.37M| StkId ra = RA(i); ------------------ | | 1059| 1.37M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1.37M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1.37M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 1.37M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 1.37M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1233| 1.37M| int b = GETARG_B(i); ------------------ | | 128| 1.37M|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 1.37M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 1.37M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1234| 1.37M| setobj2s(L, ra, cl->upvals[b]->v.p); ------------------ | | 131| 1.37M|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 1.37M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 1.37M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 1.37M|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 1.37M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 1.37M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 21.0M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.37M|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 1.30M] | | | | | | | | | Branch (115:29): [True: 1.30M, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 1.30M] | | | | | | | | | Branch (115:29): [True: 1.30M, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 1.30M] | | | | | | | | | Branch (115:29): [True: 1.30M, False: 0] | | | | | | | | | Branch (115:29): [True: 1.30M, False: 0] | | | | | | | | | Branch (115:29): [True: 69.6k, False: 1.30M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 1.37M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 1.37M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1235| 1.37M| vmbreak; ------------------ | | 16| 1.37M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 1.37M|#define vmfetch() { \ | | | | 1134| 1.37M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.37M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.37M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1.37M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 1.37M| i = *(pc++); \ | | | | 1139| 1.37M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.37M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1236| 1.37M| } 1237| 560k| vmcase(OP_SETUPVAL) { ------------------ | | 14| 560k|#define vmcase(l) L_##l: ------------------ 1238| 560k| StkId ra = RA(i); ------------------ | | 1059| 560k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 560k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 560k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 560k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 560k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1239| 560k| UpVal *uv = cl->upvals[GETARG_B(i)]; ------------------ | | 128| 560k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 560k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 560k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1240| 560k| setobj(L, uv->v.p, s2v(ra)); ------------------ | | 119| 560k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 560k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 560k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 560k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 560k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 115| 8.96M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 560k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 560k] | | | | | | | Branch (115:29): [True: 560k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 560k] | | | | | | | Branch (115:29): [True: 560k, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 560k] | | | | | | | Branch (115:29): [True: 560k, False: 0] | | | | | | | Branch (115:29): [True: 560k, False: 0] | | | | | | | Branch (115:29): [True: 3, False: 560k] | | | | | | ------------------ | | | | ------------------ | | | | 108| 560k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 109| 560k|#define lua_assert(c) assert(c) | | ------------------ ------------------ 1241| 560k| luaC_barrier(L, uv, s2v(ra)); ------------------ | | 226| 560k|#define luaC_barrier(L,p,v) ( \ | | 227| 560k| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 313| 560k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 560k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 311| 560k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (313:26): [True: 560k, False: 3] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 222| 560k|#define luaC_objbarrier(L,p,o) ( \ | | | | 223| 560k| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 91| 560k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 70| 560k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 65| 1.12M|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (65:24): [True: 12.5k, False: 547k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 90| 12.5k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 50.0k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 12.5k, False: 2] | | | | | | | | | Branch (65:26): [True: 0, False: 12.5k] | | | | | | | | | Branch (65:26): [True: 12.5k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 224| 560k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 388| 12.5k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 12.5k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 12.5k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 388| 12.5k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 50.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 12.5k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (113:42): [True: 0, False: 12.5k] | | | | | | | | | Branch (113:42): [True: 12.5k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 141| 547k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 139| 547k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 141| 3|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 3|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1242| 560k| vmbreak; ------------------ | | 16| 560k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 560k|#define vmfetch() { \ | | | | 1134| 560k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 560k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 560k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 560k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 560k| i = *(pc++); \ | | | | 1139| 560k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 560k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1243| 560k| } 1244| 2.23M| vmcase(OP_GETTABUP) { ------------------ | | 14| 2.23M|#define vmcase(l) L_##l: ------------------ 1245| 2.23M| StkId ra = RA(i); ------------------ | | 1059| 2.23M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 2.23M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 2.23M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 2.23M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 2.23M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1246| 2.23M| TValue *upval = cl->upvals[GETARG_B(i)]->v.p; ------------------ | | 128| 2.23M|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 2.23M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 2.23M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1247| 2.23M| TValue *rc = KC(i); ------------------ | | 1065| 2.23M|#define KC(i) (k+GETARG_C(i)) | | ------------------ | | | | 132| 2.23M|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 113| 2.23M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 2.23M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1248| 4.47M| TString *key = tsvalue(rc); /* key must be a short string */ ------------------ | | 382| 2.23M|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 8.94M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 2.23M|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 2.23M] | | | | | Branch (113:42): [True: 2.23M, False: 0] | | | | ------------------ | | ------------------ ------------------ 1249| 0| int tag; 1250| 4.47M| luaV_fastget(upval, key, s2v(ra), luaH_getshortstr, tag); ------------------ | | 82| 4.47M| (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 719| 2.23M|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 2.23M|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 2.23M|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 192| 0|#define LUA_VNOTABLE makevariant(LUA_TNIL, 3) | | | | ------------------ | | | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 721| 2.23M|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 113| 8.94M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 2.23M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 2.23M] | | | | | | | Branch (113:42): [True: 2.23M, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:11): [True: 0, False: 2.23M] | | ------------------ ------------------ 1251| 2.23M| if (tagisempty(tag)) ------------------ | | 204| 2.23M|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 80| 2.23M|#define novariant(t) ((t) & 0x0F) | | ------------------ | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 64| 2.23M|#define LUA_TNIL 0 | | ------------------ | | | Branch (204:26): [True: 1.19M, False: 1.03M] | | ------------------ ------------------ 1252| 1.19M| Protect(luaV_finishget(L, upval, rc, ra, tag)); ------------------ | | 1114| 1.19M|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 1.19M|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 1.19M|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 1.19M|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1253| 4.47M| vmbreak; ------------------ | | 16| 2.23M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 2.23M|#define vmfetch() { \ | | | | 1134| 2.23M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 2.23M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 2.23M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 54, False: 2.23M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 54| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 54| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 54|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 54| } \ | | | | 1138| 2.23M| i = *(pc++); \ | | | | 1139| 2.23M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 2.23M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1254| 4.47M| } 1255| 113k| vmcase(OP_GETTABLE) { ------------------ | | 14| 113k|#define vmcase(l) L_##l: ------------------ 1256| 113k| StkId ra = RA(i); ------------------ | | 1059| 113k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 113k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 113k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 113k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 113k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1257| 113k| TValue *rb = vRB(i); ------------------ | | 1061| 113k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 452k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 113k] | | | | | Branch (172:19): [True: 113k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1258| 113k| TValue *rc = vRC(i); ------------------ | | 1064| 113k|#define vRC(i) s2v(RC(i)) | | ------------------ | | | | 172| 452k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 113k] | | | | | Branch (172:19): [True: 113k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1259| 0| int tag; 1260| 113k| if (ttisinteger(rc)) { /* fast track for integers? */ ------------------ | | 341| 113k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 113k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 113k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 82.7k, False: 30.3k] | | | | ------------------ | | ------------------ ------------------ 1261| 82.7k| luaV_fastgeti(rb, ivalue(rc), s2v(ra), tag); ------------------ | | 90| 82.7k| if (!ttistable(t)) tag = LUA_VNOTABLE; \ | | ------------------ | | | | 719| 82.7k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 82.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 82.7k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (!ttistable(t)) tag = LUA_VNOTABLE; \ | | ------------------ | | | | 192| 0|#define LUA_VNOTABLE makevariant(LUA_TNIL, 3) | | | | ------------------ | | | | | | 42| 82.7k|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (90:7): [True: 0, False: 82.7k] | | ------------------ | | 91| 248k| else { luaH_fastgeti(hvalue(t), k, res, tag); } | | ------------------ | | | | 50| 661k| { Table *h = t; lua_Unsigned u = l_castS2U(k); \ | | | | ------------------ | | | | | | 155| 330k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | | | | | ------------------ | | | | | | | Branch (155:38): [True: 0, False: 82.7k] | | | | | | | Branch (155:38): [True: 82.7k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (50:16): [True: 0, False: 82.7k] | | | | | Branch (50:16): [True: 82.7k, False: 0] | | | | | Branch (50:16): [True: 0, False: 82.7k] | | | | | Branch (50:16): [True: 82.7k, False: 0] | | | | ------------------ | | | | 51| 82.7k| if ((u - 1u < h->alimit)) { \ | | | | ------------------ | | | | | Branch (51:9): [True: 6.13k, False: 76.5k] | | | | ------------------ | | | | 52| 6.13k| tag = *getArrTag(h,(u)-1u); \ | | | | ------------------ | | | | | | 106| 6.13k|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | | | | | ------------------ | | | | | | | | 139| 6.13k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | 53| 6.13k| if (!tagisempty(tag)) { farr2val(h, u, tag, res); }} \ | | | | ------------------ | | | | | | 204| 6.13k|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | | | | | ------------------ | | | | | | | | 80| 6.13k|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | | | | | ------------------ | | | | | | | | 64| 6.13k|#define LUA_TNIL 0 | | | | | | ------------------ | | | | ------------------ | | | | if (!tagisempty(tag)) { farr2val(h, u, tag, res); }} \ | | | | ------------------ | | | | | | 128| 6.13k| ((res)->tt_ = tag, (res)->value_ = *getArrVal(h,(k)-1u)) | | | | | | ------------------ | | | | | | | | 109| 6.13k|#define getArrVal(t,k) ((t)->array - 1 - (k)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (53:11): [True: 6.13k, False: 0] | | | | ------------------ | | | | 54| 82.7k| else { tag = luaH_getint(h, u, res); }} | | ------------------ ------------------ 1262| 82.7k| } 1263| 30.3k| else 1264| 30.3k| luaV_fastget(rb, rc, s2v(ra), luaH_get, tag); ------------------ | | 82| 60.7k| (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 719| 30.3k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 30.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 30.3k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 192| 0|#define LUA_VNOTABLE makevariant(LUA_TNIL, 3) | | | | ------------------ | | | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 721| 30.3k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 113| 121k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 30.3k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 30.3k] | | | | | | | Branch (113:42): [True: 30.3k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:11): [True: 0, False: 30.3k] | | ------------------ ------------------ 1265| 113k| if (tagisempty(tag)) ------------------ | | 204| 113k|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 80| 113k|#define novariant(t) ((t) & 0x0F) | | ------------------ | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 64| 113k|#define LUA_TNIL 0 | | ------------------ | | | Branch (204:26): [True: 37.6k, False: 75.4k] | | ------------------ ------------------ 1266| 37.6k| Protect(luaV_finishget(L, rb, rc, ra, tag)); ------------------ | | 1114| 37.6k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 37.6k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 37.6k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 37.6k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1267| 113k| vmbreak; ------------------ | | 16| 113k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 113k|#define vmfetch() { \ | | | | 1134| 113k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 113k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 113k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 27, False: 113k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 27| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 27| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 27|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 27| } \ | | | | 1138| 113k| i = *(pc++); \ | | | | 1139| 113k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 113k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1268| 113k| } 1269| 3| vmcase(OP_GETI) { ------------------ | | 14| 3|#define vmcase(l) L_##l: ------------------ 1270| 3| StkId ra = RA(i); ------------------ | | 1059| 3|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 3|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 3|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 3|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 3|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1271| 3| TValue *rb = vRB(i); ------------------ | | 1061| 3|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 12|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 3] | | | | | Branch (172:19): [True: 3, False: 0] | | | | ------------------ | | ------------------ ------------------ 1272| 3| int c = GETARG_C(i); ------------------ | | 132| 3|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 113| 3|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 3|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1273| 0| int tag; 1274| 3| luaV_fastgeti(rb, c, s2v(ra), tag); ------------------ | | 90| 3| if (!ttistable(t)) tag = LUA_VNOTABLE; \ | | ------------------ | | | | 719| 3|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 3|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 3|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (!ttistable(t)) tag = LUA_VNOTABLE; \ | | ------------------ | | | | 192| 0|#define LUA_VNOTABLE makevariant(LUA_TNIL, 3) | | | | ------------------ | | | | | | 42| 3|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (90:7): [True: 0, False: 3] | | ------------------ | | 91| 6| else { luaH_fastgeti(hvalue(t), k, res, tag); } | | ------------------ | | | | 50| 24| { Table *h = t; lua_Unsigned u = l_castS2U(k); \ | | | | ------------------ | | | | | | 155| 3|#define l_castS2U(i) ((lua_Unsigned)(i)) | | | | ------------------ | | | | | Branch (50:16): [True: 0, False: 3] | | | | | Branch (50:16): [True: 3, False: 0] | | | | | Branch (50:16): [True: 0, False: 3] | | | | | Branch (50:16): [True: 3, False: 0] | | | | ------------------ | | | | 51| 3| if ((u - 1u < h->alimit)) { \ | | | | ------------------ | | | | | Branch (51:9): [True: 0, False: 3] | | | | ------------------ | | | | 52| 0| tag = *getArrTag(h,(u)-1u); \ | | | | ------------------ | | | | | | 106| 0|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | | | | | ------------------ | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | 53| 0| if (!tagisempty(tag)) { farr2val(h, u, tag, res); }} \ | | | | ------------------ | | | | | | 204| 0|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | | | | | ------------------ | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | | | | | ------------------ | | | | | | | | 64| 0|#define LUA_TNIL 0 | | | | | | ------------------ | | | | ------------------ | | | | if (!tagisempty(tag)) { farr2val(h, u, tag, res); }} \ | | | | ------------------ | | | | | | 128| 0| ((res)->tt_ = tag, (res)->value_ = *getArrVal(h,(k)-1u)) | | | | | | ------------------ | | | | | | | | 109| 0|#define getArrVal(t,k) ((t)->array - 1 - (k)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (53:11): [True: 0, False: 0] | | | | ------------------ | | | | 54| 3| else { tag = luaH_getint(h, u, res); }} | | ------------------ ------------------ 1275| 3| if (tagisempty(tag)) { ------------------ | | 204| 3|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 80| 3|#define novariant(t) ((t) & 0x0F) | | ------------------ | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 64| 3|#define LUA_TNIL 0 | | ------------------ | | | Branch (204:26): [True: 3, False: 0] | | ------------------ ------------------ 1276| 3| TValue key; 1277| 3| setivalue(&key, c); ------------------ | | 358| 3| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 3|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 3|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1278| 3| Protect(luaV_finishget(L, rb, &key, ra, tag)); ------------------ | | 1114| 3|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 3|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 3|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 3|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1279| 3| } 1280| 3| vmbreak; ------------------ | | 16| 3|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 3|#define vmfetch() { \ | | | | 1134| 3| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 3| i = *(pc++); \ | | | | 1139| 3|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 3|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1281| 3| } 1282| 6| vmcase(OP_GETFIELD) { ------------------ | | 14| 6|#define vmcase(l) L_##l: ------------------ 1283| 6| StkId ra = RA(i); ------------------ | | 1059| 6|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 6|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 6|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 6|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 6|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1284| 6| TValue *rb = vRB(i); ------------------ | | 1061| 6|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 24|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 6] | | | | | Branch (172:19): [True: 6, False: 0] | | | | ------------------ | | ------------------ ------------------ 1285| 6| TValue *rc = KC(i); ------------------ | | 1065| 6|#define KC(i) (k+GETARG_C(i)) | | ------------------ | | | | 132| 6|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 113| 6|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 6|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1286| 12| TString *key = tsvalue(rc); /* key must be a short string */ ------------------ | | 382| 6|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 24|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 6|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 6] | | | | | Branch (113:42): [True: 6, False: 0] | | | | ------------------ | | ------------------ ------------------ 1287| 0| int tag; 1288| 12| luaV_fastget(rb, key, s2v(ra), luaH_getshortstr, tag); ------------------ | | 82| 6| (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 719| 6|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 6|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 6|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 192| 6|#define LUA_VNOTABLE makevariant(LUA_TNIL, 3) | | | | ------------------ | | | | | | 42| 6|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 721| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:11): [True: 6, False: 0] | | ------------------ ------------------ 1289| 6| if (tagisempty(tag)) ------------------ | | 204| 6|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 80| 6|#define novariant(t) ((t) & 0x0F) | | ------------------ | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 64| 6|#define LUA_TNIL 0 | | ------------------ | | | Branch (204:26): [True: 6, False: 0] | | ------------------ ------------------ 1290| 6| Protect(luaV_finishget(L, rb, rc, ra, tag)); ------------------ | | 1114| 6|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 6|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 6|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 6|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1291| 12| vmbreak; ------------------ | | 16| 6|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 6|#define vmfetch() { \ | | | | 1134| 6| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 6|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 6|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 6] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 6| i = *(pc++); \ | | | | 1139| 6|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 6|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1292| 12| } 1293| 2.37M| vmcase(OP_SETTABUP) { ------------------ | | 14| 2.37M|#define vmcase(l) L_##l: ------------------ 1294| 2.37M| int hres; 1295| 2.37M| TValue *upval = cl->upvals[GETARG_A(i)]->v.p; ------------------ | | 125| 2.37M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 2.37M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 144| 2.37M|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 2.37M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1296| 2.37M| TValue *rb = KB(i); ------------------ | | 1062| 2.37M|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 2.37M|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 113| 2.37M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 2.37M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1297| 2.37M| TValue *rc = RKC(i); ------------------ | | 1066| 2.37M|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 2.37M|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 113| 2.37M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 2.37M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 1.55M|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 113| 1.55M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 1.55M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 3.28M|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 822k] | | | | | Branch (172:19): [True: 822k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1066:17): [True: 1.55M, False: 822k] | | ------------------ ------------------ 1298| 4.75M| TString *key = tsvalue(rb); /* key must be a short string */ ------------------ | | 382| 2.37M|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 9.51M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 2.37M|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 2.37M] | | | | | Branch (113:42): [True: 2.37M, False: 0] | | | | ------------------ | | ------------------ ------------------ 1299| 2.37M| luaV_fastset(upval, key, rc, hres, luaH_psetshortstr); ------------------ | | 95| 4.75M| (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 719| 2.37M|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 2.37M|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 2.37M|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 69| 0|#define HNOTATABLE 2 | | ------------------ | | (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 721| 2.37M|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 113| 9.51M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 2.37M|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 2.37M] | | | | | | | Branch (113:42): [True: 2.37M, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (95:12): [True: 0, False: 2.37M] | | ------------------ ------------------ 1300| 2.37M| if (hres == HOK) ------------------ | | 67| 2.37M|#define HOK 0 ------------------ | Branch (1300:13): [True: 1.75M, False: 627k] ------------------ 1301| 2.37M| luaV_finishfastset(L, upval, rc); ------------------ | | 105| 1.75M|#define luaV_finishfastset(L,t,v) luaC_barrierback(L, gcvalue(t), v) | | ------------------ | | | | 232| 1.75M|#define luaC_barrierback(L,p,v) ( \ | | | | 233| 1.75M| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 313| 1.75M|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 1.75M|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 311| 1.75M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (313:26): [True: 520k, False: 1.23M] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 229| 520k|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 230| 520k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 91| 520k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 70| 520k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 2.08M|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (65:24): [True: 362k, False: 158k] | | | | | | | | | | | | | Branch (65:26): [True: 0, False: 520k] | | | | | | | | | | | | | Branch (65:26): [True: 520k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 90| 362k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 65| 1.45M|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (65:24): [True: 1.08k, False: 361k] | | | | | | | | | | | Branch (65:26): [True: 0, False: 362k] | | | | | | | | | | | Branch (65:26): [True: 362k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 141| 519k|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 519k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (230:51): [True: 0, False: 1.08k] | | | | | | | Branch (230:51): [True: 1.08k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 141| 1.23M|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 139| 1.23M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1302| 627k| else 1303| 627k| Protect(luaV_finishset(L, upval, rb, rc, hres)); ------------------ | | 1114| 627k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 627k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 627k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 627k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1304| 2.37M| vmbreak; ------------------ | | 16| 2.37M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 2.37M|#define vmfetch() { \ | | | | 1134| 2.37M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 2.37M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 2.37M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 46, False: 2.37M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 46| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 46| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 46|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 46| } \ | | | | 1138| 2.37M| i = *(pc++); \ | | | | 1139| 2.37M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 2.37M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1305| 4.75M| } 1306| 448k| vmcase(OP_SETTABLE) { ------------------ | | 14| 448k|#define vmcase(l) L_##l: ------------------ 1307| 448k| StkId ra = RA(i); ------------------ | | 1059| 448k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 448k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 448k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 448k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 448k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1308| 448k| int hres; 1309| 448k| TValue *rb = vRB(i); /* key (table is in 'ra') */ ------------------ | | 1061| 448k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 1.79M|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 448k] | | | | | Branch (172:19): [True: 448k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1310| 448k| TValue *rc = RKC(i); /* value */ ------------------ | | 1066| 448k|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 448k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 113| 448k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 448k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 261k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 113| 261k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 261k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 745k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 186k] | | | | | Branch (172:19): [True: 186k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1066:17): [True: 261k, False: 186k] | | ------------------ ------------------ 1311| 448k| if (ttisinteger(rb)) { /* fast track for integers? */ ------------------ | | 341| 448k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 448k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 448k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 395k, False: 52.4k] | | | | ------------------ | | ------------------ ------------------ 1312| 395k| luaV_fastseti(s2v(ra), ivalue(rb), rc, hres); ------------------ | | 98| 395k| if (!ttistable(t)) hres = HNOTATABLE; \ | | ------------------ | | | | 719| 395k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 395k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 395k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (!ttistable(t)) hres = HNOTATABLE; \ | | ------------------ | | | | 69| 395k|#define HNOTATABLE 2 | | ------------------ | | | Branch (98:7): [True: 0, False: 395k] | | ------------------ | | 99| 1.18M| else { luaH_fastseti(hvalue(t), k, val, hres); } | | ------------------ | | | | 58| 3.16M| { Table *h = t; lua_Unsigned u = l_castS2U(k); \ | | | | ------------------ | | | | | | 155| 1.58M|#define l_castS2U(i) ((lua_Unsigned)(i)) | | | | | | ------------------ | | | | | | | Branch (155:38): [True: 0, False: 395k] | | | | | | | Branch (155:38): [True: 395k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (58:16): [True: 0, False: 395k] | | | | | Branch (58:16): [True: 395k, False: 0] | | | | | Branch (58:16): [True: 0, False: 395k] | | | | | Branch (58:16): [True: 395k, False: 0] | | | | ------------------ | | | | 59| 395k| if ((u - 1u < h->alimit)) { \ | | | | ------------------ | | | | | Branch (59:9): [True: 85.6k, False: 310k] | | | | ------------------ | | | | 60| 85.6k| lu_byte *tag = getArrTag(h,(u)-1u); \ | | | | ------------------ | | | | | | 106| 85.6k|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | | | | | ------------------ | | | | | | | | 139| 85.6k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | 61| 85.6k| if (tagisempty(*tag)) hres = ~cast_int(u); \ | | | | ------------------ | | | | | | 204| 85.6k|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | | | | | ------------------ | | | | | | | | 80| 85.6k|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | | | | | ------------------ | | | | | | | | 64| 85.6k|#define LUA_TNIL 0 | | | | | | ------------------ | | | | | | | Branch (204:26): [True: 6.23k, False: 79.4k] | | | | | | ------------------ | | | | ------------------ | | | | if (tagisempty(*tag)) hres = ~cast_int(u); \ | | | | ------------------ | | | | | | 144| 6.23k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 91.9k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | 62| 85.6k| else { fval2arr(h, u, tag, val); hres = HOK; }} \ | | | | ------------------ | | | | | | 131| 79.4k| (*tag = (val)->tt_, *getArrVal(h,(k)-1u) = (val)->value_) | | | | | | ------------------ | | | | | | | | 109| 79.4k|#define getArrVal(t,k) ((t)->array - 1 - (k)) | | | | | | ------------------ | | | | ------------------ | | | | else { fval2arr(h, u, tag, val); hres = HOK; }} \ | | | | ------------------ | | | | | | 67| 79.4k|#define HOK 0 | | | | ------------------ | | | | 63| 395k| else { hres = luaH_psetint(h, u, val); }} | | ------------------ ------------------ 1313| 395k| } 1314| 52.4k| else { 1315| 52.4k| luaV_fastset(s2v(ra), rb, rc, hres, luaH_pset); ------------------ | | 95| 104k| (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 719| 52.4k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 52.4k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 52.4k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 69| 0|#define HNOTATABLE 2 | | ------------------ | | (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 721| 52.4k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 113| 209k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 52.4k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 52.4k] | | | | | | | Branch (113:42): [True: 52.4k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (95:12): [True: 0, False: 52.4k] | | ------------------ ------------------ 1316| 52.4k| } 1317| 448k| if (hres == HOK) ------------------ | | 67| 448k|#define HOK 0 ------------------ | Branch (1317:13): [True: 369k, False: 78.9k] ------------------ 1318| 448k| luaV_finishfastset(L, s2v(ra), rc); ------------------ | | 105| 369k|#define luaV_finishfastset(L,t,v) luaC_barrierback(L, gcvalue(t), v) | | ------------------ | | | | 232| 369k|#define luaC_barrierback(L,p,v) ( \ | | | | 233| 369k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 313| 369k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 369k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 311| 369k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (313:26): [True: 28.3k, False: 340k] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 229| 28.3k|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 230| 28.3k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 91| 28.3k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 70| 28.3k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 113k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (65:24): [True: 126, False: 28.2k] | | | | | | | | | | | | | Branch (65:26): [True: 0, False: 28.3k] | | | | | | | | | | | | | Branch (65:26): [True: 28.3k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 90| 126|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 65| 504|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (65:24): [True: 24, False: 102] | | | | | | | | | | | Branch (65:26): [True: 0, False: 126] | | | | | | | | | | | Branch (65:26): [True: 126, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 141| 28.3k|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 28.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (230:51): [True: 0, False: 24] | | | | | | | Branch (230:51): [True: 24, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 141| 340k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 139| 340k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1319| 78.9k| else 1320| 78.9k| Protect(luaV_finishset(L, s2v(ra), rb, rc, hres)); ------------------ | | 1114| 78.9k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 78.9k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 78.9k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 78.9k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1321| 448k| vmbreak; ------------------ | | 16| 448k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 448k|#define vmfetch() { \ | | | | 1134| 448k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 448k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 448k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 448k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 448k| i = *(pc++); \ | | | | 1139| 448k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 448k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1322| 448k| } 1323| 35.0k| vmcase(OP_SETI) { ------------------ | | 14| 35.0k|#define vmcase(l) L_##l: ------------------ 1324| 35.0k| StkId ra = RA(i); ------------------ | | 1059| 35.0k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 35.0k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 35.0k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 35.0k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 35.0k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1325| 35.0k| int hres; 1326| 35.0k| int b = GETARG_B(i); ------------------ | | 128| 35.0k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 35.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 35.0k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1327| 35.0k| TValue *rc = RKC(i); ------------------ | | 1066| 35.0k|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 35.0k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 113| 35.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 35.0k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 240|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 113| 240|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 240|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 139k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 34.8k] | | | | | Branch (172:19): [True: 34.8k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1066:17): [True: 240, False: 34.8k] | | ------------------ ------------------ 1328| 35.0k| luaV_fastseti(s2v(ra), b, rc, hres); ------------------ | | 98| 35.0k| if (!ttistable(t)) hres = HNOTATABLE; \ | | ------------------ | | | | 719| 35.0k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 35.0k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 35.0k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (!ttistable(t)) hres = HNOTATABLE; \ | | ------------------ | | | | 69| 35.0k|#define HNOTATABLE 2 | | ------------------ | | | Branch (98:7): [True: 0, False: 35.0k] | | ------------------ | | 99| 70.0k| else { luaH_fastseti(hvalue(t), k, val, hres); } | | ------------------ | | | | 58| 280k| { Table *h = t; lua_Unsigned u = l_castS2U(k); \ | | | | ------------------ | | | | | | 155| 35.0k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | | | ------------------ | | | | | Branch (58:16): [True: 0, False: 35.0k] | | | | | Branch (58:16): [True: 35.0k, False: 0] | | | | | Branch (58:16): [True: 0, False: 35.0k] | | | | | Branch (58:16): [True: 35.0k, False: 0] | | | | ------------------ | | | | 59| 35.0k| if ((u - 1u < h->alimit)) { \ | | | | ------------------ | | | | | Branch (59:9): [True: 30.8k, False: 4.20k] | | | | ------------------ | | | | 60| 30.8k| lu_byte *tag = getArrTag(h,(u)-1u); \ | | | | ------------------ | | | | | | 106| 30.8k|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | | | | | ------------------ | | | | | | | | 139| 30.8k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | 61| 30.8k| if (tagisempty(*tag)) hres = ~cast_int(u); \ | | | | ------------------ | | | | | | 204| 30.8k|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | | | | | ------------------ | | | | | | | | 80| 30.8k|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | | | | | ------------------ | | | | | | | | 64| 30.8k|#define LUA_TNIL 0 | | | | | | ------------------ | | | | | | | Branch (204:26): [True: 22.6k, False: 8.22k] | | | | | | ------------------ | | | | ------------------ | | | | if (tagisempty(*tag)) hres = ~cast_int(u); \ | | | | ------------------ | | | | | | 144| 22.6k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 139| 53.4k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | 62| 30.8k| else { fval2arr(h, u, tag, val); hres = HOK; }} \ | | | | ------------------ | | | | | | 131| 8.22k| (*tag = (val)->tt_, *getArrVal(h,(k)-1u) = (val)->value_) | | | | | | ------------------ | | | | | | | | 109| 8.22k|#define getArrVal(t,k) ((t)->array - 1 - (k)) | | | | | | ------------------ | | | | ------------------ | | | | else { fval2arr(h, u, tag, val); hres = HOK; }} \ | | | | ------------------ | | | | | | 67| 8.22k|#define HOK 0 | | | | ------------------ | | | | 63| 35.0k| else { hres = luaH_psetint(h, u, val); }} | | ------------------ ------------------ 1329| 35.0k| if (hres == HOK) ------------------ | | 67| 35.0k|#define HOK 0 ------------------ | Branch (1329:13): [True: 12.2k, False: 22.7k] ------------------ 1330| 35.0k| luaV_finishfastset(L, s2v(ra), rc); ------------------ | | 105| 12.2k|#define luaV_finishfastset(L,t,v) luaC_barrierback(L, gcvalue(t), v) | | ------------------ | | | | 232| 12.2k|#define luaC_barrierback(L,p,v) ( \ | | | | 233| 12.2k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 313| 12.2k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 12.2k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 311| 12.2k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (313:26): [True: 0, False: 12.2k] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 229| 0|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 230| 0| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 91| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 70| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 141| 0|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (230:51): [True: 0, False: 0] | | | | | | | Branch (230:51): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 141| 12.2k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 139| 12.2k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1331| 22.7k| else { 1332| 22.7k| TValue key; 1333| 22.7k| setivalue(&key, b); ------------------ | | 358| 22.7k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 22.7k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 22.7k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1334| 22.7k| Protect(luaV_finishset(L, s2v(ra), &key, rc, hres)); ------------------ | | 1114| 22.7k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 22.7k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 22.7k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 22.7k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1335| 22.7k| } 1336| 35.0k| vmbreak; ------------------ | | 16| 35.0k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 35.0k|#define vmfetch() { \ | | | | 1134| 35.0k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 35.0k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 35.0k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 35.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 35.0k| i = *(pc++); \ | | | | 1139| 35.0k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 35.0k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1337| 35.0k| } 1338| 6| vmcase(OP_SETFIELD) { ------------------ | | 14| 6|#define vmcase(l) L_##l: ------------------ 1339| 6| StkId ra = RA(i); ------------------ | | 1059| 6|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 6|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 6|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 6|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 6|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1340| 6| int hres; 1341| 6| TValue *rb = KB(i); ------------------ | | 1062| 6|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 6|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 113| 6|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 6|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1342| 6| TValue *rc = RKC(i); ------------------ | | 1066| 6|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 6|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 113| 6|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 6|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #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)) | | | | ------------------ | | | | | | 113| 1|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 1|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 20|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 5] | | | | | Branch (172:19): [True: 5, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1066:17): [True: 1, False: 5] | | ------------------ ------------------ 1343| 12| TString *key = tsvalue(rb); /* key must be a short string */ ------------------ | | 382| 6|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 24|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 6|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 6] | | | | | Branch (113:42): [True: 6, False: 0] | | | | ------------------ | | ------------------ ------------------ 1344| 6| luaV_fastset(s2v(ra), key, rc, hres, luaH_psetshortstr); ------------------ | | 95| 6| (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 719| 6|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 6|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 6|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 69| 4|#define HNOTATABLE 2 | | ------------------ | | (hres = (!ttistable(t) ? HNOTATABLE : f(hvalue(t), k, val))) | | ------------------ | | | | 721| 2|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 113| 8|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 2|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 2] | | | | | | | Branch (113:42): [True: 2, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (95:12): [True: 4, False: 2] | | ------------------ ------------------ 1345| 6| if (hres == HOK) ------------------ | | 67| 6|#define HOK 0 ------------------ | Branch (1345:13): [True: 0, False: 6] ------------------ 1346| 6| luaV_finishfastset(L, s2v(ra), rc); ------------------ | | 105| 0|#define luaV_finishfastset(L,t,v) luaC_barrierback(L, gcvalue(t), v) | | ------------------ | | | | 232| 0|#define luaC_barrierback(L,p,v) ( \ | | | | 233| 0| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 313| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 311| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (313:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 229| 0|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 230| 0| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 91| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 70| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | | | Branch (65:26): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 141| 0|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (230:51): [True: 0, False: 0] | | | | | | | Branch (230:51): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 141| 0|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1347| 6| else 1348| 6| Protect(luaV_finishset(L, s2v(ra), rb, rc, hres)); ------------------ | | 1114| 6|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 6|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 6|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 6|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1349| 6| vmbreak; ------------------ | | 16| 6|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 6|#define vmfetch() { \ | | | | 1134| 6| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 6|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 6|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 6] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 6| i = *(pc++); \ | | | | 1139| 6|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 6|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1350| 12| } 1351| 124k| vmcase(OP_NEWTABLE) { ------------------ | | 14| 124k|#define vmcase(l) L_##l: ------------------ 1352| 124k| StkId ra = RA(i); ------------------ | | 1059| 124k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 124k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 124k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 124k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 124k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1353| 124k| int b = GETARG_B(i); /* log2(hash size) + 1 */ ------------------ | | 128| 124k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 124k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 124k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1354| 124k| int c = GETARG_C(i); /* array size */ ------------------ | | 132| 124k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 113| 124k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 124k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1355| 0| Table *t; 1356| 124k| if (b > 0) ------------------ | Branch (1356:13): [True: 2, False: 124k] ------------------ 1357| 2| b = 1 << (b - 1); /* size is 2^(b - 1) */ 1358| 124k| lua_assert((!TESTARG_k(i)) == (GETARG_Ax(*pc) == 0)); ------------------ | | 109| 124k|#define lua_assert(c) assert(c) ------------------ 1359| 124k| if (TESTARG_k(i)) /* non-zero extra argument? */ ------------------ | | 136| 124k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 113| 124k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 124k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:25): [True: 13, False: 124k] | | | | ------------------ | | ------------------ ------------------ 1360| 13| c += GETARG_Ax(*pc) * (MAXARG_C + 1); /* add it to size */ ------------------ | | 143| 13|#define GETARG_Ax(i) check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax)) | | ------------------ | | | | 113| 13|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 13|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ c += GETARG_Ax(*pc) * (MAXARG_C + 1); /* add it to size */ ------------------ | | 97| 13|#define MAXARG_C ((1<top.p = ra + 1; /* correct top in case of emergency GC */ 1363| 124k| t = luaH_new(L); /* memory allocation */ 1364| 124k| sethvalue2s(L, ra, t); ------------------ | | 728| 124k|#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) | | ------------------ | | | | 724| 124k| { TValue *io = (obj); Table *x_ = (x); \ | | | | 725| 124k| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 72| 124k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 388| 124k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 124k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 124k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 114| 124k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 726| 124k| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 124k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 1.98M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 124k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 124k] | | | | | | | | | Branch (115:29): [True: 124k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 124k] | | | | | | | | | Branch (115:29): [True: 124k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 124k] | | | | | | | | | Branch (115:29): [True: 124k, False: 0] | | | | | | | | | Branch (115:29): [True: 124k, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 124k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 124k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1365| 124k| if (b != 0 || c != 0) ------------------ | Branch (1365:13): [True: 2, False: 124k] | Branch (1365:23): [True: 44.2k, False: 79.9k] ------------------ 1366| 44.2k| luaH_resize(L, t, c, b); /* idem */ 1367| 124k| checkGC(L, ra + 1); ------------------ | | 1127| 124k| { luaC_condGC(L, (savepc(L), L->top.p = (c)), \ | | ------------------ | | | | 215| 124k| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 124k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 608, False: 123k] | | | | ------------------ | | | | 216| 124k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 124k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 1128| 124k| updatetrap(ci)); \ | | 1129| 124k| luai_threadyield(L); } | | ------------------ | | | | 276| 124k|#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 268| 124k|#define lua_unlock(L) ((void) 0) | | | | ------------------ | | | | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 267| 124k|#define lua_lock(L) ((void) 0) | | | | ------------------ | | ------------------ ------------------ 1368| 124k| vmbreak; ------------------ | | 16| 124k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 124k|#define vmfetch() { \ | | | | 1134| 124k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 124k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 124k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 47, False: 124k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 47| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 47| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 47|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 47| } \ | | | | 1138| 124k| i = *(pc++); \ | | | | 1139| 124k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 124k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1369| 124k| } 1370| 0| vmcase(OP_SELF) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1371| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1372| 0| int tag; 1373| 0| TValue *rb = vRB(i); ------------------ | | 1061| 0|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 0] | | | | | Branch (172:19): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1374| 0| TValue *rc = RKC(i); ------------------ | | 1066| 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))))) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 0] | | | | | Branch (172:19): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1066:17): [True: 0, False: 0] | | ------------------ ------------------ 1375| 0| TString *key = tsvalue(rc); /* key must be a string */ ------------------ | | 382| 0|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 0] | | | | | Branch (113:42): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1376| 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) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1377| 0| luaV_fastget(rb, key, s2v(ra), luaH_getstr, tag); ------------------ | | 82| 0| (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 719| 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_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 192| 0|#define LUA_VNOTABLE makevariant(LUA_TNIL, 3) | | | | ------------------ | | | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | (tag = (!ttistable(t) ? LUA_VNOTABLE : f(hvalue(t), k, res))) | | ------------------ | | | | 721| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | | Branch (113:42): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (82:11): [True: 0, False: 0] | | ------------------ ------------------ 1378| 0| if (tagisempty(tag)) ------------------ | | 204| 0|#define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | ------------------ | | #define tagisempty(tag) (novariant(tag) == LUA_TNIL) | | ------------------ | | | | 64| 0|#define LUA_TNIL 0 | | ------------------ | | | Branch (204:26): [True: 0, False: 0] | | ------------------ ------------------ 1379| 0| Protect(luaV_finishget(L, rb, rc, ra, tag)); ------------------ | | 1114| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1380| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1381| 0| } 1382| 3.60k| vmcase(OP_ADDI) { ------------------ | | 14| 3.60k|#define vmcase(l) L_##l: ------------------ 1383| 7.20k| op_arithI(L, l_addi, luai_numadd); ------------------ | | 900| 3.60k|#define op_arithI(L,iop,fop) { \ | | 901| 3.60k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 3.60k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 3.60k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 3.60k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 3.60k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 3.60k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 902| 3.60k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 3.60k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 14.4k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 3.60k] | | | | | | | Branch (172:19): [True: 3.60k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 903| 3.60k| int imm = GETARG_sC(i); \ | | ------------------ | | | | 133| 3.60k|#define GETARG_sC(i) sC2int(GETARG_C(i)) | | | | ------------------ | | | | | | 101| 14.4k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 3.60k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 3.60k|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 9, False: 3.59k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 905| 9| lua_Integer iv1 = ivalue(v1); \ | | ------------------ | | | | 346| 9|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 113| 9|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 9|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 906| 9| pc++; setivalue(s2v(ra), iop(L, iv1, imm)); \ | | ------------------ | | | | 358| 9| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 9|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 9|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 907| 9| } \ | | 908| 3.60k| else if (ttisfloat(v1)) { \ | | ------------------ | | | | 340| 3.59k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 3.59k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 3.59k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 3.59k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 909| 3.59k| lua_Number nb = fltvalue(v1); \ | | ------------------ | | | | 345| 3.59k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 113| 3.59k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 3.59k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 910| 3.59k| lua_Number fimm = cast_num(imm); \ | | ------------------ | | | | 143| 3.59k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 139| 3.59k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 911| 3.59k| pc++; setfltvalue(s2v(ra), fop(L, nb, fimm)); \ | | ------------------ | | | | 352| 3.59k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | ------------------ | | | | | | 72| 3.59k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | ------------------ | | | | | | 114| 3.59k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 912| 3.59k| }} ------------------ 1384| 3.60k| vmbreak; ------------------ | | 16| 3.60k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 3.60k|#define vmfetch() { \ | | | | 1134| 3.60k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 3.60k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 3.60k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 3.60k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 3.60k| i = *(pc++); \ | | | | 1139| 3.60k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 3.60k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1385| 3.60k| } 1386| 139k| vmcase(OP_ADDK) { ------------------ | | 14| 139k|#define vmcase(l) L_##l: ------------------ 1387| 559k| op_arithK(L, l_addi, luai_numadd); ------------------ | | 970| 139k|#define op_arithK(L,iop,fop) { \ | | 971| 139k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 139k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 559k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 139k] | | | | | | | Branch (172:19): [True: 139k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 972| 139k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 139k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 139k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 113| 139k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 139k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 109| 139k|#define lua_assert(c) assert(c) | | ------------------ | | 973| 139k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 139k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 139k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 139k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 139k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 139k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 144| 139k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 139| 139k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 139k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 139k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 279k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 139k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 70.6k, False: 69.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 70.6k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 70.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 70.6k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 0, False: 70.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 0| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 953| 0| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 358| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 0| } \ | | | | 955| 139k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 139k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 139k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 139k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 279k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 139k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 139k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 139k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 69.1k, False: 70.6k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 69.1k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 69.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 69.1k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 139k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 279k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 70.6k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 70.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 70.6k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 70.6k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 143| 70.6k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 282k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 70.6k] | | | | | | | | | | | | | Branch (139:27): [True: 70.6k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 139k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 139k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 139k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 139k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 139k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 139k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 139k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 139k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 139k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 139k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 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)) | | | | | | | | ------------------ | | | | | | | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 139k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 352| 139k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 139k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 139k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 139k| }} | | | | ------------------ | | ------------------ ------------------ 1388| 559k| vmbreak; ------------------ | | 16| 139k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 139k|#define vmfetch() { \ | | | | 1134| 139k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 139k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 139k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 139k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 139k| i = *(pc++); \ | | | | 1139| 139k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 139k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1389| 559k| } 1390| 19.2k| vmcase(OP_SUBK) { ------------------ | | 14| 19.2k|#define vmcase(l) L_##l: ------------------ 1391| 77.1k| op_arithK(L, l_subi, luai_numsub); ------------------ | | 970| 19.2k|#define op_arithK(L,iop,fop) { \ | | 971| 19.2k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 19.2k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 77.1k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 19.2k] | | | | | | | Branch (172:19): [True: 19.2k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 972| 19.2k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 19.2k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 19.2k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 113| 19.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 19.2k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 109| 19.2k|#define lua_assert(c) assert(c) | | ------------------ | | 973| 19.2k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 19.2k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 19.2k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 19.2k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 19.2k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 19.2k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 144| 19.2k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 139| 19.2k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 19.2k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 19.2k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 38.5k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 19.2k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 19.2k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 19.2k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 19.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 19.2k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 0, False: 19.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 0| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 953| 0| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 358| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 0| } \ | | | | 955| 19.2k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 19.2k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 19.2k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 19.2k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 38.5k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 19.2k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 19.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 19.2k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 19.2k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 19.2k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 38.5k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 19.2k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 19.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 19.2k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 19.2k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 143| 19.2k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 77.1k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 19.2k] | | | | | | | | | | | | | Branch (139:27): [True: 19.2k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 19.2k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 19.2k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 19.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 19.2k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 19.2k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 19.2k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 19.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 19.2k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 19.2k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 19.2k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 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)) | | | | | | | | ------------------ | | | | | | | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 19.2k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 352| 19.2k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 19.2k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 19.2k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 19.2k| }} | | | | ------------------ | | ------------------ ------------------ 1392| 77.1k| vmbreak; ------------------ | | 16| 19.2k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 19.2k|#define vmfetch() { \ | | | | 1134| 19.2k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 19.2k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 19.2k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 19.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 19.2k| i = *(pc++); \ | | | | 1139| 19.2k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 19.2k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1393| 77.1k| } 1394| 255k| vmcase(OP_MULK) { ------------------ | | 14| 255k|#define vmcase(l) L_##l: ------------------ 1395| 1.02M| op_arithK(L, l_muli, luai_nummul); ------------------ | | 970| 255k|#define op_arithK(L,iop,fop) { \ | | 971| 255k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 255k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 1.02M|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 255k] | | | | | | | Branch (172:19): [True: 255k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 972| 255k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 255k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 255k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 113| 255k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 255k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 109| 255k|#define lua_assert(c) assert(c) | | ------------------ | | 973| 255k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 255k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 255k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 255k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 255k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 255k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 144| 255k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 139| 255k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 255k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 255k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 510k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 255k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 224k, False: 30.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 224k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 224k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 224k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 0, False: 224k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 0| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 953| 0| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 358| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 0| } \ | | | | 955| 255k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 255k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 255k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 255k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 510k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 255k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 255k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 255k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 30.3k, False: 224k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 30.3k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 30.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 30.3k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 255k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 510k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 224k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 224k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 224k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 224k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 143| 224k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 899k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 224k] | | | | | | | | | | | | | Branch (139:27): [True: 224k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 255k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 255k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 255k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 255k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 224k, False: 30.3k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 224k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 224k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 224k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 255k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 255k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 30.3k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 30.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 30.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 30.3k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 143| 30.3k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 121k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 30.3k] | | | | | | | | | | | | | Branch (139:27): [True: 30.3k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 255k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 352| 255k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 255k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 255k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 255k| }} | | | | ------------------ | | ------------------ ------------------ 1396| 1.02M| vmbreak; ------------------ | | 16| 255k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 255k|#define vmfetch() { \ | | | | 1134| 255k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 255k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 255k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 255k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 255k| i = *(pc++); \ | | | | 1139| 255k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 255k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1397| 1.02M| } 1398| 30.4k| vmcase(OP_MODK) { ------------------ | | 14| 30.4k|#define vmcase(l) L_##l: ------------------ 1399| 30.4k| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1107| 30.4k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1100| 30.4k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1400| 121k| op_arithK(L, luaV_mod, luaV_modf); ------------------ | | 970| 30.4k|#define op_arithK(L,iop,fop) { \ | | 971| 30.4k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 30.4k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 121k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 30.4k] | | | | | | | Branch (172:19): [True: 30.4k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 972| 30.4k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 30.4k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 30.4k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 113| 30.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 30.4k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 109| 30.4k|#define lua_assert(c) assert(c) | | ------------------ | | 973| 30.4k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 30.4k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 30.4k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 30.4k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 30.4k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 30.4k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 144| 30.4k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 139| 30.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 30.4k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 30.4k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 60.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 30.4k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 30.3k, False: 58] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 30.3k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 30.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 30.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 1.99k, False: 28.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 1.99k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 1.99k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 1.99k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.99k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 1.99k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 1.99k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.99k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 953| 1.99k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 358| 1.99k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 1.99k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 1.99k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 1.99k| } \ | | | | 955| 30.4k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 28.4k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 28.4k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 28.4k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 56.8k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 28.4k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 28.4k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 28.4k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 55, False: 28.3k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 55|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 55|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 55|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 28.4k, False: 3] | | | | | | | | ------------------ | | | | | | | | 58| 56.8k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 28.3k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 28.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 28.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 28.3k, False: 3] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 143| 28.3k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 113k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 28.3k] | | | | | | | | | | | | | Branch (139:27): [True: 28.3k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 28.4k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 28.4k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 28.4k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 28.4k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 28.3k, False: 54] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 28.3k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 28.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 28.3k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 28.4k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 28.4k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 54|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 54|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 54|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 54, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 143| 54|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 216|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 54] | | | | | | | | | | | | | Branch (139:27): [True: 54, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 28.4k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 352| 28.4k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 28.4k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 28.4k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 28.4k| }} | | | | ------------------ | | ------------------ ------------------ 1401| 121k| vmbreak; ------------------ | | 16| 30.4k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 30.4k|#define vmfetch() { \ | | | | 1134| 30.4k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 30.4k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 30.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 30.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 30.4k| i = *(pc++); \ | | | | 1139| 30.4k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 30.4k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1402| 121k| } 1403| 40| vmcase(OP_POWK) { ------------------ | | 14| 40|#define vmcase(l) L_##l: ------------------ 1404| 120| op_arithfK(L, luai_numpow); ------------------ | | 939| 40|#define op_arithfK(L,fop) { \ | | 940| 40| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 40|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 40|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 40|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 40|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 40|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 941| 40| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 40|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 160|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 40] | | | | | | | Branch (172:19): [True: 40, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 942| 40| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 40|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 40|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 113| 40|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 40|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 109| 40|#define lua_assert(c) assert(c) | | ------------------ | | 943| 40| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 919| 40|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 920| 40| lua_Number n1; lua_Number n2; \ | | | | 921| 40| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 80| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 340| 40|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 40|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 40|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 0, False: 40] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 345| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 40, False: 0] | | | | | | ------------------ | | | | | | 58| 80| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 341| 40|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 40|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 40|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 40, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 143| 40|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 160|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (139:27): [True: 0, False: 40] | | | | | | | | | | | Branch (139:27): [True: 40, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 40| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 340| 40|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 40|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 40|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 0, False: 40] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 345| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 40, False: 0] | | | | | | ------------------ | | | | | | 58| 40| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 341| 40|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 40|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 40|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 40, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 143| 40|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 160|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (139:27): [True: 0, False: 40] | | | | | | | | | | | Branch (139:27): [True: 40, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 922| 40| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | ------------------ | | | | | | 352| 80| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 72| 40|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 114| 40|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | | Branch (352:35): [True: 0, False: 40] | | | | | | ------------------ | | | | ------------------ | | | | 923| 40| }} | | ------------------ ------------------ 1405| 120| vmbreak; ------------------ | | 16| 40|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 40|#define vmfetch() { \ | | | | 1134| 40| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 40|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 40|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 40] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 40| i = *(pc++); \ | | | | 1139| 40|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 40|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1406| 120| } 1407| 174k| vmcase(OP_DIVK) { ------------------ | | 14| 174k|#define vmcase(l) L_##l: ------------------ 1408| 523k| op_arithfK(L, luai_numdiv); ------------------ | | 939| 174k|#define op_arithfK(L,fop) { \ | | 940| 174k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 174k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 174k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 174k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 174k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 174k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 941| 174k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 174k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 698k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 174k] | | | | | | | Branch (172:19): [True: 174k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 942| 174k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 174k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 174k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 113| 174k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 174k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 109| 174k|#define lua_assert(c) assert(c) | | ------------------ | | 943| 174k| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 919| 174k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 920| 174k| lua_Number n1; lua_Number n2; \ | | | | 921| 174k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 349k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 340| 174k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 174k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 174k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 174k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 345| 174k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 113| 174k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 109| 174k|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 174k, False: 0] | | | | | | ------------------ | | | | | | 58| 349k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 341| 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)) | | | | | | ------------------ | | | | | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 174k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 340| 174k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 174k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 174k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 174k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 345| 174k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 113| 174k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 109| 174k|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 174k, False: 0] | | | | | | ------------------ | | | | | | 58| 174k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 341| 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)) | | | | | | ------------------ | | | | | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 922| 174k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | ------------------ | | | | | | 352| 174k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 72| 174k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 114| 174k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 923| 174k| }} | | ------------------ ------------------ 1409| 523k| vmbreak; ------------------ | | 16| 174k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 174k|#define vmfetch() { \ | | | | 1134| 174k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 174k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 174k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 174k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 174k| i = *(pc++); \ | | | | 1139| 174k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 174k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1410| 523k| } 1411| 3.23k| vmcase(OP_IDIVK) { ------------------ | | 14| 3.23k|#define vmcase(l) L_##l: ------------------ 1412| 3.23k| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1107| 3.23k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1100| 3.23k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1413| 12.9k| op_arithK(L, luaV_idiv, luai_numidiv); ------------------ | | 970| 3.23k|#define op_arithK(L,iop,fop) { \ | | 971| 3.23k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 3.23k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 12.9k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 3.23k] | | | | | | | Branch (172:19): [True: 3.23k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 972| 3.23k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 3.23k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 3.23k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 113| 3.23k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 3.23k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 109| 3.23k|#define lua_assert(c) assert(c) | | ------------------ | | 973| 3.23k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 3.23k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 3.23k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 3.23k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 3.23k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 3.23k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 144| 3.23k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 139| 3.23k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 3.23k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 3.23k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 6.46k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 3.23k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 3.12k, False: 102] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 3.12k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 3.12k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 3.12k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 3.12k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 3.12k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 3.12k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 3.12k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 3.12k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 3.12k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 3.12k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 3.12k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 953| 3.12k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 358| 3.12k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 3.12k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 3.12k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 3.12k| } \ | | | | 955| 3.23k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 102|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 102| lua_Number n1; lua_Number n2; \ | | | | | | 921| 102| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 204| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 102|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 102|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 102|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 102, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 102|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 102|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 102|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 102, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 204| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 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)) | | | | | | | | ------------------ | | | | | | | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 102| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 102|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 102|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 102|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 102] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 102, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 102| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 102|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 102|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 102|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 102, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 143| 102|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 408|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 102] | | | | | | | | | | | | | Branch (139:27): [True: 102, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 102| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 352| 102| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 102|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 102|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 102| }} | | | | ------------------ | | ------------------ ------------------ 1414| 12.9k| vmbreak; ------------------ | | 16| 3.23k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 3.23k|#define vmfetch() { \ | | | | 1134| 3.23k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 3.23k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 3.23k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 3.23k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 3.23k| i = *(pc++); \ | | | | 1139| 3.23k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 3.23k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1415| 12.9k| } 1416| 0| vmcase(OP_BANDK) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1417| 0| op_bitwiseK(L, l_band); ------------------ | | 979| 0|#define op_bitwiseK(L,op) { \ | | 980| 0| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 981| 0| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 0|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 982| 0| TValue *v2 = KC(i); \ | | ------------------ | | | | 1065| 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)) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 983| 0| lua_Integer i1; \ | | 984| 0| lua_Integer i2 = ivalue(v2); \ | | ------------------ | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 985| 0| if (tointegerns(v1, &i1)) { \ | | ------------------ | | | | 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) \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 0, False: 0] | | | | ------------------ | | | | 70| 0| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 986| 0| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 358| 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)) | | | | ------------------ | | ------------------ | | 987| 0| }} ------------------ 1418| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1419| 0| } 1420| 1.00k| vmcase(OP_BORK) { ------------------ | | 14| 1.00k|#define vmcase(l) L_##l: ------------------ 1421| 3.01k| op_bitwiseK(L, l_bor); ------------------ | | 979| 1.00k|#define op_bitwiseK(L,op) { \ | | 980| 1.00k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 1.00k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 1.00k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 1.00k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 1.00k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 1.00k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 981| 1.00k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 1.00k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 4.02k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 1.00k] | | | | | | | Branch (172:19): [True: 1.00k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 982| 1.00k| TValue *v2 = KC(i); \ | | ------------------ | | | | 1065| 1.00k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 1.00k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 113| 1.00k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.00k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 983| 1.00k| lua_Integer i1; \ | | 984| 1.00k| lua_Integer i2 = ivalue(v2); \ | | ------------------ | | | | 346| 1.00k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 113| 1.00k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 1.00k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 985| 1.00k| if (tointegerns(v1, &i1)) { \ | | ------------------ | | | | 69| 1.00k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 1.00k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 1.00k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 1.00k, False: 4] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 346| 1.00k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 1.00k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.00k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 1.00k, False: 0] | | | | ------------------ | | | | 70| 1.00k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 4|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 986| 1.00k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 358| 1.00k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 1.00k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 1.00k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 987| 1.00k| }} ------------------ 1422| 3.01k| vmbreak; ------------------ | | 16| 1.00k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 1.00k|#define vmfetch() { \ | | | | 1134| 1.00k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.00k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.00k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1.00k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 1.00k| i = *(pc++); \ | | | | 1139| 1.00k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.00k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1423| 3.01k| } 1424| 27| vmcase(OP_BXORK) { ------------------ | | 14| 27|#define vmcase(l) L_##l: ------------------ 1425| 81| op_bitwiseK(L, l_bxor); ------------------ | | 979| 27|#define op_bitwiseK(L,op) { \ | | 980| 27| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 27|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 27|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 27|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 27|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 27|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 981| 27| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 27|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 108|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 27] | | | | | | | Branch (172:19): [True: 27, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 982| 27| TValue *v2 = KC(i); \ | | ------------------ | | | | 1065| 27|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 27|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 113| 27|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 27|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 983| 27| lua_Integer i1; \ | | 984| 27| lua_Integer i2 = ivalue(v2); \ | | ------------------ | | | | 346| 27|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 113| 27|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 27|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 985| 27| if (tointegerns(v1, &i1)) { \ | | ------------------ | | | | 69| 27| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 27|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 27|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 0, False: 27] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 27, False: 0] | | | | ------------------ | | | | 70| 27| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 27|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 986| 27| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 358| 27| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 27|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 27|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 987| 27| }} ------------------ 1426| 81| vmbreak; ------------------ | | 16| 27|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 27|#define vmfetch() { \ | | | | 1134| 27| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 27|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 27|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 27] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 27| i = *(pc++); \ | | | | 1139| 27|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 27|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1427| 81| } 1428| 38.5k| vmcase(OP_SHRI) { ------------------ | | 14| 38.5k|#define vmcase(l) L_##l: ------------------ 1429| 38.5k| StkId ra = RA(i); ------------------ | | 1059| 38.5k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 38.5k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 38.5k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 38.5k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 38.5k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1430| 38.5k| TValue *rb = vRB(i); ------------------ | | 1061| 38.5k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 154k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 38.5k] | | | | | Branch (172:19): [True: 38.5k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1431| 38.5k| int ic = GETARG_sC(i); ------------------ | | 133| 38.5k|#define GETARG_sC(i) sC2int(GETARG_C(i)) | | ------------------ | | | | 101| 154k|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 38.5k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 38.5k|#define MAXARG_C ((1<value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 38.5k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1435| 38.5k| } 1436| 38.5k| vmbreak; ------------------ | | 16| 38.5k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 38.5k|#define vmfetch() { \ | | | | 1134| 38.5k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 38.5k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 38.5k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 38.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 38.5k| i = *(pc++); \ | | | | 1139| 38.5k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 38.5k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1437| 38.5k| } 1438| 1.00k| vmcase(OP_SHLI) { ------------------ | | 14| 1.00k|#define vmcase(l) L_##l: ------------------ 1439| 1.00k| StkId ra = RA(i); ------------------ | | 1059| 1.00k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1.00k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1.00k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 1.00k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 1.00k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1440| 1.00k| TValue *rb = vRB(i); ------------------ | | 1061| 1.00k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 4.00k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 1.00k] | | | | | Branch (172:19): [True: 1.00k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1441| 1.00k| int ic = GETARG_sC(i); ------------------ | | 133| 1.00k|#define GETARG_sC(i) sC2int(GETARG_C(i)) | | ------------------ | | | | 101| 4.00k|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 1.00k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 1.00k|#define MAXARG_C ((1<value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 1.00k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1445| 1.00k| } 1446| 1.00k| vmbreak; ------------------ | | 16| 1.00k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 1.00k|#define vmfetch() { \ | | | | 1134| 1.00k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.00k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.00k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1.00k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 1.00k| i = *(pc++); \ | | | | 1139| 1.00k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.00k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1447| 1.00k| } 1448| 178k| vmcase(OP_ADD) { ------------------ | | 14| 178k|#define vmcase(l) L_##l: ------------------ 1449| 534k| op_arith(L, l_addi, luai_numadd); ------------------ | | 961| 178k|#define op_arith(L,iop,fop) { \ | | 962| 178k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 178k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 713k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 178k] | | | | | | | Branch (172:19): [True: 178k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 963| 178k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 178k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 713k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 178k] | | | | | | | Branch (172:19): [True: 178k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 964| 178k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 178k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 178k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 178k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 178k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 178k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 144| 178k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 139| 178k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 178k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 178k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 356k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 178k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 174k, False: 3.60k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 174k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 174k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 174k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 0, False: 174k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 0| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 953| 0| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 358| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 0| } \ | | | | 955| 178k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 178k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 178k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 178k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 356k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 178k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 178k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 178k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 3.59k, False: 174k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 3.59k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 3.59k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 3.59k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 178k, False: 4] | | | | | | | | ------------------ | | | | | | | | 58| 356k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 174k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 174k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 174k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 174k, False: 4] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 143| 174k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 698k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 174k] | | | | | | | | | | | | | Branch (139:27): [True: 174k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 178k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 178k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 178k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 178k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 174k, False: 3.56k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 174k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 174k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 174k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 178k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 178k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 3.56k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 3.56k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 3.56k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 3.56k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 143| 3.56k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 14.2k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 3.56k] | | | | | | | | | | | | | Branch (139:27): [True: 3.56k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 178k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 352| 178k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 178k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 178k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 178k| }} | | | | ------------------ | | ------------------ ------------------ 1450| 534k| vmbreak; ------------------ | | 16| 178k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 178k|#define vmfetch() { \ | | | | 1134| 178k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 178k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 178k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 178k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 178k| i = *(pc++); \ | | | | 1139| 178k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 178k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1451| 534k| } 1452| 73.6k| vmcase(OP_SUB) { ------------------ | | 14| 73.6k|#define vmcase(l) L_##l: ------------------ 1453| 220k| op_arith(L, l_subi, luai_numsub); ------------------ | | 961| 73.6k|#define op_arith(L,iop,fop) { \ | | 962| 73.6k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 73.6k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 294k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 73.6k] | | | | | | | Branch (172:19): [True: 73.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 963| 73.6k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 73.6k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 294k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 73.6k] | | | | | | | Branch (172:19): [True: 73.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 964| 73.6k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 73.6k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 73.6k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 73.6k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 73.6k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 73.6k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 144| 73.6k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 139| 73.6k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 73.6k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 73.6k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 147k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 73.6k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 45.2k, False: 28.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 45.2k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 45.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 45.2k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 45.2k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 45.2k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 45.2k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 45.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 45.2k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 45.2k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 45.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 45.2k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 953| 45.2k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 358| 45.2k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 45.2k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 45.2k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 45.2k| } \ | | | | 955| 73.6k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 28.3k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 28.3k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 28.3k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 56.7k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 28.3k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 28.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 28.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 28.3k, False: 2] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 28.3k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 28.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 28.3k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 28.3k, False: 2] | | | | | | | | ------------------ | | | | | | | | 58| 56.7k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 2|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 2|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 2|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 2] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 28.3k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 28.3k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 28.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 28.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 1, False: 28.3k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 1|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 1|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 1|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 28.3k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 28.3k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 28.3k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 28.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 28.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 28.3k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 143| 28.3k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 113k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 28.3k] | | | | | | | | | | | | | Branch (139:27): [True: 28.3k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 28.3k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 352| 28.3k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 28.3k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 28.3k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 28.3k| }} | | | | ------------------ | | ------------------ ------------------ 1454| 220k| vmbreak; ------------------ | | 16| 73.6k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 73.6k|#define vmfetch() { \ | | | | 1134| 73.6k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 73.6k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 73.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 73.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 73.6k| i = *(pc++); \ | | | | 1139| 73.6k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 73.6k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1455| 220k| } 1456| 30.5k| vmcase(OP_MUL) { ------------------ | | 14| 30.5k|#define vmcase(l) L_##l: ------------------ 1457| 91.5k| op_arith(L, l_muli, luai_nummul); ------------------ | | 961| 30.5k|#define op_arith(L,iop,fop) { \ | | 962| 30.5k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 30.5k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 122k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 30.5k] | | | | | | | Branch (172:19): [True: 30.5k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 963| 30.5k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 30.5k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 122k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 30.5k] | | | | | | | Branch (172:19): [True: 30.5k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 964| 30.5k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 30.5k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 30.5k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 30.5k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 30.5k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 30.5k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 144| 30.5k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 139| 30.5k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 30.5k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 30.5k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 61.0k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 30.5k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 1.99k, False: 28.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 1.99k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 1.99k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 1.99k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 1.99k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 1.99k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 1.99k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 1.99k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.99k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 1.99k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 1.99k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.99k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 953| 1.99k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 358| 1.99k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 1.99k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 1.99k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 1.99k| } \ | | | | 955| 30.5k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 28.5k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 28.5k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 28.5k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 57.0k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 28.5k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 28.5k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 28.5k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 28.5k, False: 1] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 28.5k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 28.5k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 28.5k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 28.5k, False: 1] | | | | | | | | ------------------ | | | | | | | | 58| 57.0k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 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)) | | | | | | | | ------------------ | | | | | | | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 28.5k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 28.5k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 28.5k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 28.5k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 647, False: 27.8k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 647|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 647|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 647|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 28.5k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 28.5k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 27.8k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 27.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 27.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 27.8k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 143| 27.8k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 111k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 27.8k] | | | | | | | | | | | | | Branch (139:27): [True: 27.8k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 28.5k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 352| 28.5k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 28.5k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 28.5k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 28.5k| }} | | | | ------------------ | | ------------------ ------------------ 1458| 91.5k| vmbreak; ------------------ | | 16| 30.5k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 30.5k|#define vmfetch() { \ | | | | 1134| 30.5k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 30.5k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 30.5k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 30.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 30.5k| i = *(pc++); \ | | | | 1139| 30.5k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 30.5k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1459| 91.5k| } 1460| 0| vmcase(OP_MOD) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1461| 0| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1462| 0| op_arith(L, luaV_mod, luaV_modf); ------------------ | | 961| 0|#define op_arith(L,iop,fop) { \ | | 962| 0| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 0|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 963| 0| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 0|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 964| 0| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 0|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 0| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 0| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 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)) { \ | | | | ------------------ | | | | | | 341| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 0| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 953| 0| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 358| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 0| } \ | | | | 955| 0| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 0|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 0| lua_Number n1; lua_Number n2; \ | | | | | | 921| 0| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 0| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 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) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 0| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 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)) | | | | | | | | ------------------ | | | | | | | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 0| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 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) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 0| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 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)) | | | | | | | | ------------------ | | | | | | | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 0| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 352| 0| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 0| }} | | | | ------------------ | | ------------------ ------------------ 1463| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1464| 0| } 1465| 223k| vmcase(OP_POW) { ------------------ | | 14| 223k|#define vmcase(l) L_##l: ------------------ 1466| 447k| op_arithf(L, luai_numpow); ------------------ | | 929| 223k|#define op_arithf(L,fop) { \ | | 930| 223k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 223k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 223k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 223k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 223k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 223k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 931| 223k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 223k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 894k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 223k] | | | | | | | Branch (172:19): [True: 223k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 932| 223k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 223k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 894k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 223k] | | | | | | | Branch (172:19): [True: 223k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 933| 223k| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 919| 223k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 920| 223k| lua_Number n1; lua_Number n2; \ | | | | 921| 223k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 447k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 340| 223k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 223k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 223k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 47.5k, False: 176k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 345| 47.5k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 113| 47.5k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 109| 47.5k|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 223k, False: 0] | | | | | | ------------------ | | | | | | 58| 447k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 341| 176k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 176k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 176k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 176k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 143| 176k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 704k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (139:27): [True: 0, False: 176k] | | | | | | | | | | | Branch (139:27): [True: 176k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 223k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 340| 223k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 223k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 223k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 27, False: 223k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 345| 27|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 113| 27|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 109| 27|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 223k, False: 0] | | | | | | ------------------ | | | | | | 58| 223k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 341| 223k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 223k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 223k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 223k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 143| 223k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 894k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (139:27): [True: 0, False: 223k] | | | | | | | | | | | Branch (139:27): [True: 223k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 922| 223k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | ------------------ | | | | | | 352| 447k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 72| 223k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 114| 223k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | | Branch (352:35): [True: 155, False: 223k] | | | | | | ------------------ | | | | ------------------ | | | | 923| 223k| }} | | ------------------ ------------------ 1467| 447k| vmbreak; ------------------ | | 16| 223k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 223k|#define vmfetch() { \ | | | | 1134| 223k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 223k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 223k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 223k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 223k| i = *(pc++); \ | | | | 1139| 223k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 223k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1468| 447k| } 1469| 46.6k| vmcase(OP_DIV) { /* float division (always with floats) */ ------------------ | | 14| 46.6k|#define vmcase(l) L_##l: ------------------ 1470| 93.3k| op_arithf(L, luai_numdiv); ------------------ | | 929| 46.6k|#define op_arithf(L,fop) { \ | | 930| 46.6k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 46.6k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 46.6k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 46.6k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 46.6k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 46.6k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 931| 46.6k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 46.6k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 186k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 46.6k] | | | | | | | Branch (172:19): [True: 46.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 932| 46.6k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 46.6k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 186k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 46.6k] | | | | | | | Branch (172:19): [True: 46.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 933| 46.6k| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 919| 46.6k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 920| 46.6k| lua_Number n1; lua_Number n2; \ | | | | 921| 46.6k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 93.3k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 340| 46.6k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 46.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 46.6k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 3.67k, False: 42.9k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 345| 3.67k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 113| 3.67k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 109| 3.67k|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 46.6k, False: 0] | | | | | | ------------------ | | | | | | 58| 93.3k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 341| 42.9k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 42.9k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 42.9k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 42.9k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 143| 42.9k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 171k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (139:27): [True: 0, False: 42.9k] | | | | | | | | | | | Branch (139:27): [True: 42.9k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 46.6k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 340| 46.6k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 46.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 46.6k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 0, False: 46.6k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 345| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 46.6k, False: 12] | | | | | | ------------------ | | | | | | 58| 46.6k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 341| 46.6k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 46.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 46.6k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 46.6k, False: 12] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 143| 46.6k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 186k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (139:27): [True: 0, False: 46.6k] | | | | | | | | | | | Branch (139:27): [True: 46.6k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 922| 46.6k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | ------------------ | | | | | | 352| 46.6k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 72| 46.6k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 114| 46.6k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 923| 46.6k| }} | | ------------------ ------------------ 1471| 93.3k| vmbreak; ------------------ | | 16| 46.6k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 46.6k|#define vmfetch() { \ | | | | 1134| 46.6k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 46.6k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 46.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 46.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 46.6k| i = *(pc++); \ | | | | 1139| 46.6k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 46.6k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1472| 93.3k| } 1473| 2| vmcase(OP_IDIV) { /* floor division */ ------------------ | | 14| 2|#define vmcase(l) L_##l: ------------------ 1474| 2| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1107| 2|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1100| 2|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1475| 6| op_arith(L, luaV_idiv, luai_numidiv); ------------------ | | 961| 2|#define op_arith(L,iop,fop) { \ | | 962| 2| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 2|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 8|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 2] | | | | | | | Branch (172:19): [True: 2, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 963| 2| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 2|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 8|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 2] | | | | | | | Branch (172:19): [True: 2, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 964| 2| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 2|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 2| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 2|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 2|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 2|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 144| 2|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 139| 2|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 2| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 2|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 4|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 2|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 1, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 341| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 1| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 1|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 1|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 346| 1|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 1|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 953| 1| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 358| 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)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 1| } \ | | | | 955| 2| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 1|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 1| lua_Number n1; lua_Number n2; \ | | | | | | 921| 1| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 2| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 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: 1, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 1|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 1|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 1|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 1, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 2| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 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)) | | | | | | | | ------------------ | | | | | | | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 1| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 340| 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: 1, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 345| 1|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 1|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 1|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 1, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 1| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 341| 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)) | | | | | | | | ------------------ | | | | | | | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 1| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 352| 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)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 1| }} | | | | ------------------ | | ------------------ ------------------ 1476| 6| vmbreak; ------------------ | | 16| 2|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 2|#define vmfetch() { \ | | | | 1134| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 2| i = *(pc++); \ | | | | 1139| 2|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 2|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1477| 6| } 1478| 31| vmcase(OP_BAND) { ------------------ | | 14| 31|#define vmcase(l) L_##l: ------------------ 1479| 62| op_bitwise(L, l_band); ------------------ | | 993| 31|#define op_bitwise(L,op) { \ | | 994| 31| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 31|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 31|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 31|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 31|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 31|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 995| 31| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 31|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 124|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 31] | | | | | | | Branch (172:19): [True: 31, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 996| 31| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 31|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 124|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 31] | | | | | | | Branch (172:19): [True: 31, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 997| 31| lua_Integer i1; lua_Integer i2; \ | | 998| 31| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 62| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 31|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 31|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 0, False: 31] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 0, False: 31] | | | | ------------------ | | | | 70| 62| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 31|#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) \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 0, False: 0] | | | | ------------------ | | | | 70| 0| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 999| 0| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 358| 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)) | | | | ------------------ | | ------------------ | | 1000| 0| }} ------------------ 1480| 62| vmbreak; ------------------ | | 16| 31|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 31|#define vmfetch() { \ | | | | 1134| 31| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 31| i = *(pc++); \ | | | | 1139| 31|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 31|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1481| 62| } 1482| 16.1k| vmcase(OP_BOR) { ------------------ | | 14| 16.1k|#define vmcase(l) L_##l: ------------------ 1483| 32.3k| op_bitwise(L, l_bor); ------------------ | | 993| 16.1k|#define op_bitwise(L,op) { \ | | 994| 16.1k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 16.1k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 16.1k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 16.1k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 16.1k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 16.1k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 995| 16.1k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 16.1k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 64.7k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 16.1k] | | | | | | | Branch (172:19): [True: 16.1k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 996| 16.1k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 16.1k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 64.7k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 16.1k] | | | | | | | Branch (172:19): [True: 16.1k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 997| 16.1k| lua_Integer i1; lua_Integer i2; \ | | 998| 16.1k| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 32.3k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 16.1k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 16.1k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 13.0k, False: 3.17k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 346| 13.0k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 13.0k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 13.0k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 16.1k, False: 1] | | | | ------------------ | | | | 70| 32.3k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 3.17k|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 16.1k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 16.1k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 16.1k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 15.4k, False: 747] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 346| 15.4k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 15.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 15.4k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 16.1k, False: 1] | | | | ------------------ | | | | 70| 16.1k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 747|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 999| 16.1k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 358| 16.1k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 16.1k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 16.1k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 1000| 16.1k| }} ------------------ 1484| 32.3k| vmbreak; ------------------ | | 16| 16.1k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 16.1k|#define vmfetch() { \ | | | | 1134| 16.1k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 16.1k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 16.1k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 16.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 16.1k| i = *(pc++); \ | | | | 1139| 16.1k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 16.1k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1485| 32.3k| } 1486| 0| vmcase(OP_BXOR) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1487| 0| op_bitwise(L, l_bxor); ------------------ | | 993| 0|#define op_bitwise(L,op) { \ | | 994| 0| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 995| 0| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 0|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 996| 0| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 0|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 997| 0| lua_Integer i1; lua_Integer i2; \ | | 998| 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) \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 0, False: 0] | | | | ------------------ | | | | 70| 0| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 0| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 0|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 0|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 0, False: 0] | | | | ------------------ | | | | 70| 0| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 999| 0| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 358| 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)) | | | | ------------------ | | ------------------ | | 1000| 0| }} ------------------ 1488| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1489| 0| } 1490| 0| vmcase(OP_SHR) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1491| 0| op_bitwise(L, luaV_shiftr); ------------------ | | 993| 0|#define op_bitwise(L,op) { \ | | 994| 0| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 995| 0| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 0|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 996| 0| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 0|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 0|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | | Branch (172:19): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 997| 0| lua_Integer i1; lua_Integer i2; \ | | 998| 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) \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 0, False: 0] | | | | ------------------ | | | | 70| 0| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 0| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 0|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 0|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 0, False: 0] | | | | ------------------ | | | | 70| 0| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 999| 0| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 358| 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)) | | | | ------------------ | | ------------------ | | 1000| 0| }} ------------------ 1492| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1493| 0| } 1494| 1.00k| vmcase(OP_SHL) { ------------------ | | 14| 1.00k|#define vmcase(l) L_##l: ------------------ 1495| 2.00k| op_bitwise(L, luaV_shiftl); ------------------ | | 993| 1.00k|#define op_bitwise(L,op) { \ | | 994| 1.00k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 1.00k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 1.00k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 1.00k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 1.00k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 1.00k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 995| 1.00k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 1.00k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 4.00k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 1.00k] | | | | | | | Branch (172:19): [True: 1.00k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 996| 1.00k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 1.00k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 4.00k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 1.00k] | | | | | | | Branch (172:19): [True: 1.00k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 997| 1.00k| lua_Integer i1; lua_Integer i2; \ | | 998| 1.00k| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 2.00k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 1.00k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 1.00k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 0, False: 1.00k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 998, False: 4] | | | | ------------------ | | | | 70| 2.00k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 1.00k|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 998| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 696| 998|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 684| 998|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (684:25): [True: 998, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 346| 998|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 113| 998|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 998|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 998, False: 0] | | | | ------------------ | | | | 70| 998| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 999| 998| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 358| 998| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 998|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 998|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 1000| 998| }} ------------------ 1496| 2.00k| vmbreak; ------------------ | | 16| 1.00k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 1.00k|#define vmfetch() { \ | | | | 1134| 1.00k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.00k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.00k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1.00k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 1.00k| i = *(pc++); \ | | | | 1139| 1.00k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.00k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1497| 2.00k| } 1498| 56| vmcase(OP_MMBIN) { ------------------ | | 14| 56|#define vmcase(l) L_##l: ------------------ 1499| 56| StkId ra = RA(i); ------------------ | | 1059| 56|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 56|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 56|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 56|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 56|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1500| 56| Instruction pi = *(pc - 2); /* original arith. expression */ 1501| 56| TValue *rb = vRB(i); ------------------ | | 1061| 56|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 224|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 56] | | | | | Branch (172:19): [True: 56, False: 0] | | | | ------------------ | | ------------------ ------------------ 1502| 56| TMS tm = (TMS)GETARG_C(i); ------------------ | | 132| 56|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 113| 56|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 56|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1503| 56| StkId result = RA(pi); ------------------ | | 1059| 56|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 56|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 56|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 56|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 56|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1504| 56| lua_assert(OP_ADD <= GET_OPCODE(pi) && GET_OPCODE(pi) <= OP_SHR); ------------------ | | 109| 56|#define lua_assert(c) assert(c) ------------------ 1505| 56| Protect(luaT_trybinTM(L, s2v(ra), rb, result, tm)); ------------------ | | 1114| 56|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 56|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 56|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 56|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1506| 56| vmbreak; ------------------ | | 16| 56|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 56|#define vmfetch() { \ | | | | 1134| 56| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 56|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 56|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 56] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 56| i = *(pc++); \ | | | | 1139| 56|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 56|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1507| 56| } 1508| 0| vmcase(OP_MMBINI) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1509| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1510| 0| Instruction pi = *(pc - 2); /* original arith. expression */ 1511| 0| int imm = GETARG_sB(i); ------------------ | | 129| 0|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | ------------------ | | | | 101| 0|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 0|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 0|#define MAXARG_C ((1<>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1515| 0| Protect(luaT_trybiniTM(L, s2v(ra), imm, flip, result, tm)); ------------------ | | 1114| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1516| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1517| 0| } 1518| 3| vmcase(OP_MMBINK) { ------------------ | | 14| 3|#define vmcase(l) L_##l: ------------------ 1519| 3| StkId ra = RA(i); ------------------ | | 1059| 3|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 3|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 3|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 3|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 3|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1520| 3| Instruction pi = *(pc - 2); /* original arith. expression */ 1521| 3| TValue *imm = KB(i); ------------------ | | 1062| 3|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 3|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 113| 3|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 3|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1522| 3| TMS tm = (TMS)GETARG_C(i); ------------------ | | 132| 3|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 113| 3|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 3|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1523| 3| int flip = GETARG_k(i); ------------------ | | 137| 3|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | ------------------ | | | | 113| 3|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 3|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1524| 3| StkId result = RA(pi); ------------------ | | 1059| 3|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 3|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 3|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 3|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 3|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1525| 3| Protect(luaT_trybinassocTM(L, s2v(ra), imm, flip, result, tm)); ------------------ | | 1114| 3|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 3|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 3|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 3|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1526| 3| vmbreak; ------------------ | | 16| 3|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 3|#define vmfetch() { \ | | | | 1134| 3| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 3| i = *(pc++); \ | | | | 1139| 3|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 3|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1527| 3| } 1528| 75.1k| vmcase(OP_UNM) { ------------------ | | 14| 75.1k|#define vmcase(l) L_##l: ------------------ 1529| 75.1k| StkId ra = RA(i); ------------------ | | 1059| 75.1k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 75.1k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 75.1k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 75.1k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 75.1k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1530| 75.1k| TValue *rb = vRB(i); ------------------ | | 1061| 75.1k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 300k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 75.1k] | | | | | Branch (172:19): [True: 75.1k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1531| 0| lua_Number nb; 1532| 75.1k| if (ttisinteger(rb)) { ------------------ | | 341| 75.1k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 75.1k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 75.1k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 59.2k, False: 15.8k] | | | | ------------------ | | ------------------ ------------------ 1533| 59.2k| lua_Integer ib = ivalue(rb); ------------------ | | 346| 59.2k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 59.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 59.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1534| 59.2k| setivalue(s2v(ra), intop(-, 0, ib)); ------------------ | | 358| 59.2k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 59.2k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 59.2k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1535| 59.2k| } 1536| 15.8k| else if (tonumberns(rb, nb)) { ------------------ | | 57| 15.8k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 340| 15.8k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 15.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 15.8k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 15.8k, False: 5] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 345| 15.8k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 113| 15.8k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 15.8k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 15.8k, False: 5] | | ------------------ | | 58| 15.8k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 341| 5|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 5|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 5|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 5] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | | Branch (139:27): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1537| 15.8k| setfltvalue(s2v(ra), luai_numunm(L, nb)); ------------------ | | 352| 15.8k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 15.8k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 15.8k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1538| 15.8k| } 1539| 5| else 1540| 5| Protect(luaT_trybinTM(L, rb, rb, ra, TM_UNM)); ------------------ | | 1114| 5|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 5|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 5|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 5|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1541| 75.1k| vmbreak; ------------------ | | 16| 75.1k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 75.1k|#define vmfetch() { \ | | | | 1134| 75.1k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 75.1k|#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: 75.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 75.1k| i = *(pc++); \ | | | | 1139| 75.1k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 75.1k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1542| 75.1k| } 1543| 1.13k| vmcase(OP_BNOT) { ------------------ | | 14| 1.13k|#define vmcase(l) L_##l: ------------------ 1544| 1.13k| StkId ra = RA(i); ------------------ | | 1059| 1.13k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1.13k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1.13k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 1.13k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 1.13k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1545| 1.13k| TValue *rb = vRB(i); ------------------ | | 1061| 1.13k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 4.55k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 1.13k] | | | | | Branch (172:19): [True: 1.13k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1546| 0| lua_Integer ib; 1547| 1.13k| if (tointegerns(rb, &ib)) { ------------------ | | 69| 1.13k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 696| 1.13k|#define l_likely(x) luai_likely(x) | | | | ------------------ | | | | | | 684| 1.13k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | ------------------ | | | | | | | Branch (684:25): [True: 1.06k, False: 70] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 346| 1.06k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 113| 1.06k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 1.06k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (69:3): [True: 1.08k, False: 58] | | ------------------ | | 70| 1.13k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | ------------------ | | | | 36| 70|#define LUA_FLOORN2I F2Ieq | | ------------------ ------------------ 1548| 1.08k| setivalue(s2v(ra), intop(^, ~l_castS2U(0), ib)); ------------------ | | 358| 1.08k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 1.08k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 1.08k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1549| 1.08k| } 1550| 58| else 1551| 58| Protect(luaT_trybinTM(L, rb, rb, ra, TM_BNOT)); ------------------ | | 1114| 58|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 58|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 58|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 58|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1552| 1.13k| vmbreak; ------------------ | | 16| 1.13k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 1.13k|#define vmfetch() { \ | | | | 1134| 1.13k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.13k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.13k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 1.13k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 1.13k| i = *(pc++); \ | | | | 1139| 1.13k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.13k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1553| 1.13k| } 1554| 6.05k| vmcase(OP_NOT) { ------------------ | | 14| 6.05k|#define vmcase(l) L_##l: ------------------ 1555| 6.05k| StkId ra = RA(i); ------------------ | | 1059| 6.05k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 6.05k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 6.05k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 6.05k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 6.05k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1556| 6.05k| TValue *rb = vRB(i); ------------------ | | 1061| 6.05k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 24.2k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 6.05k] | | | | | Branch (172:19): [True: 6.05k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1557| 6.05k| if (l_isfalse(rb)) ------------------ | | 258| 6.05k|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 254| 6.05k|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 12.1k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 6.05k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 6.05k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 196| 6.05k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 6.05k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 6.05k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 6.05k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 2.70k, False: 3.34k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1558| 6.05k| setbtvalue(s2v(ra)); ------------------ | | 264| 2.70k|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 2.70k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1559| 3.34k| else 1560| 6.05k| setbfvalue(s2v(ra)); ------------------ | | 263| 3.34k|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 3.34k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1561| 6.05k| vmbreak; ------------------ | | 16| 6.05k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 6.05k|#define vmfetch() { \ | | | | 1134| 6.05k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 6.05k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 6.05k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 6.05k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 6.05k| i = *(pc++); \ | | | | 1139| 6.05k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 6.05k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1562| 6.05k| } 1563| 187k| vmcase(OP_LEN) { ------------------ | | 14| 187k|#define vmcase(l) L_##l: ------------------ 1564| 187k| StkId ra = RA(i); ------------------ | | 1059| 187k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 187k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 187k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 187k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 187k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1565| 187k| Protect(luaV_objlen(L, ra, vRB(i))); ------------------ | | 1114| 751k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 187k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 187k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 187k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ | | | Branch (1114:42): [True: 0, False: 187k] | | | Branch (1114:42): [True: 187k, False: 0] | | ------------------ ------------------ 1566| 187k| vmbreak; ------------------ | | 16| 187k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 187k|#define vmfetch() { \ | | | | 1134| 187k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 187k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 187k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 5, False: 187k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 5| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 5| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 5|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 5| } \ | | | | 1138| 187k| i = *(pc++); \ | | | | 1139| 187k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 187k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1567| 187k| } 1568| 38.8k| vmcase(OP_CONCAT) { ------------------ | | 14| 38.8k|#define vmcase(l) L_##l: ------------------ 1569| 38.8k| StkId ra = RA(i); ------------------ | | 1059| 38.8k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 38.8k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 38.8k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 38.8k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 38.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1570| 38.8k| int n = GETARG_B(i); /* number of elements to concatenate */ ------------------ | | 128| 38.8k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 38.8k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 38.8k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1571| 0| L->top.p = ra + n; /* mark the end of concat operands */ 1572| 38.8k| ProtectNT(luaV_concat(L, n)); ------------------ | | 1117| 38.8k|#define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1100| 38.8k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ | | #define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 38.8k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1573| 38.8k| checkGC(L, L->top.p); /* 'luaV_concat' ensures correct top */ ------------------ | | 1127| 38.8k| { luaC_condGC(L, (savepc(L), L->top.p = (c)), \ | | ------------------ | | | | 215| 38.8k| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 38.8k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 97, False: 38.7k] | | | | ------------------ | | | | 216| 38.8k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 38.8k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 1128| 38.8k| updatetrap(ci)); \ | | 1129| 38.8k| luai_threadyield(L); } | | ------------------ | | | | 276| 38.8k|#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 268| 38.8k|#define lua_unlock(L) ((void) 0) | | | | ------------------ | | | | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 267| 38.8k|#define lua_lock(L) ((void) 0) | | | | ------------------ | | ------------------ ------------------ 1574| 38.8k| vmbreak; ------------------ | | 16| 38.8k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 38.8k|#define vmfetch() { \ | | | | 1134| 38.8k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 38.8k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 38.8k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 4, False: 38.8k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 4| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 4| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 4|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 4| } \ | | | | 1138| 38.8k| i = *(pc++); \ | | | | 1139| 38.8k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 38.8k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1575| 38.8k| } 1576| 14.4k| vmcase(OP_CLOSE) { ------------------ | | 14| 14.4k|#define vmcase(l) L_##l: ------------------ 1577| 14.4k| StkId ra = RA(i); ------------------ | | 1059| 14.4k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 14.4k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 14.4k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 14.4k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 14.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1578| 14.4k| Protect(luaF_close(L, ra, LUA_OK, 1)); ------------------ | | 1114| 14.4k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 14.4k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 14.4k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 14.4k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1579| 14.4k| vmbreak; ------------------ | | 16| 14.4k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 14.4k|#define vmfetch() { \ | | | | 1134| 14.4k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 14.4k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 14.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 14.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 14.4k| i = *(pc++); \ | | | | 1139| 14.4k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 14.4k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1580| 14.4k| } 1581| 14.4k| vmcase(OP_TBC) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1582| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1583| | /* create new to-be-closed upvalue */ 1584| 0| halfProtect(luaF_newtbcupval(L, ra)); ------------------ | | 1123| 0|#define halfProtect(exp) (savestate(L,ci), (exp)) | | ------------------ | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ ------------------ 1585| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1586| 0| } 1587| 5.36k| vmcase(OP_JMP) { ------------------ | | 14| 5.36k|#define vmcase(l) L_##l: ------------------ 1588| 5.36k| dojump(ci, i, 0); ------------------ | | 1083| 5.36k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | ------------------ | | | | 151| 5.36k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | ------------------ | | | | | | 113| 5.36k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 5.36k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | ------------------ | | | | 1070| 5.36k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1589| 5.36k| vmbreak; ------------------ | | 16| 5.36k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 5.36k|#define vmfetch() { \ | | | | 1134| 5.36k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 5.36k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 5.36k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 5.36k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 5.36k| i = *(pc++); \ | | | | 1139| 5.36k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 5.36k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1590| 5.36k| } 1591| 22.6k| vmcase(OP_EQ) { ------------------ | | 14| 22.6k|#define vmcase(l) L_##l: ------------------ 1592| 22.6k| StkId ra = RA(i); ------------------ | | 1059| 22.6k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 22.6k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 22.6k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 22.6k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 22.6k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1593| 22.6k| int cond; 1594| 22.6k| TValue *rb = vRB(i); ------------------ | | 1061| 22.6k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 90.7k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 22.6k] | | | | | Branch (172:19): [True: 22.6k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1595| 22.6k| Protect(cond = luaV_equalobj(L, s2v(ra), rb)); ------------------ | | 1114| 22.6k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 22.6k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 22.6k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 22.6k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1596| 22.6k| docondjump(); ------------------ | | 1094| 22.6k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 22.6k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 113| 22.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 22.6k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1087| 22.6k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1083| 22.6k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 22.6k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 113| 22.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 109| 22.6k|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1070| 22.6k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1094:26): [True: 0, False: 22.6k] | | ------------------ ------------------ 1597| 22.6k| vmbreak; ------------------ | | 16| 22.6k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 22.6k|#define vmfetch() { \ | | | | 1134| 22.6k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 22.6k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 22.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 22.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 22.6k| i = *(pc++); \ | | | | 1139| 22.6k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 22.6k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1598| 22.6k| } 1599| 74.9k| vmcase(OP_LT) { ------------------ | | 14| 74.9k|#define vmcase(l) L_##l: ------------------ 1600| 224k| op_order(L, l_lti, LTnum, lessthanothers); ------------------ | | 1008| 74.9k|#define op_order(L,opi,opn,other) { \ | | 1009| 74.9k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 74.9k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 74.9k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 74.9k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 74.9k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 74.9k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1010| 74.9k| int cond; \ | | 1011| 74.9k| TValue *rb = vRB(i); \ | | ------------------ | | | | 1061| 74.9k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 299k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 74.9k] | | | | | | | Branch (172:19): [True: 74.9k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1012| 74.9k| if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 341| 74.9k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 149k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 74.9k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 72.5k, False: 2.39k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 341| 72.5k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 72.5k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 72.5k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 27.3k, False: 45.1k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1013| 27.3k| lua_Integer ia = ivalue(s2v(ra)); \ | | ------------------ | | | | 346| 27.3k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 113| 27.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 27.3k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1014| 27.3k| lua_Integer ib = ivalue(rb); \ | | ------------------ | | | | 346| 27.3k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 113| 27.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 27.3k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1015| 27.3k| cond = opi(ia, ib); \ | | ------------------ | | | | 1600| 27.3k| op_order(L, l_lti, LTnum, lessthanothers); | | | | ------------------ | | | | | | 890| 27.3k|#define l_lti(a,b) (a < b) | | | | ------------------ | | ------------------ | | 1016| 27.3k| } \ | | 1017| 74.9k| else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 339| 47.5k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 95.0k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 47.5k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 47.5k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 47.5k, False: 17] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 339| 47.5k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 47.5k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 47.5k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 47.5k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 47.5k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1018| 47.5k| cond = opn(s2v(ra), rb); \ | | ------------------ | | | | 172| 47.5k|#define s2v(o) (&(o)->val) | | ------------------ | | 1019| 47.5k| else \ | | 1020| 47.5k| Protect(cond = other(L, s2v(ra), rb)); \ | | ------------------ | | | | 1114| 17|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1107| 17|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1100| 17|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1070| 17|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1021| 74.9k| docondjump(); } | | ------------------ | | | | 1094| 74.9k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 74.9k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 113| 74.9k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 74.9k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1087| 11.6k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1083| 11.6k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 11.6k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 11.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 11.6k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1070| 11.6k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1094:26): [True: 63.2k, False: 11.6k] | | | | ------------------ | | ------------------ ------------------ 1601| 224k| vmbreak; ------------------ | | 16| 74.9k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 74.9k|#define vmfetch() { \ | | | | 1134| 74.9k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 74.9k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 74.9k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 74.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 74.9k| i = *(pc++); \ | | | | 1139| 74.9k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 74.9k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1602| 224k| } 1603| 23.6k| vmcase(OP_LE) { ------------------ | | 14| 23.6k|#define vmcase(l) L_##l: ------------------ 1604| 70.9k| op_order(L, l_lei, LEnum, lessequalothers); ------------------ | | 1008| 23.6k|#define op_order(L,opi,opn,other) { \ | | 1009| 23.6k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 23.6k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 23.6k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 23.6k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 23.6k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 23.6k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1010| 23.6k| int cond; \ | | 1011| 23.6k| TValue *rb = vRB(i); \ | | ------------------ | | | | 1061| 23.6k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 94.5k|#define s2v(o) (&(o)->val) | | | | | | ------------------ | | | | | | | Branch (172:19): [True: 0, False: 23.6k] | | | | | | | Branch (172:19): [True: 23.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1012| 23.6k| if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 341| 23.6k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 47.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 23.6k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 22.2k, False: 1.36k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 341| 22.2k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 22.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 22.2k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 22.2k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1013| 0| lua_Integer ia = ivalue(s2v(ra)); \ | | ------------------ | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1014| 0| lua_Integer ib = ivalue(rb); \ | | ------------------ | | | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1015| 0| cond = opi(ia, ib); \ | | ------------------ | | | | 1604| 0| op_order(L, l_lei, LEnum, lessequalothers); | | | | ------------------ | | | | | | 891| 0|#define l_lei(a,b) (a <= b) | | | | ------------------ | | ------------------ | | 1016| 0| } \ | | 1017| 23.6k| else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 339| 23.6k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 47.2k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 23.6k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 23.6k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 23.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 339| 23.6k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 23.6k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 23.6k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 23.6k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 23.6k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1018| 23.6k| cond = opn(s2v(ra), rb); \ | | ------------------ | | | | 172| 23.6k|#define s2v(o) (&(o)->val) | | ------------------ | | 1019| 23.6k| else \ | | 1020| 23.6k| Protect(cond = other(L, s2v(ra), rb)); \ | | ------------------ | | | | 1114| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1021| 23.6k| docondjump(); } | | ------------------ | | | | 1094| 23.6k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 23.6k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 113| 23.6k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 23.6k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1087| 2.00k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1083| 2.00k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 2.00k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 2.00k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 2.00k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1070| 2.00k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1094:26): [True: 21.6k, False: 2.00k] | | | | ------------------ | | ------------------ ------------------ 1605| 70.9k| vmbreak; ------------------ | | 16| 23.6k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 23.6k|#define vmfetch() { \ | | | | 1134| 23.6k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 23.6k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 23.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 23.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 23.6k| i = *(pc++); \ | | | | 1139| 23.6k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 23.6k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1606| 70.9k| } 1607| 0| vmcase(OP_EQK) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1608| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1609| 0| TValue *rb = KB(i); ------------------ | | 1062| 0|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 0|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1610| | /* basic types do not use '__eq'; we can use raw equality */ 1611| 0| int cond = luaV_rawequalobj(s2v(ra), rb); ------------------ | | 75| 0|#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2) ------------------ 1612| 0| docondjump(); ------------------ | | 1094| 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)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1087| 0|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1083| 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) | | | | | | | | ------------------ | | | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1094:26): [True: 0, False: 0] | | ------------------ ------------------ 1613| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1614| 0| } 1615| 13.3k| vmcase(OP_EQI) { ------------------ | | 14| 13.3k|#define vmcase(l) L_##l: ------------------ 1616| 13.3k| StkId ra = RA(i); ------------------ | | 1059| 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))) | | | | | | ------------------ | | | | | | | | 144| 13.3k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 13.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1617| 13.3k| int cond; 1618| 13.3k| int im = GETARG_sB(i); ------------------ | | 129| 13.3k|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | ------------------ | | | | 101| 53.4k|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 13.3k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 13.3k|#define MAXARG_C ((1<tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 13.3k, False: 4] | | | | ------------------ | | ------------------ ------------------ 1620| 13.3k| cond = (ivalue(s2v(ra)) == im); ------------------ | | 346| 13.3k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 13.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 13.3k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1621| 4| else if (ttisfloat(s2v(ra))) ------------------ | | 340| 4|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 4|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 4|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 4] | | | | ------------------ | | ------------------ ------------------ 1622| 0| cond = luai_numeq(fltvalue(s2v(ra)), cast_num(im)); ------------------ | | 353| 0|#define luai_numeq(a,b) ((a)==(b)) | | ------------------ | | | Branch (353:35): [True: 0, False: 0] | | | Branch (353:35): [True: 0, False: 0] | | ------------------ ------------------ 1623| 4| else 1624| 4| cond = 0; /* other types cannot be equal to a number */ 1625| 26.7k| docondjump(); ------------------ | | 1094| 13.3k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 13.3k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 113| 13.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 13.3k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1087| 13.3k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1083| 13.3k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 13.3k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 113| 13.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 109| 13.3k|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1070| 13.3k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1094:26): [True: 1, False: 13.3k] | | ------------------ ------------------ 1626| 26.7k| vmbreak; ------------------ | | 16| 13.3k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 13.3k|#define vmfetch() { \ | | | | 1134| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 13.3k| i = *(pc++); \ | | | | 1139| 13.3k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 13.3k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1627| 26.7k| } 1628| 0| vmcase(OP_LTI) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1629| 0| op_orderI(L, l_lti, luai_numlt, 0, TM_LT); ------------------ | | 1028| 0|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1029| 0| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1030| 0| int cond; \ | | 1031| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1033| 0| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1629| 0| op_orderI(L, l_lti, luai_numlt, 0, TM_LT); | | | | ------------------ | | | | | | 890| 0|#define l_lti(a,b) (a < b) | | | | | | ------------------ | | | | | | | Branch (890:21): [True: 0, False: 0] | | | | | | | Branch (890:21): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1034| 0| else if (ttisfloat(s2v(ra))) { \ | | ------------------ | | | | 340| 0|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 0| lua_Number fa = fltvalue(s2v(ra)); \ | | ------------------ | | | | 345| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1036| 0| lua_Number fim = cast_num(im); \ | | ------------------ | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 1037| 0| cond = opf(fa, fim); \ | | ------------------ | | | | 1629| 0| op_orderI(L, l_lti, luai_numlt, 0, TM_LT); | | | | ------------------ | | | | | | 354| 0|#define luai_numlt(a,b) ((a)<(b)) | | | | ------------------ | | ------------------ | | 1038| 0| } \ | | 1039| 0| else { \ | | 1040| 0| int isf = GETARG_C(i); \ | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1041| 0| Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \ | | ------------------ | | | | 1114| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1042| 0| } \ | | 1043| 0| docondjump(); } | | ------------------ | | | | 1094| 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)) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1087| 0|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1083| 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) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1094:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1630| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1631| 0| } 1632| 714| vmcase(OP_LEI) { ------------------ | | 14| 714|#define vmcase(l) L_##l: ------------------ 1633| 2.14k| op_orderI(L, l_lei, luai_numle, 0, TM_LE); ------------------ | | 1028| 714|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1029| 714| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 714|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 714|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 714|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 714|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 714|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1030| 714| int cond; \ | | 1031| 714| int im = GETARG_sB(i); \ | | ------------------ | | | | 129| 714|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | | | ------------------ | | | | | | 101| 2.85k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 714|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 714|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 714, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1033| 714| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1633| 714| op_orderI(L, l_lei, luai_numle, 0, TM_LE); | | | | ------------------ | | | | | | 891| 2.85k|#define l_lei(a,b) (a <= b) | | | | | | ------------------ | | | | | | | Branch (891:21): [True: 0, False: 714] | | | | | | | Branch (891:21): [True: 714, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1034| 714| else if (ttisfloat(s2v(ra))) { \ | | ------------------ | | | | 340| 0|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 0| lua_Number fa = fltvalue(s2v(ra)); \ | | ------------------ | | | | 345| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1036| 0| lua_Number fim = cast_num(im); \ | | ------------------ | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 1037| 0| cond = opf(fa, fim); \ | | ------------------ | | | | 1633| 0| op_orderI(L, l_lei, luai_numle, 0, TM_LE); | | | | ------------------ | | | | | | 355| 0|#define luai_numle(a,b) ((a)<=(b)) | | | | ------------------ | | ------------------ | | 1038| 0| } \ | | 1039| 0| else { \ | | 1040| 0| int isf = GETARG_C(i); \ | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1041| 0| Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \ | | ------------------ | | | | 1114| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1042| 0| } \ | | 1043| 714| docondjump(); } | | ------------------ | | | | 1094| 714|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 714|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 113| 714|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 714|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1087| 0|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1083| 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) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1094:26): [True: 714, False: 0] | | | | ------------------ | | ------------------ ------------------ 1634| 2.14k| vmbreak; ------------------ | | 16| 714|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 714|#define vmfetch() { \ | | | | 1134| 714| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 714|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 714|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 714] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 714| i = *(pc++); \ | | | | 1139| 714|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 714|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1635| 2.14k| } 1636| 26| vmcase(OP_GTI) { ------------------ | | 14| 26|#define vmcase(l) L_##l: ------------------ 1637| 77| op_orderI(L, l_gti, luai_numgt, 1, TM_LT); ------------------ | | 1028| 26|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1029| 26| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 26|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 26|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 26|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 26|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 26|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1030| 26| int cond; \ | | 1031| 26| int im = GETARG_sB(i); \ | | ------------------ | | | | 129| 26|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | | | ------------------ | | | | | | 101| 104|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 26|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 26|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 10, False: 16] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1033| 26| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1637| 10| op_orderI(L, l_gti, luai_numgt, 1, TM_LT); | | | | ------------------ | | | | | | 892| 40|#define l_gti(a,b) (a > b) | | | | | | ------------------ | | | | | | | Branch (892:21): [True: 0, False: 10] | | | | | | | Branch (892:21): [True: 10, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1034| 26| else if (ttisfloat(s2v(ra))) { \ | | ------------------ | | | | 340| 16|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 16|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 16|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 15, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 15| lua_Number fa = fltvalue(s2v(ra)); \ | | ------------------ | | | | 345| 15|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 113| 15|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 15|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1036| 15| lua_Number fim = cast_num(im); \ | | ------------------ | | | | 143| 15|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 139| 15|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 1037| 15| cond = opf(fa, fim); \ | | ------------------ | | | | 1637| 15| op_orderI(L, l_gti, luai_numgt, 1, TM_LT); | | | | ------------------ | | | | | | 356| 15|#define luai_numgt(a,b) ((a)>(b)) | | | | ------------------ | | ------------------ | | 1038| 15| } \ | | 1039| 16| else { \ | | 1040| 1| int isf = GETARG_C(i); \ | | ------------------ | | | | 132| 1|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 113| 1|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 1|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1041| 1| Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \ | | ------------------ | | | | 1114| 1|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1107| 1|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1100| 1|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1070| 1|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1042| 1| } \ | | 1043| 26| docondjump(); } | | ------------------ | | | | 1094| 26|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 26|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 113| 26|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 26|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1087| 26|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1083| 26|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 26| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 26|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 26|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1070| 25|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1094:26): [True: 0, False: 26] | | | | ------------------ | | ------------------ ------------------ 1638| 77| vmbreak; ------------------ | | 16| 25|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 25|#define vmfetch() { \ | | | | 1134| 25| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 25|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 25|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 25] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 25| i = *(pc++); \ | | | | 1139| 25|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 25|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1639| 77| } 1640| 17.4k| vmcase(OP_GEI) { ------------------ | | 14| 17.4k|#define vmcase(l) L_##l: ------------------ 1641| 52.3k| op_orderI(L, l_gei, luai_numge, 1, TM_LE); ------------------ | | 1028| 17.4k|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1029| 17.4k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 17.4k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 17.4k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 17.4k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 17.4k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 17.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1030| 17.4k| int cond; \ | | 1031| 17.4k| int im = GETARG_sB(i); \ | | ------------------ | | | | 129| 17.4k|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | | | ------------------ | | | | | | 101| 69.8k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 17.4k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 17.4k|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 17.4k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1033| 17.4k| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1641| 17.4k| op_orderI(L, l_gei, luai_numge, 1, TM_LE); | | | | ------------------ | | | | | | 893| 69.8k|#define l_gei(a,b) (a >= b) | | | | | | ------------------ | | | | | | | Branch (893:21): [True: 0, False: 17.4k] | | | | | | | Branch (893:21): [True: 17.4k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1034| 17.4k| else if (ttisfloat(s2v(ra))) { \ | | ------------------ | | | | 340| 0|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 0| lua_Number fa = fltvalue(s2v(ra)); \ | | ------------------ | | | | 345| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1036| 0| lua_Number fim = cast_num(im); \ | | ------------------ | | | | 143| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 1037| 0| cond = opf(fa, fim); \ | | ------------------ | | | | 1641| 0| op_orderI(L, l_gei, luai_numge, 1, TM_LE); | | | | ------------------ | | | | | | 357| 0|#define luai_numge(a,b) ((a)>=(b)) | | | | ------------------ | | ------------------ | | 1038| 0| } \ | | 1039| 0| else { \ | | 1040| 0| int isf = GETARG_C(i); \ | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1041| 0| Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \ | | ------------------ | | | | 1114| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1042| 0| } \ | | 1043| 17.4k| docondjump(); } | | ------------------ | | | | 1094| 17.4k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 17.4k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 113| 17.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 17.4k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1087| 11.3k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1083| 11.3k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 11.3k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 113| 11.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 109| 11.3k|#define lua_assert(c) assert(c) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1070| 11.3k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1094:26): [True: 6.07k, False: 11.3k] | | | | ------------------ | | ------------------ ------------------ 1642| 52.3k| vmbreak; ------------------ | | 16| 17.4k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 17.4k|#define vmfetch() { \ | | | | 1134| 17.4k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 17.4k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 17.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 3, False: 17.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 3| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 3| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 3|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 3| } \ | | | | 1138| 17.4k| i = *(pc++); \ | | | | 1139| 17.4k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 17.4k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1643| 52.3k| } 1644| 15.2k| vmcase(OP_TEST) { ------------------ | | 14| 15.2k|#define vmcase(l) L_##l: ------------------ 1645| 15.2k| StkId ra = RA(i); ------------------ | | 1059| 15.2k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 15.2k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 15.2k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 15.2k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 15.2k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1646| 15.2k| int cond = !l_isfalse(s2v(ra)); ------------------ | | 258| 15.2k|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 254| 15.2k|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 30.5k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 15.2k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 3, False: 15.2k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 196| 15.2k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 15.2k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 15.2k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 15.2k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 4.77k, False: 10.4k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1647| 15.2k| docondjump(); ------------------ | | 1094| 15.2k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 15.2k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 113| 15.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 15.2k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1087| 13.9k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1083| 13.9k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 13.9k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 113| 13.9k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 109| 13.9k|#define lua_assert(c) assert(c) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1070| 13.9k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1094:26): [True: 1.35k, False: 13.9k] | | ------------------ ------------------ 1648| 15.2k| vmbreak; ------------------ | | 16| 15.2k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 15.2k|#define vmfetch() { \ | | | | 1134| 15.2k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 15.2k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 15.2k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 27, False: 15.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 27| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 27| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 27|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 27| } \ | | | | 1138| 15.2k| i = *(pc++); \ | | | | 1139| 15.2k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 15.2k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1649| 15.2k| } 1650| 315| vmcase(OP_TESTSET) { ------------------ | | 14| 315|#define vmcase(l) L_##l: ------------------ 1651| 315| StkId ra = RA(i); ------------------ | | 1059| 315|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 315|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 315|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 315|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 315|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1652| 315| TValue *rb = vRB(i); ------------------ | | 1061| 315|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 1.26k|#define s2v(o) (&(o)->val) | | | | ------------------ | | | | | Branch (172:19): [True: 0, False: 315] | | | | | Branch (172:19): [True: 315, False: 0] | | | | ------------------ | | ------------------ ------------------ 1653| 315| if (l_isfalse(rb) == GETARG_k(i)) ------------------ | | 258| 315|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 254| 315|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 630|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 315|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 315] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 196| 315|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 315|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 315|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 315|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 315] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (l_isfalse(rb) == GETARG_k(i)) ------------------ | | 137| 315|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | ------------------ | | | | 113| 315|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 315|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ | Branch (1653:13): [True: 315, False: 0] ------------------ 1654| 315| pc++; 1655| 0| else { 1656| 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) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1657| 0| donextjump(ci); ------------------ | | 1087| 0|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | ------------------ | | | | 1083| 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) | | | | | | ------------------ | | | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | ------------------ | | | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ ------------------ 1658| 0| } 1659| 315| vmbreak; ------------------ | | 16| 315|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 315|#define vmfetch() { \ | | | | 1134| 315| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 315|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 315|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 315] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 315| i = *(pc++); \ | | | | 1139| 315|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 315|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1660| 315| } 1661| 560k| vmcase(OP_CALL) { ------------------ | | 14| 560k|#define vmcase(l) L_##l: ------------------ 1662| 560k| StkId ra = RA(i); ------------------ | | 1059| 560k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 560k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 560k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 560k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 560k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1663| 560k| CallInfo *newci; 1664| 560k| int b = GETARG_B(i); ------------------ | | 128| 560k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 560k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 560k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1665| 560k| int nresults = GETARG_C(i) - 1; ------------------ | | 132| 560k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 113| 560k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 560k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1666| 560k| if (b != 0) /* fixed number of arguments? */ ------------------ | Branch (1666:13): [True: 559k, False: 1.03k] ------------------ 1667| 559k| L->top.p = ra + b; /* top signals number of arguments */ 1668| | /* else previous instruction set top */ 1669| 560k| savepc(L); /* in case of errors */ ------------------ | | 1100| 560k|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1670| 560k| if ((newci = luaD_precall(L, ra, nresults)) == NULL) ------------------ | Branch (1670:13): [True: 0, False: 560k] ------------------ 1671| 0| updatetrap(ci); /* C call; nothing else to be done */ ------------------ | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1672| 560k| else { /* Lua call: run function in this same C frame */ 1673| 560k| ci = newci; 1674| 560k| goto startfunc; 1675| 560k| } 1676| 560k| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1677| 0| } 1678| 0| vmcase(OP_TAILCALL) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1679| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1680| 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)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1681| 0| int n; /* number of results when calling a C function */ 1682| 0| int nparams1 = GETARG_C(i); ------------------ | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1683| | /* delta is virtual 'func' - real 'func' (vararg functions) */ 1684| 0| int delta = (nparams1) ? ci->u.l.nextraargs + nparams1 : 0; ------------------ | Branch (1684:21): [True: 0, False: 0] ------------------ 1685| 0| if (b != 0) ------------------ | Branch (1685:13): [True: 0, False: 0] ------------------ 1686| 0| L->top.p = ra + b; 1687| 0| else /* previous instruction set top */ 1688| 0| b = cast_int(L->top.p - ra); ------------------ | | 144| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1689| 0| savepc(ci); /* several calls here can raise errors */ ------------------ | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1690| 0| if (TESTARG_k(i)) { ------------------ | | 136| 0|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1691| 0| luaF_closeupval(L, base); /* close upvalues from current call */ 1692| 0| lua_assert(L->tbclist.p < base); /* no pending tbc variables */ ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ 1693| 0| lua_assert(base == ci->func.p + 1); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ 1694| 0| } 1695| 0| if ((n = luaD_pretailcall(L, ci, ra, b, delta)) < 0) /* Lua function? */ ------------------ | Branch (1695:13): [True: 0, False: 0] ------------------ 1696| 0| goto startfunc; /* execute the callee */ 1697| 0| else { /* C function? */ 1698| 0| ci->func.p -= delta; /* restore 'func' (if vararg) */ 1699| 0| luaD_poscall(L, ci, n); /* finish caller */ 1700| 0| updatetrap(ci); /* 'luaD_poscall' can change hooks */ ------------------ | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1701| 0| goto ret; /* caller returns after the tail call */ 1702| 0| } 1703| 0| } 1704| 496k| vmcase(OP_RETURN) { ------------------ | | 14| 496k|#define vmcase(l) L_##l: ------------------ 1705| 496k| StkId ra = RA(i); ------------------ | | 1059| 496k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 496k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 496k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 496k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 496k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1706| 496k| int n = GETARG_B(i) - 1; /* number of results */ ------------------ | | 128| 496k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 496k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 496k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1707| 496k| int nparams1 = GETARG_C(i); ------------------ | | 132| 496k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 113| 496k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 496k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1708| 496k| if (n < 0) /* not fixed? */ ------------------ | Branch (1708:13): [True: 0, False: 496k] ------------------ 1709| 0| n = cast_int(L->top.p - ra); /* get what is available */ ------------------ | | 144| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1710| 496k| savepc(ci); ------------------ | | 1100| 496k|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1711| 496k| if (TESTARG_k(i)) { /* may there be open upvalues? */ ------------------ | | 136| 496k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 113| 496k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 496k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:25): [True: 496k, False: 2] | | | | ------------------ | | ------------------ ------------------ 1712| 496k| ci->u2.nres = n; /* save number of returns */ 1713| 496k| if (L->top.p < ci->top.p) ------------------ | Branch (1713:15): [True: 5.50k, False: 491k] ------------------ 1714| 5.50k| L->top.p = ci->top.p; 1715| 496k| luaF_close(L, base, CLOSEKTOP, 1); ------------------ | | 47| 496k|#define CLOSEKTOP (-1) ------------------ 1716| 496k| updatetrap(ci); ------------------ | | 1070| 496k|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1717| 496k| updatestack(ci); ------------------ | | 1076| 496k| { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 697| 496k|#define l_unlikely(x) luai_unlikely(x) | | | | ------------------ | | | | | | 685| 496k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | ------------------ | | | | | | | Branch (685:26): [True: 0, False: 496k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | ------------------ | | { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1718| 496k| } 1719| 496k| if (nparams1) /* vararg function? */ ------------------ | Branch (1719:13): [True: 9, False: 496k] ------------------ 1720| 9| ci->func.p -= ci->u.l.nextraargs + nparams1; 1721| 496k| L->top.p = ra + n; /* set call for 'luaD_poscall' */ 1722| 496k| luaD_poscall(L, ci, n); 1723| 496k| updatetrap(ci); /* 'luaD_poscall' can change hooks */ ------------------ | | 1070| 496k|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1724| 496k| goto ret; 1725| 496k| } 1726| 36.5k| vmcase(OP_RETURN0) { ------------------ | | 14| 36.5k|#define vmcase(l) L_##l: ------------------ 1727| 36.5k| if (l_unlikely(L->hookmask)) { ------------------ | | 697| 36.5k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 36.5k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 36.5k] | | | | ------------------ | | ------------------ ------------------ 1728| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1729| 0| L->top.p = ra; 1730| 0| savepc(ci); ------------------ | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1731| 0| luaD_poscall(L, ci, 0); /* no hurry... */ 1732| 0| trap = 1; 1733| 0| } 1734| 36.5k| else { /* do the 'poscall' here */ 1735| 36.5k| int nres; 1736| 36.5k| L->ci = ci->previous; /* back to caller */ 1737| 36.5k| L->top.p = base - 1; 1738| 36.5k| for (nres = ci->nresults; l_unlikely(nres > 0); nres--) 1739| 36.5k| setnilvalue(s2v(L->top.p++)); /* all results are nil */ ------------------ | | 211| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1740| 36.5k| } 1741| 36.5k| goto ret; 1742| 496k| } 1743| 26.2k| vmcase(OP_RETURN1) { ------------------ | | 14| 26.2k|#define vmcase(l) L_##l: ------------------ 1744| 26.2k| if (l_unlikely(L->hookmask)) { ------------------ | | 697| 26.2k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 26.2k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 26.2k] | | | | ------------------ | | ------------------ ------------------ 1745| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1746| 0| L->top.p = ra + 1; 1747| 0| savepc(ci); ------------------ | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1748| 0| luaD_poscall(L, ci, 1); /* no hurry... */ 1749| 0| trap = 1; 1750| 0| } 1751| 26.2k| else { /* do the 'poscall' here */ 1752| 26.2k| int nres = ci->nresults; 1753| 26.2k| L->ci = ci->previous; /* back to caller */ 1754| 26.2k| if (nres == 0) ------------------ | Branch (1754:15): [True: 19.3k, False: 6.92k] ------------------ 1755| 19.3k| L->top.p = base - 1; /* asked for no results */ 1756| 6.92k| else { 1757| 6.92k| StkId ra = RA(i); ------------------ | | 1059| 6.92k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 6.92k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 6.92k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 6.92k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 6.92k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1758| 6.92k| setobjs2s(L, base - 1, ra); /* at least this result */ ------------------ | | 129| 6.92k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 6.92k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 6.92k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 6.92k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 6.92k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 6.92k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 6.92k|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 6.92k|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 6.92k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 6.92k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 6.92k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1759| 6.92k| L->top.p = base; 1760| 6.92k| for (; l_unlikely(nres > 1); nres--) 1761| 6.92k| setnilvalue(s2v(L->top.p++)); /* complete missing results */ ------------------ | | 211| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 6.92k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1762| 6.92k| } 1763| 26.2k| } 1764| 559k| ret: /* return from a Lua function */ 1765| 559k| if (ci->callstatus & CIST_FRESH) ------------------ | | 213| 559k|#define CIST_FRESH (1<<2) /* call is on a fresh "luaV_execute" frame */ ------------------ | Branch (1765:13): [True: 9, False: 559k] ------------------ 1766| 9| return; /* end this frame */ 1767| 559k| else { 1768| 559k| ci = ci->previous; 1769| 559k| goto returning; /* continue running caller in this frame */ 1770| 559k| } 1771| 559k| } 1772| 6.89M| vmcase(OP_FORLOOP) { ------------------ | | 14| 6.89M|#define vmcase(l) L_##l: ------------------ 1773| 6.89M| StkId ra = RA(i); ------------------ | | 1059| 6.89M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 6.89M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 6.89M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 6.89M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 6.89M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1774| 6.89M| if (ttisinteger(s2v(ra + 1))) { /* integer loop? */ ------------------ | | 341| 6.89M|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 6.89M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 6.89M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 6.89M, False: 0] | | | | ------------------ | | ------------------ ------------------ 1775| 6.89M| lua_Unsigned count = l_castS2U(ivalue(s2v(ra))); ------------------ | | 155| 27.5M|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | | Branch (155:38): [True: 0, False: 6.89M] | | | Branch (155:38): [True: 6.89M, False: 0] | | ------------------ ------------------ 1776| 6.89M| if (count > 0) { /* still more iterations? */ ------------------ | Branch (1776:15): [True: 6.72M, False: 174k] ------------------ 1777| 6.72M| lua_Integer step = ivalue(s2v(ra + 1)); ------------------ | | 346| 6.72M|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 6.72M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 6.72M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1778| 6.72M| lua_Integer idx = ivalue(s2v(ra + 2)); /* control variable */ ------------------ | | 346| 6.72M|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 6.72M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 6.72M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1779| 6.72M| chgivalue(s2v(ra), count - 1); /* update counter */ ------------------ | | 361| 6.72M| { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 109| 6.72M|#define lua_assert(c) assert(c) | | ------------------ | | { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 72| 6.72M|#define val_(o) ((o)->value_) | | ------------------ ------------------ 1780| 6.72M| idx = intop(+, idx, step); /* add step to index */ ------------------ | | 73| 6.72M|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 164| 6.72M|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 1781| 6.72M| chgivalue(s2v(ra + 2), idx); /* update control variable */ ------------------ | | 361| 6.72M| { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 109| 6.72M|#define lua_assert(c) assert(c) | | ------------------ | | { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 72| 6.72M|#define val_(o) ((o)->value_) | | ------------------ ------------------ 1782| 6.72M| pc -= GETARG_Bx(i); /* jump back */ ------------------ | | 140| 6.72M|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 113| 6.72M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 6.72M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1783| 6.72M| } 1784| 6.89M| } 1785| 0| else if (floatforloop(ra)) /* float loop */ ------------------ | Branch (1785:18): [True: 0, False: 0] ------------------ 1786| 0| pc -= GETARG_Bx(i); /* jump back */ ------------------ | | 140| 0|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1787| 6.89M| updatetrap(ci); /* allows a signal to break the loop */ ------------------ | | 1070| 6.89M|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1788| 6.89M| vmbreak; ------------------ | | 16| 6.89M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 6.89M|#define vmfetch() { \ | | | | 1134| 6.89M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 6.89M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 6.89M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 6.89M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 6.89M| i = *(pc++); \ | | | | 1139| 6.89M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 6.89M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1789| 6.89M| } 1790| 174k| vmcase(OP_FORPREP) { ------------------ | | 14| 174k|#define vmcase(l) L_##l: ------------------ 1791| 174k| StkId ra = RA(i); ------------------ | | 1059| 174k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 174k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 174k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 174k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 174k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1792| 174k| savestate(L, ci); /* in case of errors */ ------------------ | | 1107| 174k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1100| 174k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1793| 174k| if (forprep(L, ra)) ------------------ | Branch (1793:13): [True: 0, False: 174k] ------------------ 1794| 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)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1795| 174k| vmbreak; ------------------ | | 16| 174k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 174k|#define vmfetch() { \ | | | | 1134| 174k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 174k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 174k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 174k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 174k| i = *(pc++); \ | | | | 1139| 174k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 174k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1796| 174k| } 1797| 0| vmcase(OP_TFORPREP) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1798| | /* before: 'ra' has the iterator function, 'ra + 1' has the state, 1799| | 'ra + 2' has the initial value for the control variable, and 1800| | 'ra + 3' has the closing variable. This opcode then swaps the 1801| | control and the closing variables and marks the closing variable 1802| | as to-be-closed. 1803| | */ 1804| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1805| 0| TValue temp; /* to swap control and closing variables */ 1806| 0| setobj(L, &temp, s2v(ra + 3)); ------------------ | | 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) || \ | | | | ------------------ | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 109| 0|#define lua_assert(c) assert(c) | | ------------------ ------------------ 1807| 0| setobjs2s(L, ra + 3, ra + 2); ------------------ | | 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) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1808| 0| setobj2s(L, ra + 2, &temp); ------------------ | | 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) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1809| | /* create to-be-closed upvalue (if closing var. is not nil) */ 1810| 0| halfProtect(luaF_newtbcupval(L, ra + 2)); ------------------ | | 1123| 0|#define halfProtect(exp) (savestate(L,ci), (exp)) | | ------------------ | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ ------------------ 1811| 0| pc += GETARG_Bx(i); /* go to end of the loop */ ------------------ | | 140| 0|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1812| 0| i = *(pc++); /* fetch next instruction */ 1813| 0| lua_assert(GET_OPCODE(i) == OP_TFORCALL && ra == RA(i)); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ 1814| 0| goto l_tforcall; 1815| 0| } 1816| 0| vmcase(OP_TFORCALL) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1817| 0| l_tforcall: { 1818| | /* 'ra' has the iterator function, 'ra + 1' has the state, 1819| | 'ra + 2' has the closing variable, and 'ra + 3' has the control 1820| | variable. The call will use the stack starting at 'ra + 3', 1821| | so that it preserves the first three values, and the first 1822| | return will be the new value for the control variable. 1823| | */ 1824| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1825| 0| setobjs2s(L, ra + 5, ra + 3); /* copy the 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) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1826| 0| setobjs2s(L, ra + 4, ra + 1); /* copy state */ ------------------ | | 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) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1827| 0| setobjs2s(L, ra + 3, ra); /* copy function */ ------------------ | | 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) || \ | | | | | | ------------------ | | | | | | | | 115| 0|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1828| 0| L->top.p = ra + 3 + 3; 1829| 0| ProtectNT(luaD_call(L, ra + 3, GETARG_C(i))); /* do the call */ ------------------ | | 1117| 0|#define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ | | #define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ | | | Branch (1117:38): [True: 0, False: 0] | | | Branch (1117:38): [True: 0, False: 0] | | ------------------ ------------------ 1830| 0| updatestack(ci); /* stack may have changed */ ------------------ | | 1076| 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); } } | | ------------------ | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | ------------------ | | { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1831| 0| i = *(pc++); /* go to next instruction */ 1832| 0| lua_assert(GET_OPCODE(i) == OP_TFORLOOP && ra == RA(i)); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ 1833| 0| goto l_tforloop; 1834| 0| }} 1835| 0| vmcase(OP_TFORLOOP) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1836| 0| l_tforloop: { 1837| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1838| 0| if (!ttisnil(s2v(ra + 3))) /* continue loop? */ ------------------ | | 196| 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 (1838:13): [True: 0, False: 0] ------------------ 1839| 0| pc -= GETARG_Bx(i); /* jump back */ ------------------ | | 140| 0|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1840| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1841| 0| }} 1842| 101k| vmcase(OP_SETLIST) { ------------------ | | 14| 101k|#define vmcase(l) L_##l: ------------------ 1843| 101k| StkId ra = RA(i); ------------------ | | 1059| 101k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 101k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 101k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 101k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 101k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1844| 101k| int n = GETARG_B(i); ------------------ | | 128| 101k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 113| 101k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 101k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1845| 101k| unsigned int last = GETARG_C(i); ------------------ | | 132| 101k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 113| 101k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 101k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1846| 202k| Table *h = hvalue(s2v(ra)); ------------------ | | 721| 101k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 113| 405k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 101k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 101k] | | | | | Branch (113:42): [True: 101k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1847| 101k| if (n == 0) ------------------ | Branch (1847:13): [True: 46.6k, False: 54.6k] ------------------ 1848| 46.6k| n = cast_int(L->top.p - ra) - 1; /* get up to the top */ ------------------ | | 144| 46.6k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 139| 46.6k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1849| 54.6k| else 1850| 54.6k| L->top.p = ci->top.p; /* correct top in case of emergency GC */ 1851| 202k| last += n; 1852| 202k| if (TESTARG_k(i)) { ------------------ | | 136| 101k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 113| 101k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 101k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:25): [True: 10.3k, False: 90.9k] | | | | ------------------ | | ------------------ ------------------ 1853| 10.3k| last += GETARG_Ax(*pc) * (MAXARG_C + 1); ------------------ | | 143| 10.3k|#define GETARG_Ax(i) check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax)) | | ------------------ | | | | 113| 10.3k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 10.3k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ last += GETARG_Ax(*pc) * (MAXARG_C + 1); ------------------ | | 97| 10.3k|#define MAXARG_C ((1< luaH_realasize(h)) /* needs more space? */ ------------------ | Branch (1856:13): [True: 10.1k, False: 91.1k] ------------------ 1857| 10.1k| luaH_resizearray(L, h, last); /* preallocate it at once */ 1858| 1.18M| for (; n > 0; n--) { ------------------ | Branch (1858:16): [True: 1.08M, False: 101k] ------------------ 1859| 1.08M| TValue *val = s2v(ra + n); ------------------ | | 172| 1.08M|#define s2v(o) (&(o)->val) ------------------ 1860| 1.08M| obj2arr(h, last, val); ------------------ | | 119| 1.08M| (*getArrTag(h,(k)-1u) = (val)->tt_, *getArrVal(h,(k)-1u) = (val)->value_) | | ------------------ | | | | 106| 1.08M|#define getArrTag(t,k) (cast(lu_byte*, (t)->array) + (k)) | | | | ------------------ | | | | | | 139| 1.08M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | (*getArrTag(h,(k)-1u) = (val)->tt_, *getArrVal(h,(k)-1u) = (val)->value_) | | ------------------ | | | | 109| 1.08M|#define getArrVal(t,k) ((t)->array - 1 - (k)) | | ------------------ ------------------ 1861| 1.08M| last--; 1862| 1.08M| luaC_barrierback(L, obj2gco(h), val); ------------------ | | 232| 1.08M|#define luaC_barrierback(L,p,v) ( \ | | 233| 1.08M| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 313| 1.08M|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 1.08M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 311| 1.08M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (313:26): [True: 44.2k, False: 1.04M] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 229| 44.2k|#define luaC_objbarrierback(L,p,o) ( \ | | | | 230| 44.2k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 91| 44.2k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 70| 44.2k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 65| 176k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (65:24): [True: 2, False: 44.2k] | | | | | | | | | | | Branch (65:26): [True: 0, False: 44.2k] | | | | | | | | | | | Branch (65:26): [True: 44.2k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 90| 2|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 65| 8|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 2] | | | | | | | | | Branch (65:26): [True: 0, False: 2] | | | | | | | | | Branch (65:26): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 141| 44.2k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 139| 44.2k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (230:51): [True: 0, False: 0] | | | | | Branch (230:51): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 141| 1.04M|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 1.04M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1863| 1.08M| } 1864| 101k| vmbreak; ------------------ | | 16| 101k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 101k|#define vmfetch() { \ | | | | 1134| 101k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 101k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 101k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 0, False: 101k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 101k| i = *(pc++); \ | | | | 1139| 101k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 101k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1865| 101k| } 1866| 1.07M| vmcase(OP_CLOSURE) { ------------------ | | 14| 1.07M|#define vmcase(l) L_##l: ------------------ 1867| 1.07M| StkId ra = RA(i); ------------------ | | 1059| 1.07M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1.07M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1.07M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 1.07M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 1.07M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1868| 1.07M| Proto *p = cl->p->p[GETARG_Bx(i)]; ------------------ | | 140| 1.07M|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 113| 1.07M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 1.07M|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1869| 1.07M| halfProtect(pushclosure(L, p, cl->upvals, base, ra)); ------------------ | | 1123| 1.07M|#define halfProtect(exp) (savestate(L,ci), (exp)) | | ------------------ | | | | 1107| 1.07M|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 1.07M|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ ------------------ 1870| 1.07M| checkGC(L, ra + 1); ------------------ | | 1127| 1.07M| { luaC_condGC(L, (savepc(L), L->top.p = (c)), \ | | ------------------ | | | | 215| 1.07M| { if (G(L)->GCdebt <= 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 333| 1.07M|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (215:8): [True: 11.5k, False: 1.06M] | | | | ------------------ | | | | 216| 1.07M| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 377| 1.07M|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 1128| 1.07M| updatetrap(ci)); \ | | 1129| 1.07M| luai_threadyield(L); } | | ------------------ | | | | 276| 1.07M|#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 268| 1.07M|#define lua_unlock(L) ((void) 0) | | | | ------------------ | | | | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 267| 1.07M|#define lua_lock(L) ((void) 0) | | | | ------------------ | | ------------------ ------------------ 1871| 1.07M| vmbreak; ------------------ | | 16| 1.07M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 1.07M|#define vmfetch() { \ | | | | 1134| 1.07M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.07M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.07M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 103, False: 1.07M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 103| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 103| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 103|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 103| } \ | | | | 1138| 1.07M| i = *(pc++); \ | | | | 1139| 1.07M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.07M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1872| 1.07M| } 1873| 75.4k| vmcase(OP_VARARG) { ------------------ | | 14| 75.4k|#define vmcase(l) L_##l: ------------------ 1874| 75.4k| StkId ra = RA(i); ------------------ | | 1059| 75.4k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 75.4k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 75.4k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 144| 75.4k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 139| 75.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1875| 75.4k| int n = GETARG_C(i) - 1; /* required results */ ------------------ | | 132| 75.4k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 113| 75.4k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 75.4k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 1876| 75.4k| Protect(luaT_getvarargs(L, ci, ra, n)); ------------------ | | 1114| 75.4k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 75.4k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 75.4k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 75.4k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1877| 75.4k| vmbreak; ------------------ | | 16| 75.4k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 75.4k|#define vmfetch() { \ | | | | 1134| 75.4k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 75.4k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 75.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 14, False: 75.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 14| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 14| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 14|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 14| } \ | | | | 1138| 75.4k| i = *(pc++); \ | | | | 1139| 75.4k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 75.4k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1878| 75.4k| } 1879| 1.19k| vmcase(OP_VARARGPREP) { ------------------ | | 14| 1.19k|#define vmcase(l) L_##l: ------------------ 1880| 1.19k| ProtectNT(luaT_adjustvarargs(L, GETARG_A(i), ci, cl->p)); ------------------ | | 1117| 1.19k|#define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1100| 1.19k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ | | #define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 1.19k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1881| 1.19k| if (l_unlikely(trap)) { /* previous "Protect" updated trap */ ------------------ | | 697| 1.19k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 1.19k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 14, False: 1.18k] | | | | ------------------ | | ------------------ ------------------ 1882| 14| luaD_hookcall(L, ci); 1883| 14| L->oldpc = 1; /* next opcode will be seen as a "new" line */ 1884| 14| } 1885| 1.19k| updatebase(ci); /* function has new base after adjustment */ ------------------ | | 1072| 1.19k|#define updatebase(ci) (base = ci->func.p + 1) ------------------ 1886| 1.19k| vmbreak; ------------------ | | 16| 1.19k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 1.19k|#define vmfetch() { \ | | | | 1134| 1.19k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 697| 1.19k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 685| 1.19k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (685:26): [True: 14, False: 1.18k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 14| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 14| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 14|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 14| } \ | | | | 1138| 1.19k| i = *(pc++); \ | | | | 1139| 1.19k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.19k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1887| 1.19k| } 1888| 1.19k| vmcase(OP_EXTRAARG) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1889| 0| lua_assert(0); ------------------ | | 109| 0|#define lua_assert(c) assert(c) ------------------ 1890| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1891| 0| } 1892| 0| } 1893| 0| } 1894| 2.24M|} lvm.c:l_strton: 90| 174k|static int l_strton (const TValue *obj, TValue *result) { 91| 174k| lua_assert(obj != result); ------------------ | | 109| 174k|#define lua_assert(c) assert(c) ------------------ 92| 174k| if (!cvt2num(obj)) /* is object not a string? */ ------------------ | | 24| 174k|#define cvt2num(o) ttisstring(o) | | ------------------ | | | | 376| 174k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | | | ------------------ | | | | | | 92| 174k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 174k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 174k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (92:7): [True: 174k, False: 2] ------------------ 93| 174k| return 0; 94| 2| else { 95| 2| TString *st = tsvalue(obj); ------------------ | | 382| 2|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 8|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 2|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 2] | | | | | Branch (113:42): [True: 2, False: 0] | | | | ------------------ | | ------------------ ------------------ 96| 0| size_t stlen; 97| 2| const char *s = getlstr(st, stlen); ------------------ | | 440| 2| (strisshr(ts) \ | | ------------------ | | | | 420| 2|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 0, False: 2] | | | | ------------------ | | ------------------ | | 441| 2| ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 141| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 427| 0|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 0|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 442| 2| : (cast_void((len) = (ts)->u.lnglen), (ts)->contents)) | | ------------------ | | | | 141| 2|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 2|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 98| 2| return (luaO_str2num(s, result) == stlen + 1); 99| 2| } 100| 174k|} lvm.c:LTnum: 474| 47.5k|l_sinline int LTnum (const TValue *l, const TValue *r) { 475| 47.5k| lua_assert(ttisnumber(l) && ttisnumber(r)); ------------------ | | 109| 47.5k|#define lua_assert(c) assert(c) ------------------ 476| 47.5k| if (ttisinteger(l)) { ------------------ | | 341| 47.5k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 47.5k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 47.5k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 45.1k, False: 2.38k] | | | | ------------------ | | ------------------ ------------------ 477| 45.1k| lua_Integer li = ivalue(l); ------------------ | | 346| 45.1k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 45.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 45.1k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 478| 45.1k| if (ttisinteger(r)) ------------------ | | 341| 45.1k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 45.1k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 45.1k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 45.1k] | | | | ------------------ | | ------------------ ------------------ 479| 45.1k| return li < ivalue(r); /* both are integers */ ------------------ | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 480| 45.1k| else /* 'l' is int and 'r' is float */ 481| 45.1k| return LTintfloat(li, fltvalue(r)); /* l < r ? */ ------------------ | | 345| 45.1k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 113| 45.1k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 45.1k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 482| 45.1k| } 483| 2.38k| else { 484| 2.38k| lua_Number lf = fltvalue(l); /* 'l' must be float */ ------------------ | | 345| 2.38k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 113| 2.38k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 2.38k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 485| 2.38k| if (ttisfloat(r)) ------------------ | | 340| 2.38k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 2.38k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 2.38k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 1.76k, False: 612] | | | | ------------------ | | ------------------ ------------------ 486| 2.38k| return luai_numlt(lf, fltvalue(r)); /* both are float */ ------------------ | | 354| 7.07k|#define luai_numlt(a,b) ((a)<(b)) | | ------------------ | | | Branch (354:39): [True: 0, False: 1.76k] | | | Branch (354:39): [True: 1.76k, False: 0] | | ------------------ ------------------ 487| 612| else /* 'l' is float and 'r' is int */ 488| 612| return LTfloatint(lf, ivalue(r)); ------------------ | | 346| 612|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 612|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 612|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 489| 2.38k| } 490| 47.5k|} lvm.c:LTintfloat: 407| 45.1k|l_sinline int LTintfloat (lua_Integer i, lua_Number f) { 408| 45.1k| if (l_intfitsf(i)) ------------------ | | 74| 45.1k|#define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 45.1k|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 45.1k|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 45.1k|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 155| 45.1k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 45.1k|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 45.1k|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 45.1k|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (74:23): [True: 42.5k, False: 2.59k] | | ------------------ ------------------ 409| 42.5k| return luai_numlt(cast_num(i), f); /* compare them as floats */ ------------------ | | 354| 42.5k|#define luai_numlt(a,b) ((a)<(b)) ------------------ 410| 2.59k| else { /* i < f <=> i < ceil(f) */ 411| 2.59k| lua_Integer fi; 412| 2.59k| if (luaV_flttointeger(f, &fi, F2Iceil)) /* fi = ceil(f) */ ------------------ | Branch (412:9): [True: 0, False: 2.59k] ------------------ 413| 0| return i < fi; /* compare them as integers */ 414| 2.59k| else /* 'f' is either greater or less than all integers */ 415| 2.59k| return f > 0; /* greater? */ 416| 2.59k| } 417| 45.1k|} lvm.c:LTfloatint: 441| 612|l_sinline int LTfloatint (lua_Number f, lua_Integer i) { 442| 612| if (l_intfitsf(i)) ------------------ | | 74| 612|#define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 612|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 612|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 612|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 155| 612|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 612|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 612|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 612|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (74:23): [True: 450, False: 162] | | ------------------ ------------------ 443| 450| return luai_numlt(f, cast_num(i)); /* compare them as floats */ ------------------ | | 354| 450|#define luai_numlt(a,b) ((a)<(b)) ------------------ 444| 162| else { /* f < i <=> floor(f) < i */ 445| 162| lua_Integer fi; 446| 162| if (luaV_flttointeger(f, &fi, F2Ifloor)) /* fi = floor(f) */ ------------------ | Branch (446:9): [True: 162, False: 0] ------------------ 447| 162| return fi < i; /* compare them as integers */ 448| 0| else /* 'f' is either greater or less than all integers */ 449| 0| return f < 0; /* less? */ 450| 162| } 451| 612|} lvm.c:lessthanothers: 518| 17|static int lessthanothers (lua_State *L, const TValue *l, const TValue *r) { 519| 17| lua_assert(!ttisnumber(l) || !ttisnumber(r)); ------------------ | | 109| 17|#define lua_assert(c) assert(c) ------------------ 520| 17| if (ttisstring(l) && ttisstring(r)) /* both are strings? */ ------------------ | | 376| 17|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 34|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 17|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 17|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 2, False: 15] | | | | ------------------ | | ------------------ ------------------ if (ttisstring(l) && ttisstring(r)) /* both are strings? */ ------------------ | | 376| 2|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 2|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 2|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 2|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ ------------------ 521| 4| return l_strcmp(tsvalue(l), tsvalue(r)) < 0; ------------------ | | 382| 2|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 8|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 2|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 2] | | | | | Branch (113:42): [True: 2, False: 0] | | | | ------------------ | | ------------------ ------------------ return l_strcmp(tsvalue(l), tsvalue(r)) < 0; ------------------ | | 382| 2|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 8|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 2|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 2] | | | | | Branch (113:42): [True: 2, False: 0] | | | | ------------------ | | ------------------ ------------------ 522| 15| else 523| 15| return luaT_callorderTM(L, l, r, TM_LT); 524| 17|} lvm.c:l_strcmp: 372| 2|static int l_strcmp (const TString *ts1, const TString *ts2) { 373| 2| size_t rl1; /* real length */ 374| 2| const char *s1 = getlstr(ts1, rl1); ------------------ | | 440| 2| (strisshr(ts) \ | | ------------------ | | | | 420| 2|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 0, False: 2] | | | | ------------------ | | ------------------ | | 441| 2| ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 141| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 427| 0|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 0|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 442| 2| : (cast_void((len) = (ts)->u.lnglen), (ts)->contents)) | | ------------------ | | | | 141| 2|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 2|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 375| 2| size_t rl2; 376| 2| const char *s2 = getlstr(ts2, rl2); ------------------ | | 440| 2| (strisshr(ts) \ | | ------------------ | | | | 420| 2|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 0, False: 2] | | | | ------------------ | | ------------------ | | 441| 2| ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 141| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 427| 0|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 0|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 442| 2| : (cast_void((len) = (ts)->u.lnglen), (ts)->contents)) | | ------------------ | | | | 141| 2|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 2|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 377| 2| for (;;) { /* for each segment */ 378| 2| int temp = strcoll(s1, s2); 379| 2| if (temp != 0) /* not equal? */ ------------------ | Branch (379:9): [True: 2, False: 0] ------------------ 380| 2| return temp; /* done */ 381| 0| else { /* strings are equal up to a '\0' */ 382| 0| size_t zl1 = strlen(s1); /* index of first '\0' in 's1' */ 383| 0| size_t zl2 = strlen(s2); /* index of first '\0' in 's2' */ 384| 0| if (zl2 == rl2) /* 's2' is finished? */ ------------------ | Branch (384:11): [True: 0, False: 0] ------------------ 385| 0| return (zl1 == rl1) ? 0 : 1; /* check 's1' */ ------------------ | Branch (385:16): [True: 0, False: 0] ------------------ 386| 0| else if (zl1 == rl1) /* 's1' is finished? */ ------------------ | Branch (386:16): [True: 0, False: 0] ------------------ 387| 0| return -1; /* 's1' is less than 's2' ('s2' is not finished) */ 388| | /* both strings longer than 'zl'; go on comparing after the '\0' */ 389| 0| zl1++; zl2++; 390| 0| s1 += zl1; rl1 -= zl1; s2 += zl2; rl2 -= zl2; 391| 0| } 392| 2| } 393| 2|} lvm.c:LEnum: 496| 23.6k|l_sinline int LEnum (const TValue *l, const TValue *r) { 497| 23.6k| lua_assert(ttisnumber(l) && ttisnumber(r)); ------------------ | | 109| 23.6k|#define lua_assert(c) assert(c) ------------------ 498| 23.6k| if (ttisinteger(l)) { ------------------ | | 341| 23.6k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 23.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 23.6k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 22.2k, False: 1.36k] | | | | ------------------ | | ------------------ ------------------ 499| 22.2k| lua_Integer li = ivalue(l); ------------------ | | 346| 22.2k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 22.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 22.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 500| 22.2k| if (ttisinteger(r)) ------------------ | | 341| 22.2k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 22.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 22.2k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 22.2k] | | | | ------------------ | | ------------------ ------------------ 501| 22.2k| return li <= ivalue(r); /* both are integers */ ------------------ | | 346| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 502| 22.2k| else /* 'l' is int and 'r' is float */ 503| 22.2k| return LEintfloat(li, fltvalue(r)); /* l <= r ? */ ------------------ | | 345| 22.2k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 113| 22.2k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 22.2k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 504| 22.2k| } 505| 1.36k| else { 506| 1.36k| lua_Number lf = fltvalue(l); /* 'l' must be float */ ------------------ | | 345| 1.36k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 113| 1.36k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 1.36k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 507| 1.36k| if (ttisfloat(r)) ------------------ | | 340| 1.36k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 1.36k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 1.36k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 1.36k, False: 3] | | | | ------------------ | | ------------------ ------------------ 508| 1.36k| return luai_numle(lf, fltvalue(r)); /* both are float */ ------------------ | | 355| 5.44k|#define luai_numle(a,b) ((a)<=(b)) | | ------------------ | | | Branch (355:40): [True: 0, False: 1.36k] | | | Branch (355:40): [True: 1.36k, False: 0] | | ------------------ ------------------ 509| 3| else /* 'l' is float and 'r' is int */ 510| 3| return LEfloatint(lf, ivalue(r)); ------------------ | | 346| 3|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 3|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 3|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 511| 1.36k| } 512| 23.6k|} lvm.c:LEintfloat: 424| 22.2k|l_sinline int LEintfloat (lua_Integer i, lua_Number f) { 425| 22.2k| if (l_intfitsf(i)) ------------------ | | 74| 22.2k|#define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 22.2k|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 22.2k|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 22.2k|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 155| 22.2k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 22.2k|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 22.2k|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 22.2k|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (74:23): [True: 16.9k, False: 5.36k] | | ------------------ ------------------ 426| 16.9k| return luai_numle(cast_num(i), f); /* compare them as floats */ ------------------ | | 355| 16.9k|#define luai_numle(a,b) ((a)<=(b)) ------------------ 427| 5.36k| else { /* i <= f <=> i <= floor(f) */ 428| 5.36k| lua_Integer fi; 429| 5.36k| if (luaV_flttointeger(f, &fi, F2Ifloor)) /* fi = floor(f) */ ------------------ | Branch (429:9): [True: 5.36k, False: 0] ------------------ 430| 5.36k| return i <= fi; /* compare them as integers */ 431| 0| else /* 'f' is either greater or less than all integers */ 432| 0| return f > 0; /* greater? */ 433| 5.36k| } 434| 22.2k|} lvm.c:LEfloatint: 458| 3|l_sinline int LEfloatint (lua_Number f, lua_Integer i) { 459| 3| if (l_intfitsf(i)) ------------------ | | 74| 3|#define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 3|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 3|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 3|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 155| 3|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 3|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 3|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 475| 3|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (74:23): [True: 3, False: 0] | | ------------------ ------------------ 460| 3| return luai_numle(f, cast_num(i)); /* compare them as floats */ ------------------ | | 355| 3|#define luai_numle(a,b) ((a)<=(b)) ------------------ 461| 0| else { /* f <= i <=> ceil(f) <= i */ 462| 0| lua_Integer fi; 463| 0| if (luaV_flttointeger(f, &fi, F2Iceil)) /* fi = ceil(f) */ ------------------ | Branch (463:9): [True: 0, False: 0] ------------------ 464| 0| return fi <= i; /* compare them as integers */ 465| 0| else /* 'f' is either greater or less than all integers */ 466| 0| return f < 0; /* less? */ 467| 0| } 468| 3|} lvm.c:copy2buff: 622| 39.2k|static void copy2buff (StkId top, int n, char *buff) { 623| 39.2k| size_t tl = 0; /* size already copied */ 624| 78.4k| do { 625| 156k| TString *st = tsvalue(s2v(top - n)); ------------------ | | 382| 78.4k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 113| 313k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 78.4k|#define lua_assert(c) assert(c) | | | | ------------------ | | | | | Branch (113:42): [True: 0, False: 78.4k] | | | | | Branch (113:42): [True: 78.4k, False: 0] | | | | ------------------ | | ------------------ ------------------ 626| 0| size_t l; /* length of string being copied */ 627| 156k| const char *s = getlstr(st, l); ------------------ | | 440| 78.4k| (strisshr(ts) \ | | ------------------ | | | | 420| 78.4k|#define strisshr(ts) ((ts)->shrlen >= 0) | | | | ------------------ | | | | | Branch (420:22): [True: 78.0k, False: 414] | | | | ------------------ | | ------------------ | | 441| 78.4k| ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 141| 78.0k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 78.0k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | ? (cast_void((len) = (ts)->shrlen), rawgetshrstr(ts)) \ | | ------------------ | | | | 427| 78.0k|#define rawgetshrstr(ts) (cast_charp(&(ts)->contents)) | | | | ------------------ | | | | | | 149| 78.0k|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 139| 78.0k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 442| 78.4k| : (cast_void((len) = (ts)->u.lnglen), (ts)->contents)) | | ------------------ | | | | 141| 414|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 414|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 628| 156k| memcpy(buff + tl, s, l * sizeof(char)); 629| 156k| tl += l; 630| 156k| } while (--n > 0); ------------------ | Branch (630:12): [True: 39.2k, False: 39.2k] ------------------ 631| 39.2k|} lvm.c:forprep: 213| 174k|static int forprep (lua_State *L, StkId ra) { 214| 174k| TValue *pinit = s2v(ra); ------------------ | | 172| 174k|#define s2v(o) (&(o)->val) ------------------ 215| 174k| TValue *plimit = s2v(ra + 1); ------------------ | | 172| 174k|#define s2v(o) (&(o)->val) ------------------ 216| 174k| TValue *pstep = s2v(ra + 2); ------------------ | | 172| 174k|#define s2v(o) (&(o)->val) ------------------ 217| 174k| if (ttisinteger(pinit) && ttisinteger(pstep)) { /* integer loop? */ ------------------ | | 341| 174k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 349k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 174k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 174k, False: 0] | | | | ------------------ | | ------------------ ------------------ if (ttisinteger(pinit) && ttisinteger(pstep)) { /* integer loop? */ ------------------ | | 341| 174k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 174k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 174k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 174k, False: 0] | | | | ------------------ | | ------------------ ------------------ 218| 174k| lua_Integer init = ivalue(pinit); ------------------ | | 346| 174k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 174k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 174k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 219| 174k| lua_Integer step = ivalue(pstep); ------------------ | | 346| 174k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 113| 174k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | ------------------ | | | | | | 109| 174k|#define lua_assert(c) assert(c) | | | | ------------------ | | ------------------ ------------------ 220| 0| lua_Integer limit; 221| 174k| if (step == 0) ------------------ | Branch (221:9): [True: 0, False: 174k] ------------------ 222| 0| luaG_runerror(L, "'for' step is zero"); 223| 174k| if (forlimit(L, init, plimit, &limit, step)) ------------------ | Branch (223:9): [True: 0, False: 174k] ------------------ 224| 0| return 1; /* skip the loop */ 225| 174k| else { /* prepare loop counter */ 226| 174k| lua_Unsigned count; 227| 174k| if (step > 0) { /* ascending loop? */ ------------------ | Branch (227:11): [True: 89.4k, False: 85.2k] ------------------ 228| 89.4k| count = l_castS2U(limit) - l_castS2U(init); ------------------ | | 155| 89.4k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ count = l_castS2U(limit) - l_castS2U(init); ------------------ | | 155| 89.4k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 229| 89.4k| if (step != 1) /* avoid division in the too common case */ ------------------ | Branch (229:13): [True: 89.4k, False: 12] ------------------ 230| 89.4k| count /= l_castS2U(step); ------------------ | | 155| 89.4k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 231| 89.4k| } 232| 85.2k| else { /* step < 0; descending loop */ 233| 85.2k| count = l_castS2U(init) - l_castS2U(limit); ------------------ | | 155| 85.2k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ count = l_castS2U(init) - l_castS2U(limit); ------------------ | | 155| 85.2k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 234| | /* 'step+1' avoids negating 'mininteger' */ 235| 85.2k| count /= l_castS2U(-(step + 1)) + 1u; ------------------ | | 155| 85.2k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 236| 85.2k| } 237| | /* use 'chgivalue' for places that for sure had integers */ 238| 174k| chgivalue(s2v(ra), l_castU2S(count)); /* change init to count */ ------------------ | | 361| 174k| { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 109| 174k|#define lua_assert(c) assert(c) | | ------------------ | | { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 72| 174k|#define val_(o) ((o)->value_) | | ------------------ ------------------ 239| 174k| setivalue(s2v(ra + 1), step); /* change limit to step */ ------------------ | | 358| 174k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 174k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 174k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 240| 174k| chgivalue(s2v(ra + 2), init); /* change step to init */ ------------------ | | 361| 174k| { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 109| 174k|#define lua_assert(c) assert(c) | | ------------------ | | { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 72| 174k|#define val_(o) ((o)->value_) | | ------------------ ------------------ 241| 174k| } 242| 174k| } 243| 0| else { /* try making all values floats */ 244| 0| lua_Number init; lua_Number limit; lua_Number step; 245| 0| if (l_unlikely(!tonumber(plimit, &limit))) ------------------ | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 246| 0| luaG_forerror(L, plimit, "limit"); 247| 0| if (l_unlikely(!tonumber(pstep, &step))) ------------------ | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 248| 0| luaG_forerror(L, pstep, "step"); 249| 0| if (l_unlikely(!tonumber(pinit, &init))) ------------------ | | 697| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 685| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (685:26): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | | Branch (685:46): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 250| 0| luaG_forerror(L, pinit, "initial value"); 251| 0| if (step == 0) ------------------ | Branch (251:9): [True: 0, False: 0] ------------------ 252| 0| luaG_runerror(L, "'for' step is zero"); 253| 0| if (luai_numlt(0, step) ? luai_numlt(limit, init) ------------------ | | 354| 0|#define luai_numlt(a,b) ((a)<(b)) | | ------------------ | | | Branch (354:33): [True: 0, False: 0] | | ------------------ ------------------ if (luai_numlt(0, step) ? luai_numlt(limit, init) ------------------ | | 354| 0|#define luai_numlt(a,b) ((a)<(b)) ------------------ | Branch (253:9): [True: 0, False: 0] ------------------ 254| 0| : luai_numlt(init, limit)) ------------------ | | 354| 0|#define luai_numlt(a,b) ((a)<(b)) ------------------ 255| 0| return 1; /* skip the loop */ 256| 0| else { 257| | /* make sure all values are floats */ 258| 0| setfltvalue(s2v(ra), limit); ------------------ | | 352| 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)) | | ------------------ ------------------ 259| 0| setfltvalue(s2v(ra + 1), step); ------------------ | | 352| 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)) | | ------------------ ------------------ 260| 0| setfltvalue(s2v(ra + 2), init); /* control variable */ ------------------ | | 352| 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)) | | ------------------ ------------------ 261| 0| } 262| 0| } 263| 174k| return 0; 264| 174k|} lvm.c:forlimit: 181| 174k| lua_Integer *p, lua_Integer step) { 182| 174k| if (!luaV_tointeger(lim, p, (step < 0 ? F2Iceil : F2Ifloor))) { ------------------ | Branch (182:7): [True: 154k, False: 20.2k] | Branch (182:32): [True: 85.2k, False: 89.4k] ------------------ 183| | /* not coercible to in integer */ 184| 154k| lua_Number flim; /* try to convert to float */ 185| 154k| if (!tonumber(lim, &flim)) /* cannot convert to float? */ ------------------ | | 52| 154k| (ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n)) | | ------------------ | | | | 340| 154k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 154k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 154k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 154k, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n)) | | ------------------ | | | | 345| 154k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 113| 154k|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 154k|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (185:9): [True: 1, False: 154k] ------------------ 186| 1| luaG_forerror(L, lim, "limit"); 187| | /* else 'flim' is a float out of integer bounds */ 188| 154k| if (luai_numlt(0, flim)) { /* if it is positive, it is too large */ ------------------ | | 354| 154k|#define luai_numlt(a,b) ((a)<(b)) | | ------------------ | | | Branch (354:33): [True: 88.3k, False: 66.0k] | | ------------------ ------------------ 189| 88.3k| if (step < 0) return 1; /* initial value must be less than it */ ------------------ | Branch (189:11): [True: 0, False: 88.3k] ------------------ 190| 88.3k| *p = LUA_MAXINTEGER; /* truncate */ ------------------ | | 554| 88.3k|#define LUA_MAXINTEGER LLONG_MAX ------------------ 191| 88.3k| } 192| 66.0k| else { /* it is less than min integer */ 193| 66.0k| if (step > 0) return 1; /* initial value must be greater than it */ ------------------ | Branch (193:11): [True: 0, False: 66.0k] ------------------ 194| 66.0k| *p = LUA_MININTEGER; /* truncate */ ------------------ | | 555| 66.0k|#define LUA_MININTEGER LLONG_MIN ------------------ 195| 66.0k| } 196| 154k| } 197| 174k| return (step > 0 ? init > *p : init < *p); /* not to run? */ ------------------ | Branch (197:11): [True: 89.4k, False: 85.2k] ------------------ 198| 174k|} lvm.c:pushclosure: 789| 1.07M| StkId ra) { 790| 1.07M| int nup = p->sizeupvalues; 791| 1.07M| Upvaldesc *uv = p->upvalues; 792| 1.07M| int i; 793| 1.07M| LClosure *ncl = luaF_newLclosure(L, nup); 794| 1.07M| ncl->p = p; 795| 1.07M| setclLvalue2s(L, ra, ncl); /* anchor new closure in stack */ ------------------ | | 652| 1.07M|#define setclLvalue2s(L,o,cl) setclLvalue(L,s2v(o),cl) | | ------------------ | | | | 648| 1.07M| { TValue *io = (obj); LClosure *x_ = (x); \ | | | | 649| 1.07M| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 72| 1.07M|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 388| 1.07M|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 113| 1.07M|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.07M|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 114| 1.07M|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 650| 1.07M| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 1.07M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 115| 17.2M|#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) | | | | | | | | ------------------ | | | | | | | | | | 109| 1.07M|#define lua_assert(c) assert(c) | | | | | | | | ------------------ | | | | | | | | | Branch (115:29): [True: 0, False: 1.07M] | | | | | | | | | Branch (115:29): [True: 1.07M, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 1.07M] | | | | | | | | | Branch (115:29): [True: 1.07M, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 1.07M] | | | | | | | | | Branch (115:29): [True: 1.07M, False: 0] | | | | | | | | | Branch (115:29): [True: 1.07M, False: 0] | | | | | | | | | Branch (115:29): [True: 0, False: 1.07M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 108| 1.07M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 796| 4.24M| for (i = 0; i < nup; i++) { /* fill in its upvalues */ ------------------ | Branch (796:15): [True: 3.16M, False: 1.07M] ------------------ 797| 3.16M| if (uv[i].instack) /* upvalue refers to local variable? */ ------------------ | Branch (797:9): [True: 1.57M, False: 1.59M] ------------------ 798| 1.57M| ncl->upvals[i] = luaF_findupval(L, base + uv[i].idx); 799| 1.59M| else /* get upvalue from enclosing function */ 800| 1.59M| ncl->upvals[i] = encup[uv[i].idx]; 801| 3.16M| luaC_objbarrier(L, ncl, ncl->upvals[i]); ------------------ | | 222| 3.16M|#define luaC_objbarrier(L,p,o) ( \ | | 223| 3.16M| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 91| 3.16M|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 70| 3.16M|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 65| 6.32M|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (65:24): [True: 0, False: 3.16M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 90| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 65| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (65:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 224| 3.16M| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 388| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 113| 0|#define check_exp(c,e) (lua_assert(c), (e)) | | | | | | ------------------ | | | | | | | | 109| 0|#define lua_assert(c) assert(c) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 141| 3.16M|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 139| 3.16M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 802| 3.16M| } 803| 1.07M|} luaZ_fill: 23| 803|int luaZ_fill (ZIO *z) { 24| 803| size_t size; 25| 803| lua_State *L = z->L; 26| 803| const char *buff; 27| 803| lua_unlock(L); ------------------ | | 268| 803|#define lua_unlock(L) ((void) 0) ------------------ 28| 803| buff = z->reader(L, z->data, &size); 29| 803| lua_lock(L); ------------------ | | 267| 803|#define lua_lock(L) ((void) 0) ------------------ 30| 803| if (buff == NULL || size == 0) ------------------ | Branch (30:7): [True: 242, False: 561] | Branch (30:23): [True: 0, False: 561] ------------------ 31| 242| return EOZ; ------------------ | | 16| 242|#define EOZ (-1) /* end of stream */ ------------------ 32| 561| z->n = size - 1; /* discount char being returned */ 33| 561| z->p = buff; 34| 561| return cast_uchar(*(z->p++)); ------------------ | | 147| 561|#define cast_uchar(i) cast(unsigned char, (i)) | | ------------------ | | | | 139| 561|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 35| 803|} luaZ_init: 38| 561|void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) { 39| 561| z->L = L; 40| 561| z->reader = reader; 41| 561| z->data = data; 42| 561| z->n = 0; 43| 561| z->p = NULL; 44| 561|}