name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
pushbuff | static void pushbuff (lua_State *L, void *ud) {
BuffFS *buff = cast(BuffFS*, ud);
switch (buff->err) {
case 1: /* memory error */
luaD_throw(L, LUA_ERRMEM);
break;
case 2: /* length overflow: Add "..." at the end of result */
if (buff->buffsize - buff->blen < 3)
strcpy(buff->b + buff->blen - 3, "..."); /* 'blen' must be > 3 */
else { /* there is enough space left for the "..." */
strcpy(buff->b + buff->blen, "...");
buff->blen += 3;
}
/* FALLTHROUGH */
default: { /* no errors, but it can raise one creating the new string */
TString *ts = luaS_newlstr(L, buff->b, buff->blen);
setsvalue2s(L, L->top.p, ts);
L->top.p++;
}
}
} | pushq %rbx
movq %rdi, %rbx
movl 0x20(%rsi), %eax
cmpl $0x2, %eax
je 0x12e7f
cmpl $0x1, %eax
jne 0x12eaa
movq %rbx, %rdi
movl $0x4, %esi
callq 0xb220
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rcx
subq %rcx, %rdx
cmpq $0x2, %rdx
ja 0x12e9e
movl $0x2e2e2e, -0x3(%rax,%rcx) # imm = 0x2E2E2E
jmp 0x12eaa
movl $0x2e2e2e, (%rax,%rcx) # imm = 0x2E2E2E
addq $0x3, 0x18(%rsi)
movq 0x8(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x170cb
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movb 0x8(%rax), %al
orb $0x40, %al
movb %al, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
popq %rbx
retq
nop
| /mmanyen[P]CLua/build_O1/_deps/lua/lobject.c |
os_date | static int os_date (lua_State *L) {
size_t slen;
const char *s = luaL_optlstring(L, 1, "%c", &slen);
time_t t = luaL_opt(L, l_checktime, 2, time(NULL));
const char *se = s + slen; /* 's' end */
struct tm tmr, *stm;
if (*s == '!') { /* UTC? */
stm = l_gmtime(&t, &tmr);
s++; /* skip '!' */
}
else
stm = l_localtime(&t, &tmr);
if (stm == NULL) /* invalid date? */
return luaL_error(L,
"date result cannot be represented in this installation");
if (strcmp(s, "*t") == 0) {
lua_createtable(L, 0, 9); /* 9 = number of fields */
setallfields(L, stm);
}
else {
char cc[4]; /* buffer for individual conversion specifiers */
luaL_Buffer b;
cc[0] = '%';
luaL_buffinit(L, &b);
while (s < se) {
if (*s != '%') /* not a conversion specifier? */
luaL_addchar(&b, *s++);
else {
size_t reslen;
char *buff = luaL_prepbuffsize(&b, SIZETIMEFMT);
s++; /* skip '%' */
s = checkoption(L, s, se - s, cc + 1); /* copy specifier to 'cc' */
reslen = strftime(buff, SIZETIMEFMT, cc, stm);
luaL_addsize(&b, reslen);
}
}
luaL_pushresult(&b);
}
return 1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp # imm = 0x458
movq %rdi, %r15
leaq 0x174ce(%rip), %rdx # 0x2a483
leaq 0x30(%rsp), %rcx
movl $0x1, %esi
callq 0x8da3
movq %rax, %r14
movq %r15, %rdi
movl $0x2, %esi
callq 0x68d4
testl %eax, %eax
jle 0x12fe7
movq %r15, %rdi
movl $0x2, %esi
callq 0x8f2d
jmp 0x12fee
xorl %edi, %edi
callq 0x52e0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %r12
addq %r14, %r12
cmpb $0x21, (%r14)
jne 0x13013
leaq 0x10(%rsp), %rdi
callq 0x52c0
movq %rax, %rbx
incq %r14
jmp 0x13020
leaq 0x10(%rsp), %rdi
callq 0x5240
movq %rax, %rbx
testq %rbx, %rbx
je 0x1318c
leaq 0x1748d(%rip), %rsi # 0x2a4bd
movq %r14, %rdi
callq 0x5420
testl %eax, %eax
je 0x1319f
movb $0x25, 0xc(%rsp)
leaq 0x38(%rsp), %rsi
movq %r15, %rdi
callq 0x8517
cmpq %r12, %r14
jae 0x13180
movq %r12, 0x20(%rsp)
movq %rbx, 0x18(%rsp)
cmpb $0x25, (%r14)
jne 0x130ff
movq %r15, %rbx
movl $0xfa, %esi
leaq 0x38(%rsp), %rdi
callq 0x857a
movq %rax, 0x28(%rsp)
incq %r14
movq %r12, %r15
subq %r14, %r15
testq %r15, %r15
jle 0x130d6
movl $0x1, %ebp
movb $0x61, %al
movl $0x1, %r12d
leaq 0x1743c(%rip), %r13 # 0x2a4e4
cmpb $0x7c, %al
jne 0x130b0
incl %ebp
jmp 0x130c2
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x5350
testl %eax, %eax
je 0x13138
movl %ebp, %r12d
movb (%r13,%r12), %al
testb %al, %al
je 0x130d6
addq %r12, %r13
cmpq %r12, %r15
jge 0x130a8
movq %rbx, %r15
movq %rbx, %rdi
leaq 0x1744f(%rip), %rsi # 0x2a532
movq %r14, %rdx
xorl %eax, %eax
callq 0x6ee9
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0x86ba
jmp 0x13154
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
jb 0x1311a
movl $0x1, %esi
leaq 0x38(%rsp), %rdi
callq 0x857a
movb (%r14), %al
incq %r14
movq 0x38(%rsp), %rcx
movq 0x48(%rsp), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x48(%rsp)
movb %al, (%rcx,%rdx)
jmp 0x13177
leaq 0xd(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x52a0
movb $0x0, 0xd(%rsp,%r12)
addq %r12, %r14
movq %rbx, %r15
movl $0xfa, %esi
movq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x5280
addq %rax, 0x48(%rsp)
movq 0x20(%rsp), %r12
cmpq %r12, %r14
jb 0x13065
leaq 0x38(%rsp), %rdi
callq 0x85e7
jmp 0x131b9
leaq 0x172f3(%rip), %rsi # 0x2a486
movq %r15, %rdi
xorl %eax, %eax
callq 0x87c6
jmp 0x131be
movq %r15, %rdi
xorl %esi, %esi
movl $0x9, %edx
callq 0x7355
movq %r15, %rdi
movq %rbx, %rsi
callq 0x135a3
movl $0x1, %eax
addq $0x458, %rsp # imm = 0x458
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/loslib.c |
os_exit | static int os_exit (lua_State *L) {
int status;
if (lua_isboolean(L, 1))
status = (lua_toboolean(L, 1) ? EXIT_SUCCESS : EXIT_FAILURE);
else
status = (int)luaL_optinteger(L, 1, EXIT_SUCCESS);
if (lua_toboolean(L, 2))
lua_close(L);
if (L) exit(status); /* 'if' to avoid warnings for unreachable 'return' */
return 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x68d4
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x1, %eax
jne 0x13292
callq 0x6b9e
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
jmp 0x1329c
xorl %edx, %edx
callq 0x8fb7
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6b9e
testl %eax, %eax
je 0x132b5
movq %rbx, %rdi
callq 0x16d5c
testq %rbx, %rbx
jne 0x132c4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %r14d, %edi
callq 0x53d0
| /mmanyen[P]CLua/build_O1/_deps/lua/loslib.c |
os_time | static int os_time (lua_State *L) {
time_t t;
if (lua_isnoneornil(L, 1)) /* called without args? */
t = time(NULL); /* get current time */
else {
struct tm ts;
luaL_checktype(L, 1, LUA_TTABLE);
lua_settop(L, 1); /* make sure table is at the top */
ts.tm_year = getfield(L, "year", -1, 1900);
ts.tm_mon = getfield(L, "month", -1, 1);
ts.tm_mday = getfield(L, "day", -1, 0);
ts.tm_hour = getfield(L, "hour", 12, 0);
ts.tm_min = getfield(L, "min", 0, 0);
ts.tm_sec = getfield(L, "sec", 0, 0);
ts.tm_isdst = getboolfield(L, "isdst");
t = mktime(&ts);
setallfields(L, &ts); /* update fields with normalized values */
}
if (t != (time_t)(l_timet)t || t == (time_t)(-1))
return luaL_error(L,
"time result cannot be represented in this installation");
l_pushtime(L, t);
return 1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x68d4
testl %eax, %eax
jle 0x1351f
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x8e50
movq %rbx, %rdi
movl $0x1, %esi
callq 0x664e
leaq 0x1708d(%rip), %rsi # 0x2a4c0
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0x76c, %ecx # imm = 0x76C
callq 0x136ec
movl %eax, 0x14(%rsp)
leaq 0x17070(%rip), %rsi # 0x2a4c5
movq %rbx, %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0x1, %ecx
callq 0x136ec
movl %eax, 0x10(%rsp)
leaq 0x17068(%rip), %rsi # 0x2a4da
movq %rbx, %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x136ec
movl %eax, 0xc(%rsp)
leaq 0x1703f(%rip), %rsi # 0x2a4cb
movq %rbx, %rdi
movl $0xc, %edx
xorl %ecx, %ecx
callq 0x136ec
movl %eax, 0x8(%rsp)
leaq 0x16a49(%rip), %rsi # 0x29eef
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x136ec
movl %eax, 0x4(%rsp)
leaq 0x17013(%rip), %rsi # 0x2a4d0
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x136ec
movl %eax, (%rsp)
leaq 0x1700b(%rip), %rdx # 0x2a4de
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x71a1
testl %eax, %eax
je 0x134f3
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x6b9e
movl %eax, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
movq %rsp, %r15
movl %ebp, 0x20(%r15)
movq %r15, %rdi
callq 0x5230
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x135a3
jmp 0x13529
xorl %edi, %edi
callq 0x52e0
movq %rax, %r14
cmpq $-0x1, %r14
je 0x1354a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6d91
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17024(%rip), %rsi # 0x2a575
movq %rbx, %rdi
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x87c6
| /mmanyen[P]CLua/build_O1/_deps/lua/loslib.c |
os_tmpname | static int os_tmpname (lua_State *L) {
char buff[LUA_TMPNAMBUFSIZE];
int err;
lua_tmpnam(buff, err);
if (l_unlikely(err))
return luaL_error(L, "unable to generate a unique filename");
lua_pushstring(L, buff);
return 1;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x5290
testq %rax, %rax
je 0x13590
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6e5b
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
leaq 0x1706e(%rip), %rsi # 0x2a605
movq %rbx, %rdi
xorl %eax, %eax
callq 0x87c6
jmp 0x1358a
| /mmanyen[P]CLua/build_O1/_deps/lua/loslib.c |
setallfields | static void setallfields (lua_State *L, struct tm *stm) {
setfield(L, "year", stm->tm_year, 1900);
setfield(L, "month", stm->tm_mon, 1);
setfield(L, "day", stm->tm_mday, 0);
setfield(L, "hour", stm->tm_hour, 0);
setfield(L, "min", stm->tm_min, 0);
setfield(L, "sec", stm->tm_sec, 0);
setfield(L, "yday", stm->tm_yday, 1);
setfield(L, "wday", stm->tm_wday, 1);
setboolfield(L, "isdst", stm->tm_isdst);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x14(%rsi), %rsi
addq $0x76c, %rsi # imm = 0x76C
callq 0x6d91
leaq 0x16efc(%rip), %rdx # 0x2a4c0
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x75d5
movslq 0x10(%r14), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x6d91
leaq 0x16ede(%rip), %rdx # 0x2a4c5
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x75d5
movslq 0xc(%r14), %rsi
movq %rbx, %rdi
callq 0x6d91
leaq 0x16ed3(%rip), %rdx # 0x2a4da
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x75d5
movslq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x6d91
leaq 0x16ea4(%rip), %rdx # 0x2a4cb
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x75d5
movslq 0x4(%r14), %rsi
movq %rbx, %rdi
callq 0x6d91
leaq 0x168a8(%rip), %rdx # 0x29eef
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x75d5
movslq (%r14), %rsi
movq %rbx, %rdi
callq 0x6d91
leaq 0x16e6a(%rip), %rdx # 0x2a4d0
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x75d5
movslq 0x1c(%r14), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x6d91
leaq 0x16e4b(%rip), %rdx # 0x2a4d4
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x75d5
movslq 0x18(%r14), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x6d91
leaq 0x16e2d(%rip), %rdx # 0x2a4d9
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x75d5
movl 0x20(%r14), %esi
testl %esi, %esi
js 0x136e4
movq %rbx, %rdi
callq 0x704c
leaq 0x16e0e(%rip), %rdx # 0x2a4de
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x75d5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/loslib.c |
getfield | static int getfield (lua_State *L, const char *key, int d, int delta) {
int isnum;
int t = lua_getfield(L, -1, key); /* get field and its type */
lua_Integer res = lua_tointegerx(L, -1, &isnum);
if (!isnum) { /* field is not an integer? */
if (l_unlikely(t != LUA_TNIL)) /* some other value? */
return luaL_error(L, "field '%s' is not an integer", key);
else if (l_unlikely(d < 0)) /* absent field; no default? */
return luaL_error(L, "field '%s' missing in date table", key);
res = d;
}
else {
if (!(res >= 0 ? res - delta <= INT_MAX : INT_MIN + delta <= res))
return luaL_error(L, "field '%s' is out-of-bound", key);
res -= delta;
}
lua_pop(L, 1);
return (int)res;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x71a1
movl %eax, %r12d
leaq 0x4(%rsp), %r13
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movq %r13, %rdx
callq 0x6b52
cmpl $0x0, (%r13)
je 0x1374d
testq %rax, %rax
js 0x13765
movl %r15d, %ecx
movq %rax, %rdx
subq %rcx, %rdx
movl $0x80000000, %ecx # imm = 0x80000000
cmpq %rcx, %rdx
jge 0x13776
subl %r15d, %eax
movl %eax, %ebp
jmp 0x13756
testl %r12d, %r12d
jne 0x1379d
testl %ebp, %ebp
js 0x137a6
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
jmp 0x1378c
movl %r15d, %ecx
orl $0x80000000, %ecx # imm = 0x80000000
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x13746
leaq 0x16e6d(%rip), %rsi # 0x2a5ea
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x87c6
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16e08(%rip), %rsi # 0x2a5ac
jmp 0x1377d
leaq 0x16e1c(%rip), %rsi # 0x2a5c9
jmp 0x1377d
nop
| /mmanyen[P]CLua/build_O1/_deps/lua/loslib.c |
errorlimit | static l_noret errorlimit (FuncState *fs, int limit, const char *what) {
lua_State *L = fs->ls->L;
const char *msg;
int line = fs->f->linedefined;
const char *where = (line == 0)
? "main function"
: luaO_pushfstring(L, "function at line %d", line);
msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s",
what, limit, where);
luaX_syntaxerror(fs->ls, msg);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x38(%rcx), %r15
movl 0x2c(%rax), %edx
testl %edx, %edx
jne 0x137ea
leaq 0x16f52(%rip), %r8 # 0x2a73a
jmp 0x137fe
leaq 0x16f57(%rip), %rsi # 0x2a748
movq %r15, %rdi
xorl %eax, %eax
callq 0x12c36
movq %rax, %r8
leaq 0x16f57(%rip), %rsi # 0x2a75c
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x12c36
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x27434
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
statement | static void statement (LexState *ls) {
int line = ls->linenumber; /* may be needed for error messages */
enterlevel(ls);
switch (ls->t.token) {
case ';': { /* stat -> ';' (empty statement) */
luaX_next(ls); /* skip ';' */
break;
}
case TK_IF: { /* stat -> ifstat */
ifstat(ls, line);
break;
}
case TK_WHILE: { /* stat -> whilestat */
whilestat(ls, line);
break;
}
case TK_DO: { /* stat -> DO block END */
luaX_next(ls); /* skip DO */
block(ls);
check_match(ls, TK_END, TK_DO, line);
break;
}
case TK_FOR: { /* stat -> forstat */
forstat(ls, line);
break;
}
case TK_REPEAT: { /* stat -> repeatstat */
repeatstat(ls, line);
break;
}
case TK_FUNCTION: { /* stat -> funcstat */
funcstat(ls, line);
break;
}
case TK_LOCAL: { /* stat -> localstat */
luaX_next(ls); /* skip LOCAL */
if (testnext(ls, TK_FUNCTION)) /* local function? */
localfunc(ls);
else
localstat(ls);
break;
}
case TK_DBCOLON: { /* stat -> label */
luaX_next(ls); /* skip double colon */
labelstat(ls, str_checkname(ls), line);
break;
}
case TK_RETURN: { /* stat -> retstat */
luaX_next(ls); /* skip RETURN */
retstat(ls);
break;
}
case TK_BREAK: { /* stat -> breakstat */
breakstat(ls, line);
break;
}
case TK_GOTO: { /* stat -> 'goto' NAME */
luaX_next(ls); /* skip 'goto' */
gotostat(ls, line);
break;
}
default: { /* stat -> func | assignment */
exprstat(ls);
break;
}
}
lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
ls->fs->freereg >= luaY_nvarstack(ls->fs));
ls->fs->freereg = luaY_nvarstack(ls->fs); /* free registers */
leavelevel(ls);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x4(%rdi), %ebp
movq 0x38(%rdi), %rdi
callq 0x166f2
movl 0x10(%rbx), %eax
leal -0x101(%rax), %ecx
cmpl $0x14, %ecx
ja 0x13dba
leaq 0x168df(%rip), %rax # 0x2a650
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x30(%rbx), %rax
addq $0x18, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1490e
cmpb $0x0, 0x12(%rax)
je 0x13d82
movb $0x2, 0x12(%rax)
movq %rbx, %rdi
callq 0x275c6
movq 0x38(%rbx), %rdi
leaq 0x16a6f(%rip), %rsi # 0x2a81a
movl $0x5, %edx
callq 0x170cb
jmp 0x13fde
cmpl $0x11f, %eax # imm = 0x11F
je 0x14138
cmpl $0x3b, %eax
je 0x148cf
movq 0x30(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x153d9
movl 0x10(%rbx), %eax
cmpl $0x3d, %eax
je 0x13df0
cmpl $0x2c, %eax
jne 0x1433c
movq %rsp, %rsi
movq $0x0, (%rsi)
movq %rbx, %rdi
movl $0x1, %edx
callq 0x16426
jmp 0x148d7
movq 0x30(%rbx), %r14
movq %r14, %rdi
callq 0x23eee
movl %eax, %r15d
movb $0x1, 0x12(%rsp)
movb 0x4a(%r14), %al
movb %al, 0x10(%rsp)
movq 0x10(%r14), %rcx
movq 0x58(%rcx), %rdx
movl 0x28(%rdx), %ecx
movl %ecx, 0x8(%rsp)
movl 0x18(%rdx), %edx
movl %edx, 0xc(%rsp)
movb $0x0, 0x11(%rsp)
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x1435d
cmpb $0x0, 0x13(%rdi)
setne %sil
jmp 0x1435f
movq %rbx, %rdi
callq 0x275c6
movq 0x30(%rbx), %r14
movq %r14, %rdi
callq 0x13820
movl 0x10(%rbx), %edi
leal -0x103(%rdi), %ecx
cmpl $0x1e, %ecx
setb %dl
movl $0x20020007, %esi # imm = 0x20020007
shrl %cl, %esi
movzbl %al, %ebp
xorl %r15d, %r15d
cmpl $0x3b, %edi
je 0x148bc
andb %sil, %dl
jne 0x148bc
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15be9
movl %eax, %r12d
movl (%r15), %eax
andl $-0x2, %eax
cmpl $0x12, %eax
jne 0x14735
movq %rsp, %r13
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movq %r14, %rdi
movq %r13, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x241f7
movl (%r13), %eax
xorl $0x12, %eax
xorl $0x1, %r12d
orl %eax, %r12d
jne 0x148bc
movq 0x18(%r14), %rax
cmpb $0x0, 0x13(%rax)
jne 0x148bc
movq (%r14), %rax
movq 0x40(%rax), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
andl $-0x80, %edx
orl $0x45, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x148bc
movq %rbx, %rdi
callq 0x275c6
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15982
movl 0x10(%rbx), %eax
cmpl $0x2e, %eax
jne 0x13f42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x157e7
jmp 0x13f2d
cmpl $0x3a, %eax
jne 0x14213
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x157e7
movl $0x1, %edx
jmp 0x14215
movq %rbx, %rdi
callq 0x275c6
movq %rbx, %rdi
callq 0x1495e
movq %rbx, %rdi
movl $0x105, %esi # imm = 0x105
movl $0x102, %edx # imm = 0x102
movl %ebp, %ecx
callq 0x149c0
jmp 0x148d7
movq 0x30(%rbx), %r14
movb $0x1, 0x42(%rsp)
movb 0x4a(%r14), %al
movb %al, 0x40(%rsp)
movq 0x10(%r14), %rax
movq 0x58(%rax), %rax
movl 0x28(%rax), %ecx
movl %ecx, 0x38(%rsp)
movl 0x18(%rax), %eax
movl %eax, 0x3c(%rsp)
movb $0x0, 0x41(%rsp)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x1442e
cmpb $0x0, 0x13(%rax)
setne %cl
jmp 0x14430
movq %rbx, %rdi
callq 0x275c6
movq %rbx, %rdi
callq 0x14a31
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x163ce
jmp 0x148d7
movq %rbx, %rdi
callq 0x275c6
cmpl $0x108, 0x10(%rbx) # imm = 0x108
jne 0x14254
movq %rbx, %rdi
callq 0x275c6
movq 0x30(%rbx), %r15
movzbl 0x4a(%r15), %r14d
movq %rbx, %rdi
callq 0x14a31
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x15762
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1562b
movl 0x4(%rbx), %ecx
movq %rsp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x15180
movl 0x28(%r15), %eax
movq (%r15), %rcx
movq 0x10(%r15), %rdx
movq 0x58(%rdx), %rdx
movq (%rdx), %rdx
movslq 0x40(%r15), %rsi
addq %r14, %rsi
leaq (%rsi,%rsi,2), %rsi
movswq 0xc(%rdx,%rsi,8), %rdx
movq 0x68(%rcx), %rcx
shlq $0x4, %rdx
movl %eax, 0x8(%rcx,%rdx)
jmp 0x148d7
movq 0x30(%rbx), %r14
movq %rsp, %r15
movl $0xffffffff, (%r15) # imm = 0xFFFFFFFF
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14a53
movl 0x10(%rbx), %eax
cmpl $0x104, %eax # imm = 0x104
je 0x1408a
cmpl $0x103, %eax # imm = 0x103
jne 0x140b6
movq %rbx, %rdi
callq 0x275c6
movq %rbx, %rdi
callq 0x1495e
movq %rbx, %rdi
movl $0x105, %esi # imm = 0x105
movl $0x10a, %edx # imm = 0x10A
movl %ebp, %ecx
callq 0x149c0
movl (%rsp), %esi
movq %r14, %rdi
jmp 0x146e9
movq 0x30(%rbx), %r14
movq %rbx, %rdi
callq 0x275c6
movq %r14, %rdi
callq 0x23eee
movl %eax, %r12d
movq %rbx, %rdi
callq 0x14abf
movl %eax, %r15d
movb $0x1, 0x12(%rsp)
movb 0x4a(%r14), %al
movb %al, 0x10(%rsp)
movq 0x10(%r14), %rax
movq 0x58(%rax), %rax
movl 0x28(%rax), %ecx
movl %ecx, 0x8(%rsp)
movl 0x18(%rax), %eax
movl %eax, 0xc(%rsp)
movb $0x0, 0x11(%rsp)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x1468e
cmpb $0x0, 0x13(%rax)
setne %cl
jmp 0x14690
leaq 0x38(%rbx), %r15
movq %rbx, %rdi
callq 0x275c6
movq %rbx, %rdi
callq 0x14a31
movq %rax, %r14
movq %rbx, %rdi
movl $0x11f, %esi # imm = 0x11F
callq 0x14afd
movl 0x10(%rbx), %ecx
cmpl $0x11f, %ecx # imm = 0x11F
je 0x1416c
cmpl $0x3b, %ecx
jne 0x14176
movq %rbx, %rdi
callq 0x13d3f
jmp 0x1415c
movq 0x30(%rbx), %r13
movq 0x58(%rbx), %r12
movslq 0x44(%r13), %rdx
movslq 0x28(%r12), %rax
cmpl %edx, %eax
jle 0x141ad
subq %rdx, %rax
leaq (%rdx,%rdx,2), %rsi
shlq $0x3, %rsi
addq 0x20(%r12), %rsi
cmpq %r14, (%rsi)
cmoveq %rsi, %rdx
je 0x141af
addq $0x18, %rsi
decq %rax
jne 0x1419b
xorl %edx, %edx
testq %rdx, %rdx
jne 0x14900
addl $0xfffffefd, %ecx # imm = 0xFFFFFEFD
cmpl $0x1e, %ecx
setae %al
movl $0x1ffffff8, %r15d # imm = 0x1FFFFFF8
shrl %cl, %r15d
orb %al, %r15b
addq $0x20, %r12
movq %r13, %rdi
callq 0x23eee
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movl %eax, %r8d
callq 0x16001
testb $0x1, %r15b
jne 0x148d7
movq 0x18(%r13), %rcx
movb 0x10(%rcx), %cl
movq (%r12), %rdx
cltq
leaq (%rax,%rax,2), %rax
movb %cl, 0x10(%rdx,%rax,8)
jmp 0x148d7
xorl %edx, %edx
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x15180
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x16320
movq 0x30(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x24691
movq 0x30(%rbx), %rdi
movl %ebp, %esi
callq 0x25947
jmp 0x148d7
movq 0x30(%rbx), %r14
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x14a31
movq %rax, %r13
xorl %r12d, %r12d
cmpl $0x3c, 0x10(%rbx)
movl $0x0, %eax
jne 0x142da
movq %rbx, %rdi
callq 0x275c6
movq %rbx, %rdi
callq 0x14a31
leaq 0x18(%rax), %r12
cmpb $0x0, 0xb(%rax)
jns 0x14297
movq (%r12), %r12
movq %rbx, %rdi
movl $0x3e, %esi
callq 0x14afd
movq %r12, %rdi
leaq 0x166a7(%rip), %rsi # 0x2a955
callq 0x5420
testl %eax, %eax
je 0x142d5
movq %r12, %rdi
leaq 0x15442(%rip), %rsi # 0x29703
callq 0x5420
testl %eax, %eax
jne 0x1492c
movb $0x2, %al
movb $0x1, %r12b
jmp 0x142da
movb $0x1, %al
xorl %r12d, %r12d
movzbl %al, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x15762
movl %eax, %r13d
testb %r12b, %r12b
je 0x14302
cmpl $-0x1, %r15d
jne 0x1491d
movzbl 0x4a(%r14), %r15d
addl %ebp, %r15d
cmpl $0x2c, 0x10(%rbx)
jne 0x14317
movq %rbx, %rdi
callq 0x275c6
incl %ebp
jmp 0x14260
cmpl $0x3d, 0x10(%rbx)
jne 0x14757
movq %rbx, %rdi
callq 0x275c6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x15be9
movl %eax, %r8d
jmp 0x14761
cmpl $0x12, 0x8(%rsp)
jne 0x1494c
movq (%r14), %rax
movq 0x40(%rax), %rax
movslq 0x10(%rsp), %rcx
movb $0x1, 0x3(%rax,%rcx,4)
jmp 0x148d7
xorl %esi, %esi
movq %rsp, %r8
movb %sil, 0x13(%r8)
movq %rdi, (%r8)
movq %r8, 0x18(%r14)
leaq 0x30(%rsp), %r13
movb %al, 0x10(%r13)
movl %ecx, 0x8(%r13)
movl %edx, 0xc(%r13)
movw $0x0, 0x11(%r13)
movb %sil, 0x13(%r13)
movq %r8, (%r13)
movq %r13, 0x18(%r14)
movq %rbx, %rdi
callq 0x275c6
movq %rbx, %rdi
callq 0x13b62
movq %rbx, %rdi
movl $0x114, %esi # imm = 0x114
movl $0x110, %edx # imm = 0x110
movl %ebp, %ecx
callq 0x149c0
movq %rbx, %rdi
callq 0x14abf
movl %eax, %r12d
movq %r14, %rdi
callq 0x15c32
cmpb $0x0, 0x11(%r13)
je 0x14722
movq %r14, %rdi
callq 0x23e88
movl %eax, %ebp
movq %r14, %rdi
movl %r12d, %esi
callq 0x23f78
movzbl 0x40(%rsp), %ecx
testl %ecx, %ecx
jle 0x146f3
movq 0x10(%r14), %rdx
movq 0x58(%rdx), %rdx
movq (%rdx), %rsi
movslq 0x40(%r14), %rdx
addq %rcx, %rdx
leaq (%rdx,%rdx,2), %rdi
movb -0xf(%rsi,%rdi,8), %dl
cmpb $0x3, %dl
je 0x14421
leaq (%rsi,%rdi,8), %rax
addq $-0x18, %rax
movb 0xa(%rax), %al
incb %al
decq %rcx
cmpb $0x3, %dl
je 0x143ed
jmp 0x146f5
xorl %ecx, %ecx
leaq 0x30(%rsp), %rdx
movb %cl, 0x13(%rdx)
movq %rax, (%rdx)
movq %rdx, 0x18(%r14)
movq %rbx, %rdi
callq 0x275c6
movq %rbx, %rdi
callq 0x14a31
movq %rax, %r13
movl 0x10(%rbx), %eax
cmpl $0x2c, %eax
je 0x14556
cmpl $0x10b, %eax # imm = 0x10B
je 0x14556
cmpl $0x3d, %eax
jne 0x14955
movq 0x30(%rbx), %r12
movzbl 0x4c(%r12), %eax
movl %eax, 0x20(%rsp)
leaq 0x16450(%rip), %r15 # 0x2a8d7
movl $0xb, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x274c6
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x15762
movl $0xb, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x274c6
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x15762
movq %rbx, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x15762
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x14afd
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x14b0c
movq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x24484
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x14afd
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x14b0c
movq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x24484
cmpl $0x2c, 0x10(%rbx)
jne 0x14837
movq %rbx, %rdi
callq 0x275c6
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x14b0c
movq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x24484
jmp 0x14857
movq %r14, 0x20(%rsp)
movq 0x30(%rbx), %r12
movzbl 0x4c(%r12), %eax
movl %eax, 0x2c(%rsp)
leaq 0x16367(%rip), %r15 # 0x2a8d7
movl $0xb, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x274c6
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x15762
movl $0xb, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x274c6
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x15762
movl $0xb, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x274c6
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x15762
movl $0x1, %r15d
movq %rbx, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x15762
cmpl $0x2c, 0x10(%rbx)
jne 0x1460f
movl $0x1, %r15d
movq %rbx, %rdi
callq 0x275c6
movq %rbx, %rdi
callq 0x14a31
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x15762
incl %r15d
cmpl $0x2c, 0x10(%rbx)
je 0x145e9
movq %rbx, %rdi
movl $0x10b, %esi # imm = 0x10B
callq 0x14afd
movl 0x4(%rbx), %r13d
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15be9
movq %rbx, %rdi
movl $0x4, %esi
movl %eax, %edx
movq %r14, %rcx
callq 0x162ae
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1562b
movq 0x18(%r12), %rax
movb $0x1, %cl
movb %cl, 0x11(%rax)
movb %cl, 0x13(%rax)
movb %cl, 0x4e(%r12)
movq %r12, %rdi
movl $0x2, %esi
callq 0x24102
movq %rbx, %rdi
movl 0x2c(%rsp), %esi
movl %r13d, %edx
movl %r15d, %ecx
movl $0x1, %r8d
callq 0x16121
movq 0x20(%rsp), %r14
jmp 0x1487a
xorl %ecx, %ecx
movq %rsp, %rdx
movb %cl, 0x13(%rdx)
movq %rax, (%rdx)
movq %rdx, 0x18(%r14)
movq %rbx, %rdi
movl $0x102, %esi # imm = 0x102
callq 0x14afd
movq %rbx, %rdi
callq 0x1495e
movq %r14, %rdi
callq 0x23e88
movq %r14, %rdi
movl %eax, %esi
movl %r12d, %edx
callq 0x23ef5
movq %rbx, %rdi
movl $0x105, %esi # imm = 0x105
movl $0x115, %edx # imm = 0x115
movl %ebp, %ecx
callq 0x149c0
movq %r14, %rdi
callq 0x15c32
movq %r14, %rdi
movl %r15d, %esi
callq 0x23f78
jmp 0x148d7
xorl %eax, %eax
movzbl %al, %edx
movq %r14, %rdi
movl $0x36, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x23de3
movq %r14, %rdi
callq 0x23e88
movl %eax, %r12d
movq %r14, %rdi
movl %ebp, %esi
callq 0x23f78
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x23ef5
jmp 0x1488e
movq %rsp, %rsi
movq %r14, %rdi
cmpl $0x1, %r12d
jne 0x148b4
callq 0x245fc
movl %eax, %ebp
movl $0x1, %r15d
jmp 0x148bc
movl $0x0, (%rsp)
xorl %r8d, %r8d
leal -0x1(%r8), %eax
cmpl %ebp, %eax
jne 0x147bc
movq 0x10(%r14), %rax
movq 0x58(%rax), %rax
movslq 0x40(%r14), %rcx
movslq %r13d, %rdx
addq %rcx, %rdx
leaq (%rdx,%rdx,2), %r12
shlq $0x3, %r12
addq (%rax), %r12
cmpb $0x1, 0x9(%r12)
jne 0x147bc
movq %rsp, %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %r8, %r13
callq 0x23c61
movq %r13, %r8
testl %eax, %eax
je 0x147bc
movb $0x3, 0x9(%r12)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1562b
incb 0x4a(%r14)
jmp 0x147d8
incl %ebp
movq %rsp, %rcx
movq %rbx, %rdi
movl %ebp, %esi
movl %r8d, %edx
callq 0x162ae
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1562b
cmpl $-0x1, %r15d
je 0x148d7
movq 0x18(%r14), %rax
movb $0x1, %cl
movb %cl, 0x11(%rax)
movb %cl, 0x13(%rax)
movb %cl, 0x4e(%r14)
leal -0x1(%r15), %eax
movslq %eax, %rcx
testl %r15d, %r15d
jle 0x14898
movq 0x10(%r14), %rdx
movq 0x58(%rdx), %rdx
movq (%rdx), %rsi
movslq 0x40(%r14), %rdx
addq %rcx, %rdx
leaq (%rdx,%rdx,2), %rdi
movb 0x9(%rsi,%rdi,8), %dl
cmpb $0x3, %dl
je 0x1482a
leaq (%rsi,%rdi,8), %rax
movb 0xa(%rax), %al
incb %al
decq %rcx
decl %r15d
cmpb $0x3, %dl
je 0x147f9
jmp 0x1489a
movzbl 0x4c(%r12), %esi
movl $0x1, %edx
movq %r12, %rdi
callq 0x24155
movq %r12, %rdi
movl $0x1, %esi
callq 0x2413b
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1562b
movq %rbx, %rdi
movl 0x20(%rsp), %esi
movl %ebp, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x16121
movq %rbx, %rdi
movl $0x105, %esi # imm = 0x105
movl $0x107, %edx # imm = 0x107
movl %ebp, %ecx
callq 0x149c0
movq %r14, %rdi
callq 0x15c32
jmp 0x148d7
xorl %eax, %eax
movzbl %al, %edx
movq %r14, %rdi
movl $0x37, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x23de3
jmp 0x148d7
callq 0x24484
movl %r12d, %r15d
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x23e92
cmpl $0x3b, 0x10(%rbx)
jne 0x148d7
movq %rbx, %rdi
callq 0x275c6
movq 0x30(%rbx), %r14
movq %r14, %rdi
callq 0x13820
movb %al, 0x4c(%r14)
movq 0x38(%rbx), %rax
decl 0xb0(%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x59b3
leaq 0x16083(%rip), %rsi # 0x2a998
movq %rbx, %rdi
callq 0x27434
leaq 0x16003(%rip), %rsi # 0x2a927
movq %rbx, %rdi
callq 0x23c54
movq 0x38(%rbx), %rdi
leaq 0x16024(%rip), %rsi # 0x2a95b
movq %r12, %rdx
xorl %eax, %eax
callq 0x12c36
movq %rbx, %rdi
movq %rax, %rsi
callq 0x23c54
leaq 0x16058(%rip), %rsi # 0x2a9ab
jmp 0x14915
leaq 0x15f66(%rip), %rsi # 0x2a8c2
jmp 0x14915
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
block | static void block (LexState *ls) {
/* block -> statlist */
FuncState *fs = ls->fs;
BlockCnt bl;
enterblock(fs, &bl, 0);
statlist(ls);
leaveblock(fs);
} | pushq %rbx
subq $0x20, %rsp
movq 0x30(%rdi), %rbx
xorl %eax, %eax
movb %al, 0x1a(%rsp)
movb 0x4a(%rbx), %cl
movb %cl, 0x18(%rsp)
movq 0x10(%rbx), %rcx
movq 0x58(%rcx), %rcx
movl 0x28(%rcx), %edx
movl %edx, 0x10(%rsp)
movl 0x18(%rcx), %ecx
movl %ecx, 0x14(%rsp)
movb %al, 0x19(%rsp)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1499e
cmpb $0x0, 0x13(%rcx)
setne %al
leaq 0x8(%rsp), %rdx
movb %al, 0x13(%rdx)
movq %rcx, (%rdx)
movq %rdx, 0x18(%rbx)
callq 0x13b62
movq %rbx, %rdi
callq 0x15c32
addq $0x20, %rsp
popq %rbx
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
check_match | static void check_match (LexState *ls, int what, int who, int where) {
if (l_unlikely(!testnext(ls, what))) {
if (where == ls->linenumber) /* all in the same line? */
error_expected(ls, what); /* do not need a complex message */
else {
luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
"%s expected (to close %s at line %d)",
luaX_token2str(ls, what), luaX_token2str(ls, who), where));
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl %esi, 0x10(%rdi)
jne 0x149e0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x275c6
movl %ecx, %ebp
cmpl %ecx, 0x4(%rbx)
jne 0x149ef
movq %rbx, %rdi
callq 0x160f2
movl %edx, %r14d
movq 0x38(%rbx), %r15
movq %rbx, %rdi
callq 0x273cf
movq %rax, %r12
movq %rbx, %rdi
movl %r14d, %esi
callq 0x273cf
leaq 0x15e7e(%rip), %rsi # 0x2a891
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x12c36
movq %rbx, %rdi
movq %rax, %rsi
callq 0x27434
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
test_then_block | static void test_then_block (LexState *ls, int *escapelist) {
/* test_then_block -> [IF | ELSEIF] cond THEN block */
FuncState *fs = ls->fs;
int condtrue;
luaX_next(ls); /* skip IF or ELSEIF */
condtrue = cond(ls); /* read condition */
checknext(ls, TK_THEN);
block(ls); /* 'then' part */
if (ls->t.token == TK_ELSE ||
ls->t.token == TK_ELSEIF) /* followed by 'else'/'elseif'? */
luaK_concat(fs, escapelist, luaK_jump(fs)); /* must jump over it */
luaK_patchtohere(fs, condtrue);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rbx
callq 0x275c6
movq %r15, %rdi
callq 0x14abf
movl %eax, %ebp
movq %r15, %rdi
movl $0x112, %esi # imm = 0x112
callq 0x14afd
movq %r15, %rdi
callq 0x1495e
movl $0xfffffefd, %eax # imm = 0xFFFFFEFD
addl 0x10(%r15), %eax
cmpl $0x1, %eax
ja 0x14aab
movq %rbx, %rdi
callq 0x23e88
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x23e01
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x23f78
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
cond | static int cond (LexState *ls) {
/* cond -> exp */
expdesc v;
expr(ls, &v); /* read condition */
if (v.k == VNIL) v.k = VFALSE; /* 'falses' are all equal here */
luaK_goiftrue(ls->fs, &v);
return v.f;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x14b0c
cmpl $0x1, (%r14)
jne 0x14ae3
movl $0x3, (%rsp)
movq 0x30(%rbx), %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x24814
movl 0x14(%rbx), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
subexpr | static BinOpr subexpr (LexState *ls, expdesc *v, int limit) {
BinOpr op;
UnOpr uop;
enterlevel(ls);
uop = getunopr(ls->t.token);
if (uop != OPR_NOUNOPR) { /* prefix (unary) operator? */
int line = ls->linenumber;
luaX_next(ls); /* skip operator */
subexpr(ls, v, UNARY_PRIORITY);
luaK_prefix(ls->fs, uop, v, line);
}
else simpleexp(ls, v);
/* expand while operators have priorities higher than 'limit' */
op = getbinopr(ls->t.token);
while (op != OPR_NOBINOPR && priority[op].left > limit) {
expdesc v2;
BinOpr nextop;
int line = ls->linenumber;
luaX_next(ls); /* skip operator */
luaK_infix(ls->fs, op, v);
/* read sub-expression with higher priority */
nextop = subexpr(ls, &v2, priority[op].right);
luaK_posfix(ls->fs, op, v, &v2, line);
op = nextop;
}
leavelevel(ls);
return op; /* return first untreated operator */
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x166f2
movl 0x10(%rbx), %eax
cmpl $0x7d, %eax
jg 0x14b48
cmpl $0x23, %eax
je 0x14b66
cmpl $0x2d, %eax
jne 0x14b5c
xorl %ecx, %ecx
xorl %r15d, %r15d
jmp 0x14b76
cmpl $0x7e, %eax
je 0x14b6e
cmpl $0x10e, %eax # imm = 0x10E
jne 0x14b5c
movl $0x2, %r15d
jmp 0x14b74
movl $0x4, %r15d
movb $0x1, %cl
jmp 0x14b76
movl $0x3, %r15d
jmp 0x14b74
movl $0x1, %r15d
xorl %ecx, %ecx
testb %cl, %cl
je 0x14bda
cmpl $0x112, %eax # imm = 0x112
jle 0x14c12
cmpl $0x120, %eax # imm = 0x120
jle 0x14c73
cmpl $0x124, %eax # imm = 0x124
je 0x14cf7
cmpl $0x122, %eax # imm = 0x122
je 0x14d2c
cmpl $0x121, %eax # imm = 0x121
jne 0x14e32
movq 0x8(%rsp), %rax
movq $-0x1, 0x10(%rax)
movl $0x5, (%rax)
movl $0x0, 0x8(%rax)
movsd 0x18(%rbx), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x14d4e
movl 0x4(%rbx), %r12d
movq %rbx, %rdi
callq 0x275c6
movq %rbx, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rsi
movl $0xc, %edx
callq 0x14b0c
movq 0x30(%rbx), %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %r12d, %ecx
callq 0x24d08
jmp 0x14d56
cmpl $0x107, %eax # imm = 0x107
jg 0x14c45
cmpl $0x7b, %eax
je 0x14ccc
cmpl $0x106, %eax # imm = 0x106
jne 0x14e32
movq 0x8(%rsp), %rax
movq $-0x1, 0x10(%rax)
movl $0x3, (%rax)
jmp 0x14d23
cmpl $0x108, %eax # imm = 0x108
je 0x14cdb
cmpl $0x10d, %eax # imm = 0x10D
jne 0x14e32
movq 0x8(%rsp), %rax
movq $-0x1, 0x10(%rax)
movl $0x1, (%rax)
jmp 0x14d23
cmpl $0x113, %eax # imm = 0x113
je 0x14d10
cmpl $0x118, %eax # imm = 0x118
jne 0x14e32
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
testb $0x1, 0xb(%rax)
je 0x14f4d
movl $0x50, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x23de3
movq 0x8(%rsp), %rcx
movq $-0x1, 0x10(%rcx)
movl $0x13, (%rcx)
movl %eax, 0x8(%rcx)
jmp 0x14d4e
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x14f5c
jmp 0x14d56
movq %rbx, %rdi
callq 0x275c6
movl 0x4(%rbx), %ecx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x15180
jmp 0x14d56
movq 0x18(%rbx), %rax
movq 0x8(%rsp), %rcx
movq $-0x1, 0x10(%rcx)
movl $0x7, (%rcx)
jmp 0x14d4a
movq 0x8(%rsp), %rax
movq $-0x1, 0x10(%rax)
movl $0x2, (%rax)
movl $0x0, 0x8(%rax)
jmp 0x14d4e
movq 0x8(%rsp), %rcx
movq $-0x1, 0x10(%rcx)
movl $0x6, (%rcx)
movl $0x0, 0x8(%rcx)
movq 0x18(%rbx), %rax
movq %rax, 0x8(%rcx)
movq %rbx, %rdi
callq 0x275c6
movl 0x10(%rbx), %eax
cmpl $0x7d, %eax
jg 0x14d8a
cmpl $0x3b, %eax
jg 0x14db0
addl $-0x25, %eax
cmpl $0xa, %eax
ja 0x14e54
leaq 0x1592e(%rip), %rcx # 0x2a6a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, %r15d
jmp 0x14ea4
leal -0x10f(%rax), %ecx
cmpl $0xf, %ecx
ja 0x14de7
leaq 0x15934(%rip), %rax # 0x2a6d0
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x14, %r15d
jmp 0x14ea4
cmpl $0x5d, %eax
jg 0x14dd2
cmpl $0x3c, %eax
je 0x14e44
cmpl $0x3e, %eax
jne 0x14e54
movl $0x11, %r15d
jmp 0x14ea4
cmpl $0x5e, %eax
je 0x14e4c
cmpl $0x7c, %eax
jne 0x14e54
movl $0x8, %r15d
jmp 0x14ea4
cmpl $0x7e, %eax
je 0x14e9e
cmpl $0x100, %eax # imm = 0x100
jne 0x14e54
movl $0x13, %r15d
jmp 0x14ea4
movl $0x2, %r15d
jmp 0x14ea4
movl $0x7, %r15d
jmp 0x14ea4
xorl %eax, %eax
xorl %r15d, %r15d
jmp 0x14ea6
movl $0x1, %r15d
jmp 0x14ea4
movl $0x5, %r15d
jmp 0x14ea4
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x153d9
jmp 0x14d56
movl $0xe, %r15d
jmp 0x14ea4
movl $0x4, %r15d
jmp 0x14ea4
movl $0x15, %r15d
movb $0x1, %al
jmp 0x14ea6
movl $0xa, %r15d
jmp 0x14ea4
movl $0xc, %r15d
jmp 0x14ea4
movl $0xf, %r15d
jmp 0x14ea4
movl $0x12, %r15d
jmp 0x14ea4
movl $0xd, %r15d
jmp 0x14ea4
movl $0xb, %r15d
jmp 0x14ea4
movl $0x6, %r15d
jmp 0x14ea4
movl $0x10, %r15d
jmp 0x14ea4
movl $0x9, %r15d
xorl %eax, %eax
movq %rbx, 0x18(%rsp)
testb %al, %al
je 0x14eb4
movl %r15d, %r13d
jmp 0x14f2c
movq 0x18(%rsp), %r14
movq 0x8(%rsp), %rbx
movl %r15d, %r13d
leaq 0x15848(%rip), %rax # 0x2a710
movzbl (%rax,%r13,2), %eax
cmpl 0x14(%rsp), %eax
jle 0x14eaf
movl 0x4(%r14), %ebp
movq %r14, %rdi
callq 0x275c6
movq 0x30(%r14), %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x25006
leaq 0x1581b(%rip), %rax # 0x2a710
movzbl 0x1(%rax,%r13,2), %edx
movq %r14, %rdi
leaq 0x20(%rsp), %r12
movq %r12, %rsi
callq 0x14b0c
movl %eax, %r13d
movq 0x30(%r14), %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r12, %rcx
movl %ebp, %r8d
callq 0x25191
movl %r13d, %r15d
cmpl $0x15, %r13d
jne 0x14ebe
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
decl 0xb0(%rax)
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15828(%rip), %rsi # 0x2a77c
movq %rbx, %rdi
callq 0x27434
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
singlevar | static void singlevar (LexState *ls, expdesc *var) {
TString *varname = str_checkname(ls);
FuncState *fs = ls->fs;
singlevaraux(fs, varname, var, 1);
if (var->k == VVOID) { /* global name? */
expdesc key;
singlevaraux(fs, ls->envn, var, 1); /* get environment variable */
lua_assert(var->k != VVOID); /* this one must exist */
luaK_exp2anyregup(fs, var); /* but could be a constant */
codestring(&key, varname); /* key is variable name */
luaK_indexed(fs, var, &key); /* env[varname] */
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r12
callq 0x14a31
movq %rax, %r15
movq 0x30(%r12), %r14
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x15a04
cmpl $0x0, (%rbx)
jne 0x159f8
movq 0x68(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x15a04
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24661
movq %rsp, %rdx
movq $-0x1, 0x10(%rdx)
movl $0x7, (%rdx)
movq %r15, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24bd4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
singlevaraux | static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
if (fs == NULL) /* no more levels? */
init_exp(var, VVOID, 0); /* default is global */
else {
int v = searchvar(fs, n, var); /* look up locals at current level */
if (v >= 0) { /* found? */
if (v == VLOCAL && !base)
markupval(fs, var->u.var.vidx); /* local will be used as an upval */
}
else { /* not found as local at current level; try upvalues */
int idx = searchupvalue(fs, n); /* try existing upvalues */
if (idx < 0) { /* not found? */
singlevaraux(fs->prev, n, var, 0); /* try upper levels */
if (var->k == VLOCAL || var->k == VUPVAL) /* local or upvalue? */
idx = newupvalue(fs, n, var); /* will be a new upvalue */
else /* it is a global or a constant */
return; /* don't need to do anything at this level */
}
init_exp(var, VUPVAL, idx); /* new or old upvalue */
}
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
testq %rdi, %rdi
je 0x15aa3
movq %rsi, %r15
movq %rdi, %rbx
movzbl 0x4a(%rdi), %eax
decl %eax
leal 0x1(%rax), %esi
testl %esi, %esi
jle 0x15ab5
movq 0x10(%rbx), %rsi
movq 0x58(%rsi), %rsi
movq (%rsi), %r8
movl 0x40(%rbx), %edi
addl %eax, %edi
movslq %edi, %rsi
leaq (%rsi,%rsi,2), %r9
movq 0x10(%r8,%r9,8), %rsi
cmpq %r15, %rsi
jne 0x15a9a
leaq (%r8,%r9,8), %rdx
cmpb $0x3, 0x9(%rdx)
movq $-0x1, 0x10(%r14)
jne 0x15a6c
movl $0xb, (%r14)
movl %edi, 0x8(%r14)
jmp 0x15a97
movl $0x9, (%r14)
movw %ax, 0xa(%r14)
movq 0x10(%rbx), %rdx
movq 0x58(%rdx), %rdx
movq (%rdx), %rdx
movl 0x40(%rbx), %edi
addl %eax, %edi
movslq %edi, %rdi
leaq (%rdi,%rdi,2), %rdi
movb 0xa(%rdx,%rdi,8), %dl
movb %dl, 0x8(%r14)
movl (%r14), %edx
decl %eax
cmpq %r15, %rsi
jne 0x15a21
jmp 0x15aba
movq $-0x1, 0x10(%r14)
xorl %eax, %eax
movl %eax, (%r14)
jmp 0x15bdf
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
testl %edx, %edx
js 0x15aeb
xorl $0x9, %edx
orl %edx, %ecx
jne 0x15be3
movzwl 0xa(%r14), %ecx
leaq 0x18(%rbx), %rax
movq (%rax), %rax
movzbl 0x10(%rax), %edx
cmpw %dx, %cx
jb 0x15ad2
movb $0x1, %cl
movb %cl, 0x11(%rax)
movb %cl, 0x4e(%rbx)
jmp 0x15be3
movzbl 0x4b(%rbx), %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x15b17
movq (%rbx), %rdx
movq 0x50(%rdx), %rsi
xorl %edx, %edx
cmpq %r15, (%rsi)
je 0x15b15
incq %rdx
addq $0x10, %rsi
cmpq %rdx, %rcx
jne 0x15b02
jmp 0x15b17
movl %edx, %eax
testl %eax, %eax
jns 0x15bd0
movq 0x8(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x15a04
movl (%r14), %eax
addl $-0x9, %eax
cmpl $0x1, %eax
ja 0x15be3
movq %rbx, %rdi
callq 0x13ace
movq 0x8(%rbx), %rcx
cmpl $0x9, (%r14)
jne 0x15b81
movb $0x1, 0x8(%rax)
movb 0x8(%r14), %dl
movb %dl, 0x9(%rax)
movzwl 0xa(%r14), %edx
movq 0x10(%rcx), %rsi
movq 0x58(%rsi), %rsi
movq (%rsi), %rsi
movslq 0x40(%rcx), %rcx
addq %rdx, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rsi,%rcx,8), %rcx
addq $0x9, %rcx
jmp 0x15ba2
movb $0x0, 0x8(%rax)
movb 0x8(%r14), %dl
movb %dl, 0x9(%rax)
movq (%rcx), %rcx
movq 0x50(%rcx), %rcx
movslq 0x8(%r14), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
addq $0xa, %rcx
movb (%rcx), %cl
movb %cl, 0xa(%rax)
movq %r15, (%rax)
movq (%rbx), %rsi
testb $0x20, 0x9(%rsi)
je 0x15bca
testb $0x18, 0x9(%r15)
je 0x15bca
movq 0x10(%rbx), %rax
movq 0x38(%rax), %rdi
movq %r15, %rdx
callq 0xd508
movzbl 0x4b(%rbx), %eax
decl %eax
movq $-0x1, 0x10(%r14)
movl $0xa, (%r14)
movl %eax, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
explist | static int explist (LexState *ls, expdesc *v) {
/* explist -> expr { ',' expr } */
int n = 1; /* at least one expression */
expr(ls, v);
while (testnext(ls, ',')) {
luaK_exp2nextreg(ls->fs, v);
expr(ls, v);
n++;
}
return n;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0x14b0c
movl $0x1, %ebp
cmpl $0x2c, 0x10(%r14)
jne 0x15c2b
movq %r14, %rdi
callq 0x275c6
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x24484
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x14b0c
incl %ebp
jmp 0x15bff
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
leaveblock | static void leaveblock (FuncState *fs) {
BlockCnt *bl = fs->bl;
LexState *ls = fs->ls;
lu_byte stklevel = reglevel(fs, bl->nactvar); /* level outside block */
if (bl->previous && bl->upval) /* need a 'close'? */
luaK_codeABC(fs, OP_CLOSE, stklevel, 0, 0);
fs->freereg = stklevel; /* free registers */
removevars(fs, bl->nactvar); /* remove block locals */
lua_assert(bl->nactvar == fs->nactvar); /* back to level on entry */
if (bl->isloop == 2) /* has to fix pending breaks? */
createlabel(ls, luaS_newliteral(ls->L, "break"), 0, 0);
solvegotos(fs, bl);
if (bl->previous == NULL) { /* was it the last block? */
if (bl->firstgoto < ls->dyd->gt.n) /* still pending gotos? */
undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */
}
fs->bl = bl->previous; /* current block now is previous one */
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r13
movzbl 0x10(%r13), %eax
testl %eax, %eax
jle 0x15c85
movq 0x58(%r15), %rcx
movq (%rcx), %rdx
movl 0x40(%r14), %ecx
addl %eax, %ecx
decl %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rsi
movb 0x9(%rdx,%rsi,8), %cl
cmpb $0x3, %cl
je 0x15c7c
leaq (%rdx,%rsi,8), %rdx
movb 0xa(%rdx), %bl
incb %bl
decl %eax
cmpb $0x3, %cl
je 0x15c50
jmp 0x15c87
xorl %ebx, %ebx
cmpq $0x0, (%r13)
je 0x15cad
cmpb $0x0, 0x11(%r13)
je 0x15cad
movzbl %bl, %edx
movq %r14, %rdi
movl $0x36, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x23de3
movb %bl, 0x4c(%r14)
movzbl 0x10(%r13), %eax
movzbl 0x4a(%r14), %ecx
movl %eax, %esi
subl %ecx, %esi
movq 0x10(%r14), %rdx
movq 0x58(%rdx), %rdx
addl %esi, 0x8(%rdx)
cmpb %al, %cl
jbe 0x15d1b
movq (%rdx), %rdx
leal -0x1(%rcx), %esi
movzbl %sil, %esi
addl 0x40(%r14), %esi
decb %cl
movb %cl, 0x4a(%r14)
movslq %esi, %rdi
leaq (%rdi,%rdi,2), %rdi
cmpb $0x3, 0x9(%rdx,%rdi,8)
jne 0x15cf4
xorl %edi, %edi
jmp 0x15d08
leaq (%rdx,%rdi,8), %rdi
movswq 0xc(%rdi), %rdi
movq (%r14), %r8
shlq $0x4, %rdi
addq 0x68(%r8), %rdi
testq %rdi, %rdi
je 0x15d15
movl 0x28(%r14), %r8d
movl %r8d, 0xc(%rdi)
decl %esi
cmpb %cl, %al
jb 0x15cdc
movq %r15, (%rsp)
cmpb $0x2, 0x12(%r13)
jne 0x15d66
movq (%rsp), %rbx
movq 0x38(%rbx), %rdi
leaq 0x14ae5(%rip), %rsi # 0x2a81a
movl $0x5, %edx
callq 0x170cb
movq %rax, %r15
movq 0x30(%rbx), %rdi
movq 0x58(%rbx), %r12
addq $0x20, %r12
callq 0x23eee
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
movl %eax, %r8d
callq 0x16001
movq 0x10(%r14), %rdi
movq 0x58(%rdi), %r12
movzbl 0x10(%r13), %eax
testl %eax, %eax
jle 0x15da7
movq (%r12), %rdx
movl 0x40(%r14), %ecx
addl %eax, %ecx
decl %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rsi
movb 0x9(%rdx,%rsi,8), %cl
cmpb $0x3, %cl
je 0x15d9e
leaq (%rdx,%rsi,8), %rdx
movb 0xa(%rdx), %r8b
incb %r8b
decl %eax
cmpb $0x3, %cl
je 0x15d73
jmp 0x15daa
xorl %r8d, %r8d
movl %r8d, 0xc(%rsp)
movl 0xc(%r13), %ebx
cmpl 0x18(%r12), %ebx
jge 0x15f7b
movq %r13, 0x10(%rsp)
movq 0x10(%r12), %rdx
movslq %ebx, %r15
leaq (%r15,%r15,2), %rcx
movslq 0x8(%r13), %rax
movq 0x58(%rdi), %rbp
movslq 0x28(%rbp), %rsi
cmpl %eax, %esi
jle 0x15e04
movq (%rdx,%rcx,8), %r9
subq %rax, %rsi
leaq (%rax,%rax,2), %r8
shlq $0x3, %r8
addq 0x20(%rbp), %r8
cmpq %r9, (%r8)
cmoveq %r8, %rax
je 0x15e06
addq $0x18, %r8
decq %rsi
jne 0x15df2
xorl %eax, %eax
movb 0x11(%r13), %r8b
testq %rax, %rax
je 0x15e86
movq 0x10(%rbp), %rdx
leaq (%rdx,%rcx,8), %rsi
movb 0x10(%rsi), %dl
movzbl 0x10(%rax), %ecx
cmpb %cl, %dl
jb 0x15fb3
movq %rdi, %r13
movq 0x30(%rdi), %rdi
cmpb $0x0, 0x11(%rsi)
jne 0x15e44
testb %r8b, %r8b
je 0x15f04
cmpb %dl, %cl
jae 0x15f04
testl %ecx, %ecx
jle 0x15eda
movq 0x10(%rdi), %r8
movq 0x58(%r8), %r8
movq (%r8), %r9
movl 0x40(%rdi), %r8d
addl %ecx, %r8d
decl %r8d
movslq %r8d, %r8
leaq (%r8,%r8,2), %r10
movb 0x9(%r9,%r10,8), %r8b
cmpb $0x3, %r8b
je 0x15e7c
leaq (%r9,%r10,8), %rdx
movb 0xa(%rdx), %dl
incb %dl
decl %ecx
cmpb $0x3, %r8b
je 0x15e44
jmp 0x15edc
leaq (%rdx,%rcx,8), %rax
testb %r8b, %r8b
je 0x15f67
movzbl 0x10(%rax), %edx
testl %edx, %edx
jle 0x15f5b
movq 0x10(%r14), %rsi
movq 0x58(%rsi), %rsi
movq (%rsi), %r9
movl 0x40(%r14), %esi
addl %edx, %esi
decl %esi
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %r8
movb 0x9(%r9,%r8,8), %sil
cmpb $0x3, %sil
je 0x15ecd
leaq (%r9,%r8,8), %rcx
movb 0xa(%rcx), %cl
incb %cl
decl %edx
cmpb $0x3, %sil
je 0x15e97
jmp 0x15f5d
xorl %edx, %edx
movq (%rdi), %rcx
movq 0x40(%rcx), %rcx
movslq 0x8(%rsi), %r8
movl (%rcx,%r8,4), %r9d
movl %r9d, 0x4(%rcx,%r8,4)
movzbl %dl, %edx
shll $0x7, %edx
orl $0x36, %edx
movslq 0x8(%rsi), %r8
movl %edx, (%rcx,%r8,4)
incl 0x8(%rsi)
movl 0x8(%rsi), %esi
movl 0x8(%rax), %edx
callq 0x23ef5
movl 0x18(%rbp), %ecx
decl %ecx
cmpl %ebx, %ecx
jle 0x15f4e
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %rax
movq 0x10(%rbp), %rcx
incq %r15
movq 0x28(%rcx,%rax), %rdx
movq %rdx, 0x10(%rcx,%rax)
movups 0x18(%rcx,%rax), %xmm0
movups %xmm0, (%rcx,%rax)
movslq 0x18(%rbp), %rcx
decq %rcx
addq $0x18, %rax
cmpq %rcx, %r15
jl 0x15f24
movl %ecx, 0x18(%rbp)
movq %r13, %rdi
movq 0x10(%rsp), %r13
jmp 0x15f70
xorl %ecx, %ecx
cmpb 0xc(%rsp), %cl
jbe 0x15f67
movb $0x1, 0x11(%rax)
movb 0x10(%r13), %cl
movb %cl, 0x10(%rax)
incl %ebx
cmpl 0x18(%r12), %ebx
jl 0x15dc3
movl 0x8(%r13), %eax
movq 0x58(%rdi), %rcx
movl %eax, 0x28(%rcx)
movq (%r13), %rax
testq %rax, %rax
jne 0x15fa0
movslq 0xc(%r13), %rdx
movq (%rsp), %rcx
movq 0x58(%rcx), %rcx
cmpl 0x18(%rcx), %edx
jl 0x15fb8
movq %rax, 0x18(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1608e
leaq (%rdx,%rdx,2), %rsi
shlq $0x3, %rsi
addq 0x10(%rcx), %rsi
movq (%rsp), %rdi
callq 0x15fcd
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
newlabelentry | static int newlabelentry (LexState *ls, Labellist *l, TString *name,
int line, int pc) {
int n = l->n;
luaM_growvector(ls->L, l->arr, n, l->size,
Labeldesc, SHRT_MAX, "labels/gotos");
l->arr[n].name = name;
l->arr[n].line = line;
l->arr[n].nactvar = ls->fs->nactvar;
l->arr[n].close = 0;
l->arr[n].pc = pc;
l->n = n + 1;
return n;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movslq 0x8(%rsi), %r13
movq 0x38(%rdi), %rdi
movq (%rsi), %rsi
leaq 0xc(%rbx), %rcx
leaq 0x147ef(%rip), %rax # 0x2a820
movq %rax, (%rsp)
movl %r13d, %edx
movl $0x18, %r8d
movl $0x7fff, %r9d # imm = 0x7FFF
callq 0x111d8
movq %rax, (%rbx)
leaq (,%r13,2), %rcx
addq %r13, %rcx
movq %r15, (%rax,%rcx,8)
movl %r14d, 0xc(%rax,%rcx,8)
movq 0x30(%r12), %rdx
movb 0x4a(%rdx), %dl
movb %dl, 0x10(%rax,%rcx,8)
movb $0x0, 0x11(%rax,%rcx,8)
movl %ebp, 0x8(%rax,%rcx,8)
leal 0x1(%r13), %eax
movl %eax, 0x8(%rbx)
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
jumpscopeerror | static l_noret jumpscopeerror (LexState *ls, Labeldesc *gt) {
TString *tsname = getlocalvardesc(ls->fs, gt->nactvar)->vd.name;
const char *varname = getstr(tsname);
const char *msg = "<goto %s> at line %d jumps into the scope of local '%s'";
msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line, varname);
luaK_semerror(ls, msg); /* raise the error */
} | pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movzbl 0x10(%rsi), %ecx
movq 0x10(%rax), %rdx
movq 0x58(%rdx), %rdx
movq (%rdx), %rdx
movslq 0x40(%rax), %rax
addq %rcx, %rax
leaq (%rax,%rax,2), %rax
movq 0x10(%rdx,%rax,8), %rax
leaq 0x18(%rax), %r8
cmpb $0x0, 0xb(%rax)
jns 0x160c2
movq (%r8), %r8
movq 0x38(%rbx), %rdi
movq (%rsi), %rax
leaq 0x18(%rax), %rdx
cmpb $0x0, 0xb(%rax)
jns 0x160d6
movq (%rdx), %rdx
movl 0xc(%rsi), %ecx
leaq 0x1474d(%rip), %rsi # 0x2a82d
xorl %eax, %eax
callq 0x12c36
movq %rbx, %rdi
movq %rax, %rsi
callq 0x23c54
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
forbody | static void forbody (LexState *ls, int base, int line, int nvars, int isgen) {
/* forbody -> DO block */
static const OpCode forprep[2] = {OP_FORPREP, OP_TFORPREP};
static const OpCode forloop[2] = {OP_FORLOOP, OP_TFORLOOP};
BlockCnt bl;
FuncState *fs = ls->fs;
int prep, endfor;
checknext(ls, TK_DO);
prep = luaK_codeABx(fs, forprep[isgen], base, 0);
fs->freereg--; /* both 'forprep' remove one register from the stack */
enterblock(fs, &bl, 0); /* scope for declared variables */
adjustlocalvars(ls, nvars);
luaK_reserveregs(fs, nvars);
block(ls);
leaveblock(fs); /* end of scope for declared variables */
fixforjump(fs, prep, luaK_getlabel(fs), 0);
if (isgen) { /* generic for? */
luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars);
luaK_fixline(fs, line);
}
endfor = luaK_codeABx(fs, forloop[isgen], base, 0);
fixforjump(fs, endfor, prep + 1, 1);
luaK_fixline(fs, line);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, 0x4(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %r14
movl $0x102, %esi # imm = 0x102
callq 0x14afd
movl %r15d, (%rsp)
movl %r15d, %ecx
leaq 0x1485e(%rip), %rax # 0x2a9b8
movq %rcx, 0x8(%rsp)
movl (%rax,%rcx,4), %esi
xorl %r13d, %r13d
movq %r14, %rdi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x240f3
movl %eax, %r15d
decb 0x4c(%r14)
movb %r13b, 0x22(%rsp)
movb 0x4a(%r14), %al
movb %al, 0x20(%rsp)
movq 0x10(%r14), %rax
movq 0x58(%rax), %rax
movl 0x28(%rax), %ecx
movl %ecx, 0x18(%rsp)
movl 0x18(%rax), %eax
movl %eax, 0x1c(%rsp)
movb %r13b, 0x21(%rsp)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x161b1
cmpb $0x0, 0x13(%rax)
setne %r13b
leaq 0x10(%rsp), %rcx
movb %r13b, 0x13(%rcx)
movq %rax, (%rcx)
movq %rcx, 0x18(%r14)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1562b
movq %r14, %rdi
movl %r12d, %esi
callq 0x2413b
movq %rbx, %rdi
callq 0x1495e
movq %r14, %rdi
callq 0x15c32
movq %r14, %rdi
callq 0x23eee
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
xorl %ecx, %ecx
callq 0x16272
cmpl $0x0, (%rsp)
movl 0x4(%rsp), %ebx
je 0x16229
movq %r14, %rdi
movl $0x4c, %esi
movl %ebp, %edx
xorl %ecx, %ecx
movl %r12d, %r8d
xorl %r9d, %r9d
callq 0x23de3
movq %r14, %rdi
movl %ebx, %esi
callq 0x25947
leaq 0x14790(%rip), %rax # 0x2a9c0
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %esi
movq %r14, %rdi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x240f3
incl %r15d
movq %r14, %rdi
movl %eax, %esi
movl %r15d, %edx
movl $0x1, %ecx
callq 0x16272
movq %r14, %rdi
movl %ebx, %esi
callq 0x25947
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
check_readonly | static void check_readonly (LexState *ls, expdesc *e) {
FuncState *fs = ls->fs;
TString *varname = NULL; /* to be set if variable is const */
switch (e->k) {
case VCONST: {
varname = ls->dyd->actvar.arr[e->u.info].vd.name;
break;
}
case VLOCAL: {
Vardesc *vardesc = getlocalvardesc(fs, e->u.var.vidx);
if (vardesc->vd.kind != VDKREG) /* not a regular variable? */
varname = vardesc->vd.name;
break;
}
case VUPVAL: {
Upvaldesc *up = &fs->f->upvalues[e->u.info];
if (up->kind != VDKREG)
varname = up->name;
break;
}
default:
return; /* other cases cannot be read-only */
}
if (varname) {
const char *msg = luaO_pushfstring(ls->L,
"attempt to assign to const variable '%s'", getstr(varname));
luaK_semerror(ls, msg); /* error */
}
} | pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl (%rsi), %ecx
cmpl $0x9, %ecx
je 0x1636d
cmpl $0xa, %ecx
je 0x16352
cmpl $0xb, %ecx
jne 0x163a2
movq 0x58(%rbx), %rax
movq (%rax), %rax
movslq 0x8(%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
addq $0x10, %rax
jmp 0x16396
movq (%rax), %rax
movq 0x50(%rax), %rax
movslq 0x8(%rsi), %rcx
shlq $0x4, %rcx
cmpb $0x0, 0xa(%rax,%rcx)
je 0x1639b
addq %rcx, %rax
jmp 0x16396
movzwl 0xa(%rsi), %edx
movq 0x10(%rax), %rcx
movq 0x58(%rcx), %rcx
movq (%rcx), %rcx
movslq 0x40(%rax), %rax
addq %rdx, %rax
leaq (%rax,%rax,2), %rax
cmpb $0x0, 0x9(%rcx,%rax,8)
je 0x1639b
leaq (%rcx,%rax,8), %rax
addq $0x10, %rax
movq (%rax), %rax
jmp 0x1639d
xorl %eax, %eax
testq %rax, %rax
jne 0x163a4
popq %rbx
retq
movq 0x38(%rbx), %rdi
leaq 0x18(%rax), %rdx
cmpb $0x0, 0xb(%rax)
jns 0x163b5
movq (%rdx), %rdx
leaq 0x14542(%rip), %rsi # 0x2a8fe
xorl %eax, %eax
callq 0x12c36
movq %rbx, %rdi
movq %rax, %rsi
callq 0x23c54
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
restassign | static void restassign (LexState *ls, struct LHS_assign *lh, int nvars) {
expdesc e;
check_condition(ls, vkisvar(lh->v.k), "syntax error");
check_readonly(ls, &lh->v);
if (testnext(ls, ',')) { /* restassign -> ',' suffixedexp restassign */
struct LHS_assign nv;
nv.prev = lh;
suffixedexp(ls, &nv.v);
if (!vkisindexed(nv.v.k))
check_conflict(ls, lh, &nv.v);
enterlevel(ls); /* control recursion depth */
restassign(ls, &nv, nvars+1);
leavelevel(ls);
}
else { /* restassign -> '=' explist */
int nexps;
checknext(ls, '=');
nexps = explist(ls, &e);
if (nexps != nvars)
adjust_assign(ls, nvars, nexps, &e);
else {
luaK_setoneret(ls->fs, &e); /* close last expression */
luaK_storevar(ls->fs, &lh->v, &e);
return; /* avoid default */
}
}
init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */
luaK_storevar(ls->fs, &lh->v, &e);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x8(%rsi), %eax
addl $-0x9, %eax
cmpl $0x7, %eax
jae 0x1660a
movl %edx, %ebp
movq %rsi, %r15
leaq 0x8(%rsi), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16320
cmpl $0x2c, 0x10(%rbx)
jne 0x1653b
movq %rbx, %rdi
callq 0x275c6
leaq 0x8(%rsp), %r12
movq %r15, -0x8(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x153d9
movl (%r12), %eax
andl $-0x4, %eax
cmpl $0xc, %eax
je 0x165b5
testq %r15, %r15
je 0x165b5
movq 0x30(%rbx), %r12
movb 0x4c(%r12), %al
movzbl %al, %edx
xorl %ecx, %ecx
movl 0x8(%r15), %edi
movl %edi, %esi
andl $-0x4, %esi
cmpl $0xc, %esi
jne 0x16518
movl 0x8(%rsp), %esi
cmpl $0xd, %edi
jne 0x164db
cmpl $0xa, %esi
jne 0x16518
movzbl 0x12(%r15), %esi
cmpl %esi, 0x10(%rsp)
jne 0x16518
movl $0xf, 0x8(%r15)
movb %al, 0x12(%r15)
jmp 0x16513
cmpl $0x9, %esi
jne 0x164f4
movb 0x12(%r15), %dil
cmpb 0x10(%rsp), %dil
jne 0x164f4
movb %al, 0x12(%r15)
movl $0x1, %ecx
cmpl $0x9, %esi
jne 0x16518
cmpl $0xc, 0x8(%r15)
jne 0x16518
movswl 0x10(%r15), %esi
movzbl 0x10(%rsp), %edi
cmpl %edi, %esi
jne 0x16518
movw %dx, 0x10(%r15)
movl $0x1, %ecx
movq (%r15), %r15
testq %r15, %r15
jne 0x164a6
testl %ecx, %ecx
je 0x165b5
cmpl $0x9, 0x8(%rsp)
jne 0x16591
movzbl 0x10(%rsp), %ecx
movq %r12, %rdi
xorl %esi, %esi
jmp 0x1659d
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x14afd
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x15be9
movl %eax, %r15d
cmpl %ebp, %eax
jne 0x1657a
movq 0x30(%rbx), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0x2426b
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x24691
jmp 0x1658a
movq %rsp, %rcx
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x162ae
cmpl %ebp, %r15d
jne 0x165d7
jmp 0x165fd
movl 0x10(%rsp), %ecx
movq %r12, %rdi
movl $0x9, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x23de3
movq %r12, %rdi
movl $0x1, %esi
callq 0x2413b
movq 0x38(%rbx), %rdi
callq 0x166f2
incl %ebp
movq %rsp, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x16426
movq 0x38(%rbx), %rax
decl 0xb0(%rax)
movq 0x30(%rbx), %rdi
movzbl 0x4c(%rdi), %eax
decl %eax
movq %rsp, %rdx
movq $-0x1, 0x10(%rdx)
movl $0x8, (%rdx)
movl %eax, 0x8(%rdx)
movq %r14, %rsi
callq 0x24691
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1439a(%rip), %rsi # 0x2a9ab
movq %rbx, %rdi
callq 0x27434
nopl (%rax)
| /mmanyen[P]CLua/build_O1/_deps/lua/lparser.c |
luaE_setdebt | void luaE_setdebt (global_State *g, l_mem debt) {
l_mem tb = gettotalbytes(g);
lua_assert(tb > 0);
if (debt > MAX_LMEM - tb)
debt = MAX_LMEM - tb; /* will make GCtotalbytes == MAX_LMEM */
g->GCtotalbytes = tb + debt;
g->GCdebt = debt;
} | movq 0x10(%rdi), %rax
subq 0x18(%rdi), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
xorq %rax, %rcx
cmpq %rsi, %rcx
cmovgeq %rsi, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstate.c |
luaE_extendCI | CallInfo *luaE_extendCI (lua_State *L) {
CallInfo *ci;
lua_assert(L->ci->next == NULL);
ci = luaM_new(L, CallInfo);
lua_assert(L->ci->next == NULL);
L->ci->next = ci;
ci->previous = L->ci;
ci->next = NULL;
ci->u.l.trap = 0;
L->nci++;
return ci;
} | pushq %rbx
movq %rdi, %rbx
movl $0x40, %esi
xorl %edx, %edx
callq 0x11387
movq 0x20(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movl $0x0, 0x28(%rax)
incl 0xb8(%rbx)
popq %rbx
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstate.c |
luaE_shrinkCI | void luaE_shrinkCI (lua_State *L) {
CallInfo *ci = L->ci->next; /* first free CallInfo */
CallInfo *next;
if (ci == NULL)
return; /* no extra elements */
while ((next = ci->next) != NULL) { /* two extra elements? */
CallInfo *next2 = next->next; /* next's next */
ci->next = next2; /* remove next from the list */
L->nci--;
luaM_free(L, next); /* free next */
if (next2 == NULL)
break; /* no more elements */
else {
next2->previous = ci;
ci = next2; /* continue */
}
}
} | pushq %r15
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rax
movq 0x18(%rax), %r14
testq %r14, %r14
je 0x166c1
movq %rdi, %rbx
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x166c1
movq 0x18(%rsi), %r15
movq %r15, 0x18(%r14)
decl 0xb8(%rbx)
movl $0x40, %edx
movq %rbx, %rdi
callq 0x112b5
testq %r15, %r15
je 0x166bc
movq %r14, 0x10(%r15)
movq %r15, %r14
testq %r15, %r15
jne 0x1668c
popq %rbx
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstate.c |
lua_newthread | LUA_API lua_State *lua_newthread (lua_State *L) {
global_State *g = G(L);
GCObject *o;
lua_State *L1;
lua_lock(L);
luaC_checkGC(L);
/* create new thread */
o = luaC_newobjdt(L, LUA_TTHREAD, sizeof(LX), offsetof(LX, l));
L1 = gco2th(o);
/* anchor it on L stack */
setthvalue2s(L, L->top.p, L1);
api_incr_top(L);
preinit_thread(L1, g);
L1->hookmask = L->hookmask;
L1->basehookcount = L->basehookcount;
L1->hook = L->hook;
resethookcount(L1);
/* initialize L1 extra space */
memcpy(lua_getextraspace(L1), lua_getextraspace(mainthread(g)),
LUA_EXTRASPACE);
luai_userstatethread(L, L1);
stack_init(L1, L); /* init stack */
lua_unlock(L);
return L1;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r15
cmpq $0x0, 0x18(%r15)
jg 0x16761
movq %rbx, %rdi
callq 0xdd3f
movl $0xd8, %edx
movl $0x8, %ecx
movq %rbx, %rdi
movl $0x8, %esi
callq 0xd6f0
movq %rax, %r14
movq 0x10(%rbx), %rax
movq %r14, (%rax)
movb $0x48, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %r15, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
xorl %eax, %eax
movq %rax, 0x20(%r14)
movl %eax, 0xb8(%r14)
movq %r14, 0x50(%r14)
movq %rax, 0x58(%r14)
movq %rax, 0xa0(%r14)
movl %eax, 0xc4(%r14)
movq %rax, 0xbc(%r14)
movw $0x1, 0xa(%r14)
movups %xmm0, 0xa8(%r14)
movups %xmm0, 0x70(%r14)
movl 0xc4(%rbx), %eax
movl %eax, 0xc4(%r14)
movl 0xbc(%rbx), %eax
movl %eax, 0xbc(%r14)
movq 0xa0(%rbx), %rcx
movq %rcx, 0xa0(%r14)
movl %eax, 0xc0(%r14)
movq 0x580(%r15), %rax
movq %rax, -0x8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16823
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstate.c |
stack_init | static void stack_init (lua_State *L1, lua_State *L) {
int i;
/* initialize stack array */
L1->stack.p = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, StackValue);
L1->tbclist.p = L1->stack.p;
for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++)
setnilvalue(s2v(L1->stack.p + i)); /* erase new stack */
L1->stack_last.p = L1->stack.p + BASIC_STACK_SIZE;
/* initialize first ci */
resetCI(L1);
L1->top.p = L1->stack.p + 1; /* +1 for 'function' entry */
} | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movl $0x2d0, %esi # imm = 0x2D0
movq %rax, %rdi
xorl %edx, %edx
callq 0x11387
movq %rax, 0x30(%rbx)
movq %rax, 0x40(%rbx)
movl $0x8, %eax
movq 0x30(%rbx), %rcx
movb $0x0, (%rcx,%rax)
addq $0x10, %rax
cmpq $0x2d8, %rax # imm = 0x2D8
jne 0x16846
movq 0x30(%rbx), %rax
leaq 0x280(%rax), %rcx
movq %rcx, 0x28(%rbx)
leaq 0x60(%rbx), %rcx
movq %rcx, 0x20(%rbx)
movq %rax, 0x60(%rbx)
xorl %ecx, %ecx
movb %cl, 0x8(%rax)
movl $0x150, %eax # imm = 0x150
addq 0x60(%rbx), %rax
movq %rax, 0x68(%rbx)
movq %rcx, 0x80(%rbx)
movl $0x8000, 0x9c(%rbx) # imm = 0x8000
movb %cl, 0xb(%rbx)
movq %rcx, 0xa8(%rbx)
movq 0x30(%rbx), %rax
addq $0x10, %rax
movq %rax, 0x10(%rbx)
popq %rbx
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstate.c |
luaE_freethread | void luaE_freethread (lua_State *L, lua_State *L1) {
LX *l = fromstate(L1);
luaF_closeupval(L1, L1->stack.p); /* close all upvalues */
lua_assert(L1->openupval == NULL);
luai_userstatefree(L, L1);
freestack(L1);
luaM_free(L, l);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x8(%rsi), %r15
movq 0x30(%rsi), %rsi
movq %rbx, %rdi
callq 0xd1e9
movq %rbx, %rdi
callq 0x168e8
movl $0xd8, %edx
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x112b5
| /mmanyen[P]CLua/build_O1/_deps/lua/lstate.c |
luaS_init | void luaS_init (lua_State *L) {
global_State *g = G(L);
int i, j;
stringtable *tb = &G(L)->strt;
tb->hash = luaM_newvector(L, MINSTRTABSIZE, TString*);
tablerehash(tb->hash, 0, MINSTRTABSIZE); /* clear array */
tb->size = MINSTRTABSIZE;
/* pre-create memory-error message */
g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
luaC_fix(L, obj2gco(g->memerrmsg)); /* it should never be collected */
for (i = 0; i < STRCACHE_N; i++) /* fill cache with valid strings */
for (j = 0; j < STRCACHE_M; j++)
g->strcache[i][j] = g->memerrmsg;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
xorl %r15d, %r15d
movl $0x400, %esi # imm = 0x400
xorl %edx, %edx
callq 0x11387
movq %rax, 0x30(%r14)
movl $0x400, %edx # imm = 0x400
movq %rax, %rdi
xorl %esi, %esi
callq 0x51d0
movl $0x80, 0x3c(%r14)
leaq 0x1268d(%rip), %rsi # 0x29709
movl $0x11, %edx
movq %rbx, %rdi
callq 0x171df
movq %rax, 0x108(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd6c7
movq 0x108(%r14), %rax
addq $0x220, %r14 # imm = 0x220
xorl %ecx, %ecx
movq %rax, (%r14,%rcx,8)
incq %rcx
cmpq $0x1, %rcx
je 0x170ab
incq %r15
addq $0x10, %r14
cmpq $0x35, %r15
jne 0x170a9
popq %rbx
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstring.c |
luaS_newlstr | TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
if (l <= LUAI_MAXSHORTLEN) /* short string? */
return internshrstr(L, str, l);
else {
TString *ts;
if (l_unlikely(l * sizeof(char) >= (MAX_SIZE - sizeof(TString))))
luaM_toobig(L);
ts = luaS_createlngstrobj(L, l);
memcpy(getlngstr(ts), str, l * sizeof(char));
return ts;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpq $0x28, %rdx
ja 0x170f3
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x171df
movabsq $0x7fffffffffffffcf, %rax # imm = 0x7FFFFFFFFFFFFFCF
cmpq %rax, %rbx
jae 0x17152
leaq 0x21(%rbx), %rdx
movq 0x18(%rdi), %rax
movl 0x60(%rax), %ebp
movl $0x14, %esi
callq 0xd734
movq %rax, %r15
movl %ebp, 0xc(%rax)
movw $0xff00, 0xa(%rax) # imm = 0xFF00
movq %rbx, 0x10(%rax)
addq $0x20, %rax
movq %rax, 0x18(%r15)
movb $0x0, 0x20(%r15,%rbx)
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x52a0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x112a6
| /mmanyen[P]CLua/build_O1/_deps/lua/lstring.c |
luaS_sizelngstr | size_t luaS_sizelngstr (size_t len, int kind) {
switch (kind) {
case LSTRREG: /* regular long string */
/* don't need 'falloc'/'ud', but need space for content */
return offsetof(TString, falloc) + (len + 1) * sizeof(char);
case LSTRFIX: /* fixed external long string */
/* don't need 'falloc'/'ud' */
return offsetof(TString, falloc);
default: /* external long string with deallocation */
lua_assert(kind == LSTRMEM);
return sizeof(TString);
}
} | cmpl $-0x2, %esi
je 0x17169
cmpl $-0x1, %esi
jne 0x1716f
movq %rdi, %rax
addq $0x21, %rax
retq
movl $0x20, %eax
retq
movl $0x30, %eax
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstring.c |
luaS_createlngstrobj | TString *luaS_createlngstrobj (lua_State *L, size_t l) {
size_t totalsize = luaS_sizelngstr(l, LSTRREG);
TString *ts = createstrobj(L, totalsize, LUA_VLNGSTR, G(L)->seed);
ts->u.lnglen = l;
ts->shrlen = LSTRREG; /* signals that it is a regular long string */
ts->contents = cast_charp(ts) + offsetof(TString, falloc);
ts->contents[l] = '\0'; /* ending 0 */
return ts;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x21(%rsi), %rdx
movq 0x18(%rdi), %rax
movl 0x60(%rax), %ebp
movl $0x14, %esi
callq 0xd734
movl %ebp, 0xc(%rax)
movw $0xff00, 0xa(%rax) # imm = 0xFF00
movq %rbx, 0x10(%rax)
leaq 0x20(%rax), %rcx
movq %rcx, 0x18(%rax)
movb $0x0, 0x20(%rax,%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstring.c |
luaS_remove | void luaS_remove (lua_State *L, TString *ts) {
stringtable *tb = &G(L)->strt;
TString **p = &tb->hash[lmod(ts->hash, tb->size)];
while (*p != ts) /* find previous element */
p = &(*p)->u.hnext;
*p = (*p)->u.hnext; /* remove element from its list */
tb->nuse--;
} | movq 0x18(%rdi), %rax
movl 0x3c(%rax), %ecx
decl %ecx
andl 0xc(%rsi), %ecx
shlq $0x3, %rcx
addq 0x30(%rax), %rcx
movq %rcx, %rdx
movq (%rcx), %rdi
leaq 0x10(%rdi), %rcx
cmpq %rsi, %rdi
jne 0x171c5
movq 0x10(%rdi), %rcx
movq %rcx, (%rdx)
decl 0x38(%rax)
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstring.c |
internshrstr | static TString *internshrstr (lua_State *L, const char *str, size_t l) {
TString *ts;
global_State *g = G(L);
stringtable *tb = &g->strt;
unsigned int h = luaS_hash(str, l, g->seed);
TString **list = &tb->hash[lmod(h, tb->size)];
lua_assert(str != NULL); /* otherwise 'memcmp'/'memcpy' are undefined */
for (ts = *list; ts != NULL; ts = ts->u.hnext) {
if (l == cast_uint(ts->shrlen) &&
(memcmp(str, getshrstr(ts), l * sizeof(char)) == 0)) {
/* found! */
if (isdead(g, ts)) /* dead (but not collected yet)? */
changewhite(ts); /* resurrect it */
return ts;
}
}
/* else must create a new string */
if (tb->nuse >= tb->size) { /* need to grow string table? */
growstrtab(L, tb);
list = &tb->hash[lmod(h, tb->size)]; /* rehash with new size */
}
ts = createstrobj(L, sizestrshr(l), LUA_VSHRSTR, h);
ts->shrlen = cast(ls_byte, l);
getshrstr(ts)[l] = '\0'; /* ending 0 */
memcpy(getshrstr(ts), str, l * sizeof(char));
ts->u.hnext = *list;
*list = ts;
tb->nuse++;
return ts;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x18(%rdi), %rsi
movl 0x60(%rsi), %ebp
xorl %ebx, %ebp
testq %rdx, %rdx
movq %rdi, 0x10(%rsp)
je 0x17224
movq %rbx, %rax
movl %ebp, %ecx
shll $0x5, %ecx
movl %ebp, %edx
shrl $0x2, %edx
addl %ecx, %edx
movzbl -0x1(%r14,%rax), %ecx
addl %edx, %ecx
xorl %ecx, %ebp
decq %rax
jne 0x17209
movq 0x30(%rsi), %rax
movq %rsi, (%rsp)
movl 0x3c(%rsi), %r13d
leal -0x1(%r13), %r15d
andl %ebp, %r15d
movq %rax, 0x8(%rsp)
movq (%rax,%r15,8), %r12
testq %r12, %r12
je 0x17271
movsbq 0xb(%r12), %rax
movl %eax, %eax
cmpq %rbx, %rax
jne 0x1726a
leaq 0x18(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5350
testl %eax, %eax
je 0x1731d
movq 0x10(%r12), %r12
jmp 0x17240
movq (%rsp), %rax
cmpl %r13d, 0x38(%rax)
movq %rax, %r13
movq 0x10(%rsp), %r12
jge 0x1728e
movq 0x8(%rsp), %rax
leaq (%rax,%r15,8), %r15
jmp 0x172c4
cmpl $0x7fffffff, 0x38(%r13) # imm = 0x7FFFFFFF
je 0x17339
movl 0x3c(%r13), %esi
cmpl $0x3fffffff, %esi # imm = 0x3FFFFFFF
jg 0x172b2
addl %esi, %esi
movq %r12, %rdi
callq 0x16f0c
movl 0x3c(%r13), %r15d
decl %r15d
andl %ebp, %r15d
shlq $0x3, %r15
addq 0x30(%r13), %r15
leaq 0x19(%rbx), %rdx
movq %r12, %rdi
movl $0x4, %esi
callq 0xd734
movq %rax, %r12
movl %ebp, 0xc(%rax)
xorl %eax, %eax
movb %al, 0xa(%r12)
movb %bl, 0xb(%r12)
leaq 0x18(%r12), %rdi
movb %al, 0x18(%r12,%rbx)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x52a0
movq (%r15), %rax
movq %rax, 0x10(%r12)
movq %r12, (%r15)
incl 0x38(%r13)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb 0x9(%r12), %al
movq (%rsp), %rcx
movb 0x6a(%rcx), %cl
xorb $0x18, %cl
testb %al, %cl
je 0x1730b
xorb $0x18, %al
movb %al, 0x9(%r12)
jmp 0x1730b
leaq 0x38(%r13), %rsi
movq %r12, %rdi
callq 0x5a1b
jmp 0x1729c
| /mmanyen[P]CLua/build_O1/_deps/lua/lstring.c |
luaS_new | TString *luaS_new (lua_State *L, const char *str) {
unsigned int i = point2uint(str) % STRCACHE_N; /* hash */
int j;
TString **p = G(L)->strcache[i];
for (j = 0; j < STRCACHE_M; j++) {
if (strcmp(str, getstr(p[j])) == 0) /* hit? */
return p[j]; /* that is it */
}
/* normal route */
for (j = STRCACHE_M - 1; j > 0; j--)
p[j] = p[j - 1]; /* move out last element */
/* new element is first in the list */
p[0] = luaS_newlstr(L, str, strlen(str));
return p[0];
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %ebx, %eax
imulq $0x3521cfb3, %rax, %rax # imm = 0x3521CFB3
shrq $0x20, %rax
movl %ebx, %ecx
subl %eax, %ecx
shrl %ecx
addl %eax, %ecx
shrl $0x5, %ecx
imull $0x35, %ecx, %eax
movl %ebx, %ecx
subl %eax, %ecx
movq 0x18(%rdi), %rax
shll $0x4, %ecx
leaq (%rax,%rcx), %r12
addq $0x220, %r12 # imm = 0x220
xorl %r13d, %r13d
movq (%r12,%r13,8), %r15
leaq 0x18(%r15), %rsi
cmpb $0x0, 0xb(%r15)
jns 0x1739f
movq (%rsi), %rsi
movq %rbx, %rdi
callq 0x5420
testl %eax, %eax
je 0x173da
incq %r13
cmpq $0x1, %r13
je 0x1738d
movq (%r12), %rax
movq %rax, 0x8(%r12)
movq %rbx, %rdi
callq 0x5180
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x170cb
movq %rax, %r15
movq %rax, (%r12)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstring.c |
str_byte | static int str_byte (lua_State *L) {
size_t l;
const char *s = luaL_checklstring(L, 1, &l);
lua_Integer pi = luaL_optinteger(L, 2, 1);
size_t posi = posrelatI(pi, l);
size_t pose = getendpos(L, 3, pi, l);
int n, i;
if (posi > pose) return 0; /* empty interval; return no values */
if (l_unlikely(pose - posi >= (size_t)INT_MAX)) /* arithmetic overflow? */
return luaL_error(L, "string slice too long");
n = (int)(pose - posi) + 1;
luaL_checkstack(L, n, "string slice too long");
for (i=0; i<n; i++)
lua_pushinteger(L, cast_uchar(s[posi + cast_uint(i) - 1]));
return n;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x8dfc
movq %rax, %r14
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8fb7
movq (%r15), %r13
movq %rax, %r12
testq %rax, %rax
jg 0x176ef
sete %cl
movq %r13, %rdx
negq %rdx
cmpq %rdx, %rax
setl %dl
orb %cl, %dl
movl $0x1, %r12d
jne 0x176ef
leaq (%rax,%r13), %r12
incq %r12
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x8fb7
cmpq %r13, %rax
jle 0x17709
movq %r13, %r15
jmp 0x17727
movq %rax, %r15
testq %rax, %rax
jns 0x17727
movq %r13, %rax
negq %rax
cmpq %rax, %r15
jge 0x17721
xorl %r15d, %r15d
jmp 0x17727
addq %r13, %r15
incq %r15
xorl %ebp, %ebp
movq %r15, %rax
subq %r12, %rax
jb 0x17766
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
jae 0x17777
movl %eax, %ebp
incl %ebp
leaq 0x134f4(%rip), %rdx # 0x2ac38
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8e28
decq %r12
movzbl (%r14,%r12), %esi
movq %rbx, %rdi
callq 0x6d91
incq %r12
cmpq %r12, %r15
jne 0x17751
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x134ba(%rip), %rsi # 0x2ac38
movq %rbx, %rdi
xorl %eax, %eax
callq 0x87c6
movl %eax, %ebp
jmp 0x17766
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
str_char | static int str_char (lua_State *L) {
int n = lua_gettop(L); /* number of arguments */
int i;
luaL_Buffer b;
char *p = luaL_buffinitsize(L, &b, cast_uint(n));
for (i=1; i<=n; i++) {
lua_Unsigned c = (lua_Unsigned)luaL_checkinteger(L, i);
luaL_argcheck(L, c <= (lua_Unsigned)UCHAR_MAX, i, "value out of range");
p[i - 1] = cast_char(cast_uchar(c));
}
luaL_pushresultsize(&b, cast_uint(n));
return 1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movq %rdi, %rbx
callq 0x663a
movl %eax, %ebp
movl %eax, %r14d
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x91e7
testl %ebp, %ebp
jle 0x17804
movq %rax, %r15
leal 0x1(%r14), %r13d
movl $0x1, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x8f2d
movq %rax, %rbp
cmpq $0x100, %rax # imm = 0x100
jae 0x177f0
movb %bpl, -0x1(%r15,%r12)
incq %r12
cmpq %r12, %r13
jne 0x177cb
jmp 0x17804
movq %rbx, %rdi
movl %r12d, %esi
leaq 0x13451(%rip), %rdx # 0x2ac4e
callq 0x86ba
jmp 0x177e1
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x91de
movl $0x1, %eax
addq $0x428, %rsp # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
str_dump | static int str_dump (lua_State *L) {
struct str_Writer state;
int strip = lua_toboolean(L, 2);
luaL_argcheck(L, lua_type(L, 1) == LUA_TFUNCTION && !lua_iscfunction(L, 1),
1, "Lua function expected");
/* ensure function is on the top of the stack and vacate slot 1 */
lua_pushvalue(L, 1);
state.init = 0;
lua_dump(L, writer, &state, strip);
lua_settop(L, 1); /* leave final result on top */
return 1;
} | pushq %rbp
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movq %rdi, %rbx
movl $0x2, %esi
callq 0x6b9e
movl %eax, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x68d4
cmpl $0x6, %eax
jne 0x17863
movq %rbx, %rdi
movl $0x1, %esi
callq 0x690a
testl %eax, %eax
je 0x17877
leaq 0x133f7(%rip), %rdx # 0x2ac61
movq %rbx, %rdi
movl $0x1, %esi
callq 0x86ba
movq %rbx, %rdi
movl $0x1, %esi
callq 0x68aa
movq %rsp, %rdx
movl $0x0, (%rdx)
leaq 0x1af3(%rip), %rsi # 0x19387
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x7b1b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x664e
movl $0x1, %eax
addq $0x428, %rsp # imm = 0x428
popq %rbx
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
str_format | static int str_format (lua_State *L) {
int top = lua_gettop(L);
int arg = 1;
size_t sfl;
const char *strfrmt = luaL_checklstring(L, arg, &sfl);
const char *strfrmt_end = strfrmt+sfl;
const char *flags;
luaL_Buffer b;
luaL_buffinit(L, &b);
while (strfrmt < strfrmt_end) {
if (*strfrmt != L_ESC)
luaL_addchar(&b, *strfrmt++);
else if (*++strfrmt == L_ESC)
luaL_addchar(&b, *strfrmt++); /* %% */
else { /* format item */
char form[MAX_FORMAT]; /* to store the format ('%...') */
unsigned maxitem = MAX_ITEM; /* maximum length for the result */
char *buff = luaL_prepbuffsize(&b, maxitem); /* to put result */
int nb = 0; /* number of bytes in result */
if (++arg > top)
return luaL_argerror(L, arg, "no value");
strfrmt = getformat(L, strfrmt, form);
switch (*strfrmt++) {
case 'c': {
checkformat(L, form, L_FMTFLAGSC, 0);
nb = l_sprintf(buff, maxitem, form, (int)luaL_checkinteger(L, arg));
break;
}
case 'd': case 'i':
flags = L_FMTFLAGSI;
goto intcase;
case 'u':
flags = L_FMTFLAGSU;
goto intcase;
case 'o': case 'x': case 'X':
flags = L_FMTFLAGSX;
intcase: {
lua_Integer n = luaL_checkinteger(L, arg);
checkformat(L, form, flags, 1);
addlenmod(form, LUA_INTEGER_FRMLEN);
nb = l_sprintf(buff, maxitem, form, (LUAI_UACINT)n);
break;
}
case 'a': case 'A':
checkformat(L, form, L_FMTFLAGSF, 1);
addlenmod(form, LUA_NUMBER_FRMLEN);
nb = lua_number2strx(L, buff, maxitem, form,
luaL_checknumber(L, arg));
break;
case 'f':
maxitem = MAX_ITEMF; /* extra space for '%f' */
buff = luaL_prepbuffsize(&b, maxitem);
/* FALLTHROUGH */
case 'e': case 'E': case 'g': case 'G': {
lua_Number n = luaL_checknumber(L, arg);
checkformat(L, form, L_FMTFLAGSF, 1);
addlenmod(form, LUA_NUMBER_FRMLEN);
nb = l_sprintf(buff, maxitem, form, (LUAI_UACNUMBER)n);
break;
}
case 'p': {
const void *p = lua_topointer(L, arg);
checkformat(L, form, L_FMTFLAGSC, 0);
if (p == NULL) { /* avoid calling 'printf' with argument NULL */
p = "(null)"; /* result */
form[strlen(form) - 1] = 's'; /* format it as a string */
}
nb = l_sprintf(buff, maxitem, form, p);
break;
}
case 'q': {
if (form[2] != '\0') /* modifiers? */
return luaL_error(L, "specifier '%%q' cannot have modifiers");
addliteral(L, &b, arg);
break;
}
case 's': {
size_t l;
const char *s = luaL_tolstring(L, arg, &l);
if (form[2] == '\0') /* no modifiers? */
luaL_addvalue(&b); /* keep entire string */
else {
luaL_argcheck(L, l == strlen(s), arg, "string contains zeros");
checkformat(L, form, L_FMTFLAGSC, 1);
if (strchr(form, '.') == NULL && l >= 100) {
/* no precision and string is too long to be formatted */
luaL_addvalue(&b); /* keep entire string */
}
else { /* format the string into 'buff' */
nb = l_sprintf(buff, maxitem, form, s);
lua_pop(L, 1); /* remove result from 'luaL_tolstring' */
}
}
break;
}
default: { /* also treat cases 'pnLlh' */
return luaL_error(L, "invalid conversion '%s' to 'format'", form);
}
}
lua_assert(cast_uint(nb) < maxitem);
luaL_addsize(&b, cast_uint(nb));
}
}
luaL_pushresult(&b);
return 1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp # imm = 0x498
movq %rdi, %r15
callq 0x663a
movl %eax, 0x2c(%rsp)
leaq 0x70(%rsp), %r14
movq %r15, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x8dfc
movq %rax, %rbp
movq (%r14), %r12
leaq 0x78(%rsp), %rsi
movq %r15, 0x10(%rsp)
movq %r15, %rdi
callq 0x8517
testq %r12, %r12
jle 0x180f7
addq %rbp, %r12
movl $0x1, %r15d
movq %r12, 0x8(%rsp)
cmpb $0x25, (%rbp)
jne 0x17962
leaq 0x1(%rbp), %r14
cmpb $0x25, 0x1(%rbp)
jne 0x179b1
movq 0x88(%rsp), %rax
cmpq 0x80(%rsp), %rax
jb 0x17956
movl $0x1, %esi
leaq 0x78(%rsp), %rdi
callq 0x857a
movq %rbp, %rax
addq $0x2, %rax
movq %r14, %rbp
jmp 0x17987
movq 0x88(%rsp), %rax
cmpq 0x80(%rsp), %rax
jb 0x17983
movl $0x1, %esi
leaq 0x78(%rsp), %rdi
callq 0x857a
leaq 0x1(%rbp), %rax
movb (%rbp), %cl
movq 0x78(%rsp), %rdx
movq 0x88(%rsp), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, 0x88(%rsp)
movb %cl, (%rdx,%rsi)
movq %rax, %rbp
movl %r15d, %r13d
jmp 0x17d5f
movl $0x78, %esi
leaq 0x78(%rsp), %rdi
callq 0x857a
leal 0x1(%r15), %r13d
cmpl 0x2c(%rsp), %r15d
jge 0x17a5a
movq %rax, %r12
movq %r14, %rdi
leaq 0x13422(%rip), %rsi # 0x2adfe
callq 0x5170
movq %rax, %r15
leaq 0x1(%rax), %rbp
cmpq $0x16, %rbp
jb 0x17a01
movq 0x10(%rsp), %rdi
leaq 0x13414(%rip), %rsi # 0x2ae0e
xorl %eax, %eax
callq 0x87c6
movb $0x25, 0x30(%rsp)
leaq 0x31(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x52a0
movb $0x0, 0x32(%rsp,%r15)
addq %r14, %rbp
movzbl (%r14,%r15), %eax
movl $0x78, %r14d
cmpl $0x57, %eax
jle 0x17a80
addl $-0x58, %eax
cmpl $0x20, %eax
ja 0x17a97
leaq 0x12fba(%rip), %rcx # 0x2a9f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
leaq 0x13340(%rip), %r15 # 0x2ad8c
jmpq *%rax
leaq 0x1333f(%rip), %r15 # 0x2ad94
jmp 0x17ce9
movq 0x10(%rsp), %rdi
movl %r13d, %esi
leaq 0x1331a(%rip), %rdx # 0x2ad83
callq 0x86ba
movl %eax, %ebx
xorl %r15d, %r15d
movq %r14, %rbp
movq 0x8(%rsp), %r12
jmp 0x17d56
cmpl $0x41, %eax
je 0x17ab4
cmpl $0x45, %eax
je 0x17c16
cmpl $0x47, %eax
je 0x17c16
xorl %r15d, %r15d
movq 0x10(%rsp), %rdi
leaq 0x13334(%rip), %rsi # 0x2adda
leaq 0x30(%rsp), %rdx
xorl %eax, %eax
callq 0x87c6
jmp 0x17b26
movl %ebx, %r15d
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
leaq 0x30(%rsp), %r14
movq %r14, %rsi
leaq 0x132ca(%rip), %rdx # 0x2ad98
movl $0x1, %ecx
callq 0x19f6e
movq %r14, %rdi
leaq 0x12715(%rip), %rsi # 0x2a1f7
callq 0x19ff5
movq %rbx, %rdi
movl %r15d, %ebx
movl %r13d, %esi
callq 0x8eb7
movl $0x78, %esi
movq %r12, %rdi
movq %r14, %rdx
jmp 0x17c6c
cmpb $0x0, 0x32(%rsp)
je 0x17d70
xorl %r15d, %r15d
movq 0x10(%rsp), %rdi
leaq 0x1327f(%rip), %rsi # 0x2ad9e
xorl %eax, %eax
callq 0x87c6
movl %eax, %ebx
jmp 0x17a76
movq 0x10(%rsp), %rdi
movl %r13d, %esi
leaq 0x58(%rsp), %rdx
callq 0x97a7
cmpb $0x0, 0x32(%rsp)
je 0x17f17
movq %rax, %r14
movl %ebx, 0x1c(%rsp)
movq 0x58(%rsp), %r15
movq %rax, %rdi
callq 0x5180
cmpq %rax, %r15
jne 0x180de
movq 0x10(%rsp), %r15
movq %r15, %rdi
leaq 0x30(%rsp), %rbx
movq %rbx, %rsi
leaq 0x13102(%rip), %rdx # 0x2ac80
movl $0x1, %ecx
callq 0x19f6e
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x5140
testq %rax, %rax
jne 0x17f29
cmpq $0x64, 0x58(%rsp)
jb 0x17f29
leaq 0x78(%rsp), %rdi
callq 0x8584
xorl %r14d, %r14d
jmp 0x17f50
movq 0x10(%rsp), %r14
movq %r14, %rdi
leaq 0x30(%rsp), %r15
movq %r15, %rsi
leaq 0x130ad(%rip), %rdx # 0x2ac80
xorl %ecx, %ecx
callq 0x19f6e
movq %r14, %rdi
movl %r13d, %esi
callq 0x8f2d
movl $0x78, %esi
movq %r12, %rdi
movq %r15, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0x54b0
jmp 0x17d40
movl $0x1a2, %r14d # imm = 0x1A2
movl $0x1a2, %esi # imm = 0x1A2
leaq 0x78(%rsp), %rdi
callq 0x857a
movq %rax, %r12
movl %ebx, %r15d
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x8eb7
movsd %xmm0, 0x20(%rsp)
movq %rbx, %rdi
leaq 0x30(%rsp), %rbx
movq %rbx, %rsi
leaq 0x13157(%rip), %rdx # 0x2ad98
movl $0x1, %ecx
callq 0x19f6e
movq %rbx, %rdi
leaq 0x125a2(%rip), %rsi # 0x2a1f7
callq 0x19ff5
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r15d, %ebx
movsd 0x20(%rsp), %xmm0
movb $0x1, %al
callq 0x54b0
jmp 0x17d40
movl %ebx, %r15d
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x6d11
movq %rax, %r14
movq %rbx, %rdi
leaq 0x30(%rsp), %rbx
movq %rbx, %rsi
leaq 0x12fe0(%rip), %rdx # 0x2ac80
xorl %ecx, %ecx
callq 0x19f6e
testq %r14, %r14
jne 0x17cc0
movq %rbx, %rdi
callq 0x5180
movb $0x73, -0x1(%rax,%rbx)
leaq 0x126e5(%rip), %r14 # 0x2a3a5
movl $0x78, %esi
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x54b0
movl %eax, %r14d
movq 0x8(%rsp), %r12
movl %r15d, %ebx
jmp 0x17d48
leaq 0x130a8(%rip), %r15 # 0x2ad91
movl %ebx, 0x1c(%rsp)
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x8f2d
movq %rax, %r14
movq %rbx, %rdi
leaq 0x30(%rsp), %rbx
movq %rbx, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x19f6e
movq %rbx, %rdi
leaq 0x140cd(%rip), %rsi # 0x2bdef
callq 0x19ff5
movl $0x78, %esi
movq %r12, %rdi
movq %rbx, %rdx
movl 0x1c(%rsp), %ebx
movq %r14, %rcx
xorl %eax, %eax
callq 0x54b0
movl %eax, %r14d
movq 0x8(%rsp), %r12
movl %r14d, %eax
addq %rax, 0x88(%rsp)
movb $0x1, %r15b
testb %r15b, %r15b
je 0x18106
movl %r13d, %r15d
cmpq %r12, %rbp
jb 0x17925
jmp 0x180f7
movq 0x10(%rsp), %r15
movq %r15, %rdi
movl %r13d, %esi
callq 0x68d4
cmpl $0x2, %eax
movq 0x8(%rsp), %r12
jb 0x17f5e
cmpl $0x3, %eax
je 0x17f7d
movq %r15, %rdi
movl %r13d, %esi
cmpl $0x4, %eax
jne 0x18016
leaq 0x68(%rsp), %rdx
callq 0x6bb8
movq %rax, %r12
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x88(%rsp), %rax
cmpq 0x80(%rsp), %rax
jb 0x17dde
movl $0x1, %esi
leaq 0x78(%rsp), %rdi
callq 0x857a
movq 0x78(%rsp), %rax
movq 0x88(%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x88(%rsp)
movb $0x22, (%rax,%rcx)
cmpq $0x0, 0x20(%rsp)
je 0x17fd3
xorl %r15d, %r15d
movl %ebx, 0x1c(%rsp)
movzbl (%r12,%r15), %r14d
cmpl $0xa, %r14d
je 0x17e29
cmpl $0x5c, %r14d
je 0x17e29
cmpl $0x22, %r14d
jne 0x17ebb
movq 0x88(%rsp), %rax
cmpq 0x80(%rsp), %rax
jb 0x17e4a
movl $0x1, %esi
leaq 0x78(%rsp), %rdi
callq 0x857a
movq 0x78(%rsp), %rax
movq 0x88(%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x88(%rsp)
movb $0x5c, (%rax,%rcx)
movq 0x88(%rsp), %rax
cmpq 0x80(%rsp), %rax
jb 0x17e88
movl $0x1, %esi
leaq 0x78(%rsp), %rdi
callq 0x857a
movb (%r12,%r15), %al
movq 0x78(%rsp), %rcx
movq 0x88(%rsp), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x88(%rsp)
movb %al, (%rcx,%rdx)
incq %r15
cmpq %r15, 0x20(%rsp)
jne 0x17e0e
jmp 0x17fd3
callq 0x5360
movq (%rax), %rcx
testb $0x2, (%rcx,%r14,2)
je 0x17e67
movq (%rax), %rax
movzbl 0x1(%r12,%r15), %ecx
movzwl (%rax,%rcx,2), %eax
btl $0xb, %eax
leaq 0x12f92(%rip), %rdx # 0x2ae74
leaq 0x12f87(%rip), %rax # 0x2ae70
cmovaeq %rax, %rdx
movl $0xa, %esi
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x54b0
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
movl 0x1c(%rsp), %ebx
callq 0x8537
jmp 0x17ea8
leaq 0x78(%rsp), %rdi
callq 0x8584
xorl %r14d, %r14d
jmp 0x17d43
movl $0x78, %esi
movq %r12, %rdi
leaq 0x30(%rsp), %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x54b0
movl %eax, %r14d
movq %r15, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
movq 0x8(%rsp), %r12
movl 0x1c(%rsp), %ebx
jmp 0x17d48
xorl %r14d, %r14d
movq %r15, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x97a7
leaq 0x78(%rsp), %rdi
callq 0x8584
jmp 0x17d48
movl $0x78, %esi
leaq 0x78(%rsp), %rdi
callq 0x857a
movq %rax, %r12
movq %r15, %rdi
movl %r13d, %esi
callq 0x6924
movq %r15, %rdi
movl %r13d, %esi
xorl %edx, %edx
testl %eax, %eax
je 0x18024
callq 0x6b52
movq %rax, %rcx
negq %rcx
leaq 0x123e8(%rip), %rdx # 0x2a3a0
leaq 0x12e90(%rip), %rcx # 0x2ae4f
cmovoq %rcx, %rdx
movl $0x78, %esi
movq %r12, %rdi
movq %rax, %rcx
jmp 0x1805e
movq 0x88(%rsp), %rax
cmpq 0x80(%rsp), %rax
jb 0x17ff4
movl $0x1, %esi
leaq 0x78(%rsp), %rdi
callq 0x857a
movq 0x78(%rsp), %rax
movq 0x88(%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x88(%rsp)
movb $0x22, (%rax,%rcx)
jmp 0x17f21
leaq 0x12e39(%rip), %rdx # 0x2ae56
callq 0x86ba
jmp 0x18078
callq 0x6b05
ucomisd 0x10fd7(%rip), %xmm0 # 0x29008
leaq 0x12e43(%rip), %rcx # 0x2ae7b
jae 0x1804f
movsd 0x129ae(%rip), %xmm1 # 0x2a9f0
ucomisd %xmm0, %xmm1
leaq 0x12e2d(%rip), %rcx # 0x2ae7a
jb 0x18080
movl $0x78, %esi
movq %r12, %rdi
leaq 0x12128(%rip), %rdx # 0x2a186
xorl %eax, %eax
callq 0x54b0
movl %eax, %r14d
movq 0x8(%rsp), %r12
movl %r14d, %eax
addq %rax, 0x88(%rsp)
xorl %r14d, %r14d
jmp 0x17d48
ucomisd %xmm0, %xmm0
leaq 0x12df7(%rip), %rcx # 0x2ae82
jp 0x1804f
movl $0x78, %esi
movq %r12, %rdi
leaq 0x12dec(%rip), %rdx # 0x2ae88
movb $0x1, %al
callq 0x54b0
movl %eax, %r14d
movl %eax, %r15d
movq %r12, %rdi
movl $0x2e, %esi
movq %r15, %rdx
callq 0x5380
testq %rax, %rax
jne 0x18068
callq 0x5590
movq (%rax), %rax
movsbl (%rax), %esi
movq %r12, %rdi
movq %r15, %rdx
callq 0x5380
testq %rax, %rax
je 0x18068
movb $0x2e, (%rax)
jmp 0x18068
movq 0x10(%rsp), %rdi
movl %r13d, %esi
leaq 0x12cd7(%rip), %rdx # 0x2adc4
callq 0x86ba
jmp 0x17b67
leaq 0x78(%rsp), %rdi
callq 0x85e7
movl $0x1, %ebx
movl %ebx, %eax
addq $0x498, %rsp # imm = 0x498
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
gmatch | static int gmatch (lua_State *L) {
size_t ls, lp;
const char *s = luaL_checklstring(L, 1, &ls);
const char *p = luaL_checklstring(L, 2, &lp);
size_t init = posrelatI(luaL_optinteger(L, 3, 1), ls) - 1;
GMatchState *gm;
lua_settop(L, 2); /* keep strings on closure to avoid being collected */
gm = (GMatchState *)lua_newuserdatauv(L, sizeof(GMatchState), 0);
if (init > ls) /* start after string's end? */
init = ls + 1; /* avoid overflows in 's + init' */
prepstate(&gm->ms, L, s, ls, p, lp);
gm->src = s + init; gm->p = p; gm->lastmatch = NULL;
lua_pushcclosure(L, gmatch_aux, 3);
return 1;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x8dfc
movq %rax, %r14
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8dfc
movq %rax, %r15
movl $0x1, %edx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8fb7
movq %rax, %r12
testq %rax, %rax
jg 0x18190
movq 0x8(%rsp), %rcx
sete %dl
movq %rcx, %rsi
negq %rsi
cmpq %rsi, %rax
setl %sil
orb %dl, %sil
movl $0x1, %r12d
jne 0x18190
leaq (%rax,%rcx), %r12
incq %r12
decq %r12
movq %rbx, %rdi
movl $0x2, %esi
callq 0x664e
movl $0x240, %esi # imm = 0x240
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7f05
movq 0x8(%rsp), %rcx
leaq 0x1(%rcx), %rdx
cmpq %rcx, %r12
cmovbeq %r12, %rdx
movq 0x10(%rsp), %rsi
addq %r15, %rsi
movq %rbx, 0x30(%rax)
movl $0xc8, 0x38(%rax)
movq %r14, 0x18(%rax)
addq %r14, %rcx
movq %rcx, 0x20(%rax)
movq %rsi, 0x28(%rax)
addq %r14, %rdx
movq %rdx, (%rax)
movq %r15, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq 0x1e7e(%rip), %rsi # 0x1a078
movq %rbx, %rdi
movl $0x3, %edx
callq 0x6fa4
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
str_gsub | static int str_gsub (lua_State *L) {
size_t srcl, lp;
const char *src = luaL_checklstring(L, 1, &srcl); /* subject */
const char *p = luaL_checklstring(L, 2, &lp); /* pattern */
const char *lastmatch = NULL; /* end of last match */
int tr = lua_type(L, 3); /* replacement type */
/* max replacements */
lua_Integer max_s = luaL_optinteger(L, 4, cast_st2S(srcl) + 1);
int anchor = (*p == '^');
lua_Integer n = 0; /* replacement count */
int changed = 0; /* change flag */
MatchState ms;
luaL_Buffer b;
luaL_argexpected(L, tr == LUA_TNUMBER || tr == LUA_TSTRING ||
tr == LUA_TFUNCTION || tr == LUA_TTABLE, 3,
"string/function/table");
luaL_buffinit(L, &b);
if (anchor) {
p++; lp--; /* skip anchor character */
}
prepstate(&ms, L, src, srcl, p, lp);
while (n < max_s) {
const char *e;
reprepstate(&ms); /* (re)prepare state for new match */
if ((e = match(&ms, src, p)) != NULL && e != lastmatch) { /* match? */
n++;
changed = add_value(&ms, &b, src, e, tr) | changed;
src = lastmatch = e;
}
else if (src < ms.src_end) /* otherwise, skip one character */
luaL_addchar(&b, *src++);
else break; /* end of subject */
if (anchor) break;
}
if (!changed) /* no changes? */
lua_pushvalue(L, 1); /* return original string */
else { /* something changed */
luaL_addlstring(&b, src, ct_diff2sz(ms.src_end - src));
luaL_pushresult(&b); /* create and return new string */
}
lua_pushinteger(L, n); /* number of substitutions */
return 2;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6a8, %rsp # imm = 0x6A8
movq %rdi, %r14
leaq 0x50(%rsp), %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x8dfc
movq %rax, %r12
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movl $0x2, %esi
callq 0x8dfc
movq %rax, %r15
movq %r14, %rdi
movl $0x3, %esi
callq 0x68d4
movl %eax, %r13d
movq (%rbx), %rdx
incq %rdx
movq %r14, %rdi
movl $0x4, %esi
callq 0x8fb7
movq %rax, 0x40(%rsp)
movb (%r15), %bl
cmpb $0x5e, %bl
setne 0x3(%rsp)
leal -0x3(%r13), %eax
cmpl $0x4, %eax
jb 0x182a6
leaq 0x12bf2(%rip), %rdx # 0x2ae8b
movq %r14, %rdi
movl $0x3, %esi
callq 0x8975
leaq 0x60(%rsp), %rsi
movq %r14, %rdi
callq 0x8517
cmpb $0x5e, %bl
jne 0x182c0
incq %r15
decq 0x20(%rsp)
leaq 0x480(%rsp), %rcx
movq %r14, 0x18(%rcx)
movl $0xc8, 0x20(%rcx)
movq %r12, (%rcx)
movq 0x50(%rsp), %rax
addq %r12, %rax
movq %rax, 0x8(%rcx)
movq 0x20(%rsp), %rax
addq %r15, %rax
movq %rax, 0x10(%rcx)
xorl %ebx, %ebx
xorl %ecx, %ecx
movl $0x0, 0x4(%rsp)
movq %r14, 0x30(%rsp)
movq %r15, 0x8(%rsp)
movq %r13, 0x28(%rsp)
cmpq 0x40(%rsp), %rcx
jge 0x18669
movq %rcx, 0x10(%rsp)
movl $0x0, 0x4a4(%rsp)
leaq 0x480(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x196bd
movq %rax, %rbp
testq %rax, %rax
sete %al
cmpq %rbx, %rbp
sete %cl
orb %al, %cl
je 0x18399
cmpq 0x488(%rsp), %r12
jae 0x183ed
movq 0x70(%rsp), %rax
cmpq 0x68(%rsp), %rax
jb 0x18373
movl $0x1, %esi
leaq 0x60(%rsp), %rdi
callq 0x857a
movb (%r12), %al
incq %r12
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x70(%rsp)
movb %al, (%rcx,%rdx)
movq %rbx, %rbp
movb 0x3(%rsp), %al
jmp 0x183f2
movq 0x498(%rsp), %rbx
cmpl $0x5, %r13d
je 0x183fc
cmpl $0x6, %r13d
jne 0x18469
movq %r13, %r15
movq %r14, %r13
movq %rbx, %rdi
movl $0x3, %esi
callq 0x68aa
leaq 0x480(%rsp), %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x19b26
movq %rbx, %rdi
movl %eax, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x78e1
jmp 0x18424
xorl %eax, %eax
movq %rbx, %rbp
movq 0x10(%rsp), %rcx
jmp 0x1862c
movq %r13, %r15
movq %r14, %r13
leaq 0x480(%rsp), %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x19ea9
movq %rbx, %rdi
movl $0x3, %esi
callq 0x714b
movq %rbx, %r14
movl 0x4(%rsp), %ebx
movq %r14, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x6b9e
testl %eax, %eax
je 0x185bd
movq %r14, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x6960
testl %eax, %eax
je 0x18639
leaq 0x60(%rsp), %rdi
callq 0x8584
movl $0x1, %eax
jmp 0x185df
movq %rbx, 0x38(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
leaq 0x18(%rsp), %rdx
callq 0x6bb8
movq %rax, %r13
movq 0x18(%rsp), %rbx
movq %rax, %rdi
movl $0x25, %esi
movq %rbx, %rdx
callq 0x5380
testq %rax, %rax
je 0x185ec
movq %rax, %r14
movq %rbp, %rax
subq %r12, %rax
movq %rax, 0x48(%rsp)
movq %r14, %rdx
subq %r13, %rdx
leaq 0x60(%rsp), %rdi
movq %r13, %rsi
callq 0x913a
movzbl 0x1(%r14), %ebx
cmpl $0x30, %ebx
je 0x18508
cmpl $0x25, %ebx
jne 0x1851c
movq 0x70(%rsp), %rax
cmpq 0x68(%rsp), %rax
jb 0x184ec
movl $0x1, %esi
leaq 0x60(%rsp), %rdi
callq 0x857a
movb 0x1(%r14), %al
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x70(%rsp)
movb %al, (%rcx,%rdx)
jmp 0x18573
leaq 0x60(%rsp), %rdi
movq %r12, %rsi
movq 0x48(%rsp), %rdx
callq 0x913a
jmp 0x18573
callq 0x5360
movq (%rax), %rax
testb $0x8, 0x1(%rax,%rbx,2)
jne 0x18545
movq 0x38(%rsp), %rdi
leaq 0x1298b(%rip), %rsi # 0x2aec2
movl $0x25, %edx
xorl %eax, %eax
callq 0x87c6
jmp 0x18573
movsbl %bl, %esi
addl $-0x31, %esi
leaq 0x480(%rsp), %rdi
movq %r12, %rdx
movq %rbp, %rcx
leaq 0x58(%rsp), %r8
callq 0x19edd
cmpq $-0x2, %rax
jne 0x185ab
leaq 0x60(%rsp), %rdi
callq 0x8584
movq %r14, %r15
addq $0x2, %r15
subq %r15, %r13
movq %r13, %rbx
addq 0x18(%rsp), %rbx
movq %rbx, 0x18(%rsp)
movq %r15, %rdi
movl $0x25, %esi
movq %rbx, %rdx
callq 0x5380
movq %rax, %r14
movq %r15, %r13
testq %rax, %rax
jne 0x184af
jmp 0x185ef
movq 0x58(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movq %rax, %rdx
jmp 0x18515
movq %r14, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
movq %rbp, %rdx
subq %r12, %rdx
leaq 0x60(%rsp), %rdi
movq %r12, %rsi
callq 0x913a
xorl %eax, %eax
movq %r13, %r14
movq %r15, %r13
movq 0x8(%rsp), %r15
jmp 0x18617
movq %r13, %r15
leaq 0x60(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x913a
movl $0x1, %eax
movq 0x30(%rsp), %r14
movq 0x8(%rsp), %r15
movq 0x28(%rsp), %r13
movl 0x4(%rsp), %ebx
movq 0x10(%rsp), %rcx
incq %rcx
orl %eax, %ebx
movl %ebx, 0x4(%rsp)
movq %rbp, %r12
movb 0x3(%rsp), %al
movq %rbp, %rbx
testb %al, %al
jne 0x18309
jmp 0x18669
movq %r14, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x68d4
movq %r14, %rdi
movl %eax, %esi
callq 0x68fa
movq %r14, %rdi
leaq 0x12847(%rip), %rsi # 0x2aea1
movq %rax, %rdx
xorl %eax, %eax
callq 0x87c6
jmp 0x185df
movq %rcx, %r15
cmpl $0x0, 0x4(%rsp)
je 0x18698
movq 0x488(%rsp), %rdx
subq %r12, %rdx
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x913a
movq %rbx, %rdi
callq 0x85e7
jmp 0x186a5
movq %r14, %rdi
movl $0x1, %esi
callq 0x68aa
movq %r14, %rdi
movq %r15, %rsi
callq 0x6d91
movl $0x2, %eax
addq $0x6a8, %rsp # imm = 0x6A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
str_rep | static int str_rep (lua_State *L) {
size_t l, lsep;
const char *s = luaL_checklstring(L, 1, &l);
lua_Integer n = luaL_checkinteger(L, 2);
const char *sep = luaL_optlstring(L, 3, "", &lsep);
if (n <= 0)
lua_pushliteral(L, "");
else if (l_unlikely(l + lsep < l || l + lsep > MAX_SIZE / cast_sizet(n)))
return luaL_error(L, "resulting string too large");
else {
size_t totallen = ((size_t)n * (l + lsep)) - lsep;
luaL_Buffer b;
char *p = luaL_buffinitsize(L, &b, totallen);
while (n-- > 1) { /* first n-1 copies (followed by separator) */
memcpy(p, s, l * sizeof(char)); p += l;
if (lsep > 0) { /* empty 'memcpy' is not that cheap */
memcpy(p, sep, lsep * sizeof(char));
p += lsep;
}
}
memcpy(p, s, l * sizeof(char)); /* last copy (not followed by separator) */
luaL_pushresultsize(&b, totallen);
}
return 1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movq %rdi, %r13
movl $0x1, %ebp
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x8dfc
movq %rax, %rbx
movq %r13, %rdi
movl $0x2, %esi
callq 0x8f2d
movq %rax, %r14
leaq 0x11a39(%rip), %rdx # 0x2a1f7
leaq 0x10(%rsp), %rcx
movq %r13, %rdi
movl $0x3, %esi
callq 0x8da3
testq %r14, %r14
jle 0x187fc
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r15
addq %rcx, %r15
jae 0x18810
leaq 0x10eef(%rip), %rsi # 0x296da
movq %r13, %rdi
xorl %eax, %eax
callq 0x87c6
movl %eax, %ebp
jmp 0x188a4
leaq 0x119f4(%rip), %rsi # 0x2a1f7
movq %r13, %rdi
callq 0x6e5b
jmp 0x188a4
movq %rax, %r12
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
divq %r14
cmpq %rax, %r15
ja 0x187e4
imulq %r14, %r15
subq %rcx, %r15
leaq 0x18(%rsp), %rsi
movq %r13, %rdi
movq %r15, %rdx
callq 0x91e7
movq %rax, %r13
cmpq $0x1, %r14
je 0x18882
incq %r14
movq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x52a0
addq 0x8(%rsp), %r13
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x18879
movq %r13, %rdi
movq %r12, %rsi
callq 0x52a0
addq 0x10(%rsp), %r13
decq %r14
cmpq $0x2, %r14
jg 0x1884a
movq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x52a0
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x91de
movl $0x1, %ebp
movl %ebp, %eax
addq $0x438, %rsp # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
str_reverse | static int str_reverse (lua_State *L) {
size_t l, i;
luaL_Buffer b;
const char *s = luaL_checklstring(L, 1, &l);
char *p = luaL_buffinitsize(L, &b, l);
for (i = 0; i < l; i++)
p[i] = s[l - i - 1];
luaL_pushresultsize(&b, l);
return 1;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x430, %rsp # imm = 0x430
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x8dfc
movq %rax, %rbx
movq (%r15), %rdx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x91e7
movq (%r15), %rsi
testq %rsi, %rsi
je 0x1890f
decq %rbx
xorl %ecx, %ecx
movb (%rbx,%rsi), %dl
movb %dl, (%rax,%rcx)
incq %rcx
movq 0x8(%rsp), %rsi
decq %rbx
cmpq %rsi, %rcx
jb 0x188f9
leaq 0x10(%rsp), %rdi
callq 0x91de
movl $0x1, %eax
addq $0x430, %rsp # imm = 0x430
popq %rbx
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
str_upper | static int str_upper (lua_State *L) {
size_t l;
size_t i;
luaL_Buffer b;
const char *s = luaL_checklstring(L, 1, &l);
char *p = luaL_buffinitsize(L, &b, l);
for (i=0; i<l; i++)
p[i] = cast_char(toupper(cast_uchar(s[i])));
luaL_pushresultsize(&b, l);
return 1;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x430, %rsp # imm = 0x430
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x8dfc
movq %rax, %rbx
movq (%r15), %rdx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x91e7
movq (%r15), %rsi
testq %rsi, %rsi
je 0x18a58
movq %rax, %r14
xorl %r15d, %r15d
callq 0x5090
movq (%rax), %rcx
movzbl (%rbx,%r15), %edx
movb (%rcx,%rdx,4), %cl
movb %cl, (%r14,%r15)
incq %r15
movq 0x8(%rsp), %rsi
cmpq %rsi, %r15
jb 0x18a3c
leaq 0x10(%rsp), %rdi
callq 0x91de
movl $0x1, %eax
addq $0x430, %rsp # imm = 0x430
popq %rbx
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
str_packsize | static int str_packsize (lua_State *L) {
Header h;
const char *fmt = luaL_checkstring(L, 1); /* format string */
size_t totalsize = 0; /* accumulate total size of result */
initheader(L, &h);
while (*fmt != '\0') {
unsigned ntoalign;
size_t size;
KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
luaL_argcheck(L, opt != Kstring && opt != Kzstr, 1,
"variable-length format");
size += ntoalign; /* total space used by option */
luaL_argcheck(L, totalsize <= LUA_MAXINTEGER - size,
1, "format result too large");
totalsize += size;
}
lua_pushinteger(L, cast_st2S(totalsize));
return 1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x1, %esi
xorl %edx, %edx
callq 0x8dfc
movq %rax, 0x20(%rsp)
movq %rbx, 0x8(%rsp)
movq %rbx, 0x28(%rsp)
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x30(%rsp)
cmpb $0x0, (%rax)
je 0x1902a
xorl %r14d, %r14d
leaq 0x20(%rsp), %r12
leaq 0x18(%rsp), %r13
leaq 0x14(%rsp), %rbp
movabsq $0x7fffffffffffffff, %rbx # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
callq 0x1a0ff
addl $-0x8, %eax
cmpl $-0x2, %eax
jae 0x18ffa
movl 0x14(%rsp), %r15d
addq 0x18(%rsp), %r15
movq %r15, 0x18(%rsp)
movq %r15, %rax
xorq %rbx, %rax
cmpq %rax, %r14
ja 0x19012
addq %r15, %r14
movq 0x20(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x18fb3
jmp 0x1902a
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x1200d(%rip), %rdx # 0x2b018
callq 0x86ba
jmp 0x18fd1
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x1200c(%rip), %rdx # 0x2b02f
callq 0x86ba
jmp 0x18feb
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6d91
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
writer | static int writer (lua_State *L, const void *b, size_t size, void *ud) {
struct str_Writer *state = (struct str_Writer *)ud;
if (!state->init) {
state->init = 1;
luaL_buffinit(L, &state->B);
}
if (b == NULL) { /* finishing dump? */
luaL_pushresult(&state->B); /* push result */
lua_replace(L, 1); /* move it to reserved slot */
}
else
luaL_addlstring(&state->B, (const char *)b, size);
return 0;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
cmpl $0x0, (%rcx)
jne 0x193b3
movl $0x1, (%r14)
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x8517
addq $0x8, %r14
movq %r14, %rdi
testq %r12, %r12
je 0x193cc
movq %r12, %rsi
movq %r15, %rdx
callq 0x913a
jmp 0x193f0
callq 0x85e7
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x67d5
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
str_find_aux | static int str_find_aux (lua_State *L, int find) {
size_t ls, lp;
const char *s = luaL_checklstring(L, 1, &ls);
const char *p = luaL_checklstring(L, 2, &lp);
size_t init = posrelatI(luaL_optinteger(L, 3, 1), ls) - 1;
if (init > ls) { /* start after string's end? */
luaL_pushfail(L); /* cannot find anything */
return 1;
}
/* explicit request or no special characters? */
if (find && (lua_toboolean(L, 4) || nospecials(p, lp))) {
/* do a plain search */
const char *s2 = lmemfind(s + init, ls - init, p, lp);
if (s2) {
lua_pushinteger(L, ct_diff2S(s2 - s) + 1);
lua_pushinteger(L, cast_st2S(ct_diff2sz(s2 - s) + lp));
return 2;
}
}
else {
MatchState ms;
const char *s1 = s + init;
int anchor = (*p == '^');
if (anchor) {
p++; lp--; /* skip anchor character */
}
prepstate(&ms, L, s, ls, p, lp);
do {
const char *res;
reprepstate(&ms);
if ((res=match(&ms, s1, p)) != NULL) {
if (find) {
lua_pushinteger(L, ct_diff2S(s1 - s) + 1); /* start */
lua_pushinteger(L, ct_diff2S(res - s)); /* end */
return push_captures(&ms, NULL, 0) + 2;
}
else
return push_captures(&ms, s1, res);
}
} while (s1++ < ms.src_end && !anchor);
}
luaL_pushfail(L); /* not found */
return 1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movl %esi, 0x24(%rsp)
movq %rdi, %r14
leaq 0x38(%rsp), %rbx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x8dfc
movq %rax, 0x28(%rsp)
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
movl $0x2, %esi
callq 0x8dfc
movq %rax, 0x30(%rsp)
movl $0x1, %edx
movq %r14, 0x10(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x8fb7
movq (%rbx), %rcx
movq %rax, %r12
testq %rax, %rax
jg 0x19488
sete %dl
movq %rcx, %rsi
negq %rsi
cmpq %rsi, %rax
setl %sil
orb %dl, %sil
movl $0x1, %r12d
jne 0x19488
leaq (%rax,%rcx), %r12
incq %r12
leaq -0x1(%r12), %r15
cmpq %rcx, %r15
jbe 0x194b5
movq 0x10(%rsp), %rdi
callq 0x6d71
movl $0x1, %ebp
movl %ebp, %eax
addq $0x268, %rsp # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0x24(%rsp)
je 0x195c9
movq 0x10(%rsp), %rdi
movl $0x4, %esi
callq 0x6b9e
testl %eax, %eax
je 0x19586
movq 0x28(%rsp), %rax
leaq (%rax,%r15), %rbx
movq 0x18(%rsp), %r14
testq %r14, %r14
je 0x1954d
movq 0x38(%rsp), %r13
subq %r15, %r13
cmpq %r13, %r14
ja 0x1954b
decq %r14
subq %r14, %r13
je 0x1954b
movq 0x30(%rsp), %r15
movsbl (%r15), %eax
movl %eax, 0xc(%rsp)
incq %r15
movq %rbx, %rdi
movl 0xc(%rsp), %esi
movq %r13, %rdx
callq 0x5380
testq %rax, %rax
je 0x1954b
movq %rax, %r12
leaq 0x1(%rax), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5350
testl %eax, %eax
je 0x196b5
addq %rbx, %r13
movq %rbp, %rbx
subq %rbp, %r13
jne 0x1950f
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x19492
subq 0x28(%rsp), %rbx
leaq 0x1(%rbx), %rsi
movq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x6d91
addq 0x18(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d91
movl $0x2, %ebp
jmp 0x194a1
movq 0x18(%rsp), %rbp
xorl %ebx, %ebx
movq 0x30(%rsp), %rax
leaq (%rax,%rbx), %r13
movq %r13, %rdi
leaq 0x116d7(%rip), %rsi # 0x2ac77
callq 0x5500
testq %rax, %rax
jne 0x195c9
movq %rax, %r14
movq %r13, %rdi
callq 0x5180
addq %rax, %rbx
incq %rbx
cmpq %rbp, %rbx
jbe 0x1958d
testq %r14, %r14
je 0x194d7
movq 0x30(%rsp), %rdx
movb (%rdx), %al
movb %al, 0xc(%rsp)
cmpb $0x5e, %al
jne 0x195e0
incq %rdx
decq 0x18(%rsp)
leaq 0x40(%rsp), %rsi
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsi)
movl $0xc8, 0x20(%rsi)
movq 0x28(%rsp), %rcx
movq %rcx, (%rsi)
movq 0x38(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x8(%rsi)
movq 0x18(%rsp), %rax
movq %rdx, %r13
addq %rdx, %rax
movq %rax, 0x10(%rsi)
leaq -0x1(%rcx), %r15
leaq (%r15,%r12), %r14
movl $0x0, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x196bd
movq %rax, %rbx
testq %rax, %rax
je 0x1968e
cmpl $0x0, 0x24(%rsp)
je 0x1967c
movq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x6d91
movq %rbx, %rsi
subq 0x28(%rsp), %rsi
movq %rbp, %rdi
callq 0x6d91
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x19b26
movl %eax, %ebp
addl $0x2, %ebp
jmp 0x1968e
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x19b26
movl %eax, %ebp
testq %rbx, %rbx
jne 0x194a1
cmpb $0x5e, 0xc(%rsp)
je 0x19492
incq %r12
cmpq 0x48(%rsp), %r14
jb 0x1961c
jmp 0x19492
movq %r12, %rbx
jmp 0x1954d
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
push_captures | static int push_captures (MatchState *ms, const char *s, const char *e) {
int i;
int nlevels = (ms->level == 0 && s) ? 1 : ms->level;
luaL_checkstack(ms->L, nlevels, "too many captures");
for (i = 0; i < nlevels; i++)
push_onecapture(ms, i, s, e);
return nlevels; /* number of strings pushed */
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x24(%rdi), %eax
testl %eax, %eax
movl $0x1, %ebp
cmovnel %eax, %ebp
testq %rsi, %rsi
cmovel %eax, %ebp
movq 0x18(%rdi), %rdi
leaq 0x11164(%rip), %rdx # 0x2acb9
movl %ebp, %esi
callq 0x8e28
testl %ebp, %ebp
jle 0x19b7c
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x19ea9
incl %r12d
cmpl %r12d, %ebp
jne 0x19b63
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
start_capture | static const char *start_capture (MatchState *ms, const char *s,
const char *p, int what) {
const char *res;
int level = ms->level;
if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures");
ms->capture[level].init = s;
ms->capture[level].len = what;
ms->level = level+1;
if ((res=match(ms, s, p)) == NULL) /* match failed? */
ms->level--; /* undo capture */
return res;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movslq 0x24(%rdi), %r12
cmpq $0x20, %r12
jl 0x19bb6
movq 0x18(%rbx), %rdi
leaq 0x1110a(%rip), %rsi # 0x2acb9
xorl %eax, %eax
callq 0x87c6
movq %r12, %rax
shlq $0x4, %rax
movq %r15, 0x28(%rbx,%rax)
movslq %ebp, %rcx
movq %rcx, 0x30(%rbx,%rax)
leal 0x1(%r12), %eax
movl %eax, 0x24(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x196bd
testq %rax, %rax
jne 0x19be8
decl 0x24(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
classend | static const char *classend (MatchState *ms, const char *p) {
switch (*p++) {
case L_ESC: {
if (l_unlikely(p == ms->p_end))
luaL_error(ms->L, "malformed pattern (ends with '%%')");
return p+1;
}
case '[': {
if (*p == '^') p++;
do { /* look for a ']' */
if (l_unlikely(p == ms->p_end))
luaL_error(ms->L, "malformed pattern (missing ']')");
if (*(p++) == L_ESC && p < ms->p_end)
p++; /* skip escapes (e.g. '%]') */
} while (*p != ']');
return p+1;
}
default: {
return p;
}
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x1(%rsi), %rbx
movzbl (%rsi), %eax
cmpl $0x5b, %eax
je 0x19c1c
cmpl $0x25, %eax
jne 0x19c68
cmpq 0x10(%r14), %rbx
je 0x19c71
addq $0x2, %r15
movq %r15, %rbx
jmp 0x19c68
cmpb $0x5e, 0x1(%r15)
leaq 0x2(%r15), %rax
cmoveq %rax, %rbx
leaq 0x11105(%rip), %r15 # 0x2ad35
cmpq 0x10(%r14), %rbx
je 0x19c55
leaq 0x1(%rbx), %rax
cmpb $0x25, (%rbx)
jne 0x19c45
cmpq 0x10(%r14), %rax
jb 0x19c4a
movq %rax, %rbx
jmp 0x19c4e
addq $0x2, %rbx
cmpb $0x5d, (%rbx)
jne 0x19c30
jmp 0x19c65
movq 0x18(%r14), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x87c6
jmp 0x19c36
incq %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x18(%r14), %rdi
leaq 0x11096(%rip), %rsi # 0x2ad12
xorl %eax, %eax
callq 0x87c6
jmp 0x19c13
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
matchbracketclass | static int matchbracketclass (int c, const char *p, const char *ec) {
int sig = 1;
if (*(p+1) == '^') {
sig = 0;
p++; /* skip the '^' */
}
while (++p < ec) {
if (*p == L_ESC) {
p++;
if (match_class(c, cast_uchar(*p)))
return sig;
}
else if ((*(p+1) == '-') && (p+2 < ec)) {
p+=2;
if (cast_uchar(*(p-2)) <= c && c <= cast_uchar(*p))
return sig;
}
else if (cast_uchar(*p) == c) return sig;
}
return !sig;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x1(%rsi), %r12
cmpb $0x5e, 0x1(%rsi)
sete %r14b
setne %r15b
cmovneq %rsi, %r12
leaq 0x1(%r12), %rax
cmpq %rdx, %rax
jae 0x19d09
movq %rdx, %rbx
movl %edi, %ebp
movzbl 0x1(%r12), %ecx
movzbl 0x2(%r12), %esi
cmpl $0x25, %ecx
jne 0x19cd5
movl %ebp, %edi
callq 0x19d56
testl %eax, %eax
jne 0x19d06
addq $0x2, %r12
movq %r12, %rax
jmp 0x19cf9
cmpl $0x2d, %esi
jne 0x19cf5
addq $0x3, %r12
cmpq %rbx, %r12
jae 0x19cf5
cmpl %ebp, %ecx
jg 0x19cd0
movzbl (%r12), %ecx
movq %r12, %rax
cmpl %ebp, %ecx
jl 0x19cf9
jmp 0x19d06
cmpl %ebp, %ecx
je 0x19d06
movq %rax, %r12
incq %rax
cmpq %rbx, %rax
jb 0x19cb0
jmp 0x19d09
movl %r15d, %r14d
movzbl %r14b, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
gmatch_aux | static int gmatch_aux (lua_State *L) {
GMatchState *gm = (GMatchState *)lua_touserdata(L, lua_upvalueindex(3));
const char *src;
gm->ms.L = L;
for (src = gm->src; src <= gm->ms.src_end; src++) {
const char *e;
reprepstate(&gm->ms);
if ((e = match(&gm->ms, src, gm->p)) != NULL && e != gm->lastmatch) {
gm->src = gm->lastmatch = e;
return push_captures(&gm->ms, src, e);
}
}
return 0; /* not found */
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0xfff0b9d5, %esi # imm = 0xFFF0B9D5
callq 0x6cbc
movq %rbx, 0x30(%rax)
movq (%rax), %r15
xorl %ebx, %ebx
cmpq 0x20(%rax), %r15
ja 0x1a0f4
movq %rax, %r14
movq %rax, %r12
addq $0x18, %r12
movl $0x0, 0x3c(%r14)
movq 0x8(%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x196bd
movb $0x1, %cl
testq %rax, %rax
je 0x1a0e3
cmpq 0x10(%r14), %rax
je 0x1a0e3
movq %rax, 0x10(%r14)
movq %rax, (%r14)
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x19b26
movl %eax, %ebp
xorl %ecx, %ecx
testb %cl, %cl
je 0x1a0f2
incq %r15
cmpq 0x20(%r14), %r15
jbe 0x1a0a6
jmp 0x1a0f4
movl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
getdetails | static KOption getdetails (Header *h, size_t totalsize, const char **fmt,
size_t *psize, unsigned *ntoalign) {
KOption opt = getoption(h, fmt, psize);
size_t align = *psize; /* usually, alignment follows size */
if (opt == Kpaddalign) { /* 'X' gets alignment from following option */
if (**fmt == '\0' || getoption(h, fmt, &align) == Kchar || align == 0)
luaL_argerror(h->L, 1, "invalid next option for option 'X'");
}
if (align <= 1 || opt == Kchar) /* need no alignment? */
*ntoalign = 0;
else {
if (align > h->maxalign) /* enforce maximum alignment */
align = h->maxalign;
if (l_unlikely(!ispow2(align))) { /* not a power of 2? */
*ntoalign = 0; /* to avoid warnings */
luaL_argerror(h->L, 1, "format asks for alignment not power of 2");
}
else {
/* 'szmoda' = totalsize % align */
unsigned szmoda = cast_uint(totalsize & (align - 1));
*ntoalign = cast_uint((align - szmoda) & (align - 1));
}
}
return opt;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x1a272
movl %eax, %ebx
movq (%rbp), %rax
movq %rax, (%rsp)
cmpl $0x9, %ebx
jne 0x1a16b
movq (%r13), %rax
cmpb $0x0, (%rax)
je 0x1a156
movq %rsp, %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x1a272
cmpl $0x5, %eax
je 0x1a156
cmpq $0x0, (%rsp)
jne 0x1a16b
movq (%r12), %rdi
leaq 0x10e05(%rip), %rdx # 0x2af66
movl $0x1, %esi
callq 0x86ba
movq (%rsp), %rax
cmpq $0x2, %rax
setae %cl
cmpl $0x5, %ebx
setne %dl
testb %cl, %dl
jne 0x1a189
movl $0x0, (%r14)
jmp 0x1a1b2
movl 0xc(%r12), %ecx
cmpq %rcx, %rax
jbe 0x1a197
movq %rcx, (%rsp)
movq (%rsp), %rax
leaq -0x1(%rax), %rcx
testq %rcx, %rax
jne 0x1a1c3
leal -0x1(%rax), %ecx
andl %ecx, %r15d
subl %r15d, %eax
andl %ecx, %eax
movl %eax, (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, (%r14)
movq (%r12), %rdi
leaq 0x10db4(%rip), %rdx # 0x2af89
movl $0x1, %esi
callq 0x86ba
jmp 0x1a1b2
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
packint | static void packint (luaL_Buffer *b, lua_Unsigned n,
int islittle, unsigned size, int neg) {
char *buff = luaL_prepbuffsize(b, size);
unsigned i;
buff[islittle ? 0 : size - 1] = (char)(n & MC); /* first byte */
for (i = 1; i < size; i++) {
n >>= NB;
buff[islittle ? i : size - 1 - i] = (char)(n & MC);
}
if (neg && size > SZINT) { /* negative number need sign extension? */
for (i = SZINT; i < size; i++) /* correct extra bytes */
buff[islittle ? i : size - 1 - i] = (char)MC;
}
luaL_addsize(b, size); /* add result to buffer */
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r14
movl %ecx, %r15d
movq %r15, %rsi
callq 0x857a
leal -0x1(%rbx), %ecx
xorl %edx, %edx
testl %ebp, %ebp
cmovel %ecx, %edx
movb %r13b, (%rax,%rdx)
cmpl $0x2, %ebx
jb 0x1a235
leal -0x2(%rbx), %ecx
movl $0x1, %edx
shrq $0x8, %r13
testl %ebp, %ebp
movl %edx, %esi
cmovel %ecx, %esi
movb %r13b, (%rax,%rsi)
incl %edx
addl $-0x1, %ecx
jb 0x1a21f
testl %r12d, %r12d
sete %cl
cmpl $0x9, %ebx
setb %dl
orb %cl, %dl
jne 0x1a25f
addl $-0x9, %ebx
movl $0x8, %ecx
testl %ebp, %ebp
movl %ecx, %edx
cmovel %ebx, %edx
movb $-0x1, (%rax,%rdx)
incl %ecx
addl $-0x1, %ebx
jb 0x1a24d
addq %r15, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
getoption | static KOption getoption (Header *h, const char **fmt, size_t *size) {
/* dummy structure to get native alignment requirements */
struct cD { char c; union { LUAI_MAXALIGN; } u; };
int opt = *((*fmt)++);
*size = 0; /* default */
switch (opt) {
case 'b': *size = sizeof(char); return Kint;
case 'B': *size = sizeof(char); return Kuint;
case 'h': *size = sizeof(short); return Kint;
case 'H': *size = sizeof(short); return Kuint;
case 'l': *size = sizeof(long); return Kint;
case 'L': *size = sizeof(long); return Kuint;
case 'j': *size = sizeof(lua_Integer); return Kint;
case 'J': *size = sizeof(lua_Integer); return Kuint;
case 'T': *size = sizeof(size_t); return Kuint;
case 'f': *size = sizeof(float); return Kfloat;
case 'n': *size = sizeof(lua_Number); return Knumber;
case 'd': *size = sizeof(double); return Kdouble;
case 'i': *size = getnumlimit(h, fmt, sizeof(int)); return Kint;
case 'I': *size = getnumlimit(h, fmt, sizeof(int)); return Kuint;
case 's': *size = getnumlimit(h, fmt, sizeof(size_t)); return Kstring;
case 'c':
*size = getnum(fmt, cast_sizet(-1));
if (l_unlikely(*size == cast_sizet(-1)))
luaL_error(h->L, "missing size for format option 'c'");
return Kchar;
case 'z': return Kzstr;
case 'x': *size = 1; return Kpadding;
case 'X': return Kpaddalign;
case ' ': break;
case '<': h->islittle = 1; break;
case '>': h->islittle = 0; break;
case '=': h->islittle = nativeendian.little; break;
case '!': {
const size_t maxalign = offsetof(struct cD, u);
h->maxalign = getnumlimit(h, fmt, maxalign);
break;
}
default: luaL_error(h->L, "invalid format option '%c'", opt);
}
return Knop;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
movzbl (%rax), %eax
movq $0x0, (%rdx)
cmpl $0x53, %eax
jg 0x1a2ba
leal -0x3c(%rax), %ecx
cmpl $0x10, %ecx
ja 0x1a2de
leaq 0x108b0(%rip), %rdx # 0x2ab54
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x1, 0x8(%r14)
jmp 0x1a368
leal -0x62(%rax), %ecx
cmpl $0x18, %ecx
ja 0x1a2ff
leaq 0x108cf(%rip), %rdx # 0x2ab98
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq $0x8, (%rbx)
jmp 0x1a416
cmpl $0x20, %eax
je 0x1a368
cmpl $0x21, %eax
jne 0x1a354
movl $0x8, %edx
movq %r14, %rdi
callq 0x1a430
movl %eax, 0xc(%r14)
jmp 0x1a368
cmpl $0x54, %eax
je 0x1a313
cmpl $0x58, %eax
jne 0x1a354
movl $0x9, %ebx
jmp 0x1a418
movq $0x8, (%rbx)
jmp 0x1a34a
movl $0x0, 0x8(%r14)
jmp 0x1a368
movl $0x4, %edx
movq %r14, %rdi
callq 0x1a430
movl %eax, %eax
movq %rax, (%rbx)
jmp 0x1a34a
movq $0x1, (%rbx)
jmp 0x1a34a
movq $0x2, (%rbx)
movl $0x1, %ebx
jmp 0x1a418
movsbl %al, %edx
movq (%r14), %rdi
leaq 0x10c74(%rip), %rsi # 0x2afd5
xorl %eax, %eax
callq 0x87c6
movl $0xa, %ebx
jmp 0x1a418
movl $0x7, %ebx
jmp 0x1a418
movq $0x8, (%rbx)
movl $0x3, %ebx
jmp 0x1a418
movl $0x8, %edx
movq %r14, %rdi
callq 0x1a430
movl %eax, %eax
movq %rax, (%rbx)
movl $0x6, %ebx
jmp 0x1a418
movl $0x4, %edx
movq %r14, %rdi
callq 0x1a430
movl %eax, %eax
movq %rax, (%rbx)
jmp 0x1a416
movq $0x4, (%rbx)
movl $0x2, %ebx
jmp 0x1a418
movq $0x1, (%rbx)
movl $0x8, %ebx
jmp 0x1a418
movq %rsi, %rdi
movq $-0x1, %rsi
callq 0x1a468
movq %rax, (%rbx)
movl $0x5, %ebx
cmpq $-0x1, %rax
jne 0x1a418
movq (%r14), %rdi
leaq 0x10bb5(%rip), %rsi # 0x2afb2
xorl %eax, %eax
callq 0x87c6
jmp 0x1a418
movq $0x1, (%rbx)
jmp 0x1a416
movq $0x2, (%rbx)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq $0x8, (%rbx)
movl $0x4, %ebx
jmp 0x1a418
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
getnum | static size_t getnum (const char **fmt, size_t df) {
if (!digit(**fmt)) /* no number? */
return df; /* return default value */
else {
size_t a = 0;
do {
a = a*10 + cast_uint(*((*fmt)++) - '0');
} while (digit(**fmt) && a <= (MAX_SIZE - 9)/10);
return a;
}
} | movq %rsi, %rax
movq (%rdi), %rcx
movsbl (%rcx), %ecx
addl $-0x3a, %ecx
cmpl $-0xa, %ecx
jb 0x1a4b0
movq (%rdi), %rcx
incq %rcx
xorl %eax, %eax
movabsq $0xccccccccccccccc, %rdx # imm = 0xCCCCCCCCCCCCCCC
leaq (%rax,%rax,4), %rax
movq %rcx, (%rdi)
movsbl -0x1(%rcx), %esi
addl $-0x30, %esi
leaq (%rsi,%rax,2), %rax
movsbl (%rcx), %esi
addl $-0x30, %esi
cmpl $0x9, %esi
ja 0x1a4b0
incq %rcx
cmpq %rdx, %rax
jb 0x1a48b
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
unpackint | static lua_Integer unpackint (lua_State *L, const char *str,
int islittle, int size, int issigned) {
lua_Unsigned res = 0;
int i;
int limit = (size <= SZINT) ? size : SZINT;
for (i = limit - 1; i >= 0; i--) {
res <<= NB;
res |= (lua_Unsigned)(unsigned char)str[islittle ? i : size - 1 - i];
}
if (size < SZINT) { /* real size smaller than lua_Integer? */
if (issigned) { /* needs sign extension? */
lua_Unsigned mask = (lua_Unsigned)1 << (size*NB - 1);
res = ((res ^ mask) - mask); /* do sign extension */
}
}
else if (size > SZINT) { /* must check unread bytes */
int mask = (!issigned || (lua_Integer)res >= 0) ? 0 : MC;
for (i = limit; i < size; i++) {
if (l_unlikely((unsigned char)str[islittle ? i : size - 1 - i] != mask))
luaL_error(L, "%d-byte integer does not fit into Lua Integer", size);
}
}
return (lua_Integer)res;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r15
cmpl $0x8, %ecx
movl $0x8, %r13d
cmovll %ecx, %r13d
testl %ecx, %ecx
jle 0x1a503
leal 0x1(%r13), %eax
movl %ecx, %esi
subl %r13d, %esi
xorl %r14d, %r14d
leal -0x2(%rax), %edx
shlq $0x8, %r14
testl %ebp, %ebp
cmovel %esi, %edx
movslq %edx, %rdx
movzbl (%r15,%rdx), %edx
orq %rdx, %r14
decl %eax
incl %esi
cmpl $0x1, %eax
jg 0x1a4e1
jmp 0x1a506
xorl %r14d, %r14d
cmpl $0x7, %ecx
jg 0x1a526
testl %r8d, %r8d
je 0x1a52b
shll $0x3, %ecx
decb %cl
movl $0x1, %eax
shlq %cl, %rax
btcq %rcx, %r14
subq %rax, %r14
jmp 0x1a52b
cmpl $0x8, %ecx
jne 0x1a53d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
testq %r14, %r14
movl $0xff, %r12d
cmovnsl %eax, %r12d
testl %r8d, %r8d
cmovel %r8d, %r12d
movl %r13d, %ebx
notl %ebx
addl %ecx, %ebx
testl %ebp, %ebp
movl %r13d, %eax
cmovel %ebx, %eax
cltq
movzbl (%r15,%rax), %eax
cmpl %eax, %r12d
jne 0x1a57a
incl %r13d
decl %ebx
cmpl %ecx, %r13d
jl 0x1a55a
jmp 0x1a52b
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x10b23(%rip), %rsi # 0x2b0ae
movl %ecx, %edx
xorl %eax, %eax
movq %rcx, 0x10(%rsp)
callq 0x87c6
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rcx
jmp 0x1a56e
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
arith | static int arith (lua_State *L, int op, const char *mtname) {
if (tonum(L, 1) && tonum(L, 2))
lua_arith(L, op); /* result will be on the top */
else
trymt(L, mtname);
return 1;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1a710
testl %eax, %eax
je 0x1a6a3
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1a710
testl %eax, %eax
je 0x1a6a3
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x69de
movq %rbx, %rdi
movl $0x2, %esi
callq 0x664e
movq %rbx, %rdi
movl $0x2, %esi
callq 0x68d4
cmpl $0x4, %eax
je 0x1a703
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x89f6
testl %eax, %eax
je 0x1a703
movq %rbx, %rdi
movl $0xfffffffd, %esi # imm = 0xFFFFFFFD
movl $0x1, %edx
callq 0x66f8
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x78e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5a49
jmp 0x1a6d6
| /mmanyen[P]CLua/build_O1/_deps/lua/lstrlib.c |
luaH_next | int luaH_next (lua_State *L, Table *t, StkId key) {
unsigned int asize = t->asize;
unsigned int i = findindex(L, t, s2v(key), asize); /* find original key */
for (; i < asize; i++) { /* try first array part */
lu_byte tag = *getArrTag(t, i);
if (!tagisempty(tag)) { /* a non-empty entry? */
setivalue(s2v(key), cast_int(i) + 1);
farr2val(t, i, tag, s2v(key + 1));
return 1;
}
}
for (i -= asize; i < sizenode(t); i++) { /* hash part */
if (!isempty(gval(gnode(t, i)))) { /* a non-empty entry? */
Node *n = gnode(t, i);
getnodekey(L, s2v(key), n);
setobj2s(L, key + 1, gval(n));
return 1;
}
}
return 0; /* no more elements */
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl 0xc(%rsi), %r12d
movb 0x8(%rdx), %al
testb $0xf, %al
je 0x1a7d5
movq %rdi, %r15
xorl %edx, %edx
cmpb $0x3, %al
jne 0x1a7a1
movq (%rbx), %rdx
leaq -0x1(%rdx), %rax
xorl %ecx, %ecx
cmpq %r12, %rax
cmovael %ecx, %edx
testl %edx, %edx
jne 0x1a7d7
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x1b0d3
cmpb $0x20, 0x8(%rax)
je 0x1a895
subq 0x18(%r14), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
leal (%r12,%rax), %edx
incl %edx
jmp 0x1a7d7
xorl %edx, %edx
cmpl %r12d, %edx
jae 0x1a81a
movq 0x10(%r14), %rsi
movl %r12d, %ecx
negl %ecx
movl %edx, %edi
incl %edx
leaq (,%rdi,8), %rax
negq %rax
addq %rdi, %rsi
addq $0x4, %rsi
movb (%rsi), %dil
testb $0xf, %dil
jne 0x1a849
leal (%rcx,%rdx), %edi
incl %edi
incl %edx
addq $-0x8, %rax
incq %rsi
cmpl $0x1, %edi
jne 0x1a7fb
movl %r12d, %edx
subl %r12d, %edx
movzbl 0xb(%r14), %ecx
movl %edx, %esi
shrl %cl, %esi
xorl %eax, %eax
testl %esi, %esi
jne 0x1a889
movq 0x18(%r14), %rsi
movl %edx, %edi
leaq (%rdi,%rdi,2), %rdi
testb $0xf, 0x8(%rsi,%rdi,8)
jne 0x1a866
incl %edx
movl %edx, %edi
shrl %cl, %edi
testl %edi, %edi
je 0x1a830
jmp 0x1a889
movslq %edx, %rcx
movq %rcx, (%rbx)
movb $0x3, 0x8(%rbx)
movb %dil, 0x18(%rbx)
movq 0x10(%r14), %rcx
movq -0x8(%rcx,%rax), %rax
movq %rax, 0x10(%rbx)
jmp 0x1a884
leaq (%rsi,%rdi,8), %rax
movq 0x10(%rax), %rcx
movq %rcx, (%rbx)
movb 0x9(%rax), %cl
movb %cl, 0x8(%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
movb 0x8(%rax), %al
movb %al, 0x18(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x10921(%rip), %rsi # 0x2b1bd
movq %r15, %rdi
xorl %eax, %eax
callq 0xa859
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_resize | void luaH_resize (lua_State *L, Table *t, unsigned newasize,
unsigned nhsize) {
Table newt; /* to keep the new hash part */
unsigned oldasize = t->asize;
Value *newarray;
if (newasize > MAXASIZE)
luaG_runerror(L, "table overflow");
/* create new hash part with appropriate size into 'newt' */
newt.flags = 0;
setnodevector(L, &newt, nhsize);
if (newasize < oldasize) { /* will array shrink? */
/* re-insert into the new hash the elements from vanishing slice */
exchangehashpart(t, &newt); /* pretend table has new hash */
reinsertOldSlice(t, oldasize, newasize);
exchangehashpart(t, &newt); /* restore old hash (in case of errors) */
}
/* allocate new array */
newarray = resizearray(L, t, oldasize, newasize);
if (l_unlikely(newarray == NULL && newasize > 0)) { /* allocation failed? */
freehash(L, &newt); /* release new hash part */
luaM_error(L); /* raise error (with array unchanged) */
}
/* allocation ok; initialize new part of the array */
exchangehashpart(t, &newt); /* 't' has the new hash ('newt' has the old) */
t->array = newarray; /* set new array part */
t->asize = newasize;
if (newarray != NULL)
*lenhint(t) = newasize / 2u; /* set an initial hint */
clearNewSlice(t, oldasize, newasize);
/* re-insert elements from old hash part into new parts */
reinserthash(L, &newt, t); /* 'newt' now has the old hash */
freehash(L, &newt); /* free old hash part */
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
cmpl $0x80000001, %edx # imm = 0x80000001
jae 0x1ab37
movl %edx, %ebp
movq %rsi, %r14
movl 0xc(%rsi), %r15d
leaq 0x20(%rsp), %rsi
movb $0x0, 0xa(%rsi)
movq %rbx, %rdi
movl %ecx, %edx
callq 0x1ab48
cmpl %ebp, %r15d
movq %rbx, 0x8(%rsp)
jbe 0x1a9f8
movb 0xa(%r14), %al
movb 0xb(%r14), %sil
movq 0x18(%r14), %rdi
movl %eax, %edx
andb $0x40, %dl
movb 0x2b(%rsp), %cl
movb %cl, 0xb(%r14)
movq 0x38(%rsp), %rcx
movq %rcx, 0x18(%r14)
andb $-0x41, %al
movb 0x2a(%rsp), %r8b
movl %r8d, %ecx
andb $0x40, %cl
orb %al, %cl
movb %cl, 0xa(%r14)
movb %sil, 0x3(%rsp)
movb %sil, 0x2b(%rsp)
movq %rdi, 0x58(%rsp)
movq %rdi, 0x38(%rsp)
andb $-0x41, %r8b
movq %rdx, 0x60(%rsp)
movq %r8, 0x50(%rsp)
leal (%r8,%rdx), %eax
movb %al, 0x2a(%rsp)
movl %ebp, %ebx
movl %ebp, %eax
movl %r15d, %ebp
movl %eax, 0x4(%rsp)
subl %eax, %ebp
movq %rbx, %r12
notq %r12
shlq $0x3, %r12
addq $0x4, %rbx
leaq 0x68(%rsp), %r13
movq 0x10(%r14), %rax
movb (%rax,%rbx), %cl
testb $0xf, %cl
je 0x1a9a3
leaq -0x3(%rbx), %rdx
movq %rdx, 0x10(%rsp)
movb $0x3, 0x18(%rsp)
movb %cl, 0x70(%rsp)
movq (%rax,%r12), %rax
movq %rax, 0x68(%rsp)
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
callq 0x1b2c1
addq $-0x8, %r12
incq %rbx
decl %ebp
jne 0x1a96c
movb 0xa(%r14), %al
movb 0xb(%r14), %cl
movq 0x18(%r14), %rdx
movl %eax, %esi
andb $0x40, %sil
movb 0x3(%rsp), %dil
movb %dil, 0xb(%r14)
movq 0x58(%rsp), %rdi
movq %rdi, 0x18(%r14)
andb $-0x41, %al
orb 0x60(%rsp), %al
movb %al, 0xa(%r14)
movb %cl, 0x2b(%rsp)
movq %rdx, 0x38(%rsp)
orb 0x50(%rsp), %sil
movb %sil, 0x2a(%rsp)
movq 0x8(%rsp), %rbx
movl 0x4(%rsp), %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x1ac1d
testl %ebp, %ebp
je 0x1aa15
testq %rax, %rax
je 0x1ab2a
movzbl 0xb(%r14), %r12d
movq 0x18(%r14), %r13
movb 0xa(%r14), %cl
movl %ecx, %ebx
andb $0x40, %bl
movb 0x2b(%rsp), %dl
movb %dl, 0xb(%r14)
movq 0x38(%rsp), %rdx
movq %rdx, 0x18(%r14)
andb $-0x41, %cl
movb 0x2a(%rsp), %dl
movl %edx, %esi
andb $0x40, %sil
orb %cl, %sil
andb $-0x41, %dl
orb %bl, %dl
movb %sil, 0xa(%r14)
movb %r12b, 0x2b(%rsp)
movq %r13, 0x38(%rsp)
movb %dl, 0x2a(%rsp)
movq %rax, 0x10(%r14)
movl %ebp, 0xc(%r14)
testq %rax, %rax
je 0x1aa72
movl %ebp, %ecx
shrl %ecx
movl %ecx, (%rax)
cmpl %ebp, %r15d
jae 0x1aa8b
movl %ebp, %eax
movq 0x10(%r14), %rcx
movb $0x10, 0x4(%rcx,%r15)
incq %r15
cmpq %r15, %rax
jne 0x1aa79
movl $0x1, %ebp
leaq 0x10(%rsp), %r15
leal -0x1(%rbp), %eax
leaq (%rax,%rax,2), %rax
testb $0xf, 0x8(%r13,%rax,8)
je 0x1aaca
leaq (,%rax,8), %rdx
addq %r13, %rdx
movq 0x10(%rdx), %rax
movq %rax, 0x10(%rsp)
movb 0x9(%rdx), %al
movb %al, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1bc60
movl %ebp, %eax
movl %r12d, %ecx
shrl %cl, %eax
incl %ebp
testl %eax, %eax
je 0x1aa95
testb %bl, %bl
jne 0x1ab1b
xorl %eax, %eax
xorl %ecx, %ecx
cmpb $0x3, %r12b
setae %al
setb %cl
leaq -0x8(,%rcx,8), %rsi
addq %r13, %rsi
movl $0x18, %edx
movl %r12d, %ecx
shlq %cl, %rdx
leaq (%rdx,%rax,8), %rdx
movq 0x8(%rsp), %rdi
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x112b5
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5aa1
leaq 0x1064a(%rip), %rsi # 0x2b188
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa859
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
setnodevector | static void setnodevector (lua_State *L, Table *t, unsigned size) {
if (size == 0) { /* no elements to hash part? */
t->node = cast(Node *, dummynode); /* use common 'dummynode' */
t->lsizenode = 0;
setdummy(t); /* signal that it is using dummy node */
}
else {
int i;
int lsize = luaO_ceillog2(size);
if (lsize > MAXHBITS || (1 << lsize) > MAXHSIZE)
luaG_runerror(L, "table overflow");
size = twoto(lsize);
if (lsize < LIMFORLAST) /* no 'lastfree' field? */
t->node = luaM_newvector(L, size, Node);
else {
size_t bsize = size * sizeof(Node) + sizeof(Limbox);
char *node = luaM_newblock(L, bsize);
t->node = cast(Node *, node + sizeof(Limbox));
getlastfree(t) = gnode(t, size); /* all positions are free */
}
t->lsizenode = cast_byte(lsize);
setnodummy(t);
for (i = 0; i < cast_int(size); i++) {
Node *n = gnode(t, i);
gnext(n) = 0;
setnilkey(n);
setempty(gval(n));
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testl %edx, %edx
je 0x1ab95
movq %rdi, %r14
movl %edx, %edi
callq 0x12114
cmpb $0x1e, %al
ja 0x1ac0c
movl %eax, %ebp
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
movl %eax, %r15d
cmpb $0x3, %bpl
jae 0x1abaa
movl $0x18, %esi
movl %ebp, %ecx
shll %cl, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x11387
movq %rax, 0x18(%rbx)
jmp 0x1abd9
leaq 0x105d4(%rip), %rax # 0x2b170
movq %rax, 0x18(%rbx)
movb $0x0, 0xb(%rbx)
orb $0x40, 0xa(%rbx)
jmp 0x1ac01
movl $0x18, %esi
movl %ebp, %ecx
shlq %cl, %rsi
orq $0x8, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x11387
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rbx)
leaq (%r15,%r15,2), %rcx
leaq (%rax,%rcx,8), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
movb %bpl, 0xb(%rbx)
andb $-0x41, 0xa(%rbx)
movl $0xc, %eax
movq 0x18(%rbx), %rcx
movl $0x0, (%rcx,%rax)
movw $0x10, -0x4(%rcx,%rax)
addq $0x18, %rax
decq %r15
jne 0x1abe6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10575(%rip), %rsi # 0x2b188
movq %r14, %rdi
xorl %eax, %eax
callq 0xa859
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
resizearray | static Value *resizearray (lua_State *L , Table *t,
unsigned oldasize,
unsigned newasize) {
if (oldasize == newasize)
return t->array; /* nothing to be done */
else if (newasize == 0) { /* erasing array? */
Value *op = t->array - oldasize; /* original array's real address */
luaM_freemem(L, op, concretesize(oldasize)); /* free it */
return NULL;
}
else {
size_t newasizeb = concretesize(newasize);
Value *np = cast(Value *,
luaM_reallocvector(L, NULL, 0, newasizeb, lu_byte));
if (np == NULL) /* allocation error? */
return NULL;
np += newasize; /* shift pointer to the end of value segment */
if (oldasize > 0) {
/* move common elements to new position */
size_t oldasizeb = concretesize(oldasize);
Value *op = t->array; /* original array */
unsigned tomove = (oldasize < newasize) ? oldasize : newasize;
size_t tomoveb = (oldasize < newasize) ? oldasizeb : newasizeb;
lua_assert(tomoveb > 0);
memcpy(np - tomove, op - tomove, tomoveb);
luaM_freemem(L, op - oldasize, oldasizeb); /* free old block */
}
return np;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
cmpl %ecx, %edx
jne 0x1ac39
movq 0x10(%r12), %r14
jmp 0x1ace7
movl %ecx, %r15d
movl %edx, %ebp
movq %rdi, %rbx
testl %ecx, %ecx
je 0x1acbf
movl %r15d, %r13d
leaq 0x4(,%r13,8), %rcx
addq %r13, %rcx
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rcx, (%rsp)
callq 0x112d5
testq %rax, %rax
je 0x1ace7
leaq (%rax,%r13,8), %r14
testl %ebp, %ebp
je 0x1ace7
movl %ebp, %r13d
leaq 0x4(,%r13,8), %rax
addq %r13, %rax
cmpl %r15d, %ebp
cmovbl %ebp, %r15d
movq 0x10(%r12), %r12
movq (%rsp), %rdx
cmovbq %rax, %rdx
movq %rax, %rbp
shlq $0x3, %r15
movq %r14, %rdi
subq %r15, %rdi
movq %r12, %rsi
subq %r15, %rsi
callq 0x52a0
shlq $0x3, %r13
subq %r13, %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
jmp 0x1ace2
movq 0x10(%r12), %rsi
movl %ebp, %eax
leaq (,%rax,8), %rcx
subq %rcx, %rsi
xorl %r14d, %r14d
testl %ebp, %ebp
leaq 0x4(%rax,%rax,8), %rdx
cmoveq %r14, %rdx
movq %rbx, %rdi
callq 0x112b5
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_new | Table *luaH_new (lua_State *L) {
GCObject *o = luaC_newobj(L, LUA_VTABLE, sizeof(Table));
Table *t = gco2t(o);
t->metatable = NULL;
t->flags = maskflags; /* table has no metamethod fields */
t->array = NULL;
t->asize = 0;
setnodevector(L, t, 0);
return t;
} | pushq %rax
movl $0x30, %edx
movl $0x5, %esi
callq 0xd734
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movq %rcx, 0x10(%rax)
movl $0x0, 0xc(%rax)
leaq 0x10401(%rip), %rcx # 0x2b170
movq %rcx, 0x18(%rax)
movw $0x7f, 0xa(%rax)
popq %rcx
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_free | void luaH_free (lua_State *L, Table *t) {
freehash(L, t);
resizearray(L, t, t->asize, 0);
luaM_free(L, t);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1acf9
movl 0xc(%rbx), %eax
testq %rax, %rax
je 0x1ade7
movq 0x10(%rbx), %rsi
leaq (,%rax,8), %rcx
subq %rcx, %rsi
leaq (%rax,%rax,8), %rdx
addq $0x4, %rdx
movq %r14, %rdi
callq 0x112b5
movl $0x30, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x112b5
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_getint | lu_byte luaH_getint (Table *t, lua_Integer key, TValue *res) {
unsigned k = ikeyinarray(t, key);
if (k > 0) {
lu_byte tag = *getArrTag(t, k - 1);
if (!tagisempty(tag))
farr2val(t, k - 1, tag, res);
return tag;
}
else
return finishnodeget(getintfromhash(t, key), res);
} | pushq %rbx
movq %rdx, %rbx
testl %esi, %esi
je 0x1ae33
movl 0xc(%rdi), %eax
leaq -0x1(%rsi), %rcx
cmpq %rax, %rcx
jae 0x1ae33
movq 0x10(%rdi), %rcx
decl %esi
movb 0x4(%rcx,%rsi), %al
testb $0xf, %al
je 0x1ae4f
movb %al, 0x8(%rbx)
shlq $0x3, %rsi
subq %rsi, %rcx
movq -0x8(%rcx), %rcx
movq %rcx, (%rbx)
jmp 0x1ae4f
callq 0x1ae51
testb $0xf, 0x8(%rax)
je 0x1ae4a
movq (%rax), %rcx
movq %rcx, (%rbx)
movb 0x8(%rax), %cl
movb %cl, 0x8(%rbx)
movb 0x8(%rax), %al
andb $0x3f, %al
popq %rbx
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_Hgetshortstr | const TValue *luaH_Hgetshortstr (Table *t, TString *key) {
Node *n = hashstr(t, key);
lua_assert(strisshr(key));
for (;;) { /* check whether 'key' is somewhere in the chain */
if (keyisshrstr(n) && eqshrstr(keystrval(n), key))
return gval(n); /* that's it */
else {
int nx = gnext(n);
if (nx == 0)
return &absentkey; /* not found */
n += nx;
}
}
} | movb 0xb(%rdi), %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
andl 0xc(%rsi), %eax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x18(%rdi), %rax
leaq 0x10282(%rip), %rcx # 0x2b160
cmpb $0x44, 0x9(%rax)
jne 0x1aeea
cmpq %rsi, 0x10(%rax)
je 0x1aefe
movslq 0xc(%rax), %rdx
leaq (%rdx,%rdx,2), %rdi
leaq (%rax,%rdi,8), %rax
testq %rdx, %rdx
jne 0x1aede
movq %rcx, %rax
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_getshortstr | const TValue *luaH_Hgetshortstr (Table *t, TString *key) {
Node *n = hashstr(t, key);
lua_assert(strisshr(key));
for (;;) { /* check whether 'key' is somewhere in the chain */
if (keyisshrstr(n) && eqshrstr(keystrval(n), key))
return gval(n); /* that's it */
else {
int nx = gnext(n);
if (nx == 0)
return &absentkey; /* not found */
n += nx;
}
}
} | movb 0xb(%rdi), %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
andl 0xc(%rsi), %eax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x18(%rdi), %rax
leaq 0x1023f(%rip), %rcx # 0x2b160
cmpb $0x44, 0x9(%rax)
jne 0x1af2d
cmpq %rsi, 0x10(%rax)
je 0x1af41
movslq 0xc(%rax), %rdi
leaq (%rdi,%rdi,2), %r8
leaq (%rax,%r8,8), %rax
testq %rdi, %rdi
jne 0x1af21
movq %rcx, %rax
testb $0xf, 0x8(%rax)
je 0x1af53
movq (%rax), %rcx
movq %rcx, (%rdx)
movb 0x8(%rax), %cl
movb %cl, 0x8(%rdx)
movb 0x8(%rax), %al
andb $0x3f, %al
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_getstr | lu_byte luaH_getstr (Table *t, TString *key, TValue *res) {
return finishnodeget(Hgetstr(t, key), res);
} | pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
cmpb $0x0, 0xb(%rsi)
js 0x1afab
movb 0xb(%rdi), %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
andl 0xc(%rsi), %eax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x18(%rdi), %rax
leaq 0x101d7(%rip), %rcx # 0x2b160
cmpb $0x44, 0x9(%rax)
jne 0x1af95
cmpq %rsi, 0x10(%rax)
je 0x1afc4
movslq 0xc(%rax), %rdx
leaq (%rdx,%rdx,2), %rdi
leaq (%rax,%rdi,8), %rax
testq %rdx, %rdx
jne 0x1af89
movq %rcx, %rax
jmp 0x1afc4
movq %rsp, %rax
movq %rsi, (%rax)
movb 0x8(%rsi), %cl
orb $0x40, %cl
movb %cl, 0x8(%rax)
movq %rax, %rsi
xorl %edx, %edx
callq 0x1b0d3
testb $0xf, 0x8(%rax)
je 0x1afd6
movq (%rax), %rcx
movq %rcx, (%rbx)
movb 0x8(%rax), %cl
movb %cl, 0x8(%rbx)
movb 0x8(%rax), %al
andb $0x3f, %al
addq $0x10, %rsp
popq %rbx
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_get | lu_byte luaH_get (Table *t, const TValue *key, TValue *res) {
const TValue *slot;
switch (ttypetag(key)) {
case LUA_VSHRSTR:
slot = luaH_Hgetshortstr(t, tsvalue(key));
break;
case LUA_VNUMINT:
return luaH_getint(t, ivalue(key), res);
case LUA_VNIL:
slot = &absentkey;
break;
case LUA_VNUMFLT: {
lua_Integer k;
if (luaV_flttointeger(fltvalue(key), &k, F2Ieq)) /* integral index? */
return luaH_getint(t, k, res); /* use specialized version */
/* else... */
} /* FALLTHROUGH */
default:
slot = getgeneric(t, key, 0);
break;
}
return finishnodeget(slot, res);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movzbl 0x8(%rsi), %ecx
andl $0x3f, %ecx
leaq 0x10161(%rip), %rax # 0x2b160
cmpl $0x3, %ecx
jg 0x1b02d
testl %ecx, %ecx
je 0x1b0ac
cmpl $0x3, %ecx
jne 0x1b09f
movq (%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1adfe
cmpl $0x13, %ecx
je 0x1b075
cmpl $0x4, %ecx
jne 0x1b09f
movb 0xb(%r14), %cl
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
shll %cl, %edx
movq (%r15), %rcx
notl %edx
andl 0xc(%rcx), %edx
leaq (%rdx,%rdx,2), %rdx
shlq $0x3, %rdx
addq 0x18(%r14), %rdx
cmpb $0x44, 0x9(%rdx)
jne 0x1b062
cmpq %rcx, 0x10(%rdx)
je 0x1b0ce
movslq 0xc(%rdx), %rsi
leaq (%rsi,%rsi,2), %rdi
leaq (%rdx,%rdi,8), %rdx
testq %rsi, %rsi
jne 0x1b056
jmp 0x1b0ac
movsd (%r15), %xmm0
movq %rsp, %rdi
xorl %esi, %esi
callq 0x1dc39
movl %eax, %ebp
testl %eax, %eax
je 0x1b09b
movq (%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1adfe
jmp 0x1b09b
testl %ebp, %ebp
jne 0x1b0c3
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1b0d3
testb $0xf, 0x8(%rax)
je 0x1b0be
movq (%rax), %rcx
movq %rcx, (%rbx)
movb 0x8(%rax), %cl
movb %cl, 0x8(%rbx)
movb 0x8(%rax), %al
andb $0x3f, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rax
jmp 0x1b0ac
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
getgeneric | static const TValue *getgeneric (Table *t, const TValue *key, int deadok) {
Node *n = mainpositionTV(t, key);
for (;;) { /* check whether 'key' is somewhere in the chain */
if (equalkey(key, n, deadok))
return gval(n); /* that's it */
else {
int nx = gnext(n);
if (nx == 0)
return &absentkey; /* not found */
n += nx;
}
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
callq 0x1bca5
movq %rax, %r15
leaq 0x10071(%rip), %r12 # 0x2b160
movb 0x8(%r14), %dl
movzbl 0x9(%r15), %ecx
cmpb %cl, %dl
je 0x1b10c
xorl %eax, %eax
testb $0x40, %dl
je 0x1b16b
testl %ebx, %ebx
je 0x1b16b
cmpb $0xb, %cl
jne 0x1b16b
movl $0x1, %eax
cmpl $0x10, %ecx
jg 0x1b122
cmpl $0x2, %ecx
jb 0x1b16b
je 0x1b15f
cmpl $0x3, %ecx
jmp 0x1b15f
cmpl $0x15, %ecx
jg 0x1b147
cmpl $0x11, %ecx
je 0x1b16b
cmpl $0x13, %ecx
jne 0x1b15f
movsd 0x10(%r15), %xmm0
cmpeqsd (%r14), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x1b16b
cmpl $0x16, %ecx
je 0x1b15f
cmpl $0x54, %ecx
jne 0x1b15f
movq (%r14), %rdi
movq 0x10(%r15), %rsi
callq 0x16e74
jmp 0x1b16b
movq (%r14), %rcx
xorl %eax, %eax
cmpq 0x10(%r15), %rcx
sete %al
testl %eax, %eax
jne 0x1b187
movslq 0xc(%r15), %rax
leaq (%rax,%rax,2), %rcx
leaq (%r15,%rcx,8), %r15
testq %rax, %rax
jne 0x1b0ef
movq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_psetint | int luaH_psetint (Table *t, lua_Integer key, TValue *val) {
lua_assert(!ikeyinarray(t, key));
return finishnodeset(t, getintfromhash(t, key), val);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x1ae51
movb 0x8(%rax), %dl
testb $0xf, %dl
je 0x1b1be
movq (%r14), %rcx
movq %rcx, (%rax)
movb 0x8(%r14), %cl
movb %cl, 0x8(%rax)
xorl %ecx, %ecx
jmp 0x1b1dc
movl $0x1, %ecx
cmpb $0x20, %dl
je 0x1b1dc
movq 0x18(%rbx), %rcx
subq %rcx, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %ecx # imm = 0xAAAAAAAB
addl $0x3, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_psetshortstr | int luaH_psetshortstr (Table *t, TString *key, TValue *val) {
const TValue *slot = luaH_Hgetshortstr(t, key);
if (!ttisnil(slot)) { /* key already has a value? (all too common) */
setobj(((lua_State*)NULL), cast(TValue*, slot), val); /* update it */
return HOK; /* done */
}
else if (checknoTM(t->metatable, TM_NEWINDEX)) { /* no metamethod? */
if (ttisnil(val)) /* new value is nil? */
return HOK; /* done (value is already nil/absent) */
if (isabstkey(slot) && /* key is absent? */
!(isblack(t) && iswhite(key))) { /* and don't need barrier? */
TValue tk; /* key as a TValue */
setsvalue(cast(lua_State *, NULL), &tk, key);
if (insertkey(t, &tk, val)) { /* insert key, if there is space */
invalidateTMcache(t);
return HOK;
}
}
}
/* Else, either table has new-index metamethod, or it needs barrier,
or it needs to rehash for the new key. In any of these cases, the
operation cannot be completed here. Return a code for the caller. */
return retpsetcode(t, slot);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb 0xb(%rdi), %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
andl 0xc(%rsi), %eax
leaq (%rax,%rax,2), %r14
shlq $0x3, %r14
addq 0x18(%rdi), %r14
leaq 0xff4d(%rip), %rax # 0x2b160
cmpb $0x44, 0x9(%r14)
jne 0x1b220
cmpq %rsi, 0x10(%r14)
je 0x1b234
movslq 0xc(%r14), %rcx
leaq (%rcx,%rcx,2), %rdi
leaq (%r14,%rdi,8), %r14
testq %rcx, %rcx
jne 0x1b213
movq %rax, %r14
movb 0x8(%r14), %al
testb $0xf, %al
je 0x1b256
movq (%rdx), %rax
movq %rax, (%r14)
movb 0x8(%rdx), %al
movb %al, 0x8(%r14)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x1b265
testb $0x2, 0xa(%rcx)
je 0x1b2a1
xorl %ebp, %ebp
testb $0xf, 0x8(%rdx)
je 0x1b24b
cmpb $0x20, %al
jne 0x1b2a1
testb $0x20, 0x9(%rbx)
je 0x1b27d
testb $0x18, 0x9(%rsi)
jne 0x1b2a1
movq %rsp, %rax
movq %rsi, (%rax)
movb 0x8(%rsi), %cl
orb $0x40, %cl
movb %cl, 0x8(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1b2c1
testl %eax, %eax
je 0x1b2a1
andb $-0x40, 0xa(%rbx)
jmp 0x1b24b
movl $0x1, %ebp
cmpb $0x20, 0x8(%r14)
je 0x1b24b
subq 0x18(%rbx), %r14
shrq $0x3, %r14
imull $0xaaaaaaab, %r14d, %ebp # imm = 0xAAAAAAAB
addl $0x3, %ebp
jmp 0x1b24b
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
insertkey | static int insertkey (Table *t, const TValue *key, TValue *value) {
Node *mp = mainpositionTV(t, key);
/* table cannot already contain the key */
lua_assert(isabstkey(getgeneric(t, key, 0)));
if (!isempty(gval(mp)) || isdummy(t)) { /* main position is taken? */
Node *othern;
Node *f = getfreepos(t); /* get a free place */
if (f == NULL) /* cannot find a free place? */
return 0;
lua_assert(!isdummy(t));
othern = mainpositionfromnode(t, mp);
if (othern != mp) { /* is colliding node out of its main position? */
/* yes; move colliding node into free position */
while (othern + gnext(othern) != mp) /* find previous */
othern += gnext(othern);
gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */
*f = *mp; /* copy colliding node into free pos. (mp->next also goes) */
if (gnext(mp) != 0) {
gnext(f) += cast_int(mp - f); /* correct 'next' */
gnext(mp) = 0; /* now 'mp' is free */
}
setempty(gval(mp));
}
else { /* colliding node is in its own main position */
/* new node will go into free position */
if (gnext(mp) != 0)
gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */
else lua_assert(gnext(f) == 0);
gnext(mp) = cast_int(f - mp);
mp = f;
}
}
setnodekey(mp, key);
lua_assert(isempty(gval(mp)));
setobj2t(cast(lua_State *, 0), gval(mp), value);
return 1;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x1bca5
movq %rax, %r15
testb $0xf, 0x8(%rax)
jne 0x1b2f1
testb $0x40, 0xa(%r12)
je 0x1b424
movzbl 0xb(%r12), %ecx
cmpq $0x3, %rcx
jb 0x1b31f
movq 0x18(%r12), %rax
movq -0x8(%rax), %rcx
cmpq %rax, %rcx
jbe 0x1b35a
leaq -0x18(%rcx), %rdx
movq %rdx, -0x8(%rax)
cmpb $0x0, -0xf(%rcx)
cmoveq %rdx, %r13
jne 0x1b2fd
jmp 0x1b35d
movl $0x1, %eax
shlq %cl, %rax
leaq (%rax,%rax,2), %rax
leaq -0x18(,%rax,8), %rcx
leaq -0x18(%rcx), %rax
cmpq $-0x30, %rax
je 0x1b354
movq 0x18(%r12), %rdx
cmpb $0x0, 0x9(%rdx,%rcx)
leaq (%rdx,%rcx), %rcx
cmoveq %rcx, %r13
movq %rax, %rcx
jne 0x1b333
cmpq $-0x30, %rax
jne 0x1b35d
xorl %r13d, %r13d
testq %r13, %r13
je 0x1b41f
movq 0x10(%r15), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movb 0x9(%r15), %al
movb %al, 0x8(%rsi)
movq %r12, %rdi
callq 0x1bca5
cmpq %r15, %rax
je 0x1b3e6
movq %rax, %rcx
movslq 0xc(%rax), %rax
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
cmpq %r15, %rax
jne 0x1b384
movq %r13, %rax
subq %rcx, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0xc(%rcx)
movq 0x10(%r15), %rax
movq %rax, 0x10(%r13)
movups (%r15), %xmm0
movups %xmm0, (%r13)
cmpl $0x0, 0xc(%r15)
je 0x1b3df
movq %r15, %rax
subq %r13, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
addl %eax, 0xc(%r13)
movl $0x0, 0xc(%r15)
movb $0x10, 0x8(%r15)
jmp 0x1b41f
movslq 0xc(%r15), %rax
testq %rax, %rax
je 0x1b408
leaq (%rax,%rax,2), %rax
leaq (%r15,%rax,8), %rax
subq %r13, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0xc(%r13)
movq %r13, %rax
subq %r15, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0xc(%r15)
movq %r13, %r15
testq %r13, %r13
je 0x1b447
movq (%r14), %rax
movq %rax, 0x10(%r15)
movb 0x8(%r14), %al
movb %al, 0x9(%r15)
movq (%rbx), %rax
movq %rax, (%r15)
movb 0x8(%rbx), %al
movb %al, 0x8(%r15)
movl $0x1, %eax
jmp 0x1b449
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_psetstr | int luaH_psetstr (Table *t, TString *key, TValue *val) {
if (strisshr(key))
return luaH_psetshortstr(t, key, val);
else
return finishnodeset(t, Hgetlongstr(t, key), val);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpb $0x0, 0xb(%rsi)
js 0x1b47e
movq %rbx, %rdi
movq %r14, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1b1e6
movq %rsp, %rax
movq %rsi, (%rax)
movb 0x8(%rsi), %cl
orb $0x40, %cl
movb %cl, 0x8(%rax)
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1b0d3
movb 0x8(%rax), %cl
testb $0xf, %cl
je 0x1b4b3
movq (%r14), %rcx
movq %rcx, (%rax)
movb 0x8(%r14), %cl
movb %cl, 0x8(%rax)
jmp 0x1b4d1
movl $0x1, %ebp
cmpb $0x20, %cl
je 0x1b4d1
movq 0x18(%rbx), %rcx
subq %rcx, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %ebp # imm = 0xAAAAAAAB
addl $0x3, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_finishset | void luaH_finishset (lua_State *L, Table *t, const TValue *key,
TValue *value, int hres) {
lua_assert(hres != HOK);
if (hres == HNOTFOUND) {
TValue aux;
if (l_unlikely(ttisnil(key)))
luaG_runerror(L, "table index is nil");
else if (ttisfloat(key)) {
lua_Number f = fltvalue(key);
lua_Integer k;
if (luaV_flttointeger(f, &k, F2Ieq)) {
setivalue(&aux, k); /* key is equal to an integer */
key = &aux; /* insert it as an integer */
}
else if (l_unlikely(luai_numisnan(f)))
luaG_runerror(L, "table index is NaN");
}
luaH_newkey(L, t, key, value);
}
else if (hres > 0) { /* regular Node? */
setobj2t(L, gval(gnode(t, hres - HFIRSTNODE)), value);
}
else { /* array entry */
hres = ~hres; /* real index */
obj2arr(t, cast_uint(hres), value);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
cmpl $0x1, %r8d
jne 0x1b67e
movq %rdx, %r12
movq %rdi, %r15
movb 0x8(%rdx), %al
testb $0xf, %al
je 0x1b6e9
cmpb $0x13, %al
jne 0x1b6cc
movsd (%r12), %xmm0
leaq 0x10(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
xorl %esi, %esi
callq 0x1dc39
testl %eax, %eax
je 0x1b6c0
movq 0x10(%rsp), %rax
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movb $0x3, 0x8(%r12)
jmp 0x1b6cc
jl 0x1b69c
movq 0x18(%r14), %rax
movl %r8d, %ecx
leaq (%rcx,%rcx,2), %rcx
movq (%rbx), %rdx
movq %rdx, -0x48(%rax,%rcx,8)
movb 0x8(%rbx), %dl
movb %dl, -0x40(%rax,%rcx,8)
jmp 0x1b6dd
notl %r8d
movb 0x8(%rbx), %al
movq 0x10(%r14), %rcx
movb %al, 0x4(%rcx,%r8)
movq 0x10(%r14), %rax
shlq $0x3, %r8
negq %r8
movq (%rbx), %rcx
movq %rcx, -0x8(%rax,%r8)
jmp 0x1b6dd
movsd 0x8(%rsp), %xmm0
ucomisd %xmm0, %xmm0
jp 0x1b6fa
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1b703
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xfaa7(%rip), %rsi # 0x2b197
movq %r15, %rdi
xorl %eax, %eax
callq 0xa859
leaq 0xfaa9(%rip), %rsi # 0x2b1aa
jmp 0x1b6f0
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_newkey | static void luaH_newkey (lua_State *L, Table *t, const TValue *key,
TValue *value) {
if (!ttisnil(value)) { /* do not insert nil values */
int done = insertkey(t, key, value);
if (!done) { /* could not find a free place? */
rehash(L, t, key); /* grow table */
newcheckedkey(t, key, value); /* insert key in grown table */
}
luaC_barrierback(L, obj2gco(t), key);
/* for debugging only: any new key may force an emergency collection */
condchangemem(L, (void)0, (void)0, 1);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
testb $0xf, 0x8(%rcx)
je 0x1b931
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x1b2c1
testl %eax, %eax
jne 0x1b8ff
movq %r14, (%rsp)
leaq 0x10(%rsp), %r13
xorl %ebp, %ebp
movl $0x88, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x51d0
movl $0x1, -0x4(%r13)
cmpb $0x3, 0x8(%r15)
jne 0x1b776
movq (%r15), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1be04
movb 0xb(%rbx), %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
leaq (%rax,%rax,2), %rax
leaq 0x10(,%rax,8), %r14
leaq 0xc(%rsp), %r13
movq 0x18(%rbx), %rax
testb $0xf, -0x8(%rax,%r14)
je 0x1b7b7
incl %ebp
cmpb $0x3, -0x7(%rax,%r14)
jne 0x1b7bf
movq (%rax,%r14), %rdi
movq %r13, %rsi
callq 0x1be04
jmp 0x1b7bf
movl $0x1, 0x14(%rsp)
addq $-0x18, %r14
cmpq $-0x8, %r14
jne 0x1b793
addl 0xc(%rsp), %ebp
movl %ebp, 0xc(%rsp)
movl 0x10(%rsp), %eax
movl 0xc(%rbx), %edx
testl %eax, %eax
je 0x1b8ca
xorl %esi, %esi
movl $0x1, %edi
xorl %ecx, %ecx
movl $0x1, %r8d
movl %r8d, %r9d
cmpl %edx, %r8d
jbe 0x1b803
movl %edx, %r9d
cmpl %edx, %edi
jbe 0x1b803
xorl %r9d, %r9d
jmp 0x1b859
xorl %r10d, %r10d
cmpl %r9d, %edi
ja 0x1b84e
movq 0x10(%rbx), %r11
leal 0x1(%rdi), %r10d
incl %r9d
cmpl %r9d, %r10d
cmoval %r10d, %r9d
movl %r9d, %r14d
negl %r14d
decl %edi
xorl %r10d, %r10d
movl %edi, %r13d
movb 0x4(%r11,%r13), %r13b
andb $0xf, %r13b
cmpb $0x1, %r13b
sbbl $-0x1, %r10d
leal (%r14,%rdi), %r13d
incl %r13d
incl %edi
cmpl $-0x1, %r13d
jne 0x1b828
movl %r9d, %edi
addl %r10d, 0x18(%rsp,%rsi,4)
addl %r10d, %ecx
movb $0x1, %r9b
testb %r9b, %r9b
je 0x1b86a
incq %rsi
addl %r8d, %r8d
cmpq $0x20, %rsi
jne 0x1b7ef
addl %ecx, %ebp
movl %ebp, 0xc(%rsp)
addl %ecx, %eax
movl %eax, 0x10(%rsp)
leaq (%rax,%rax,2), %rcx
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
xorl %edi, %edi
movq (%rsp), %r14
movl %r8d, %r8d
cmpq %r8, %rcx
jb 0x1b8c4
movl 0x18(%rsp,%rsi,4), %r9d
addl %r9d, %edi
testl %r9d, %r9d
sete %r9b
leaq (%rdi,%rdi,2), %r10
cmpq %r8, %r10
setb %r10b
orb %r9b, %r10b
cmovel %edi, %eax
cmovel %r8d, %edx
incq %rsi
addl %r8d, %r8d
cmpq $0x20, %rsi
jne 0x1b88c
movl %eax, 0x10(%rsp)
jmp 0x1b8ce
movq (%rsp), %r14
movl 0xc(%rsp), %eax
movl 0x14(%rsp), %esi
subl 0x10(%rsp), %eax
movl %eax, %ecx
shrl $0x2, %ecx
testl %esi, %esi
cmovel %esi, %ecx
addl %eax, %ecx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a8a6
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1bc60
testb $0x40, 0x8(%r15)
je 0x1b931
testb $0x20, 0x9(%rbx)
je 0x1b931
movq (%r15), %rax
testb $0x18, 0x9(%rax)
je 0x1b931
movq %r14, %rdi
movq %rbx, %rsi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd62e
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_setint | void luaH_setint (lua_State *L, Table *t, lua_Integer key, TValue *value) {
unsigned ik = ikeyinarray(t, key);
if (ik > 0)
obj2arr(t, ik - 1, value);
else {
int ok = rawfinishnodeset(getintfromhash(t, key), value);
if (!ok) {
TValue k;
setivalue(&k, key);
luaH_newkey(L, t, &k, value);
}
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testl %r14d, %r14d
je 0x1b9e1
movl 0xc(%r15), %eax
leaq -0x1(%r14), %rcx
cmpq %rax, %rcx
jae 0x1b9e1
movb 0x8(%rbx), %al
movq 0x10(%r15), %rcx
decl %r14d
movb %al, 0x4(%rcx,%r14)
movq 0x10(%r15), %rax
shlq $0x3, %r14
negq %r14
movq (%rbx), %rcx
movq %rcx, -0x8(%rax,%r14)
jmp 0x1ba1a
movq %r15, %rdi
movq %r14, %rsi
callq 0x1ae51
cmpb $0x20, 0x8(%rax)
jne 0x1ba0e
leaq 0x8(%rsp), %rdx
movq %r14, (%rdx)
movb $0x3, 0x8(%rdx)
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x1b703
jmp 0x1ba1a
movq (%rbx), %rcx
movq %rcx, (%rax)
movb 0x8(%rbx), %cl
movb %cl, 0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
luaH_getn | lua_Unsigned luaH_getn (Table *t) {
unsigned asize = t->asize;
if (asize > 0) { /* is there an array part? */
const unsigned maxvicinity = 4;
unsigned limit = *lenhint(t); /* start with the hint */
if (limit == 0)
limit = 1; /* make limit a valid index in the array */
if (arraykeyisempty(t, limit)) { /* t[limit] empty? */
/* there must be a border before 'limit' */
unsigned i;
/* look for a border in the vicinity of the hint */
for (i = 0; i < maxvicinity && limit > 1; i++) {
limit--;
if (!arraykeyisempty(t, limit))
return newhint(t, limit); /* 'limit' is a border */
}
/* t[limit] still empty; search for a border in [0, limit) */
return newhint(t, binsearch(t, 0, limit));
}
else { /* 'limit' is present in table; look for a border after it */
unsigned i;
/* look for a border in the vicinity of the hint */
for (i = 0; i < maxvicinity && limit < asize; i++) {
limit++;
if (arraykeyisempty(t, limit))
return newhint(t, limit - 1); /* 'limit - 1' is a border */
}
if (arraykeyisempty(t, asize)) { /* last element empty? */
/* t[limit] not empty; search for a border in [limit, asize) */
return newhint(t, binsearch(t, limit, asize));
}
}
/* last element non empty; set a hint to speed up finding that again */
/* (keys in the hash part cannot be hints) */
*lenhint(t) = asize;
}
/* no array part or t[asize] is not empty; check the hash part */
lua_assert(asize == 0 || !arraykeyisempty(t, asize));
if (isdummy(t) || hashkeyisempty(t, asize + 1))
return asize; /* 'asize + 1' is empty */
else /* 'asize + 1' is also non empty */
return hash_search(t, asize);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %r15d
testq %r15, %r15
je 0x1bb63
movq 0x10(%rbx), %rax
movl (%rax), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovael %edx, %ecx
leal -0x1(%rcx), %esi
testb $0xf, 0x4(%rax,%rsi)
je 0x1baa0
cmpl %r15d, %ecx
jae 0x1ba8e
cmpl $0x2, %edx
movl $0x1, %ecx
cmovael %edx, %ecx
xorl %edx, %edx
movq %rcx, %r14
testb $0xf, 0x4(%rax,%r14)
je 0x1bb34
incq %r14
leal 0x1(%rdx), %esi
cmpq %r15, %r14
jae 0x1ba8c
cmpl $0x3, %edx
movl %esi, %edx
jb 0x1ba6e
addl %esi, %ecx
leal -0x1(%r15), %edx
testb $0xf, 0x4(%rax,%rdx)
je 0x1bb07
movb $0x1, %cl
jmp 0x1bb4e
cmpl $0x2, %edx
setae %sil
jb 0x1bad9
leal -0x2(%rcx), %edi
cmpl $0x3, %edi
movl $0x3, %esi
cmovbl %edi, %esi
addq %rax, %rdx
addq $0x2, %rdx
incl %esi
negl %ecx
testb $0xf, (%rdx)
jne 0x1bb3a
decq %rdx
incl %ecx
decl %esi
jne 0x1bac2
negl %ecx
cmpl $0x2, %ecx
setae %sil
xorl %edx, %edx
testb %sil, %sil
je 0x1bb00
xorl %esi, %esi
leal (%rcx,%rsi), %edx
shrl %edx
leal -0x1(%rdx), %edi
testb $0xf, 0x4(%rax,%rdi)
jne 0x1baf5
movl %edx, %ecx
movl %esi, %edx
movl %ecx, %edi
subl %edx, %edi
movl %edx, %esi
cmpl $0x1, %edi
ja 0x1bae2
movl %edx, (%rax)
movl %edx, %r14d
jmp 0x1bb59
movl %r15d, %edx
subl %ecx, %edx
cmpl $0x2, %edx
jb 0x1bb45
movl %r15d, %edx
leal (%rdx,%rcx), %esi
shrl %esi
leal -0x1(%rsi), %edi
testb $0xf, 0x4(%rax,%rdi)
jne 0x1bb27
movl %esi, %edx
movl %ecx, %esi
movl %edx, %edi
subl %esi, %edi
movl %esi, %ecx
cmpl $0x1, %edi
ja 0x1bb14
jmp 0x1bb47
addl %edx, %ecx
movl %ecx, (%rax)
jmp 0x1bb4c
notl %ecx
movl %ecx, (%rax)
xorl %eax, %eax
movq %rcx, %r14
jmp 0x1bb5b
movl %ecx, %esi
movl %esi, (%rax)
movl %esi, %r14d
xorl %ecx, %ecx
testb %cl, %cl
je 0x1bb59
movl %r15d, (%rax)
movb $0x1, %al
jmp 0x1bb5b
xorl %eax, %eax
testb %al, %al
je 0x1bc51
testb $0x40, 0xa(%rbx)
jne 0x1bc4e
leal 0x1(%r15), %esi
movq %rbx, %rdi
callq 0x1ae51
testb $0xf, 0x8(%rax)
movq %r15, %r14
je 0x1bc51
cmpl $0x1, %r15d
adcl $0x0, %r15d
movq %r15, %r14
movq %r14, %r15
movq %r14, %rax
shrq $0x3e, %rax
jne 0x1bbb4
leaq (%r15,%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ae51
testb $0xf, 0x8(%rax)
jne 0x1bb91
jmp 0x1bc0e
movb 0xb(%rbx), %cl
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
shll %cl, %esi
movabsq $0x7fffffffffffffff, %r14 # imm = 0x7FFFFFFFFFFFFFFF
notl %esi
orl $0x1, %esi
movq %r14, %rax
xorl %edx, %edx
divq %rsi
leaq (%rdx,%rdx,2), %rax
shlq $0x3, %rax
addq 0x18(%rbx), %rax
leaq 0xf578(%rip), %rcx # 0x2b160
cmpb $0x3, 0x9(%rax)
jne 0x1bbf4
cmpq %r14, 0x10(%rax)
je 0x1bc08
movslq 0xc(%rax), %rdx
leaq (%rdx,%rdx,2), %rsi
leaq (%rax,%rsi,8), %rax
testq %rdx, %rdx
jne 0x1bbe8
movq %rcx, %rax
testb $0xf, 0x8(%rax)
jne 0x1bc51
movq %r14, %rax
subq %r15, %rax
cmpq $0x2, %rax
jb 0x1bc4e
movq %r14, %r12
leaq (%r12,%r15), %r14
shrq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ae51
testb $0xf, 0x8(%rax)
je 0x1bc3a
movq %r14, %r15
jmp 0x1bc40
movq %r14, %r12
movq %r15, %r14
movq %r12, %rax
subq %r14, %rax
cmpq $0x1, %rax
ja 0x1bc1d
jmp 0x1bc51
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
newcheckedkey | static void newcheckedkey (Table *t, const TValue *key, TValue *value) {
unsigned i = keyinarray(t, key);
if (i > 0) /* is key in the array part? */
obj2arr(t, i - 1, value); /* set value in the array */
else {
int done = insertkey(t, key, value); /* insert key in the hash part */
lua_assert(done); /* it cannot fail */
cast(void, done); /* to avoid warnings */
}
} | xorl %eax, %eax
cmpb $0x3, 0x8(%rsi)
jne 0x1bc7c
movq (%rsi), %rax
movl 0xc(%rdi), %ecx
leaq -0x1(%rax), %r8
xorl %r9d, %r9d
cmpq %rcx, %r8
cmovael %r9d, %eax
testl %eax, %eax
je 0x1b2c1
movb 0x8(%rdx), %cl
movq 0x10(%rdi), %rsi
decl %eax
movb %cl, 0x4(%rsi,%rax)
movq 0x10(%rdi), %rcx
shlq $0x3, %rax
negq %rax
movq (%rdx), %rdx
movq %rdx, -0x8(%rcx,%rax)
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
mainpositionTV | static Node *mainpositionTV (const Table *t, const TValue *key) {
switch (ttypetag(key)) {
case LUA_VNUMINT: {
lua_Integer i = ivalue(key);
return hashint(t, i);
}
case LUA_VNUMFLT: {
lua_Number n = fltvalue(key);
return hashmod(t, l_hashfloat(n));
}
case LUA_VSHRSTR: {
TString *ts = tsvalue(key);
return hashstr(t, ts);
}
case LUA_VLNGSTR: {
TString *ts = tsvalue(key);
return hashpow2(t, luaS_hashlongstr(ts));
}
case LUA_VFALSE:
return hashboolean(t, 0);
case LUA_VTRUE:
return hashboolean(t, 1);
case LUA_VLIGHTUSERDATA: {
void *p = pvalue(key);
return hashpointer(t, p);
}
case LUA_VLCF: {
lua_CFunction f = fvalue(key);
return hashpointer(t, f);
}
default: {
GCObject *o = gcvalue(key);
return hashpointer(t, o);
}
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl 0x8(%rsi), %eax
andl $0x3f, %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
jbe 0x1bce8
addl $-0x11, %eax
cmpl $0x5, %eax
ja 0x1bd01
leaq 0xf47e(%rip), %rcx # 0x2b148
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
cmpb $0x0, 0xb(%rbx)
setne %al
leaq (%rax,%rax,2), %rax
shll $0x3, %eax
jmp 0x1bdda
leaq 0xf449(%rip), %rax # 0x2b138
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x18(%rbx), %rax
jmp 0x1bdde
movb 0xb(%rbx), %cl
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
shll %cl, %edi
movl (%rsi), %eax
notl %edi
orl $0x1, %edi
xorl %edx, %edx
divl %edi
leaq (%rdx,%rdx,2), %rax
jmp 0x1bdd6
movq (%rsi), %rdi
movq 0x18(%rbx), %r14
callq 0x16ecb
movb 0xb(%rbx), %cl
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
shll %cl, %edx
notl %edx
andl %eax, %edx
jmp 0x1bd92
movsd (%rsi), %xmm0
movq 0x18(%rbx), %r14
leaq 0x4(%rsp), %rdi
callq 0x5560
mulsd 0xf3db(%rip), %xmm0 # 0x2b130
xorl %eax, %eax
ucomisd 0xe101(%rip), %xmm0 # 0x29e60
jb 0x1bd7f
movsd 0xe0ff(%rip), %xmm1 # 0x29e68
ucomisd %xmm0, %xmm1
jbe 0x1bd7f
cvttsd2si %xmm0, %rcx
addl 0x4(%rsp), %ecx
movl %ecx, %eax
sarl $0x1f, %eax
xorl %ecx, %eax
movb 0xb(%rbx), %cl
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
shll %cl, %esi
notl %esi
orl $0x1, %esi
xorl %edx, %edx
divl %esi
leaq (%rdx,%rdx,2), %rax
leaq (%r14,%rax,8), %rax
jmp 0x1bdde
movq (%rsi), %rax
movq 0x18(%rbx), %rsi
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
ja 0x1bde6
movb 0xb(%rbx), %cl
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
shll %cl, %edi
notl %edi
orl $0x1, %edi
xorl %edx, %edx
divl %edi
jmp 0x1bdfa
movb 0xb(%rbx), %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
shll %cl, %eax
movq (%rsi), %rcx
notl %eax
andl 0xc(%rcx), %eax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x18(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb 0xb(%rbx), %cl
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
shll %cl, %edi
notl %edi
orl $0x1, %edi
xorl %edx, %edx
divq %rdi
leaq (%rdx,%rdx,2), %rax
leaq (%rsi,%rax,8), %rax
jmp 0x1bdde
| /mmanyen[P]CLua/build_O1/_deps/lua/ltable.c |
tconcat | static int tconcat (lua_State *L) {
luaL_Buffer b;
lua_Integer last = aux_getn(L, 1, TAB_R);
size_t lsep;
const char *sep = luaL_optlstring(L, 2, "", &lsep);
lua_Integer i = luaL_optinteger(L, 3, 1);
last = luaL_optinteger(L, 4, last);
luaL_buffinit(L, &b);
for (; i < last; i++) {
addfield(L, &b, i);
luaL_addlstring(&b, sep, lsep);
}
if (i == last) /* add last value (if interval was not empty) */
addfield(L, &b, i);
luaL_pushresult(&b);
return 1;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x430, %rsp # imm = 0x430
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x1c549
movq %rbx, %rdi
movl $0x1, %esi
callq 0x974b
movq %rax, %r12
leaq 0xe349(%rip), %rdx # 0x2a1f7
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8da3
movq %rax, %r15
movl $0x1, %edx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8fb7
movq %rax, %r14
movq %rbx, %rdi
movl $0x4, %esi
movq %r12, %rdx
callq 0x8fb7
movq %rax, %r12
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x8517
cmpq %r12, %r14
jge 0x1bf2b
leaq 0x10(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1c634
movq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0x913a
incq %r14
cmpq %r14, %r12
jne 0x1bf02
movq %r12, %r14
cmpq %r12, %r14
jne 0x1bf40
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1c634
leaq 0x10(%rsp), %rdi
callq 0x85e7
movl $0x1, %eax
addq $0x430, %rsp # imm = 0x430
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltablib.c |
tcreate | static int tcreate (lua_State *L) {
lua_Unsigned sizeseq = (lua_Unsigned)luaL_checkinteger(L, 1);
lua_Unsigned sizerest = (lua_Unsigned)luaL_optinteger(L, 2, 0);
luaL_argcheck(L, sizeseq <= cast_uint(INT_MAX), 1, "out of range");
luaL_argcheck(L, sizerest <= cast_uint(INT_MAX), 2, "out of range");
lua_createtable(L, cast_int(sizeseq), cast_int(sizerest));
return 1;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x80000000, %r12d # imm = 0x80000000
movl $0x1, %esi
callq 0x8f2d
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x8fb7
movq %rax, %r15
testq $-0x80000000, %r14 # imm = 0x80000000
jne 0x1bfbd
cmpq %r12, %r15
jae 0x1bfd3
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x7355
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xf986(%rip), %rdx # 0x2b94a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x86ba
jmp 0x1bf99
leaq 0xf970(%rip), %rdx # 0x2b94a
movq %rbx, %rdi
movl $0x2, %esi
callq 0x86ba
jmp 0x1bf9e
| /mmanyen[P]CLua/build_O1/_deps/lua/ltablib.c |
tinsert | static int tinsert (lua_State *L) {
lua_Integer pos; /* where to insert new element */
lua_Integer e = aux_getn(L, 1, TAB_RW);
e = luaL_intop(+, e, 1); /* first empty element */
switch (lua_gettop(L)) {
case 2: { /* called with only 2 arguments */
pos = e; /* insert new element at the end */
break;
}
case 3: {
lua_Integer i;
pos = luaL_checkinteger(L, 2); /* 2nd argument is the position */
/* check whether 'pos' is in [1, e] */
luaL_argcheck(L, (lua_Unsigned)pos - 1u < (lua_Unsigned)e, 2,
"position out of bounds");
for (i = e; i > pos; i--) { /* move up elements */
lua_geti(L, 1, i - 1);
lua_seti(L, 1, i); /* t[i] = t[i - 1] */
}
break;
}
default: {
return luaL_error(L, "wrong number of arguments to 'insert'");
}
}
lua_seti(L, 1, pos); /* t[pos] = v */
return 0;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x7, %edx
callq 0x1c549
movq %rbx, %rdi
movl $0x1, %esi
callq 0x974b
movq %rax, %r14
leaq 0x1(%rax), %r15
movq %rbx, %rdi
callq 0x663a
cmpl $0x2, %eax
je 0x1c079
cmpl $0x3, %eax
jne 0x1c097
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8f2d
movq %rax, %r12
decq %rax
cmpq %r15, %rax
jae 0x1c0b3
cmpq %r12, %r15
jle 0x1c076
leaq 0x1(%r14), %r15
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x71c5
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x75f9
leaq -0x1(%r14), %rax
cmpq %r12, %r14
movq %rax, %r14
jg 0x1c046
movq %r12, %r15
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x75f9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xf18e(%rip), %rsi # 0x2b22c
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x87c6
leaq 0xf651(%rip), %rdx # 0x2b70b
movq %rbx, %rdi
movl $0x2, %esi
callq 0x86ba
jmp 0x1c041
| /mmanyen[P]CLua/build_O1/_deps/lua/ltablib.c |
tpack | static int tpack (lua_State *L) {
int i;
int n = lua_gettop(L); /* number of elements to pack */
lua_createtable(L, n, 1); /* create result table */
lua_insert(L, 1); /* put it at index 1 */
for (i = n; i >= 1; i--) /* assign elements */
lua_seti(L, 1, i);
lua_pushinteger(L, n);
lua_setfield(L, 1, "n"); /* t.n = number of elements */
return 1; /* return table */
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x663a
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x7355
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x66f8
testl %ebp, %ebp
jle 0x1c11f
movl %ebp, %r14d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x75f9
leaq -0x1(%r14), %rax
cmpq $0x1, %r14
movq %rax, %r14
jg 0x1c102
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x6d91
leaq 0xd02e(%rip), %rdx # 0x2915f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x75d5
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltablib.c |
tunpack | static int tunpack (lua_State *L) {
lua_Unsigned n;
lua_Integer i = luaL_optinteger(L, 2, 1);
lua_Integer e = luaL_opt(L, luaL_checkinteger, 3, luaL_len(L, 1));
if (i > e) return 0; /* empty range */
n = l_castS2U(e) - l_castS2U(i); /* number of elements minus 1 */
if (l_unlikely(n >= (unsigned int)INT_MAX ||
!lua_checkstack(L, (int)(++n))))
return luaL_error(L, "too many results to unpack");
for (; i < e; i++) { /* push arg[i..e - 1] (to avoid overflows) */
lua_geti(L, 1, i);
}
lua_geti(L, 1, e); /* push last element */
return (int)n;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edx
movl $0x2, %esi
callq 0x8fb7
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x68d4
movq %rbx, %rdi
testl %eax, %eax
jle 0x1c185
movl $0x3, %esi
callq 0x8f2d
jmp 0x1c18f
movl $0x1, %esi
callq 0x974b
movq %rax, %r15
xorl %eax, %eax
movq %r15, %r12
subq %r14, %r12
jl 0x1c1ee
movb $0x1, %al
cmpq $0x7ffffffe, %r12 # imm = 0x7FFFFFFE
ja 0x1c1ba
incq %r12
movq %rbx, %rdi
movl %r12d, %esi
callq 0x656c
testl %eax, %eax
sete %al
testb %al, %al
jne 0x1c1fa
cmpq %r14, %r15
jle 0x1c1db
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x71c5
incq %r14
cmpq %r14, %r15
jne 0x1c1c3
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x71c5
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xf051(%rip), %rsi # 0x2b252
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x87c6
| /mmanyen[P]CLua/build_O1/_deps/lua/ltablib.c |
tmove | static int tmove (lua_State *L) {
lua_Integer f = luaL_checkinteger(L, 2);
lua_Integer e = luaL_checkinteger(L, 3);
lua_Integer t = luaL_checkinteger(L, 4);
int tt = !lua_isnoneornil(L, 5) ? 5 : 1; /* destination table */
checktab(L, 1, TAB_R);
checktab(L, tt, TAB_W);
if (e >= f) { /* otherwise, nothing to move */
lua_Integer n, i;
luaL_argcheck(L, f > 0 || e < LUA_MAXINTEGER + f, 3,
"too many elements to move");
n = e - f + 1; /* number of elements to move */
luaL_argcheck(L, t <= LUA_MAXINTEGER - n + 1, 4,
"destination wrap around");
if (t > e || t <= f || (tt != 1 && !lua_compare(L, 1, tt, LUA_OPEQ))) {
for (i = 0; i < n; i++) {
lua_geti(L, 1, f + i);
lua_seti(L, tt, t + i);
}
}
else {
for (i = n - 1; i >= 0; i--) {
lua_geti(L, 1, f + i);
lua_seti(L, tt, t + i);
}
}
}
lua_pushvalue(L, tt); /* return destination table */
return 1;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x2, %esi
callq 0x8f2d
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8f2d
movq %rax, %r14
movq %rbx, %rdi
movl $0x4, %esi
callq 0x8f2d
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x68d4
movl %eax, %r13d
xorl %eax, %eax
testl %r13d, %r13d
setg %al
leal 0x1(,%rax,4), %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x1c549
movq %rbx, %rdi
movl %ebp, %esi
movl $0x2, %edx
callq 0x1c549
movq %r14, %rdx
subq %r15, %rdx
jl 0x1c453
movl %r13d, 0x14(%rsp)
movabsq $0x7fffffffffffffff, %r13 # imm = 0x7FFFFFFFFFFFFFFF
testq %r15, %r15
setg %al
leaq (%r15,%r13), %rcx
cmpq %rcx, %r14
setl %cl
orb %al, %cl
je 0x1c471
subq %rdx, %r13
cmpq %r13, %r12
jg 0x1c494
cmpq %r14, %r12
setle %al
movq %r12, %r13
subq %r15, %r13
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1c423
cmpl $0x0, 0x14(%rsp)
jle 0x1c3e6
movq %rbx, %rdi
movl $0x1, %esi
movq %rdx, 0x8(%rsp)
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x6a1e
movq 0x8(%rsp), %rdx
testl %eax, %eax
je 0x1c423
testq %rdx, %rdx
js 0x1c453
movl $0x1, %r12d
subq %r15, %r12
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x71c5
leaq (%r14,%r13), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x75f9
leaq (%r12,%r14), %rax
decq %rax
decq %r14
testq %rax, %rax
jg 0x1c3f4
jmp 0x1c453
testq %rdx, %rdx
js 0x1c453
incq %r14
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x71c5
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x75f9
incq %r15
incq %r12
cmpq %r15, %r14
jne 0x1c42b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x68aa
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, 0x8(%rsp)
leaq 0xedf0(%rip), %rdx # 0x2b26d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x86ba
movq 0x8(%rsp), %rdx
jmp 0x1c39e
movq %rdx, %r13
leaq 0xede9(%rip), %rdx # 0x2b287
movq %rbx, %rdi
movl $0x4, %esi
callq 0x86ba
movq %r13, %rdx
jmp 0x1c3aa
| /mmanyen[P]CLua/build_O1/_deps/lua/ltablib.c |
sort | static int sort (lua_State *L) {
lua_Integer n = aux_getn(L, 1, TAB_RW);
if (n > 1) { /* non-trivial interval? */
luaL_argcheck(L, n < INT_MAX, 1, "array too big");
if (!lua_isnoneornil(L, 2)) /* is there a 2nd argument? */
luaL_checktype(L, 2, LUA_TFUNCTION); /* must be a function */
lua_settop(L, 2); /* make sure there are two arguments */
auxsort(L, 1, (IdxT)n, 0);
}
return 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x7, %edx
callq 0x1c549
movq %rbx, %rdi
movl $0x1, %esi
callq 0x974b
cmpq $0x2, %rax
jl 0x1c529
movq %rax, %r14
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
jge 0x1c533
movq %rbx, %rdi
movl $0x2, %esi
callq 0x68d4
testl %eax, %eax
jle 0x1c50a
movq %rbx, %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x8e50
movq %rbx, %rdi
movl $0x2, %esi
callq 0x664e
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x1c677
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xed65(%rip), %rdx # 0x2b29f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x86ba
jmp 0x1c4e7
| /mmanyen[P]CLua/build_O1/_deps/lua/ltablib.c |
checktab | static void checktab (lua_State *L, int arg, int what) {
if (lua_type(L, arg) != LUA_TTABLE) { /* is it not a table? */
int n = 1; /* number of elements to pop */
if (lua_getmetatable(L, arg) && /* must have metatable */
(!(what & TAB_R) || checkfield(L, "__index", ++n)) &&
(!(what & TAB_W) || checkfield(L, "__newindex", ++n)) &&
(!(what & TAB_L) || checkfield(L, "__len", ++n))) {
lua_pop(L, n); /* pop metatable and tested metamethods */
}
else
luaL_checktype(L, arg, LUA_TTABLE); /* force an error */
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x68d4
cmpl $0x5, %eax
jne 0x1c56d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %ebp, %esi
callq 0x73b1
testl %eax, %eax
je 0x1c61b
movl $0x1, %r15d
testb $0x1, %r14b
je 0x1c5b1
leaq 0xd82c(%rip), %rsi # 0x29dbe
movq %rbx, %rdi
callq 0x6e5b
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x7262
movl $0x2, %r15d
testl %eax, %eax
je 0x1c61b
testb $0x2, %r14b
je 0x1c5da
leaq 0xec28(%rip), %rsi # 0x2b1e6
movq %rbx, %rdi
callq 0x6e5b
movl %r15d, %esi
notl %esi
movq %rbx, %rdi
callq 0x7262
testl %eax, %eax
je 0x1c61b
incl %r15d
testb $0x4, %r14b
je 0x1c603
leaq 0xec0a(%rip), %rsi # 0x2b1f1
movq %rbx, %rdi
callq 0x6e5b
movl %r15d, %esi
notl %esi
movq %rbx, %rdi
callq 0x7262
testl %eax, %eax
je 0x1c61b
incl %r15d
notl %r15d
movq %rbx, %rdi
movl %r15d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x664e
movq %rbx, %rdi
movl %ebp, %esi
movl $0x5, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8e50
| /mmanyen[P]CLua/build_O1/_deps/lua/ltablib.c |
auxsort | static void auxsort (lua_State *L, IdxT lo, IdxT up, unsigned rnd) {
while (lo < up) { /* loop for tail recursion */
IdxT p; /* Pivot index */
IdxT n; /* to be used later */
/* sort elements 'lo', 'p', and 'up' */
geti(L, 1, lo);
geti(L, 1, up);
if (sort_comp(L, -1, -2)) /* a[up] < a[lo]? */
set2(L, lo, up); /* swap a[lo] - a[up] */
else
lua_pop(L, 2); /* remove both values */
if (up - lo == 1) /* only 2 elements? */
return; /* already sorted */
if (up - lo < RANLIMIT || rnd == 0) /* small interval or no randomize? */
p = (lo + up)/2; /* middle element is a good pivot */
else /* for larger intervals, it is worth a random pivot */
p = choosePivot(lo, up, rnd);
geti(L, 1, p);
geti(L, 1, lo);
if (sort_comp(L, -2, -1)) /* a[p] < a[lo]? */
set2(L, p, lo); /* swap a[p] - a[lo] */
else {
lua_pop(L, 1); /* remove a[lo] */
geti(L, 1, up);
if (sort_comp(L, -1, -2)) /* a[up] < a[p]? */
set2(L, p, up); /* swap a[up] - a[p] */
else
lua_pop(L, 2);
}
if (up - lo == 2) /* only 3 elements? */
return; /* already sorted */
geti(L, 1, p); /* get middle element (Pivot) */
lua_pushvalue(L, -1); /* push Pivot */
geti(L, 1, up - 1); /* push a[up - 1] */
set2(L, p, up - 1); /* swap Pivot (a[p]) with a[up - 1] */
p = partition(L, lo, up);
/* a[lo .. p - 1] <= a[p] == P <= a[p + 1 .. up] */
if (p - lo < up - p) { /* lower interval is smaller? */
auxsort(L, lo, p - 1, rnd); /* call recursively for lower interval */
n = p - lo; /* size of smaller interval */
lo = p + 1; /* tail call for [p + 1 .. up] (upper interval) */
}
else {
auxsort(L, p + 1, up, rnd); /* call recursively for upper interval */
n = up - p; /* size of smaller interval */
up = p - 1; /* tail call for [lo .. p - 1] (lower interval) */
}
if ((up - lo) / 128 > n) /* partition too imbalanced? */
rnd = l_randomizePivot(L); /* try a new randomization */
} /* tail call auxsort(L, lo, up, rnd) */
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r15d
movl %edx, %r14d
movl %esi, %r13d
movq %rdi, %rbx
movl %r14d, %ebp
subl %r13d, %ebp
jbe 0x1ca31
movl %r13d, %r12d
movq %rbx, %rdi
movl $0x1, %esi
movq %r12, %rdx
callq 0x71c5
movq %r14, 0x8(%rsp)
movl %r14d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x71c5
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx # imm = 0xFFFFFFFE
callq 0x1ca40
movq %rbx, %rdi
testl %eax, %eax
je 0x1c700
movl $0x1, %esi
movq %r12, %rdx
callq 0x75f9
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x75f9
jmp 0x1c70a
movl $0xfffffffd, %esi # imm = 0xFFFFFFFD
callq 0x664e
cmpl $0x1, %ebp
jne 0x1c716
xorl %ebp, %ebp
jmp 0x1ca12
cmpl $0x64, %ebp
setb %al
testl %r15d, %r15d
sete %cl
orb %al, %cl
cmpb $0x1, %cl
movq %r13, 0x18(%rsp)
jne 0x1c73b
movq 0x8(%rsp), %rax
leal (%rax,%r13), %ecx
shrl %ecx
jmp 0x1c757
movl %ebp, %ecx
shrl $0x2, %ecx
movq 0x8(%rsp), %rax
xorl %r13d, %eax
xorl %r15d, %eax
leal (%rcx,%rcx), %esi
xorl %edx, %edx
divl %esi
addl %r13d, %ecx
addl %edx, %ecx
movl %ecx, %r13d
movq %rbx, %rdi
movl $0x1, %esi
movq %r13, %rdx
callq 0x71c5
movq %rbx, %rdi
movl $0x1, %esi
movq %r12, %rdx
callq 0x71c5
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x1ca40
movq %rbx, %rdi
testl %eax, %eax
je 0x1c7ad
movl $0x1, %esi
movq %r13, %rdx
callq 0x75f9
movq %rbx, %rdi
movl $0x1, %esi
movq %r12, %rdx
jmp 0x1c7fc
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x71c5
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx # imm = 0xFFFFFFFE
callq 0x1ca40
movq %rbx, %rdi
testl %eax, %eax
je 0x1ca22
movl $0x1, %esi
movq %r13, %rdx
callq 0x75f9
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x75f9
cmpl $0x2, %ebp
jne 0x1c812
xorl %ebp, %ebp
movq 0x18(%rsp), %r13
jmp 0x1ca12
movl %r15d, 0x14(%rsp)
movq %rbx, %rdi
movl $0x1, %esi
movq %r13, %rdx
callq 0x71c5
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x68aa
movq 0x8(%rsp), %rax
leal -0x1(%rax), %r14d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x71c5
movq %r14, %rbp
movq 0x18(%rsp), %r12
movq %r14, 0x20(%rsp)
movq %rbx, %rdi
movl $0x1, %esi
movq %r13, %rdx
callq 0x75f9
movq %rbx, %rdi
movl $0x1, %esi
movq %rbp, %rdx
callq 0x75f9
leal 0x1(%r12), %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x71c5
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx # imm = 0xFFFFFFFE
callq 0x1ca40
movq %r15, %r13
testl %eax, %eax
je 0x1c90a
addl $0x2, %r12d
movq 0x8(%rsp), %r15
cmpl %r12d, %r15d
je 0x1c8f1
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
movl %r12d, %r13d
movq %rbx, %rdi
movl $0x1, %esi
movq %r13, %rdx
callq 0x71c5
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx # imm = 0xFFFFFFFE
callq 0x1ca40
incl %r12d
testl %eax, %eax
jne 0x1c8b1
jmp 0x1c904
movq %rbx, %rdi
leaq 0xe9b2(%rip), %rsi # 0x2b2ad
xorl %eax, %eax
callq 0x87c6
jmp 0x1c8b6
decl %r12d
movl %r12d, %r15d
decl %r14d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x71c5
movq %rbx, %rdi
movl $0xfffffffd, %esi # imm = 0xFFFFFFFD
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x1ca40
testl %eax, %eax
je 0x1c95a
cmpl %r15d, %r14d
jb 0x1c947
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
jmp 0x1c90a
movq %rbx, %rdi
leaq 0xe95c(%rip), %rsi # 0x2b2ad
xorl %eax, %eax
callq 0x87c6
jmp 0x1c938
movq %r14, %rbp
movl %r15d, %r12d
cmpl %r15d, %r14d
jae 0x1c85a
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
movq %rbx, %rdi
movl $0x1, %esi
movq 0x20(%rsp), %rdx
callq 0x75f9
movq %rbx, %rdi
movl $0x1, %esi
movq %r13, %rdx
callq 0x75f9
movl %r15d, %r14d
movq 0x18(%rsp), %r13
subl %r13d, %r14d
movq 0x8(%rsp), %r12
movl %r12d, %ebp
subl %r15d, %ebp
cmpl %ebp, %r14d
jae 0x1c9ce
leal -0x1(%r15), %edx
movq %rbx, %rdi
movl %r13d, %esi
movl 0x14(%rsp), %ecx
callq 0x1c677
incl %r15d
movl %r15d, %r13d
jmp 0x1c9ea
leal 0x1(%r15), %esi
movq %rbx, %rdi
movl %r12d, %edx
movl 0x14(%rsp), %ecx
callq 0x1c677
decl %r15d
movl %r15d, %r12d
movl %ebp, %r14d
movq %r12, 0x8(%rsp)
movl %r12d, %eax
subl %r13d, %eax
shrl $0x7, %eax
movb $0x1, %bpl
cmpl %r14d, %eax
jbe 0x1ca0d
movq %rbx, %rdi
callq 0x9c2f
movl %eax, %r15d
jmp 0x1ca12
movl 0x14(%rsp), %r15d
testb %bpl, %bpl
movq 0x8(%rsp), %r14
jne 0x1c691
jmp 0x1ca31
movl $0xfffffffd, %esi # imm = 0xFFFFFFFD
callq 0x664e
jmp 0x1c801
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltablib.c |
sort_comp | static int sort_comp (lua_State *L, int a, int b) {
if (lua_isnil(L, 2)) /* no function? */
return lua_compare(L, a, b, LUA_OPLT); /* a < b */
else { /* function */
int res;
lua_pushvalue(L, 2); /* push function */
lua_pushvalue(L, a-1); /* -1 to compensate function */
lua_pushvalue(L, b-2); /* -2 to compensate function and 'a' */
lua_call(L, 2, 1); /* call function */
res = lua_toboolean(L, -1); /* get result */
lua_pop(L, 1); /* pop result */
return res;
}
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl $0x2, %esi
callq 0x68d4
testl %eax, %eax
je 0x1cabc
movq %rbx, %rdi
movl $0x2, %esi
callq 0x68aa
decl %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x68aa
addl $-0x2, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x68aa
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x78e1
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x6b9e
movl %eax, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x664e
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl $0x1, %ecx
popq %rbx
popq %r14
popq %rbp
jmp 0x6a1e
nop
| /mmanyen[P]CLua/build_O1/_deps/lua/ltablib.c |
luaT_init | void luaT_init (lua_State *L) {
static const char *const luaT_eventname[] = { /* ORDER TM */
"__index", "__newindex",
"__gc", "__mode", "__len", "__eq",
"__add", "__sub", "__mul", "__mod", "__pow",
"__div", "__idiv",
"__band", "__bor", "__bxor", "__shl", "__shr",
"__unm", "__bnot", "__lt", "__le",
"__concat", "__call", "__close"
};
int i;
for (i=0; i<TM_N; i++) {
G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
luaC_fix(L, obj2gco(G(L)->tmname[i])); /* never collect these names */
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0xe88e(%rip), %r15 # 0x2b374
movslq (%r14,%r15), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x1734a
movq 0x18(%rbx), %rcx
movq %rax, 0x110(%rcx,%r14,2)
movq 0x18(%rbx), %rax
movq 0x110(%rax,%r14,2), %rsi
movq %rbx, %rdi
callq 0xd6c7
addq $0x4, %r14
cmpq $0x64, %r14
jne 0x1cae6
popq %rbx
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltm.c |
luaT_gettmbyobj | const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
Table *mt;
switch (ttype(o)) {
case LUA_TTABLE:
mt = hvalue(o)->metatable;
break;
case LUA_TUSERDATA:
mt = uvalue(o)->metatable;
break;
default:
mt = G(L)->mt[ttype(o)];
}
return (mt ? luaH_Hgetshortstr(mt, G(L)->tmname[event]) : &G(L)->nilvalue);
} | movzbl 0x8(%rsi), %eax
andl $0xf, %eax
cmpq $0x7, %rax
je 0x1cb6b
cmpl $0x5, %eax
jne 0x1cb74
movq (%rsi), %rax
addq $0x20, %rax
jmp 0x1cb82
movq (%rsi), %rax
addq $0x18, %rax
jmp 0x1cb82
movq 0x18(%rdi), %rcx
leaq (%rcx,%rax,8), %rax
addq $0x1d8, %rax # imm = 0x1D8
movq (%rax), %rcx
movq 0x18(%rdi), %rax
testq %rcx, %rcx
je 0x1cba0
movl %edx, %edx
movq 0x110(%rax,%rdx,8), %rsi
movq %rcx, %rdi
jmp 0x1aebc
addq $0x50, %rax
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltm.c |
luaT_objtypename | const char *luaT_objtypename (lua_State *L, const TValue *o) {
Table *mt;
if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) ||
(ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) {
const TValue *name = luaH_Hgetshortstr(mt, luaS_new(L, "__name"));
if (ttisstring(name)) /* is '__name' a string? */
return getstr(tsvalue(name)); /* use it as type name */
}
return ttypename(ttype(o)); /* else use standard type name */
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movzbl 0x8(%rsi), %eax
cmpl $0x47, %eax
je 0x1cbca
cmpl $0x45, %eax
jne 0x1cc10
movq (%rbx), %rcx
movq 0x20(%rcx), %r14
testq %r14, %r14
jne 0x1cbd6
cmpb $0x47, %al
jne 0x1cc10
movq (%rbx), %rax
movq 0x18(%rax), %r14
testq %r14, %r14
je 0x1cc10
leaq 0xc91b(%rip), %rsi # 0x294f8
callq 0x1734a
movq %r14, %rdi
movq %rax, %rsi
callq 0x1aebc
movq %rax, %rcx
movb 0x8(%rax), %dl
andb $0xf, %dl
cmpb $0x4, %dl
jne 0x1cc0b
movq (%rcx), %rcx
leaq 0x18(%rcx), %rax
cmpb $0x0, 0xb(%rcx)
jns 0x1cc0b
movq (%rax), %rax
cmpb $0x4, %dl
je 0x1cc23
movzbl 0x8(%rbx), %eax
andl $0xf, %eax
leaq 0x1c902(%rip), %rcx # 0x39520
movq 0x8(%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltm.c |
luaT_callTM | void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
const TValue *p2, const TValue *p3) {
StkId func = L->top.p;
setobj2s(L, func, f); /* push function (assume EXTRA_STACK) */
setobj2s(L, func + 1, p1); /* 1st argument */
setobj2s(L, func + 2, p2); /* 2nd argument */
setobj2s(L, func + 3, p3); /* 3rd argument */
L->top.p = func + 4;
/* metamethod may yield only when called from Lua code */
if (isLuacode(L->ci))
luaD_call(L, func, 0);
else
luaD_callnoyield(L, func, 0);
} | movq %rsi, %rax
movq 0x10(%rdi), %rsi
movq (%rax), %r9
movq %r9, (%rsi)
movb 0x8(%rax), %al
movb %al, 0x8(%rsi)
movq (%rdx), %rax
movq %rax, 0x10(%rsi)
movb 0x8(%rdx), %al
movb %al, 0x18(%rsi)
movq (%rcx), %rax
movq %rax, 0x20(%rsi)
movb 0x8(%rcx), %al
movb %al, 0x28(%rsi)
movq (%r8), %rax
movq %rax, 0x30(%rsi)
movb 0x8(%r8), %al
movb %al, 0x38(%rsi)
leaq 0x40(%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x20(%rdi), %rax
movzwl 0x3d(%rax), %eax
xorl %edx, %edx
testl $0x1080, %eax # imm = 0x1080
jne 0xbf7d
jmp 0xbf14
| /mmanyen[P]CLua/build_O1/_deps/lua/ltm.c |
luaT_callTMres | lu_byte luaT_callTMres (lua_State *L, const TValue *f, const TValue *p1,
const TValue *p2, StkId res) {
ptrdiff_t result = savestack(L, res);
StkId func = L->top.p;
setobj2s(L, func, f); /* push function (assume EXTRA_STACK) */
setobj2s(L, func + 1, p1); /* 1st argument */
setobj2s(L, func + 2, p2); /* 2nd argument */
L->top.p += 3;
/* metamethod may yield only when called from Lua code */
if (isLuacode(L->ci))
luaD_call(L, func, 1);
else
luaD_callnoyield(L, func, 1);
res = restorestack(L, result);
setobjs2s(L, res, --L->top.p); /* move result to its place */
return ttypetag(s2v(res)); /* return tag of the result */
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq 0x30(%rdi), %r15
movq (%rax), %rdi
movq %rdi, (%rsi)
movb 0x8(%rax), %al
movb %al, 0x8(%rsi)
movq (%rdx), %rax
movq %rax, 0x10(%rsi)
movb 0x8(%rdx), %al
movb %al, 0x18(%rsi)
movq (%rcx), %rax
movq %rax, 0x20(%rsi)
movb 0x8(%rcx), %al
movb %al, 0x28(%rsi)
addq $0x30, 0x10(%rbx)
movq %r8, %r14
movq 0x20(%rbx), %rax
movzwl 0x3d(%rax), %eax
movq %rbx, %rdi
movl $0x1, %edx
testl $0x1080, %eax # imm = 0x1080
je 0x1cce7
callq 0xbf7d
jmp 0x1ccec
callq 0xbf14
subq %r15, %r14
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %rcx
leaq -0x10(%rax), %rdx
movq %rdx, 0x10(%rbx)
movq -0x10(%rax), %rdx
movq %rdx, (%rcx,%r14)
movb -0x8(%rax), %al
movb %al, 0x8(%rcx,%r14)
andb $0x3f, %al
popq %rbx
popq %r14
popq %r15
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltm.c |
luaT_trybinTM | void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
StkId res, TMS event) {
if (l_unlikely(callbinTM(L, p1, p2, res, event) < 0)) {
switch (event) {
case TM_BAND: case TM_BOR: case TM_BXOR:
case TM_SHL: case TM_SHR: case TM_BNOT: {
if (ttisnumber(p1) && ttisnumber(p2))
luaG_tointerror(L, p1, p2);
else
luaG_opinterror(L, p1, p2, "perform bitwise operation on");
}
/* calls never return, but to avoid warnings: *//* FALLTHROUGH */
default:
luaG_opinterror(L, p1, p2, "perform arithmetic on");
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1cd4e
testl %eax, %eax
js 0x1cd3e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x5aef
| /mmanyen[P]CLua/build_O1/_deps/lua/ltm.c |
callbinTM | static int callbinTM (lua_State *L, const TValue *p1, const TValue *p2,
StkId res, TMS event) {
const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */
if (notm(tm))
tm = luaT_gettmbyobj(L, p2, event); /* try second operand */
if (notm(tm))
return -1; /* tag method not found */
else /* call tag method and return the tag of the result */
return luaT_callTMres(L, tm, p1, p2, res);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl %r8d, %edx
callq 0x1cb50
testb $0xf, 0x8(%rax)
jne 0x1cd80
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1cb50
testb $0xf, 0x8(%rax)
je 0x1cd9f
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x1cc88
movzbl %al, %eax
jmp 0x1cda4
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltm.c |
luaT_callorderTM | int luaT_callorderTM (lua_State *L, const TValue *p1, const TValue *p2,
TMS event) {
int tag = callbinTM(L, p1, p2, L->top.p, event); /* try original event */
if (tag >= 0) /* found tag method? */
return !tagisfalse(tag);
#if defined(LUA_COMPAT_LT_LE)
else if (event == TM_LE) {
/* try '!(p2 < p1)' for '(p1 <= p2)' */
L->ci->callstatus |= CIST_LEQ; /* mark it is doing 'lt' for 'le' */
tag = callbinTM(L, p2, p1, L->top.p, TM_LT);
L->ci->callstatus ^= CIST_LEQ; /* clear mark */
if (tag >= 0) /* found tag method? */
return tagisfalse(tag);
}
#endif
luaG_ordererror(L, p1, p2); /* no metamethod found */
return 0; /* to avoid warnings */
} | pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %r8d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rcx
callq 0x1cd4e
testl %eax, %eax
js 0x1ce5b
cmpl $0x1, %eax
setne %cl
testb $0xf, %al
setne %al
andb %cl, %al
movzbl %al, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa9e1
| /mmanyen[P]CLua/build_O1/_deps/lua/ltm.c |
luaT_callorderiTM | int luaT_callorderiTM (lua_State *L, const TValue *p1, int v2,
int flip, int isfloat, TMS event) {
TValue aux; const TValue *p2;
if (isfloat) {
setfltvalue(&aux, cast_num(v2));
}
else
setivalue(&aux, v2);
if (flip) { /* arguments were exchanged? */
p2 = p1; p1 = &aux; /* correct them */
}
else
p2 = &aux;
return luaT_callorderTM(L, p1, p2, event);
} | testl %r8d, %r8d
setne %r8b
je 0x1ce78
cvtsi2sd %edx, %xmm0
jmp 0x1ce80
movslq %edx, %rax
movq %rax, %xmm0
subq $0x18, %rsp
shlb $0x4, %r8b
orb $0x3, %r8b
leaq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
movb %r8b, 0x8(%rax)
testl %ecx, %ecx
movq %rsi, %rdx
cmoveq %rax, %rdx
cmoveq %rsi, %rax
movq %rax, %rsi
movl %r9d, %ecx
callq 0x1ce27
addq $0x18, %rsp
retq
| /mmanyen[P]CLua/build_O1/_deps/lua/ltm.c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.