Datasets:
LLM4Binary
/
decompile-bench

Dataset card Data Studio Files
xet
 Community
1
name
string
code
string
asm
string
file
string
luaG_getfuncline
int luaG_getfuncline (const Proto *f, int pc) { if (f->lineinfo == NULL) /* no debug information? */ return -1; else { int basepc; int baseline = getbaseline(f, pc, &basepc); while (basepc++ < pc) { /* walk until given instruction */ lua_assert(f->lineinfo[basepc] != ABSLINEINFO); base...
movq 0x58(%rdi), %rcx testq %rcx, %rcx je 0x9ec5 movslq 0x28(%rdi), %rdx testq %rdx, %rdx je 0x9eba movq 0x60(%rdi), %rax cmpl %esi, (%rax) jle 0x9ecb addq $0x2c, %rdi movl $0xffffffff, %edx # imm = 0xFFFFFFFF jmp 0x9f0e movl $0xffffffff, %eax # imm = 0xFFFFFFFF retq leal 0x7f(%rsi), %edi testl %esi, %esi c...
/mmanyen[P]CLua/build_O1/_deps/lua/ldebug.c
lua_sethook
LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) { if (func == NULL || mask == 0) { /* turn off hooks? */ mask = 0; func = NULL; } L->hook = func; L->basehookcount = count; resethookcount(L); L->hookmask = cast_byte(mask); if (mask) settraps(L->ci); /* to trace ins...
xorl %eax, %eax testq %rsi, %rsi movl %edx, %r8d cmovel %eax, %r8d testl %edx, %edx cmovneq %rsi, %rax movq %rax, 0xa0(%rdi) movl %ecx, 0xbc(%rdi) movl %ecx, 0xc0(%rdi) movzbl %r8b, %eax movl %eax, 0xc4(%rdi) testl %r8d, %r8d je 0x9f7a movq 0x20(%rdi), %rax testq %rax, %rax je 0x9f7a testb $-0x80, 0x3d(%rax) jne 0x9f74...
/mmanyen[P]CLua/build_O1/_deps/lua/ldebug.c
lua_getstack
LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) { int status; CallInfo *ci; if (level < 0) return 0; /* invalid (negative) level */ lua_lock(L); for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous) level--; if (level == 0 && ci != &L->base_ci) { /* level found? */ ...
xorl %eax, %eax testl %esi, %esi js 0x9fed movq 0x20(%rdi), %rcx addq $0x60, %rdi testl %esi, %esi setne %r9b cmpq %rdi, %rcx setne %r8b andb %r8b, %r9b cmpb $0x1, %r9b jne 0x9fd2 movl %esi, %r9d leal -0x1(%r9), %esi movq 0x10(%rcx), %rcx cmpq %rdi, %rcx setne %r8b cmpl $0x2, %r9d jl 0x9fd2 cmpq %rdi, %rcx jne 0x9fb5 t...
/mmanyen[P]CLua/build_O1/_deps/lua/ldebug.c
lua_getlocal
LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) { const char *name; lua_lock(L); if (ar == NULL) { /* information about non-active function? */ if (!isLfunction(s2v(L->top.p - 1))) /* not a Lua function? */ name = NULL; else /* consider live variables at function start...
pushq %rbx subq $0x10, %rsp movq %rdi, %rbx testq %rsi, %rsi je 0xa130 leaq 0x8(%rsp), %rcx movq $0x0, (%rcx) movq 0x88(%rsi), %rsi movq %rbx, %rdi callq 0x9fee testq %rax, %rax je 0xa152 movq 0x10(%rbx), %rcx movq 0x8(%rsp), %rdx movq (%rdx), %rsi movq %rsi, (%rcx) movb 0x8(%rdx), %dl movb %dl, 0x8(%rcx) addq $0x10, 0...
/mmanyen[P]CLua/build_O1/_deps/lua/ldebug.c
luaD_throw
l_noret luaD_throw (lua_State *L, TStatus errcode) { if (L->errorJmp) { /* thread has an error handler? */ L->errorJmp->status = errcode; /* set status */ LUAI_THROW(L, L->errorJmp); /* jump to it */ } else { /* thread has no error handler */ global_State *g = G(L); lua_State *mainth = mainthr...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x58(%rdi), %rdi testq %rdi, %rdi jne 0xb263 movq 0x18(%rbx), %r14 movzbl %sil, %esi movq %rbx, %rdi callq 0x16962 movb %al, 0xb(%rbx) cmpq $0x0, 0x5e0(%r14) jne 0xb278 movq 0x100(%r14), %rax testq %rax, %rax je 0xb25e movq %rbx, %rdi callq *%rax callq 0x51e0 movb %...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
luaD_rawrunprotected
TStatus luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) { l_uint32 oldnCcalls = L->nCcalls; struct lua_longjmp lj; lj.status = LUA_OK; lj.previous = L->errorJmp; /* chain new error handler */ L->errorJmp = &lj; LUAI_TRY(L, &lj, f, ud); /* call 'f' catching errors */ L->errorJmp = lj.previous; /*...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0xd8, %rsp movq %rdx, %r15 movq %rsi, %r14 movq %rdi, %rbx movl 0xb0(%rdi), %ebp movq %rsp, %rax movb $0x0, 0xd0(%rax) movq 0x58(%rdi), %rcx movq %rcx, (%rax) movq %rax, 0x58(%rdi) leaq 0x8(%rsp), %rdi callq 0x5440 testl %eax, %eax jne 0xb2f2 movq %rbx, %rdi movq %r15, ...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
luaD_reallocstack
int luaD_reallocstack (lua_State *L, int newsize, int raiseerror) { int oldsize = stacksize(L); int i; StkId newstack; StkId oldstack = L->stack.p; lu_byte oldgcstop = G(L)->gcstopem; lua_assert(newsize <= MAXSTACK || newsize == ERRORSTACKSIZE); relstack(L); /* change pointers to offsets */ G(L)->gcsto...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %edx, 0x4(%rsp) movq %rdi, %rbx movq 0x18(%rdi), %rcx movq 0x28(%rdi), %r12 movq 0x30(%rdi), %rax movb 0x6d(%rcx), %r13b subq %rax, 0x10(%rdi) movl %esi, %ebp subq %rax, 0x40(%rdi) subq %rax, %r12 shrq $0x4, %r12 movq 0x38(%rdi), %rcx tes...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
correctstack
static void correctstack (lua_State *L, StkId oldstack) { CallInfo *ci; UpVal *up; UNUSED(oldstack); L->top.p = restorestack(L, L->top.offset); L->tbclist.p = restorestack(L, L->tbclist.offset); for (up = L->openupval; up != NULL; up = up->u.open.next) up->v.p = s2v(restorestack(L, up->v.offset)); for...
movq 0x30(%rdi), %rcx movq 0x38(%rdi), %rax addq %rcx, 0x10(%rdi) addq %rcx, 0x40(%rdi) testq %rax, %rax je 0xb484 movq 0x30(%rdi), %rcx addq %rcx, 0x10(%rax) movq 0x18(%rax), %rax jmp 0xb471 movq 0x20(%rdi), %rax testq %rax, %rax je 0xb4af movq 0x30(%rdi), %rcx addq %rcx, 0x8(%rax) movq 0x30(%rdi), %rcx addq %rcx, (%r...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
luaD_growstack
int luaD_growstack (lua_State *L, int n, int raiseerror) { int size = stacksize(L); if (l_unlikely(size > MAXSTACK)) { /* if stack is larger than maximum, thread is already using the extra space reserved for errors, that is, thread is handling a stack error; cannot grow further than that. */ l...
pushq %rbp pushq %r14 pushq %rbx movl %edx, %ebp movq %rdi, %rbx movq 0x28(%rdi), %rax movq 0x30(%rdi), %rcx subq %rcx, %rax shrq $0x4, %rax cmpl $0xf4241, %eax # imm = 0xF4241 jge 0xb532 cmpl $0xf423f, %esi # imm = 0xF423F jg 0xb518 movq 0x10(%rbx), %r14 subq %rcx, %r14 shrq $0x4, %r14 addl %esi, %r1...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
luaD_hook
void luaD_hook (lua_State *L, int event, int line, int ftransfer, int ntransfer) { lua_Hook hook = L->hook; if (hook && L->allowhook) { /* make sure there is a hook */ CallInfo *ci = L->ci; ptrdiff_t top = savestack(L, L->top.p); /* preserve original 'top' */ ptrdiff_t ci...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x98, %rsp movq 0xa0(%rdi), %r14 testq %r14, %r14 je 0xb6bd movq %rdi, %rbx cmpb $0x0, 0xa(%rdi) je 0xb6bd movq 0x10(%rbx), %r12 movq 0x20(%rbx), %r15 movq 0x30(%rbx), %rbp movq 0x8(%r15), %r13 movl %esi, 0x8(%rsp) movl %edx, 0x38(%rsp) movq %r15, ...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
luaD_poscall
void luaD_poscall (lua_State *L, CallInfo *ci, int nres) { l_uint32 fwanted = ci->callstatus & (CIST_TBC | CIST_NRESULTS); if (l_unlikely(L->hookmask) && !(fwanted & CIST_TBC)) rethook(L, ci, nres); /* move results to proper place */ moveresults(L, ci->func.p, nres, fwanted); /* function cannot be in any ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %edx, %ebp movq %rsi, %r14 movq %rdi, %rbx movl 0x3c(%rsi), %r13d cmpl $0x0, 0xc4(%rdi) jne 0xb905 movq (%r14), %r15 movl %r13d, %eax andl $0x400ff, %eax # imm = 0x400FF je 0xb84f cmpl $0x2, %eax je 0xb82b cmpl $0x1, %eax je 0xb8...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
rethook
static void rethook (lua_State *L, CallInfo *ci, int nres) { if (L->hookmask & LUA_MASKRET) { /* is return hook on? */ StkId firstres = L->top.p - nres; /* index of first result */ int delta = 0; /* correction for vararg functions */ int ftransfer; if (isLua(ci)) { Proto *p = ci_func(ci)->p; ...
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %rbx testl $0x2, 0xc4(%rdi) je 0xb99e movl %edx, %r8d movq 0x10(%rbx), %rcx movslq %edx, %rax shlq $0x4, %rax subq %rax, %rcx testb $-0x80, 0x3d(%r14) jne 0xb961 movq (%r14), %rax movq (%rax), %rax movq 0x18(%rax), %rax testb $0x1, 0xb(%rax) jne 0xb966 xorl %r...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
luaD_pretailcall
int luaD_pretailcall (lua_State *L, CallInfo *ci, StkId func, int narg1, int delta) { unsigned status = LUA_MULTRET + 1; retry: switch (ttypetag(s2v(func))) { case LUA_VCCL: /* C closure */ return precallC(L, func, status, clCvalue(s2v(func))->f); case LUA_VLCF: ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %r8d, (%rsp) movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %rbx movslq %ecx, %r12 movq %r12, %r13 shlq $0x4, %r13 orq $0x8, %r13 xorl %ebp, %ebp movzbl 0x8(%r14), %eax andl $0x3f, %eax cmpl $0x6, %eax je 0xba58 cmpl $0x16, %eax je 0xbb...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
tryfuncTM
static unsigned tryfuncTM (lua_State *L, StkId func, unsigned status) { const TValue *tm; StkId p; tm = luaT_gettmbyobj(L, s2v(func), TM_CALL); if (l_unlikely(ttisnil(tm))) /* no metamethod? */ luaG_callerror(L, s2v(func)); for (p = L->top.p; p > func; p--) /* open space for metamethod */ setobjs2s(...
pushq %rbp pushq %r14 pushq %rbx movl %edx, %ebp movq %rsi, %r14 movq %rdi, %rbx movl $0x17, %edx callq 0x1cb50 testb $0xf, 0x8(%rax) je 0xbd02 movq 0x10(%rbx), %rcx cmpq %r14, %rcx jbe 0xbcd8 movq -0x10(%rcx), %rdx movq %rdx, (%rcx) movb -0x8(%rcx), %dl movb %dl, 0x8(%rcx) leaq -0x10(%rcx), %rdx movq %rdx, %rcx cmpq %...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
luaD_precall
CallInfo *luaD_precall (lua_State *L, StkId func, int nresults) { unsigned status = cast_uint(nresults + 1); lua_assert(status <= MAXRESULTS + 1); retry: switch (ttypetag(s2v(func))) { case LUA_VCCL: /* C closure */ precallC(L, func, status, clCvalue(s2v(func))->f); return NULL; case LUA_VLC...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %edx, %ebp movq %rsi, %r14 movq %rdi, %rbx incl %ebp movzbl 0x8(%r14), %eax andl $0x3f, %eax cmpl $0x6, %eax je 0xbd8d cmpl $0x16, %eax je 0xbe2e cmpl $0x26, %eax je 0xbe25 movq 0x28(%rbx), %rax subq 0x10(%rbx), %rax cmpq $0x10, %rax jle ...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
luaD_callnoyield
void luaD_callnoyield (lua_State *L, StkId func, int nResults) { ccall(L, func, nResults, nyci); }
pushq %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movl %edx, %ebp movq %rdi, %rbx movl $0x10001, %eax # imm = 0x10001 addl 0xb0(%rdi), %eax movl %eax, 0xb0(%rdi) andl $0xfff8, %eax # imm = 0xFFF8 cmpl $0xc8, %eax jae 0xbfd8 movq %rbx, %rdi movl %ebp, %edx callq 0xbd1e testq %rax, %rax je 0xbfc5 orb $...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
lua_resume
LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs, int *nresults) { TStatus status; lua_lock(L); if (L->status == LUA_OK) { /* may be starting a coroutine */ if (L->ci != &L->base_ci) /* not in base level? */ return resume_error(L, "cannot resume no...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rcx, %r14 movq %rdi, %rbx movl %edx, 0xc(%rsp) movzbl 0xb(%rdi), %eax cmpl $0x1, %eax je 0xc098 testl %eax, %eax jne 0xc03c movq 0x10(%rbx), %r15 movq 0x20(%rbx), %rax leaq 0x60(%rbx), %rcx cmpq %rcx, %rax je 0xc05a movslq %edx, %rax shlq $0x...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
resume
static void resume (lua_State *L, void *ud) { int n = *(cast(int*, ud)); /* number of arguments */ StkId firstArg = L->top.p - n; /* first argument */ CallInfo *ci = L->ci; if (L->status == LUA_OK) /* starting a coroutine? */ ccall(L, firstArg - 1, LUA_MULTRET, 0); /* just call its body */ else { /* ...
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx movslq (%rsi), %rdx movq 0x10(%rdi), %rax movq %rdx, %rcx shlq $0x4, %rcx movq %rax, %r14 subq %rcx, %r14 cmpb $0x0, 0xb(%rdi) je 0xc200 movq 0x20(%rbx), %r15 movb $0x0, 0xb(%rbx) testb $-0x80, 0x3d(%r15) movq 0x20(%r15), %rax jne 0xc240 addq $-0x4, %rax movq %rax, 0x20(...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
lua_yieldk
LUA_API int lua_yieldk (lua_State *L, int nresults, lua_KContext ctx, lua_KFunction k) { CallInfo *ci; luai_userstateyield(L, nresults); lua_lock(L); ci = L->ci; api_checkpop(L, nresults); if (l_unlikely(!yieldable(L))) { if (L != mainthread(G(L))) luaG_runerror(L, "attempt...
pushq %rax cmpl $0x10000, 0xb0(%rdi) # imm = 0x10000 jae 0xc2d5 movq 0x20(%rdi), %rax movb $0x1, 0xb(%rdi) movl %esi, 0x38(%rax) testb $-0x80, 0x3d(%rax) jne 0xc2da xorl %eax, %eax popq %rcx retq callq 0x5893 movq %rcx, 0x20(%rax) testq %rcx, %rcx je 0xc2e7 movq %rdx, 0x30(%rax) movl $0x1, %esi callq 0xb220
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
luaD_closeprotected
TStatus luaD_closeprotected (lua_State *L, ptrdiff_t level, TStatus status) { CallInfo *old_ci = L->ci; lu_byte old_allowhooks = L->allowhook; for (;;) { /* keep closing upvalues until no more errors */ struct CloseP pcl; pcl.level = restorestack(L, level); pcl.status = status; status = luaD_rawrunpr...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %edx, %eax movq %rsi, %rbx movq %rdi, %r14 movq 0x20(%rdi), %rcx movq %rcx, (%rsp) movb 0xa(%rdi), %r13b leaq 0x51(%rip), %r15 # 0xc36b leaq 0x8(%rsp), %r12 movq 0x30(%r14), %rcx addq %rbx, %rcx movq %rcx, 0x8(%rsp) movb %al,...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
luaD_pcall
TStatus luaD_pcall (lua_State *L, Pfunc func, void *u, ptrdiff_t old_top, ptrdiff_t ef) { TStatus status; CallInfo *old_ci = L->ci; lu_byte old_allowhooks = L->allowhook; ptrdiff_t old_errfunc = L->errfunc; L->errfunc = ef; status = luaD_rawrunprotected(L, func, u); if (l...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rcx, %r14 movq %rdi, %rbx movq 0x20(%rdi), %r12 movb 0xa(%rdi), %r13b movq 0xa8(%rdi), %r15 movq %r8, 0xa8(%rdi) callq 0xb2aa movl %eax, %ebp testb %al, %al jne 0xc3c6 movq %r15, 0xa8(%rbx) movl %ebp, %eax addq $0x8, %rsp popq %rbx popq ...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
luaD_protectedparser
TStatus luaD_protectedparser (lua_State *L, ZIO *z, const char *name, const char *mode) { struct SParser p; TStatus status; incnny(L); /* cannot yield during parsing */ p.z = z; p.name = name; p.mode = mode; p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0; p.dyd.g...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x68, %rsp movq %rdi, %rbx addl $0x10000, 0xb0(%rdi) # imm = 0x10000 leaq 0x8(%rsp), %r14 movq %rsi, (%r14) movq %rdx, 0x58(%r14) movq %rcx, 0x50(%r14) xorl %r15d, %r15d movl %r15d, 0x2c(%r14) movq %r15, 0x30(%r14) movl %r15d, 0x3c(%r14) movq %r15, 0x40(%r14) movl %r...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
f_parser
static void f_parser (lua_State *L, void *ud) { LClosure *cl; struct SParser *p = cast(struct SParser *, ud); const char *mode = p->mode ? p->mode : "bt"; int c = zgetc(p->z); /* read first character */ if (c == LUA_SIGNATURE[0]) { int fixed = 0; if (strchr(mode, 'B') != NULL) fixed = 1; el...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx movq 0x50(%rsi), %rax testq %rax, %rax leaq 0x1d632(%rip), %r15 # 0x29b50 cmovneq %rax, %r15 movq (%rsi), %rdi subq $0x1, (%rdi) jae 0xc534 callq 0x22428 movl %eax, %ebp jmp 0xc543 movq 0x8(%rdi), %rax leaq 0x1(%rax), %rcx movq %...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
unroll
static void unroll (lua_State *L, void *ud) { CallInfo *ci; UNUSED(ud); while ((ci = L->ci) != &L->base_ci) { /* something in the stack */ if (!isLua(ci)) /* C function? */ finishCcall(L, ci); /* complete its execution */ else { /* Lua function */ luaV_finishOp(L); /* finish interrupted i...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax leaq 0x60(%rdi), %r15 movq 0x20(%rdi), %r14 cmpq %r15, %r14 je 0xc6e3 movq %rdi, %rbx movl 0x3c(%r14), %eax testw %ax, %ax js 0xc602 movq %rbx, %rdi callq 0x1ea24 movq %rbx, %rdi movq %r14, %rsi callq 0x1eb29 jmp 0xc65f btl $0x11, %eax jb 0xc6...
/mmanyen[P]CLua/build_O1/_deps/lua/ldo.c
luaU_dump
int luaU_dump (lua_State *L, const Proto *f, lua_Writer w, void *data, int strip) { DumpState D; D.h = luaH_new(L); /* aux. table to keep strings already dumped */ sethvalue2s(L, L->top.p, D.h); /* anchor it */ L->top.p++; D.L = L; D.writer = w; D.offset = 0; D.data = data; D.strip = ...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x50, %rsp movl %r8d, %ebp movq %rcx, %r14 movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r12 callq 0x1ad47 movq %rax, 0x40(%rsp) movq 0x10(%r12), %rcx movq %rax, (%rcx) movb $0x45, 0x8(%rcx) addq $0x10, 0x10(%r12) movq %r12, 0x18(%rsp) movq %r15, 0x20(%rsp) xor...
/mmanyen[P]CLua/build_O1/_deps/lua/ldump.c
dumpFunction
static void dumpFunction (DumpState *D, const Proto *f) { dumpInt(D, f->linedefined); dumpInt(D, f->lastlinedefined); dumpByte(D, f->numparams); dumpByte(D, f->flag); dumpByte(D, f->maxstacksize); dumpCode(D, f); dumpConstants(D, f); dumpUpvalues(D, f); dumpProtos(D, f); dumpString(D, D->strip ? NUL...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movslq 0x2c(%rsi), %rsi callq 0xcef2 movslq 0x30(%rbx), %rsi movq %r14, %rdi callq 0xcef2 movb 0xa(%rbx), %al movb %al, (%rsp) cmpl $0x0, 0x24(%r14) jne 0xca76 movq (%r14), %rdi movq 0x10(%r14), %rcx movq %rsp, ...
/mmanyen[P]CLua/build_O1/_deps/lua/ldump.c
dumpString
static void dumpString (DumpState *D, TString *ts) { if (ts == NULL) dumpSize(D, 0); else { TValue idx; int tag = luaH_getstr(D->h, ts, &idx); if (!tagisempty(tag)) { /* string already saved? */ dumpSize(D, 1); /* reuse a saved string */ dumpSize(D, cast_sizet(ivalue(&idx))); /* index...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rdi, %rbx testq %rsi, %rsi je 0xce58 movq %rsi, %r14 movq 0x28(%rbx), %rdi leaq 0x8(%rsp), %rdx callq 0x1af59 testb $0xf, %al je 0xce6d movl $0x1, %esi movq %rbx, %rdi callq 0xcef2 movq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0xcef2 jmp 0xcee6 movq %rbx, ...
/mmanyen[P]CLua/build_O1/_deps/lua/ldump.c
dumpVarint
static void dumpVarint (DumpState *D, size_t x) { lu_byte buff[DIBS]; unsigned n = 1; buff[DIBS - 1] = x & 0x7f; /* fill least-significant byte */ while ((x >>= 7) != 0) /* fill other bytes in reverse order */ buff[DIBS - (++n)] = cast_byte((x & 0x7f) | 0x80); dumpVector(D, buff + DIBS - n, n); }
pushq %r14 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx movl %esi, %eax andb $0x7f, %al movb %al, 0x17(%rsp) movl $0x1, %r14d cmpq $0x80, %rsi jb 0xcf40 movq $-0x1, %r14 movq %rsi, %rax shrq $0x7, %rax movl %eax, %ecx orb $-0x80, %cl leal 0x9(%r14), %edx movb %cl, 0xe(%rsp,%rdx) decq %r14 cmpq $0x3fff, %rsi # ...
/mmanyen[P]CLua/build_O1/_deps/lua/ldump.c
dumpAlign
static void dumpAlign (DumpState *D, unsigned align) { unsigned padding = align - cast_uint(D->offset % align); if (padding < align) { /* padding == align means no padding */ static lua_Integer paddingContent = 0; lua_assert(align <= sizeof(lua_Integer)); dumpBlock(D, &paddingContent, padding); } l...
movl 0x18(%rdi), %eax andl $0x3, %eax je 0xcfae pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx cmpl $0x0, 0x24(%rdi) jne 0xcfa7 movl $0x4, %r14d subl %eax, %r14d movq (%rbx), %rdi movq 0x10(%rbx), %rcx leaq 0x2d3be(%rip), %rsi # 0x3a358 movq %r14, %rdx callq *0x8(%rbx) movl %eax, 0x24(%rbx) addq %r14, 0x18(%rbx) ...
/mmanyen[P]CLua/build_O1/_deps/lua/ldump.c
luaF_newLclosure
LClosure *luaF_newLclosure (lua_State *L, int nupvals) { GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals)); LClosure *c = gco2lcl(o); c->p = NULL; c->nupvalues = cast_byte(nupvals); while (nupvals--) c->upvals[nupvals] = NULL; return c; }
pushq %r15 pushq %r14 pushq %rbx movl %esi, %r15d movl %esi, %ebx leaq 0x20(,%rbx,8), %rdx movl $0x6, %esi callq 0xd734 movq %rax, %r14 movq $0x0, 0x18(%rax) movb %r15b, 0xa(%rax) testl %r15d, %r15d je 0xd023 decl %r15d movslq %r15d, %rax shlq $0x3, %rax shlq $0x3, %r15 subq %r15, %rax leaq (%rax,%r14), %rdi addq $0x20...
/mmanyen[P]CLua/build_O1/_deps/lua/lfunc.c
luaF_initupvals
void luaF_initupvals (lua_State *L, LClosure *cl) { int i; for (i = 0; i < cl->nupvalues; i++) { GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal)); UpVal *uv = gco2upv(o); uv->v.p = &uv->u.value; /* make it closed */ setnilvalue(uv->v.p); cl->upvals[i] = uv; luaC_objbarrier(L, cl, uv)...
cmpb $0x0, 0xa(%rsi) je 0xd08e pushq %r15 pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 xorl %r15d, %r15d movl $0x28, %edx movq %r14, %rdi movl $0x9, %esi callq 0xd734 leaq 0x18(%rax), %rcx movq %rcx, 0x10(%rax) movb $0x0, 0x20(%rax) movq %rax, 0x20(%rbx,%r15,8) testb $0x20, 0x9(%rbx) je 0xd07d testb $0x18, 0x9...
/mmanyen[P]CLua/build_O1/_deps/lua/lfunc.c
luaF_findupval
UpVal *luaF_findupval (lua_State *L, StkId level) { UpVal **pp = &L->openupval; UpVal *p; lua_assert(isintwups(L) || L->openupval == NULL); while ((p = *pp) != NULL && uplevel(p) >= level) { /* search for it */ lua_assert(!isdead(G(L), p)); if (uplevel(p) == level) /* corresponding upvalue? */ r...
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %rbx leaq 0x38(%rdi), %r15 movq 0x38(%rdi), %rcx testq %rcx, %rcx je 0xd0d1 movq 0x10(%rcx), %rdx cmpq %r14, %rdx jb 0xd0d1 movq %rcx, %rax cmpq %r14, %rdx je 0xd121 movq 0x18(%rax), %rcx testq %rcx, %rcx je 0xd0ca movq 0x10(%rcx), %rdx cmpq %r14, %rdx jae 0xd...
/mmanyen[P]CLua/build_O1/_deps/lua/lfunc.c
luaF_newtbcupval
void luaF_newtbcupval (lua_State *L, StkId level) { lua_assert(level > L->tbclist.p); if (l_isfalse(s2v(level))) return; /* false doesn't need to be closed */ checkclosemth(L, level); /* value must have a close method */ while (cast_uint(level - L->tbclist.p) > MAXDELTA) { L->tbclist.p += MAXDELTA; /...
pushq %r14 pushq %rbx pushq %rax movb 0x8(%rsi), %al cmpb $0x1, %al sete %cl testb $0xf, %al sete %al orb %cl, %al jne 0xd18d movq %rsi, %r14 movq %rdi, %rbx movl $0x18, %edx callq 0x1cb50 testb $0xf, 0x8(%rax) je 0xd195 movabsq $0xffff00000, %rax # imm = 0xFFFF00000 movq 0x40(%rbx), %rcx movq %r14, %rdx subq %rcx...
/mmanyen[P]CLua/build_O1/_deps/lua/lfunc.c
luaF_closeupval
void luaF_closeupval (lua_State *L, StkId level) { UpVal *uv; StkId upl; /* stack index pointed by 'uv' */ while ((uv = L->openupval) != NULL && (upl = uplevel(uv)) >= level) { TValue *slot = &uv->u.value; /* new position for value */ lua_assert(uplevel(uv) < L->top.p); luaF_unlinkupval(uv); /* rem...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq 0x38(%rdi), %rsi testq %rsi, %rsi je 0xd264 movq %rdi, %r14 cmpq %rbx, 0x10(%rsi) jb 0xd264 movq 0x18(%rsi), %rax movq 0x20(%rsi), %rcx movq %rax, (%rcx) movq 0x18(%rsi), %rax testq %rax, %rax je 0xd21e movq 0x20(%rsi), %rcx movq %rcx, 0x20(%rax) leaq 0x18(%rsi), %r...
/mmanyen[P]CLua/build_O1/_deps/lua/lfunc.c
luaF_close
StkId luaF_close (lua_State *L, StkId level, TStatus status, int yy) { ptrdiff_t levelrel = savestack(L, level); luaF_closeupval(L, level); /* first, close the upvalues */ while (L->tbclist.p >= level) { /* traverse tbc's down to that level */ StkId tbc = L->tbclist.p; /* get variable index */ poptbcli...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %ecx, 0x4(%rsp) movl %edx, (%rsp) movq %rsi, %rbx movq %rdi, %r14 movq %rsi, %rbp subq 0x30(%rdi), %rbp callq 0xd1e9 movq 0x40(%r14), %r12 cmpq %rbx, %r12 jb 0xd383 movzbl (%rsp), %r15d movzwl 0xa(%r12), %ecx shll $0x4, %ecx movq %r12, %r...
/mmanyen[P]CLua/build_O1/_deps/lua/lfunc.c
reallymarkobject
static void reallymarkobject (global_State *g, GCObject *o) { g->GCmarked += objsize(o); switch (o->tt) { case LUA_VSHRSTR: case LUA_VLNGSTR: { set2black(o); /* nothing to visit */ break; } case LUA_VUPVAL: { UpVal *uv = gco2upv(o); if (upisopen(uv)) set2gray(uv); /...
pushq %rbp pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 movq %rbx, %rdi callq 0xe110 addq %rax, 0x20(%r14) movzbl 0x8(%rbx), %eax cmpl $0x9, %eax jne 0xd5a7 movq 0x10(%rbx), %rax leaq 0x18(%rbx), %rcx movb 0x9(%rbx), %dl andb $-0x39, %dl leal 0x20(%rdx), %esi cmpq %rcx, %rax movzbl %dl, %ecx movzbl %sil, %edx ...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
getgclist
static GCObject **getgclist (GCObject *o) { switch (o->tt) { case LUA_VTABLE: return &gco2t(o)->gclist; case LUA_VLCL: return &gco2lcl(o)->gclist; case LUA_VCCL: return &gco2ccl(o)->gclist; case LUA_VTHREAD: return &gco2th(o)->gclist; case LUA_VPROTO: return &gco2p(o)->gclist; case LUA_VUSERDA...
movzbl 0x8(%rdi), %ecx xorl %eax, %eax leal -0x5(%rcx), %edx cmpl $0x5, %edx ja 0xd6a8 leaq 0x1c523(%rip), %rcx # 0x29bbc movslq (%rcx,%rdx,4), %rdx addq %rcx, %rdx jmpq *%rdx addq $0x28, %rdi jmp 0xd6c3 cmpl $0x26, %ecx jne 0xd6c6 addq $0x10, %rdi jmp 0xd6c3 addq $0x78, %rdi jmp 0xd6c3 addq $0x20, %rdi jmp 0xd6c3 ...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
luaC_fix
void luaC_fix (lua_State *L, GCObject *o) { global_State *g = G(L); lua_assert(g->allgc == o); /* object must be 1st in 'allgc' list! */ set2gray(o); /* they will be gray forever */ setage(o, G_OLD); /* and old forever */ g->allgc = o->next; /* remove object from 'allgc' list */ o->next = g->fixedgc; /...
movq 0x18(%rdi), %rax movb 0x9(%rsi), %cl andb $-0x40, %cl orb $0x4, %cl movb %cl, 0x9(%rsi) movq (%rsi), %rcx movq %rcx, 0x70(%rax) movq 0xb8(%rax), %rcx movq %rcx, (%rsi) movq %rsi, 0xb8(%rax) retq
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
luaC_newobj
GCObject *luaC_newobj (lua_State *L, lu_byte tt, size_t sz) { return luaC_newobjdt(L, tt, sz, 0); }
pushq %r14 pushq %rbx pushq %rax movl %esi, %ebx movq 0x18(%rdi), %r14 movl %esi, %eax andl $0xf, %eax movq %rdx, %rsi movl %eax, %edx callq 0x11387 movb 0x6a(%r14), %cl andb $0x18, %cl movb %cl, 0x9(%rax) movb %bl, 0x8(%rax) movq 0x70(%r14), %rcx movq %rcx, (%rax) movq %rax, 0x70(%r14) addq $0x8, %rsp popq %rbx popq %...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
luaC_checkfinalizer
void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) { global_State *g = G(L); if (tofinalize(o) || /* obj. is already marked... */ gfasttm(g, mt, TM_GC) == NULL || /* or has no finalizer... */ (g->gcstp & GCSTPCLS)) /* or closing state? */ return; /*...
testq %rdx, %rdx je 0xd88b pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movb 0x9(%rsi), %al andb $0x40, %al jne 0xd880 testb $0x4, 0xa(%rdx) jne 0xd880 movq %rdi, %r14 movq 0x18(%rdi), %r15 movq 0x120(%r15), %rax movq %rdx, %rdi movl $0x2, %esi movq %rax, %rdx callq 0x1cb25 testq %rax, %rax je...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
luaC_changemode
void luaC_changemode (lua_State *L, int newmode) { global_State *g = G(L); if (g->gckind == KGC_GENMAJOR) /* doing major collections? */ g->gckind = KGC_INC; /* already incremental but in name */ if (newmode != g->gckind) { /* does it need to change? */ if (newmode == KGC_INC) /* entering incremental ...
movl %esi, %eax movq 0x18(%rdi), %rsi cmpb $0x2, 0x6c(%rsi) jne 0xd89c movb $0x0, 0x6c(%rsi) movzbl 0x6c(%rsi), %ecx cmpl %eax, %ecx jne 0xd8a5 retq testl %eax, %eax je 0xd8ae jmp 0xd939 xorl %edx, %edx jmp 0xd8b2
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
minor2inc
static void minor2inc (lua_State *L, global_State *g, lu_byte kind) { g->GCmajorminor = g->GCmarked; /* number of live bytes */ g->gckind = kind; g->reallyold = g->old1 = g->survival = NULL; g->finobjrold = g->finobjold1 = g->finobjsur = NULL; entersweep(L); /* continue as an incremental cycle */ /* set a...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq 0x20(%rsi), %rax movq %rax, 0x28(%rsi) movb %dl, 0x6c(%rsi) xorps %xmm0, %xmm0 movups %xmm0, 0xc0(%rsi) xorl %eax, %eax movq %rax, 0xd0(%rsi) movups %xmm0, 0xe0(%rsi) movq %rax, 0xf0(%rsi) movq 0x18(%rdi), %r15 movb $0x3, 0x6b(%...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
entergen
static void entergen (lua_State *L, global_State *g) { luaC_runtilstate(L, GCSpause, 1); /* prepare to start a new cycle */ luaC_runtilstate(L, GCSpropagate, 1); /* start new cycle */ atomic(L); /* propagates all and then do the atomic stuff */ atomic2gen(L, g); setminordebt(g); /* set debt assuming next ...
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 movq 0x18(%rdi), %r15 cmpb $0x8, 0x6b(%r15) je 0xd95e movq %r14, %rdi movl $0x1, %esi callq 0xdaf6 jmp 0xd948 movq 0x18(%r14), %r15 cmpb $0x0, 0x6b(%r15) je 0xd978 movq %r14, %rdi movl $0x1, %esi callq 0xdaf6 jmp 0xd962 movq %r14, %rdi callq 0xe324 movq %...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
separatetobefnz
static void separatetobefnz (global_State *g, int all) { GCObject *curr; GCObject **p = &g->finobj; GCObject **lastnext = findlast(&g->tobefnz); while ((curr = *p) != g->finobjold1) { /* traverse all finalizable objects */ lua_assert(tofinalize(curr)); if (!(iswhite(curr) || all)) /* not being collect...
leaq 0xb0(%rdi), %rcx movq %rcx, %rax movq (%rcx), %rcx testq %rcx, %rcx jne 0xda56 movq 0x80(%rdi), %rdx cmpq 0xe8(%rdi), %rdx je 0xdabc leaq 0x80(%rdi), %rcx testl %esi, %esi jne 0xda8b movb 0x9(%rdx), %r8b andb $0x18, %r8b jne 0xda8b movq %rdx, %rcx jmp 0xdab0 cmpq 0xe0(%rdi), %rdx jne 0xda9e movq (%rdx), %r8 movq %...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
singlestep
static l_mem singlestep (lua_State *L, int fast) { global_State *g = G(L); l_mem stepresult; lua_assert(!g->gcstopem); /* collector is not reentrant */ g->gcstopem = 1; /* no emergency collections while collecting */ switch (g->gcstate) { case GCSpause: { restartcollection(g); g->gcstate = G...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq 0x18(%rdi), %rbx movb $0x1, 0x6d(%rbx) movzbl 0x6b(%rbx), %ecx xorl %eax, %eax cmpq $0x8, %rcx ja 0xdcc6 movq %rdi, %r14 leaq 0x1c0b4(%rip), %rdx # 0x29bd4 movslq (%rdx,%rcx,4), %rcx addq %rdx, %rcx jmpq *%rcx testl %esi, %esi je 0xdd0c movb $0x1, 0x6b(%rb...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
luaC_step
void luaC_step (lua_State *L) { global_State *g = G(L); lua_assert(!g->gcemergency); if (!gcrunning(g)) { /* not running? */ if (g->gcstp & GCSTPUSR) /* stopped by the user? */ luaE_setdebt(g, 20000); } else { luai_tracegc(L, 1); /* for internal debugging */ switch (g->gckind) { cas...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq 0x18(%rdi), %rbx movb 0x6e(%rbx), %al testb %al, %al je 0xdd6d testb $0x1, %al je 0xde1c movl $0x4e20, %esi # imm = 0x4E20 movq %rbx, %rdi jmp 0xdff8 movq %rdi, %r14 movzbl 0x6c(%rbx), %eax cmpl $0x2, %eax je 0xdd8a cmpl $...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
luaC_fullgc
void luaC_fullgc (lua_State *L, int isemergency) { global_State *g = G(L); lua_assert(!g->gcemergency); g->gcemergency = cast_byte(isemergency); /* set flag */ switch (g->gckind) { case KGC_GENMINOR: fullgen(L, g); break; case KGC_INC: fullinc(L, g); break; case KGC_GENMAJOR: g->gckind = KGC_...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 movq 0x18(%rdi), %rbx movb %sil, 0x6f(%rbx) movzbl 0x6c(%rbx), %eax testl %eax, %eax je 0xe05b cmpl $0x2, %eax je 0xe046 cmpl $0x1, %eax jne 0xe066 movq %r14, %rdi movq %rbx, %rsi xorl %edx, %edx callq 0xd8b2 movq %r14, %rdi movq %rbx, %rsi callq 0xd939 jmp 0xe066 movb $...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
fullinc
static void fullinc (lua_State *L, global_State *g) { if (keepinvariant(g)) /* black objects? */ entersweep(L); /* sweep everything to turn them back to white */ /* finish any pending sweep phase to start a new cycle */ luaC_runtilstate(L, GCSpause, 1); luaC_runtilstate(L, GCScallfin, 1); /* run up to fin...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 cmpb $0x2, 0x6b(%rsi) ja 0xe0af movq 0x18(%r14), %r15 movb $0x3, 0x6b(%r15) leaq 0x70(%r15), %r12 movq %r12, %rax movl $0x1, %edx movq %r14, %rdi movq %rax, %rsi callq 0xe19a cmpq %r12, %rax je 0xe096 movq %rax, 0x78(%r15) movq 0x18(...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
objsize
static l_mem objsize (GCObject *o) { lu_mem res; switch (o->tt) { case LUA_VTABLE: { res = luaH_size(gco2t(o)); break; } case LUA_VLCL: { LClosure *cl = gco2lcl(o); res = sizeLclosure(cl->nupvalues); break; } case LUA_VCCL: { CClosure *cl = gco2ccl(o); r...
movzbl 0x8(%rdi), %ecx leal -0x4(%rcx), %eax cmpl $0x10, %eax ja 0xe137 leaq 0x1bad5(%rip), %rcx # 0x29bf8 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax movsbl 0xb(%rdi), %eax incl %eax addq $0x18, %rax retq cmpl $0x26, %ecx jne 0xe148 movzbl 0xa(%rdi), %eax shll $0x4, %eax addq $0x20, %rax retq xorl %eax, ...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
freeobj
static void freeobj (lua_State *L, GCObject *o) { assert_code(l_mem newmem = gettotalbytes(G(L)) - objsize(o)); switch (o->tt) { case LUA_VPROTO: luaF_freeproto(L, gco2p(o)); break; case LUA_VUPVAL: freeupval(L, gco2upv(o)); break; case LUA_VLCL: { LClosure *cl = gco2lcl(o)...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movzbl 0x8(%rsi), %ecx leal -0x4(%rcx), %eax cmpl $0x10, %eax ja 0xe24a leaq 0x1ba15(%rip), %rcx # 0x29c3c movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax movq %r14, %rdi movq %rbx, %rsi callq 0x171b1 movsbl 0xb(%rbx), %edx incl %edx addq $0x18,...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
atomic
static void atomic (lua_State *L) { global_State *g = G(L); GCObject *origweak, *origall; GCObject *grayagain = g->grayagain; /* save original list */ g->grayagain = NULL; lua_assert(g->ephemeron == NULL && g->weak == NULL); lua_assert(!iswhite(mainthread(g))); g->gcstate = GCSatomic; markobject(g, L);...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq 0x18(%rdi), %rbx movq 0x90(%rbx), %r14 movq $0x0, 0x90(%rbx) movb $0x2, 0x6b(%rbx) testb $0x18, 0x9(%rdi) je 0xe357 movq %rdi, %rsi movq %rbx, %rdi callq 0xd556 testb $0x40, 0x48(%rbx) je 0xe36f movq 0x40(%rbx), %rsi testb $0x18, 0x9(%rsi) je 0xe36f movq %rbx,...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
atomic2gen
static void atomic2gen (lua_State *L, global_State *g) { cleargraylists(g); /* sweep all elements making them old */ g->gcstate = GCSswpallgc; sweep2old(L, &g->allgc); /* everything alive now is old */ g->reallyold = g->old1 = g->survival = g->allgc; g->firstold1 = NULL; /* there are no OLD1 objects anyw...
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 xorps %xmm0, %xmm0 movups %xmm0, 0x98(%rsi) movups %xmm0, 0x88(%rsi) xorl %r15d, %r15d movq %r15, 0xa8(%rsi) movb $0x3, 0x6b(%rsi) addq $0x70, %rsi callq 0xef5f movq 0x70(%rbx), %rax movq %rax, 0xc0(%rbx) movq %rax, 0xc8(%rbx) movq %rax, 0xd0(%rbx) movq %...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
traverseephemeron
static int traverseephemeron (global_State *g, Table *h, int inv) { int hasclears = 0; /* true if table has white keys */ int hasww = 0; /* true if table has entry "white-key -> white-value" */ unsigned int i; unsigned int nsize = sizenode(h); int marked = traversearray(g, h); /* traverse array part */ /...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %edx, %r15d movq %rsi, %rbx movb 0xb(%rsi), %cl movl $0x1, %r12d shlq %cl, %r12 movq %rdi, 0x10(%rsp) callq 0xeef4 movl %eax, 0xc(%rsp) xorl %r13d, %r13d xorl %ebp, %ebp movl $0x0, 0x8(%rsp) testl %r15d, %r15d je 0xed8a leal -0x1(%r...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
genlink
static void genlink (global_State *g, GCObject *o) { lua_assert(isblack(o)); if (getage(o) == G_TOUCHED1) { /* touched in this cycle? */ linkobjgclist(o, g->grayagain); /* link it back in 'grayagain' */ } /* everything else do not need to be linked back */ else if (getage(o) == G_TOUCHED2) setage(o, ...
pushq %rbp pushq %r14 pushq %rbx movq %rsi, %rbx movzbl 0x9(%rsi), %ebp movl %ebp, %eax andl $0x7, %eax cmpl $0x6, %eax je 0xeee6 cmpl $0x5, %eax jne 0xeeef movq %rdi, %r14 movq %rbx, %rdi callq 0xd684 movq 0x90(%r14), %rcx movq %rcx, (%rax) movq %rbx, 0x90(%r14) movb $-0x39, %al jmp 0xeee8 movb $-0x4, %al andb %al, %b...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
traversearray
static int traversearray (global_State *g, Table *h) { unsigned asize = h->asize; int marked = 0; /* true if some object is marked in this traversal */ unsigned i; for (i = 0; i < asize; i++) { GCObject *o = gcvalarr(h, i); if (o != NULL && iswhite(o)) { marked = 1; reallymarkobject(g, o); ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movl 0xc(%rsi), %r15d testq %r15, %r15 je 0xef51 movq %rsi, %rbx movq %rdi, %r14 xorl %r12d, %r12d xorl %eax, %eax movq 0x10(%rbx), %rcx testb $0x40, 0x4(%rcx,%r12) jne 0xef20 xorl %esi, %esi jmp 0xef2f leaq (,%r12,8), %rdx subq %rdx, %rcx movq -0x8(%rcx), %rsi tes...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
sweep2old
static void sweep2old (lua_State *L, GCObject **p) { GCObject *curr; global_State *g = G(L); while ((curr = *p) != NULL) { if (iswhite(curr)) { /* is 'curr' dead? */ lua_assert(isdead(g, curr)); *p = curr->next; /* remove 'curr' from list */ freeobj(L, curr); /* erase 'curr' */ } ...
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq (%rsi), %rsi testq %rsi, %rsi je 0xefdc movq %rdi, %rbx movq 0x18(%rdi), %r15 movb 0x9(%rsi), %al testb $0x18, %al je 0xef90 movq (%rsi), %rax movq %rax, (%r14) movq %rbx, %rdi callq 0xe20a movq %r14, %rsi jmp 0xefd1 andb $-0x20, %al leal 0x4(%rax), %ecx movb %cl, 0...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
finishgencycle
static void finishgencycle (lua_State *L, global_State *g) { correctgraylists(g); checkSizes(L, g); g->gcstate = GCSpropagate; /* skip restart */ if (!g->gcemergency) callallpendingfinalizers(L); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %rbx leaq 0x90(%rsi), %rdi callq 0xf09e movq 0x98(%r14), %rcx movq %rcx, (%rax) xorl %r15d, %r15d movq %r15, 0x98(%r14) movq %rax, %rdi callq 0xf09e movq 0xa8(%r14), %rcx movq %rcx, (%rax) movq %r15, 0xa8(%r14) movq %rax, %rdi callq 0xf09e movq 0xa0(%r14), %rc...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
correctgraylist
static GCObject **correctgraylist (GCObject **p) { GCObject *curr; while ((curr = *p) != NULL) { GCObject **next = getgclist(curr); if (iswhite(curr)) goto remove; /* remove all white objects */ else if (getage(curr) == G_TOUCHED1) { /* touched in this cycle? */ lua_assert(isgray(curr)); ...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq (%rdi), %r14 testq %r14, %r14 je 0xf0ff movq %r14, %rdi callq 0xd684 movzbl 0x9(%r14), %ecx testb $0x18, %cl je 0xf0c7 movq (%rax), %rax movq %rax, (%rbx) jmp 0xf0e7 movl %ecx, %edx andl $0x7, %edx cmpl $0x5, %edx jne 0xf0dd andb $-0x28, %cl orb $0x26, %cl movb %cl,...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
GCTM
static void GCTM (lua_State *L) { global_State *g = G(L); const TValue *tm; TValue v; lua_assert(!g->gcemergency); setgcovalue(L, &v, udata2finalize(g)); tm = luaT_gettmbyobj(L, &v, TM_GC); if (!notm(tm)) { /* is there a finalizer? */ TStatus status; lu_byte oldah = L->allowhook; lu_byte oldg...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx movq 0x18(%rdi), %r14 movq 0x70(%r14), %rcx movq 0xb0(%r14), %rax movq (%rax), %rdx movq %rdx, 0xb0(%r14) movq %rcx, (%rax) movq %rax, 0x70(%r14) movb 0x9(%rax), %cl movl %ecx, %edx andb $-0x41, %dl movb %dl, 0x9(%rax) movb 0x6b(%r14), %dl add...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
markold
static void markold (global_State *g, GCObject *from, GCObject *to) { GCObject *p; for (p = from; p != to; p = p->next) { if (getage(p) == G_OLD1) { lua_assert(!iswhite(p)); setage(p, G_OLD); /* now they are old */ if (isblack(p)) reallymarkobject(g, p); } } }
cmpq %rdx, %rsi je 0xf2c4 pushq %r15 pushq %r14 pushq %rbx movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 movb 0x9(%r14), %al movl %eax, %ecx andb $0x7, %cl cmpb $0x3, %cl jne 0xf2b7 movl %eax, %ecx andb $-0x8, %cl orb $0x4, %cl movb %cl, 0x9(%r14) testb $0x20, %al je 0xf2b7 movq %r15, %rdi movq %r14, %rsi callq 0xd55...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
sweepgen
static GCObject **sweepgen (lua_State *L, global_State *g, GCObject **p, GCObject *limit, GCObject **pfirstold1, l_mem *paddedold) { static const lu_byte nextage[] = { G_SURVIVAL, /* from G_NEW */ G_OLD1, /* from G_SURVIVAL */ G_OLD1, /* f...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %r9, 0x8(%rsp) movq %r8, 0x10(%rsp) movq %rdx, %rbp movq (%rdx), %r13 cmpq %rcx, %r13 je 0xf366 movq %rcx, %r15 movq %rdi, %r12 movb 0x6a(%rsi), %r14b andb $0x18, %r14b xorl %ebx, %ebx movzbl 0x9(%r13), %eax testb $0x18, %al je 0xf3...
/mmanyen[P]CLua/build_O1/_deps/lua/lgc.c
luaL_openselectedlibs
LUALIB_API void luaL_openselectedlibs (lua_State *L, int load, int preload) { int mask; const luaL_Reg *lib; luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE); for (lib = stdlibs, mask = 1; lib->name != NULL; lib++, mask <<= 1) { if (load & mask) { /* selected? */ luaL_requiref(L, lib->name, ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %edx, %ebx movl %esi, %ebp movq %rdi, %r14 leaq 0x1a902(%rip), %rdx # 0x29c9f movl $0xfff0b9d8, %esi # imm = 0xFFF0B9D8 callq 0x99b7 movl $0x1, %r12d leaq 0x1a8f4(%rip), %r15 # 0x29ca8 leaq 0x298dd(%rip), %r13 # 0x38c98 ...
/mmanyen[P]CLua/build_O1/_deps/lua/linit.c
luaopen_io
LUAMOD_API int luaopen_io (lua_State *L) { luaL_newlib(L, iolib); /* new module */ createmeta(L); /* create (and set) default files */ createstdfile(L, stdin, IO_INPUT, "stdin"); createstdfile(L, stdout, IO_OUTPUT, "stdout"); createstdfile(L, stderr, NULL, "stderr"); return 1; }
pushq %rbx movq %rdi, %rbx movsd 0x19f18(%rip), %xmm0 # 0x29358 movl $0x88, %esi callq 0x9c8c movq %rbx, %rdi xorl %esi, %esi movl $0xb, %edx callq 0x7355 leaq 0x298e0(%rip), %rsi # 0x38d40 movq %rbx, %rdi xorl %edx, %edx callq 0x9919 leaq 0x1a88f(%rip), %rsi # 0x29d00 movq %rbx, %rdi callq 0x8bc3 leaq 0x299...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
createstdfile
static void createstdfile (lua_State *L, FILE *f, const char *k, const char *fname) { LStream *p = newprefile(L); p->f = f; p->closef = &io_noclose; if (k != NULL) { lua_pushvalue(L, -1); lua_setfield(L, LUA_REGISTRYINDEX, k); /* add file to registry */ } lua_setfield(L, ...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rcx, %rbx movq %rdx, %r15 movq %rsi, %r12 movq %rdi, %r14 movl $0x10, %esi xorl %edx, %edx callq 0x7f05 movq %rax, %r13 movq $0x0, 0x8(%rax) leaq 0x1a7a0(%rip), %rsi # 0x29d00 movq %r14, %rdi callq 0x8c47 movq %r12, (%r13) leaq 0x11ab(%rip), %rax # 0...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
io_lines
static int io_lines (lua_State *L) { int toclose; if (lua_isnone(L, 1)) lua_pushnil(L); /* at least one argument */ if (lua_isnil(L, 1)) { /* no file name? */ lua_getfield(L, LUA_REGISTRYINDEX, IO_INPUT); /* get default input */ lua_replace(L, 1); /* put it at index 1 */ tofile(L); /* check that ...
pushq %rbp pushq %r14 pushq %rbx movq %rdi, %rbx movl $0x1, %esi callq 0x68d4 cmpl $-0x1, %eax jne 0xf637 movq %rbx, %rdi callq 0x6d71 movl $0x1, %r14d movq %rbx, %rdi movl $0x1, %esi callq 0x68d4 movl %eax, %ebp testl %eax, %eax je 0xf692 movq %rbx, %rdi movl $0x1, %esi xorl %edx, %edx callq 0x8dfc leaq 0x1ae5d(%rip),...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
io_open
static int io_open (lua_State *L) { const char *filename = luaL_checkstring(L, 1); const char *mode = luaL_optstring(L, 2, "r"); LStream *p = newfile(L); const char *md = mode; /* to traverse/check mode */ luaL_argcheck(L, l_checkmode(md), 2, "invalid mode"); errno = 0; p->f = fopen(filename, mode); re...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx xorl %r13d, %r13d movl $0x1, %esi xorl %edx, %edx callq 0x8dfc movq %rax, %r14 leaq 0x1ad8f(%rip), %rdx # 0x2a4c3 movq %rbx, %rdi movl $0x2, %esi xorl %ecx, %ecx callq 0x8da3 movq %rax, %r15 movl $0x10, %esi movq %rbx, %rdi...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
io_tmpfile
static int io_tmpfile (lua_State *L) { LStream *p = newfile(L); errno = 0; p->f = tmpfile(); return (p->f == NULL) ? luaL_fileresult(L, 0, NULL) : 1; }
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx xorl %r15d, %r15d movl $0x10, %esi xorl %edx, %edx callq 0x7f05 movq %rax, %r14 movq %r15, 0x8(%rax) leaq 0x1a3a4(%rip), %rsi # 0x29d00 movq %rbx, %rdi callq 0x8c47 movq %r15, (%r14) leaq 0x2a2(%rip), %rax # 0xfc10 movq %rax, 0x8(%r14) callq 0x5060 movl $0x0, (...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
io_type
static int io_type (lua_State *L) { LStream *p; luaL_checkany(L, 1); p = (LStream *)luaL_testudata(L, 1, LUA_FILEHANDLE); if (p == NULL) luaL_pushfail(L); /* not a file */ else if (isclosed(p)) lua_pushliteral(L, "closed file"); else lua_pushliteral(L, "file"); return 1; }
pushq %rbx movq %rdi, %rbx movl $0x1, %esi callq 0x8e84 leaq 0x1a345(%rip), %rdx # 0x29d00 movq %rbx, %rdi movl $0x1, %esi callq 0x8c66 testq %rax, %rax je 0xf9dd cmpq $0x0, 0x8(%rax) je 0xf9e7 leaq 0x1a343(%rip), %rsi # 0x29d1e jmp 0xf9ee movq %rbx, %rdi callq 0x6d71 jmp 0xf9f6 leaq 0x1a329(%rip), %rsi # 0...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
getiofile
static FILE *getiofile (lua_State *L, const char *findex) { LStream *p; lua_getfield(L, LUA_REGISTRYINDEX, findex); p = (LStream *)lua_touserdata(L, -1); if (l_unlikely(isclosed(p))) luaL_error(L, "default %s file is closed", findex + IOPREF_LEN); return p->f; }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 movl $0xfff0b9d8, %esi # imm = 0xFFF0B9D8 movq %rbx, %rdx callq 0x71a1 movq %r14, %rdi movl $0xffffffff, %esi # imm = 0xFFFFFFFF callq 0x6cbc movq %rax, %r15 cmpq $0x0, 0x8(%rax) je 0xfb0d movq (%r15), %rax popq %rbx popq %r14 popq %r15 retq a...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
g_iofile
static int g_iofile (lua_State *L, const char *f, const char *mode) { if (!lua_isnoneornil(L, 1)) { const char *filename = lua_tostring(L, 1); if (filename) opencheck(L, filename, mode); else { tofile(L); /* check that it's a valid file handle */ lua_pushvalue(L, 1); } lua_setfi...
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r14 movl $0x1, %esi callq 0x68d4 testl %eax, %eax jle 0xfb89 movq %r14, %rdi movl $0x1, %esi xorl %edx, %edx callq 0x6bb8 movq %r14, %rdi testq %rax, %rax je 0xfb67 movq %rax, %rsi movq %r15, %rdx callq 0xfb9e jmp 0xfb79 callq 0xfa5f movq %r14...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
opencheck
static void opencheck (lua_State *L, const char *fname, const char *mode) { LStream *p = newfile(L); p->f = fopen(fname, mode); if (l_unlikely(p->f == NULL)) luaL_error(L, "cannot open file '%s' (%s)", fname, strerror(errno)); }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r14 xorl %r13d, %r13d movl $0x10, %esi xorl %edx, %edx callq 0x7f05 movq %rax, %r12 movq %r13, 0x8(%rax) leaq 0x1a133(%rip), %rsi # 0x29d00 movq %r14, %rdi callq 0x8c47 movq %r13, (%r12) leaq 0x30(%rip), %rax #...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
aux_lines
static void aux_lines (lua_State *L, int toclose) { int n = lua_gettop(L) - 1; /* number of arguments to read */ luaL_argcheck(L, n <= MAXARGLINE, MAXARGLINE + 2, "too many arguments"); lua_pushvalue(L, 1); /* file */ lua_pushinteger(L, n); /* number of arguments to read */ lua_pushboolean(L, toclose); /*...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movl %esi, %ebp movq %rdi, %rbx callq 0x663a movl %eax, %r14d cmpl $0xfc, %eax jge 0xfcca leal -0x1(%r14), %r15d movq %rbx, %rdi movl $0x1, %esi callq 0x68aa movslq %r15d, %rsi movq %rbx, %rdi callq 0x6d91 movq %rbx, %rdi movl %ebp, %esi callq 0x704c movq %rbx, %rd...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
read_line
static int read_line (lua_State *L, FILE *f, int chop) { luaL_Buffer b; int c; luaL_buffinit(L, &b); do { /* may need to read several chunks to get whole line */ char *buff = luaL_prepbuffer(&b); /* preallocate buffer space */ unsigned i = 0; l_lockfile(f); /* no memory errors can happen inside t...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x428, %rsp # imm = 0x428 movl %edx, %r14d movq %rsi, %r15 leaq 0x8(%rsp), %r12 movq %rdi, (%rsp) movq %r12, %rsi callq 0x8517 movl $0x400, %esi # imm = 0x400 movq %r12, %rdi callq 0x857a movq %rax, %r13 xorl %ebx, %ebx movq %...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
nextc
static int nextc (RN *rn) { if (l_unlikely(rn->n >= L_MAXLENNUM)) { /* buffer overflow? */ rn->buff[0] = '\0'; /* invalidate result */ return 0; /* fail */ } else { rn->buff[rn->n++] = cast_char(rn->c); /* save current char */ rn->c = l_getc(rn->f); /* read next one */ return 1; } }
pushq %rbx movq %rdi, %rbx movslq 0xc(%rdi), %rax cmpq $0xc8, %rax jge 0x103bf movb 0x8(%rbx), %cl leal 0x1(%rax), %edx movl %edx, 0xc(%rbx) movb %cl, 0x10(%rbx,%rax) movq (%rbx), %rdi callq 0x5120 movl %eax, 0x8(%rbx) movl $0x1, %eax popq %rbx retq movb $0x0, 0x10(%rbx) xorl %eax, %eax jmp 0x103bd
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
g_write
static int g_write (lua_State *L, FILE *f, int arg) { int nargs = lua_gettop(L) - arg; size_t totalbytes = 0; /* total number of bytes written */ errno = 0; for (; nargs--; arg++) { /* for each argument */ char buff[LUA_N2SBUFFSZ]; const char *s; size_t numbytes; /* bytes written in one call to '...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movl %edx, %ebx movq %rsi, 0x18(%rsp) movq %rdi, %r15 callq 0x663a movl %eax, %ebp callq 0x5060 movl $0x0, (%rax) movl $0x1, %eax movl %ebp, 0x14(%rsp) cmpl %ebx, %ebp je 0x104cd xorl %r13d, %r13d leaq 0x20(%rsp), %r14 movq %r15, %rdi mo...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
f_tostring
static int f_tostring (lua_State *L) { LStream *p = tolstream(L); if (isclosed(p)) lua_pushliteral(L, "file (closed)"); else lua_pushfstring(L, "file (%p)", p->f); return 1; }
pushq %rbx movq %rdi, %rbx leaq 0x197bc(%rip), %rdx # 0x29d00 movl $0x1, %esi callq 0x8cd9 cmpq $0x0, 0x8(%rax) je 0x1056b movq (%rax), %rdx leaq 0x19875(%rip), %rsi # 0x29dd4 movq %rbx, %rdi xorl %eax, %eax callq 0x6ee9 jmp 0x1057a leaq 0x19854(%rip), %rsi # 0x29dc6 movq %rbx, %rdi callq 0x6e5b movl $0x1, ...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
f_seek
static int f_seek (lua_State *L) { static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END}; static const char *const modenames[] = {"set", "cur", "end", NULL}; FILE *f = tofile(L); int op = luaL_checkoption(L, 2, "cur", modenames); lua_Integer p3 = luaL_optinteger(L, 3, 0); l_seeknum offset = (l_seeknum)p3...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx callq 0xfa5f movq %rax, %r14 leaq 0x197d5(%rip), %rdx # 0x29deb leaq 0x288b3(%rip), %rcx # 0x38ed0 movq %rbx, %rdi movl $0x2, %esi callq 0x8d12 movl %eax, %ebp movq %rbx, %rdi movl $0x3, %esi xorl %edx, %edx callq 0x8fb7 movq %rax, %r15 call...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
f_setvbuf
static int f_setvbuf (lua_State *L) { static const int mode[] = {_IONBF, _IOFBF, _IOLBF}; static const char *const modenames[] = {"no", "full", "line", NULL}; FILE *f = tofile(L); int op = luaL_checkoption(L, 2, NULL, modenames); lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE); int res; errno = 0;...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx callq 0xfa5f movq %rax, %r14 leaq 0x28839(%rip), %rcx # 0x38ef0 movq %rbx, %rdi movl $0x2, %esi xorl %edx, %edx callq 0x8d12 movl %eax, %ebp movl $0x400, %edx # imm = 0x400 movq %rbx, %rdi movl $0x3, %esi callq 0x8fb7 movq %rax, %r15 ...
/mmanyen[P]CLua/build_O1/_deps/lua/liolib.c
luaopen_math
LUAMOD_API int luaopen_math (lua_State *L) { luaL_newlib(L, mathlib); lua_pushnumber(L, PI); lua_setfield(L, -2, "pi"); lua_pushnumber(L, (lua_Number)HUGE_VAL); lua_setfield(L, -2, "huge"); lua_pushinteger(L, LUA_MAXINTEGER); lua_setfield(L, -2, "maxinteger"); lua_pushinteger(L, LUA_MININTEGER); lua_s...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movsd 0x18bed(%rip), %xmm0 # 0x29358 movl $0x88, %esi callq 0x9c8c movq %rbx, %rdi xorl %esi, %esi movl $0x1b, %edx callq 0x7355 leaq 0x28785(%rip), %rsi # 0x38f10 movq %rbx, %rdi xorl %edx, %edx callq 0x9919 movsd 0x19693(%rip), %xmm0 # 0x29e30 movq %rbx, %rdi...
/mmanyen[P]CLua/build_O1/_deps/lua/lmathlib.c
math_abs
static int math_abs (lua_State *L) { if (lua_isinteger(L, 1)) { lua_Integer n = lua_tointeger(L, 1); if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n); lua_pushinteger(L, n); } else lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1))); return 1; }
pushq %rbx movq %rdi, %rbx movl $0x1, %esi callq 0x6924 movq %rbx, %rdi movl $0x1, %esi testl %eax, %eax je 0x108b4 xorl %edx, %edx callq 0x6b52 movq %rax, %rsi negq %rsi cmovsq %rax, %rsi movq %rbx, %rdi callq 0x6d91 jmp 0x108c8 callq 0x8eb7 andps 0x195c0(%rip), %xmm0 # 0x29e80 movq %rbx, %rdi callq 0x6d7f movl $0x...
/mmanyen[P]CLua/build_O1/_deps/lua/lmathlib.c
math_toint
static int math_toint (lua_State *L) { int valid; lua_Integer n = lua_tointegerx(L, 1, &valid); if (l_likely(valid)) lua_pushinteger(L, n); else { luaL_checkany(L, 1); luaL_pushfail(L); /* value is not convertible to integer */ } return 1; }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x4(%rsp), %r14 movl $0x1, %esi movq %r14, %rdx callq 0x6b52 cmpl $0x0, (%r14) je 0x10a43 movq %rbx, %rdi movq %rax, %rsi callq 0x6d91 movl $0x1, %eax addq $0x8, %rsp popq %rbx popq %r14 retq movq %rbx, %rdi callq 0x58f2 jmp 0x10a36
/mmanyen[P]CLua/build_O1/_deps/lua/lmathlib.c
math_floor
static int math_floor (lua_State *L) { if (lua_isinteger(L, 1)) lua_settop(L, 1); /* integer is its own floor */ else { lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1)); pushnumint(L, d); } return 1; }
pushq %rbx movq %rdi, %rbx movl $0x1, %esi callq 0x6924 testl %eax, %eax je 0x10a6e movq %rbx, %rdi movl $0x1, %esi callq 0x664e jmp 0x10a88 movq %rbx, %rdi movl $0x1, %esi callq 0x8eb7 callq 0x54e0 movq %rbx, %rdi callq 0x10ec4 movl $0x1, %eax popq %rbx retq
/mmanyen[P]CLua/build_O1/_deps/lua/lmathlib.c
math_log
static int math_log (lua_State *L) { lua_Number x = luaL_checknumber(L, 1); lua_Number res; if (lua_isnoneornil(L, 2)) res = l_mathop(log)(x); else { lua_Number base = luaL_checknumber(L, 2); #if !defined(LUA_USE_C89) if (base == l_mathop(2.0)) res = l_mathop(log2)(x); else #endif if (...
pushq %rbx subq $0x10, %rsp movq %rdi, %rbx movl $0x1, %esi callq 0x8eb7 movsd %xmm0, (%rsp) movq %rbx, %rdi movl $0x2, %esi callq 0x68d4 testl %eax, %eax jle 0x10be0 movq %rbx, %rdi movl $0x2, %esi callq 0x8eb7 ucomisd 0x19278(%rip), %xmm0 # 0x29e48 jne 0x10bec jp 0x10bec movsd (%rsp), %xmm0 callq 0x5530 jmp 0x10c3...
/mmanyen[P]CLua/build_O1/_deps/lua/lmathlib.c
math_min
static int math_min (lua_State *L) { int n = lua_gettop(L); /* number of arguments */ int imin = 1; /* index of current minimum value */ int i; luaL_argcheck(L, n >= 1, 1, "value expected"); for (i = 2; i <= n; i++) { if (lua_compare(L, i, imin, LUA_OPLT)) imin = i; } lua_pushvalue(L, imin); ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx callq 0x663a movl %eax, %r14d testl %eax, %eax jle 0x10d39 movl $0x1, %ebp cmpl $0x2, %r14d jl 0x10d1f negl %r14d movl $0x2, %r15d movq %rbx, %rdi movl %r15d, %esi movl %ebp, %edx movl $0x1, %ecx callq 0x6a1e testl %eax, %eax je 0x10d0c movl %r15d, ...
/mmanyen[P]CLua/build_O1/_deps/lua/lmathlib.c
math_modf
static int math_modf (lua_State *L) { if (lua_isinteger(L ,1)) { lua_settop(L, 1); /* number is its own integer part */ lua_pushnumber(L, 0); /* no fractional part */ } else { lua_Number n = luaL_checknumber(L, 1); /* integer part (rounds toward zero) */ lua_Number ip = (n < 0) ? l_mathop(ce...
pushq %rbx subq $0x20, %rsp movq %rdi, %rbx movl $0x1, %esi callq 0x6924 movq %rbx, %rdi movl $0x1, %esi testl %eax, %eax je 0x10d78 callq 0x664e xorpd %xmm0, %xmm0 jmp 0x10dc4 callq 0x8eb7 xorpd %xmm1, %xmm1 ucomisd %xmm0, %xmm1 movapd %xmm0, 0x10(%rsp) jbe 0x10d94 callq 0x50b0 jmp 0x10d99 callq 0x54e0 movq %rbx, %rdi...
/mmanyen[P]CLua/build_O1/_deps/lua/lmathlib.c
math_type
static int math_type (lua_State *L) { if (lua_type(L, 1) == LUA_TNUMBER) lua_pushstring(L, (lua_isinteger(L, 1)) ? "integer" : "float"); else { luaL_checkany(L, 1); luaL_pushfail(L); } return 1; }
pushq %rbx movq %rdi, %rbx movl $0x1, %esi callq 0x68d4 movq %rbx, %rdi movl $0x1, %esi cmpl $0x3, %eax jne 0x10eb0 callq 0x6924 testl %eax, %eax leaq 0x19078(%rip), %rax # 0x29f13 leaq 0x1a5b4(%rip), %rsi # 0x2b456 cmoveq %rax, %rsi movq %rbx, %rdi callq 0x6e5b jmp 0x10ebd callq 0x8e84 movq %rbx, %rdi callq 0x...
/mmanyen[P]CLua/build_O1/_deps/lua/lmathlib.c
setseed
static void setseed (lua_State *L, Rand64 *state, lua_Unsigned n1, lua_Unsigned n2) { int i; state[0] = Int2I(n1); state[1] = Int2I(0xff); /* avoid a zero state */ state[2] = Int2I(n2); state[3] = Int2I(0); for (i = 0; i < 16; i++) nextrand(state); /* discard initial values to "sp...
pushq %r14 pushq %rbx pushq %rax movq %rcx, %rbx movq %rdi, %r14 movq %rdx, (%rsi) movq $0xff, 0x8(%rsi) movq %rcx, 0x10(%rsi) movq $0x0, 0x18(%rsi) movl $0xff, %edi movl $0x10, %ecx xorl %eax, %eax movq %rdx, %r8 movq %rbx, %r9 movq %r9, %r10 movq %rdi, %r9 xorq %r8, %r10 xorq %rdi, %rax xorq %rax, %r8 movq %r10, %rdi...
/mmanyen[P]CLua/build_O1/_deps/lua/lmathlib.c
math_randomseed
static int math_randomseed (lua_State *L) { RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1)); lua_Unsigned n1, n2; if (lua_isnone(L, 1)) { n1 = luaL_makeseed(L); /* "random" seed */ n2 = I2UInt(nextrand(state->s)); /* in case seed is not that random... */ } else { n1 = l_cast...
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx movl $0xfff0b9d7, %esi # imm = 0xFFF0B9D7 callq 0x6cbc movq %rax, %r14 movq %rbx, %rdi movl $0x1, %esi callq 0x68d4 movq %rbx, %rdi cmpl $-0x1, %eax je 0x11170 movl $0x1, %esi callq 0x8f2d movq %rax, %r15 movq %rbx, %rdi movl $0x2, %esi xorl %edx, %edx callq 0x8fb7...
/mmanyen[P]CLua/build_O1/_deps/lua/lmathlib.c
luaM_growaux_
void *luaM_growaux_ (lua_State *L, void *block, int nelems, int *psize, unsigned size_elems, int limit, const char *what) { void *newblock; int size = *psize; if (nelems + 1 <= size) /* does one extra element still fit? */ return block; /* nothing to be done */ if (size >= limit / 2) ...
pushq %r14 pushq %rbx pushq %rax movl %edx, %eax movslq (%rcx), %rdx cmpl %eax, %edx jle 0x111ea movq %rsi, %rax jmp 0x11229 movq %rcx, %rbx movl %r9d, %eax shrl $0x1f, %eax addl %r9d, %eax sarl %eax cmpl %eax, %edx jge 0x1120e leal (%rdx,%rdx), %eax cmpl $0x5, %eax movl $0x4, %r9d cmovgel %eax, %r9d jmp 0x11213 cmpl %...
/mmanyen[P]CLua/build_O1/_deps/lua/lmem.c
luaM_shrinkvector_
void *luaM_shrinkvector_ (lua_State *L, void *block, int *size, int final_n, unsigned size_elem) { void *newblock; size_t oldsize = cast_sizet(*size) * size_elem; size_t newsize = cast_sizet(final_n) * size_elem; lua_assert(newsize <= oldsize); newblock = luaM_saferealloc_(L, block, ...
pushq %r14 pushq %rbx pushq %rax movq %rdx, %rbx movslq (%rdx), %rdx movl %r8d, %eax imulq %rax, %rdx movslq %ecx, %r14 imulq %r14, %rax movq %rax, %rcx callq 0x11247 movl %r14d, (%rbx) addq $0x8, %rsp popq %rbx popq %r14 retq
/mmanyen[P]CLua/build_O1/_deps/lua/lmem.c
luaM_realloc_
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) { void *newblock; global_State *g = G(L); lua_assert((osize == 0) == (block == NULL)); newblock = firsttry(g, block, osize, nsize); if (l_unlikely(newblock == NULL && nsize > 0)) { newblock = tryagain(L, block, osize, nsize); ...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rcx, %rbx movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %r12 movq 0x18(%rdi), %r13 movq 0x8(%r13), %rdi callq *(%r13) testq %rbx, %rbx je 0x11300 testq %rax, %rax je 0x11311 subq %rbx, %r14 addq %r14, 0x18(%r13) popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 ...
/mmanyen[P]CLua/build_O1/_deps/lua/lmem.c
luaM_malloc_
void *luaM_malloc_ (lua_State *L, size_t size, int tag) { if (size == 0) return NULL; /* that's all */ else { global_State *g = G(L); void *newblock = firsttry(g, NULL, cast_sizet(tag), size); if (l_unlikely(newblock == NULL)) { newblock = tryagain(L, NULL, cast_sizet(tag), size); if (n...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax testq %rsi, %rsi je 0x113be movq %rsi, %rbx movq %rdi, %r14 movq 0x18(%rdi), %r12 movq 0x8(%r12), %rdi movslq %edx, %r15 xorl %esi, %esi movq %r15, %rdx movq %rbx, %rcx callq *(%r12) testq %rax, %rax je 0x113cc subq %rbx, 0x18(%r12) jmp 0x113c0 xorl %eax, %eax addq...
/mmanyen[P]CLua/build_O1/_deps/lua/lmem.c
setpath
static void setpath (lua_State *L, const char *fieldname, const char *envname, const char *dft) { const char *dftmark; const char *nver = lua_pushfstring(L, "%s%s", envname, LUA_VERSUFFIX); const char *path = getenv(nver); /* try versioned nam...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x428, %rsp # imm = 0x428 movq %rcx, %r15 movq %rdx, %r13 movq %rsi, %r14 movq %rdi, %rbx leaq 0x18bad(%rip), %rsi # 0x2a1b2 leaq 0x18bab(%rip), %rcx # 0x2a1b7 xorl %eax, %eax callq 0x6ee9 movq %rax, %rdi callq 0x53e0 movq %rax, ...
/mmanyen[P]CLua/build_O1/_deps/lua/loadlib.c
ll_loadlib
static int ll_loadlib (lua_State *L) { const char *path = luaL_checkstring(L, 1); const char *init = luaL_checkstring(L, 2); int stat = lookforfunc(L, path, init); if (l_likely(stat == 0)) /* no errors? */ return 1; /* return the loaded function */ else { /* error; error message is on stack top */ ...
pushq %rbp pushq %r14 pushq %rbx movq %rdi, %rbx movl $0x1, %ebp movl $0x1, %esi xorl %edx, %edx callq 0x8dfc movq %rax, %r14 movq %rbx, %rdi movl $0x2, %esi xorl %edx, %edx callq 0x8dfc movq %rbx, %rdi movq %r14, %rsi movq %rax, %rdx callq 0x11906 testl %eax, %eax jne 0x11852 movl %ebp, %eax popq %rbx popq %r14 popq %...
/mmanyen[P]CLua/build_O1/_deps/lua/loadlib.c
findfile
static const char *findfile (lua_State *L, const char *name, const char *pname, const char *dirsep) { const char *path; lua_getfield(L, lua_upvalueindex(1), pname); path = lua_tostring(L, -1); if (l_unlikely(path == NULL)) ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r14 movl $0xfff0b9d7, %esi # imm = 0xFFF0B9D7 callq 0x71a1 movq %r14, %rdi movl $0xffffffff, %esi # imm = 0xFFFFFFFF xorl %edx, %edx callq 0x6bb8 movq %rax, %r12 testq %rax, %rax je 0x11d8e leaq 0x18642(%rip),...
/mmanyen[P]CLua/build_O1/_deps/lua/loadlib.c
intarith
static lua_Integer intarith (lua_State *L, int op, lua_Integer v1, lua_Integer v2) { switch (op) { case LUA_OPADD: return intop(+, v1, v2); case LUA_OPSUB:return intop(-, v1, v2); case LUA_OPMUL:return intop(*, v1, v2); case LUA_OPMOD: return luaV_mod...
xorl %eax, %eax cmpl $0xd, %esi ja 0x12387 movl %esi, %esi leaq 0x17ec2(%rip), %r8 # 0x2a220 movslq (%r8,%rsi,4), %rsi addq %r8, %rsi jmpq *%rsi addq %rdx, %rcx jmp 0x12390 negq %rdx jmp 0x12384 imulq %rdx, %rcx jmp 0x12390 andq %rdx, %rcx jmp 0x12390 notq %rdx jmp 0x12384 subq %rcx, %rdx movq %rdx, %rax retq orq ...
/mmanyen[P]CLua/build_O1/_deps/lua/lobject.c
luaO_str2num
size_t luaO_str2num (const char *s, TValue *o) { lua_Integer i; lua_Number n; const char *e; if ((e = l_str2int(s, &i)) != NULL) { /* try as an integer */ setivalue(o, i); } else if ((e = l_str2d(s, &n)) != NULL) { /* else try as a float */ setfltvalue(o, n); } else return 0; /* conversion ...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0xe0, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq 0x19775(%rip), %rcx # 0x2bc20 movq %rdi, %rax movzbl (%rax), %edx incq %rax testb $0x8, 0x1(%rdx,%rcx) jne 0x124ae cmpl $0x2b, %edx je 0x124d1 cmpl $0x2d, %edx jne 0x124ce movl $0x8, %edi xorl %edx, %edx jmp...
/mmanyen[P]CLua/build_O1/_deps/lua/lobject.c
luaO_tostringbuff
unsigned luaO_tostringbuff (const TValue *obj, char *buff) { int len; lua_assert(ttisnumber(obj)); if (ttisinteger(obj)) len = lua_integer2str(buff, LUA_N2SBUFFSZ, ivalue(obj)); else len = tostringbuffFloat(fltvalue(obj), buff); lua_assert(len < LUA_N2SBUFFSZ); return cast_uint(len); }
pushq %rbp pushq %rbx pushq %rax movq %rsi, %rbx cmpb $0x3, 0x8(%rdi) jne 0x12759 movq (%rdi), %rcx leaq 0x17c5c(%rip), %rdx # 0x2a3a0 movl $0x40, %esi movq %rbx, %rdi xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %rbp jmp 0x54b0 movsd (%rdi), %xmm0 movsd %xmm0, (%rsp) leaq 0x17c5c(%rip), %rdx # 0x2a3c5 movl $...
/mmanyen[P]CLua/build_O1/_deps/lua/lobject.c
addstr2buff
static void addstr2buff (BuffFS *buff, const char *str, size_t slen) { size_t left = buff->buffsize - buff->blen; /* space left in the buffer */ if (buff->err) /* do nothing else after an error */ return; if (slen > left) { /* new string doesn't fit into current buffer? */ if (slen > ((MAX_SIZE/2) - bu...
cmpl $0x0, 0x20(%rdi) je 0x12b60 retq pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r15 movq %rsi, %r14 movq %rdi, %rbx movq 0x10(%rdi), %rdx movq 0x18(%rdi), %rdi movq %rdx, %rax subq %rdi, %rax cmpq %r15, %rax jae 0x12c10 movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFF...
/mmanyen[P]CLua/build_O1/_deps/lua/lobject.c
luaO_chunkid
void luaO_chunkid (char *out, const char *source, size_t srclen) { size_t bufflen = LUA_IDSIZE; /* free space in buffer */ if (*source == '=') { /* 'literal' source */ if (srclen <= bufflen) /* small enough? */ memcpy(out, source + 1, srclen * sizeof(char)); else { /* truncate it */ addstr(o...
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %r15 movq %rsi, %r14 movq %rdi, %rbx movzbl (%rsi), %eax cmpl $0x40, %eax je 0x12d23 cmpl $0x3d, %eax jne 0x12d3f incq %r14 cmpq $0x3c, %r15 jbe 0x12d2c movups (%r14), %xmm0 movups 0x10(%r14), %xmm1 movups 0x20(%r14), %xmm2 movups 0x2b(%r14), %xmm3 movups %xmm3, 0x2b(%rbx) mo...
/mmanyen[P]CLua/build_O1/_deps/lua/lobject.c