Datasets:
LLM4Binary
/
decompile-bench

Dataset card Data Studio Files
xet
 Community
1
name
string
code
string
asm
string
file
string
luaT_adjustvarargs
void luaT_adjustvarargs (lua_State *L, int nfixparams, CallInfo *ci, const Proto *p) { int i; int actual = cast_int(L->top.p - ci->func.p) - 1; /* number of arguments */ int nextra = actual - nfixparams; /* number of extra arguments */ ci->u.l.nextraargs = nextra; luaD_checkstack(L,...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdx, %rbx movl %esi, %ebp movq %rdi, %r14 movq 0x10(%rdi), %r15 subq (%rdx), %r15 shrq $0x4, %r15 movl %esi, %eax notl %eax addl %r15d, %eax movl %eax, 0x2c(%rdx) movq 0x28(%rdi), %rax subq 0x10(%rdi), %rax sarq $0x4, %rax movzbl 0xc(%rcx), %esi incq %rsi cmp...
/mmanyen[P]CLua/build_O1/_deps/lua/ltm.c
luaT_getvarargs
void luaT_getvarargs (lua_State *L, CallInfo *ci, StkId where, int wanted) { int i; int nextra = ci->u.l.nextraargs; if (wanted < 0) { wanted = nextra; /* get all extra arguments available */ checkstackp(L, nextra, where); /* ensure stack space */ L->top.p = where + nextra; /* next instruction will...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %rbx movq %rsi, %r14 movl 0x2c(%rsi), %r13d movslq %r13d, %r12 testl %ecx, %ecx js 0x1cf92 movl %ecx, %ebp jmp 0x1cfbb movq %rdi, %r15 movl %r12d, %ebp movq 0x28(%rdi), %rax subq 0x10(%rdi), %rax sarq $0x4, %rax cmpq %r12, %rax jle ...
/mmanyen[P]CLua/build_O1/_deps/lua/ltm.c
luaU_undump
LClosure *luaU_undump (lua_State *L, ZIO *Z, const char *name, int fixed) { LoadState S; LClosure *cl; if (*name == '@' || *name == '=') S.name = name + 1; else if (*name == LUA_SIGNATURE[0]) S.name = "binary string"; else S.name = name; S.L = L; S.Z = Z; S.fixed = cast_byte(fixed); S.offs...
pushq %r15 pushq %r14 pushq %rbx subq $0x40, %rsp movq %rdi, %rbx movzbl (%rdx), %eax cmpl $0x1b, %eax je 0x1d06f cmpl $0x40, %eax je 0x1d06a cmpl $0x3d, %eax jne 0x1d076 incq %rdx jmp 0x1d076 leaq 0xe37e(%rip), %rdx # 0x2b3f4 leaq 0x8(%rsp), %r14 movq %rdx, 0x10(%r14) movq %rbx, (%r14) movq %rsi, 0x8(%r14) movb %...
/mmanyen[P]CLua/build_O1/_deps/lua/lundump.c
loadFunction
static void loadFunction (LoadState *S, Proto *f) { f->linedefined = loadInt(S); f->lastlinedefined = loadInt(S); f->numparams = loadByte(S); f->flag = loadByte(S) & PF_ISVARARG; /* get only the meaningful flags */ if (S->fixed) f->flag |= PF_FIXED; /* signal that code is fixed */ f->maxstacksize = lo...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rsi, %r14 movq %rdi, %rbx movl $0x7fffffff, %esi # imm = 0x7FFFFFFF callq 0x1db2e movl %eax, 0x2c(%r14) movl $0x7fffffff, %esi # imm = 0x7FFFFFFF movq %rbx, %rdi callq 0x1db2e movl %eax, 0x30(%r14) movq %rbx, %rdi callq...
/mmanyen[P]CLua/build_O1/_deps/lua/lundump.c
loadVarint
static size_t loadVarint (LoadState *S, size_t limit) { size_t x = 0; int b; limit >>= 7; do { b = loadByte(S); if (x > limit) error(S, "integer overflow"); x = (x << 7) | (b & 0x7f); } while ((b & 0x80) != 0); return x; }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %rbx shrq $0x7, %r14 xorl %r15d, %r15d movq %rbx, %rdi callq 0x1d2e5 cmpq %r14, %r15 ja 0x1db6d movq %r15, %rcx shlq $0x7, %rcx movl %eax, %edx andb $0x7f, %dl movzbl %dl, %r15d orq %rcx, %r15 testb %al, %al js 0x1db40 movq %r15, %rax popq %rbx popq %r14 popq ...
/mmanyen[P]CLua/build_O1/_deps/lua/lundump.c
luaV_tonumber_
int luaV_tonumber_ (const TValue *obj, lua_Number *n) { TValue v; if (ttisinteger(obj)) { *n = cast_num(ivalue(obj)); return 1; } else if (l_strton(obj, &v)) { /* string coercible to number? */ *n = nvalue(&v); /* convert result of 'luaO_str2num' to a float */ return 1; } else return 0...
pushq %rbx subq $0x10, %rsp movq %rsi, %rbx cmpb $0x3, 0x8(%rdi) jne 0x1dbc5 cvtsi2sdq (%rdi), %xmm0 jmp 0x1dbec movq %rsp, %rsi callq 0x1dbfb testl %eax, %eax je 0x1dbe3 cmpb $0x3, 0x8(%rsp) movq (%rsp), %rax je 0x1dbe7 movq %rax, %xmm0 jmp 0x1dbec xorl %eax, %eax jmp 0x1dbf5 cvtsi2sd %rax, %xmm0 movsd %xmm0, (%rbx) m...
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
l_strton
static int l_strton (const TValue *obj, TValue *result) { lua_assert(obj != result); if (!cvt2num(obj)) /* is object not a string? */ return 0; else { TString *st = tsvalue(obj); size_t stlen; const char *s = getlstr(st, stlen); return (luaO_str2num(s, result) == stlen + 1); } }
movb 0x8(%rdi), %cl andb $0xf, %cl xorl %eax, %eax cmpb $0x4, %cl jne 0x1dc38 pushq %rbx movq (%rdi), %rdi movsbq 0xb(%rdi), %rbx testq %rbx, %rbx js 0x1dc1c addq $0x18, %rdi jmp 0x1dc24 movq 0x10(%rdi), %rbx movq 0x18(%rdi), %rdi callq 0x1248f movq %rax, %rcx incq %rbx xorl %eax, %eax cmpq %rbx, %rcx sete %al popq %rb...
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
luaV_flttointeger
int luaV_flttointeger (lua_Number n, lua_Integer *p, F2Imod mode) { lua_Number f = l_floor(n); if (n != f) { /* not an integral value? */ if (mode == F2Ieq) return 0; /* fails if mode demands integral value */ else if (mode == F2Iceil) /* needs ceiling? */ f += 1; /* convert floor to ceiling (reme...
pushq %rbp pushq %rbx pushq %rax movl %esi, %ebp movq %rdi, %rbx movsd %xmm0, (%rsp) callq 0x54e0 ucomisd (%rsp), %xmm0 jne 0x1dc54 jnp 0x1dc65 testl %ebp, %ebp je 0x1dc9d cmpl $0x2, %ebp jne 0x1dc65 addsd 0xc1d3(%rip), %xmm0 # 0x29e38 movsd 0xc1fb(%rip), %xmm1 # 0x29e68 movapd %xmm0, %xmm2 cmpltpd %xmm1, %xmm2...
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
luaV_tointegerns
int luaV_tointegerns (const TValue *obj, lua_Integer *p, F2Imod mode) { if (ttisfloat(obj)) return luaV_flttointeger(fltvalue(obj), p, mode); else if (ttisinteger(obj)) { *p = ivalue(obj); return 1; } else return 0; }
pushq %rbp pushq %rbx pushq %rax movq %rsi, %rbx movzbl 0x8(%rdi), %ecx cmpl $0x3, %ecx je 0x1dd20 xorl %eax, %eax cmpl $0x13, %ecx jne 0x1dd2b movl %edx, %ebp movsd (%rdi), %xmm0 movsd %xmm0, (%rsp) callq 0x54e0 ucomisd (%rsp), %xmm0 jne 0x1dcd5 jnp 0x1dce6 testl %ebp, %ebp je 0x1dd32 cmpl $0x2, %ebp jne 0x1dce6 addsd...
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
luaV_finishget
lu_byte luaV_finishget (lua_State *L, const TValue *t, TValue *key, StkId val, lu_byte tag) { int loop; /* counter to avoid infinite loops */ const TValue *tm; /* metamethod */ for (loop = 0; loop < MAXTAGLOOP; loop++) { if (tag == LUA_VNOTABLE) { /* 't' is not a table...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %r8d, %eax movq %rcx, %r14 movq %rdx, %r15 movq %rsi, %r12 movq %rdi, %rbx movl $0x7d0, %ebp # imm = 0x7D0 cmpb $0x30, %al jne 0x1ddb3 movq %rbx, %rdi movq %r12, %rsi xorl %edx, %edx callq 0x1cb50 movq %rax, %r13 testb $0xf, 0x...
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
luaV_finishset
void luaV_finishset (lua_State *L, const TValue *t, TValue *key, TValue *val, int hres) { int loop; /* counter to avoid infinite loops */ for (loop = 0; loop < MAXTAGLOOP; loop++) { const TValue *tm; /* '__newindex' metamethod */ if (hres != HNOTATABLE) { /* is 't' a table? */ ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %r8d, %ebp movq %rcx, 0x8(%rsp) movq %rdx, 0x10(%rsp) movq %rsi, %r12 movq %rdi, %rbx movl $0x7d0, %r14d # imm = 0x7D0 cmpl $0x2, %ebp jne 0x1deb7 movq %rbx, %rdi movq %r12, %rsi movl $0x1, %edx callq 0x1cb50 movq %rax, %r...
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
luaV_lessthan
int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) { if (ttisnumber(l) && ttisnumber(r)) /* both operands are numbers? */ return LTnum(l, r); else return lessthanothers(L, l, r); }
movb 0x8(%rsi), %cl movl %ecx, %eax andb $0xf, %al cmpb $0x3, %al jne 0x1e16d movb 0x8(%rdx), %al movl %eax, %r8d andb $0xf, %r8b cmpb $0x3, %r8b jne 0x1e16d pushq %rbx subq $0x10, %rsp cmpb $0x3, %cl jne 0x1e055 movq (%rsi), %rbx cmpb $0x3, %al jne 0x1e063 cmpq (%rdx), %rbx setl %al jmp 0x1e164 movsd (%rsi), %xmm0 cmp...
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
luaV_lessequal
int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) { if (ttisnumber(l) && ttisnumber(r)) /* both operands are numbers? */ return LEnum(l, r); else return lessequalothers(L, l, r); }
movb 0x8(%rsi), %cl movl %ecx, %eax andb $0xf, %al cmpb $0x3, %al jne 0x1e2f5 movb 0x8(%rdx), %al movl %eax, %r8d andb $0xf, %r8b cmpb $0x3, %r8b jne 0x1e2f5 pushq %rbx subq $0x10, %rsp cmpb $0x3, %cl jne 0x1e1d9 movq (%rsi), %rbx cmpb $0x3, %al jne 0x1e1e7 cmpq (%rdx), %rbx setle %al jmp 0x1e2ec movsd (%rsi), %xmm0 cm...
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
luaV_equalobj
int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) { const TValue *tm; if (ttypetag(t1) != ttypetag(t2)) { /* not the same variant? */ if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) return 0; /* only numbers can be equal with different variants */ else { /* two numbers wi...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rdx, %rbx movq %rsi, %r14 movzbl 0x8(%rsi), %eax movl %eax, %ecx andl $0x3f, %ecx movzbl 0x8(%rdx), %ebp movl %ebp, %edx andl $0x3f, %edx cmpl %edx, %ecx jne 0x1e37e cmpl $0x16, %ecx ja 0x1e370 movq %rdi, %r12 movl $0x1, %r15d movl %ecx, %eax...
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
luaV_concat
void luaV_concat (lua_State *L, int total) { if (total == 1) return; /* "all" values already concatenated */ do { StkId top = L->top.p; int n = 2; /* number of elements handled in this pass (at least 2) */ if (!(ttisstring(s2v(top - 2)) || cvt2str(s2v(top - 2))) || !tostring(L, s2v(top - 1...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp cmpl $0x1, %esi jne 0x1e5da addq $0x58, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl %esi, %r15d movq %rdi, %rbx movabsq $0x7fffffffffffffcf, %rbp # imm = 0x7FFFFFFFFFFFFFCF movq %rdi, 0x10(%rsp) movl %r15d,...
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
luaV_objlen
void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) { const TValue *tm; switch (ttypetag(rb)) { case LUA_VTABLE: { Table *h = hvalue(rb); tm = fasttm(L, h->metatable, TM_LEN); if (tm) break; /* metamethod? break switch to call it */ setivalue(s2v(ra), l_castU2S(luaH_getn(h))); ...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r14 movq %rsi, %rbx movzbl 0x8(%rdx), %eax andl $0x3f, %eax cmpl $0x4, %eax je 0x1e8cd cmpl $0x14, %eax je 0x1e8c4 movq %rdi, %r15 cmpl $0x5, %eax jne 0x1e8d7 movq (%r14), %r12 movq 0x20(%r12), %rdi testq %rdi, %rdi je 0x1e902 testb $0x10, 0xa(%rdi) jne...
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
luaV_idiv
lua_Integer luaV_idiv (lua_State *L, lua_Integer m, lua_Integer n) { if (l_unlikely(l_castS2U(n) + 1u <= 1u)) { /* special cases: -1 or 0 */ if (n == 0) luaG_runerror(L, "attempt to divide by zero"); return intop(-, 0, m); /* n==-1; avoid overflow with 0x80000...//-1 */ } else { lua_Integer q...
movq %rdx, %rcx leaq 0x1(%rdx), %rax cmpq $0x1, %rax jbe 0x1e964 movq %rsi, %rax cqto idivq %rcx xorq %rsi, %rcx js 0x1e95b retq cmpq $0x1, %rdx adcq $-0x1, %rax retq testq %rcx, %rcx je 0x1e970 negq %rsi movq %rsi, %rax retq pushq %rax leaq 0xcc9c(%rip), %rsi # 0x2b614 xorl %eax, %eax callq 0xa859
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
luaV_shiftl
lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) { if (y < 0) { /* shift right? */ if (y <= -NBITS) return 0; else return intop(>>, x, -y); } else { /* shift left */ if (y >= NBITS) return 0; else return intop(<<, x, y); } }
movq %rdi, %rax testq %rsi, %rsi js 0x1ea12 movl %esi, %ecx shlq %cl, %rax xorl %ecx, %ecx cmpq $0x40, %rsi cmovgeq %rcx, %rax retq cmpq $-0x3f, %rsi jge 0x1ea1b xorl %eax, %eax retq negb %sil movl %esi, %ecx shrq %cl, %rax retq
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
luaV_finishOp
void luaV_finishOp (lua_State *L) { CallInfo *ci = L->ci; StkId base = ci->func.p + 1; Instruction inst = *(ci->u.l.savedpc - 1); /* interrupted instruction */ OpCode op = GET_OPCODE(inst); switch (op) { /* finish its execution */ case OP_MMBIN: case OP_MMBINI: case OP_MMBINK: { setobjs2s(L, base ...
movq 0x20(%rdi), %rdx movq (%rdx), %rax movq 0x20(%rdx), %rsi addq $0x10, %rax movl -0x4(%rsi), %ecx movl %ecx, %r8d andl $0x7f, %r8d leal -0x2e(%r8), %r9d cmpl $0x18, %r9d ja 0x1ea8c leaq 0xcaea(%rip), %r8 # 0x2b538 movslq (%r8,%r9,4), %r9 addq %r8, %r9 jmpq *%r9 movq 0x10(%rdi), %rax movb -0x8(%rax), %sil cmpb ...
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
l_strcmp
static int l_strcmp (const TString *ts1, const TString *ts2) { size_t rl1; /* real length */ const char *s1 = getlstr(ts1, rl1); size_t rl2; const char *s2 = getlstr(ts2, rl2); for (;;) { /* for each segment */ int temp = strcoll(s1, s2); if (temp != 0) /* not equal? */ return temp; /* done ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movsbq 0xb(%rdi), %r12 testq %r12, %r12 js 0x22393 addq $0x18, %r14 jmp 0x2239b movq 0x10(%r14), %r12 movq 0x18(%r14), %r14 movsbq 0xb(%rbx), %r13 testq %r13, %r13 js 0x223ab addq $0x18, %rbx jmp 0x223b3 movq 0x...
/mmanyen[P]CLua/build_O1/_deps/lua/lvm.c
luaZ_fill
int luaZ_fill (ZIO *z) { size_t size; lua_State *L = z->L; const char *buff; lua_unlock(L); buff = z->reader(L, z->data, &size); lua_lock(L); if (buff == NULL || size == 0) return EOZ; z->n = size - 1; /* discount char being returned */ z->p = buff; return cast_uchar(*(z->p++)); }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x18(%rdi), %rsi movq 0x20(%rdi), %rdi movq %rsp, %r14 movq %r14, %rdx callq *0x10(%rbx) testq %rax, %rax sete %cl movq (%r14), %rdx testq %rdx, %rdx sete %sil orb %cl, %sil movl $0xffffffff, %ecx # imm = 0xFFFFFFFF jne 0x2246d decq %rdx movq %rdx, (%rbx) movq...
/mmanyen[P]CLua/build_O1/_deps/lua/lzio.c
luaZ_read
size_t luaZ_read (ZIO *z, void *b, size_t n) { while (n) { size_t m; if (!checkbuffer(z)) return n; /* no more input; return number of missing bytes */ m = (n <= z->n) ? n : z->n; /* min. between n and z->n */ memcpy(b, z->p, m); z->n -= m; z->p += m; b = (char *)b + m; n -= m;...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 testq %rbx, %rbx je 0x224e2 movq %r15, %rdi callq 0x224f7 movl %eax, %ebp testl %eax, %eax je 0x224d9 movq (%r15), %r13 movq 0x8(%r15), %rsi cmpq %r13, %rbx cmovbq %rbx, %r13 movq %r14, %rdi movq...
/mmanyen[P]CLua/build_O1/_deps/lua/lzio.c
checkbuffer
static int checkbuffer (ZIO *z) { if (z->n == 0) { /* no bytes in buffer? */ if (luaZ_fill(z) == EOZ) /* try to read more */ return 0; /* no more input */ else { z->n++; /* luaZ_fill consumed first byte; put it back */ z->p--; } } return 1; /* now buffer has something */ }
pushq %r14 pushq %rbx pushq %rax movl $0x1, %ebx cmpq $0x0, (%rdi) jne 0x2251e movq %rdi, %r14 callq 0x22428 cmpl $-0x1, %eax je 0x2251c incq (%r14) decq 0x8(%r14) jmp 0x2251e xorl %ebx, %ebx movl %ebx, %eax addq $0x8, %rsp popq %rbx popq %r14 retq
/mmanyen[P]CLua/build_O1/_deps/lua/lzio.c
luaZ_getaddr
const void *luaZ_getaddr (ZIO* z, size_t n) { const void *res; if (!checkbuffer(z)) return NULL; /* no more input */ if (z->n < n) /* not enough bytes? */ return NULL; /* block not whole; cannot give an address */ res = z->p; /* get block address */ z->n -= n; /* consume these bytes */ z->p += ...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 callq 0x224f7 testl %eax, %eax je 0x22543 movq (%r14), %rcx subq %rbx, %rcx jae 0x22547 xorl %eax, %eax jmp 0x22555 movq 0x8(%r14), %rax movq %rcx, (%r14) addq %rax, %rbx movq %rbx, 0x8(%r14) addq $0x8, %rsp popq %rbx popq %r14 retq nopl (%rax)
/mmanyen[P]CLua/build_O1/_deps/lua/lzio.c
byteoffset
static int byteoffset (lua_State *L) { size_t len; const char *s = luaL_checklstring(L, 1, &len); lua_Integer n = luaL_checkinteger(L, 2); lua_Integer posi = (n >= 0) ? 1 : cast_st2S(len) + 1; posi = u_posrelat(luaL_optinteger(L, 3, posi), len); luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 3, ...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rdi, %rbx leaq 0x8(%rsp), %r13 movl $0x1, %esi movq %r13, %rdx callq 0x8dfc movq %rax, %r14 movq %rbx, %rdi movl $0x2, %esi callq 0x8f2d movq %rax, %r12 movq (%r13), %rax incq %rax testq %r12, %r12 movl $0x1, %edx cmovsq %rax, %rdx movq %rbx,...
/mmanyen[P]CLua/build_O1/_deps/lua/lutf8lib.c
codepoint
static int codepoint (lua_State *L) { size_t len; const char *s = luaL_checklstring(L, 1, &len); lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len); lua_Integer pose = u_posrelat(luaL_optinteger(L, 3, posi), len); int lax = lua_toboolean(L, 4); int n; const char *se; luaL_argcheck(L, posi >= 1...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx leaq 0x8(%rsp), %rdx movl $0x1, %esi callq 0x8dfc movq %rax, %r15 movl $0x1, %edx movq %rbx, %rdi movl $0x2, %esi callq 0x8fb7 movq %rax, %r12 testq %rax, %rax jns 0x22802 movq 0x8(%rsp), %rax movq %r12, %rcx negq %rcx cm...
/mmanyen[P]CLua/build_O1/_deps/lua/lutf8lib.c
utflen
static int utflen (lua_State *L) { lua_Integer n = 0; /* counter for the number of characters */ size_t len; /* string length in bytes */ const char *s = luaL_checklstring(L, 1, &len); lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len); lua_Integer posj = u_posrelat(luaL_optinteger(L, 3, -1), len)...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %r15 movq %rsp, %rdx movl $0x1, %esi callq 0x8dfc movq %rax, %r14 movl $0x1, %edx movq %r15, %rdi movl $0x2, %esi callq 0x8fb7 movq %rax, %rbx testq %rax, %rax jns 0x22a2e movq (%rsp), %rax movq %rbx, %rcx negq %rcx cmpq %rcx,...
/mmanyen[P]CLua/build_O1/_deps/lua/lutf8lib.c
iter_codes
static int iter_codes (lua_State *L) { int lax = lua_toboolean(L, 2); const char *s = luaL_checkstring(L, 1); luaL_argcheck(L, !iscontp(s), 1, MSGInvalid); lua_pushcfunction(L, lax ? iter_auxlax : iter_auxstrict); lua_pushvalue(L, 1); lua_pushinteger(L, 0); return 3; }
pushq %rbp pushq %rbx pushq %rax movq %rdi, %rbx movl $0x2, %esi callq 0x6b9e movl %eax, %ebp movq %rbx, %rdi movl $0x1, %esi xorl %edx, %edx callq 0x8dfc movb (%rax), %al andb $-0x40, %al negb %al jo 0x22bcd testl %ebp, %ebp leaq 0x16b(%rip), %rax # 0x22d00 leaq 0x160(%rip), %rsi # 0x22cfc cmoveq %rax, %rs...
/mmanyen[P]CLua/build_O1/_deps/lua/lutf8lib.c
utf8_decode
static const char *utf8_decode (const char *s, l_uint32 *val, int strict) { static const l_uint32 limits[] = {~(l_uint32)0, 0x80, 0x800, 0x10000u, 0x200000u, 0x4000000u}; unsigned int c = (unsigned char)s[0]; l_uint32 res = 0; /* final result */ if (c < 0x80) /* ascii? */ res = c; else { int...
movq %rdi, %rax movzbl (%rdi), %edi testb %dil, %dil jns 0x22c88 xorl %ecx, %ecx testb $0x40, %dil jne 0x22c02 movl %edi, %r9d xorl %r8d, %r8d jmp 0x22c41 xorl %r8d, %r8d xorl %ecx, %ecx movl %ecx, %r9d movzbl 0x1(%rax,%r8), %ecx movl %ecx, %r10d andl $-0x40, %r10d movl %r9d, %r11d shll $0x6, %r11d andl $0x3f, %ecx orl...
/mmanyen[P]CLua/build_O1/_deps/lua/lutf8lib.c
iter_aux
static int iter_aux (lua_State *L, int strict) { size_t len; const char *s = luaL_checklstring(L, 1, &len); lua_Unsigned n = (lua_Unsigned)lua_tointeger(L, 2); if (n < len) { while (iscontp(s + n)) n++; /* go to next character */ } if (n >= len) /* (also handles original 'n' being negative) */ ret...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %esi, %ebp movq %rdi, %rbx leaq 0x10(%rsp), %r13 movl $0x1, %esi movq %r13, %rdx callq 0x8dfc movq %rax, %r12 xorl %r15d, %r15d movq %rbx, %rdi movl $0x2, %esi xorl %edx, %edx callq 0x6b52 movq %rax, %r14 movq (%r13), %rax cmpq %rax...
/mmanyen[P]CLua/build_O1/_deps/lua/lutf8lib.c
luaopen_base
LUAMOD_API int luaopen_base (lua_State *L) { /* open lib into global table */ lua_pushglobaltable(L); luaL_setfuncs(L, base_funcs, 0); /* set global _G */ lua_pushvalue(L, -1); lua_setfield(L, -2, LUA_GNAME); /* set global _VERSION */ lua_pushliteral(L, LUA_VERSION); lua_setfield(L, -2, "_VERSION"); ...
pushq %rbx movq %rdi, %rbx movl $0x2, %edx movl $0xfff0b9d8, %esi # imm = 0xFFF0B9D8 callq 0x729c leaq 0x16aaa(%rip), %rsi # 0x39890 movq %rbx, %rdi xorl %edx, %edx callq 0x9919 movq %rbx, %rdi movl $0xffffffff, %esi # imm = 0xFFFFFFFF callq 0x68aa leaq 0x6ea4(%rip), %rdx # 0x29ca8 movq %rbx, %rdi ...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_assert
static int luaB_assert (lua_State *L) { if (l_likely(lua_toboolean(L, 1))) /* condition is true? */ return lua_gettop(L); /* return all arguments */ else { /* error */ luaL_checkany(L, 1); /* there must be a condition */ lua_remove(L, 1); /* remove it */ lua_pushliteral(L, "assertion failed!");...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movl $0x1, %esi callq 0x6b9e testl %eax, %eax je 0x22e5f movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %r14 jmp 0x663a leaq 0x4(%rsp), %r14 movq %rbx, %rdi movq %r14, %rsi callq 0x5b40 movl (%r14), %eax addq $0x8, %rsp popq %rbx popq %r14 retq
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_collectgarbage
static int luaB_collectgarbage (lua_State *L) { static const char *const opts[] = {"stop", "restart", "collect", "count", "step", "isrunning", "generational", "incremental", "param", NULL}; static const char optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT, LUA_GCCOUNT, LUA_GCSTEP, LUA_GCISRUNNING,...
pushq %rbp pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x89a2(%rip), %rdx # 0x2b829 leaq 0x16ba2(%rip), %rcx # 0x39a30 movl $0x1, %esi callq 0x8d12 cltq leaq 0x88c3(%rip), %rcx # 0x2b764 movzbl (%rax,%rcx), %eax leal -0x3(%rax), %ecx cmpl $0x6, %ecx ja 0x22f6b leaq 0x8890(%rip), %rdx # 0x2b748 movslq ...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_dofile
static int luaB_dofile (lua_State *L) { const char *fname = luaL_optstring(L, 1, NULL); lua_settop(L, 1); if (l_unlikely(luaL_loadfile(L, fname) != LUA_OK)) return lua_error(L); lua_callk(L, 0, LUA_MULTRET, 0, dofilecont); return dofilecont(L, 0, 0); }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movl $0x1, %esi xorl %edx, %edx xorl %ecx, %ecx callq 0x8da3 movq %rax, %r14 movq %rbx, %rdi movl $0x1, %esi callq 0x664e movq %rbx, %rdi movq %r14, %rsi xorl %edx, %edx callq 0x9357 testl %eax, %eax jne 0x23055 leaq 0xa44(%rip), %r8 # 0x23a76 movq %rbx, %rdi xorl...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_error
static int luaB_error (lua_State *L) { int level = (int)luaL_optinteger(L, 2, 1); lua_settop(L, 1); if (lua_type(L, 1) == LUA_TSTRING && level > 0) { luaL_where(L, level); /* add extra information */ lua_pushvalue(L, 1); lua_concat(L, 2); } return lua_error(L); }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movl $0x1, %edx movl $0x2, %esi callq 0x8fb7 movq %rax, %r14 movq %rbx, %rdi movl $0x1, %esi callq 0x664e movq %rbx, %rdi movl $0x1, %esi callq 0x68d4 cmpl $0x4, %eax sete %al testl %r14d, %r14d setg %cl andb %al, %cl cmpb $0x1, %cl jne 0x230cf movq %rbx, %rdi movl %r14d...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_getmetatable
static int luaB_getmetatable (lua_State *L) { luaL_checkany(L, 1); if (!lua_getmetatable(L, 1)) { lua_pushnil(L); return 1; /* no metatable */ } luaL_getmetafield(L, 1, "__metatable"); return 1; /* returns either __metatable field (if present) or metatable */ }
pushq %rbx movq %rdi, %rbx movl $0x1, %esi callq 0x8e84 movq %rbx, %rdi movl $0x1, %esi callq 0x73b1 testl %eax, %eax je 0x23113 leaq 0x8792(%rip), %rdx # 0x2b896 movq %rbx, %rdi movl $0x1, %esi callq 0x89f6 jmp 0x2311b movq %rbx, %rdi callq 0x6d71 movl $0x1, %eax popq %rbx retq
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_load
static int luaB_load (lua_State *L) { int status; size_t l; const char *s = lua_tolstring(L, 1, &l); const char *mode = getMode(L, 3); int env = (!lua_isnone(L, 4) ? 4 : 0); /* 'env' index or 0 if no 'env' */ if (s != NULL) { /* loading a string? */ const char *chunkname = luaL_optstring(L, 2, s); ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq %rsp, %rdx movl $0x1, %esi callq 0x6bb8 movq %rax, %r15 movq %rbx, %rdi movl $0x3, %esi callq 0x23ac2 movq %rax, %r14 movq %rbx, %rdi movl $0x4, %esi callq 0x68d4 movl %eax, %ebp testq %r15, %r15 je 0x2322d movq %rbx, %rdi movl $0x2, %esi movq ...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_next
static int luaB_next (lua_State *L) { luaL_checktype(L, 1, LUA_TTABLE); lua_settop(L, 2); /* create a 2nd argument if there isn't one */ if (lua_next(L, 1)) return 2; else { lua_pushnil(L); return 1; } }
pushq %rbp pushq %rbx pushq %rax movq %rdi, %rbx movl $0x1, %esi movl $0x5, %edx callq 0x8e50 movl $0x2, %ebp movq %rbx, %rdi movl $0x2, %esi callq 0x664e movq %rbx, %rdi movl $0x1, %esi callq 0x7de1 testl %eax, %eax jne 0x232e1 movq %rbx, %rdi callq 0x6d71 movl $0x1, %ebp movl %ebp, %eax addq $0x8, %rsp popq %rbx popq...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_pairs
static int luaB_pairs (lua_State *L) { luaL_checkany(L, 1); if (luaL_getmetafield(L, 1, "__pairs") == LUA_TNIL) { /* no metamethod? */ lua_pushcfunction(L, luaB_next); /* will return generator, */ lua_pushvalue(L, 1); /* state, */ lua_pushnil(L); /* and initial value */ } else { lua_pushvalu...
pushq %rbx movq %rdi, %rbx movl $0x1, %esi callq 0x8e84 leaq 0x85ea(%rip), %rdx # 0x2b8e9 movq %rbx, %rdi movl $0x1, %esi callq 0x89f6 testl %eax, %eax je 0x2333a movq %rbx, %rdi movl $0x1, %esi callq 0x68aa leaq 0x90a(%rip), %r8 # 0x23c2e movq %rbx, %rdi movl $0x1, %esi movl $0x3, %edx xorl %ecx, %ecx call...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_pcall
static int luaB_pcall (lua_State *L) { int status; luaL_checkany(L, 1); lua_pushboolean(L, 1); /* first result if no errors */ lua_insert(L, 1); /* put it in place */ status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall); return finishpcall(L, status, 0); }
pushq %rbx movq %rdi, %rbx movl $0x1, %esi callq 0x8e84 movq %rbx, %rdi movl $0x1, %esi callq 0x704c movq %rbx, %rdi movl $0x1, %esi movl $0x1, %edx callq 0x66f8 movq %rbx, %rdi callq 0x663a leal -0x2(%rax), %esi leaq 0x88e(%rip), %r9 # 0x23c34 movq %rbx, %rdi movl $0xffffffff, %edx # imm = 0xFFFFFFFF xorl...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_print
static int luaB_print (lua_State *L) { int n = lua_gettop(L); /* number of arguments */ int i; for (i = 1; i <= n; i++) { /* for each argument */ size_t l; const char *s = luaL_tolstring(L, i, &l); /* convert it to string */ if (i > 1) /* not the first element? */ lua_writestring("\t", 1); ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx callq 0x663a testl %eax, %eax jle 0x2344c movl %eax, %r14d negl %r14d movl $0x1, %r12d movq %rsp, %r15 movq 0x16bc6(%rip), %rbp # 0x39fb8 movq %rbx, %rdi movl %r12d, %esi movq %r15, %rdx callq 0x97a7 movq %rax, %r13 cmpl $0...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_warn
static int luaB_warn (lua_State *L) { int n = lua_gettop(L); /* number of arguments */ int i; luaL_checkstring(L, 1); /* at least one argument */ for (i = 2; i <= n; i++) luaL_checkstring(L, i); /* make sure all arguments are strings */ for (i = 1; i < n; i++) /* compose warning */ lua_warning(L, ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx callq 0x663a movl %eax, %ebp movq %rbx, %rdi movl $0x1, %esi xorl %edx, %edx callq 0x8dfc cmpl $0x2, %ebp jl 0x234ca movl %ebp, %r15d negl %r15d movl $0x2, %r14d movq %rbx, %rdi movl %r14d, %esi xorl %edx, %edx callq 0x8dfc leal (%r15,%r14), %eax in...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_rawset
static int luaB_rawset (lua_State *L) { luaL_checktype(L, 1, LUA_TTABLE); luaL_checkany(L, 2); luaL_checkany(L, 3); lua_settop(L, 3); lua_rawset(L, 1); return 1; }
pushq %rbx movq %rdi, %rbx movl $0x1, %esi movl $0x5, %edx callq 0x8e50 movq %rbx, %rdi movl $0x2, %esi callq 0x8e84 movq %rbx, %rdi movl $0x3, %esi callq 0x8e84 movq %rbx, %rdi movl $0x3, %esi callq 0x664e movq %rbx, %rdi movl $0x1, %esi callq 0x76e4 movl $0x1, %eax popq %rbx retq
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_select
static int luaB_select (lua_State *L) { int n = lua_gettop(L); if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') { lua_pushinteger(L, n-1); return 1; } else { lua_Integer i = luaL_checkinteger(L, 1); if (i < 0) i = n + i; else if (i > n) i = n; luaL_argcheck(L, 1 <= i, 1, ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 callq 0x663a movl %eax, %ebx movq %r14, %rdi movl $0x1, %esi callq 0x68d4 cmpl $0x4, %eax jne 0x23683 movl $0x1, %ebp movq %r14, %rdi movl $0x1, %esi xorl %edx, %edx callq 0x6bb8 cmpb $0x23, (%rax) jne 0x23683 decl %ebx movslq %ebx, %rsi movq %r14, ...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_setmetatable
static int luaB_setmetatable (lua_State *L) { int t = lua_type(L, 2); luaL_checktype(L, 1, LUA_TTABLE); luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table"); if (l_unlikely(luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL)) return luaL_error(L, "cannot change a protected metatable"); ...
pushq %rbp pushq %rbx pushq %rax movq %rdi, %rbx movl $0x2, %esi callq 0x68d4 movl %eax, %ebp movq %rbx, %rdi movl $0x1, %esi movl $0x5, %edx callq 0x8e50 testl %ebp, %ebp je 0x23713 cmpl $0x5, %ebp je 0x23713 leaq 0x820e(%rip), %rdx # 0x2b914 movq %rbx, %rdi movl $0x2, %esi callq 0x8975 leaq 0x817c(%rip), %rdx ...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_tonumber
static int luaB_tonumber (lua_State *L) { if (lua_isnoneornil(L, 2)) { /* standard conversion? */ if (lua_type(L, 1) == LUA_TNUMBER) { /* already a number? */ lua_settop(L, 1); /* yes; return it */ return 1; } else { size_t l; const char *s = lua_tolstring(L, 1, &l); if (s...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx movl $0x2, %esi callq 0x68d4 movq %rbx, %rdi testl %eax, %eax jle 0x238a4 movl $0x2, %esi callq 0x8f2d movq %rax, %r15 movq %rbx, %rdi movl $0x1, %esi movl $0x4, %edx callq 0x8e50 leaq 0x8(%rsp), %rdx movq %rbx, %rdi movl...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaB_xpcall
static int luaB_xpcall (lua_State *L) { int status; int n = lua_gettop(L); luaL_checktype(L, 2, LUA_TFUNCTION); /* check error function */ lua_pushboolean(L, 1); /* first result */ lua_pushvalue(L, 1); /* function */ lua_rotate(L, 3, 2); /* move them below function's arguments */ status = lua_pcallk(L...
pushq %rbp pushq %rbx pushq %rax movq %rdi, %rbx callq 0x663a movl %eax, %ebp movq %rbx, %rdi movl $0x2, %esi movl $0x6, %edx callq 0x8e50 movq %rbx, %rdi movl $0x1, %esi callq 0x704c movq %rbx, %rdi movl $0x1, %esi callq 0x68aa movq %rbx, %rdi movl $0x3, %esi movl $0x2, %edx callq 0x66f8 addl $-0x2, %ebp leaq 0x211(%r...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
pushmode
static int pushmode (lua_State *L, int oldmode) { if (oldmode == -1) luaL_pushfail(L); /* invalid call to 'lua_gc' */ else lua_pushstring(L, (oldmode == LUA_GCINC) ? "incremental" : "generational"); return 1; }
cmpl $-0x1, %esi je 0x23a71 cmpl $0x8, %esi leaq 0x7ded(%rip), %rax # 0x2b84e leaq 0x7dd9(%rip), %rsi # 0x2b841 cmoveq %rax, %rsi jmp 0x6e5b jmp 0x6d71
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
generic_reader
static const char *generic_reader (lua_State *L, void *ud, size_t *size) { (void)(ud); /* not used */ luaL_checkstack(L, 2, "too many nested functions"); lua_pushvalue(L, 1); /* get function */ lua_call(L, 0, 1); /* call it */ if (lua_isnil(L, -1)) { lua_pop(L, 1); /* pop result */ *size = 0; ...
pushq %r14 pushq %rbx pushq %rax movq %rdx, %rbx movq %rdi, %r14 leaq 0x7d30(%rip), %rdx # 0x2b8aa movl $0x2, %esi callq 0x8e28 movq %r14, %rdi movl $0x1, %esi callq 0x68aa movq %r14, %rdi xorl %esi, %esi movl $0x1, %edx xorl %ecx, %ecx xorl %r8d, %r8d callq 0x78e1 movq %r14, %rdi movl $0xffffffff, %esi # im...
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
finishpcall
static int finishpcall (lua_State *L, int status, lua_KContext extra) { if (l_unlikely(status != LUA_OK && status != LUA_YIELD)) { /* error? */ lua_pushboolean(L, 0); /* first result (false) */ lua_pushvalue(L, -2); /* error message */ return 2; /* return false, msg */ } else return lua_gettop...
pushq %rbx cmpl $0x2, %esi jae 0x23c46 movq %rdx, %rbx callq 0x663a subl %ebx, %eax popq %rbx retq callq 0x5bac movl $0x2, %eax jmp 0x23c44 nop
/mmanyen[P]CLua/build_O1/_deps/lua/lbaselib.c
luaK_exp2const
int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v) { if (hasjumps(e)) return 0; /* not a constant */ switch (e->k) { case VFALSE: setbfvalue(v); return 1; case VTRUE: setbtvalue(v); return 1; case VNIL: setnilvalue(v); return 1; case VKSTR: { ...
movl 0x10(%rsi), %ecx xorl %eax, %eax cmpl 0x14(%rsi), %ecx jne 0x23cd2 movl (%rsi), %eax decl %eax cmpl $0xa, %eax ja 0x23c8a leaq 0x7ce5(%rip), %rcx # 0x2b960 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax movb $0x0, 0x8(%rdx) jmp 0x23ccd movq %rsi, %rdi movq %rdx, %rsi jmp 0x23cd3 movb $0x1, 0x8(%rdx) jm...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
tonumeral
static int tonumeral (const expdesc *e, TValue *v) { if (hasjumps(e)) return 0; /* not a numeral */ switch (e->k) { case VKINT: if (v) setivalue(v, e->u.ival); return 1; case VKFLT: if (v) setfltvalue(v, e->u.nval); return 1; default: return 0; } }
movl 0x10(%rdi), %ecx xorl %eax, %eax cmpl 0x14(%rdi), %ecx jne 0x23d05 movl (%rdi), %ecx cmpl $0x5, %ecx je 0x23ced cmpl $0x6, %ecx jne 0x23d05 movb $0x3, %al jmp 0x23cef movb $0x13, %al testq %rsi, %rsi je 0x23d00 movsd 0x8(%rdi), %xmm0 movsd %xmm0, (%rsi) movb %al, 0x8(%rsi) movl $0x1, %eax retq
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_nil
void luaK_nil (FuncState *fs, int from, int n) { int l = from + n - 1; /* last register to set nil */ Instruction *previous = previousinstruction(fs); if (GET_OPCODE(*previous) == OP_LOADNIL) { /* previous is LOADNIL? */ int pfrom = GETARG_A(*previous); /* get previous range */ int pl = pfrom + GETARG_...
movslq 0x28(%rdi), %rax cmpl 0x2c(%rdi), %eax jle 0x23d20 movq (%rdi), %rcx movq 0x40(%rcx), %rcx leaq (%rcx,%rax,4), %rax addq $-0x4, %rax jmp 0x23d27 leaq 0x7e61(%rip), %rax # 0x2bb88 movl (%rax), %ecx movl %ecx, %r8d andl $0x7f, %r8d cmpl $0x8, %r8d jne 0x23dcd pushq %rbx leal (%rdx,%rsi), %r9d movl %ecx, %r10d...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_concat
void luaK_concat (FuncState *fs, int *l1, int l2) { if (l2 == NO_JUMP) return; /* nothing to concatenate? */ else if (*l1 == NO_JUMP) /* no original list? */ *l1 = l2; /* 'l1' points to 'l2' */ else { int list = *l1; int next; while ((next = getjump(fs, list)) != NO_JUMP) /* find last element ...
cmpl $-0x1, %edx je 0x23e41 movl (%rsi), %ecx cmpl $-0x1, %ecx je 0x23e3f movq (%rdi), %rax movq 0x40(%rax), %rax movl %ecx, %esi movslq %ecx, %rcx movl (%rax,%rcx,4), %r8d shrl $0x7, %r8d leal -0xffffff(%r8), %r9d cmpl $-0x1, %r9d leal -0xfffffe(%rcx,%r8), %ecx cmovel %r9d, %ecx cmpl $-0x1, %ecx jne 0x23e14 jmp 0x23e4...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
fixjump
static void fixjump (FuncState *fs, int pc, int dest) { Instruction *jmp = &fs->f->code[pc]; int offset = dest - (pc + 1); lua_assert(dest != NO_JUMP); if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) luaX_syntaxerror(fs->ls, "control structure too long"); lua_assert(GET_OPCODE(*jmp) == OP_...
movl %esi, %eax notl %eax leal (%rax,%rdx), %ecx addl $0xffffff, %ecx # imm = 0xFFFFFF cmpl $0x2000000, %ecx # imm = 0x2000000 jae 0x23e77 addl %edx, %eax movq (%rdi), %rcx movq 0x40(%rcx), %rcx movslq %esi, %rdx movl (%rcx,%rdx,4), %esi andl $0x7f, %esi shll $0x7, %eax addl %esi, %eax addl $0x7fffff80, ...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_ret
void luaK_ret (FuncState *fs, int first, int nret) { OpCode op; switch (nret) { case 0: op = OP_RETURN0; break; case 1: op = OP_RETURN1; break; default: op = OP_RETURN; break; } luaY_checklimit(fs, nret + 1, MAXARG_B, "returns"); luaK_codeABC(fs, op, first, nret + 1, 0); }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movl %esi, %ebx movq %rdi, %r14 xorl %eax, %eax cmpl $0x1, %edx sete %al leal 0x46(,%rax,2), %eax testl %edx, %edx movl $0x47, %r15d cmovnel %eax, %r15d leal 0x1(%rdx), %ebp leaq 0x7c8d(%rip), %rcx # 0x2bb50 movl %ebp, %esi movl $0xff, %edx callq 0x137b0 shll ...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
patchlistaux
static void patchlistaux (FuncState *fs, int list, int vtarget, int reg, int dtarget) { while (list != NO_JUMP) { int next = getjump(fs, list); if (patchtestreg(fs, list, reg)) fixjump(fs, list, vtarget); else fixjump(fs, list, dtarget); /* jump to default target */ ...
cmpl $-0x1, %esi je 0x23f77 pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %r8d, %ebx movl %ecx, %ebp movl %edx, %r14d movl %esi, %r12d movq %rdi, %r15 movq (%r15), %rax movq 0x40(%rax), %rax movslq %r12d, %r13 movl (%rax,%r13,4), %eax shrl $0x7, %eax leal -0xffffff(%rax), %ecx cmpl $...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_code
int luaK_code (FuncState *fs, Instruction i) { Proto *f = fs->f; /* put new instruction in code array */ luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction, INT_MAX, "opcodes"); f->code[fs->pc++] = i; savelineinfo(fs, f, fs->ls->lastline); return fs->pc - 1; /* index of ...
pushq %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movl %esi, %ebp movq %rdi, %rbx movq (%rdi), %r14 movq 0x10(%rdi), %rax movq 0x38(%rax), %rdi movq 0x40(%r14), %rsi movl 0x28(%rbx), %edx leaq 0x18(%r14), %rcx leaq 0x7ba3(%rip), %rax # 0x2bb58 movq %rax, (%rsp) movl $0x4, %r8d movl $0x7fffffff, %r9d # imm = ...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
savelineinfo
static void savelineinfo (FuncState *fs, Proto *f, int line) { int linedif = line - fs->previousline; int pc = fs->pc - 1; /* last instruction coded */ if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) { luaM_growvector(fs->ls->L, f->abslineinfo, fs->nabslineinfo, f->sizeabs...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp movl %edx, %ebx movq %rdi, %r14 movl %edx, %ebp subl 0x30(%rdi), %ebp movq %rsi, %r12 movslq 0x28(%rdi), %r15 decq %r15 movl %ebp, %eax negl %eax cmovsl %ebp, %eax cmpl $0x7f, %eax ja 0x24036 movb 0x4d(%r14), %al leal 0x1(%rax), %ecx movb %cl, 0x4d...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_int
void luaK_int (FuncState *fs, int reg, lua_Integer i) { if (fitsBx(i)) codeAsBx(fs, OP_LOADI, reg, cast_int(i)); else luaK_codek(fs, reg, luaK_intK(fs, i)); }
pushq %rbp pushq %rbx subq $0x18, %rsp movl %esi, %ebp movq %rdi, %rbx leaq -0x10001(%rdx), %rax cmpq $-0x20000, %rax # imm = 0xFFFE0000 jae 0x24199 leaq 0x8(%rsp), %rsi movq %rdx, (%rsi) movb $0x3, 0x8(%rsi) movq %rbx, %rdi movq %rsi, %rdx callq 0x25ba6 movq %rbx, %rdi movl %ebp, %esi movl %eax, %edx callq 0x2...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_codek
static int luaK_codek (FuncState *fs, int reg, int k) { if (k <= MAXARG_Bx) return luaK_codeABx(fs, OP_LOADK, reg, k); else { int p = luaK_codeABx(fs, OP_LOADKX, reg, 0); codeextraarg(fs, k); return p; } }
pushq %rbp pushq %rbx pushq %rax movl %edx, %ebp movq %rdi, %rbx shll $0x7, %esi cmpl $0x1ffff, %edx # imm = 0x1FFFF jg 0x241d6 shll $0xf, %ebp orl %ebp, %esi orl $0x3, %esi jmp 0x241e9 orl $0x4, %esi movq %rbx, %rdi callq 0x23f8b shll $0x7, %ebp orl $0x52, %ebp movl %ebp, %esi movq %rbx, %rdi addq $0x8, %rsp ...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_setreturns
void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) { Instruction *pc = &getinstruction(fs, e); luaY_checklimit(fs, nresults + 1, MAXARG_C, "multiple results"); if (e->k == VCALL) /* expression is an open function call? */ SETARG_C(*pc, nresults + 1); else { lua_assert(e->k == VVARARG); ...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movl %edx, %ebp movq %rsi, %r14 movq %rdi, %rbx movq (%rdi), %rax movq 0x40(%rax), %r15 movslq 0x8(%rsi), %r12 incl %ebp leaq 0x794f(%rip), %rcx # 0x2bb6a movl %ebp, %esi movl $0xff, %edx callq 0x137b0 movl $0xffffff, %eax # imm = 0xFFFFFF andl (%r15,%...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_setoneret
void luaK_setoneret (FuncState *fs, expdesc *e) { if (e->k == VCALL) { /* expression is an open function call? */ /* already returns 1 value */ lua_assert(GETARG_C(getinstruction(fs, e)) == 2); e->k = VNONRELOC; /* result has fixed position */ e->u.info = GETARG_A(getinstruction(fs, e)); } else ...
movl (%rsi), %eax cmpl $0x13, %eax je 0x24295 cmpl $0x12, %eax jne 0x242ab movl $0x8, (%rsi) movq (%rdi), %rax movq 0x40(%rax), %rax movslq 0x8(%rsi), %rcx movl (%rax,%rcx,4), %eax shrl $0x7, %eax movzbl %al, %eax movl %eax, 0x8(%rsi) retq movq (%rdi), %rax movq 0x40(%rax), %rax movslq 0x8(%rsi), %rcx movb $0x2, 0x3(%r...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_dischargevars
void luaK_dischargevars (FuncState *fs, expdesc *e) { switch (e->k) { case VCONST: { const2exp(const2val(fs, e), e); break; } case VLOCAL: { /* already in a register */ int temp = e->u.var.ridx; e->u.info = temp; /* (can't do a direct assignment; values overlap) */ e->k = V...
pushq %rbp pushq %r14 pushq %rbx movl (%rsi), %eax addl $-0x9, %eax cmpl $0xa, %eax ja 0x243e7 movq %rsi, %rbx movq %rdi, %r14 leaq 0x76c1(%rip), %rcx # 0x2b98c movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax movq %r14, %rdi movq %rbx, %rsi popq %rbx popq %r14 popq %rbp jmp 0x2426b movq 0x10(%r14), %rax movq...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_exp2nextreg
void luaK_exp2nextreg (FuncState *fs, expdesc *e) { luaK_dischargevars(fs, e); freeexp(fs, e); luaK_reserveregs(fs, 1); exp2reg(fs, e, fs->freereg - 1); }
pushq %rbp pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 callq 0x242ac cmpl $0x8, (%rbx) jne 0x244ae movl 0x8(%rbx), %ebp movq %r14, %rdi callq 0x13820 movzbl %al, %eax cmpl %eax, %ebp jl 0x244ae decb 0x4c(%r14) movq %r14, %rdi movl $0x1, %esi callq 0x24102 movb 0x4c(%r14), %al incb %al movb %al, 0x4c(%r14) mov...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
exp2reg
static void exp2reg (FuncState *fs, expdesc *e, int reg) { discharge2reg(fs, e, reg); if (e->k == VJMP) /* expression itself is a test? */ luaK_concat(fs, &e->t, e->u.info); /* put this jump in 't' list */ if (hasjumps(e)) { int final; /* position after whole expression */ int p_f = NO_JUMP; /* po...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %edx, %ebp movq %rsi, %rbx movq %rdi, %r14 callq 0x25cde cmpl $0x10, (%rbx) jne 0x24502 leaq 0x10(%rbx), %rsi movl 0x8(%rbx), %edx movq %r14, %rdi callq 0x23e01 movl 0x10(%rbx), %esi movl 0x14(%rbx), %r15d cmpl %r15d, %esi je 0x245ce movq...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
jumponcond
static int jumponcond (FuncState *fs, expdesc *e, int cond) { if (e->k == VRELOC) { Instruction ie = getinstruction(fs, e); if (GET_OPCODE(ie) == OP_NOT) { removelastinstruction(fs); /* remove previous OP_NOT */ return condjump(fs, OP_TEST, GETARG_B(ie), 0, 0, !cond); } /* else go through...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movl %edx, %ebp movq %rsi, %r14 movq %rdi, %rbx cmpl $0x11, (%rsi) jne 0x24956 movq (%rbx), %rdx movq 0x40(%rdx), %rax movslq 0x8(%r14), %rcx movl (%rax,%rcx,4), %ecx movl %ecx, %r15d andl $0x7f, %r15d cmpl $0x33, %r15d jne 0x24945 movslq 0x28(%rbx), %rax movq 0x58...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_goiffalse
void luaK_goiffalse (FuncState *fs, expdesc *e) { int pc; /* pc of new jump */ luaK_dischargevars(fs, e); switch (e->k) { case VJMP: { pc = e->u.info; /* already jump if true */ break; } case VNIL: case VFALSE: { pc = NO_JUMP; /* always false; do nothing */ break; } ...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 callq 0x242ac movl (%rbx), %eax movl $0xffffffff, %edx # imm = 0xFFFFFFFF cmpl $0x1, %eax je 0x249ed cmpl $0x3, %eax je 0x249ed cmpl $0x10, %eax jne 0x249db movl 0x8(%rbx), %edx jmp 0x249ed movq %r14, %rdi movq %rbx, %rsi movl $0x1, %edx callq 0x248...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_self
void luaK_self (FuncState *fs, expdesc *e, expdesc *key) { int ereg, base; luaK_exp2anyreg(fs, e); ereg = e->u.info; /* register where 'e' (the receiver) was placed */ freeexp(fs, e); base = e->u.info = fs->freereg; /* base register for op_self */ e->k = VNONRELOC; /* self expression has a fixed register...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %rbx callq 0x245fc movl 0x8(%r15), %r12d cmpl $0x8, (%r15) jne 0x24a59 movq %rbx, %rdi callq 0x13820 movzbl %al, %eax cmpl %eax, %r12d jl 0x24a59 decb 0x4c(%rbx) movzbl 0x4c(%rbx), %r13d movl %r13d, 0...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_exp2K
static int luaK_exp2K (FuncState *fs, expdesc *e) { if (!hasjumps(e)) { int info; switch (e->k) { /* move constants to 'k' */ case VTRUE: info = boolT(fs); break; case VFALSE: info = boolF(fs); break; case VNIL: info = nilK(fs); break; case VKINT: info = luaK_intK(fs, e->u.ival); brea...
movl 0x10(%rsi), %eax cmpl 0x14(%rsi), %eax jne 0x24bd1 pushq %rbx subq $0x20, %rsp movq %rsi, %rbx movl (%rsi), %eax decl %eax cmpl $0x6, %eax ja 0x24b75 leaq 0x6eaf(%rip), %rcx # 0x2b9e8 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax leaq 0x10(%rsp), %rdx movb $0x0, 0x8(%rdx) movq 0x20(%rdi), %rax movq %r...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_indexed
void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) { if (k->k == VKSTR) str2K(fs, k); lua_assert(!hasjumps(t) && (t->k == VLOCAL || t->k == VNONRELOC || t->k == VUPVAL)); if (t->k == VUPVAL && !isKstr(fs, k)) /* upvalue indexed by non 'Kstr'? */ luaK_exp2anyreg(fs, t); /* put it in a...
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdx, %r14 movq %rsi, %rbx movq %rdi, %r15 cmpl $0x7, (%rdx) jne 0x24c13 movq 0x8(%r14), %rax movq %rsp, %rdx movq %rax, (%rdx) movb 0x8(%rax), %al orb $0x40, %al movb %al, 0x8(%rdx) movq %r15, %rdi movq %rdx, %rsi callq 0x25ba6 movl %eax, 0x8(%r14) movl $0x4, (%r1...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_prefix
void luaK_prefix (FuncState *fs, UnOpr opr, expdesc *e, int line) { static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP}; luaK_dischargevars(fs, e); switch (opr) { case OPR_MINUS: case OPR_BNOT: /* use 'ef' as fake 2nd operand */ if (constfolding(fs, cast_int(opr + LUA_OPUNM), e, &ef)) brea...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %ecx, %ebp movq %rdx, %r14 movl %esi, %r15d movq %rdi, %rbx movq %rdx, %rsi callq 0x242ac cmpl $0x2, %r15d jb 0x24d9c je 0x24dc5 cmpl $0x3, %r15d jne 0x24db6 addl $0x31, %r15d movq %rbx, %rdi movq %r14, %rsi callq 0x245fc movl %eax, %r12d...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
constfolding
static int constfolding (FuncState *fs, int op, expdesc *e1, const expdesc *e2) { TValue v1, v2, res; if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2)) return 0; /* non-numeric operands or not safe to fold */ luaO_rawarith(fs->ls->L, op, &v1, &v...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x30, %rsp movl 0x10(%rdx), %eax xorl %ebx, %ebx cmpl 0x14(%rdx), %eax jne 0x24ff7 movq %rdx, %r14 movl %esi, %ebp movq %rdi, %r15 movl (%rdx), %eax cmpl $0x6, %eax je 0x24ed9 cmpl $0x5, %eax jne 0x24ff7 movb $0x13, %al jmp 0x24edb movb $0x3, %al movsd 0x8(%r...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_infix
void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) { luaK_dischargevars(fs, v); switch (op) { case OPR_AND: { luaK_goiftrue(fs, v); /* go ahead only if 'v' is true */ break; } case OPR_OR: { luaK_goiffalse(fs, v); /* go ahead only if 'v' is false */ break; } case OP...
pushq %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdx, %rbx movl %esi, %ebp movq %rdi, %r14 movq %rdx, %rsi callq 0x242ac cmpl $0x14, %ebp ja 0x2509f movl %ebp, %eax leaq 0x6a1c(%rip), %rcx # 0x2ba48 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax movl 0x10(%rbx), %eax cmpl 0x14(%rbx), %eax jne 0x25047...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_posfix
void luaK_posfix (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2, int line) { luaK_dischargevars(fs, e2); if (foldbinop(opr) && constfolding(fs, cast_int(opr + LUA_OPADD), e1, e2)) return; /* done by folding */ switch (opr) { case OPR_AND: { lua_assert(e1->t == NO_JUMP); /* ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movl %r8d, %r13d movq %rcx, %r15 movq %rdx, %rbx movl %esi, %r12d movq %rdi, %r14 movq %rcx, %rsi callq 0x242ac cmpl $0xb, %r12d ja 0x251d5 movq %r14, %rdi movl %r12d, %esi movq %rbx, %rdx movq %r15, %rcx callq 0x24ea3 testl %eax, %eax j...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
finishbinexpneg
static int finishbinexpneg (FuncState *fs, expdesc *e1, expdesc *e2, OpCode op, int line, TMS event) { if (!isKint(e2)) return 0; /* not an integer constant */ else { lua_Integer i2 = e2->u.ival; if (!(fitsC(i2) && fitsC(-i2))) return 0; /* not in the proper range */...
xorl %eax, %eax cmpl $0x6, (%rdx) jne 0x25851 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movl 0x10(%rdx), %edi cmpl 0x14(%rdx), %edi jne 0x2584a movq 0x8(%rdx), %r14 leaq -0x80(%r14), %rdi cmpq $-0xff, %rdi jb 0x2584a movl %r9d, %r10d movl %r8d, %r11d movl $0x7f, %r8d subl %r14d, %r8d subq $0x8, %rsp movq %rbx, %...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
codearith
static void codearith (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2, int flip, int line) { if (tonumeral(e2, NULL) && luaK_exp2K(fs, e2)) /* K operand? */ codebinK(fs, opr, e1, e2, flip, line); else /* 'e2' is neither an immediate nor a K operand */ codebinNoK(fs, opr, e1, e2...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %r9d, %ebx movl %r8d, %ebp movq %rcx, %r14 movq %rdx, %r15 movl %esi, %r12d movq %rdi, %r13 movl 0x10(%rcx), %eax cmpl 0x14(%rcx), %eax jne 0x258c9 movl (%r14), %eax addl $-0x7, %eax cmpl $-0x2, %eax jb 0x258c9 movq %r13, %rdi movq %r14, ...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
codebinexpval
static void codebinexpval (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2, int line) { OpCode op = binopr2op(opr, OPR_ADD, OP_ADD); int v2 = luaK_exp2anyreg(fs, e2); /* make sure 'e2' is in a register */ /* 'e1' must be already in a register or it is a constant */ lua_assert((VN...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movl %r8d, %ebx movq %rcx, %r14 movq %rdx, %r15 movl %esi, %r12d movq %rdi, %r13 leal 0x22(%r12), %ebp movq %rcx, %rsi callq 0x245fc addl $0x6, %r12d subq $0x8, %rsp movq %r13, %rdi movq %r15, %rsi movq %r14, %rdx movl %ebp, %ecx movl %eax, %r...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_fixline
void luaK_fixline (FuncState *fs, int line) { removelastlineinfo(fs); savelineinfo(fs, fs->f, line); }
movl %esi, %edx movq (%rdi), %rsi movslq 0x28(%rdi), %rax movq 0x58(%rsi), %rcx movsbl -0x1(%rcx,%rax), %eax cmpl $-0x80, %eax jne 0x2596a decl 0x3c(%rdi) movb $-0x7f, 0x4d(%rdi) jmp 0x23ffb subl %eax, 0x30(%rdi) decb 0x4d(%rdi) jmp 0x23ffb
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_settablesize
void luaK_settablesize (FuncState *fs, int pc, int ra, int asize, int hsize) { Instruction *inst = &fs->f->code[pc]; int extra = asize / (MAXARG_vC + 1); /* higher bits of array size */ int rc = asize % (MAXARG_vC + 1); /* lower bits of array size */ int k = (extra > 0); /* true iff needs extra argument */ ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movl %ecx, %ebx movl %edx, %ebp movl %esi, %r14d movq (%rdi), %rax movq 0x40(%rax), %r15 testl %r8d, %r8d je 0x259a4 movl %r8d, %edi callq 0x12114 movzbl %al, %eax shll $0x10, %eax addl $0x10000, %eax # imm = 0x10000 jmp 0x259a6 xorl %eax, %eax xorl %ecx, ...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_setlist
void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) { lua_assert(tostore != 0); if (tostore == LUA_MULTRET) tostore = 0; if (nelems <= MAXARG_vC) luaK_codevABCk(fs, OP_SETLIST, base, tostore, nelems, 0); else { int extra = nelems / (MAXARG_vC + 1); nelems %= (MAXARG_vC + 1); ...
pushq %rbp pushq %r14 pushq %rbx movl %edx, %ebp movl %esi, %ebx movq %rdi, %r14 movl %ecx, %eax shll $0x10, %eax movl %esi, %edx shll $0x7, %edx xorl %edi, %edi cmpl $-0x1, %ecx cmovnel %eax, %edi movl %ebp, %esi shll $0x16, %esi orl %edx, %esi orl %edi, %esi cmpl $0x3ff, %ebp # imm = 0x3FF jg 0x25a21 orl $...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_finish
void luaK_finish (FuncState *fs) { int i; Proto *p = fs->f; for (i = 0; i < fs->pc; i++) { Instruction *pc = &p->code[i]; /* avoid "not used" warnings when assert is off (for 'onelua.c') */ (void)luaP_isOT; (void)luaP_isIT; lua_assert(i == 0 || luaP_isOT(*(pc - 1)) == luaP_isIT(*pc)); switch (...
cmpl $0x0, 0x28(%rdi) jle 0x25b2e pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx movq (%rdi), %r15 xorl %r12d, %r12d xorl %r14d, %r14d movq 0x40(%r15), %rax movl (%rax,%r14,4), %ecx movl %ecx, %edx andl $0x7f, %edx leal -0x45(%rdx), %esi cmpl $0x2, %esi jb 0x25aa2 leal -0x47(%rdx), %esi cmpl $0x...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
patchtestreg
static int patchtestreg (FuncState *fs, int node, int reg) { Instruction *i = getjumpcontrol(fs, node); if (GET_OPCODE(*i) != OP_TESTSET) return 0; /* cannot patch other instructions */ if (reg != NO_REG && reg != GETARG_B(*i)) SETARG_A(*i, reg); else { /* no register to put value or register alre...
movq (%rdi), %rax movslq %esi, %rsi leaq (,%rsi,4), %rcx addq 0x40(%rax), %rcx testl %esi, %esi jle 0x25b5c movl -0x4(%rcx), %eax andl $0x7f, %eax leaq 0x488e(%rip), %rsi # 0x2a3e0 testb $0x10, (%rax,%rsi) je 0x25b5c addq $-0x4, %rcx movl (%rcx), %esi movl %esi, %edi andl $0x7f, %edi xorl %eax, %eax cmpl $0x43, %e...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
k2proto
static int k2proto (FuncState *fs, TValue *key, TValue *v) { TValue val; Proto *f = fs->f; int tag = luaH_get(fs->kcache, key, &val); /* query scanner table */ int k; if (!tagisempty(tag)) { /* is there an index there? */ k = cast_int(ivalue(&val)); /* collisions can happen only for float keys */ ...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r14 movq (%rdi), %r12 movq 0x20(%rdi), %rdi movq %rsp, %rdx callq 0x1afe1 testb $0xf, %al je 0x25bd3 movl (%rsp), %ebp jmp 0x25c03 movq %r14, %rdi movq %r12, %rsi movq %r15, %rdx callq 0x25c12 movl %eax, ...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
addk
static int addk (FuncState *fs, Proto *f, TValue *v) { lua_State *L = fs->ls->L; int oldsize = f->sizek; int k = fs->nk; luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants"); while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]); setobj(L, &f->k[k], v); fs->nk++; luaC_barrier(L, ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdx, %r15 movq %rsi, %rbx movq %rdi, %r12 movq 0x10(%rdi), %rax movq 0x38(%rax), %rdi leaq 0x14(%rsi), %rcx movslq 0x14(%rsi), %r14 movl 0x34(%r12), %ebp movslq %ebp, %r13 movq 0x38(%rsi), %rsi leaq 0x5f2f(%rip), %rax # 0x2bb7...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
need_value
static int need_value (FuncState *fs, int list) { for (; list != NO_JUMP; list = getjump(fs, list)) { Instruction i = *getjumpcontrol(fs, list); if (GET_OPCODE(i) != OP_TESTSET) return 1; } return 0; /* not found */ }
xorl %eax, %eax cmpl $-0x1, %esi je 0x25e95 movq (%rdi), %rcx movq 0x40(%rcx), %rcx leaq 0x459c(%rip), %rdx # 0x2a3e0 movslq %esi, %r8 leaq (%rcx,%r8,4), %rdi testl %r8d, %r8d jle 0x25e5f movl -0x4(%rdi), %r8d andl $0x7f, %r8d testb $0x10, (%r8,%rdx) jne 0x25e64 movq %rdi, %r8 jmp 0x25e68 leaq -0x4(%rdi), %r8 movl...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaK_numberK
static int luaK_numberK (FuncState *fs, lua_Number r) { TValue o, kv; setfltvalue(&o, r); /* value as a TValue */ if (r == 0) { /* handle zero as a special case */ setpvalue(&kv, fs); /* use FuncState as index */ return k2proto(fs, &kv, &o); /* cannot collide */ } else { const int nbm = l_floa...
pushq %rbp pushq %r14 pushq %rbx subq $0x30, %rsp movapd %xmm0, %xmm1 movq %rdi, %rbx movsd %xmm0, (%rsp) movb $0x13, 0x8(%rsp) xorpd %xmm0, %xmm0 ucomisd %xmm0, %xmm1 jne 0x25eda jp 0x25eda leaq 0x18(%rsp), %rsi movq %rbx, (%rsi) movb $0x2, 0x8(%rsi) movq %rsp, %rdx movq %rbx, %rdi callq 0x25ba6 jmp 0x25f29 movsd 0x3f...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
finishbinexpval
static void finishbinexpval (FuncState *fs, expdesc *e1, expdesc *e2, OpCode op, int v2, int flip, int line, OpCode mmop, TMS event) { int v1 = luaK_exp2anyreg(fs, e1); int pc = luaK_codeABCk(fs, op, 0, v1, v2, 0); freeexps(fs, e1, e2); e1->u.info = pc; ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %r9d, %ebx movl %r8d, %r15d movl %ecx, %ebp movq %rdx, 0x10(%rsp) movq %rsi, %r13 movq %rdi, %r14 movl 0x60(%rsp), %eax movl %eax, 0x8(%rsp) movl 0x58(%rsp), %eax movl %eax, 0x4(%rsp) movl 0x50(%rsp), %eax movl %eax, 0xc(%rsp) callq...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
codebinNoK
static void codebinNoK (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2, int flip, int line) { if (flip) swapexps(e1, e2); /* back to original order */ codebinexpval(fs, opr, e1, e2, line); /* use standard operators */ }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %r9d, %ebx movq %rcx, %r15 movq %rdx, %r12 movl %esi, %r14d movq %rdi, %r13 testl %r8d, %r8d je 0x26123 movq 0x10(%r12), %rax movq %rax, 0x10(%rsp) movups (%r12), %xmm0 movaps %xmm0, (%rsp) movq 0x10(%r15), %rax movq %rax, 0x10(%r12...
/mmanyen[P]CLua/build_O1/_deps/lua/lcode.c
luaB_cocreate
static int luaB_cocreate (lua_State *L) { lua_State *NL; luaL_checktype(L, 1, LUA_TFUNCTION); NL = lua_newthread(L); lua_pushvalue(L, 1); /* move function to top */ lua_xmove(L, NL, 1); /* move function from L to NL */ return 1; }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movl $0x1, %esi movl $0x6, %edx callq 0x8e50 movq %rbx, %rdi callq 0x16746 movq %rax, %r14 movq %rbx, %rdi movl $0x1, %esi callq 0x68aa movq %rbx, %rdi movq %r14, %rsi movl $0x1, %edx callq 0x65b7 movl $0x1, %eax addq $0x8, %rsp popq %rbx popq %r14 retq
/mmanyen[P]CLua/build_O1/_deps/lua/lcorolib.c
luaB_coresume
static int luaB_coresume (lua_State *L) { lua_State *co = getco(L); int r; r = auxresume(L, co, lua_gettop(L) - 1); if (l_unlikely(r < 0)) { lua_pushboolean(L, 0); lua_insert(L, -2); return 2; /* return false + error message */ } else { lua_pushboolean(L, 1); lua_insert(L, -(r + 1)); ...
pushq %rbp pushq %r14 pushq %rbx movq %rdi, %rbx callq 0x263a4 movq %rax, %r14 movq %rbx, %rdi callq 0x663a leal -0x1(%rax), %edx movq %rbx, %rdi movq %r14, %rsi callq 0x263de testl %eax, %eax js 0x26243 movl %eax, %r14d movq %rbx, %rdi movl $0x1, %esi callq 0x704c leal 0x1(%r14), %ebp notl %r14d movq %rbx, %rdi movl %...
/mmanyen[P]CLua/build_O1/_deps/lua/lcorolib.c
auxstatus
static int auxstatus (lua_State *L, lua_State *co) { if (L == co) return COS_RUN; else { switch (lua_status(co)) { case LUA_YIELD: return COS_YIELD; case LUA_OK: { lua_Debug ar; if (lua_getstack(co, 0, &ar)) /* does it have frames? */ return COS_NORM; /* it is run...
cmpq %rsi, %rdi je 0x264d9 pushq %rbx subq $0x90, %rsp movq %rsi, %rbx movq %rsi, %rdi callq 0x7b53 cmpl $0x1, %eax je 0x264dc testl %eax, %eax jne 0x264e3 movq %rsp, %rdx movq %rbx, %rdi xorl %esi, %esi callq 0x9f91 movl %eax, %ecx movl $0x3, %eax testl %ecx, %ecx jne 0x264e8 movq %rbx, %rdi callq 0x663a cmpl $0x1, %e...
/mmanyen[P]CLua/build_O1/_deps/lua/lcorolib.c
db_getuservalue
static int db_getuservalue (lua_State *L) { int n = (int)luaL_optinteger(L, 2, 1); if (lua_type(L, 1) != LUA_TUSERDATA) luaL_pushfail(L); else if (lua_getiuservalue(L, 1, n) != LUA_TNONE) { lua_pushboolean(L, 1); return 2; } return 1; }
pushq %rbp pushq %r14 pushq %rbx movq %rdi, %rbx movl $0x1, %edx movl $0x2, %esi callq 0x8fb7 movq %rax, %r14 movl $0x1, %ebp movq %rbx, %rdi movl $0x1, %esi callq 0x68d4 cmpl $0x7, %eax jne 0x265e3 movl $0x1, %ebp movq %rbx, %rdi movl $0x1, %esi movl %r14d, %edx callq 0x740f cmpl $-0x1, %eax je 0x265eb movq %rbx, %rdi...
/mmanyen[P]CLua/build_O1/_deps/lua/ldblib.c
db_gethook
static int db_gethook (lua_State *L) { int arg; lua_State *L1 = getthread(L, &arg); char buff[5]; int mask = lua_gethookmask(L1); lua_Hook hook = lua_gethook(L1); if (hook == NULL) { /* no hook? */ luaL_pushfail(L); return 1; } else if (hook != hookf) /* external hook? */ lua_pushliteral(L...
pushq %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdi, %rbx leaq 0xc(%rsp), %rsi callq 0x27138 movq %rax, %r14 movq %rax, %rdi callq 0x9f83 movl %eax, %ebp movq %r14, %rdi callq 0x9f7b testq %rax, %rax je 0x2663e leaq 0xb56(%rip), %rcx # 0x2717e cmpq %rcx, %rax je 0x26650 leaq 0x5796(%rip), %rsi # 0x2b...
/mmanyen[P]CLua/build_O1/_deps/lua/ldblib.c
db_getlocal
static int db_getlocal (lua_State *L) { int arg; lua_State *L1 = getthread(L, &arg); int nvar = (int)luaL_checkinteger(L, arg + 2); /* local-variable index */ if (lua_isfunction(L, arg + 1)) { /* function argument? */ lua_pushvalue(L, arg + 1); /* push function */ lua_pushstring(L, lua_getlocal(L, NU...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0xa0, %rsp movq %rdi, %rbx leaq 0xc(%rsp), %r15 movq %r15, %rsi callq 0x27138 movq %rax, %r14 movl (%r15), %r12d leal 0x2(%r12), %esi movq %rbx, %rdi callq 0x8f2d movq %rax, %r15 incl %r12d movq %rbx, %rdi movl %r12d, %esi callq 0x68d4 movq %rbx, %rdi cmpl $0...
/mmanyen[P]CLua/build_O1/_deps/lua/ldblib.c
db_upvaluejoin
static int db_upvaluejoin (lua_State *L) { int n1, n2; checkupval(L, 1, 2, &n1); checkupval(L, 3, 4, &n2); luaL_argcheck(L, !lua_iscfunction(L, 1), 1, "Lua function expected"); luaL_argcheck(L, !lua_iscfunction(L, 3), 3, "Lua function expected"); lua_upvaluejoin(L, 1, n1, 3, n2); return 0; }
pushq %rbx subq $0x10, %rsp movq %rdi, %rbx leaq 0xc(%rsp), %rcx movl $0x1, %esi movl $0x2, %edx callq 0x272f7 leaq 0x8(%rsp), %rcx movq %rbx, %rdi movl $0x3, %esi movl $0x4, %edx callq 0x272f7 movq %rbx, %rdi movl $0x1, %esi callq 0x690a testl %eax, %eax jne 0x26ce7 movq %rbx, %rdi movl $0x3, %esi callq 0x690a testl %...
/mmanyen[P]CLua/build_O1/_deps/lua/ldblib.c
save
static void save (LexState *ls, int c) { Mbuffer *b = ls->buff; if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { size_t newsize = luaZ_sizebuffer(b); /* get old size */; if (newsize >= (MAX_SIZE/3 * 2)) /* larger than MAX_SIZE/1.5 ? */ lexerror(ls, "lexical element too long", 0); newsize += (news...
pushq %r15 pushq %r14 pushq %rbx movl %esi, %ebx movq 0x48(%rdi), %r15 movq 0x8(%r15), %rax movq 0x10(%r15), %rdx incq %rax cmpq %rdx, %rax jbe 0x28034 movabsq $0x5555555555555554, %rax # imm = 0x5555555555555554 cmpq %rax, %rdx jae 0x2804c movq %rdx, %r14 shrq %r14 addq %rdx, %r14 movq 0x38(%rdi), %rdi movq (%r15), %r...
/mmanyen[P]CLua/build_O1/_deps/lua/llex.c
inclinenumber
static void inclinenumber (LexState *ls) { int old = ls->current; lua_assert(currIsNewline(ls)); next(ls); /* skip '\n' or '\r' */ if (currIsNewline(ls) && ls->current != old) next(ls); /* skip '\n\r' or '\r\n' */ if (++ls->linenumber >= INT_MAX) lexerror(ls, "chunk has too many lines", 0); }
pushq %rbp pushq %rbx pushq %rax movq %rdi, %rbx movl (%rdi), %ebp movq 0x40(%rdi), %rdi subq $0x1, (%rdi) jae 0x28073 callq 0x22428 jmp 0x28082 movq 0x8(%rdi), %rax leaq 0x1(%rax), %rcx movq %rcx, 0x8(%rdi) movzbl (%rax), %eax movl %eax, (%rbx) cmpl $0xd, %eax je 0x2808e cmpl $0xa, %eax jne 0x280b4 cmpl %ebp, %eax je ...
/mmanyen[P]CLua/build_O1/_deps/lua/llex.c
skip_sep
static size_t skip_sep (LexState *ls) { size_t count = 0; int s = ls->current; lua_assert(s == '[' || s == ']'); save_and_next(ls); while (ls->current == '=') { save_and_next(ls); count++; } return (ls->current == s) ? count + 2 : (count == 0) ? 1 : 0; }
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %r14 movl (%rdi), %ebx movl %ebx, %esi callq 0x27feb movq 0x40(%r14), %rdi subq $0x1, (%rdi) jae 0x280fd callq 0x22428 jmp 0x2810c movq 0x8(%rdi), %rax leaq 0x1(%rax), %rcx movq %rcx, 0x8(%rdi) movzbl (%rax), %eax movl %eax, (%r14) xorl %r15d, %r15d cmpl $0x3d, %eax jne 0x281...
/mmanyen[P]CLua/build_O1/_deps/lua/llex.c
JSON::JSON(std::unique_ptr<JSON::JSON_value, std::default_delete<JSON::JSON_value>>)
JSON::JSON(std::unique_ptr<JSON_value> value) : m(new Members(std::move(value))) { }
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 pushq $0x18 popq %rdi callq 0x191a0 movq (%rbx), %rcx andq $0x0, (%rbx) movq %rcx, (%rax) xorps %xmm0, %xmm0 movups %xmm0, 0x8(%rax) movq %r14, %rdi movq %rax, %rsi addq $0x8, %rsp popq %rbx popq %r14 jmp 0x22edc nop
/qpdf[P]qpdf/libqpdf/JSON.cc