LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: getbinopr
static BinOpr getbinopr(int op){
switch(op){
case'+':return OPR_ADD;
case'-':return OPR_SUB;
case'*':return OPR_MUL;
case'/':return OPR_DIV;
case'%':return OPR_MOD;
case'^':return OPR_POW;
case TK_CONCAT:return OPR_CONCAT;
case TK_NE:return OPR_NE;
case TK_EQ:return OPR_EQ;
case'<':return OPR_LT;
case TK_LE:return OPR_LE;
case'>':return OPR_GT;
case TK_GE:return OPR_GE;
case TK_AND:return OPR_AND;
case TK_OR:return OPR_OR;
default:return OPR_NOBINOPR;
}
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
subl $0x25, %eax
je 0x15a53
jmp 0x15947
movl -0xc(%rsp), %eax
subl $0x2a, %eax
je 0x15a3c
jmp 0x15956
movl -0xc(%rsp), %eax
subl $0x2b, %eax
je 0x15a22
jmp 0x15965
movl -0xc(%rsp), %eax
subl $0x2d, %eax
je 0x15a2f
jmp 0x15974
movl -0xc(%rsp), %eax
subl $0x2f, %eax
je 0x15a49
jmp 0x15983
movl -0xc(%rsp), %eax
subl $0x3c, %eax
je 0x15a85
jmp 0x15992
movl -0xc(%rsp), %eax
subl $0x3e, %eax
je 0x15a99
jmp 0x159a1
movl -0xc(%rsp), %eax
subl $0x5e, %eax
je 0x15a5d
jmp 0x159b0
movl -0xc(%rsp), %eax
subl $0x101, %eax            # imm = 0x101
je 0x15aad
jmp 0x159c1
movl -0xc(%rsp), %eax
subl $0x10f, %eax            # imm = 0x10F
je 0x15ab7
jmp 0x159d2
movl -0xc(%rsp), %eax
subl $0x116, %eax            # imm = 0x116
je 0x15a67
jmp 0x159e3
movl -0xc(%rsp), %eax
subl $0x118, %eax            # imm = 0x118
je 0x15a7b
jmp 0x159f4
movl -0xc(%rsp), %eax
subl $0x119, %eax            # imm = 0x119
je 0x15aa3
jmp 0x15a05
movl -0xc(%rsp), %eax
subl $0x11a, %eax            # imm = 0x11A
je 0x15a8f
jmp 0x15a12
movl -0xc(%rsp), %eax
subl $0x11b, %eax            # imm = 0x11B
je 0x15a71
jmp 0x15ac1
movl $0x0, -0x4(%rsp)
jmp 0x15ac9
movl $0x1, -0x4(%rsp)
jmp 0x15ac9
movl $0x2, -0x4(%rsp)
jmp 0x15ac9
movl $0x3, -0x4(%rsp)
jmp 0x15ac9
movl $0x4, -0x4(%rsp)
jmp 0x15ac9
movl $0x5, -0x4(%rsp)
jmp 0x15ac9
movl $0x6, -0x4(%rsp)
jmp 0x15ac9
movl $0x7, -0x4(%rsp)
jmp 0x15ac9
movl $0x8, -0x4(%rsp)
jmp 0x15ac9
movl $0x9, -0x4(%rsp)
jmp 0x15ac9
movl $0xa, -0x4(%rsp)
jmp 0x15ac9
movl $0xb, -0x4(%rsp)
jmp 0x15ac9
movl $0xc, -0x4(%rsp)
jmp 0x15ac9
movl $0xd, -0x4(%rsp)
jmp 0x15ac9
movl $0xe, -0x4(%rsp)
jmp 0x15ac9
movl $0xf, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_infix
static void luaK_infix(FuncState*fs,BinOpr op,expdesc*v){
switch(op){
case OPR_AND:{
luaK_goiftrue(fs,v);
break;
}
case OPR_OR:{
luaK_goiffalse(fs,v);
break;
}
case OPR_CONCAT:{
luaK_exp2nextreg(fs,v);
break;
}
case OPR_ADD:case OPR_SUB:case OPR_MUL:case OPR_DIV:
case OPR_MOD:case OPR_POW:{
if(!isnumeral(v))luaK_exp2RK(fs,v);
break;
}
default:{
luaK_exp2RK(fs,v);
break;
}
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0xe, %rax
ja 0x15b59
movq 0x8(%rsp), %rax
leaq 0xc75f(%rip), %rcx      # 0x2225c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x153f0
jmp 0x15b68
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x191e0
jmp 0x15b68
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x16470
jmp 0x15b68
movq 0x10(%rsp), %rdi
callq 0x15eb0
cmpl $0x0, %eax
jne 0x15b57
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x17410
jmp 0x15b68
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x17410
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_exp2anyreg
static int luaK_exp2anyreg(FuncState*fs,expdesc*e){
luaK_dischargevars(fs,e);
if(e->k==VNONRELOC){
if(!hasjumps(e))return e->u.s.info;
if(e->u.s.info>=fs->nactvar){
exp2reg(fs,e,e->u.s.info);
return e->u.s.info;
}
}
luaK_exp2nextreg(fs,e);
return e->u.s.info;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x161b0
movq (%rsp), %rax
cmpl $0xc, (%rax)
jne 0x15f69
movq (%rsp), %rax
movl 0x10(%rax), %eax
movq (%rsp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x15f31
movq (%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x15f82
movq (%rsp), %rax
movl 0x8(%rax), %eax
movq 0x8(%rsp), %rcx
movzbl 0x4a(%rcx), %ecx
cmpl %ecx, %eax
jl 0x15f67
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq (%rsp), %rax
movl 0x8(%rax), %edx
callq 0x162e0
movq (%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x15f82
jmp 0x15f69
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x16470
movq (%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: codearith
static void codearith(FuncState*fs,OpCode op,expdesc*e1,expdesc*e2){
if(constfolding(op,e1,e2))
return;
else{
int o2=(op!=OP_UNM&&op!=OP_LEN)?luaK_exp2RK(fs,e2):0;
int o1=luaK_exp2RK(fs,e1);
if(o1>o2){
freeexp(fs,e1);
freeexp(fs,e2);
}
else{
freeexp(fs,e2);
freeexp(fs,e1);
}
e1->u.s.info=luaK_codeABC(fs,op,0,o1,o2);
e1->k=VRELOCABLE;
}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl 0x2c(%rsp), %edi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x17210
cmpl $0x0, %eax
je 0x15fc4
jmp 0x16080
cmpl $0x12, 0x2c(%rsp)
je 0x15fe7
cmpl $0x14, 0x2c(%rsp)
je 0x15fe7
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x17410
movl %eax, 0xc(%rsp)
jmp 0x15fef
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x15fef
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x17410
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jle 0x16034
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x17140
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x17140
jmp 0x16052
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x17140
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x17140
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x10(%rsp), %ecx
movl 0x14(%rsp), %r8d
xorl %edx, %edx
callq 0x164d0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rax
movl $0xb, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: codenot
static void codenot(FuncState*fs,expdesc*e){
luaK_dischargevars(fs,e);
switch(e->k){
case VNIL:case VFALSE:{
e->k=VTRUE;
break;
}
case VK:case VKNUM:case VTRUE:{
e->k=VFALSE;
break;
}
case VJMP:{
invertjump(fs,e);
break;
}
case VRELOCABLE:
case VNONRELOC:{
discharge2anyreg(fs,e);
freeexp(fs,e);
e->u.s.info=luaK_codeABC(fs,OP_NOT,0,e->u.s.info,0);
e->k=VRELOCABLE;
break;
}
default:{
break;
}
}
{int temp=e->f;e->f=e->t;e->t=temp;}
removevalues(fs,e->f);
removevalues(fs,e->t);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x161b0
movq 0x18(%rsp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0xb, %eax
ja 0x16158
movq 0x8(%rsp), %rax
leaq 0xc202(%rip), %rcx      # 0x222d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rax
movl $0x2, (%rax)
jmp 0x1615a
movq 0x18(%rsp), %rax
movl $0x3, (%rax)
jmp 0x1615a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x17650
jmp 0x1615a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x176b0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x17140
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
movl $0x13, %esi
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x164d0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl $0xb, (%rax)
jmp 0x1615a
jmp 0x1615a
movq 0x18(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x14(%rax)
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x14(%rax), %esi
callq 0x17700
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x17700
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_dischargevars
static void luaK_dischargevars(FuncState*fs,expdesc*e){
switch(e->k){
case VLOCAL:{
e->k=VNONRELOC;
break;
}
case VUPVAL:{
e->u.s.info=luaK_codeABC(fs,OP_GETUPVAL,0,e->u.s.info,0);
e->k=VRELOCABLE;
break;
}
case VGLOBAL:{
e->u.s.info=luaK_codeABx(fs,OP_GETGLOBAL,0,e->u.s.info);
e->k=VRELOCABLE;
break;
}
case VINDEXED:{
freereg(fs,e->u.s.aux);
freereg(fs,e->u.s.info);
e->u.s.info=luaK_codeABC(fs,OP_GETTABLE,0,e->u.s.info,e->u.s.aux);
e->k=VRELOCABLE;
break;
}
case VVARARG:
case VCALL:{
luaK_setoneret(fs,e);
break;
}
default:break;
}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
addl $-0x6, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x8, %eax
ja 0x162d0
movq (%rsp), %rax
leaq 0xc122(%rip), %rcx      # 0x22304
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rax
movl $0xc, (%rax)
jmp 0x162d2
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movl $0x4, %esi
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x164d0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0xb, (%rax)
jmp 0x162d2
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movl $0x5, %esi
xorl %edx, %edx
callq 0x16530
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0xb, (%rax)
jmp 0x162d2
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %esi
callq 0x16580
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x16580
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl 0xc(%rax), %r8d
movl $0x6, %esi
xorl %edx, %edx
callq 0x164d0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0xb, (%rax)
jmp 0x162d2
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x165c0
jmp 0x162d2
jmp 0x162d2
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: exp2reg
static void exp2reg(FuncState*fs,expdesc*e,int reg){
discharge2reg(fs,e,reg);
if(e->k==VJMP)
luaK_concat(fs,&e->t,e->u.s.info);
if(hasjumps(e)){
int final;
int p_f=(-1);
int p_t=(-1);
if(need_value(fs,e->t)||need_value(fs,e->f)){
int fj=(e->k==VJMP)?(-1):luaK_jump(fs);
p_f=code_label(fs,reg,0,1);
p_t=code_label(fs,reg,1,0);
luaK_patchtohere(fs,fj);
}
final=luaK_getlabel(fs);
patchlistaux(fs,e->f,final,reg,p_f);
patchlistaux(fs,e->t,final,reg,p_t);
}
e->f=e->t=(-1);
e->u.s.info=reg;
e->k=VNONRELOC;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0x16ba0
movq 0x18(%rsp), %rax
cmpl $0xa, (%rax)
jne 0x1632a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x10, %rsi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %edx
callq 0x15220
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x14(%rcx), %eax
je 0x16432
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x16d20
cmpl $0x0, %eax
jne 0x1637e
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x14(%rax), %esi
callq 0x16d20
cmpl $0x0, %eax
je 0x163e6
movq 0x18(%rsp), %rax
cmpl $0xa, (%rax)
jne 0x16392
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rsp)
jmp 0x1639f
movq 0x20(%rsp), %rdi
callq 0x152a0
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x16d90
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x16d90
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x15300
movq 0x20(%rsp), %rdi
callq 0x16dd0
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x14(%rax), %esi
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
movl 0xc(%rsp), %r8d
callq 0x168d0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x10(%rax), %esi
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
movl 0x8(%rsp), %r8d
callq 0x168d0
movq 0x18(%rsp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl $0xc, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_exp2nextreg
static void luaK_exp2nextreg(FuncState*fs,expdesc*e){
luaK_dischargevars(fs,e);
freeexp(fs,e);
luaK_reserveregs(fs,1);
exp2reg(fs,e,fs->freereg-1);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x161b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x17140
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x17170
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movl 0x3c(%rax), %edx
subl $0x1, %edx
callq 0x162e0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_setoneret
static void luaK_setoneret(FuncState*fs,expdesc*e){
if(e->k==VCALL){
e->k=VNONRELOC;
e->u.s.info=GETARG_A(getcode(fs,e));
}
else if(e->k==VVARARG){
SETARG_B(getcode(fs,e),2);
e->k=VRELOCABLE;
}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpl $0xd, (%rax)
jne 0x1660a
movq -0x10(%rsp), %rax
movl $0xc, (%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %ecx
shrl $0x6, %ecx
andl $0xff, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
jmp 0x1665d
movq -0x10(%rsp), %rax
cmpl $0xe, (%rax)
jne 0x1665b
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
orl $0x1000000, %edx        # imm = 0x1000000
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rsp), %rax
movl $0xb, (%rax)
jmp 0x1665d
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_code
static int luaK_code(FuncState*fs,Instruction i,int line){
Proto*f=fs->f;
dischargejpc(fs);
luaM_growvector(fs->L,f->code,fs->pc,f->sizecode,Instruction,
(INT_MAX-2),"code size overflow");
f->code[fs->pc]=i;
luaM_growvector(fs->L,f->lineinfo,fs->pc,f->sizelineinfo,int,
(INT_MAX-2),"code size overflow");
f->lineinfo[fs->pc]=line;
return fs->pc++;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x16770
movq 0x10(%rsp), %rax
movl 0x30(%rax), %eax
addl $0x1, %eax
movq (%rsp), %rcx
cmpl 0x50(%rcx), %eax
jle 0x166d6
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
movq (%rsp), %rdx
addq $0x50, %rdx
movl $0x4, %ecx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
leaq 0xc64c(%rip), %r9       # 0x22d12
callq 0x167b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0xc(%rsp), %edx
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
movl 0x30(%rax), %eax
addl $0x1, %eax
movq (%rsp), %rcx
cmpl 0x54(%rcx), %eax
jle 0x1673d
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rsp), %rax
movq 0x28(%rax), %rsi
movq (%rsp), %rdx
addq $0x54, %rdx
movl $0x4, %ecx
movl $0x7ffffffd, %r8d       # imm = 0x7FFFFFFD
leaq 0xc5e5(%rip), %r9       # 0x22d12
callq 0x167b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movl 0x8(%rsp), %edx
movq (%rsp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x30(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsp), %rcx
movl 0x30(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x30(%rcx)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaM_growaux_
static void*luaM_growaux_(lua_State*L,void*block,int*size,size_t size_elems,
int limit,const char*errormsg){
void*newblock;
int newsize;
if(*size>=limit/2){
if(*size>=limit)
luaG_runerror(L,errormsg);
newsize=limit;
}
else{
newsize=(*size)*2;
if(newsize<4)
newsize=4;
}
newblock=luaM_reallocv(L,block,*size,newsize,size_elems);
*size=newsize;
return newblock;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq %r9, 0x28(%rsp)
movq 0x40(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x18(%rsp)
movl 0x34(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x18(%rsp), %eax
cmpl %ecx, %eax
jl 0x1681b
movq 0x40(%rsp), %rax
movl (%rax), %eax
cmpl 0x34(%rsp), %eax
jl 0x16811
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rsi
movb $0x0, %al
callq 0x54a0
movl 0x34(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x16839
movq 0x40(%rsp), %rax
movl (%rax), %eax
shll %eax
movl %eax, 0x1c(%rsp)
cmpl $0x4, 0x1c(%rsp)
jge 0x16837
movl $0x4, 0x1c(%rsp)
jmp 0x16839
movl 0x1c(%rsp), %eax
addl $0x1, %eax
cltq
movq %rax, 0x10(%rsp)
movq $-0x3, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x38(%rsp)
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
ja 0x16893
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rax
movslq (%rax), %rdx
imulq 0x38(%rsp), %rdx
movslq 0x1c(%rsp), %rcx
imulq 0x38(%rsp), %rcx
callq 0x4b30
movq %rax, 0x8(%rsp)
jmp 0x168a2
movq 0x50(%rsp), %rdi
callq 0x5480
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: patchlistaux
static void patchlistaux(FuncState*fs,int list,int vtarget,int reg,
int dtarget){
while(list!=(-1)){
int next=getjump(fs,list);
if(patchtestreg(fs,list,reg))
fixjump(fs,list,vtarget);
else
fixjump(fs,list,dtarget);
list=next;
}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
cmpl $-0x1, 0x1c(%rsp)
je 0x1694a
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x16950
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x169b0
cmpl $0x0, %eax
je 0x1692e
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x16a80
jmp 0x16940
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x16a80
movl 0xc(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x168ea
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: getjump
static int getjump(FuncState*fs,int pc){
int offset=GETARG_sBx(fs->f->code[pc]);
if(offset==(-1))
return(-1);
else
return(pc+1)+offset;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0xe, %eax
andl $0x3ffff, %eax          # imm = 0x3FFFF
subl $0x1ffff, %eax          # imm = 0x1FFFF
movl %eax, -0x18(%rsp)
cmpl $-0x1, -0x18(%rsp)
jne 0x1698f
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1699e
movl -0x14(%rsp), %eax
addl $0x1, %eax
addl -0x18(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: patchtestreg
static int patchtestreg(FuncState*fs,int node,int reg){
Instruction*i=getjumpcontrol(fs,node);
if(GET_OPCODE(*i)!=OP_TESTSET)
return 0;
if(reg!=((1<<8)-1)&&reg!=GETARG_B(*i))
SETARG_A(*i,reg);
else
*i=CREATE_ABC(OP_TEST,GETARG_B(*i),0,GETARG_C(*i));
return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x16b20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
shrl $0x0, %eax
andl $0x3f, %eax
cmpl $0x1b, %eax
je 0x169f3
movl $0x0, 0x24(%rsp)
jmp 0x16a75
cmpl $0xff, 0x10(%rsp)
je 0x16a39
movl 0x10(%rsp), %eax
movq 0x8(%rsp), %rcx
movl (%rcx), %ecx
shrl $0x17, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
cmpl %ecx, %eax
je 0x16a39
movq 0x8(%rsp), %rax
movl (%rax), %ecx
andl $0xffffc03f, %ecx       # imm = 0xFFFFC03F
movl 0x10(%rsp), %eax
shll $0x6, %eax
andl $0x3fc0, %eax           # imm = 0x3FC0
orl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
jmp 0x16a6d
movq 0x8(%rsp), %rax
movl (%rax), %ecx
shrl $0x17, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
shll $0x6, %ecx
orl $0x1a, %ecx
orl $0x0, %ecx
movq 0x8(%rsp), %rax
movl (%rax), %eax
shrl $0xe, %eax
andl $0x1ff, %eax            # imm = 0x1FF
shll $0xe, %eax
orl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: fixjump
static void fixjump(FuncState*fs,int pc,int dest){
Instruction*jmp=&fs->f->code[pc];
int offset=dest-(pc+1);
if(abs(offset)>(((1<<(9+9))-1)>>1))
luaX_syntaxerror(fs->ls,"control structure too long");
SETARG_sBx(*jmp,offset);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
subl %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0x1ffff, %eax          # imm = 0x1FFFF
jle 0x16ae6
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0xc244(%rip), %rsi      # 0x22d25
callq 0x14360
movq 0x10(%rsp), %rax
movl (%rax), %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
movl 0xc(%rsp), %eax
addl $0x1ffff, %eax          # imm = 0x1FFFF
shll $0xe, %eax
andl $0xffffc000, %eax       # imm = 0xFFFFC000
orl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: getjumpcontrol
static Instruction*getjumpcontrol(FuncState*fs,int pc){
Instruction*pi=&fs->f->code[pc];
if(pc>=1&&testTMode(GET_OPCODE(*(pi-1))))
return pi-1;
else
return pi;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
cmpl $0x1, -0x14(%rsp)
jl 0x16b84
movq -0x20(%rsp), %rax
movl -0x4(%rax), %eax
shrl $0x0, %eax
andl $0x3f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xbbca(%rip), %rax      # 0x22730
movzbl (%rax,%rcx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x16b84
movq -0x20(%rsp), %rax
addq $-0x4, %rax
movq %rax, -0x8(%rsp)
jmp 0x16b8e
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: discharge2reg
static void discharge2reg(FuncState*fs,expdesc*e,int reg){
luaK_dischargevars(fs,e);
switch(e->k){
case VNIL:{
luaK_nil(fs,reg,1);
break;
}
case VFALSE:case VTRUE:{
luaK_codeABC(fs,OP_LOADBOOL,reg,e->k==VTRUE,0);
break;
}
case VK:{
luaK_codeABx(fs,OP_LOADK,reg,e->u.s.info);
break;
}
case VKNUM:{
luaK_codeABx(fs,OP_LOADK,reg,luaK_numberK(fs,e->u.nval));
break;
}
case VRELOCABLE:{
Instruction*pc=&getcode(fs,e);
SETARG_A(*pc,reg);
break;
}
case VNONRELOC:{
if(reg!=e->u.s.info)
luaK_codeABC(fs,OP_MOVE,reg,e->u.s.info,0);
break;
}
default:{
return;
}
}
e->u.s.info=reg;
e->k=VNONRELOC;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x161b0
movq 0x28(%rsp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0xb, %eax
ja 0x16cfe
movq 0x10(%rsp), %rax
leaq 0xb742(%rip), %rcx      # 0x22328
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x1, %edx
callq 0x16df0
jmp 0x16d00
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %edx
movq 0x28(%rsp), %rax
cmpl $0x2, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %ecx
movl $0x2, %esi
xorl %r8d, %r8d
callq 0x164d0
jmp 0x16d00
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %edx
movq 0x28(%rsp), %rax
movl 0x8(%rax), %ecx
movl $0x1, %esi
callq 0x16530
jmp 0x16d00
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movsd 0x8(%rax), %xmm0
callq 0x16f20
movq (%rsp), %rdi
movl 0xc(%rsp), %edx
movl %eax, %ecx
movl $0x1, %esi
callq 0x16530
jmp 0x16d00
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x28(%rsp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %ecx
andl $0xffffc03f, %ecx       # imm = 0xFFFFC03F
movl 0x24(%rsp), %eax
shll $0x6, %eax
andl $0x3fc0, %eax           # imm = 0x3FC0
orl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x16d00
movl 0x24(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0x16cfc
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %edx
movq 0x28(%rsp), %rax
movl 0x8(%rax), %ecx
xorl %r8d, %r8d
movl %r8d, %esi
callq 0x164d0
jmp 0x16d00
jmp 0x16d17
movl 0x24(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movl $0xc, (%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: need_value
static int need_value(FuncState*fs,int list){
for(;list!=(-1);list=getjump(fs,list)){
Instruction i=*getjumpcontrol(fs,list);
if(GET_OPCODE(i)!=OP_TESTSET)return 1;
}
return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
je 0x16d75
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x16b20
movl (%rax), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
shrl $0x0, %eax
andl $0x3f, %eax
cmpl $0x1b, %eax
je 0x16d5f
movl $0x1, 0x14(%rsp)
jmp 0x16d7d
jmp 0x16d61
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x16950
movl %eax, 0x4(%rsp)
jmp 0x16d2d
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_nil
static void luaK_nil(FuncState*fs,int from,int n){
Instruction*previous;
if(fs->pc>fs->lasttarget){
if(fs->pc==0){
if(from>=fs->nactvar)
return;
}
else{
previous=&fs->f->code[fs->pc-1];
if(GET_OPCODE(*previous)==OP_LOADNIL){
int pfrom=GETARG_A(*previous);
int pto=GETARG_B(*previous);
if(pfrom<=from&&from<=pto+1){
if(from+n-1>pto)
SETARG_B(*previous,from+n-1);
return;
}
}
}
}
luaK_codeABC(fs,OP_LOADNIL,from,from+n-1,0);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl 0x30(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0x34(%rcx), %eax
jle 0x16ef6
movq 0x20(%rsp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x16e3d
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
movzbl 0x4a(%rcx), %ecx
cmpl %ecx, %eax
jl 0x16e38
jmp 0x16f17
jmp 0x16ef4
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x20(%rsp), %rcx
movl 0x30(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
shrl $0x0, %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jne 0x16ef2
movq 0x10(%rsp), %rax
movl (%rax), %eax
shrl $0x6, %eax
andl $0xff, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
shrl $0x17, %eax
andl $0x1ff, %eax            # imm = 0x1FF
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jg 0x16ef0
movl 0x1c(%rsp), %eax
movl 0x8(%rsp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jg 0x16ef0
movl 0x1c(%rsp), %eax
addl 0x18(%rsp), %eax
subl $0x1, %eax
cmpl 0x8(%rsp), %eax
jle 0x16eee
movq 0x10(%rsp), %rax
movl (%rax), %ecx
andl $0x7fffff, %ecx         # imm = 0x7FFFFF
movl 0x1c(%rsp), %eax
addl 0x18(%rsp), %eax
subl $0x1, %eax
shll $0x17, %eax
andl $0xff800000, %eax       # imm = 0xFF800000
orl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
jmp 0x16f17
jmp 0x16ef2
jmp 0x16ef4
jmp 0x16ef6
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl 0x1c(%rsp), %ecx
addl 0x18(%rsp), %ecx
subl $0x1, %ecx
movl $0x3, %esi
xorl %r8d, %r8d
callq 0x164d0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: addk
static int addk(FuncState*fs,TValue*k,TValue*v){
lua_State*L=fs->L;
TValue*idx=luaH_set(L,fs->h,k);
Proto*f=fs->f;
int oldsize=f->sizek;
if(ttisnumber(idx)){
return cast_int(nvalue(idx));
}
else{
setnvalue(idx,cast_num(fs->nk));
luaM_growvector(L,f->k,fs->nk,f->sizek,TValue,
((1<<(9+9))-1),"constant table overflow");
while(oldsize<f->sizek)setnilvalue(&f->k[oldsize++]);
setobj(L,&f->k[fs->nk],v);
luaC_barrier(L,f,v);
return fs->nk++;
}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x40(%rsp), %rdx
callq 0xbee0
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x4c(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x3, 0x8(%rax)
jne 0x16fe4
movq 0x28(%rsp), %rax
cvttsd2si (%rax), %eax
movl %eax, 0x54(%rsp)
jmp 0x17135
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
cvtsi2sdl 0x40(%rax), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rax
movl $0x3, 0x8(%rax)
movq 0x48(%rsp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movq 0x20(%rsp), %rcx
cmpl 0x4c(%rcx), %eax
jle 0x1705c
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x20(%rsp), %rdx
addq $0x4c, %rdx
movl $0x10, %ecx
movl $0x3ffff, %r8d          # imm = 0x3FFFF
leaq 0xbcf5(%rip), %r9       # 0x22d40
callq 0x167b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1705e
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x4c(%rcx), %eax
jge 0x17095
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x1c(%rsp)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
jmp 0x1705e
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rsp), %rcx
movslq 0x40(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x38(%rsp), %rax
cmpl $0x4, 0x8(%rax)
jl 0x17121
movq 0x38(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x17121
movq 0x20(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x17121
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rax
movq (%rax), %rdx
callq 0x5150
movq 0x48(%rsp), %rcx
movl 0x40(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x40(%rcx)
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_checkstack
static void luaK_checkstack(FuncState*fs,int n){
int newstack=fs->freereg+n;
if(newstack>fs->f->maxstacksize){
if(newstack>=250)
luaX_syntaxerror(fs->ls,"function or expression too complex");
fs->f->maxstacksize=cast_byte(newstack);
}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0x3c(%rax), %eax
addl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movzbl 0x73(%rcx), %ecx
cmpl %ecx, %eax
jle 0x17201
cmpl $0xfa, 0x8(%rsp)
jl 0x171f0
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0xbb6d(%rip), %rsi      # 0x22d58
callq 0x14360
movl 0x8(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movq (%rax), %rax
movb %cl, 0x73(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: constfolding
static int constfolding(OpCode op,expdesc*e1,expdesc*e2){
lua_Number v1,v2,r;
if(!isnumeral(e1)||!isnumeral(e2))return 0;
v1=e1->u.nval;
v2=e2->u.nval;
switch(op){
case OP_ADD:r=luai_numadd(v1,v2);break;
case OP_SUB:r=luai_numsub(v1,v2);break;
case OP_MUL:r=luai_nummul(v1,v2);break;
case OP_DIV:
if(v2==0)return 0;
r=luai_numdiv(v1,v2);break;
case OP_MOD:
if(v2==0)return 0;
r=luai_nummod(v1,v2);break;
case OP_POW:r=luai_numpow(v1,v2);break;
case OP_UNM:r=luai_numunm(v1);break;
case OP_LEN:return 0;
default:r=0;break;
}
if(luai_numisnan(r))return 0;
e1->u.nval=r;
return 1;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x15eb0
cmpl $0x0, %eax
je 0x17240
movq 0x30(%rsp), %rdi
callq 0x15eb0
cmpl $0x0, %eax
jne 0x1724d
movl $0x0, 0x44(%rsp)
jmp 0x17406
movq 0x38(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x40(%rsp), %eax
addl $-0xc, %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x8, %eax
ja 0x173c9
movq 0x10(%rsp), %rax
leaq 0xb0c8(%rip), %rcx      # 0x22358
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0x28(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x173d2
movsd 0x28(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x173d2
movsd 0x28(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x173d2
movsd 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x172fc
jp 0x172fc
movl $0x0, 0x44(%rsp)
jmp 0x17406
movsd 0x28(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x173d2
movsd 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x17331
jp 0x17331
movl $0x0, 0x44(%rsp)
jmp 0x17406
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
callq 0x3260
movsd 0x8(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x173d2
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x30d0
movsd %xmm0, 0x18(%rsp)
jmp 0x173d2
movsd 0x28(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x173d2
movl $0x0, 0x44(%rsp)
jmp 0x17406
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
ucomisd 0x18(%rsp), %xmm0
jne 0x173e4
jp 0x173e4
jmp 0x173ee
movl $0x0, 0x44(%rsp)
jmp 0x17406
movsd 0x18(%rsp), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_exp2RK
static int luaK_exp2RK(FuncState*fs,expdesc*e){
luaK_exp2val(fs,e);
switch(e->k){
case VKNUM:
case VTRUE:
case VFALSE:
case VNIL:{
if(fs->nk<=((1<<(9-1))-1)){
e->u.s.info=(e->k==VNIL)?nilK(fs):
(e->k==VKNUM)?luaK_numberK(fs,e->u.nval):
boolK(fs,(e->k==VTRUE));
e->k=VK;
return RKASK(e->u.s.info);
}
else break;
}
case VK:{
if(e->u.s.info<=((1<<(9-1))-1))
return RKASK(e->u.s.info);
else break;
}
default:break;
}
return luaK_exp2anyreg(fs,e);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x17550
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
decl %eax
subl $0x3, %eax
jb 0x1745f
jmp 0x17441
movl 0xc(%rsp), %eax
subl $0x4, %eax
je 0x17501
jmp 0x17450
movl 0xc(%rsp), %eax
subl $0x5, %eax
jne 0x17524
jmp 0x1745f
movq 0x18(%rsp), %rax
cmpl $0xff, 0x40(%rax)
jg 0x174ff
movq 0x10(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x1748b
movq 0x18(%rsp), %rdi
callq 0x175a0
movl %eax, 0x8(%rsp)
jmp 0x174d5
movq 0x10(%rsp), %rax
cmpl $0x5, (%rax)
jne 0x174af
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
callq 0x16f20
movl %eax, 0x4(%rsp)
jmp 0x174cd
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
cmpl $0x2, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x17600
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0x4, (%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x24(%rsp)
jmp 0x17539
jmp 0x17526
movq 0x10(%rsp), %rax
cmpl $0xff, 0x8(%rax)
jg 0x17522
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x24(%rsp)
jmp 0x17539
jmp 0x17526
jmp 0x17526
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x15ef0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaK_exp2val
static void luaK_exp2val(FuncState*fs,expdesc*e){
if(hasjumps(e))
luaK_exp2anyreg(fs,e);
else
luaK_dischargevars(fs,e);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x14(%rcx), %eax
je 0x17581
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x15ef0
jmp 0x17590
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x161b0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: nilK
static int nilK(FuncState*fs){
TValue k,v;
setnilvalue(&v);
sethvalue(fs->L,&k,fs->h);
return addk(fs,&k,&v);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x0, 0x18(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x5, 0x8(%rax)
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x16f70
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: body
static void body(LexState*ls,expdesc*e,int needself,int line){
FuncState new_fs;
open_func(ls,&new_fs);
new_fs.f->linedefined=line;
checknext(ls,'(');
if(needself){
new_localvarliteral(ls,"self",0);
adjustlocalvars(ls,1);
}
parlist(ls);
checknext(ls,')');
chunk(ls);
new_fs.f->lastlinedefined=ls->linenumber;
check_match(ls,TK_END,TK_FUNCTION,line);
close_func(ls);
pushclosure(ls,&new_fs,e);
}

// Assembly:
subq $0x278, %rsp            # imm = 0x278
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movl %edx, 0x264(%rsp)
movl %ecx, 0x260(%rsp)
movq 0x270(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x120e0
movl 0x260(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x60(%rax)
movq 0x270(%rsp), %rdi
movl $0x28, %esi
callq 0x15390
cmpl $0x0, 0x264(%rsp)
je 0x17ab7
movq 0x270(%rsp), %rax
movq %rax, (%rsp)
movq 0x270(%rsp), %rdi
leaq 0xb37a(%rip), %rsi      # 0x22e07
movl $0x4, %edx
callq 0x142a0
movq (%rsp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x183a0
movq 0x270(%rsp), %rdi
movl $0x1, %esi
callq 0x18430
movq 0x270(%rsp), %rdi
callq 0x184b0
movq 0x270(%rsp), %rdi
movl $0x29, %esi
callq 0x15390
movq 0x270(%rsp), %rdi
callq 0x12340
movq 0x270(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x64(%rax)
movq 0x270(%rsp), %rdi
movl 0x260(%rsp), %ecx
movl $0x106, %esi            # imm = 0x106
movl $0x109, %edx            # imm = 0x109
callq 0x14a60
movq 0x270(%rsp), %rdi
callq 0x12410
movq 0x270(%rsp), %rdi
movq 0x268(%rsp), %rdx
leaq 0x8(%rsp), %rsi
callq 0x18600
addq $0x278, %rsp            # imm = 0x278
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: primaryexp
static void primaryexp(LexState*ls,expdesc*v){
FuncState*fs=ls->fs;
prefixexp(ls,v);
for(;;){
switch(ls->t.token){
case'.':{
field(ls,v);
break;
}
case'[':{
expdesc key;
luaK_exp2anyreg(fs,v);
yindex(ls,&key);
luaK_indexed(fs,v,&key);
break;
}
case':':{
expdesc key;
luaX_next(ls);
checkname(ls,&key);
luaK_self(fs,v,&key);
funcargs(ls,v);
break;
}
case'(':case TK_STRING:case'{':{
luaK_exp2nextreg(fs,v);
funcargs(ls,v);
break;
}
default:return;
}
}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x18910
movq 0x50(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x28, %eax
je 0x17c5c
jmp 0x17b92
movl 0xc(%rsp), %eax
subl $0x2e, %eax
je 0x17bd6
jmp 0x17b9d
movl 0xc(%rsp), %eax
subl $0x3a, %eax
je 0x17c1e
jmp 0x17ba8
movl 0xc(%rsp), %eax
subl $0x5b, %eax
je 0x17bea
jmp 0x17bb3
movl 0xc(%rsp), %eax
subl $0x7b, %eax
je 0x17c5c
jmp 0x17bc2
movl 0xc(%rsp), %eax
subl $0x11e, %eax            # imm = 0x11E
je 0x17c5c
jmp 0x17c7c
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x189c0
jmp 0x17c81
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x15ef0
movq 0x50(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x181f0
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x18a20
jmp 0x17c81
movq 0x50(%rsp), %rdi
callq 0x122d0
movq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x181a0
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x18a60
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x18b20
jmp 0x17c81
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x16470
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x18b20
jmp 0x17c81
addq $0x58, %rsp
retq
jmp 0x17b7b
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: closelistfield
static void closelistfield(FuncState*fs,struct ConsControl*cc){
if(cc->v.k==VVOID)return;
luaK_exp2nextreg(fs,&cc->v);
cc->v.k=VVOID;
if(cc->tostore==50){
luaK_setlist(fs,cc->t->u.s.info,cc->na,cc->tostore);
cc->tostore=0;
}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x17cfa
jmp 0x17d51
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x16470
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movq 0x8(%rsp), %rax
cmpl $0x32, 0x28(%rax)
jne 0x17d51
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %esi
movq 0x8(%rsp), %rax
movl 0x24(%rax), %edx
movq 0x8(%rsp), %rax
movl 0x28(%rax), %ecx
callq 0x18040
movq 0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: listfield
static void listfield(LexState*ls,struct ConsControl*cc){
expr(ls,&cc->v);
luaY_checklimit(ls->fs,cc->na,(INT_MAX-2),"items in a constructor");
cc->na++;
cc->tostore++;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x153c0
movq 0x8(%rsp), %rax
cmpl $0x7ffffffd, 0x24(%rax) # imm = 0x7FFFFFFD
jle 0x17dd5
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movl $0x7ffffffd, %esi       # imm = 0x7FFFFFFD
leaq 0xafd6(%rip), %rdx      # 0x22da6
callq 0x18100
movq 0x8(%rsp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq 0x8(%rsp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: recfield
static void recfield(LexState*ls,struct ConsControl*cc){
FuncState*fs=ls->fs;
int reg=ls->fs->freereg;
expdesc key,val;
int rkkey;
if(ls->t.token==TK_NAME){
luaY_checklimit(fs,cc->nh,(INT_MAX-2),"items in a constructor");
checkname(ls,&key);
}
else
yindex(ls,&key);
cc->nh++;
checknext(ls,'=');
rkkey=luaK_exp2RK(fs,&key);
expr(ls,&val);
luaK_codeABC(fs,OP_SETTABLE,cc->t->u.s.info,rkkey,luaK_exp2RK(fs,&val));
fs->freereg=reg;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x3c(%rax), %eax
movl %eax, 0x4c(%rsp)
movq 0x60(%rsp), %rax
cmpl $0x11d, 0x10(%rax)      # imm = 0x11D
jne 0x17e6f
movq 0x58(%rsp), %rax
cmpl $0x7ffffffd, 0x20(%rax) # imm = 0x7FFFFFFD
jle 0x17e5e
movq 0x50(%rsp), %rdi
movl $0x7ffffffd, %esi       # imm = 0x7FFFFFFD
leaq 0xaf4d(%rip), %rdx      # 0x22da6
callq 0x18100
movq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x181a0
jmp 0x17e7e
movq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x181f0
movq 0x58(%rsp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq 0x60(%rsp), %rdi
movl $0x3d, %esi
callq 0x15390
movq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x17410
movl %eax, 0x14(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x153c0
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x17410
movq (%rsp), %rdi
movl 0xc(%rsp), %edx
movl 0x10(%rsp), %ecx
movl %eax, %r8d
movl $0x9, %esi
callq 0x164d0
movl 0x4c(%rsp), %ecx
movq 0x50(%rsp), %rax
movl %ecx, 0x3c(%rax)
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: lastlistfield
static void lastlistfield(FuncState*fs,struct ConsControl*cc){
if(cc->tostore==0)return;
if(hasmultret(cc->v.k)){
luaK_setmultret(fs,&cc->v);
luaK_setlist(fs,cc->t->u.s.info,cc->na,(-1));
cc->na--;
}
else{
if(cc->v.k!=VVOID)
luaK_exp2nextreg(fs,&cc->v);
luaK_setlist(fs,cc->t->u.s.info,cc->na,cc->tostore);
}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x17f3e
jmp 0x17fd8
movq 0x8(%rsp), %rax
cmpl $0xd, (%rax)
je 0x17f52
movq 0x8(%rsp), %rax
cmpl $0xe, (%rax)
jne 0x17f99
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x18280
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %esi
movq 0x8(%rsp), %rax
movl 0x24(%rax), %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x18040
movq 0x8(%rsp), %rax
movl 0x24(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x24(%rax)
jmp 0x17fd8
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
je 0x17fb2
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x16470
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %esi
movq 0x8(%rsp), %rax
movl 0x24(%rax), %edx
movq 0x8(%rsp), %rax
movl 0x28(%rax), %ecx
callq 0x18040
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/minilua.c
// Function: luaO_int2fb
static int luaO_int2fb(unsigned int x){
int e=0;
while(x>=16){
x=(x+1)>>1;
e++;
}
if(x<8)return x;
else return((e+1)<<3)|(cast_int(x)-8);
}

// Assembly:
movl %edi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x10, -0x8(%rsp)
jb 0x1800d
movl -0x8(%rsp), %eax
addl $0x1, %eax
shrl %eax
movl %eax, -0x8(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x17fec
cmpl $0x8, -0x8(%rsp)
jae 0x1801e
movl -0x8(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x18035
movl -0xc(%rsp), %eax
addl $0x1, %eax
shll $0x3, %eax
movl -0x8(%rsp), %ecx
subl $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)