name string | code string | asm string | file string |
|---|---|---|---|
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 + ... | 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
mo... | /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 '!' */
}
el... | 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... | /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 'ret... | 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 0... | /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);... | 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 = 0xF... | /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", st... | 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 0x6... | /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? */
retu... | 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... | /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_pushfs... | 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, %rd... | /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, lin... | 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 *%r... | /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... | /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,
"%... | 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
cal... | /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.to... | 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
... | /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(... | 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
j... | /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... | 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, %e... | /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)... | 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... | /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 %eb... | /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 */
... | 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)... | /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;... | 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... | /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... | 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... | /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);
pr... | 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 # 0x2a... | /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(f... | 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(%... | /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);... | 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
le... | /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 nex... | 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, 0x1... | /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_... | 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 %r1... | /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 *... | 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(%... | /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_newliter... | 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 ... | /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(ge... | 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),... | /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 'fall... | 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, ... | 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
p... | /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 */
fo... | 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... | /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 = S... | 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... | /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 - ... | 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
ne... | /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 ... | 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... | /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);
s... | 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... | /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)
... | 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)... | /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 = (GMatchSt... | 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
... | /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 */
... | 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, %e... | /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)))
... | 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(%rs... | /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 ... | /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, %r1... | /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, &si... | 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)
j... | /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... | 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 0x913... | /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 anyth... | 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(%... | /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
j... | /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 ... | 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)
... | /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_unlike... | 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),... | /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))... | 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 0x... | /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) ... | 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 %r... | /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 */
... | 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... | /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... | 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 ... | /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': *s... | 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... | /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 ... | /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... | 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, %e... | /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
ca... | /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? */
setiva... | 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, %e... | /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 ap... | 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
m... | /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_ceill... | 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 %c... | /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; /* ... | 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, %... | /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, %r... | /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 ... | /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);
i... | 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,%rd... | /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);
i... | 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,%rd... | /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 0x... | /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;... | 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 ... | /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... | 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 0x1b1... | /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... | /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->meta... | 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... | /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); /... | 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 %ra... | /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,... | /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_Nu... | 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 0x1dc... | /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 t... | 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... | /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),... | /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,... | 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
mov... | /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);... | 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 (%r... | /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: {
... | 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 ... | /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)... | 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 0... | /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_createt... | 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
ja... | /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 */
... | 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... | /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,... | 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(%r1... | /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_MA... | 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, %... | /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... | 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... | /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_setto... | 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
mov... | /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)... | 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 0x1... | /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]? ... | 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 %... | /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-... | 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
m... | /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", "_... | 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,... | /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_Hgets... | 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
te... | /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... | 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 ... | /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 */
setobj... | 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 0x... | /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... | 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)... | /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) && tt... | 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 meth... | 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,... | /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) {
/* ... | 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... | /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; /* c... | 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
ca... | /mmanyen[P]CLua/build_O1/_deps/lua/ltm.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.