name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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, p->maxstacksize + 1);
/* copy function to the top of the stack */
setobjs2s(L, L->top.p++, ci->func.p);
/* move fixed parameters to the top of the stack */
for (i = 1; i <= nfixparams; i++) {
setobjs2s(L, L->top.p++, ci->func.p + i);
setnilvalue(s2v(ci->func.p + i)); /* erase original parameter (for GC) */
}
ci->func.p += actual + 1;
ci->top.p += actual + 1;
lua_assert(L->top.p <= ci->top.p && ci->top.p <= L->stack_last.p);
} | 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
cmpq %rsi, %rax
jle 0x1cf63
movq 0x10(%r14), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%r14)
movq (%rbx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movb 0x8(%rcx), %cl
movb %cl, 0x8(%rax)
testl %ebp, %ebp
jle 0x1cf4a
movl %ebp, %eax
shlq $0x4, %rax
xorl %ecx, %ecx
movq 0x10(%r14), %rdx
leaq 0x10(%rdx), %rsi
movq %rsi, 0x10(%r14)
movq (%rbx), %rsi
movq 0x10(%rsi,%rcx), %rdi
movq %rdi, (%rdx)
movb 0x18(%rsi,%rcx), %sil
movb %sil, 0x8(%rdx)
movq (%rbx), %rdx
movb $0x0, 0x18(%rdx,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x1cf19
movslq %r15d, %rax
shlq $0x4, %rax
addq %rax, (%rbx)
addq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl $0x1, %edx
callq 0xb4b0
jmp 0x1cef2
| /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 need top */
}
for (i = 0; i < wanted && i < nextra; i++)
setobjs2s(L, where + i, ci->func.p - nextra + i);
for (; i < wanted; i++) /* complete required results with nil */
setnilvalue(s2v(where + i));
} | 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 0x1d02f
movq %r12, %rax
shlq $0x4, %rax
addq %rbx, %rax
movq %rax, 0x10(%r15)
cmpl %r13d, %ebp
cmovll %ebp, %r13d
testl %r13d, %r13d
jle 0x1cffc
movl %r13d, %ecx
shlq $0x4, %r12
negq %r12
leaq 0x8(%rbx), %rdx
xorl %eax, %eax
movq (%r14), %rsi
movq (%rsi,%r12), %rdi
movq %rdi, -0x8(%rdx)
movb 0x8(%rsi,%r12), %sil
movb %sil, (%rdx)
incq %rax
addq $0x10, %r12
addq $0x10, %rdx
cmpq %rax, %rcx
jne 0x1cfd7
jmp 0x1cffe
xorl %eax, %eax
cmpl %ebp, %eax
jge 0x1d020
movl %eax, %ecx
movl %ebp, %eax
subq %rcx, %rax
shlq $0x4, %rcx
addq %rbx, %rcx
addq $0x8, %rcx
movb $0x0, (%rcx)
addq $0x10, %rcx
decq %rax
jne 0x1d014
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
subq 0x30(%r15), %rbx
movq %r15, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0xb4b0
addq 0x30(%r15), %rbx
jmp 0x1cfad
nop
| /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.offset = 1; /* fist byte was already read */
checkHeader(&S);
cl = luaF_newLclosure(L, loadByte(&S));
setclLvalue2s(L, L->top.p, cl);
luaD_inctop(L);
S.h = luaH_new(L); /* create list of saved strings */
S.nstr = 0;
sethvalue2s(L, L->top.p, S.h); /* anchor it */
luaD_inctop(L);
cl->p = luaF_newproto(L);
luaC_objbarrier(L, cl, cl->p);
loadFunction(&S, cl->p);
if (cl->nupvalues != cl->p->sizeupvalues)
error(&S, "corrupted chunk");
luai_verifycode(L, cl->p);
L->top.p--; /* pop table */
return cl;
} | 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 %cl, 0x30(%r14)
movq $0x1, 0x20(%r14)
leaq 0xcaf1(%rip), %rsi # 0x29b8a
leaq 0xe372(%rip), %rdx # 0x2b412
movq %r14, %rdi
callq 0x1d8b8
movq %r14, %rdi
callq 0x1d2e5
cmpb $0x55, %al
jne 0x1d27a
leaq 0x8(%rsp), %rdi
callq 0x1d2e5
testb %al, %al
jne 0x1d283
leaq 0xcabd(%rip), %rsi # 0x29b8e
leaq 0xe32a(%rip), %rdx # 0x2b402
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1d8b8
leaq 0xe5d5(%rip), %rdx # 0x2b6c1
movq %r14, %rdi
movl $0x4, %esi
callq 0x1d917
movq %rsp, %r15
movl $0x4, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d946
cmpl $0xffffa988, (%r15) # imm = 0xFFFFA988
jne 0x1d28c
leaq 0xe326(%rip), %rdx # 0x2b446
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x4, %esi
callq 0x1d917
movq %rsp, %r15
movl $0x4, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d946
cmpl $0x12345678, (%r15) # imm = 0x12345678
jne 0x1d29c
leaq 0xe2f9(%rip), %rdx # 0x2b452
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x8, %esi
callq 0x1d917
movq %rsp, %r15
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d946
cmpq $-0x5678, (%r15) # imm = 0xA988
jne 0x1d2ac
leaq 0xe2cc(%rip), %rdx # 0x2b45e
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x8, %esi
callq 0x1d917
movq %rsp, %r15
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d946
movsd (%r15), %xmm0
ucomisd 0xe214(%rip), %xmm0 # 0x2b3d8
jne 0x1d2bc
jp 0x1d2bc
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1d2e5
movzbl %al, %esi
movq %rbx, %rdi
callq 0xcfcc
movq %rax, %r14
movq 0x10(%rbx), %rax
movq %r14, (%rax)
movb $0x46, 0x8(%rax)
movq %rbx, %rdi
callq 0xb5cf
movq %rbx, %rdi
callq 0x1ad47
movq %rax, 0x18(%r15)
movq $0x0, 0x28(%r15)
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movb $0x45, 0x8(%rcx)
movq %rbx, %rdi
callq 0xb5cf
movq %rbx, %rdi
callq 0xd395
movq %rax, 0x18(%r14)
testb $0x20, 0x9(%r14)
je 0x1d24c
testb $0x18, 0x9(%rax)
je 0x1d24c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd508
movq 0x18(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1d323
movzbl 0xa(%r14), %eax
movq 0x18(%r14), %rcx
cmpl %eax, 0x10(%rcx)
jne 0x1d2d4
addq $-0x10, 0x10(%rbx)
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xe1a4(%rip), %rsi # 0x2b425
jmp 0x1d2db
leaq 0xe1ac(%rip), %rsi # 0x2b436
jmp 0x1d2db
leaq 0xcaf7(%rip), %rsi # 0x29d8a
leaq 0xe427(%rip), %rdx # 0x2b6c1
jmp 0x1d2ca
leaq 0xcae7(%rip), %rsi # 0x29d8a
leaq 0xe19c(%rip), %rdx # 0x2b446
jmp 0x1d2ca
leaq 0xcad7(%rip), %rsi # 0x29d8a
leaq 0xe198(%rip), %rdx # 0x2b452
jmp 0x1d2ca
leaq 0xcac7(%rip), %rsi # 0x29d8a
leaq 0xe194(%rip), %rdx # 0x2b45e
leaq 0x8(%rsp), %rdi
callq 0x1d979
leaq 0xe127(%rip), %rsi # 0x2b402
leaq 0x8(%rsp), %rdi
callq 0x1d88f
| /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 = loadByte(S);
loadCode(S, f);
loadConstants(S, f);
loadUpvalues(S, f);
loadProtos(S, f);
loadString(S, f, &f->source);
loadDebug(S, f);
} | 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 0x1d2e5
movb %al, 0xa(%r14)
movq %rbx, %rdi
callq 0x1d2e5
andb $0x1, %al
movb %al, 0xb(%r14)
cmpb $0x0, 0x30(%rbx)
je 0x1d37c
orb $0x2, %al
movb %al, 0xb(%r14)
movq %rbx, %rdi
callq 0x1d2e5
movb %al, 0xc(%r14)
movl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x1db2e
movq %rax, %r15
movl 0x20(%rbx), %eax
andl $0x3, %eax
je 0x1d3b4
movl $0x4, %edx
subl %eax, %edx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1d946
cmpb $0x0, 0x30(%rbx)
je 0x1d3d3
movslq %r15d, %rsi
shlq $0x2, %rsi
movq %rbx, %rdi
callq 0x1db7c
movq %rax, 0x40(%r14)
movl %r15d, 0x18(%r14)
jmp 0x1d3fd
movq (%rbx), %rdi
movslq %r15d, %r12
shlq $0x2, %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0x11387
movq %rax, 0x40(%r14)
movl %r15d, 0x18(%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1d946
movl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x1db2e
movq %rax, %r15
movq %rbx, 0x8(%rsp)
movq (%rbx), %rdi
movslq %r15d, %r12
movq %r12, %rsi
shlq $0x4, %rsi
xorl %edx, %edx
callq 0x11387
movq %rax, 0x38(%r14)
movl %r12d, 0x14(%r14)
testl %r12d, %r12d
jle 0x1d564
movl %r15d, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
addq $0x8, %rax
movb $0x0, (%rax)
addq $0x10, %rax
decq %rcx
jne 0x1d444
testl %r15d, %r15d
jle 0x1d564
leaq 0x70(%r14), %r13
andl $0x7fffffff, %r15d # imm = 0x7FFFFFFF
movl $0x8, %ebp
movq %r13, %rbx
movq 0x38(%r14), %r12
movq 0x8(%rsp), %rdi
callq 0x1d2e5
movzbl %al, %eax
cmpl $0x10, %eax
jg 0x1d4aa
cmpl $0x4, %eax
movq %rbx, %r13
ja 0x1d557
movl %eax, %eax
leaq 0xdf49(%rip), %rcx # 0x2b3e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, (%r12,%rbp)
jmp 0x1d557
cmpl $0x11, %eax
je 0x1d524
cmpl $0x13, %eax
je 0x1d52e
movq %rbx, %r13
cmpl $0x14, %eax
jne 0x1d557
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1d99c
movq 0x70(%r14), %rax
testq %rax, %rax
je 0x1d87e
movq %rax, -0x8(%r12,%rbp)
movb 0x8(%rax), %al
orb $0x40, %al
movb %al, (%r12,%rbp)
movq $0x0, (%r13)
jmp 0x1d557
movl $0x8, %edx
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1d946
movq %rbx, %r13
movq 0x10(%rsp), %rax
movq %rax, -0x8(%r12,%rbp)
movb $0x3, (%r12,%rbp)
jmp 0x1d557
movb $0x1, (%r12,%rbp)
jmp 0x1d557
movb $0x11, (%r12,%rbp)
movq %rbx, %r13
jmp 0x1d557
movl $0x8, %edx
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1d946
movq %rbx, %r13
movsd 0x10(%rsp), %xmm0
movsd %xmm0, -0x8(%r12,%rbp)
movb $0x13, (%r12,%rbp)
addq $0x10, %rbp
decq %r15
jne 0x1d469
movl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1db2e
movq %rax, %r15
movq (%rbx), %rdi
movslq %r15d, %r12
movq %r12, %rsi
shlq $0x4, %rsi
xorl %edx, %edx
callq 0x11387
movq %rax, 0x50(%r14)
movl %r12d, 0x10(%r14)
testl %r12d, %r12d
jle 0x1d5fe
movl %r15d, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
movq $0x0, (%rax)
addq $0x10, %rax
decq %rcx
jne 0x1d5a3
testl %r15d, %r15d
jle 0x1d5fe
andl $0x7fffffff, %r15d # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x1d2e5
movq 0x50(%r14), %rcx
movb %al, 0x8(%rcx,%r12)
movq %rbx, %rdi
callq 0x1d2e5
movq 0x50(%r14), %rcx
movb %al, 0x9(%rcx,%r12)
movq %rbx, %rdi
callq 0x1d2e5
movq 0x50(%r14), %rcx
movb %al, 0xa(%rcx,%r12)
addq $0x10, %r12
decq %r15
jne 0x1d5c2
movl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x1db2e
movq %rax, %r15
movq (%rbx), %rdi
movslq %r15d, %r12
leaq (,%r12,8), %rsi
xorl %edx, %edx
callq 0x11387
movq %rax, 0x48(%r14)
movl %r12d, 0x20(%r14)
testl %r12d, %r12d
jle 0x1d64e
movl %r15d, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movq 0x48(%r14), %rdx
movq $0x0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1d63a
testl %r15d, %r15d
jle 0x1d6a5
andl $0x7fffffff, %r15d # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq (%rbx), %rdi
callq 0xd395
movq 0x48(%r14), %rcx
movq %rax, (%rcx,%r12,8)
testb $0x20, 0x9(%r14)
je 0x1d68d
movq 0x48(%r14), %rax
movq (%rax,%r12,8), %rdx
testb $0x18, 0x9(%rdx)
je 0x1d68d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xd508
movq 0x48(%r14), %rax
movq (%rax,%r12,8), %rsi
movq %rbx, %rdi
callq 0x1d323
incq %r12
cmpq %r12, %r15
jne 0x1d65d
leaq 0x70(%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d99c
movl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x1db2e
movq %rax, %r15
cmpb $0x0, 0x30(%rbx)
je 0x1d6df
movslq %r15d, %rsi
movq %rbx, %rdi
callq 0x1db7c
movq %rax, 0x58(%r14)
movl %r15d, 0x1c(%r14)
jmp 0x1d705
movq (%rbx), %rdi
movslq %r15d, %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0x11387
movq %rax, 0x58(%r14)
movl %r15d, 0x1c(%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1d946
movl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x1db2e
movq %rax, %r15
testl %r15d, %r15d
jle 0x1d78f
movl 0x20(%rbx), %eax
andl $0x3, %eax
je 0x1d736
movl $0x4, %edx
subl %eax, %edx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1d946
movabsq $0x3fffffff8, %rax # imm = 0x3FFFFFFF8
cmpb $0x0, 0x30(%rbx)
je 0x1d762
movq %r15, %rsi
shlq $0x3, %rsi
andq %rax, %rsi
movq %rbx, %rdi
callq 0x1db7c
movq %rax, 0x60(%r14)
movl %r15d, 0x28(%r14)
jmp 0x1d78f
movq (%rbx), %rdi
movq %r15, %r12
shlq $0x3, %r12
andq %rax, %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0x11387
movq %rax, 0x60(%r14)
movl %r15d, 0x28(%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1d946
movl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x1db2e
movq %rax, %r15
movq (%rbx), %rdi
movslq %r15d, %r12
movq %r12, %rsi
shlq $0x4, %rsi
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x11387
movq %rax, 0x68(%r14)
movl %r12d, 0x24(%r14)
testl %r12d, %r12d
jle 0x1d831
movl %r15d, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
movq $0x0, (%rax)
addq $0x10, %rax
decq %rcx
jne 0x1d7cb
testl %r15d, %r15d
jle 0x1d831
andl $0x7fffffff, %r15d # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq 0x68(%r14), %rdx
addq %r12, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d99c
movl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x1db2e
movq 0x68(%r14), %rcx
movl %eax, 0x8(%rcx,%r12)
movl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x1db2e
movq 0x68(%r14), %rcx
movl %eax, 0xc(%rcx,%r12)
addq $0x10, %r12
decq %r15
jne 0x1d7ea
movl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x1db2e
testl %eax, %eax
je 0x1d846
movl 0x10(%r14), %ebp
testl %ebp, %ebp
jle 0x1d86f
movl %ebp, %r15d
shlq $0x4, %r15
xorl %r12d, %r12d
movq 0x50(%r14), %rdx
addq %r12, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d99c
addq $0x10, %r12
cmpq %r12, %r15
jne 0x1d854
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdc1a(%rip), %rsi # 0x2b49f
movq 0x8(%rsp), %rdi
callq 0x1d88f
| /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 %r15
retq
leaq 0xd388(%rip), %rsi # 0x2aefc
movq %rbx, %rdi
callq 0x1d88f
| /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; /* conversion failed */
} | 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)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
| /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 %rbx
retq
| /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 (remember: n != f) */
}
return lua_numbertointeger(f, p);
} | 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
movsd 0xc1e2(%rip), %xmm1 # 0x29e60
cmplepd %xmm0, %xmm1
andpd %xmm2, %xmm1
movd %xmm1, %eax
testb $0x1, %al
je 0x1dc97
cvttsd2si %xmm0, %rcx
movq %rcx, (%rbx)
movzbl %al, %ebp
andl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /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 0xc152(%rip), %xmm0 # 0x29e38
movsd 0xc17a(%rip), %xmm1 # 0x29e68
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
movsd 0xc161(%rip), %xmm1 # 0x29e60
cmplepd %xmm0, %xmm1
andpd %xmm2, %xmm1
movd %xmm1, %eax
testb $0x1, %al
je 0x1dd18
cvttsd2si %xmm0, %rcx
movq %rcx, (%rbx)
movzbl %al, %eax
andl $0x1, %eax
jmp 0x1dd2b
movq (%rdi), %rax
movq %rax, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %ebp, %eax
jmp 0x1dd2b
| /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? */
lua_assert(!ttistable(t));
tm = luaT_gettmbyobj(L, t, TM_INDEX);
if (l_unlikely(notm(tm)))
luaG_typeerror(L, t, "index"); /* no metamethod */
/* else will try the metamethod */
}
else { /* 't' is a table */
tm = fasttm(L, hvalue(t)->metatable, TM_INDEX); /* table's metamethod */
if (tm == NULL) { /* no metamethod? */
setnilvalue(s2v(val)); /* result is nil */
return LUA_VNIL;
}
/* else will try the metamethod */
}
if (ttisfunction(tm)) { /* is metamethod a function? */
tag = luaT_callTMres(L, tm, t, key, val); /* call it */
return tag; /* return tag of the result */
}
t = tm; /* else try to access 'tm[key]' */
luaV_fastget(t, key, s2v(val), luaH_get, tag);
if (!tagisempty(tag))
return tag; /* done */
/* else repeat (tail call 'luaV_finishget') */
}
luaG_runerror(L, "'__index' chain too long; possible loop");
return 0; /* to avoid warnings */
} | 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, 0x8(%rax)
jne 0x1dde5
jmp 0x1de5b
movq (%r12), %rax
movq 0x20(%rax), %rdi
testq %rdi, %rdi
je 0x1dddd
testb $0x1, 0xa(%rdi)
jne 0x1dddd
movq 0x18(%rbx), %rax
movq 0x110(%rax), %rdx
xorl %esi, %esi
callq 0x1cb25
movq %rax, %r13
jmp 0x1dde0
xorl %r13d, %r13d
testq %r13, %r13
je 0x1de45
movb 0x8(%r13), %cl
movl %ecx, %eax
andb $0xf, %al
cmpb $0x6, %al
je 0x1de23
movb $0x30, %al
cmpb $0x45, %cl
jne 0x1de07
movq (%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1afe1
testb $0xf, %al
jne 0x1de4c
movq %r13, %r12
decl %ebp
jne 0x1dd94
leaq 0xd783(%rip), %rsi # 0x2b59c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa859
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1cc88
movb $0x0, 0x8(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe067(%rip), %rdx # 0x2bec9
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa57e
| /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? */
Table *h = hvalue(t); /* save 't' table */
tm = fasttm(L, h->metatable, TM_NEWINDEX); /* get metamethod */
if (tm == NULL) { /* no metamethod? */
sethvalue2s(L, L->top.p, h); /* anchor 't' */
L->top.p++; /* assume EXTRA_STACK */
luaH_finishset(L, h, key, val, hres); /* set new value */
L->top.p--;
invalidateTMcache(h);
luaC_barrierback(L, obj2gco(h), val);
return;
}
/* else will try the metamethod */
}
else { /* not a table; check metamethod */
tm = luaT_gettmbyobj(L, t, TM_NEWINDEX);
if (l_unlikely(notm(tm)))
luaG_typeerror(L, t, "index");
}
/* try the metamethod */
if (ttisfunction(tm)) {
luaT_callTM(L, tm, t, key, val);
return;
}
t = tm; /* else repeat assignment over 'tm' */
luaV_fastset(t, key, val, hres, luaH_pset);
if (hres == HOK) {
luaV_finishfastset(L, t, val);
return; /* done */
}
/* else 'return luaV_finishset(L, t, key, val, slot)' (loop) */
}
luaG_runerror(L, "'__newindex' chain too long; possible loop");
} | 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, %r13
testb $0xf, 0x8(%rax)
jne 0x1deec
jmp 0x1e004
movq (%r12), %r15
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x1dee4
testb $0x2, 0xa(%rdi)
jne 0x1dee4
movq 0x18(%rbx), %rax
movq 0x118(%rax), %rdx
movl $0x1, %esi
callq 0x1cb25
movq %rax, %r13
jmp 0x1dee7
xorl %r13d, %r13d
testq %r13, %r13
je 0x1df43
movb 0x8(%r13), %al
movl %eax, %ecx
andb $0xf, %cl
cmpb $0x6, %cl
jne 0x1df17
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x1cc2b
jmp 0x1dfd5
movl $0x2, %ebp
cmpb $0x45, %al
jne 0x1df35
movq (%r13), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1b4dc
movl %eax, %ebp
movb $0x1, %al
testl %ebp, %ebp
je 0x1dfa1
movq %r13, %r12
jmp 0x1dfd7
movq 0x10(%rbx), %rax
movq %r15, (%rax)
movb $0x45, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %r13
movq %r13, %rcx
movl %ebp, %r8d
callq 0x1b61c
addq $-0x10, 0x10(%rbx)
andb $-0x40, 0xa(%r15)
testb $0x40, 0x8(%r13)
je 0x1dfd5
testb $0x20, 0x9(%r15)
je 0x1dfd5
movq 0x8(%rsp), %rax
movq (%rax), %rax
testb $0x18, 0x9(%rax)
je 0x1dfd5
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd62e
jmp 0x1dfd5
xorl %ebp, %ebp
movq 0x8(%rsp), %rax
testb $0x40, 0x8(%rax)
je 0x1dfd2
movq (%r13), %rsi
xorl %ebp, %ebp
testb $0x20, 0x9(%rsi)
je 0x1dfd2
movq 0x8(%rsp), %rax
movq (%rax), %rax
testb $0x18, 0x9(%rax)
je 0x1dfd0
movq %rbx, %rdi
callq 0xd62e
xorl %ebp, %ebp
movq %r13, %r12
xorl %eax, %eax
testb %al, %al
je 0x1dff5
decl %r14d
jne 0x1de94
leaq 0xd5d9(%rip), %rsi # 0x2b5c4
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa859
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdebe(%rip), %rdx # 0x2bec9
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa57e
| /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
cmpb $0x13, %al
jne 0x1e08e
movsd (%rdx), %xmm1
jmp 0x1e0b2
movsd (%rdx), %xmm0
movabsq $0x20000000000000, %rax # imm = 0x20000000000000
addq %rbx, %rax
movabsq $0x40000000000001, %rcx # imm = 0x40000000000001
cmpq %rcx, %rax
jae 0x1e0be
cvtsi2sd %rbx, %xmm1
ucomisd %xmm1, %xmm0
jmp 0x1e0b6
movq (%rdx), %rbx
movabsq $0x20000000000000, %rax # imm = 0x20000000000000
addq %rbx, %rax
movabsq $0x40000000000001, %rcx # imm = 0x40000000000001
cmpq %rcx, %rax
jae 0x1e123
cvtsi2sd %rbx, %xmm1
ucomisd %xmm0, %xmm1
seta %al
jmp 0x1e164
movsd %xmm0, 0x8(%rsp)
callq 0x54e0
movsd 0xbd67(%rip), %xmm1 # 0x29e38
addsd %xmm0, %xmm1
movapd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm3
cmpneqsd %xmm3, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
cvttsd2si %xmm2, %rcx
xorl %eax, %eax
cmpq %rcx, %rbx
setl %al
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
ucomisd %xmm0, %xmm3
seta %cl
movsd 0xbd56(%rip), %xmm0 # 0x29e68
ucomisd %xmm2, %xmm0
cmovbel %ecx, %eax
ucomisd 0xbd3f(%rip), %xmm2 # 0x29e60
jmp 0x1e161
movsd %xmm0, 0x8(%rsp)
callq 0x54e0
cvttsd2si %xmm0, %rcx
xorl %eax, %eax
cmpq %rcx, %rbx
setg %al
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
ucomisd 0x8(%rsp), %xmm1
seta %cl
movsd 0xbd16(%rip), %xmm1 # 0x29e68
ucomisd %xmm0, %xmm1
cmovbel %ecx, %eax
ucomisd 0xbcff(%rip), %xmm0 # 0x29e60
cmovbl %ecx, %eax
movzbl %al, %eax
addq $0x10, %rsp
popq %rbx
retq
| /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
cmpb $0x13, %al
jne 0x1e212
movsd (%rdx), %xmm1
jmp 0x1e236
movsd (%rdx), %xmm0
movabsq $0x20000000000000, %rax # imm = 0x20000000000000
addq %rbx, %rax
movabsq $0x40000000000001, %rcx # imm = 0x40000000000001
cmpq %rcx, %rax
jae 0x1e242
cvtsi2sd %rbx, %xmm1
ucomisd %xmm1, %xmm0
jmp 0x1e23a
movq (%rdx), %rbx
movabsq $0x20000000000000, %rax # imm = 0x20000000000000
addq %rbx, %rax
movabsq $0x40000000000001, %rcx # imm = 0x40000000000001
cmpq %rcx, %rax
jae 0x1e286
cvtsi2sd %rbx, %xmm1
ucomisd %xmm0, %xmm1
setae %al
jmp 0x1e2ec
movsd %xmm0, 0x8(%rsp)
callq 0x54e0
cvttsd2si %xmm0, %rcx
xorl %eax, %eax
cmpq %rcx, %rbx
setle %al
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
movsd 0x8(%rsp), %xmm2
ucomisd %xmm1, %xmm2
seta %cl
movsd 0xbbf3(%rip), %xmm1 # 0x29e68
ucomisd %xmm0, %xmm1
cmovbel %ecx, %eax
ucomisd 0xbbdc(%rip), %xmm0 # 0x29e60
jmp 0x1e2e9
movsd %xmm0, 0x8(%rsp)
callq 0x54e0
movsd 0xbb9f(%rip), %xmm1 # 0x29e38
addsd %xmm0, %xmm1
movapd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm3
cmpneqsd %xmm3, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
cvttsd2si %xmm2, %rcx
xorl %eax, %eax
cmpq %rcx, %rbx
setge %al
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
ucomisd %xmm3, %xmm0
seta %cl
movsd 0xbb8e(%rip), %xmm0 # 0x29e68
ucomisd %xmm2, %xmm0
cmovbel %ecx, %eax
ucomisd 0xbb77(%rip), %xmm2 # 0x29e60
cmovbl %ecx, %eax
movzbl %al, %eax
addq $0x10, %rsp
popq %rbx
retq
| /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 with different variants */
/* One of them is an integer. If the other does not have an
integer value, they cannot be equal; otherwise, compare their
integer values. */
lua_Integer i1, i2;
return (luaV_tointegerns(t1, &i1, F2Ieq) &&
luaV_tointegerns(t2, &i2, F2Ieq) &&
i1 == i2);
}
}
/* values have same type and same variant */
switch (ttypetag(t1)) {
case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1;
case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2));
case LUA_VNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2));
case LUA_VLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
case LUA_VLCF: return fvalue(t1) == fvalue(t2);
case LUA_VSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2));
case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2));
case LUA_VUSERDATA: {
if (uvalue(t1) == uvalue(t2)) return 1;
else if (L == NULL) return 0;
tm = fasttm(L, uvalue(t1)->metatable, TM_EQ);
if (tm == NULL)
tm = fasttm(L, uvalue(t2)->metatable, TM_EQ);
break; /* will try TM */
}
case LUA_VTABLE: {
if (hvalue(t1) == hvalue(t2)) return 1;
else if (L == NULL) return 0;
tm = fasttm(L, hvalue(t1)->metatable, TM_EQ);
if (tm == NULL)
tm = fasttm(L, hvalue(t2)->metatable, TM_EQ);
break; /* will try TM */
}
default:
return gcvalue(t1) == gcvalue(t2);
}
if (tm == NULL) /* no TM? */
return 0; /* objects are different */
else {
int tag = luaT_callTMres(L, tm, t1, t2, L->top.p); /* call TM */
return !tagisfalse(tag);
}
} | 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
leaq 0xd175(%rip), %rcx # 0x2b4dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r14), %rax
xorl %r15d, %r15d
cmpq (%rbx), %rax
jmp 0x1e52c
movl %eax, %ecx
andl $0xf, %ecx
movl %ebp, %edx
andl $0xf, %edx
xorl $0x3, %ecx
xorl $0x3, %edx
xorl %r15d, %r15d
orl %ecx, %edx
jne 0x1e530
cmpl $0x3, %eax
je 0x1e3ee
movb $0x1, %r12b
cmpl $0x13, %eax
jne 0x1e3f6
movsd (%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x54e0
ucomisd 0x8(%rsp), %xmm0
jne 0x1e3f6
jp 0x1e3f6
movsd 0xbaa0(%rip), %xmm1 # 0x29e68
movsd 0xba90(%rip), %xmm2 # 0x29e60
cmpnlepd %xmm0, %xmm2
movapd %xmm0, %xmm3
cmpnltpd %xmm1, %xmm3
orpd %xmm2, %xmm3
movd %xmm3, %r12d
cvttsd2si %xmm0, %r14
jmp 0x1e3f6
movq (%r14), %r14
xorl %r12d, %r12d
jmp 0x1e3f6
testb $0x1, %r12b
jne 0x1e530
cmpl $0x3, %ebp
je 0x1e503
movb $0x1, %r12b
cmpl $0x13, %ebp
jne 0x1e520
movsd (%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x54e0
ucomisd 0x8(%rsp), %xmm0
jne 0x1e520
jp 0x1e520
movsd 0xba2a(%rip), %xmm1 # 0x29e68
movsd 0xba1a(%rip), %xmm2 # 0x29e60
cmpnlepd %xmm0, %xmm2
movapd %xmm0, %xmm3
cmpnltpd %xmm1, %xmm3
orpd %xmm2, %xmm3
movd %xmm3, %r12d
cvttsd2si %xmm0, %rax
jmp 0x1e520
movq (%r14), %rax
cmpq (%rbx), %rax
je 0x1e530
testq %r12, %r12
je 0x1e5b0
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x1e540
testb $0x20, 0xa(%rdi)
jne 0x1e540
movq 0x18(%r12), %rax
movq 0x138(%rax), %rdx
movl $0x5, %esi
callq 0x1cb25
movq %rax, %rsi
jmp 0x1e542
movq (%r14), %rdi
movq (%rbx), %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x16e74
movq (%r14), %rax
cmpq (%rbx), %rax
je 0x1e530
testq %r12, %r12
je 0x1e5b0
movq 0x20(%rax), %rdi
testq %rdi, %rdi
je 0x1e550
testb $0x20, 0xa(%rdi)
jne 0x1e550
movq 0x18(%r12), %rax
movq 0x138(%rax), %rdx
movl $0x5, %esi
callq 0x1cb25
movq %rax, %rsi
jmp 0x1e552
movq (%rbx), %rax
xorl %r12d, %r12d
jmp 0x1e520
movsd (%rbx), %xmm0
cmpeqsd (%r14), %xmm0
movq %xmm0, %r15
andl $0x1, %r15d
jmp 0x1e530
testb $0x1, %r12b
jne 0x1e530
xorl %r15d, %r15d
cmpq %rax, %r14
sete %r15b
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %esi, %esi
testq %rsi, %rsi
jne 0x1e586
movq (%rbx), %rax
movq 0x18(%rax), %rdi
jmp 0x1e55e
xorl %esi, %esi
testq %rsi, %rsi
jne 0x1e586
movq (%rbx), %rax
movq 0x20(%rax), %rdi
testq %rdi, %rdi
je 0x1e584
testb $0x20, 0xa(%rdi)
jne 0x1e584
movq 0x18(%r12), %rax
movq 0x138(%rax), %rdx
movl $0x5, %esi
callq 0x1cb25
movq %rax, %rsi
jmp 0x1e586
xorl %esi, %esi
testq %rsi, %rsi
je 0x1e5b0
movq 0x10(%r12), %r8
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1cc88
cmpb $0x1, %al
setne %cl
testb $0xf, %al
setne %al
andb %cl, %al
movzbl %al, %r15d
jmp 0x1e530
xorl %r15d, %r15d
jmp 0x1e530
| /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)))
luaT_tryconcatTM(L); /* may invalidate 'top' */
else if (isemptystr(s2v(top - 1))) /* second operand is empty? */
cast_void(tostring(L, s2v(top - 2))); /* result is first operand */
else if (isemptystr(s2v(top - 2))) { /* first operand is empty string? */
setobjs2s(L, top - 2, top - 1); /* result is second op. */
}
else {
/* at least two non-empty string values; get as many as possible */
size_t tl = tsslen(tsvalue(s2v(top - 1)));
TString *ts;
/* collect total length and number of strings */
for (n = 1; n < total && tostring(L, s2v(top - n - 1)); n++) {
size_t l = tsslen(tsvalue(s2v(top - n - 1)));
if (l_unlikely(l >= MAX_SIZE - sizeof(TString) - tl)) {
L->top.p = top - total; /* pop strings to avoid wasting stack */
luaG_runerror(L, "string length overflow");
}
tl += l;
}
if (tl <= LUAI_MAXSHORTLEN) { /* is result a short string? */
char buff[LUAI_MAXSHORTLEN];
copy2buff(top, n, buff); /* copy strings to buffer */
ts = luaS_newlstr(L, buff, tl);
}
else { /* long string; copy strings directly to final result */
ts = luaS_createlngstrobj(L, tl);
copy2buff(top, n, getlngstr(ts));
}
setsvalue2s(L, top - n, ts); /* create result */
}
total -= n - 1; /* got 'n' strings to create one new */
L->top.p -= n - 1; /* popped 'n' strings and pushed one */
} while (total > 1); /* repeat until only 1 result left */
} | 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, %r15d
movq 0x10(%rbx), %r14
movb -0x18(%r14), %al
andb $0xf, %al
addb $-0x3, %al
cmpb $0x1, %al
ja 0x1e759
leaq -0x10(%r14), %r12
movzbl -0x8(%r14), %eax
andl $0xf, %eax
cmpl $0x4, %eax
je 0x1e62b
cmpl $0x3, %eax
jne 0x1e759
movq %rbx, %rdi
movq %r12, %rsi
callq 0x127e3
leaq -0x20(%r14), %r13
movb -0x8(%r14), %al
cmpb $0x44, %al
jne 0x1e645
movq (%r12), %rcx
cmpb $0x0, 0xb(%rcx)
je 0x1e821
cmpb $0x44, -0x18(%r14)
jne 0x1e65a
movq (%r13), %rcx
cmpb $0x0, 0xb(%rcx)
je 0x1e83e
movq %r14, 0x8(%rsp)
movq (%r12), %rax
movsbq 0xb(%rax), %r12
testq %r12, %r12
jns 0x1e671
movq 0x10(%rax), %r12
movl $0x1, %r14d
cmpl $0x2, %r15d
jl 0x1e6d3
movl $0x1, %r14d
movzbl 0x8(%r13), %eax
andl $0xf, %eax
cmpl $0x4, %eax
je 0x1e6a0
cmpl $0x3, %eax
jne 0x1e6d3
movq %rbx, %rdi
movq %r13, %rsi
callq 0x127e3
movq (%r13), %rcx
movsbq 0xb(%rcx), %rax
testq %rax, %rax
jns 0x1e6b2
movq 0x10(%rcx), %rax
movq %rbp, %rcx
subq %r12, %rcx
cmpq %rcx, %rax
jae 0x1e84f
addq %rax, %r12
incq %r14
addq $-0x10, %r13
cmpq %r14, %r15
jne 0x1e683
movl %r15d, %r14d
movq %r15, 0x18(%rsp)
movl %r14d, %r15d
cmpq $0x28, %r12
movq %r15, 0x28(%rsp)
ja 0x1e76c
leaq 0x1(%r15), %rbx
movq %r15, %rax
shlq $0x4, %rax
movq 0x8(%rsp), %r15
subq %rax, %r15
xorl %ebp, %ebp
movq (%r15), %rsi
movsbq 0xb(%rsi), %r13
testq %r13, %r13
js 0x1e712
addq $0x18, %rsi
jmp 0x1e71a
movq 0x10(%rsi), %r13
movq 0x18(%rsi), %rsi
leaq (%rsp,%rbp), %rdi
addq $0x30, %rdi
movq %r13, %rdx
callq 0x52a0
addq %r13, %rbp
decq %rbx
addq $0x10, %r15
cmpq $0x1, %rbx
jg 0x1e6ff
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
leaq 0x30(%rsp), %rsi
movq %r12, %rdx
callq 0x170cb
movq 0x18(%rsp), %r15
jmp 0x1e7db
movq %rbx, %rdi
callq 0x1cdad
movl $0x1, %r14d
jmp 0x1e804
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17175
movq %rax, 0x20(%rsp)
movq 0x18(%rax), %r12
leaq 0x1(%r15), %rbx
movq %r15, %rax
shlq $0x4, %rax
movq 0x8(%rsp), %r15
subq %rax, %r15
xorl %ebp, %ebp
movq (%r15), %rsi
movsbq 0xb(%rsi), %r13
testq %r13, %r13
js 0x1e7a8
addq $0x18, %rsi
jmp 0x1e7b0
movq 0x10(%rsi), %r13
movq 0x18(%rsi), %rsi
leaq (%r12,%rbp), %rdi
movq %r13, %rdx
callq 0x52a0
addq %r13, %rbp
decq %rbx
addq $0x10, %r15
cmpq $0x1, %rbx
jg 0x1e795
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r15
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rdx
shlq $0x4, %rdx
movq 0x8(%rsp), %rcx
subq %rdx, %rcx
movq %rax, (%rcx)
movb 0x8(%rax), %al
orb $0x40, %al
movb %al, 0x8(%rcx)
decl %r14d
movabsq $0x7fffffffffffffcf, %rbp # imm = 0x7FFFFFFFFFFFFFCF
subl %r14d, %r15d
movslq %r14d, %rax
shlq $0x4, %rax
subq %rax, 0x10(%rbx)
cmpl $0x1, %r15d
jg 0x1e5ef
jmp 0x1e5cb
movb -0x18(%r14), %al
andb $0xf, %al
movl $0x1, %r14d
cmpb $0x3, %al
jne 0x1e804
movq %rbx, %rdi
movq %r13, %rsi
callq 0x127e3
jmp 0x1e804
movq -0x10(%r14), %rcx
movq %rcx, -0x20(%r14)
movb %al, -0x18(%r14)
jmp 0x1e761
shlq $0x4, %r15
movq 0x8(%rsp), %rax
subq %r15, %rax
movq %rax, 0x10(%rbx)
leaq 0xcd89(%rip), %rsi # 0x2b5ef
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa859
| /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))); /* else primitive len */
return;
}
case LUA_VSHRSTR: {
setivalue(s2v(ra), tsvalue(rb)->shrlen);
return;
}
case LUA_VLNGSTR: {
setivalue(s2v(ra), cast_st2S(tsvalue(rb)->u.lnglen));
return;
}
default: { /* try metamethod */
tm = luaT_gettmbyobj(L, rb, TM_LEN);
if (l_unlikely(notm(tm))) /* no metamethod? */
luaG_typeerror(L, rb, "get length of");
break;
}
}
luaT_callTMres(L, tm, rb, rb, ra);
} | 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 0x1e902
movq 0x18(%r15), %rax
movq 0x130(%rax), %rdx
movl $0x4, %esi
callq 0x1cb25
movq %rax, %rsi
jmp 0x1e904
movq (%r14), %rax
movq 0x10(%rax), %rax
jmp 0x1e92d
movq (%r14), %rax
movsbq 0xb(%rax), %rax
jmp 0x1e92d
movq %r15, %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x1cb50
movq %rax, %rsi
testb $0xf, 0x8(%rax)
jne 0x1e909
leaq 0xcd0f(%rip), %rdx # 0x2b606
movq %r15, %rdi
movq %r14, %rsi
callq 0xa57e
xorl %esi, %esi
testq %rsi, %rsi
je 0x1e925
movq %r15, %rdi
movq %r14, %rdx
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1cc88
movq %r12, %rdi
callq 0x1ba26
movq %rax, (%rbx)
movb $0x3, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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 = m / n; /* perform C division */
if ((m ^ n) < 0 && m % n != 0) /* 'm/n' would be negative non-integer? */
q -= 1; /* correct result for different rounding */
return 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 + GETARG_A(*(ci->u.l.savedpc - 2)), --L->top.p);
break;
}
case OP_UNM: case OP_BNOT: case OP_LEN:
case OP_GETTABUP: case OP_GETTABLE: case OP_GETI:
case OP_GETFIELD: case OP_SELF: {
setobjs2s(L, base + GETARG_A(inst), --L->top.p);
break;
}
case OP_LT: case OP_LE:
case OP_LTI: case OP_LEI:
case OP_GTI: case OP_GEI:
case OP_EQ: { /* note that 'OP_EQI'/'OP_EQK' cannot yield */
int res = !l_isfalse(s2v(L->top.p - 1));
L->top.p--;
#if defined(LUA_COMPAT_LT_LE)
if (ci->callstatus & CIST_LEQ) { /* "<=" using "<" instead? */
ci->callstatus ^= CIST_LEQ; /* clear mark */
res = !res; /* negate result */
}
#endif
lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_JMP);
if (res != GETARG_k(inst)) /* condition failed? */
ci->u.l.savedpc++; /* skip jump instruction */
break;
}
case OP_CONCAT: {
StkId top = L->top.p - 1; /* top when 'luaT_tryconcatTM' was called */
int a = GETARG_A(inst); /* first element to concatenate */
int total = cast_int(top - 1 - (base + a)); /* yet to concatenate */
setobjs2s(L, top - 2, top); /* put TM result in proper position */
L->top.p = top - 1; /* top is one after last element (at top-2) */
luaV_concat(L, total); /* concat them (may yield again) */
break;
}
case OP_CLOSE: { /* yielded closing variables */
ci->u.l.savedpc--; /* repeat instruction to close other vars. */
break;
}
case OP_RETURN: { /* yielded closing variables */
StkId ra = base + GETARG_A(inst);
/* adjust top to signal correct number of returns, in case the
return is "up to top" ('isIT') */
L->top.p = ra + ci->u2.nres;
/* repeat instruction to close other vars. and complete the return */
ci->u.l.savedpc--;
break;
}
default: {
/* only these other opcodes can yield */
lua_assert(op == OP_TFORCALL || op == OP_CALL ||
op == OP_TAILCALL || op == OP_SETTABUP || op == OP_SETTABLE ||
op == OP_SETI || op == OP_SETFIELD);
break;
}
}
} | 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 $0x1, %sil
setne %r8b
testb $0xf, %sil
setne %sil
andb %r8b, %sil
addq $-0x10, %rax
movq %rax, 0x10(%rdi)
testw %cx, %cx
setns %al
xorb %sil, %al
jne 0x1ea9b
addq $0x4, 0x20(%rdx)
retq
leal -0xb(%r8), %edx
cmpl $0x4, %edx
jb 0x1ea9f
cmpl $0x14, %r8d
je 0x1ea9f
retq
movl -0x8(%rsi), %ecx
shrl $0x3, %ecx
andl $0xff0, %ecx # imm = 0xFF0
movq 0x10(%rdi), %rdx
leaq -0x10(%rdx), %rsi
movq %rsi, 0x10(%rdi)
movq -0x10(%rdx), %rsi
movq %rsi, (%rax,%rcx)
movb -0x8(%rdx), %dl
movb %dl, 0x8(%rax,%rcx)
retq
addq $-0x4, %rsi
movq %rsi, 0x20(%rdx)
retq
movq 0x10(%rdi), %rdx
shrl $0x7, %ecx
movzbl %cl, %ecx
leaq -0x20(%rdx), %r8
shlq $0x4, %rcx
addq %rcx, %rax
negq %rax
leaq (%rdx,%rax), %rsi
addq $-0x20, %rsi
shrq $0x4, %rsi
movq -0x10(%rdx), %rax
movq %rax, -0x30(%rdx)
movb -0x8(%rdx), %al
movb %al, -0x28(%rdx)
movq %r8, 0x10(%rdi)
jmp 0x1e5b8
shrl $0x3, %ecx
andl $0xff0, %ecx # imm = 0xFF0
movslq 0x38(%rdx), %rsi
shlq $0x4, %rsi
addq %rsi, %rax
addq %rcx, %rax
movq %rax, 0x10(%rdi)
addq $-0x4, 0x20(%rdx)
retq
| /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 */
else { /* strings are equal up to a '\0' */
size_t zl1 = strlen(s1); /* index of first '\0' in 's1' */
size_t zl2 = strlen(s2); /* index of first '\0' in 's2' */
if (zl2 == rl2) /* 's2' is finished? */
return (zl1 == rl1) ? 0 : 1; /* check 's1' */
else if (zl1 == rl1) /* 's1' is finished? */
return -1; /* 's1' is less than 's2' ('s2' is not finished) */
/* both strings longer than 'zl'; go on comparing after the '\0' */
zl1++; zl2++;
s1 += zl1; rl1 -= zl1; s2 += zl2; rl2 -= zl2;
}
}
} | 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 0x10(%rbx), %r13
movq 0x18(%rbx), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5100
testl %eax, %eax
je 0x223c8
xorl %ecx, %ecx
movl %eax, %ebp
jmp 0x22413
movq %r14, %rdi
callq 0x5180
movq %rax, %r15
movq %rbx, %rdi
callq 0x5180
cmpq %r13, %rax
jne 0x223eb
xorl %ebp, %ebp
cmpq %r12, %r15
setne %bpl
jmp 0x223f5
cmpq %r12, %r15
jne 0x223f9
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
xorl %ecx, %ecx
jmp 0x22413
addq %r15, %r14
incq %r14
incq %r15
subq %r15, %r12
addq %rax, %rbx
incq %rbx
incq %rax
subq %rax, %r13
movb $0x1, %cl
testb %cl, %cl
jne 0x223b3
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 %rax, %rcx
incq %rcx
movq %rcx, 0x8(%rbx)
movzbl (%rax), %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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;
}
return 0;
} | 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 %r13, %rdx
callq 0x52a0
subq %r13, (%r15)
addq %r13, 0x8(%r15)
addq %r13, %r14
subq %r13, %rbx
jmp 0x224dc
movq %rbx, %r12
testl %ebp, %ebp
jne 0x2249e
jmp 0x224e5
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 += n;
return res;
} | 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,
"position out of bounds");
if (n == 0) {
/* find beginning of current byte sequence */
while (posi > 0 && iscontp(s + posi)) posi--;
}
else {
if (iscontp(s + posi))
return luaL_error(L, "initial position is a continuation byte");
if (n < 0) {
while (n < 0 && posi > 0) { /* move back */
do { /* find beginning of previous character */
posi--;
} while (posi > 0 && iscontp(s + posi));
n++;
}
}
else {
n--; /* do not move for 1st character */
while (n > 0 && posi < (lua_Integer)len) {
do { /* find beginning of next character */
posi++;
} while (iscontp(s + posi)); /* (cannot pass final '\0') */
n--;
}
}
}
if (n != 0) { /* did not find given character? */
luaL_pushfail(L);
return 1;
}
lua_pushinteger(L, posi + 1); /* initial position */
if ((s[posi] & 0x80) != 0) { /* multi-byte character? */
do {
posi++;
} while (iscontp(s + posi + 1)); /* skip to final byte */
}
/* else one-byte character: final position is the initial one */
lua_pushinteger(L, posi + 1); /* 'posi' now is the final position */
return 2;
} | 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, %rdi
movl $0x3, %esi
callq 0x8fb7
movq %rax, %r15
movq (%r13), %rax
testq %r15, %r15
jns 0x2263c
movq %r15, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x22636
xorl %r15d, %r15d
jmp 0x2263c
addq %rax, %r15
incq %r15
leaq -0x1(%r15), %rcx
testq %r15, %r15
cmovgq %rcx, %r15
jle 0x22791
cmpq %rax, %rcx
jg 0x22791
testq %r12, %r12
je 0x2267b
movb (%r14,%r15), %al
andb $-0x40, %al
negb %al
jno 0x226a7
leaq 0x9059(%rip), %rsi # 0x2b6c5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x87c6
jmp 0x22783
testq %r15, %r15
jle 0x2273b
movb (%r14,%r15), %al
andb $-0x40, %al
negb %al
jno 0x2273b
leaq -0x1(%r15), %rax
cmpq $0x1, %r15
movq %rax, %r15
jg 0x22684
xorl %r15d, %r15d
jmp 0x2273b
testq %r12, %r12
js 0x226e4
leaq -0x1(%r12), %rax
cmpq $0x2, %r12
jl 0x22730
movq 0x8(%rsp), %rcx
cmpq %rcx, %r15
jge 0x22730
movb 0x1(%r14,%r15), %dl
incq %r15
andb $-0x40, %dl
negb %dl
jo 0x226c1
leaq -0x1(%rax), %r12
cmpq $0x2, %rax
jl 0x2273b
movq %r12, %rax
cmpq %rcx, %r15
jl 0x226c1
jmp 0x2273b
testq %r15, %r15
jle 0x22735
movq %r12, %rax
testq %r15, %r15
movl $0x1, %edx
cmovleq %r15, %rdx
decq %rdx
movq %r15, %rcx
cmpq $0x2, %r15
jl 0x22718
leaq -0x1(%rcx), %r15
movb -0x1(%r14,%rcx), %sil
andb $-0x40, %sil
negb %sil
jo 0x226fb
jmp 0x2271b
movq %rdx, %r15
leaq 0x1(%rax), %r12
cmpq $-0x2, %rax
jg 0x2273b
movq %r12, %rax
cmpq $0x1, %rcx
jg 0x226ec
jmp 0x2273b
movq %rax, %r12
jmp 0x2273b
movl $0x1, %r12d
testq %r12, %r12
je 0x2274f
movq %rbx, %rdi
callq 0x6d71
movl $0x1, %eax
jmp 0x22783
leaq 0x1(%r15), %rsi
movq %rbx, %rdi
callq 0x6d91
cmpb $0x0, (%r14,%r15)
jns 0x22770
movb 0x2(%r14,%r15), %al
incq %r15
andb $-0x40, %al
negb %al
jo 0x22762
incq %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6d91
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x8f73(%rip), %rdx # 0x2b70b
movq %rbx, %rdi
movl $0x3, %esi
callq 0x86ba
jmp 0x22656
| /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, 2, "out of bounds");
luaL_argcheck(L, pose <= (lua_Integer)len, 3, "out of bounds");
if (posi > pose) return 0; /* empty interval; return no values */
if (pose - posi >= INT_MAX) /* (lua_Integer -> int) overflow? */
return luaL_error(L, "string slice too long");
n = (int)(pose - posi) + 1; /* upper bound for number of returns */
luaL_checkstack(L, n, "string slice too long");
n = 0; /* count the number of returns */
se = s + pose; /* string end */
for (s += posi - 1; s < se;) {
l_uint32 code;
s = utf8_decode(s, &code, !lax);
if (s == NULL)
return luaL_error(L, MSGInvalid);
lua_pushinteger(L, l_castU2S(code));
n++;
}
return n;
} | 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
cmpq %rcx, %rax
jae 0x227fc
xorl %r12d, %r12d
jmp 0x22802
addq %rax, %r12
incq %r12
movq %rbx, %rdi
movl $0x3, %esi
movq %r12, %rdx
callq 0x8fb7
movq %rax, %r14
testq %rax, %rax
jns 0x22835
movq 0x8(%rsp), %rax
movq %r14, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x2282f
xorl %r14d, %r14d
jmp 0x22835
addq %rax, %r14
incq %r14
movq %rbx, %rdi
movl $0x4, %esi
callq 0x6b9e
movl %eax, %r13d
testq %r12, %r12
jle 0x22917
cmpq 0x8(%rsp), %r14
jg 0x22930
movl $0x0, 0x4(%rsp)
movq %r14, %rsi
subq %r12, %rsi
jl 0x22904
cmpq $0x7fffffff, %rsi # imm = 0x7FFFFFFF
jl 0x2288d
leaq 0x83bb(%rip), %rsi # 0x2ac38
movq %rbx, %rdi
xorl %eax, %eax
callq 0x87c6
movl %eax, 0x4(%rsp)
jmp 0x22904
incl %esi
leaq 0x83a2(%rip), %rdx # 0x2ac38
movq %rbx, %rdi
callq 0x8e28
addq %r15, %r14
addq %r12, %r15
decq %r15
xorl %ebp, %ebp
testl %r13d, %r13d
sete %bpl
leaq 0x14(%rsp), %r12
xorl %r13d, %r13d
cmpq %r14, %r15
jae 0x228ff
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x22be3
movq %rax, %r15
testq %rax, %rax
je 0x228e3
movl 0x14(%rsp), %esi
movq %rbx, %rdi
callq 0x6d91
incl %r13d
jmp 0x228f8
movq %rbx, %rdi
leaq 0x8e00(%rip), %rsi # 0x2b6ed
xorl %eax, %eax
callq 0x87c6
movl %eax, 0x4(%rsp)
testq %r15, %r15
jne 0x228b8
jmp 0x22904
movl %r13d, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8df6(%rip), %rdx # 0x2b714
movq %rbx, %rdi
movl $0x2, %esi
callq 0x86ba
jmp 0x2284e
leaq 0x8ddd(%rip), %rdx # 0x2b714
movq %rbx, %rdi
movl $0x3, %esi
callq 0x86ba
jmp 0x22859
| /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);
int lax = lua_toboolean(L, 4);
luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 2,
"initial position out of bounds");
luaL_argcheck(L, --posj < (lua_Integer)len, 3,
"final position out of bounds");
while (posi <= posj) {
const char *s1 = utf8_decode(s + posi, NULL, !lax);
if (s1 == NULL) { /* conversion error? */
luaL_pushfail(L); /* return fail ... */
lua_pushinteger(L, posi + 1); /* ... and current position */
return 2;
}
posi = ct_diff2S(s1 - s);
n++;
}
lua_pushinteger(L, n);
return 1;
} | 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, %rax
jae 0x22a28
xorl %ebx, %ebx
jmp 0x22a2e
addq %rax, %rbx
incq %rbx
movq %r15, %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0x8fb7
movq %rax, %r12
testq %rax, %rax
jns 0x22a64
movq (%rsp), %rax
movq %r12, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x22a5e
xorl %r12d, %r12d
jmp 0x22a64
addq %rax, %r12
incq %r12
movq %r15, %rdi
movl $0x4, %esi
callq 0x6b9e
movl %eax, %r13d
leaq -0x1(%rbx), %rax
testq %rbx, %rbx
cmovgq %rax, %rbx
jle 0x22b4a
cmpq (%rsp), %rax
jg 0x22b4a
cmpq (%rsp), %r12
jg 0x22b31
movq %r15, 0x8(%rsp)
xorl %ebp, %ebp
testl %r13d, %r13d
sete %bpl
xorl %r13d, %r13d
cmpq %r12, %rbx
jge 0x22b10
leaq (%r14,%rbx), %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x22be3
movq %rax, %r15
testq %rax, %rax
je 0x22acf
movq %r15, %rbx
subq %r14, %rbx
incq %r13
jmp 0x22b04
movq %r13, 0x10(%rsp)
movl %ebp, %r13d
movq %r14, %rbp
movq %r12, %r14
movq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x6d71
leaq 0x1(%rbx), %rsi
movq %r12, %rdi
movq %r14, %r12
movq %rbp, %r14
movl %r13d, %ebp
movq 0x10(%rsp), %r13
callq 0x6d91
testq %r15, %r15
jne 0x22aaa
movl $0x2, %eax
jmp 0x22b22
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x6d91
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8bea(%rip), %rdx # 0x2b722
movq %r15, %rdi
movl $0x3, %esi
callq 0x86ba
jmp 0x22a99
leaq 0x8bb2(%rip), %rdx # 0x2b703
movq %r15, %rdi
movl $0x2, %esi
callq 0x86ba
jmp 0x22a8f
| /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, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6fa4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x68aa
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6d91
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8b19(%rip), %rdx # 0x2b6ed
movq %rbx, %rdi
movl $0x1, %esi
callq 0x86ba
jmp 0x22b8c
| /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 count = 0; /* to count number of continuation bytes */
for (; c & 0x40; c <<= 1) { /* while it needs continuation bytes... */
unsigned int cc = (unsigned char)s[++count]; /* read next byte */
if (!iscont(cc)) /* not a continuation byte? */
return NULL; /* invalid byte sequence */
res = (res << 6) | (cc & 0x3F); /* add lower 6 bits from cont. byte */
}
res |= ((l_uint32)(c & 0x7F) << (count * 5)); /* add first byte */
if (count > 5 || res > MAXUTF || res < limits[count])
return NULL; /* invalid byte sequence */
s += count; /* skip continuation bytes read */
}
if (strict) {
/* check for invalid code points; too large or surrogates */
if (res > MAXUNICODE || (0xD800u <= res && res <= 0xDFFFu))
return NULL;
}
if (val) *val = res;
return s + 1; /* +1 to include first byte */
} | 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 %r11d, %ecx
cmpl $0x80, %r10d
cmovnel %r9d, %ecx
jne 0x22c7e
leal (%rdi,%rdi), %r9d
incq %r8
testb $0x20, %dil
movl %r9d, %edi
jne 0x22c07
movl %ecx, %edi
andl $0x3f, %r9d
leal (%r8,%r8,4), %ecx
shll %cl, %r9d
movl %r9d, %ecx
orl %edi, %ecx
xorl %r9d, %r9d
cmpl $0x5, %r8d
ja 0x22c81
testl %ecx, %ecx
js 0x22c81
movl %r8d, %edi
leaq 0x8a26(%rip), %r8 # 0x2b690
xorl %r10d, %r10d
cmpl (%r8,%rdi,4), %ecx
setae %r9b
cmovaeq %rdi, %r10
addq %r10, %rax
jmp 0x22c81
xorl %r9d, %r9d
movl %ecx, %edi
testb %r9b, %r9b
je 0x22caa
testl %edx, %edx
je 0x22cad
cmpl $0x110000, %edi # imm = 0x110000
setae %cl
movl %edi, %edx
andl $0x1ff800, %edx # imm = 0x1FF800
cmpl $0xd800, %edx # imm = 0xD800
sete %dl
orb %cl, %dl
je 0x22cad
xorl %eax, %eax
retq
testq %rsi, %rsi
je 0x22cb4
movl %edi, (%rsi)
incq %rax
retq
| /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) */
return 0; /* no more codepoints */
else {
l_uint32 code;
const char *next = utf8_decode(s + n, &code, strict);
if (next == NULL || iscontp(next))
return luaL_error(L, MSGInvalid);
lua_pushinteger(L, l_castU2S(n + 1));
lua_pushinteger(L, l_castU2S(code));
return 2;
}
} | 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, %r14
jae 0x22d5f
decq %r14
movb 0x1(%r12,%r14), %cl
andb $-0x40, %cl
incq %r14
negb %cl
jo 0x22d50
cmpq %rax, %r14
jae 0x22db9
addq %r14, %r12
leaq 0xc(%rsp), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0x22be3
testq %rax, %rax
je 0x22d83
movb (%rax), %al
andb $-0x40, %al
negb %al
jno 0x22d99
leaq 0x8963(%rip), %rsi # 0x2b6ed
movq %rbx, %rdi
xorl %eax, %eax
callq 0x87c6
movl %eax, %r15d
jmp 0x22db9
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6d91
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x6d91
movl $0x2, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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");
return 1;
} | 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
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x75d5
leaq 0x895b(%rip), %rsi # 0x2b773
movq %rbx, %rdi
callq 0x6e5b
leaq 0x8954(%rip), %rdx # 0x2b77b
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x75d5
movl $0x1, %eax
popq %rbx
retq
| /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!"); /* default message */
lua_settop(L, 1); /* leave only message (default if no other one) */
return luaB_error(L); /* call 'error' */
}
} | 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, LUA_GCGEN, LUA_GCINC,
LUA_GCPARAM};
int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
switch (o) {
case LUA_GCCOUNT: {
int k = lua_gc(L, o);
int b = lua_gc(L, LUA_GCCOUNTB);
checkvalres(k);
lua_pushnumber(L, (lua_Number)k + ((lua_Number)b/1024));
return 1;
}
case LUA_GCSTEP: {
lua_Integer n = luaL_optinteger(L, 2, 0);
int res = lua_gc(L, o, cast_sizet(n));
checkvalres(res);
lua_pushboolean(L, res);
return 1;
}
case LUA_GCISRUNNING: {
int res = lua_gc(L, o);
checkvalres(res);
lua_pushboolean(L, res);
return 1;
}
case LUA_GCGEN: {
return pushmode(L, lua_gc(L, o));
}
case LUA_GCINC: {
return pushmode(L, lua_gc(L, o));
}
case LUA_GCPARAM: {
static const char *const params[] = {
"minormul", "majorminor", "minormajor",
"pause", "stepmul", "stepsize", NULL};
static const char pnum[] = {
LUA_GCPMINORMUL, LUA_GCPMAJORMINOR, LUA_GCPMINORMAJOR,
LUA_GCPPAUSE, LUA_GCPSTEPMUL, LUA_GCPSTEPSIZE};
int p = pnum[luaL_checkoption(L, 2, NULL, params)];
lua_Integer value = luaL_optinteger(L, 3, -1);
lua_pushinteger(L, lua_gc(L, o, p, (int)value));
return 1;
}
default: {
int res = lua_gc(L, o);
checkvalres(res);
lua_pushinteger(L, res);
return 1;
}
}
luaL_pushfail(L); /* invalid call (inside a finalizer) */
return 1;
} | 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 (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
movl $0x3, %esi
xorl %eax, %eax
callq 0x7b58
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4, %esi
xorl %eax, %eax
callq 0x7b58
cmpl $-0x1, %ebp
je 0x22fbc
cvtsi2sd %ebp, %xmm1
cvtsi2sd %eax, %xmm0
mulsd 0x8846(%rip), %xmm0 # 0x2b740
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x6d7f
jmp 0x22fe9
movq %rbx, %rdi
movl $0x6, %esi
xorl %eax, %eax
callq 0x7b58
jmp 0x22fab
leaq 0x16b5a(%rip), %rcx # 0x39a80
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x8d12
cltq
leaq 0x882f(%rip), %rcx # 0x2b76d
movsbl (%rax,%rcx), %ebp
movq %rbx, %rdi
movl $0x3, %esi
movq $-0x1, %rdx
callq 0x8fb7
movq %rbx, %rdi
movl $0x9, %esi
movl %ebp, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x7b58
jmp 0x22f7d
movsbl %al, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7b58
cmpl $-0x1, %eax
je 0x22fbc
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x6d91
jmp 0x22fe9
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x8fb7
movq %rbx, %rdi
movl $0x5, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7b58
cmpl $-0x1, %eax
je 0x22fbc
movq %rbx, %rdi
movl %eax, %esi
callq 0x704c
jmp 0x22fe9
movq %rbx, %rdi
callq 0x6d71
jmp 0x22fe9
movq %rbx, %rdi
movl $0x7, %esi
jmp 0x22fd8
movq %rbx, %rdi
movl $0x8, %esi
xorl %eax, %eax
callq 0x7b58
movq %rbx, %rdi
movl %eax, %esi
callq 0x23a52
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /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 %esi, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x78e1
movq %rbx, %rdi
callq 0x663a
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7db6
| /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, %esi
callq 0x8a5d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x68aa
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7e4f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7db6
| /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);
status = luaL_loadbufferx(L, s, l, chunkname, mode);
}
else { /* loading from a reader function */
const char *chunkname = luaL_optstring(L, 2, "=(load)");
luaL_checktype(L, 1, LUA_TFUNCTION);
lua_settop(L, RESERVEDSLOT); /* create reserved slot */
status = lua_load(L, generic_reader, NULL, chunkname, mode);
}
return load_aux(L, status, env);
} | 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 %r15, %rdx
xorl %ecx, %ecx
callq 0x8da3
movq (%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rcx
movq %r14, %r8
callq 0x967b
jmp 0x2327c
leaq 0x866e(%rip), %rdx # 0x2b8a2
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x8da3
movq %rax, %r15
movq %rbx, %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x8e50
movq %rbx, %rdi
movl $0x5, %esi
callq 0x664e
leaq 0x8fd(%rip), %rsi # 0x23b69
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x7a59
xorl %edx, %edx
cmpl $-0x1, %ebp
setne %dl
shll $0x2, %edx
movq %rbx, %rdi
movl %eax, %esi
callq 0x23b09
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /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 %rbp
retq
| /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_pushvalue(L, 1); /* argument 'self' to metamethod */
lua_callk(L, 1, 3, 0, pairscont); /* get 3 values from metamethod */
}
return 3;
} | 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
callq 0x78e1
jmp 0x23360
leaq -0xa5(%rip), %rsi # 0x2329c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6fa4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x68aa
movq %rbx, %rdi
callq 0x6d71
movl $0x3, %eax
popq %rbx
retq
| /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 %ecx, %ecx
xorl %r8d, %r8d
callq 0x794a
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x23c34
| /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); /* add a tab before it */
lua_writestring(s, l); /* print it */
lua_pop(L, 1); /* pop result */
}
lua_writeline();
return 0;
} | 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 $0x2, %r12d
jb 0x23417
movq (%rbp), %rsi
movl $0x9, %edi
callq 0x53f0
movq (%rsp), %rdx
movq (%rbp), %rcx
movl $0x1, %esi
movq %r13, %rdi
callq 0x55a0
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
leal (%r14,%r12), %eax
incl %eax
movl %r12d, %ecx
incl %ecx
movl %ecx, %r12d
cmpl $0x1, %eax
jne 0x233f2
movq 0x16b65(%rip), %rbx # 0x39fb8
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x53f0
movq (%rbx), %rdi
callq 0x53b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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, lua_tostring(L, i), 1);
lua_warning(L, lua_tostring(L, n), 0); /* close warning */
return 0;
} | 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
incl %eax
movl %r14d, %ecx
incl %ecx
movl %ecx, %r14d
cmpl $0x1, %eax
jne 0x234aa
cmpl $0x2, %ebp
jl 0x234fa
movl $0x1, %r14d
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x6bb8
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x7f00
incl %r14d
cmpl %r14d, %ebp
jne 0x234d5
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x6bb8
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x7f00
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /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, "index out of range");
return n - (int)i;
}
} | 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, %rdi
callq 0x6d91
jmp 0x236af
movq %r14, %rdi
movl $0x1, %esi
callq 0x8f2d
movslq %ebx, %r15
leaq (%rax,%r15), %rcx
cmpq %r15, %rax
cmovlq %rax, %r15
testq %rax, %rax
cmovsq %rcx, %r15
testq %r15, %r15
jle 0x236bc
subl %r15d, %ebx
movl %ebx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x823e(%rip), %rdx # 0x2b901
movq %r14, %rdi
movl $0x1, %esi
callq 0x86ba
jmp 0x236aa
| /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");
lua_settop(L, 2);
lua_setmetatable(L, 1);
return 1;
} | 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 # 0x2b896
movq %rbx, %rdi
movl $0x1, %esi
callq 0x89f6
testl %eax, %eax
jne 0x23751
movq %rbx, %rdi
movl $0x2, %esi
callq 0x664e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x77dc
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x81c9(%rip), %rsi # 0x2b921
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x87c6
| /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 != NULL && lua_stringtonumber(L, s) == l + 1)
return 1; /* successful conversion to number */
/* else not a number */
luaL_checkany(L, 1); /* (but there must be some parameter) */
}
}
else {
size_t l;
const char *s;
lua_Integer n = 0; /* to avoid warnings */
lua_Integer base = luaL_checkinteger(L, 2);
luaL_checktype(L, 1, LUA_TSTRING); /* no numbers as strings */
s = lua_tolstring(L, 1, &l);
luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
if (b_str2int(s, cast_uint(base), &n) == s + l) {
lua_pushinteger(L, n);
return 1;
} /* else not a number */
} /* else not a number */
luaL_pushfail(L); /* not a number */
return 1;
} | 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 $0x1, %esi
callq 0x6bb8
movq %rax, %r12
movq %rax, %r14
leaq -0x2(%r15), %rax
cmpq $0x23, %rax
jae 0x23943
leaq 0x817d(%rip), %rsi # 0x2b957
movq %r14, %rdi
callq 0x5170
movb (%r14,%rax), %r13b
leal -0x2b(%r13), %ecx
andb $-0x3, %cl
cmpb $0x1, %cl
adcq %rax, %r12
callq 0x5360
movq (%rax), %rbp
movzbl (%r12), %eax
movq $0x0, (%rsp)
testb $0x8, (%rbp,%rax,2)
movl $0x0, %eax
je 0x2390c
movq %r13, 0x20(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movl %r15d, %r14d
movq $0x0, (%rsp)
xorl %r13d, %r13d
movzbl (%r12), %ebx
testb $0x8, 0x1(%rbp,%rbx,2)
jne 0x23851
callq 0x5090
movq (%rax), %rax
movl (%rax,%rbx,4), %eax
addl $-0x37, %eax
jmp 0x23857
movsbl %bl, %eax
addl $-0x30, %eax
cmpl %r15d, %eax
jae 0x23900
movq %r13, %rcx
imulq %r14, %rcx
movl %eax, %r13d
addq %rcx, %r13
movzbl 0x1(%r12), %eax
incq %r12
testb $0x8, (%rbp,%rax,2)
jne 0x23835
leaq 0x80d3(%rip), %rsi # 0x2b957
movq %r12, %rdi
callq 0x5170
addq %r12, %rax
movq %r13, %rcx
negq %rcx
cmpb $0x2d, 0x20(%rsp)
cmovneq %r13, %rcx
movq %rcx, (%rsp)
jmp 0x23902
movl $0x1, %esi
callq 0x68d4
cmpl $0x3, %eax
jne 0x238c2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x664e
jmp 0x2392f
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6bb8
testq %rax, %rax
je 0x238f1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6ae6
movq 0x8(%rsp), %rcx
incq %rcx
cmpq %rcx, %rax
je 0x2392f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8e84
jmp 0x23919
xorl %eax, %eax
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %rcx
addq %r14, %rcx
cmpq %rcx, %rax
je 0x23923
movq %rbx, %rdi
callq 0x6d71
jmp 0x2392f
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x6d91
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7ffb(%rip), %rdx # 0x2b945
movq %rbx, %rdi
movl $0x2, %esi
callq 0x86ba
jmp 0x237d3
| /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, n - 2, LUA_MULTRET, 2, 2, finishpcall);
return finishpcall(L, status, 2);
} | 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(%rip), %r9 # 0x23c34
movl $0x2, %r8d
movq %rbx, %rdi
movl %ebp, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0x2, %ecx
callq 0x794a
movl $0x2, %edx
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x23c34
| /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;
return NULL;
}
else if (l_unlikely(!lua_isstring(L, -1)))
luaL_error(L, "reader function must return a string");
lua_replace(L, RESERVEDSLOT); /* save string in reserved slot */
return lua_tolstring(L, RESERVEDSLOT, size);
} | 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 # imm = 0xFFFFFFFF
callq 0x68d4
testl %eax, %eax
je 0x23bfd
movq %r14, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x6960
testl %eax, %eax
je 0x23c1b
movq %r14, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl $0x5, %edx
callq 0x67d5
movq %r14, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
movq %r14, %rdi
movl $0x5, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6bb8
movq %r14, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7ca2(%rip), %rsi # 0x2b8c4
movq %r14, %rdi
xorl %eax, %eax
callq 0x87c6
jmp 0x23bc7
| /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(L) - (int)extra; /* return all results */
} | 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: {
setsvalue(fs->ls->L, v, e->u.strval);
return 1;
}
case VCONST: {
setobj(fs->ls->L, v, const2val(fs, e));
return 1;
}
default: return tonumeral(e, v);
}
} | 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)
jmp 0x23ccd
movb $0x11, 0x8(%rdx)
jmp 0x23ccd
movq 0x8(%rsi), %rax
movq %rax, (%rdx)
movb 0x8(%rax), %al
orb $0x40, %al
jmp 0x23cca
movq 0x10(%rdi), %rax
movq 0x58(%rax), %rax
movq (%rax), %rax
movslq 0x8(%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %rsi
movq %rsi, (%rdx)
movb 0x8(%rax,%rcx,8), %al
movb %al, 0x8(%rdx)
movl $0x1, %eax
retq
| /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_B(*previous);
if ((pfrom <= from && from <= pl + 1) ||
(from <= pfrom && pfrom <= l + 1)) { /* can connect both? */
if (pfrom < from) from = pfrom; /* from = min(from, pfrom) */
if (pl > l) l = pl; /* l = max(l, pl) */
SETARG_A(*previous, from);
SETARG_B(*previous, l - from);
return;
} /* else go through */
}
luaK_codeABC(fs, OP_LOADNIL, from, n - 1, 0); /* else no optimization */
} | 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
shrl $0x7, %r10d
movl $0xff, %r11d
andl %r11d, %r10d
movl %ecx, %r8d
shrl $0x10, %r8d
andl %r11d, %r8d
cmpl %esi, %r10d
setg %r11b
leal (%r10,%r8), %ebx
incl %ebx
cmpl %esi, %ebx
setl %bl
orb %r11b, %bl
cmpb $0x1, %bl
jne 0x23d88
cmpl %esi, %r10d
setl %r11b
cmpl %r9d, %r10d
setg %bl
orb %r11b, %bl
movb $0x1, %r11b
jne 0x23dc7
leal (%rdx,%rsi), %r11d
addl $0xff, %r11d
addl %r10d, %r8d
cmpl %esi, %r10d
cmovll %r10d, %esi
cmpl %r9d, %r8d
cmovll %r11d, %r8d
andl $0xff008008, %ecx # imm = 0xFF008008
movzbl %sil, %r9d
shll $0x7, %r9d
orl %ecx, %r9d
subl %esi, %r8d
movzbl %r8b, %ecx
shll $0x10, %ecx
orl %r9d, %ecx
movl %ecx, (%rax)
xorl %r11d, %r11d
testb %r11b, %r11b
popq %rbx
je 0x23de2
shll $0x7, %esi
shll $0x10, %edx
addl $0xffff0008, %edx # imm = 0xFFFF0008
orl %esi, %edx
movl %edx, %esi
jmp 0x23f8b
retq
| /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 */
list = next;
fixjump(fs, list, l2); /* last element links to 'l2' */
}
} | 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 0x23e42
movl %edx, (%rsi)
retq
| /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_JMP);
SETARG_sJ(*jmp, offset);
} | 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, %eax # imm = 0x7FFFFF80
movl %eax, (%rcx,%rdx,4)
retq
pushq %rax
movq 0x10(%rdi), %rdi
leaq 0x6a60(%rip), %rsi # 0x2a8e3
callq 0x27434
| /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 $0x7, %ebx
orl %r15d, %ebx
shll $0x10, %ebp
orl %ebx, %ebp
movq %r14, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x23f8b
| /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 */
list = next;
}
} | 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 $-0x1, %ecx
leal -0xfffffe(%r13,%rax), %r12d
cmovel %ecx, %r12d
movq %r15, %rdi
movl %r13d, %esi
movl %ebp, %edx
callq 0x25b2f
testl %eax, %eax
movl %r14d, %edx
cmovel %ebx, %edx
movq %r15, %rdi
movl %r13d, %esi
callq 0x23e42
cmpl $-0x1, %r12d
jne 0x23f1d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 new instruction */
} | 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 = 0x7FFFFFFF
callq 0x111d8
movq %rax, 0x40(%r14)
movslq 0x28(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x28(%rbx)
movl %ebp, (%rax,%rcx,4)
movq 0x10(%rbx), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23ffb
movl 0x28(%rbx), %eax
decl %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /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->sizeabslineinfo, AbsLineInfo, INT_MAX, "lines");
f->abslineinfo[fs->nabslineinfo].pc = pc;
f->abslineinfo[fs->nabslineinfo++].line = line;
linedif = ABSLINEINFO; /* signal that there is absolute information */
fs->iwthabs = 1; /* restart counter */
}
luaM_growvector(fs->ls->L, f->lineinfo, pc, f->sizelineinfo, ls_byte,
INT_MAX, "opcodes");
f->lineinfo[pc] = cast(ls_byte, linedif);
fs->previousline = line; /* last line saved */
} | 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(%r14)
testb %al, %al
jns 0x2408a
movq 0x10(%r14), %rax
movq 0x38(%rax), %rdi
movq 0x60(%r12), %rsi
movl 0x3c(%r14), %edx
leaq 0x28(%r12), %rcx
leaq 0x8093(%rip), %rax # 0x2c0e6
movq %rax, (%rsp)
movl $0x8, %r8d
movl $0x7fffffff, %r9d # imm = 0x7FFFFFFF
callq 0x111d8
movq %rax, 0x60(%r12)
movslq 0x3c(%r14), %rcx
movl %r15d, (%rax,%rcx,8)
leal 0x1(%rcx), %edx
movl %edx, 0x3c(%r14)
movl %ebx, 0x4(%rax,%rcx,8)
movb $0x1, 0x4d(%r14)
movl $0xffffff80, %ebp # imm = 0xFFFFFF80
movq 0x10(%r14), %rax
movq 0x38(%rax), %rdi
movq 0x58(%r12), %rsi
leaq 0x1c(%r12), %rcx
leaq 0x7ab5(%rip), %rax # 0x2bb58
movq %rax, (%rsp)
movl %r15d, %edx
movl $0x1, %r8d
movl $0x7fffffff, %r9d # imm = 0x7FFFFFFF
callq 0x111d8
movq %rax, 0x58(%r12)
movb %bpl, (%rax,%r15)
movl %ebx, 0x30(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /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 0x241b9
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
shll $0x7, %ebp
shll $0xf, %edx
addl $0x7fff8000, %edx # imm = 0x7FFF8000
orl %ebp, %edx
incl %edx
movq %rbx, %rdi
movl %edx, %esi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x23f8b
| /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
popq %rbx
popq %rbp
jmp 0x23f8b
| /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);
SETARG_C(*pc, nresults + 1);
SETARG_A(*pc, fs->freereg);
luaK_reserveregs(fs, 1);
}
} | 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,%r12,4), %eax
shll $0x18, %ebp
orl %eax, %ebp
cmpl $0x12, (%r14)
movl %ebp, (%r15,%r12,4)
je 0x24262
andl $0xffff807f, %ebp # imm = 0xFFFF807F
movzbl 0x4c(%rbx), %eax
shll $0x7, %eax
orl %ebp, %eax
movl %eax, (%r15,%r12,4)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x24102
incb 0x4c(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /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 if (e->k == VVARARG) {
SETARG_C(getinstruction(fs, e), 2);
e->k = VRELOC; /* can relocate its simple result */
}
} | 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(%rax,%rcx,4)
movl $0x11, (%rsi)
retq
| /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 = VNONRELOC; /* becomes a non-relocatable value */
break;
}
case VUPVAL: { /* move value to some (pending) register */
e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0);
e->k = VRELOC;
break;
}
case VINDEXUP: {
e->u.info = luaK_codeABC(fs, OP_GETTABUP, 0, e->u.ind.t, e->u.ind.idx);
e->k = VRELOC;
break;
}
case VINDEXI: {
freereg(fs, e->u.ind.t);
e->u.info = luaK_codeABC(fs, OP_GETI, 0, e->u.ind.t, e->u.ind.idx);
e->k = VRELOC;
break;
}
case VINDEXSTR: {
freereg(fs, e->u.ind.t);
e->u.info = luaK_codeABC(fs, OP_GETFIELD, 0, e->u.ind.t, e->u.ind.idx);
e->k = VRELOC;
break;
}
case VINDEXED: {
freeregs(fs, e->u.ind.t, e->u.ind.idx);
e->u.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.ind.t, e->u.ind.idx);
e->k = VRELOC;
break;
}
case VVARARG: case VCALL: {
luaK_setoneret(fs, e);
break;
}
default: break; /* there is one value available (somewhere) */
}
} | 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 0x58(%rax), %rax
movq (%rax), %rax
movslq 0x8(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
movzbl 0x8(%rax), %ecx
andl $0x3f, %ecx
cmpl $0x10, %ecx
jg 0x243ec
cmpl $0x4, %ecx
ja 0x243e7
movl %ecx, %ecx
leaq 0x769c(%rip), %rdx # 0x2b9b8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x1, (%rbx)
jmp 0x243e7
movb 0xa(%rbx), %bpl
movq %r14, %rdi
callq 0x13820
cmpb %bpl, %al
ja 0x24345
decb 0x4c(%r14)
movzbl 0xa(%rbx), %eax
movl 0x8(%rbx), %ecx
shll $0x10, %eax
shll $0x18, %ecx
leal (%rax,%rcx), %esi
addl $0xd, %esi
jmp 0x243d6
movzbl 0x8(%rbx), %eax
movl %eax, 0x8(%rbx)
movl $0x8, (%rbx)
jmp 0x243e7
movl 0x8(%rbx), %esi
shll $0x10, %esi
orl $0x9, %esi
jmp 0x243d6
movb 0xa(%rbx), %bpl
movq %r14, %rdi
callq 0x13820
cmpb %bpl, %al
ja 0x24389
decb 0x4c(%r14)
movzbl 0xa(%rbx), %eax
movl 0x8(%rbx), %ecx
shll $0x10, %eax
shll $0x18, %ecx
leal (%rax,%rcx), %esi
addl $0xe, %esi
jmp 0x243d6
movzbl 0xa(%rbx), %esi
movswl 0x8(%rbx), %edx
movq %r14, %rdi
callq 0x24433
movzbl 0xa(%rbx), %eax
movl 0x8(%rbx), %ecx
shll $0x10, %eax
shll $0x18, %ecx
leal (%rax,%rcx), %esi
addl $0xc, %esi
jmp 0x243d6
movzbl 0xa(%rbx), %eax
movl 0x8(%rbx), %ecx
shll $0x10, %eax
shll $0x18, %ecx
leal (%rax,%rcx), %esi
addl $0xb, %esi
movq %r14, %rdi
callq 0x23f8b
movl %eax, 0x8(%rbx)
movl $0x11, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x11, %ecx
je 0x2441a
cmpl $0x13, %ecx
je 0x24422
cmpl $0x14, %ecx
jne 0x243e7
movl $0x7, (%rbx)
jmp 0x24409
movl $0x6, (%rbx)
movq (%rax), %rax
movq %rax, 0x8(%rbx)
jmp 0x243e7
movl $0x3, (%rbx)
jmp 0x243e7
movl $0x2, (%rbx)
jmp 0x243e7
movl $0x5, (%rbx)
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0x243e7
| /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)
movzbl %al, %edx
decl %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x244d6
| /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; /* position of an eventual LOAD false */
int p_t = NO_JUMP; /* position of an eventual LOAD true */
if (need_value(fs, e->t) || need_value(fs, e->f)) {
int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
p_f = code_loadbool(fs, reg, OP_LFALSESKIP); /* skip next inst. */
p_t = code_loadbool(fs, reg, OP_LOADTRUE);
/* jump around these booleans if 'e' is not a test */
luaK_patchtohere(fs, fj);
}
final = luaK_getlabel(fs);
patchlistaux(fs, e->f, final, reg, p_f);
patchlistaux(fs, e->t, final, reg, p_t);
}
e->f = e->t = NO_JUMP;
e->u.info = reg;
e->k = VNONRELOC;
} | 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 %r14, %rdi
callq 0x25e2f
testl %eax, %eax
jne 0x24531
movq %r14, %rdi
movl %r15d, %esi
callq 0x25e2f
testl %eax, %eax
je 0x245ee
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
cmpl $0x10, (%rbx)
je 0x2454c
movq %r14, %rdi
movl $0x7fffff38, %esi # imm = 0x7FFFFF38
callq 0x23f8b
movl %eax, %r15d
movl 0x28(%r14), %eax
movl %eax, 0x2c(%r14)
movl %ebp, %r12d
shll $0x7, %r12d
leal 0x6(%r12), %esi
movq %r14, %rdi
callq 0x23f8b
movl %eax, %r13d
movl 0x28(%r14), %eax
movl %eax, 0x2c(%r14)
orl $0x7, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x23f8b
movl %eax, %r12d
movl 0x28(%r14), %edx
movl %edx, 0x2c(%r14)
movq %r14, %rdi
movl %r15d, %esi
movl $0xff, %ecx
movl %edx, %r8d
callq 0x23eff
movl 0x28(%r14), %r15d
movl %r15d, 0x2c(%r14)
movl 0x14(%rbx), %esi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
movl %r13d, %r8d
callq 0x23eff
movl 0x10(%rbx), %esi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
movl %r12d, %r8d
callq 0x23eff
movq $-0x1, 0x10(%rbx)
movl %ebp, 0x8(%rbx)
movl $0x8, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
jmp 0x245a0
| /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 */
}
discharge2anyreg(fs, e);
freeexp(fs, e);
return condjump(fs, OP_TESTSET, NO_REG, e->u.info, 0, cond);
} | 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(%rdx), %rdx
movsbl -0x1(%rdx,%rax), %edx
cmpl $-0x80, %edx
jne 0x2490c
decl 0x3c(%rbx)
movb $-0x7f, 0x4d(%rbx)
jmp 0x24912
subl %edx, 0x30(%rbx)
decb 0x4d(%rbx)
decl %eax
movl %eax, 0x28(%rbx)
xorl %eax, %eax
testl %ebp, %ebp
sete %al
shrl $0x9, %ecx
andl $0x7f80, %ecx # imm = 0x7F80
shll $0xf, %eax
leal (%rax,%rcx), %esi
addl $0x42, %esi
movq %rbx, %rdi
callq 0x23f8b
movq %rbx, %rdi
movl $0x7fffff38, %esi # imm = 0x7FFFFF38
callq 0x23f8b
cmpl $0x33, %r15d
jne 0x24956
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25f69
cmpl $0x8, (%r14)
jne 0x2497e
movl 0x8(%r14), %r15d
movq %rbx, %rdi
callq 0x13820
movzbl %al, %eax
cmpl %eax, %r15d
jl 0x2497e
decb 0x4c(%rbx)
movl 0x8(%r14), %eax
shll $0x10, %eax
shll $0xf, %ebp
orl %eax, %ebp
orl $0x7fc3, %ebp # imm = 0x7FC3
movq %rbx, %rdi
movl %ebp, %esi
callq 0x23f8b
movq %rbx, %rdi
movl $0x7fffff38, %esi # imm = 0x7FFFFF38
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x23f8b
| /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;
}
default: {
pc = jumponcond(fs, e, 1); /* jump if true */
break;
}
}
luaK_concat(fs, &e->t, pc); /* insert new jump in 't' list */
luaK_patchtohere(fs, e->f); /* false list jumps to here (to go through) */
e->f = NO_JUMP;
} | 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 0x248be
movl %eax, %edx
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x23e01
movl 0x14(%rbx), %esi
movl 0x28(%r14), %edx
movl %edx, 0x2c(%r14)
movq %r14, %rdi
movl $0xff, %ecx
movl %edx, %r8d
callq 0x23eff
movl $0xffffffff, 0x14(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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 */
luaK_reserveregs(fs, 2); /* method and 'self' produced by op_self */
lua_assert(key->k == VKSTR);
/* is method name a short string in a valid K index? */
if (strisshr(key->u.strval) && luaK_exp2K(fs, key)) {
/* can use 'self' opcode */
luaK_codeABCk(fs, OP_SELF, base, ereg, key->u.info, 0);
}
else { /* cannot use 'self' opcode; use move+gettable */
luaK_exp2anyreg(fs, key); /* put method name in a register */
luaK_codeABC(fs, OP_MOVE, base + 1, ereg, 0); /* copy self to base+1 */
luaK_codeABC(fs, OP_GETTABLE, base, ereg, key->u.info); /* get method */
}
freeexp(fs, key);
} | 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, 0x8(%r15)
movl $0x8, (%r15)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x24102
addb $0x2, 0x4c(%rbx)
movq 0x8(%r14), %rax
cmpb $0x0, 0xb(%rax)
js 0x24aad
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24b15
testl %eax, %eax
je 0x24aad
movl 0x8(%r14), %esi
shll $0x7, %r13d
shll $0x10, %r12d
orl %r13d, %r12d
shll $0x18, %esi
orl %r12d, %esi
orl $0x14, %esi
jmp 0x24ae2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x245fc
shll $0x7, %r13d
shll $0x10, %r12d
leal (%r12,%r13), %ebp
leal (%r12,%r13), %esi
addl $0x80, %esi
movq %rbx, %rdi
callq 0x23f8b
movl 0x8(%r14), %esi
shll $0x18, %esi
orl %ebp, %esi
orl $0xc, %esi
movq %rbx, %rdi
callq 0x23f8b
cmpl $0x8, (%r14)
jne 0x24b06
movl 0x8(%r14), %ebp
movq %rbx, %rdi
callq 0x13820
movzbl %al, %eax
cmpl %eax, %ebp
jl 0x24b06
decb 0x4c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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); break;
case VKFLT: info = luaK_numberK(fs, e->u.nval); break;
case VKSTR: info = stringK(fs, e->u.strval); break;
case VK: info = e->u.info; break;
default: return 0; /* not a constant */
}
if (info <= MAXINDEXRK) { /* does constant fit in 'argC'? */
e->k = VK; /* make expression a 'K' expression */
e->u.info = info;
return 1;
}
}
/* else, expression doesn't fit; leave it unchanged */
return 0;
} | 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 %rsp, %rsi
movq %rax, (%rsi)
movb $0x45, 0x8(%rsi)
jmp 0x24ba7
movsd 0x8(%rbx), %xmm0
callq 0x25e9c
jmp 0x24bac
movq %rsp, %rdx
movb $0x1, 0x8(%rdx)
jmp 0x24ba4
movl 0x8(%rbx), %eax
jmp 0x24bac
xorl %eax, %eax
jmp 0x24bc1
movq %rsp, %rdx
movb $0x11, 0x8(%rdx)
jmp 0x24ba4
movq 0x8(%rbx), %rax
movq %rsp, %rdx
movq %rax, (%rdx)
movb $0x3, 0x8(%rdx)
jmp 0x24ba4
movq 0x8(%rbx), %rax
movq %rsp, %rdx
movq %rax, (%rdx)
movb 0x8(%rax), %al
orb $0x40, %al
movb %al, 0x8(%rdx)
movq %rdx, %rsi
callq 0x25ba6
cmpl $0xff, %eax
jg 0x24bc5
movl $0x4, (%rbx)
movl %eax, 0x8(%rbx)
movl $0x1, %eax
xorl %ecx, %ecx
jmp 0x24bc7
movb $0x1, %cl
testb %cl, %cl
leaq 0x20(%rsp), %rsp
popq %rbx
je 0x24bd3
xorl %eax, %eax
retq
| /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 register */
if (t->k == VUPVAL) {
lu_byte temp = cast_byte(t->u.info); /* upvalue index */
lua_assert(isKstr(fs, k));
t->u.ind.t = temp; /* (can't do a direct assignment; values overlap) */
t->u.ind.idx = cast(short, k->u.info); /* literal short string */
t->k = VINDEXUP;
}
else {
/* register index of the table */
t->u.ind.t = cast_byte((t->k == VLOCAL) ? t->u.var.ridx: t->u.info);
if (isKstr(fs, k)) {
t->u.ind.idx = cast(short, k->u.info); /* literal short string */
t->k = VINDEXSTR;
}
else if (isCint(k)) { /* int. constant in proper range? */
t->u.ind.idx = cast(short, k->u.ival);
t->k = VINDEXI;
}
else {
t->u.ind.idx = cast(short, luaK_exp2anyreg(fs, k)); /* register */
t->k = VINDEXED;
}
}
} | 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, (%r14)
cmpl $0xa, (%rbx)
jne 0x24c51
cmpl $0x4, (%r14)
jne 0x24c46
movl 0x10(%r14), %eax
cmpl 0x14(%r14), %eax
jne 0x24c46
movslq 0x8(%r14), %rax
cmpq $0xff, %rax
jg 0x24c46
movq (%r15), %rcx
movq 0x38(%rcx), %rcx
shlq $0x4, %rax
cmpb $0x44, 0x8(%rcx,%rax)
je 0x24c51
movq %r15, %rdi
movq %rbx, %rsi
callq 0x245fc
movl (%rbx), %eax
cmpl $0x9, %eax
je 0x24c73
cmpl $0xa, %eax
jne 0x24c73
movb 0x8(%rbx), %al
movb %al, 0xa(%rbx)
movzwl 0x8(%r14), %eax
movw %ax, 0x8(%rbx)
movl $0xd, %eax
jmp 0x24cec
movb 0x8(%rbx), %al
movb %al, 0xa(%rbx)
movl (%r14), %eax
cmpl $0x6, %eax
je 0x24cc4
cmpl $0x4, %eax
jne 0x24cd8
movl 0x10(%r14), %ecx
cmpl 0x14(%r14), %ecx
jne 0x24cbf
movslq 0x8(%r14), %rcx
cmpq $0xff, %rcx
jg 0x24cbf
movq (%r15), %rdx
movq 0x38(%rdx), %rdx
shlq $0x4, %rcx
cmpb $0x44, 0x8(%rdx,%rcx)
jne 0x24cbf
movzwl 0x8(%r14), %eax
movw %ax, 0x8(%rbx)
movl $0xf, %eax
jmp 0x24cec
cmpl $0x6, %eax
jne 0x24cd8
movl 0x10(%r14), %eax
cmpl 0x14(%r14), %eax
jne 0x24cd8
cmpq $0xff, 0x8(%r14)
jbe 0x24cf8
movq %r15, %rdi
movq %r14, %rsi
callq 0x245fc
movw %ax, 0x8(%rbx)
movl $0xc, %eax
movl %eax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movzwl 0x8(%r14), %eax
movw %ax, 0x8(%rbx)
movl $0xe, %eax
jmp 0x24cec
| /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))
break;
/* else */ /* FALLTHROUGH */
case OPR_LEN:
codeunexpval(fs, unopr2op(opr), e, line);
break;
case OPR_NOT: codenot(fs, e); break;
default: lua_assert(0);
}
} | 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
cmpl $0x8, (%r14)
jne 0x24d67
movl 0x8(%r14), %r13d
movq %rbx, %rdi
callq 0x13820
movzbl %al, %eax
cmpl %eax, %r13d
jl 0x24d67
decb 0x4c(%rbx)
shll $0x10, %r12d
orl %r15d, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x23f8b
movl %eax, 0x8(%r14)
movl $0x11, (%r14)
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x25947
leal 0xc(%r15), %esi
leaq 0x6d91(%rip), %rcx # 0x2bb38
movq %rbx, %rdi
movq %r14, %rdx
callq 0x24ea3
testl %eax, %eax
je 0x24d38
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%r14), %eax
decl %eax
cmpl $0x10, %eax
ja 0x24e71
leaq 0x6c2a(%rip), %rcx # 0x2ba04
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, (%r14)
jmp 0x24e71
movl $0x2, (%r14)
jmp 0x24e71
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25f69
cmpl $0x8, (%r14)
jne 0x24e1f
movl 0x8(%r14), %ebp
movq %rbx, %rdi
callq 0x13820
movzbl %al, %eax
cmpl %eax, %ebp
jl 0x24e1f
decb 0x4c(%rbx)
movl 0x8(%r14), %esi
shll $0x10, %esi
orl $0x33, %esi
movq %rbx, %rdi
callq 0x23f8b
movl %eax, 0x8(%r14)
movl $0x11, (%r14)
jmp 0x24e71
movslq 0x8(%r14), %rcx
movq (%rbx), %rdx
leaq (,%rcx,4), %rax
addq 0x40(%rdx), %rax
testq %rcx, %rcx
jle 0x24e6d
movl -0x4(%rax), %ecx
andl $0x7f, %ecx
leaq 0x557d(%rip), %rdx # 0x2a3e0
testb $0x10, (%rcx,%rdx)
je 0x24e6d
addq $-0x4, %rax
xorb $-0x80, 0x1(%rax)
movl 0x10(%r14), %esi
movl 0x14(%r14), %eax
movl %esi, 0x14(%r14)
movl %eax, 0x10(%r14)
movq %rbx, %rdi
callq 0x25fa4
movl 0x10(%r14), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x25fa4
| /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, &v2, &res); /* does operation */
if (ttisinteger(&res)) {
e1->k = VKINT;
e1->u.ival = ivalue(&res);
}
else { /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */
lua_Number n = fltvalue(&res);
if (luai_numisnan(n) || n == 0)
return 0;
e1->k = VKFLT;
e1->u.nval = n;
}
return 1;
} | 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(%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movb %al, 0x28(%rsp)
movl 0x10(%rcx), %eax
cmpl 0x14(%rcx), %eax
jne 0x24ff7
movl (%rcx), %eax
cmpl $0x6, %eax
je 0x24f0b
cmpl $0x5, %eax
jne 0x24ff7
movb $0x13, %al
jmp 0x24f0d
movb $0x3, %al
movsd 0x8(%rcx), %xmm0
movsd %xmm0, (%rsp)
movb %al, 0x8(%rsp)
movl $0x1, %r12d
cmpl $0xd, %ebp
ja 0x24f98
movl $0x2f80, %eax # imm = 0x2F80
btl %ebp, %eax
jae 0x24f62
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
xorl %r12d, %r12d
xorl %edx, %edx
callq 0x1dca6
testl %eax, %eax
je 0x24f98
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x1dca6
xorl %r12d, %r12d
testl %eax, %eax
setne %r12b
jmp 0x24f98
movl $0x68, %eax
btl %ebp, %eax
jae 0x24f98
cmpb $0x3, 0x8(%rsp)
movq (%rsp), %rax
je 0x24f7e
movq %rax, %xmm0
jmp 0x24f86
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movq %xmm1, %r12
andl $0x1, %r12d
testl %r12d, %r12d
je 0x24ff7
movq 0x10(%r15), %rax
movq 0x38(%rax), %rdi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
leaq 0x10(%rsp), %r15
movl %ebp, %esi
movq %r15, %r8
callq 0x1221e
cmpb $0x3, 0x8(%r15)
jne 0x24fd5
movl $0x6, (%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%r14)
jmp 0x24ff2
movsd 0x10(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
je 0x24ff7
movl $0x5, (%r14)
movsd %xmm0, 0x8(%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /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 OPR_CONCAT: {
luaK_exp2nextreg(fs, v); /* operand must be on the stack */
break;
}
case OPR_ADD: case OPR_SUB:
case OPR_MUL: case OPR_DIV: case OPR_IDIV:
case OPR_MOD: case OPR_POW:
case OPR_BAND: case OPR_BOR: case OPR_BXOR:
case OPR_SHL: case OPR_SHR: {
if (!tonumeral(v, NULL))
luaK_exp2anyreg(fs, v);
/* else keep numeral, which may be folded or used as an immediate
operand */
break;
}
case OPR_EQ: case OPR_NE: {
if (!tonumeral(v, NULL))
exp2RK(fs, v);
/* else keep numeral, which may be an immediate operand */
break;
}
case OPR_LT: case OPR_LE:
case OPR_GT: case OPR_GE: {
int dummy, dummy2;
if (!isSCnumber(v, &dummy, &dummy2))
luaK_exp2anyreg(fs, v);
/* else keep numeral, which may be an immediate operand */
break;
}
default: lua_assert(0);
}
} | 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
movl (%rbx), %eax
addl $-0x7, %eax
cmpl $-0x3, %eax
ja 0x2509f
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x245fc
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x25110
testl %eax, %eax
jne 0x2509f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x245fc
jmp 0x2509f
movl 0x10(%rbx), %eax
cmpl 0x14(%rbx), %eax
jne 0x2508f
movl (%rbx), %eax
addl $-0x7, %eax
cmpl $-0x3, %eax
ja 0x2509f
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x250e1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x24484
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x249b1
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x24814
| /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); /* list closed by 'luaK_infix' */
luaK_concat(fs, &e2->f, e1->f);
*e1 = *e2;
break;
}
case OPR_OR: {
lua_assert(e1->f == NO_JUMP); /* list closed by 'luaK_infix' */
luaK_concat(fs, &e2->t, e1->t);
*e1 = *e2;
break;
}
case OPR_CONCAT: { /* e1 .. e2 */
luaK_exp2nextreg(fs, e2);
codeconcat(fs, e1, e2, line);
break;
}
case OPR_ADD: case OPR_MUL: {
codecommutative(fs, opr, e1, e2, line);
break;
}
case OPR_SUB: {
if (finishbinexpneg(fs, e1, e2, OP_ADDI, line, TM_SUB))
break; /* coded as (r1 + -I) */
/* ELSE */
} /* FALLTHROUGH */
case OPR_DIV: case OPR_IDIV: case OPR_MOD: case OPR_POW: {
codearith(fs, opr, e1, e2, 0, line);
break;
}
case OPR_BAND: case OPR_BOR: case OPR_BXOR: {
codebitwise(fs, opr, e1, e2, line);
break;
}
case OPR_SHL: {
if (isSCint(e1)) {
swapexps(e1, e2);
codebini(fs, OP_SHLI, e1, e2, 1, line, TM_SHL); /* I << r2 */
}
else if (finishbinexpneg(fs, e1, e2, OP_SHRI, line, TM_SHL)) {
/* coded as (r1 >> -I) */;
}
else /* regular case (two registers) */
codebinexpval(fs, opr, e1, e2, line);
break;
}
case OPR_SHR: {
if (isSCint(e2))
codebini(fs, OP_SHRI, e1, e2, 0, line, TM_SHR); /* r1 >> I */
else /* regular case (two registers) */
codebinexpval(fs, opr, e1, e2, line);
break;
}
case OPR_EQ: case OPR_NE: {
codeeq(fs, opr, e1, e2);
break;
}
case OPR_GT: case OPR_GE: {
/* '(a > b)' <=> '(b < a)'; '(a >= b)' <=> '(b <= a)' */
swapexps(e1, e2);
opr = cast(BinOpr, (opr - OPR_GT) + OPR_LT);
} /* FALLTHROUGH */
case OPR_LT: case OPR_LE: {
codeorder(fs, opr, e1, e2);
break;
}
default: lua_assert(0);
}
} | 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
jne 0x25727
cmpl $0x14, %r12d
ja 0x25727
movl %r12d, %eax
leaq 0x68b3(%rip), %rcx # 0x2ba9c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
jmp 0x2532e
xorl %ebp, %ebp
cmpl $0x6, (%rbx)
jne 0x25244
movq 0x10(%rbx), %rax
movq %rax, 0x20(%rsp)
movups (%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rbx)
movups (%r15), %xmm0
movups %xmm0, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%r15)
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r15)
movl $0x1, %ebp
cmpl $0x6, (%r15)
jne 0x25281
movq %r14, %rdi
movq %r15, %rsi
callq 0x24b15
testl %eax, %eax
je 0x25281
leal 0x6(%r12), %eax
movl 0x8(%r15), %r8d
addl $0x16, %r12d
subq $0x8, %rsp
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %r12d, %ecx
movl %ebp, %r9d
pushq %rax
pushq $0x30
jmp 0x257c7
movq %r14, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movq %r15, %rcx
movl %ebp, %r8d
movl %r13d, %r9d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x260cb
movl 0x10(%rbx), %eax
xorl %r9d, %r9d
cmpl 0x14(%rbx), %eax
jne 0x252f3
movl (%rbx), %eax
addl $-0x7, %eax
cmpl $-0x2, %eax
jb 0x252f3
movq 0x10(%rbx), %rax
movq %rax, 0x20(%rsp)
movups (%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rbx)
movups (%r15), %xmm0
movups %xmm0, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%r15)
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r15)
movl $0x1, %r9d
testl %r12d, %r12d
jne 0x2531f
cmpl $0x6, (%r15)
jne 0x2531f
movl 0x10(%r15), %eax
cmpl 0x14(%r15), %eax
jne 0x2531f
movq 0x8(%r15), %r8
leaq -0x81(%r8), %rax
cmpq $-0x100, %rax
jae 0x257ad
movq %r14, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movq %r15, %rcx
movl %r9d, %r8d
movl %r13d, %r9d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x25852
movl $0x0, 0xc(%rsp)
cmpl $0x8, (%rbx)
je 0x25383
movq 0x10(%rbx), %rax
movq %rax, 0x20(%rsp)
movups (%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rbx)
movups (%r15), %xmm0
movups %xmm0, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%r15)
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x245fc
movl %eax, %ebp
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %r15, %rdi
callq 0x25110
testl %eax, %eax
movl %ebp, 0x34(%rsp)
je 0x255bf
movl $0x3d, %ebp
movl 0x10(%rsp), %r13d
jmp 0x256bd
movq 0x10(%rbx), %rax
movq %rax, 0x20(%rsp)
movups (%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rbx)
movups (%r15), %xmm0
movups %xmm0, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%r15)
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r15)
addl $-0x3, %r12d
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x25110
testl %eax, %eax
je 0x25423
movq %r14, %rdi
movq %rbx, %rsi
callq 0x245fc
movl %eax, %ebp
movl $0x30, %eax
jmp 0x2544f
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x25110
movq %r14, %rdi
testl %eax, %eax
je 0x255e0
movq %r15, %rsi
callq 0x245fc
movl %eax, %ebp
movl $0x32, %eax
movl 0x10(%rsp), %r13d
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpl $0x8, (%rbx)
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
jne 0x25466
movl 0x8(%rbx), %esi
addl %eax, %r12d
cmpl $0x8, (%r15)
jne 0x25473
movl 0x8(%r15), %edx
movq %r14, %rdi
callq 0x24433
movl 0xc(%rsp), %esi
shll $0x7, %ebp
orl %r12d, %ebp
shll $0x10, %r13d
orl %ebp, %r13d
shll $0x18, %esi
orl %r13d, %esi
orl $0x8000, %esi # imm = 0x8000
jmp 0x25709
cmpl $0x6, (%r15)
jne 0x254c4
movl 0x10(%r15), %eax
cmpl 0x14(%r15), %eax
jne 0x254c4
movq $-0x81, %rax
addq 0x8(%r15), %rax
cmpq $-0x100, %rax
jae 0x25736
movq %r14, %rdi
movl $0xb, %esi
jmp 0x25577
movq %r14, %rdi
movq %r15, %rsi
callq 0x24484
movslq 0x28(%r14), %rax
cmpl 0x2c(%r14), %eax
jle 0x25602
movq (%r14), %rcx
movq 0x40(%rcx), %rcx
leaq (%rcx,%rax,4), %r12
addq $-0x4, %r12
jmp 0x25609
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x15, %ecx
movl %r13d, %r8d
movl $0x7, %r9d
callq 0x257d7
testl %eax, %eax
jne 0x25727
jmp 0x251f2
cmpl $0x6, (%rbx)
jne 0x2554b
movl 0x10(%rbx), %eax
cmpl 0x14(%rbx), %eax
jne 0x2554b
movq $-0x81, %rax
addq 0x8(%rbx), %rax
cmpq $-0x100, %rax
jae 0x25757
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x20, %ecx
movl %r13d, %r8d
movl $0x10, %r9d
callq 0x257d7
testl %eax, %eax
jne 0x25727
movq %r14, %rdi
movl $0xa, %esi
movq %rbx, %rdx
movq %r15, %rcx
movl %r13d, %r8d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x258ee
leaq 0x10(%r15), %rsi
movl 0x10(%rbx), %edx
jmp 0x255a3
leaq 0x14(%r15), %rsi
movl 0x14(%rbx), %edx
movq %r14, %rdi
callq 0x23e01
movq 0x10(%r15), %rax
movq %rax, 0x10(%rbx)
movups (%r15), %xmm0
movups %xmm0, (%rbx)
jmp 0x25727
movq %r14, %rdi
movq %r15, %rsi
callq 0x250e1
testl %eax, %eax
je 0x256aa
movl 0x8(%r15), %r13d
movl $0x3c, %ebp
jmp 0x256bd
movq %rbx, %rsi
callq 0x245fc
movl %eax, %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x245fc
movl %eax, %r13d
movl $0x2c, %eax
jmp 0x25454
leaq 0x657f(%rip), %r12 # 0x2bb88
movl (%r12), %ebp
movl %ebp, %eax
andl $0x7f, %eax
cmpl $0x35, %eax
jne 0x25660
cmpl $0x8, (%r15)
jne 0x25635
movl 0x8(%r15), %r15d
movq %r14, %rdi
callq 0x13820
movzbl %al, %eax
cmpl %eax, %r15d
jl 0x25635
decb 0x4c(%r14)
movl $0xff00807f, %eax # imm = 0xFF00807F
andl (%r12), %eax
movl 0x8(%rbx), %ecx
movzbl %cl, %ecx
shll $0x7, %ecx
addl $0x10000, %ebp # imm = 0x10000
andl $0xff0000, %ebp # imm = 0xFF0000
orl %eax, %ebp
orl %ecx, %ebp
movl %ebp, (%r12)
jmp 0x25727
movl 0x8(%rbx), %esi
shll $0x7, %esi
orl $0x20035, %esi # imm = 0x20035
movq %r14, %rdi
callq 0x23f8b
cmpl $0x8, (%r15)
jne 0x25691
movl 0x8(%r15), %ebx
movq %r14, %rdi
callq 0x13820
movzbl %al, %eax
cmpl %eax, %ebx
jl 0x25691
decb 0x4c(%r14)
movq %r14, %rdi
movl %r13d, %esi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x25947
movq %r14, %rdi
movq %r15, %rsi
callq 0x245fc
movl %eax, %r13d
movl $0x39, %ebp
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpl $0x8, (%rbx)
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
jne 0x256cf
movl 0x8(%rbx), %esi
cmpl $0x8, (%r15)
jne 0x256d9
movl 0x8(%r15), %edx
movq %r14, %rdi
callq 0x24433
movl 0xc(%rsp), %eax
xorl %esi, %esi
cmpl $0xd, %r12d
sete %sil
movl 0x34(%rsp), %ecx
shll $0x7, %ecx
orl %ecx, %ebp
shll $0x10, %r13d
shll $0x18, %eax
orl %ebp, %eax
shll $0xf, %esi
orl %r13d, %esi
orl %eax, %esi
movq %r14, %rdi
callq 0x23f8b
movq %r14, %rdi
movl $0x7fffff38, %esi # imm = 0x7FFFFF38
callq 0x23f8b
movl %eax, 0x8(%rbx)
movl $0x10, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%r15), %r8d
addl $0x7f, %r8d
subq $0x8, %rsp
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x20, %ecx
xorl %r9d, %r9d
pushq $0x11
jmp 0x257c5
movq 0x10(%rbx), %rax
movq %rax, 0x20(%rsp)
movups (%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rbx)
movups (%r15), %xmm0
movups %xmm0, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%r15)
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r15)
movl 0x8(%r15), %r8d
addl $0x7f, %r8d
subq $0x8, %rsp
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x21, %ecx
movl $0x1, %r9d
pushq $0x10
jmp 0x257c5
addl $0x7f, %r8d
subq $0x8, %rsp
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x15, %ecx
pushq $0x6
pushq $0x2f
pushq %r13
callq 0x25fef
addq $0x58, %rsp
jmp 0x2572b
| /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 */
else { /* operating a small integer constant */
int v2 = cast_int(i2);
finishbinexpval(fs, e1, e2, op, int2sC(-v2), 0, line, OP_MMBINI, event);
/* correct metamethod argument */
SETARG_B(fs->f->code[fs->pc - 1], int2sC(v2));
return 1; /* successfully coded */
}
}
} | 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, %rdi
xorl %r9d, %r9d
pushq %r10
pushq $0x2f
pushq %r11
callq 0x25fef
addq $0x20, %rsp
movq (%rbx), %rax
movq 0x40(%rax), %rax
movslq 0x28(%rbx), %rcx
shll $0x10, %r14d
addl $0x7f0000, %r14d # imm = 0x7F0000
shrl $0x10, %r14d
movb %r14b, -0x2(%rax,%rcx,4)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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, flip, line);
} | 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, %rsi
callq 0x24b15
testl %eax, %eax
je 0x258c9
leal 0x6(%r12), %eax
movl 0x8(%r14), %r8d
addl $0x16, %r12d
subq $0x8, %rsp
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %r12d, %ecx
movl %ebp, %r9d
pushq %rax
pushq $0x30
pushq %rbx
callq 0x25fef
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x260cb
| /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((VNIL <= e1->k && e1->k <= VKSTR) ||
e1->k == VNONRELOC || e1->k == VRELOC);
lua_assert(OP_ADD <= op && op <= OP_SHR);
finishbinexpval(fs, e1, e2, op, v2, 0, line, OP_MMBIN, binopr2TM(opr));
} | 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, %r8d
xorl %r9d, %r9d
pushq %r12
pushq $0x2e
pushq %rbx
callq 0x25fef
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 */
hsize = (hsize != 0) ? luaO_ceillog2(cast_uint(hsize)) + 1 : 0;
*inst = CREATE_vABCk(OP_NEWTABLE, ra, hsize, rc, k);
*(inst + 1) = CREATE_Ax(OP_EXTRAARG, extra);
} | 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, %ecx
cmpl $0x400, %ebx # imm = 0x400
setge %cl
leal 0x3ff(%rbx), %edx
testl %ebx, %ebx
cmovnsl %ebx, %edx
sarl $0xa, %edx
movslq %r14d, %rsi
shll $0x7, %ebp
shll $0x16, %ebx
orl %ebp, %ebx
orl %eax, %ebx
shll $0xf, %ecx
orl %ebx, %ecx
orl $0x13, %ecx
movl %ecx, (%r15,%rsi,4)
shll $0x7, %edx
orl $0x52, %edx
movl %edx, 0x4(%r15,%rsi,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /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);
luaK_codevABCk(fs, OP_SETLIST, base, tostore, nelems, 1);
codeextraarg(fs, extra);
}
fs->freereg = cast_byte(base + 1); /* free registers with list values */
} | 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 $0x4e, %esi
jmp 0x25a3d
orl $0x804e, %esi # imm = 0x804E
movq %r14, %rdi
callq 0x23f8b
shrl $0x3, %ebp
andl $0xfffff80, %ebp # imm = 0xFFFFF80
orl $0x52, %ebp
movl %ebp, %esi
movq %r14, %rdi
callq 0x23f8b
incb %bl
movb %bl, 0x4c(%r14)
popq %rbx
popq %r14
popq %rbp
retq
| /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 (GET_OPCODE(*pc)) {
case OP_RETURN0: case OP_RETURN1: {
if (!(fs->needclose || (p->flag & PF_ISVARARG)))
break; /* no extra work */
/* else use OP_RETURN to do the extra work */
SET_OPCODE(*pc, OP_RETURN);
} /* FALLTHROUGH */
case OP_RETURN: case OP_TAILCALL: {
if (fs->needclose)
SETARG_k(*pc, 1); /* signal that it needs to close */
if (p->flag & PF_ISVARARG)
SETARG_C(*pc, p->numparams + 1); /* signal that it is vararg */
break;
}
case OP_JMP: {
int target = finaltarget(p->code, i);
fixjump(fs, i, target);
break;
}
default: break;
}
}
} | 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 $0x2, %esi
jae 0x25acd
cmpb $0x0, 0x4e(%rbx)
jne 0x25a98
testb $0x1, 0xb(%r15)
je 0x25b13
andl $-0x80, %ecx
orl $0x46, %ecx
movl %ecx, (%rax,%r14,4)
cmpb $0x0, 0x4e(%rbx)
je 0x25aae
orb $-0x80, 0x1(%rax,%r14,4)
testb $0x1, 0xb(%r15)
je 0x25b13
movzbl 0xa(%r15), %ecx
shll $0x18, %ecx
addl $0x1000000, %ecx # imm = 0x1000000
shrl $0x18, %ecx
movb %cl, 0x3(%rax,%r14,4)
jmp 0x25b13
cmpl $0x38, %edx
jne 0x25b13
movl $0x63, %ecx
movl %r14d, %edx
movslq %edx, %rdx
movl (%rax,%rdx,4), %esi
movl %esi, %edi
andl $0x7f, %edi
shrl $0x7, %esi
addl $0xff000002, %esi # imm = 0xFF000002
cmpl $0x38, %edi
cmovnel %r12d, %esi
addl %esi, %edx
subl $0x1, %ecx
setb %sil
cmpl $0x38, %edi
jne 0x25b08
testb %sil, %sil
je 0x25ada
movq %rbx, %rdi
movl %r14d, %esi
callq 0x23e42
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x25a6e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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 already has the value;
change instruction to simple test */
*i = CREATE_ABCk(OP_TEST, GETARG_B(*i), 0, 0, GETARG_k(*i));
}
return 1;
} | 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, %edi
jne 0x25ba5
cmpl $0xff, %edx
je 0x25b7e
movl %esi, %eax
shrl $0x10, %eax
movzbl %al, %eax
cmpl %edx, %eax
jne 0x25b90
movl %esi, %eax
shrl $0x9, %eax
andl $0x7f80, %eax # imm = 0x7F80
andl $0x8042, %esi # imm = 0x8042
jmp 0x25b9c
andl $0xffff8043, %esi # imm = 0xFFFF8043
movzbl %dl, %eax
shll $0x7, %eax
orl %eax, %esi
movl %esi, (%rcx)
movl $0x1, %eax
retq
| /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 */
lua_assert(ttisfloat(key) || luaV_rawequalobj(&f->k[k], v));
return k; /* reuse index */
}
/* constant not found; create a new entry */
k = addk(fs, f, v);
/* cache it for reuse; numerical value does not need GC barrier;
table is not a metatable, so it does not need to invalidate cache */
setivalue(&val, k);
luaH_set(fs->ls->L, fs->kcache, key, &val);
return k;
} | 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, %ebp
cltq
movq %rsp, %rcx
movq %rax, (%rcx)
movb $0x3, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x20(%r14), %rsi
movq 0x38(%rax), %rdi
movq %rbx, %rdx
callq 0x1b943
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /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, f, v);
return k;
} | 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 # 0x2bb7b
movq %rax, (%rsp)
movq %rdi, 0x10(%rsp)
movl %r13d, %edx
movl $0x10, %r8d
movl $0x1ffffff, %r9d # imm = 0x1FFFFFF
callq 0x111d8
movq %rax, 0x38(%rbx)
movslq 0x14(%rbx), %rcx
cmpl %ecx, %r14d
jge 0x25c91
subq %r14, %rcx
shlq $0x4, %r14
leaq (%r14,%rax), %rdx
addq $0x8, %rdx
movb $0x0, (%rdx)
addq $0x10, %rdx
decq %rcx
jne 0x25c85
shlq $0x4, %r13
movq (%r15), %rcx
movq %rcx, (%rax,%r13)
movb 0x8(%r15), %cl
movb %cl, 0x8(%rax,%r13)
incl 0x34(%r12)
testb $0x40, 0x8(%r15)
je 0x25ccd
testb $0x20, 0x9(%rbx)
je 0x25ccd
movq (%r15), %rdx
testb $0x18, 0x9(%rdx)
je 0x25ccd
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xd508
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 (%r8), %r8d
andl $0x7f, %r8d
cmpl $0x43, %r8d
jne 0x25e96
movl (%rdi), %edi
shrl $0x7, %edi
leal -0xffffff(%rdi), %r8d
cmpl $-0x1, %r8d
leal -0xfffffe(%rsi,%rdi), %esi
cmovel %r8d, %esi
cmpl $-0x1, %esi
jne 0x25e44
retq
movl $0x1, %eax
retq
| /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_floatatt(MANT_DIG);
const lua_Number q = l_mathop(ldexp)(l_mathop(1.0), -nbm + 1);
const lua_Number k = r * (1 + q); /* key */
lua_Integer ik;
setfltvalue(&kv, k); /* key as a TValue */
if (!luaV_flttointeger(k, &ik, F2Ieq)) { /* not an integral value? */
int n = k2proto(fs, &kv, &o); /* use key */
if (luaV_rawequalobj(&fs->f->k[n], &o)) /* correct value? */
return n;
}
/* else, either key is still an integer or there was a collision;
anyway, do not try to reuse constant; instead, create a new one */
return addk(fs, fs->f, &o);
}
} | 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 0x3f56(%rip), %xmm0 # 0x29e38
movl $0xffffffcc, %edi # imm = 0xFFFFFFCC
movsd %xmm1, 0x10(%rsp)
callq 0x5470
addsd 0x3f3e(%rip), %xmm0 # 0x29e38
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movb $0x13, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x1dc39
testl %eax, %eax
je 0x25f36
movq (%rbx), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x25c12
movl %eax, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x18(%rsp), %rsi
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x25ba6
movl %eax, %ebp
movq (%rbx), %rax
movslq %ebp, %rsi
shlq $0x4, %rsi
addq 0x38(%rax), %rsi
xorl %edi, %edi
movq %r14, %rdx
callq 0x1e328
testl %eax, %eax
jne 0x25f2b
jmp 0x25f1b
| /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;
e1->k = VRELOC; /* all those operations are relocatable */
luaK_fixline(fs, line);
luaK_codeABCk(fs, mmop, v1, v2, cast_int(event), flip); /* metamethod */
luaK_fixline(fs, line);
} | 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 0x245fc
movl %eax, %r12d
shll $0x10, %eax
movl %r15d, %esi
shll $0x18, %esi
orl %ebp, %esi
orl %eax, %esi
movq %r14, %rdi
callq 0x23f8b
movl %eax, %ebp
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpl $0x8, (%r13)
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
jne 0x2605c
movl 0x8(%r13), %esi
movq 0x10(%rsp), %rax
cmpl $0x8, (%rax)
jne 0x26069
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0x24433
movl %ebp, 0x8(%r13)
movl $0x11, (%r13)
movq %r14, %rdi
movl 0xc(%rsp), %ebp
movl %ebp, %esi
callq 0x25947
shll $0x7, %r12d
shll $0x10, %r15d
movl 0x8(%rsp), %eax
shll $0x18, %eax
shll $0xf, %ebx
orl %r15d, %ebx
orl 0x4(%rsp), %ebx
orl %eax, %ebx
orl %r12d, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x23f8b
movq %r14, %rdi
movl %ebp, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x25947
| /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)
movups (%r15), %xmm0
movups %xmm0, (%r12)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r15)
movaps (%rsp), %xmm0
movups %xmm0, (%r15)
leal 0x22(%r14), %ebp
movq %r13, %rdi
movq %r15, %rsi
callq 0x245fc
addl $0x6, %r14d
subq $0x8, %rsp
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
pushq %r14
pushq $0x2e
pushq %rbx
callq 0x25fef
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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));
return r + 1; /* return true + 'resume' returns */
}
} | 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 %r14d, %esi
movl $0x1, %edx
callq 0x66f8
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
xorl %esi, %esi
callq 0x704c
movl $0x2, %ebp
movl $0xfffffffe, %r14d # imm = 0xFFFFFFFE
jmp 0x2622c
| /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 running */
else if (lua_gettop(co) == 0)
return COS_DEAD;
else
return COS_YIELD; /* initial state */
}
default: /* some error occurred */
return COS_DEAD;
}
}
} | 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, %eax
movl $0x2, %eax
sbbl $0x0, %eax
jmp 0x264e8
xorl %eax, %eax
retq
movl $0x2, %eax
jmp 0x264e8
movl $0x1, %eax
addq $0x90, %rsp
popq %rbx
retq
| /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
movl $0x1, %esi
callq 0x704c
movl $0x2, %ebp
jmp 0x265eb
movq %rbx, %rdi
callq 0x6d71
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /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, "external hook");
else { /* hook table must exist */
lua_getfield(L, LUA_REGISTRYINDEX, HOOKKEY);
checkstack(L, L1, 1);
lua_pushthread(L1); lua_xmove(L1, L, 1);
lua_rawget(L, -2); /* 1st result = hooktable[L1] */
lua_remove(L, -2); /* remove hook table */
}
lua_pushstring(L, unmakemask(mask, buff)); /* 2nd result = mask */
lua_pushinteger(L, lua_gethookcount(L1)); /* 3rd result = count */
return 3;
} | 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 # 0x2bdca
movq %rbx, %rdi
callq 0x6e5b
jmp 0x266b8
movq %rbx, %rdi
callq 0x6d71
movl $0x1, %eax
jmp 0x26714
leaq 0x5781(%rip), %rdx # 0x2bdd8
movq %rbx, %rdi
movl $0xfff0b9d8, %esi # imm = 0xFFF0B9D8
callq 0x71a1
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x27207
movq %r14, %rdi
callq 0x7074
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x65b7
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x7262
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x66f8
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
xorl %eax, %eax
testb $0x1, %bpl
je 0x266ca
movb $0x63, 0x7(%rsp)
movl $0x1, %eax
testb $0x2, %bpl
je 0x266d9
movl %eax, %ecx
incl %eax
movb $0x72, 0x7(%rsp,%rcx)
testb $0x4, %bpl
je 0x266e8
movl %eax, %ecx
incl %eax
movb $0x6c, 0x7(%rsp,%rcx)
movl %eax, %eax
movb $0x0, 0x7(%rsp,%rax)
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0x6e5b
movq %r14, %rdi
callq 0x9f8a
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x6d91
movl $0x3, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /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, NULL, nvar)); /* push local name */
return 1; /* return only name (there is no value) */
}
else { /* stack-level argument */
lua_Debug ar;
const char *name;
int level = (int)luaL_checkinteger(L, arg + 1);
if (l_unlikely(!lua_getstack(L1, level, &ar))) /* out of range? */
return luaL_argerror(L, arg+1, "level out of range");
checkstack(L, L1, 1);
name = lua_getlocal(L1, &ar, nvar);
if (name) {
lua_xmove(L1, L, 1); /* move local value */
lua_pushstring(L, name); /* push name */
lua_rotate(L, -2, 1); /* re-order */
return 2;
}
else {
luaL_pushfail(L); /* no name (nor value) */
return 1;
}
}
} | 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 $0x6, %eax
jne 0x26b79
movl %r12d, %esi
callq 0x68aa
movq %rbx, %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0xa0e7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6e5b
movl $0x1, %ebp
jmp 0x26bfd
movl %r12d, %esi
callq 0x8f2d
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0x9f91
testl %eax, %eax
je 0x26c0f
movl $0x1, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x27207
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0xa0e7
testq %rax, %rax
je 0x26bf5
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x65b7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6e5b
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x66f8
movl $0x2, %ebp
jmp 0x26bfd
movq %rbx, %rdi
callq 0x6d71
movl %ebp, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5290(%rip), %rdx # 0x2bea6
movq %rbx, %rdi
movl %r12d, %esi
callq 0x86ba
movl %eax, %ebp
jmp 0x26bfd
| /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 %eax, %eax
jne 0x26cfd
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %r8d
movq %rbx, %rdi
movl $0x1, %esi
movl $0x3, %ecx
callq 0x8157
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x3f73(%rip), %rdx # 0x2ac61
movq %rbx, %rdi
movl $0x1, %esi
callq 0x86ba
jmp 0x26cb3
leaq 0x3f5d(%rip), %rdx # 0x2ac61
movq %rbx, %rdi
movl $0x3, %esi
callq 0x86ba
jmp 0x26cc4
| /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 += (newsize >> 1); /* new size is 1.5 times the old one */
luaZ_resizebuffer(ls->L, b, newsize);
}
b->buffer[luaZ_bufflen(b)++] = cast_char(c);
} | 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), %rsi
movq %r14, %rcx
callq 0x11247
movq %rax, (%r15)
movq %r14, 0x10(%r15)
movq (%r15), %rax
movq 0x8(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r15)
movb %bl, (%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4049(%rip), %rsi # 0x2c09c
xorl %edx, %edx
callq 0x2743d
| /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 0x280b4
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x280a3
callq 0x22428
jmp 0x280b2
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
movl 0x4(%rbx), %eax
incl %eax
movl %eax, 0x4(%rbx)
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
je 0x280ca
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4002(%rip), %rsi # 0x2c0d3
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2743d
| /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 0x2814c
movq %r14, %rdi
movl $0x3d, %esi
callq 0x27feb
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x28135
callq 0x22428
jmp 0x28144
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
incq %r15
jmp 0x28112
leaq 0x2(%r15), %rdx
xorl %ecx, %ecx
testq %r15, %r15
sete %cl
cmpl %ebx, %eax
cmoveq %rdx, %rcx
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
| /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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.