index int64 0 66.5k | func_name stringlengths 2 5.36k | func_dep stringlengths 16 2.19k | func stringlengths 8 55.3k | test stringlengths 0 7.07k | opt stringclasses 4 values | language stringclasses 2 values | asm stringlengths 0 45.4k | ida_asm stringlengths 0 44.7k | ida_pseudo stringlengths 0 44.3k | ghidra_asm stringlengths 0 49.1k | ghidra_pseudo stringlengths 0 64.7k |
|---|---|---|---|---|---|---|---|---|---|---|---|
32,100 | SetWindowIcons | csit-sgu[P]mit-game-2025-team-tyler/Libraries/raylib/src/platforms/rcore_desktop_glfw.c | void SetWindowIcons(Image *images, int count)
{
if ((images == NULL) || (count <= 0))
{
// Revert to the default window icon, pass in an empty image array
glfwSetWindowIcon(platform.handle, 0, NULL);
}
else
{
int valid = 0;
GLFWimage *icons = RL_CALLOC(count, sizeof(GLFWimage));
for (int i = 0; i < count; i++)
{
if (images[i].format == PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)
{
icons[valid].width = images[i].width;
icons[valid].height = images[i].height;
icons[valid].pixels = (unsigned char *)images[i].data;
valid++;
}
else TRACELOG(LOG_WARNING, "GLFW: Window icon image must be in R8G8B8A8 pixel format");
}
// NOTE: Images data is copied internally before this function returns
glfwSetWindowIcon(platform.handle, valid, icons);
RL_FREE(icons);
}
} | O3 | c | SetWindowIcons:
testq %rdi, %rdi
setne %al
testl %esi, %esi
setg %cl
testb %cl, %al
jne 0x6ff6d
movq 0xcc744(%rip), %rdi # 0x13c6a8
xorl %esi, %esi
xorl %edx, %edx
jmp 0xc0e0c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r15d
movl $0x10, %esi
movq %r15, %rdi
callq 0xa330
movq %rax, %r14
shlq $0x3, %r15
leaq (%r15,%r15,2), %r13
leaq 0x6faaf(%rip), %r12 # 0xdfa4c
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpl $0x7, 0x14(%rbx,%rbp)
jne 0x6ffca
movslq %r15d, %r15
movq %r15, %rax
shlq $0x4, %rax
movq 0x8(%rbx,%rbp), %rcx
movq %rcx, (%r14,%rax)
movq (%rbx,%rbp), %rcx
movq %rcx, 0x8(%r14,%rax)
incl %r15d
jmp 0x6ffd9
movl $0x4, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0xb9e53
addq $0x18, %rbp
cmpq %rbp, %r13
jne 0x6ffa2
movq 0xcc6bf(%rip), %rdi # 0x13c6a8
movl %r15d, %esi
movq %r14, %rdx
callq 0xc0e0c
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa650
| SetWindowIcons:
test rdi, rdi
setnz al
test esi, esi
setnle cl
test al, cl
jnz short loc_6FF6D
mov rdi, cs:platform_0
xor esi, esi
xor edx, edx
jmp glfwSetWindowIcon
loc_6FF6D:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov r15d, esi
mov esi, 10h
mov rdi, r15
call _calloc
mov r14, rax
shl r15, 3
lea r13, [r15+r15*2]
lea r12, aGlfwWindowIcon; "GLFW: Window icon image must be in R8G8"...
xor ebp, ebp
xor r15d, r15d
loc_6FFA2:
cmp dword ptr [rbx+rbp+14h], 7
jnz short loc_6FFCA
movsxd r15, r15d
mov rax, r15
shl rax, 4
mov rcx, [rbx+rbp+8]
mov [r14+rax], rcx
mov rcx, [rbx+rbp]
mov [r14+rax+8], rcx
inc r15d
jmp short loc_6FFD9
loc_6FFCA:
mov edi, 4
mov rsi, r12
xor eax, eax
call TraceLog
loc_6FFD9:
add rbp, 18h
cmp r13, rbp
jnz short loc_6FFA2
mov rdi, cs:platform_0
mov esi, r15d
mov rdx, r14
call glfwSetWindowIcon
mov rdi, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _free
| long long SetWindowIcons(long long a1, unsigned int a2)
{
int v3; // edx
long long v4; // rcx
int v5; // r8d
int v6; // r9d
long long v7; // r14
long long v8; // rbp
unsigned int v9; // r15d
long long v10; // rax
if ( (int)a2 <= 0 || a1 == 0 )
return glfwSetWindowIcon(platform_0, 0LL, 0LL);
v7 = calloc(a2, 16LL);
v8 = 0LL;
v9 = 0;
do
{
if ( *(_DWORD *)(a1 + v8 + 20) == 7 )
{
v10 = 16LL * (int)v9;
*(_QWORD *)(v7 + v10) = *(_QWORD *)(a1 + v8 + 8);
v4 = *(_QWORD *)(a1 + v8);
*(_QWORD *)(v7 + v10 + 8) = v4;
++v9;
}
else
{
TraceLog(4, (unsigned int)"GLFW: Window icon image must be in R8G8B8A8 pixel format", v3, v4, v5, v6);
}
v8 += 24LL;
}
while ( 24LL * a2 != v8 );
glfwSetWindowIcon(platform_0, v9, v7);
return free(v7);
}
| SetWindowIcons:
TEST RDI,RDI
SETNZ AL
TEST ESI,ESI
SETG CL
TEST AL,CL
JNZ 0x0016ff6d
MOV RDI,qword ptr [0x0023c6a8]
XOR ESI,ESI
XOR EDX,EDX
JMP 0x001c0e0c
LAB_0016ff6d:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R15D,ESI
MOV ESI,0x10
MOV RDI,R15
CALL 0x0010a330
MOV R14,RAX
SHL R15,0x3
LEA R13,[R15 + R15*0x2]
LEA R12,[0x1dfa4c]
XOR EBP,EBP
XOR R15D,R15D
LAB_0016ffa2:
CMP dword ptr [RBX + RBP*0x1 + 0x14],0x7
JNZ 0x0016ffca
MOVSXD R15,R15D
MOV RAX,R15
SHL RAX,0x4
MOV RCX,qword ptr [RBX + RBP*0x1 + 0x8]
MOV qword ptr [R14 + RAX*0x1],RCX
MOV RCX,qword ptr [RBX + RBP*0x1]
MOV qword ptr [R14 + RAX*0x1 + 0x8],RCX
INC R15D
JMP 0x0016ffd9
LAB_0016ffca:
MOV EDI,0x4
MOV RSI,R12
XOR EAX,EAX
CALL 0x001b9e53
LAB_0016ffd9:
ADD RBP,0x18
CMP R13,RBP
JNZ 0x0016ffa2
MOV RDI,qword ptr [0x0023c6a8]
MOV ESI,R15D
MOV RDX,R14
CALL 0x001c0e0c
MOV RDI,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0010a650
|
void SetWindowIcons(long param_1,uint param_2)
{
void *__ptr;
long lVar1;
int iVar2;
if (param_1 == 0 || (int)param_2 < 1) {
glfwSetWindowIcon(platform_0,0,0);
return;
}
__ptr = calloc((ulong)param_2,0x10);
lVar1 = 0;
iVar2 = 0;
do {
if (*(int *)(param_1 + 0x14 + lVar1) == 7) {
*(int8 *)((long)__ptr + (long)iVar2 * 0x10) = *(int8 *)(param_1 + 8 + lVar1);
*(int8 *)((long)__ptr + (long)iVar2 * 0x10 + 8) = *(int8 *)(param_1 + lVar1);
iVar2 = iVar2 + 1;
}
else {
TraceLog(4,"GLFW: Window icon image must be in R8G8B8A8 pixel format");
}
lVar1 = lVar1 + 0x18;
} while ((ulong)param_2 * 0x18 != lVar1);
glfwSetWindowIcon(platform_0,iVar2,__ptr);
free(__ptr);
return;
}
| |
32,101 | Encoder::calculate_mem_size(ggml_type) | 7CodeWizard[P]stablediffusion/vae.hpp | size_t calculate_mem_size(ggml_type wtype) {
double mem_size = 0;
int len_mults = sizeof(ch_mult) / sizeof(int);
int block_in = ch * ch_mult[len_mults - 1];
mem_size += ch * in_channels * 3 * 3 * ggml_type_sizef(GGML_TYPE_F16); // conv_in_w
mem_size += ch * ggml_type_sizef(GGML_TYPE_F32); // conv_in_b
mem_size += 2 * block_in * ggml_type_sizef(GGML_TYPE_F32); // norm_out_w/b
mem_size += z_channels * 2 * block_in * 3 * 3 * ggml_type_sizef(GGML_TYPE_F16); // conv_out_w
mem_size += z_channels * 2 * ggml_type_sizef(GGML_TYPE_F32); // conv_out_b
mem_size += mid.block_1.calculate_mem_size(wtype);
mem_size += mid.attn_1.calculate_mem_size(wtype);
mem_size += mid.block_2.calculate_mem_size(wtype);
for (int i = len_mults - 1; i >= 0; i--) {
for (int j = 0; j < num_res_blocks + 1; j++) {
mem_size += down_blocks[i][j].calculate_mem_size(wtype);
}
if (i != 0) {
mem_size += down_samples[i - 1].calculate_mem_size(wtype);
}
}
return static_cast<size_t>(mem_size);
} | O2 | cpp | Encoder::calculate_mem_size(ggml_type):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %r15d
imull %eax, %r15d
imull 0xc(%rdi), %eax
movl %esi, %ebp
leal (%rax,%rax,8), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rsp)
pushq $0x1
popq %r14
movl %r14d, %edi
callq 0x67bc7
mulsd (%rsp), %xmm0
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
cvtsi2sdl 0x4(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %edi, %edi
callq 0x67bc7
mulsd 0x10(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
leal (%r15,%r15), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %edi, %edi
callq 0x67bc7
mulsd 0x10(%rsp), %xmm0
imull 0x8(%rbx), %r15d
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
imull $0x12, %r15d, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
movl %r14d, %edi
callq 0x67bc7
mulsd 0x10(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movl 0x8(%rbx), %eax
addl %eax, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %edi, %edi
callq 0x67bc7
mulsd 0x10(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x358(%rbx), %rdi
movl %ebp, %esi
callq 0x24028
movq %rax, %xmm0
punpckldq 0x75c51(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x75c59(%rip), %xmm0 # 0x99870
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd (%rsp), %xmm1
movapd %xmm1, (%rsp)
leaq 0x3b0(%rbx), %rdi
movl %ebp, %esi
callq 0x24152
movq %rax, %xmm0
punpckldq 0x75c18(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x75c20(%rip), %xmm0 # 0x99870
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd (%rsp), %xmm1
movapd %xmm1, (%rsp)
leaq 0x408(%rbx), %rdi
movl %ebp, %esi
callq 0x24028
movq %rax, %xmm0
punpckldq 0x75bdf(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x75be7(%rip), %xmm0 # 0x99870
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd (%rsp), %xmm1
movapd %xmm1, (%rsp)
leaq 0x2f8(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rbx), %r12
pushq $0x3
popq %r13
testl %r13d, %r13d
js 0x23d67
movl %r13d, %eax
imulq $0xb0, %rax, %r14
addq %r12, %r14
xorl %r15d, %r15d
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jg 0x23d17
movq %r14, %rdi
movl %ebp, %esi
callq 0x24028
movq %rax, %xmm0
punpckldq 0x75b74(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x75b7c(%rip), %xmm0 # 0x99870
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd (%rsp), %xmm0
addsd %xmm1, %xmm0
movapd %xmm0, (%rsp)
incq %r15
addq $0x58, %r14
jmp 0x23ccc
testl %r13d, %r13d
je 0x23d5f
leal -0x1(%r13), %edi
shlq $0x5, %rdi
addq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0x236f4
movq %rax, %xmm0
punpckldq 0x75b23(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x75b2b(%rip), %xmm0 # 0x99870
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd (%rsp), %xmm0
addsd %xmm1, %xmm0
movapd %xmm0, (%rsp)
decl %r13d
jmp 0x23cb3
movapd (%rsp), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
subsd 0x75c54(%rip), %xmm0 # 0x999d0
cvttsd2si %xmm0, %rax
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN7Encoder18calculate_mem_sizeE9ggml_type:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov eax, [rdi+4]
mov r15d, [rdi+20h]
imul r15d, eax
imul eax, [rdi+0Ch]
mov ebp, esi
lea eax, [rax+rax*8]
cvtsi2sd xmm0, eax
movsd qword ptr [rsp+48h+var_48], xmm0
push 1
pop r14
mov edi, r14d
call ggml_type_sizef
mulsd xmm0, qword ptr [rsp+48h+var_48]
xorpd xmm1, xmm1
addsd xmm1, xmm0
movsd qword ptr [rsp+48h+var_48], xmm1
cvtsi2sd xmm0, dword ptr [rbx+4]
movsd [rsp+48h+var_38], xmm0
xor edi, edi
call ggml_type_sizef
mulsd xmm0, [rsp+48h+var_38]
addsd xmm0, qword ptr [rsp+48h+var_48]
movsd qword ptr [rsp+48h+var_48], xmm0
lea eax, [r15+r15]
cvtsi2sd xmm0, eax
movsd [rsp+48h+var_38], xmm0
xor edi, edi
call ggml_type_sizef
mulsd xmm0, [rsp+48h+var_38]
imul r15d, [rbx+8]
addsd xmm0, qword ptr [rsp+48h+var_48]
movsd qword ptr [rsp+48h+var_48], xmm0
imul eax, r15d, 12h
cvtsi2sd xmm0, eax
movsd [rsp+48h+var_38], xmm0
mov edi, r14d
call ggml_type_sizef
mulsd xmm0, [rsp+48h+var_38]
addsd xmm0, qword ptr [rsp+48h+var_48]
movsd qword ptr [rsp+48h+var_48], xmm0
mov eax, [rbx+8]
add eax, eax
cvtsi2sd xmm0, eax
movsd [rsp+48h+var_38], xmm0
xor edi, edi
call ggml_type_sizef
mulsd xmm0, [rsp+48h+var_38]
addsd xmm0, qword ptr [rsp+48h+var_48]
movsd qword ptr [rsp+48h+var_48], xmm0
lea rdi, [rbx+358h]
mov esi, ebp
call _ZN11ResnetBlock18calculate_mem_sizeE9ggml_type; ResnetBlock::calculate_mem_size(ggml_type)
movq xmm0, rax
punpckldq xmm0, cs:xmmword_99860
subpd xmm0, cs:xmmword_99870
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
addsd xmm1, xmm0
addsd xmm1, qword ptr [rsp+48h+var_48]
movapd [rsp+48h+var_48], xmm1
lea rdi, [rbx+3B0h]
mov esi, ebp
call _ZN9AttnBlock18calculate_mem_sizeE9ggml_type; AttnBlock::calculate_mem_size(ggml_type)
movq xmm0, rax
punpckldq xmm0, cs:xmmword_99860
subpd xmm0, cs:xmmword_99870
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
addsd xmm1, xmm0
addsd xmm1, qword ptr [rsp+48h+var_48]
movapd [rsp+48h+var_48], xmm1
lea rdi, [rbx+408h]
mov esi, ebp
call _ZN11ResnetBlock18calculate_mem_sizeE9ggml_type; ResnetBlock::calculate_mem_size(ggml_type)
movq xmm0, rax
punpckldq xmm0, cs:xmmword_99860
subpd xmm0, cs:xmmword_99870
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
addsd xmm1, xmm0
addsd xmm1, qword ptr [rsp+48h+var_48]
movapd [rsp+48h+var_48], xmm1
lea rax, [rbx+2F8h]
mov [rsp+48h+var_38], rax
lea r12, [rbx+38h]
push 3
pop r13
loc_23CB3:
test r13d, r13d
js loc_23D67
mov eax, r13d
imul r14, rax, 0B0h
add r14, r12
xor r15d, r15d
loc_23CCC:
movsxd rax, dword ptr [rbx+10h]
cmp r15, rax
jg short loc_23D17
mov rdi, r14
mov esi, ebp
call _ZN11ResnetBlock18calculate_mem_sizeE9ggml_type; ResnetBlock::calculate_mem_size(ggml_type)
movq xmm0, rax
punpckldq xmm0, cs:xmmword_99860
subpd xmm0, cs:xmmword_99870
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
addsd xmm1, xmm0
movapd xmm0, [rsp+48h+var_48]
addsd xmm0, xmm1
movapd [rsp+48h+var_48], xmm0
inc r15
add r14, 58h ; 'X'
jmp short loc_23CCC
loc_23D17:
test r13d, r13d
jz short loc_23D5F
lea edi, [r13-1]
shl rdi, 5
add rdi, [rsp+48h+var_38]
mov esi, ebp
call _ZN10DownSample18calculate_mem_sizeE9ggml_type; DownSample::calculate_mem_size(ggml_type)
movq xmm0, rax
punpckldq xmm0, cs:xmmword_99860
subpd xmm0, cs:xmmword_99870
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
addsd xmm1, xmm0
movapd xmm0, [rsp+48h+var_48]
addsd xmm0, xmm1
movapd [rsp+48h+var_48], xmm0
loc_23D5F:
dec r13d
jmp loc_23CB3
loc_23D67:
movapd xmm0, [rsp+48h+var_48]
cvttsd2si rcx, xmm0
mov rdx, rcx
subsd xmm0, cs:qword_999D0
cvttsd2si rax, xmm0
sar rdx, 3Fh
and rax, rdx
or rax, rcx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long Encoder::calculate_mem_size(_DWORD *a1, unsigned int a2)
{
int v2; // eax
int v3; // r15d
__m128d v4; // xmm0
__m128d v5; // xmm0
__m128d v6; // xmm0
__m128d v7; // xmm1
int i; // r13d
long long v9; // r14
long long j; // r15
__m128d v11; // xmm0
double v12; // xmm1_8
__m128d v13; // xmm0
double v14; // xmm1_8
double v16; // [rsp+0h] [rbp-48h]
double v17; // [rsp+0h] [rbp-48h]
double v18; // [rsp+0h] [rbp-48h]
double v19; // [rsp+0h] [rbp-48h]
double v20; // [rsp+0h] [rbp-48h]
double v21; // [rsp+0h] [rbp-48h]
double v22; // [rsp+0h] [rbp-48h]
double v23; // [rsp+0h] [rbp-48h]
__m128d v24; // [rsp+0h] [rbp-48h]
double v25; // [rsp+10h] [rbp-38h]
double v26; // [rsp+10h] [rbp-38h]
double v27; // [rsp+10h] [rbp-38h]
v2 = a1[1];
v3 = v2 * a1[8];
v16 = (double)(9 * a1[3] * v2);
v17 = ggml_type_sizef(1LL) * v16 + 0.0;
v25 = (double)(int)a1[1];
v18 = ggml_type_sizef(0LL) * v25 + v17;
v19 = ggml_type_sizef(0LL) * (double)(2 * v3) + v18;
v26 = (double)(18 * a1[2] * v3);
v20 = ggml_type_sizef(1LL) * v26 + v19;
v27 = (double)(2 * a1[2]);
v21 = ggml_type_sizef(0LL) * v27 + v20;
v4 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(
(__m128i)(unsigned long long)ResnetBlock::calculate_mem_size(a1 + 214, a2),
(__m128i)xmmword_99860),
(__m128d)xmmword_99870);
v22 = _mm_unpackhi_pd(v4, v4).m128d_f64[0] + v4.m128d_f64[0] + v21;
v5 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(
(__m128i)(unsigned long long)AttnBlock::calculate_mem_size(a1 + 236, a2),
(__m128i)xmmword_99860),
(__m128d)xmmword_99870);
v23 = _mm_unpackhi_pd(v5, v5).m128d_f64[0] + v5.m128d_f64[0] + v22;
v6 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(
(__m128i)(unsigned long long)ResnetBlock::calculate_mem_size(a1 + 258, a2),
(__m128i)xmmword_99860),
(__m128d)xmmword_99870);
v7 = _mm_unpackhi_pd(v6, v6);
v7.m128d_f64[0] = v7.m128d_f64[0] + v6.m128d_f64[0] + v23;
v24 = v7;
for ( i = 3; i >= 0; --i )
{
v9 = (long long)&a1[44 * i + 14];
for ( j = 0LL; j <= (int)a1[4]; ++j )
{
v11 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(
(__m128i)(unsigned long long)ResnetBlock::calculate_mem_size(v9, a2),
(__m128i)xmmword_99860),
(__m128d)xmmword_99870);
v12 = _mm_unpackhi_pd(v11, v11).m128d_f64[0] + v11.m128d_f64[0];
v11.m128d_f64[1] = v24.m128d_f64[1];
v11.m128d_f64[0] = v24.m128d_f64[0] + v12;
v24 = v11;
v9 += 88LL;
}
if ( i )
{
v13 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(
(__m128i)(unsigned long long)DownSample::calculate_mem_size(&a1[8 * (i - 1) + 190]),
(__m128i)xmmword_99860),
(__m128d)xmmword_99870);
v14 = _mm_unpackhi_pd(v13, v13).m128d_f64[0] + v13.m128d_f64[0];
v13.m128d_f64[1] = v24.m128d_f64[1];
v13.m128d_f64[0] = v24.m128d_f64[0] + v14;
v24 = v13;
}
}
return (unsigned int)(int)v24.m128d_f64[0];
}
| calculate_mem_size:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0x4]
MOV R15D,dword ptr [RDI + 0x20]
IMUL R15D,EAX
IMUL EAX,dword ptr [RDI + 0xc]
MOV EBP,ESI
LEA EAX,[RAX + RAX*0x8]
CVTSI2SD XMM0,EAX
MOVSD qword ptr [RSP],XMM0
PUSH 0x1
POP R14
MOV EDI,R14D
CALL 0x00167bc7
MULSD XMM0,qword ptr [RSP]
XORPD XMM1,XMM1
ADDSD XMM1,XMM0
MOVSD qword ptr [RSP],XMM1
CVTSI2SD XMM0,dword ptr [RBX + 0x4]
MOVSD qword ptr [RSP + 0x10],XMM0
XOR EDI,EDI
CALL 0x00167bc7
MULSD XMM0,qword ptr [RSP + 0x10]
ADDSD XMM0,qword ptr [RSP]
MOVSD qword ptr [RSP],XMM0
LEA EAX,[R15 + R15*0x1]
CVTSI2SD XMM0,EAX
MOVSD qword ptr [RSP + 0x10],XMM0
XOR EDI,EDI
CALL 0x00167bc7
MULSD XMM0,qword ptr [RSP + 0x10]
IMUL R15D,dword ptr [RBX + 0x8]
ADDSD XMM0,qword ptr [RSP]
MOVSD qword ptr [RSP],XMM0
IMUL EAX,R15D,0x12
CVTSI2SD XMM0,EAX
MOVSD qword ptr [RSP + 0x10],XMM0
MOV EDI,R14D
CALL 0x00167bc7
MULSD XMM0,qword ptr [RSP + 0x10]
ADDSD XMM0,qword ptr [RSP]
MOVSD qword ptr [RSP],XMM0
MOV EAX,dword ptr [RBX + 0x8]
ADD EAX,EAX
CVTSI2SD XMM0,EAX
MOVSD qword ptr [RSP + 0x10],XMM0
XOR EDI,EDI
CALL 0x00167bc7
MULSD XMM0,qword ptr [RSP + 0x10]
ADDSD XMM0,qword ptr [RSP]
MOVSD qword ptr [RSP],XMM0
LEA RDI,[RBX + 0x358]
MOV ESI,EBP
CALL 0x00124028
MOVQ XMM0,RAX
PUNPCKLDQ XMM0,xmmword ptr [0x00199860]
SUBPD XMM0,xmmword ptr [0x00199870]
MOVAPD XMM1,XMM0
UNPCKHPD XMM1,XMM0
ADDSD XMM1,XMM0
ADDSD XMM1,qword ptr [RSP]
MOVAPD xmmword ptr [RSP],XMM1
LEA RDI,[RBX + 0x3b0]
MOV ESI,EBP
CALL 0x00124152
MOVQ XMM0,RAX
PUNPCKLDQ XMM0,xmmword ptr [0x00199860]
SUBPD XMM0,xmmword ptr [0x00199870]
MOVAPD XMM1,XMM0
UNPCKHPD XMM1,XMM0
ADDSD XMM1,XMM0
ADDSD XMM1,qword ptr [RSP]
MOVAPD xmmword ptr [RSP],XMM1
LEA RDI,[RBX + 0x408]
MOV ESI,EBP
CALL 0x00124028
MOVQ XMM0,RAX
PUNPCKLDQ XMM0,xmmword ptr [0x00199860]
SUBPD XMM0,xmmword ptr [0x00199870]
MOVAPD XMM1,XMM0
UNPCKHPD XMM1,XMM0
ADDSD XMM1,XMM0
ADDSD XMM1,qword ptr [RSP]
MOVAPD xmmword ptr [RSP],XMM1
LEA RAX,[RBX + 0x2f8]
MOV qword ptr [RSP + 0x10],RAX
LEA R12,[RBX + 0x38]
PUSH 0x3
POP R13
LAB_00123cb3:
TEST R13D,R13D
JS 0x00123d67
MOV EAX,R13D
IMUL R14,RAX,0xb0
ADD R14,R12
XOR R15D,R15D
LAB_00123ccc:
MOVSXD RAX,dword ptr [RBX + 0x10]
CMP R15,RAX
JG 0x00123d17
MOV RDI,R14
MOV ESI,EBP
CALL 0x00124028
MOVQ XMM0,RAX
PUNPCKLDQ XMM0,xmmword ptr [0x00199860]
SUBPD XMM0,xmmword ptr [0x00199870]
MOVAPD XMM1,XMM0
UNPCKHPD XMM1,XMM0
ADDSD XMM1,XMM0
MOVAPD XMM0,xmmword ptr [RSP]
ADDSD XMM0,XMM1
MOVAPD xmmword ptr [RSP],XMM0
INC R15
ADD R14,0x58
JMP 0x00123ccc
LAB_00123d17:
TEST R13D,R13D
JZ 0x00123d5f
LEA EDI,[R13 + -0x1]
SHL RDI,0x5
ADD RDI,qword ptr [RSP + 0x10]
MOV ESI,EBP
CALL 0x001236f4
MOVQ XMM0,RAX
PUNPCKLDQ XMM0,xmmword ptr [0x00199860]
SUBPD XMM0,xmmword ptr [0x00199870]
MOVAPD XMM1,XMM0
UNPCKHPD XMM1,XMM0
ADDSD XMM1,XMM0
MOVAPD XMM0,xmmword ptr [RSP]
ADDSD XMM0,XMM1
MOVAPD xmmword ptr [RSP],XMM0
LAB_00123d5f:
DEC R13D
JMP 0x00123cb3
LAB_00123d67:
MOVAPD XMM0,xmmword ptr [RSP]
CVTTSD2SI RCX,XMM0
MOV RDX,RCX
SUBSD XMM0,qword ptr [0x001999d0]
CVTTSD2SI RAX,XMM0
SAR RDX,0x3f
AND RAX,RDX
OR RAX,RCX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* Encoder::calculate_mem_size(ggml_type) */
ulong __thiscall Encoder::calculate_mem_size(Encoder *this,int4 param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int8 uVar6;
uint uVar7;
Encoder *pEVar8;
int iVar9;
long lVar10;
double dVar11;
double dVar12;
double dVar13;
double dVar14;
double dVar15;
double dVar16;
double dVar17;
int1 auVar18 [16];
double dVar23;
int1 auVar19 [16];
double dVar24;
int1 auVar20 [16];
int1 auVar21 [16];
int1 auVar22 [16];
double local_48;
iVar1 = *(int *)(this + 4);
iVar9 = *(int *)(this + 0x20) * iVar1;
iVar2 = *(int *)(this + 0xc);
dVar11 = (double)ggml_type_sizef(1);
iVar3 = *(int *)(this + 4);
dVar12 = (double)ggml_type_sizef(0);
dVar13 = (double)ggml_type_sizef(0);
iVar4 = *(int *)(this + 8);
dVar14 = (double)ggml_type_sizef(1);
iVar5 = *(int *)(this + 8);
dVar15 = (double)ggml_type_sizef(0);
uVar6 = ResnetBlock::calculate_mem_size(this + 0x358,param_2);
auVar18._8_4_ = (int)((ulong)uVar6 >> 0x20);
auVar18._0_8_ = uVar6;
auVar18._12_4_ = DAT_00199860._4_4_;
dVar16 = (double)CONCAT44((int4)DAT_00199860,(int)uVar6) - _DAT_00199870;
dVar23 = auVar18._8_8_ - _UNK_00199878;
uVar6 = AttnBlock::calculate_mem_size(this + 0x3b0,param_2);
auVar19._8_4_ = (int)((ulong)uVar6 >> 0x20);
auVar19._0_8_ = uVar6;
auVar19._12_4_ = DAT_00199860._4_4_;
dVar17 = (double)CONCAT44((int4)DAT_00199860,(int)uVar6) - _DAT_00199870;
dVar24 = auVar19._8_8_ - _UNK_00199878;
uVar6 = ResnetBlock::calculate_mem_size(this + 0x408,param_2);
auVar20._8_4_ = (int)((ulong)uVar6 >> 0x20);
auVar20._0_8_ = uVar6;
auVar20._12_4_ = DAT_00199860._4_4_;
local_48 = (auVar20._8_8_ - _UNK_00199878) +
((double)CONCAT44((int4)DAT_00199860,(int)uVar6) - _DAT_00199870) +
dVar24 + dVar17 +
dVar23 + dVar16 +
dVar15 * (double)(iVar5 * 2) +
dVar14 * (double)(iVar9 * iVar4 * 0x12) +
dVar13 * (double)(iVar9 * 2) +
dVar12 * (double)iVar3 + dVar11 * (double)(iVar1 * iVar2 * 9) + 0.0;
for (uVar7 = 3; -1 < (int)uVar7; uVar7 = uVar7 - 1) {
pEVar8 = this + (ulong)uVar7 * 0xb0 + 0x38;
for (lVar10 = 0; lVar10 <= *(int *)(this + 0x10); lVar10 = lVar10 + 1) {
uVar6 = ResnetBlock::calculate_mem_size(pEVar8,param_2);
auVar21._8_4_ = (int)((ulong)uVar6 >> 0x20);
auVar21._0_8_ = uVar6;
auVar21._12_4_ = DAT_00199860._4_4_;
local_48 = local_48 +
(auVar21._8_8_ - _UNK_00199878) +
((double)CONCAT44((int4)DAT_00199860,(int)uVar6) - _DAT_00199870);
pEVar8 = pEVar8 + 0x58;
}
if (uVar7 != 0) {
uVar6 = DownSample::calculate_mem_size(this + (ulong)(uVar7 - 1) * 0x20 + 0x2f8,param_2);
auVar22._8_4_ = (int)((ulong)uVar6 >> 0x20);
auVar22._0_8_ = uVar6;
auVar22._12_4_ = DAT_00199860._4_4_;
local_48 = local_48 +
(auVar22._8_8_ - _UNK_00199878) +
((double)CONCAT44((int4)DAT_00199860,(int)uVar6) - _DAT_00199870);
}
}
return (long)(local_48 - DAT_001999d0) & (long)local_48 >> 0x3f | (long)local_48;
}
| |
32,102 | Encoder::calculate_mem_size(ggml_type) | 7CodeWizard[P]stablediffusion/vae.hpp | size_t calculate_mem_size(ggml_type wtype) {
double mem_size = 0;
int len_mults = sizeof(ch_mult) / sizeof(int);
int block_in = ch * ch_mult[len_mults - 1];
mem_size += ch * in_channels * 3 * 3 * ggml_type_sizef(GGML_TYPE_F16); // conv_in_w
mem_size += ch * ggml_type_sizef(GGML_TYPE_F32); // conv_in_b
mem_size += 2 * block_in * ggml_type_sizef(GGML_TYPE_F32); // norm_out_w/b
mem_size += z_channels * 2 * block_in * 3 * 3 * ggml_type_sizef(GGML_TYPE_F16); // conv_out_w
mem_size += z_channels * 2 * ggml_type_sizef(GGML_TYPE_F32); // conv_out_b
mem_size += mid.block_1.calculate_mem_size(wtype);
mem_size += mid.attn_1.calculate_mem_size(wtype);
mem_size += mid.block_2.calculate_mem_size(wtype);
for (int i = len_mults - 1; i >= 0; i--) {
for (int j = 0; j < num_res_blocks + 1; j++) {
mem_size += down_blocks[i][j].calculate_mem_size(wtype);
}
if (i != 0) {
mem_size += down_samples[i - 1].calculate_mem_size(wtype);
}
}
return static_cast<size_t>(mem_size);
} | O3 | cpp | Encoder::calculate_mem_size(ggml_type):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %r14d
imull %eax, %r14d
imull 0xc(%rdi), %eax
movl %esi, %ebp
leal (%rax,%rax,8), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rsp)
movl $0x1, %edi
callq 0x8cf2e
mulsd (%rsp), %xmm0
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl 0x4(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %edi, %edi
callq 0x8cf2e
mulsd 0x10(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
leal (%r14,%r14), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %edi, %edi
callq 0x8cf2e
mulsd 0x10(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
imull 0x8(%rbx), %r14d
addl %r14d, %r14d
leal (%r14,%r14,8), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x1, %edi
callq 0x8cf2e
mulsd 0x10(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movl 0x8(%rbx), %eax
addl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %edi, %edi
callq 0x8cf2e
mulsd 0x10(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x358(%rbx), %rdi
movl %ebp, %esi
callq 0x39f44
movq %rax, %xmm0
punpckldq 0x82e2c(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x82e34(%rip), %xmm0 # 0xbc940
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd (%rsp), %xmm1
movapd %xmm1, (%rsp)
leaq 0x3b0(%rbx), %rdi
movl %ebp, %esi
callq 0x3a080
movq %rax, %xmm0
punpckldq 0x82df3(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x82dfb(%rip), %xmm0 # 0xbc940
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd (%rsp), %xmm1
movapd %xmm1, (%rsp)
leaq 0x408(%rbx), %rdi
movl %ebp, %esi
callq 0x39f44
movq %rax, %xmm0
punpckldq 0x82dba(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x82dc2(%rip), %xmm0 # 0xbc940
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd (%rsp), %xmm1
leaq 0x2f8(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x248(%rbx), %r12
movl $0x3, %r13d
cmpl $0x0, 0x10(%rbx)
js 0x39c0b
movq $-0x1, %r15
movq %r12, %r14
movapd %xmm1, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x39f44
movq %rax, %xmm0
punpckldq 0x82d5c(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x82d64(%rip), %xmm0 # 0xbc940
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd (%rsp), %xmm0
addsd %xmm1, %xmm0
movapd %xmm0, (%rsp)
movapd (%rsp), %xmm1
movslq 0x10(%rbx), %rax
incq %r15
addq $0x58, %r14
cmpq %rax, %r15
jl 0x39bb8
subq $0x1, %r13
jb 0x39c69
movq %r13, %rdi
shlq $0x5, %rdi
addq 0x10(%rsp), %rdi
movl %ebp, %esi
movapd %xmm1, (%rsp)
callq 0x39618
movq %rax, %xmm0
punpckldq 0x82cfa(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x82d02(%rip), %xmm0 # 0xbc940
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd (%rsp), %xmm0
addsd %xmm1, %xmm0
movapd %xmm0, (%rsp)
movapd (%rsp), %xmm1
addq $-0xb0, %r12
jmp 0x39ba8
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
subsd 0x82e37(%rip), %xmm1 # 0xbcab0
cvttsd2si %xmm1, %rax
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN7Encoder18calculate_mem_sizeE9ggml_type:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov eax, [rdi+4]
mov r14d, [rdi+20h]
imul r14d, eax
imul eax, [rdi+0Ch]
mov ebp, esi
lea eax, [rax+rax*8]
cvtsi2sd xmm0, eax
movsd qword ptr [rsp+48h+var_48], xmm0
mov edi, 1
call ggml_type_sizef
mulsd xmm0, qword ptr [rsp+48h+var_48]
xorpd xmm1, xmm1
addsd xmm1, xmm0
movsd qword ptr [rsp+48h+var_48], xmm1
xorps xmm0, xmm0
cvtsi2sd xmm0, dword ptr [rbx+4]
movsd [rsp+48h+var_38], xmm0
xor edi, edi
call ggml_type_sizef
mulsd xmm0, [rsp+48h+var_38]
addsd xmm0, qword ptr [rsp+48h+var_48]
movsd qword ptr [rsp+48h+var_48], xmm0
lea eax, [r14+r14]
xorps xmm0, xmm0
cvtsi2sd xmm0, eax
movsd [rsp+48h+var_38], xmm0
xor edi, edi
call ggml_type_sizef
mulsd xmm0, [rsp+48h+var_38]
addsd xmm0, qword ptr [rsp+48h+var_48]
movsd qword ptr [rsp+48h+var_48], xmm0
imul r14d, [rbx+8]
add r14d, r14d
lea eax, [r14+r14*8]
xorps xmm0, xmm0
cvtsi2sd xmm0, eax
movsd [rsp+48h+var_38], xmm0
mov edi, 1
call ggml_type_sizef
mulsd xmm0, [rsp+48h+var_38]
addsd xmm0, qword ptr [rsp+48h+var_48]
movsd qword ptr [rsp+48h+var_48], xmm0
mov eax, [rbx+8]
add eax, eax
xorps xmm0, xmm0
cvtsi2sd xmm0, eax
movsd [rsp+48h+var_38], xmm0
xor edi, edi
call ggml_type_sizef
mulsd xmm0, [rsp+48h+var_38]
addsd xmm0, qword ptr [rsp+48h+var_48]
movsd qword ptr [rsp+48h+var_48], xmm0
lea rdi, [rbx+358h]
mov esi, ebp
call _ZN11ResnetBlock18calculate_mem_sizeE9ggml_type; ResnetBlock::calculate_mem_size(ggml_type)
movq xmm0, rax
punpckldq xmm0, cs:xmmword_BC930
subpd xmm0, cs:xmmword_BC940
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
addsd xmm1, xmm0
addsd xmm1, qword ptr [rsp+48h+var_48]
movapd [rsp+48h+var_48], xmm1
lea rdi, [rbx+3B0h]
mov esi, ebp
call _ZN9AttnBlock18calculate_mem_sizeE9ggml_type; AttnBlock::calculate_mem_size(ggml_type)
movq xmm0, rax
punpckldq xmm0, cs:xmmword_BC930
subpd xmm0, cs:xmmword_BC940
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
addsd xmm1, xmm0
addsd xmm1, qword ptr [rsp+48h+var_48]
movapd [rsp+48h+var_48], xmm1
lea rdi, [rbx+408h]
mov esi, ebp
call _ZN11ResnetBlock18calculate_mem_sizeE9ggml_type; ResnetBlock::calculate_mem_size(ggml_type)
movq xmm0, rax
punpckldq xmm0, cs:xmmword_BC930
subpd xmm0, cs:xmmword_BC940
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
addsd xmm1, xmm0
addsd xmm1, qword ptr [rsp+48h+var_48]
lea rax, [rbx+2F8h]
mov [rsp+48h+var_38], rax
lea r12, [rbx+248h]
mov r13d, 3
loc_39BA8:
cmp dword ptr [rbx+10h], 0
js short loc_39C0B
mov r15, 0FFFFFFFFFFFFFFFFh
mov r14, r12
loc_39BB8:
movapd [rsp+48h+var_48], xmm1
mov rdi, r14
mov esi, ebp
call _ZN11ResnetBlock18calculate_mem_sizeE9ggml_type; ResnetBlock::calculate_mem_size(ggml_type)
movq xmm0, rax
punpckldq xmm0, cs:xmmword_BC930
subpd xmm0, cs:xmmword_BC940
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
addsd xmm1, xmm0
movapd xmm0, [rsp+48h+var_48]
addsd xmm0, xmm1
movapd [rsp+48h+var_48], xmm0
movapd xmm1, [rsp+48h+var_48]
movsxd rax, dword ptr [rbx+10h]
inc r15
add r14, 58h ; 'X'
cmp r15, rax
jl short loc_39BB8
loc_39C0B:
sub r13, 1
jb short loc_39C69
mov rdi, r13
shl rdi, 5
add rdi, [rsp+48h+var_38]
mov esi, ebp
movapd [rsp+48h+var_48], xmm1
call _ZN10DownSample18calculate_mem_sizeE9ggml_type; DownSample::calculate_mem_size(ggml_type)
movq xmm0, rax
punpckldq xmm0, cs:xmmword_BC930
subpd xmm0, cs:xmmword_BC940
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
addsd xmm1, xmm0
movapd xmm0, [rsp+48h+var_48]
addsd xmm0, xmm1
movapd [rsp+48h+var_48], xmm0
movapd xmm1, [rsp+48h+var_48]
add r12, 0FFFFFFFFFFFFFF50h
jmp loc_39BA8
loc_39C69:
cvttsd2si rcx, xmm1
mov rdx, rcx
subsd xmm1, cs:qword_BCAB0
cvttsd2si rax, xmm1
sar rdx, 3Fh
and rax, rdx
or rax, rcx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long Encoder::calculate_mem_size(_DWORD *a1, unsigned int a2)
{
int v2; // eax
int v3; // r14d
__m128d v4; // xmm0
__m128d v5; // xmm0
__m128d v6; // xmm0
__m128d v7; // xmm1
_DWORD *v8; // r12
long long v9; // r13
long long v10; // r15
_DWORD *v11; // r14
__m128d v12; // xmm0
double v13; // xmm1_8
__m128d v15; // xmm0
double v16; // xmm1_8
double v18; // [rsp+0h] [rbp-48h]
double v19; // [rsp+0h] [rbp-48h]
double v20; // [rsp+0h] [rbp-48h]
double v21; // [rsp+0h] [rbp-48h]
double v22; // [rsp+0h] [rbp-48h]
double v23; // [rsp+0h] [rbp-48h]
double v24; // [rsp+0h] [rbp-48h]
double v25; // [rsp+0h] [rbp-48h]
__m128d v26; // [rsp+0h] [rbp-48h]
__m128d v27; // [rsp+0h] [rbp-48h]
double v28; // [rsp+10h] [rbp-38h]
double v29; // [rsp+10h] [rbp-38h]
double v30; // [rsp+10h] [rbp-38h]
v2 = a1[1];
v3 = v2 * a1[8];
v18 = (double)(9 * a1[3] * v2);
v19 = ggml_type_sizef(1LL) * v18 + 0.0;
v28 = (double)(int)a1[1];
v20 = ggml_type_sizef(0LL) * v28 + v19;
v21 = ggml_type_sizef(0LL) * (double)(2 * v3) + v20;
v29 = (double)(18 * a1[2] * v3);
v22 = ggml_type_sizef(1LL) * v29 + v21;
v30 = (double)(2 * a1[2]);
v23 = ggml_type_sizef(0LL) * v30 + v22;
v4 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(
(__m128i)(unsigned long long)ResnetBlock::calculate_mem_size(a1 + 214, a2),
(__m128i)xmmword_BC930),
(__m128d)xmmword_BC940);
v24 = _mm_unpackhi_pd(v4, v4).m128d_f64[0] + v4.m128d_f64[0] + v23;
v5 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(
(__m128i)(unsigned long long)AttnBlock::calculate_mem_size(a1 + 236, a2),
(__m128i)xmmword_BC930),
(__m128d)xmmword_BC940);
v25 = _mm_unpackhi_pd(v5, v5).m128d_f64[0] + v5.m128d_f64[0] + v24;
v6 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(
(__m128i)(unsigned long long)ResnetBlock::calculate_mem_size(a1 + 258, a2),
(__m128i)xmmword_BC930),
(__m128d)xmmword_BC940);
v7 = _mm_unpackhi_pd(v6, v6);
v7.m128d_f64[0] = v7.m128d_f64[0] + v6.m128d_f64[0] + v25;
v8 = a1 + 146;
v9 = 3LL;
while ( 1 )
{
if ( (int)a1[4] >= 0 )
{
v10 = -1LL;
v11 = v8;
do
{
v26 = v7;
v12 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(
(__m128i)(unsigned long long)ResnetBlock::calculate_mem_size(v11, a2),
(__m128i)xmmword_BC930),
(__m128d)xmmword_BC940);
v13 = _mm_unpackhi_pd(v12, v12).m128d_f64[0];
v12.m128d_f64[1] = v26.m128d_f64[1];
v12.m128d_f64[0] = v26.m128d_f64[0] + v13 + v12.m128d_f64[0];
v7 = v12;
++v10;
v11 += 22;
}
while ( v10 < (int)a1[4] );
}
if ( v9-- == 0 )
break;
v27 = v7;
v15 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(
(__m128i)(unsigned long long)DownSample::calculate_mem_size(&a1[8 * v9 + 190]),
(__m128i)xmmword_BC930),
(__m128d)xmmword_BC940);
v16 = _mm_unpackhi_pd(v15, v15).m128d_f64[0];
v15.m128d_f64[1] = v27.m128d_f64[1];
v15.m128d_f64[0] = v27.m128d_f64[0] + v16 + v15.m128d_f64[0];
v7 = v15;
v8 -= 44;
}
return (unsigned int)(int)v7.m128d_f64[0];
}
| |||
32,103 | Settings::canFitShips() const | 666mxvbee[P]BattleShip/lib/Settings/Settings.cpp | bool Settings::canFitShips() const {
uint64_t totalShipCells = 0;
for (const auto& [type, count] : shipCounts) {
totalShipCells += (type * count);
}
std::cout << "Settings::canFitShips(): totalShipCells=" << totalShipCells
<< " mapSize=" << (width*height) << std::endl;
if (totalShipCells > width * height) {
std::cout << "Settings::canFitShips(): Not enough space." << std::endl;
return false;
}
std::cout << "Settings::canFitShips(): Enough space." << std::endl;
return true;
} | O2 | cpp | Settings::canFitShips() const:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rax
leaq 0x68(%rdi), %r15
xorl %r14d, %r14d
cmpq %r15, %rax
je 0x654e
movslq 0x20(%rax), %rcx
imulq 0x28(%rax), %rcx
addq %rcx, %r14
movq %rax, %rdi
callq 0x53f0
jmp 0x6533
movq 0x1ea43(%rip), %r15 # 0x24f98
leaq 0x10eb3(%rip), %rsi # 0x1740f
movq %r15, %rdi
callq 0x5340
movq %rax, %rdi
movq %r14, %rsi
callq 0x5270
leaq 0x10ec2(%rip), %rsi # 0x17438
movq %rax, %rdi
callq 0x5340
movq 0x50(%rbx), %rsi
imulq 0x48(%rbx), %rsi
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
callq 0x5190
movq 0x50(%rbx), %rax
imulq 0x48(%rbx), %rax
cmpq %rax, %r14
setbe %bl
leaq 0x10ec0(%rip), %rax # 0x1746d
leaq 0x10e8e(%rip), %rsi # 0x17442
cmovbeq %rax, %rsi
movq %r15, %rdi
callq 0x5340
movq %rax, %rdi
callq 0x5190
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
| _ZNK8Settings11canFitShipsEv:
push r15
push r14
push rbx
mov rbx, rdi
mov rax, [rdi+78h]
lea r15, [rdi+68h]
xor r14d, r14d
loc_6533:
cmp rax, r15
jz short loc_654E
movsxd rcx, dword ptr [rax+20h]
imul rcx, [rax+28h]
add r14, rcx
mov rdi, rax
call __ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base const*)
jmp short loc_6533
loc_654E:
mov r15, cs:_ZSt4cout_ptr
lea rsi, aSettingsCanfit; "Settings::canFitShips(): totalShipCells"...
mov rdi, r15
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov rsi, r14
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
lea rsi, aMapsize; " mapSize="
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rsi, [rbx+50h]
imul rsi, [rbx+48h]
mov rdi, rax
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
mov rax, [rbx+50h]
imul rax, [rbx+48h]
cmp r14, rax
setbe bl
lea rax, aSettingsCanfit_0; "Settings::canFitShips(): Enough space."
lea rsi, aSettingsCanfit_1; "Settings::canFitShips(): Not enough spa"...
cmovbe rsi, rax
mov rdi, r15
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
mov eax, ebx
pop rbx
pop r14
pop r15
retn
| long long Settings::canFitShips(Settings *this)
{
unsigned int v1; // ebx
long long v2; // rax
unsigned long long v3; // r14
long long v4; // rax
long long v5; // rax
long long v6; // rax
long long v7; // rax
const char *v8; // rsi
long long v9; // rax
v1 = (unsigned int)this;
v2 = *((_QWORD *)this + 15);
v3 = 0LL;
while ( (Settings *)v2 != (Settings *)((char *)this + 104) )
{
v3 += *(_QWORD *)(v2 + 40) * *(int *)(v2 + 32);
v2 = std::_Rb_tree_increment(v2);
}
v4 = std::operator<<<std::char_traits<char>>(&std::cout, "Settings::canFitShips(): totalShipCells=");
v5 = std::ostream::_M_insert<unsigned long>(v4, v3);
v6 = std::operator<<<std::char_traits<char>>(v5, " mapSize=");
v7 = std::ostream::_M_insert<unsigned long>(v6, *((_QWORD *)this + 9) * *((_QWORD *)this + 10));
std::endl<char,std::char_traits<char>>(v7);
LOBYTE(v1) = v3 <= *((_QWORD *)this + 9) * *((_QWORD *)this + 10);
v8 = "Settings::canFitShips(): Not enough space.";
if ( v3 <= *((_QWORD *)this + 9) * *((_QWORD *)this + 10) )
v8 = "Settings::canFitShips(): Enough space.";
v9 = std::operator<<<std::char_traits<char>>(&std::cout, v8);
std::endl<char,std::char_traits<char>>(v9);
return v1;
}
| canFitShips:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x78]
LEA R15,[RDI + 0x68]
XOR R14D,R14D
LAB_00106533:
CMP RAX,R15
JZ 0x0010654e
MOVSXD RCX,dword ptr [RAX + 0x20]
IMUL RCX,qword ptr [RAX + 0x28]
ADD R14,RCX
MOV RDI,RAX
CALL 0x001053f0
JMP 0x00106533
LAB_0010654e:
MOV R15,qword ptr [0x00124f98]
LEA RSI,[0x11740f]
MOV RDI,R15
CALL 0x00105340
MOV RDI,RAX
MOV RSI,R14
CALL 0x00105270
LEA RSI,[0x117438]
MOV RDI,RAX
CALL 0x00105340
MOV RSI,qword ptr [RBX + 0x50]
IMUL RSI,qword ptr [RBX + 0x48]
MOV RDI,RAX
CALL 0x00105270
MOV RDI,RAX
CALL 0x00105190
MOV RAX,qword ptr [RBX + 0x50]
IMUL RAX,qword ptr [RBX + 0x48]
CMP R14,RAX
SETBE BL
LEA RAX,[0x11746d]
LEA RSI,[0x117442]
CMOVBE RSI,RAX
MOV RDI,R15
CALL 0x00105340
MOV RDI,RAX
CALL 0x00105190
MOV EAX,EBX
POP RBX
POP R14
POP R15
RET
|
/* Settings::canFitShips() const */
ulong __thiscall Settings::canFitShips(Settings *this)
{
long lVar1;
long lVar2;
int *puVar3;
_Rb_tree_node_base *p_Var4;
ostream *poVar5;
char *pcVar6;
ulong uVar7;
uVar7 = 0;
for (p_Var4 = *(_Rb_tree_node_base **)(this + 0x78); puVar3 = PTR_cout_00124f98,
p_Var4 != (_Rb_tree_node_base *)(this + 0x68);
p_Var4 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var4)) {
uVar7 = uVar7 + (long)*(int *)(p_Var4 + 0x20) * *(long *)(p_Var4 + 0x28);
}
poVar5 = std::operator<<((ostream *)PTR_cout_00124f98,"Settings::canFitShips(): totalShipCells=");
poVar5 = std::ostream::_M_insert<unsigned_long>((ulong)poVar5);
poVar5 = std::operator<<(poVar5," mapSize=");
poVar5 = std::ostream::_M_insert<unsigned_long>((ulong)poVar5);
std::endl<char,std::char_traits<char>>(poVar5);
lVar1 = *(long *)(this + 0x50);
lVar2 = *(long *)(this + 0x48);
pcVar6 = "Settings::canFitShips(): Not enough space.";
if (uVar7 <= (ulong)(lVar1 * lVar2)) {
pcVar6 = "Settings::canFitShips(): Enough space.";
}
poVar5 = std::operator<<((ostream *)puVar3,pcVar6);
std::endl<char,std::char_traits<char>>(poVar5);
return CONCAT71((int7)((ulong)this >> 8),uVar7 <= (ulong)(lVar1 * lVar2)) & 0xffffffff;
}
| |
32,104 | bf_pow_ui_ui | bluesky950520[P]quickjs/libbf.c | static int bf_pow_ui_ui(bf_t *r, limb_t a1, limb_t b,
limb_t prec, bf_flags_t flags)
{
bf_t a;
int ret;
if (a1 == 10 && b <= LIMB_DIGITS) {
/* use precomputed powers. We do not round at this point
because we expect the caller to do it */
ret = bf_set_ui(r, mp_pow_dec[b]);
} else {
bf_init(r->ctx, &a);
ret = bf_set_ui(&a, a1);
ret |= bf_pow_ui(r, &a, b, prec, flags);
bf_delete(&a);
}
return ret;
} | O0 | c | bf_pow_ui_ui:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
cmpq $0xa, 0x48(%rsp)
jne 0xeba6d
cmpq $0x13, 0x40(%rsp)
ja 0xeba6d
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rcx
leaq 0x262d2(%rip), %rax # 0x111d30
movq (%rax,%rcx,8), %rsi
callq 0xe60a0
movl %eax, 0x4(%rsp)
jmp 0xebac2
movq 0x50(%rsp), %rax
movq (%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe5f70
movq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xe60a0
movl %eax, 0x4(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %r8d
leaq 0x8(%rsp), %rsi
callq 0xefac0
orl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xe93d0
movl 0x4(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
| bf_pow_ui_ui:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov [rsp+58h+var_18], rdx
mov [rsp+58h+var_20], rcx
mov [rsp+58h+var_24], r8d
cmp [rsp+58h+var_10], 0Ah
jnz short loc_EBA6D
cmp [rsp+58h+var_18], 13h
ja short loc_EBA6D
mov rdi, [rsp+58h+var_8]
mov rcx, [rsp+58h+var_18]
lea rax, mp_pow_dec
mov rsi, [rax+rcx*8]
call bf_set_ui
mov [rsp+58h+var_54], eax
jmp short loc_EBAC2
loc_EBA6D:
mov rax, [rsp+58h+var_8]
mov rdi, [rax]
lea rsi, [rsp+58h+var_50]
call bf_init
mov rsi, [rsp+58h+var_10]
lea rdi, [rsp+58h+var_50]
call bf_set_ui
mov [rsp+58h+var_54], eax
mov rdi, [rsp+58h+var_8]
mov rdx, [rsp+58h+var_18]
mov rcx, [rsp+58h+var_20]
mov r8d, [rsp+58h+var_24]
lea rsi, [rsp+58h+var_50]
call bf_pow_ui
or eax, [rsp+58h+var_54]
mov [rsp+58h+var_54], eax
lea rdi, [rsp+58h+var_50]
call bf_delete_0
loc_EBAC2:
mov eax, [rsp+58h+var_54]
add rsp, 58h
retn
| long long bf_pow_ui_ui(long long *a1, long long a2, unsigned long long a3, long long a4, unsigned int a5)
{
long long v5; // rdx
long long v6; // rcx
long long v7; // r8
long long v8; // r9
unsigned int v10; // [rsp+4h] [rbp-54h]
int v11; // [rsp+4h] [rbp-54h]
long long v12[5]; // [rsp+8h] [rbp-50h] BYREF
unsigned int v13; // [rsp+34h] [rbp-24h]
long long v14; // [rsp+38h] [rbp-20h]
unsigned long long v15; // [rsp+40h] [rbp-18h]
long long v16; // [rsp+48h] [rbp-10h]
long long *v17; // [rsp+50h] [rbp-8h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13 = a5;
if ( a2 == 10 && v15 <= 0x13 )
{
return (unsigned int)bf_set_ui((long long)v17, mp_pow_dec[v15]);
}
else
{
bf_init(*v17, (long long)v12);
v11 = bf_set_ui((long long)v12, v16);
v10 = v11 | bf_pow_ui(v17, v12, v15, v14, v13);
bf_delete_0(v12, (long long)v12, v5, v6, v7, v8);
}
return v10;
}
| bf_pow_ui_ui:
SUB RSP,0x58
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x38],RCX
MOV dword ptr [RSP + 0x34],R8D
CMP qword ptr [RSP + 0x48],0xa
JNZ 0x001eba6d
CMP qword ptr [RSP + 0x40],0x13
JA 0x001eba6d
MOV RDI,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x40]
LEA RAX,[0x211d30]
MOV RSI,qword ptr [RAX + RCX*0x8]
CALL 0x001e60a0
MOV dword ptr [RSP + 0x4],EAX
JMP 0x001ebac2
LAB_001eba6d:
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RAX]
LEA RSI,[RSP + 0x8]
CALL 0x001e5f70
MOV RSI,qword ptr [RSP + 0x48]
LEA RDI,[RSP + 0x8]
CALL 0x001e60a0
MOV dword ptr [RSP + 0x4],EAX
MOV RDI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x38]
MOV R8D,dword ptr [RSP + 0x34]
LEA RSI,[RSP + 0x8]
CALL 0x001efac0
OR EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x4],EAX
LEA RDI,[RSP + 0x8]
CALL 0x001e93d0
LAB_001ebac2:
MOV EAX,dword ptr [RSP + 0x4]
ADD RSP,0x58
RET
|
uint bf_pow_ui_ui(int8 *param_1,long param_2,ulong param_3,int8 param_4,
int4 param_5)
{
uint uVar1;
uint local_54;
int1 local_50 [44];
int4 local_24;
int8 local_20;
ulong local_18;
long local_10;
int8 *local_8;
local_24 = param_5;
local_20 = param_4;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
if ((param_2 == 10) && (param_3 < 0x14)) {
local_54 = bf_set_ui(param_1,*(int8 *)(mp_pow_dec + param_3 * 8));
}
else {
bf_init(*param_1,local_50);
uVar1 = bf_set_ui(local_50,local_10);
local_54 = bf_pow_ui(local_8,local_50,local_18,local_20,local_24);
local_54 = local_54 | uVar1;
bf_delete(local_50);
}
return local_54;
}
| |
32,105 | my_wc_mb_gb2312 | eloqsql/strings/ctype-gb2312.c | static int
my_wc_mb_gb2312(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((uint) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_gb2312_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL2;
code|=0x8080;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
} | O3 | c | my_wc_mb_gb2312:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x348e0
cmpl $0x7f, %esi
ja 0x348e1
movb %sil, (%rdx)
movl $0x1, %eax
retq
leal -0xa4(%rsi), %eax
cmpl $0x138, %eax # imm = 0x138
ja 0x348fc
movl %eax, %eax
leaq 0x13a0a9(%rip), %rsi # 0x16e9a0
jmp 0x349d7
leal -0x2c7(%rsi), %eax
cmpl $0x18a, %eax # imm = 0x18A
ja 0x34917
movl %eax, %eax
leaq 0x13a30e(%rip), %rsi # 0x16ec20
jmp 0x349d7
leal -0x2015(%rsi), %eax
cmpl $0x2fd, %eax # imm = 0x2FD
ja 0x34932
movl %eax, %eax
leaq 0x13a613(%rip), %rsi # 0x16ef40
jmp 0x349d7
leal -0x2460(%rsi), %eax
cmpl $0x1e2, %eax # imm = 0x1E2
ja 0x3494d
movl %eax, %eax
leaq 0x13abf8(%rip), %rsi # 0x16f540
jmp 0x349d7
leal -0x3000(%rsi), %eax
cmpl $0x129, %eax # imm = 0x129
ja 0x34965
movl %eax, %eax
leaq 0x13afad(%rip), %rsi # 0x16f910
jmp 0x349d7
leal -0x3220(%rsi), %eax
cmpl $0x9, %eax
ja 0x3497b
movl %eax, %eax
leaq 0x13b1f7(%rip), %rsi # 0x16fb70
jmp 0x349d7
leal -0x4e00(%rsi), %eax
cmpl $0x4d54, %eax # imm = 0x4D54
ja 0x34993
movl %eax, %eax
leaq 0x13b1ff(%rip), %rsi # 0x16fb90
jmp 0x349d7
leal -0x9c7c(%rsi), %eax
cmpl $0x66, %eax
ja 0x349a9
movl %eax, %eax
leaq 0x144c99(%rip), %rsi # 0x179640
jmp 0x349d7
leal -0x9e1f(%rsi), %eax
cmpl $0x181, %eax # imm = 0x181
ja 0x349c1
movl %eax, %eax
leaq 0x144d51(%rip), %rsi # 0x179710
jmp 0x349d7
leal -0xff01(%rsi), %eax
cmpl $0xe4, %eax
ja 0x34a0d
movl %eax, %eax
leaq 0x145049(%rip), %rsi # 0x179a20
leaq (%rsi,%rax,2), %rax
pushq %rbp
movq %rsp, %rbp
movzwl (%rax), %esi
testw %si, %si
je 0x34a09
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x34a0b
orl $0x8080, %esi # imm = 0x8080
rolw $0x8, %si
movw %si, (%rdx)
movl $0x2, %eax
jmp 0x34a0b
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
| my_wc_mb_gb2312:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_348E0
cmp esi, 7Fh
ja short loc_348E1
mov [rdx], sil
mov eax, 1
locret_348E0:
retn
loc_348E1:
lea eax, [rsi-0A4h]
cmp eax, 138h
ja short loc_348FC
mov eax, eax
lea rsi, tab_uni_gb23120
jmp loc_349D7
loc_348FC:
lea eax, [rsi-2C7h]
cmp eax, 18Ah
ja short loc_34917
mov eax, eax
lea rsi, tab_uni_gb23121
jmp loc_349D7
loc_34917:
lea eax, [rsi-2015h]
cmp eax, 2FDh
ja short loc_34932
mov eax, eax
lea rsi, tab_uni_gb23122; "*!,!"
jmp loc_349D7
loc_34932:
lea eax, [rsi-2460h]
cmp eax, 1E2h
ja short loc_3494D
mov eax, eax
lea rsi, tab_uni_gb23123; "Y\"Z\"[\"\\\"]\"^\"_\"`\"a\"b\""
jmp loc_349D7
loc_3494D:
lea eax, [rsi-3000h]
cmp eax, 129h
ja short loc_34965
mov eax, eax
lea rsi, tab_uni_gb23124; "!!\"!#!(!"
jmp short loc_349D7
loc_34965:
lea eax, [rsi-3220h]
cmp eax, 9
ja short loc_3497B
mov eax, eax
lea rsi, tab_uni_gb23125; "e\"f\"g\"h\"i\"j\"k\"l\"m\"n\""
jmp short loc_349D7
loc_3497B:
lea eax, [rsi-4E00h]
cmp eax, 4D54h
ja short loc_34993
mov eax, eax
lea rsi, tab_uni_gb23126; ";R!6"
jmp short loc_349D7
loc_34993:
lea eax, [rsi-9C7Ch]
cmp eax, 66h ; 'f'
ja short loc_349A9
mov eax, eax
lea rsi, tab_uni_gb23127
jmp short loc_349D7
loc_349A9:
lea eax, [rsi-9E1Fh]
cmp eax, 181h
ja short loc_349C1
mov eax, eax
lea rsi, tab_uni_gb23128; "qD/p&<0pyC"
jmp short loc_349D7
loc_349C1:
lea eax, [rsi-0FF01h]
cmp eax, 0E4h
ja short loc_34A0D
mov eax, eax
lea rsi, tab_uni_gb23129; "!#\"###g!%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#"...
loc_349D7:
lea rax, [rsi+rax*2]
push rbp
mov rbp, rsp
movzx esi, word ptr [rax]
test si, si
jz short loc_34A09
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_34A0B
or esi, 8080h
rol si, 8
mov [rdx], si
mov eax, 2
jmp short loc_34A0B
loc_34A09:
xor eax, eax
loc_34A0B:
pop rbp
retn
loc_34A0D:
xor eax, eax
retn
| long long my_wc_mb_gb2312(long long a1, unsigned int a2, _WORD *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rax
const char *v6; // rsi
__int16 v7; // si
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
if ( a2 > 0x7F )
{
LODWORD(v5) = a2 - 164;
if ( a2 - 164 > 0x138 )
{
LODWORD(v5) = a2 - 711;
if ( a2 - 711 > 0x18A )
{
LODWORD(v5) = a2 - 8213;
if ( a2 - 8213 > 0x2FD )
{
LODWORD(v5) = a2 - 9312;
if ( a2 - 9312 > 0x1E2 )
{
LODWORD(v5) = a2 - 12288;
if ( a2 - 12288 > 0x129 )
{
LODWORD(v5) = a2 - 12832;
if ( a2 - 12832 > 9 )
{
LODWORD(v5) = a2 - 19968;
if ( a2 - 19968 > 0x4D54 )
{
LODWORD(v5) = a2 - 40060;
if ( a2 - 40060 > 0x66 )
{
LODWORD(v5) = a2 - 40479;
if ( a2 - 40479 > 0x181 )
{
LODWORD(v5) = a2 - 65281;
if ( a2 - 65281 > 0xE4 )
return 0LL;
v5 = (unsigned int)v5;
v6 = "!#\"###g!%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F#G#H#I#J#K#L#M#"
"N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#\\#]#^#_#`#a#b#c#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#+!";
}
else
{
v5 = (unsigned int)v5;
v6 = "qD/p&<0pyC";
}
}
else
{
v5 = (unsigned int)v5;
v6 = (const char *)&tab_uni_gb23127;
}
}
else
{
v5 = (unsigned int)v5;
v6 = ";R!6";
}
}
else
{
v5 = (unsigned int)v5;
v6 = "e\"f\"g\"h\"i\"j\"k\"l\"m\"n\"";
}
}
else
{
v5 = (unsigned int)v5;
v6 = "!!\"!#!(!";
}
}
else
{
v5 = (unsigned int)v5;
v6 = "Y\"Z\"[\"\\\"]\"^\"_\"`\"a\"b\"";
}
}
else
{
v5 = (unsigned int)v5;
v6 = "*!,!";
}
}
else
{
v5 = (unsigned int)v5;
v6 = (const char *)&tab_uni_gb23121;
}
}
else
{
v5 = (unsigned int)v5;
v6 = (const char *)&tab_uni_gb23120;
}
v7 = *(_WORD *)&v6[2 * v5];
if ( v7 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
*a3 = __ROL2__(v7 | 0x8080, 8);
return 2LL;
}
}
else
{
return 0LL;
}
}
else
{
*(_BYTE *)a3 = a2;
return 1LL;
}
}
return result;
}
| my_wc_mb_gb2312:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001348e0
CMP ESI,0x7f
JA 0x001348e1
MOV byte ptr [RDX],SIL
MOV EAX,0x1
LAB_001348e0:
RET
LAB_001348e1:
LEA EAX,[RSI + -0xa4]
CMP EAX,0x138
JA 0x001348fc
MOV EAX,EAX
LEA RSI,[0x26e9a0]
JMP 0x001349d7
LAB_001348fc:
LEA EAX,[RSI + -0x2c7]
CMP EAX,0x18a
JA 0x00134917
MOV EAX,EAX
LEA RSI,[0x26ec20]
JMP 0x001349d7
LAB_00134917:
LEA EAX,[RSI + -0x2015]
CMP EAX,0x2fd
JA 0x00134932
MOV EAX,EAX
LEA RSI,[0x26ef40]
JMP 0x001349d7
LAB_00134932:
LEA EAX,[RSI + -0x2460]
CMP EAX,0x1e2
JA 0x0013494d
MOV EAX,EAX
LEA RSI,[0x26f540]
JMP 0x001349d7
LAB_0013494d:
LEA EAX,[RSI + -0x3000]
CMP EAX,0x129
JA 0x00134965
MOV EAX,EAX
LEA RSI,[0x26f910]
JMP 0x001349d7
LAB_00134965:
LEA EAX,[RSI + -0x3220]
CMP EAX,0x9
JA 0x0013497b
MOV EAX,EAX
LEA RSI,[0x26fb70]
JMP 0x001349d7
LAB_0013497b:
LEA EAX,[RSI + -0x4e00]
CMP EAX,0x4d54
JA 0x00134993
MOV EAX,EAX
LEA RSI,[0x26fb90]
JMP 0x001349d7
LAB_00134993:
LEA EAX,[RSI + -0x9c7c]
CMP EAX,0x66
JA 0x001349a9
MOV EAX,EAX
LEA RSI,[0x279640]
JMP 0x001349d7
LAB_001349a9:
LEA EAX,[RSI + -0x9e1f]
CMP EAX,0x181
JA 0x001349c1
MOV EAX,EAX
LEA RSI,[0x279710]
JMP 0x001349d7
LAB_001349c1:
LEA EAX,[RSI + -0xff01]
CMP EAX,0xe4
JA 0x00134a0d
MOV EAX,EAX
LEA RSI,[0x279a20]
LAB_001349d7:
LEA RAX,[RSI + RAX*0x2]
PUSH RBP
MOV RBP,RSP
MOVZX ESI,word ptr [RAX]
TEST SI,SI
JZ 0x00134a09
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x00134a0b
OR ESI,0x8080
ROL SI,0x8
MOV word ptr [RDX],SI
MOV EAX,0x2
JMP 0x00134a0b
LAB_00134a09:
XOR EAX,EAX
LAB_00134a0b:
POP RBP
RET
LAB_00134a0d:
XOR EAX,EAX
RET
|
int8 my_wc_mb_gb2312(int8 param_1,uint param_2,ushort *param_3,ushort *param_4)
{
int8 uVar1;
ulong uVar2;
ushort uVar3;
int1 *puVar4;
uVar1 = 0xffffff9b;
if (param_3 < param_4) {
if (0x7f < param_2) {
if (param_2 - 0xa4 < 0x139) {
uVar2 = (ulong)(param_2 - 0xa4);
puVar4 = tab_uni_gb23120;
}
else if (param_2 - 0x2c7 < 0x18b) {
uVar2 = (ulong)(param_2 - 0x2c7);
puVar4 = tab_uni_gb23121;
}
else if (param_2 - 0x2015 < 0x2fe) {
uVar2 = (ulong)(param_2 - 0x2015);
puVar4 = tab_uni_gb23122;
}
else if (param_2 - 0x2460 < 0x1e3) {
uVar2 = (ulong)(param_2 - 0x2460);
puVar4 = tab_uni_gb23123;
}
else if (param_2 - 0x3000 < 0x12a) {
uVar2 = (ulong)(param_2 - 0x3000);
puVar4 = tab_uni_gb23124;
}
else if (param_2 - 0x3220 < 10) {
uVar2 = (ulong)(param_2 - 0x3220);
puVar4 = tab_uni_gb23125;
}
else if (param_2 - 0x4e00 < 0x4d55) {
uVar2 = (ulong)(param_2 - 0x4e00);
puVar4 = &tab_uni_gb23126;
}
else if (param_2 - 0x9c7c < 0x67) {
uVar2 = (ulong)(param_2 - 0x9c7c);
puVar4 = tab_uni_gb23127;
}
else if (param_2 - 0x9e1f < 0x182) {
uVar2 = (ulong)(param_2 - 0x9e1f);
puVar4 = tab_uni_gb23128;
}
else {
uVar2 = (ulong)(param_2 - 0xff01);
if (0xe4 < param_2 - 0xff01) {
return 0;
}
puVar4 = tab_uni_gb23129;
}
if (*(ushort *)(puVar4 + uVar2 * 2) == 0) {
uVar1 = 0;
}
else {
uVar1 = 0xffffff9a;
if (param_3 + 1 <= param_4) {
uVar3 = *(ushort *)(puVar4 + uVar2 * 2) | 0x8080;
*param_3 = uVar3 << 8 | uVar3 >> 8;
uVar1 = 2;
}
}
return uVar1;
}
*(char *)param_3 = (char)param_2;
uVar1 = 1;
}
return uVar1;
}
| |
32,106 | common_log::common_log(unsigned long) | monkey531[P]llama/common/log.cpp | common_log(size_t capacity) {
file = nullptr;
prefix = false;
timestamps = false;
running = false;
t_start = t_us();
// initial message size - will be expanded if longer messages arrive
entries.resize(capacity);
for (auto & entry : entries) {
entry.msg.resize(256);
}
head = 0;
tail = 0;
resume();
} | O0 | cpp | common_log::common_log(unsigned long):
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1c6630
movq 0x28(%rsp), %rdi
addq $0x28, %rdi
movq %rdi, 0x8(%rsp)
callq 0x1c6640
movq 0x28(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x10(%rsp)
callq 0x5c0f0
movq 0x28(%rsp), %rdi
addq $0x78, %rdi
movq %rdi, 0x18(%rsp)
callq 0x1c6650
movq 0x28(%rsp), %rdi
addq $0xa0, %rdi
movq %rdi, 0x20(%rsp)
callq 0x1c6660
movq 0x28(%rsp), %rax
movq $0x0, 0x60(%rax)
movb $0x0, 0x68(%rax)
movb $0x0, 0x69(%rax)
movb $0x0, 0x6a(%rax)
callq 0x1c5aa0
movq %rax, 0x30(%rsp)
jmp 0x1c6531
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rdi)
addq $0x78, %rdi
movq 0x68(%rsp), %rsi
callq 0x1c6680
jmp 0x1c654f
movq 0x28(%rsp), %rax
addq $0x78, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1c6720
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1c6750
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1c6780
testb $0x1, %al
jne 0x1c6590
jmp 0x1c65fa
leaq 0x48(%rsp), %rdi
callq 0x1c67c0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
addq $0x10, %rdi
movl $0x100, %esi # imm = 0x100
callq 0x108a60
jmp 0x1c65b4
jmp 0x1c65b6
leaq 0x48(%rsp), %rdi
callq 0x1c67d0
jmp 0x1c657b
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x1c67f0
movq 0x18(%rsp), %rdi
callq 0x1c6810
movq 0x10(%rsp), %rdi
callq 0x5bdc0
movq 0x8(%rsp), %rdi
callq 0x1c6870
jmp 0x1c6621
movq 0x28(%rsp), %rdi
movq $0x0, 0x90(%rdi)
movq $0x0, 0x98(%rdi)
callq 0x1c5ce0
jmp 0x1c661c
addq $0x78, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x5bd10
nopl (%rax,%rax)
| _ZN10common_logC2Em:
sub rsp, 78h
mov [rsp+78h+var_8], rdi
mov [rsp+78h+var_10], rsi
mov rdi, [rsp+78h+var_8]; this
mov [rsp+78h+var_50], rdi
call _ZNSt5mutexC2Ev; std::mutex::mutex(void)
mov rdi, [rsp+78h+var_50]
add rdi, 28h ; '('; this
mov [rsp+78h+var_70], rdi
call _ZNSt6threadC2Ev; std::thread::thread(void)
mov rdi, [rsp+78h+var_50]
add rdi, 30h ; '0'; this
mov [rsp+78h+var_68], rdi
call __ZNSt18condition_variableC1Ev; std::condition_variable::condition_variable(void)
mov rdi, [rsp+78h+var_50]
add rdi, 78h ; 'x'
mov [rsp+78h+var_60], rdi
call _ZNSt6vectorI16common_log_entrySaIS0_EEC2Ev; std::vector<common_log_entry>::vector(void)
mov rdi, [rsp+78h+var_50]
add rdi, 0A0h; this
mov [rsp+78h+var_58], rdi
call _ZN16common_log_entryC2Ev; common_log_entry::common_log_entry(void)
mov rax, [rsp+78h+var_50]
mov qword ptr [rax+60h], 0
mov byte ptr [rax+68h], 0
mov byte ptr [rax+69h], 0
mov byte ptr [rax+6Ah], 0
call _ZL4t_usv; t_us(void)
mov [rsp+78h+var_48], rax
jmp short $+2
loc_1C6531:
mov rdi, [rsp+78h+var_50]
mov rax, [rsp+78h+var_48]
mov [rdi+70h], rax
add rdi, 78h ; 'x'
mov rsi, [rsp+78h+var_10]
call _ZNSt6vectorI16common_log_entrySaIS0_EE6resizeEm; std::vector<common_log_entry>::resize(ulong)
jmp short $+2
loc_1C654F:
mov rax, [rsp+78h+var_50]
add rax, 78h ; 'x'
mov [rsp+78h+var_28], rax
mov rdi, [rsp+78h+var_28]
call _ZNSt6vectorI16common_log_entrySaIS0_EE5beginEv; std::vector<common_log_entry>::begin(void)
mov [rsp+78h+var_30], rax
mov rdi, [rsp+78h+var_28]
call _ZNSt6vectorI16common_log_entrySaIS0_EE3endEv; std::vector<common_log_entry>::end(void)
mov [rsp+78h+var_38], rax
loc_1C657B:
lea rdi, [rsp+78h+var_30]
lea rsi, [rsp+78h+var_38]
call _ZN9__gnu_cxxneIP16common_log_entrySt6vectorIS1_SaIS1_EEEEbRKNS_17__normal_iteratorIT_T0_EESB_; __gnu_cxx::operator!=<common_log_entry *,std::vector<common_log_entry>>(__gnu_cxx::__normal_iterator<common_log_entry *,std::vector<common_log_entry>> const&,__gnu_cxx::__normal_iterator<common_log_entry *,std::vector<common_log_entry>> const&)
test al, 1
jnz short loc_1C6590
jmp short loc_1C65FA
loc_1C6590:
lea rdi, [rsp+78h+var_30]
call _ZNK9__gnu_cxx17__normal_iteratorIP16common_log_entrySt6vectorIS1_SaIS1_EEEdeEv; __gnu_cxx::__normal_iterator<common_log_entry *,std::vector<common_log_entry>>::operator*(void)
mov [rsp+78h+var_40], rax
mov rdi, [rsp+78h+var_40]
add rdi, 10h
mov esi, 100h
call _ZNSt6vectorIcSaIcEE6resizeEm; std::vector<char>::resize(ulong)
jmp short $+2
loc_1C65B4:
jmp short $+2
loc_1C65B6:
lea rdi, [rsp+78h+var_30]
call _ZN9__gnu_cxx17__normal_iteratorIP16common_log_entrySt6vectorIS1_SaIS1_EEEppEv; __gnu_cxx::__normal_iterator<common_log_entry *,std::vector<common_log_entry>>::operator++(void)
jmp short loc_1C657B
mov rdi, [rsp+arg_18]; this
mov rcx, rax
mov eax, edx
mov [rsp+arg_58], rcx
mov [rsp+arg_54], eax
call _ZN16common_log_entryD2Ev; common_log_entry::~common_log_entry()
mov rdi, [rsp+arg_10]
call _ZNSt6vectorI16common_log_entrySaIS0_EED2Ev; std::vector<common_log_entry>::~vector()
mov rdi, [rsp+arg_8]; this
call __ZNSt18condition_variableD1Ev; std::condition_variable::~condition_variable()
mov rdi, [rsp+arg_0]; this
call _ZNSt6threadD2Ev; std::thread::~thread()
jmp short loc_1C6621
loc_1C65FA:
mov rdi, [rsp+78h+var_50]; this
mov qword ptr [rdi+90h], 0
mov qword ptr [rdi+98h], 0
call _ZN10common_log6resumeEv; common_log::resume(void)
jmp short $+2
loc_1C661C:
add rsp, 78h
retn
loc_1C6621:
mov rdi, [rsp+arg_58]
call __Unwind_Resume
| void common_log::common_log(common_log *this, long long a2)
{
long long v2; // [rsp+38h] [rbp-40h]
long long v3; // [rsp+40h] [rbp-38h] BYREF
_QWORD v4[4]; // [rsp+48h] [rbp-30h] BYREF
long long v5; // [rsp+68h] [rbp-10h]
std::mutex *v6; // [rsp+70h] [rbp-8h]
v6 = this;
v5 = a2;
std::mutex::mutex(this);
std::thread::thread((common_log *)((char *)this + 40));
std::condition_variable::condition_variable((common_log *)((char *)this + 48));
std::vector<common_log_entry>::vector();
common_log_entry::common_log_entry((common_log *)((char *)this + 160));
*((_QWORD *)this + 12) = 0LL;
*((_BYTE *)this + 104) = 0;
*((_BYTE *)this + 105) = 0;
*((_BYTE *)this + 106) = 0;
*((_QWORD *)this + 14) = t_us((common_log *)((char *)this + 160));
std::vector<common_log_entry>::resize((char *)this + 120, v5);
v4[1] = (char *)this + 120;
v4[0] = std::vector<common_log_entry>::begin((char *)this + 120);
v3 = std::vector<common_log_entry>::end((char *)this + 120);
while ( (__gnu_cxx::operator!=<common_log_entry *,std::vector<common_log_entry>>(v4, &v3) & 1) != 0 )
{
v2 = __gnu_cxx::__normal_iterator<common_log_entry *,std::vector<common_log_entry>>::operator*(v4);
std::vector<char>::resize(v2 + 16, 256LL);
__gnu_cxx::__normal_iterator<common_log_entry *,std::vector<common_log_entry>>::operator++(v4);
}
*((_QWORD *)this + 18) = 0LL;
*((_QWORD *)this + 19) = 0LL;
common_log::resume(this);
}
| |||
32,107 | common_log::common_log(unsigned long) | monkey531[P]llama/common/log.cpp | common_log(size_t capacity) {
file = nullptr;
prefix = false;
timestamps = false;
running = false;
t_start = t_us();
// initial message size - will be expanded if longer messages arrive
entries.resize(capacity);
for (auto & entry : entries) {
entry.msg.resize(256);
}
head = 0;
tail = 0;
resume();
} | O2 | cpp | common_log::common_log(unsigned long):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %r14, %rdi
callq 0x24e70
andq $0x0, 0x88(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rbx)
andq $0x0, 0xc0(%rbx)
movups %xmm0, 0xb0(%rbx)
andq $0x0, 0x60(%rbx)
leaq 0x78(%rbx), %r15
andl $0x0, 0x67(%rbx)
callq 0x99176
movq %rax, 0x70(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x99714
movq 0x78(%rbx), %r12
movq 0x80(%rbx), %r13
cmpq %r13, %r12
je 0x996c3
addq $0x10, %r12
movl $0x100, %esi # imm = 0x100
movq %r12, %rdi
callq 0x5eeba
addq $0x20, %r12
jmp 0x996a7
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movq %rbx, %rdi
callq 0x99258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x996e1
movq %rax, %r12
leaq 0xb0(%rbx), %rdi
addq $0x28, %rbx
callq 0x4198e
movq %r15, %rdi
callq 0x9974a
movq %r14, %rdi
callq 0x25280
movq %rbx, %rdi
callq 0x9976c
movq %r12, %rdi
callq 0x251e0
| _ZN10common_logC2Em:
push r15
push r14
push r13
push r12
push rbx
mov r12, rsi
mov rbx, rdi
lea r14, [rdi+30h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
mov rdi, r14; this
call __ZNSt18condition_variableC1Ev; std::condition_variable::condition_variable(void)
and qword ptr [rbx+88h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx+78h], xmm0
and qword ptr [rbx+0C0h], 0
movups xmmword ptr [rbx+0B0h], xmm0
and qword ptr [rbx+60h], 0
lea r15, [rbx+78h]
and dword ptr [rbx+67h], 0
call _ZL4t_usv; t_us(void)
mov [rbx+70h], rax
mov rdi, r15
mov rsi, r12
call _ZNSt6vectorI16common_log_entrySaIS0_EE6resizeEm; std::vector<common_log_entry>::resize(ulong)
mov r12, [rbx+78h]
mov r13, [rbx+80h]
loc_996A7:
cmp r12, r13
jz short loc_996C3
add r12, 10h
mov esi, 100h
mov rdi, r12
call _ZNSt6vectorIcSaIcEE6resizeEm; std::vector<char>::resize(ulong)
add r12, 20h ; ' '
jmp short loc_996A7
loc_996C3:
xorps xmm0, xmm0
movups xmmword ptr [rbx+90h], xmm0
mov rdi, rbx; this
call _ZN10common_log6resumeEv; common_log::resume(void)
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
jmp short $+2
loc_996E1:
mov r12, rax
lea rdi, [rbx+0B0h]
add rbx, 28h ; '('
call _ZNSt12_Vector_baseIcSaIcEED2Ev; std::_Vector_base<char>::~_Vector_base()
mov rdi, r15
call _ZNSt6vectorI16common_log_entrySaIS0_EED2Ev; std::vector<common_log_entry>::~vector()
mov rdi, r14; this
call __ZNSt18condition_variableD1Ev; std::condition_variable::~condition_variable()
mov rdi, rbx; this
call _ZNSt6threadD2Ev; std::thread::~thread()
mov rdi, r12
call __Unwind_Resume
| void common_log::common_log(common_log *this, long long a2)
{
std::condition_variable *v3; // rdi
_QWORD *v4; // r12
_QWORD *v5; // r13
_QWORD *v6; // r12
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 1) = 0LL;
*(_OWORD *)this = 0LL;
v3 = (common_log *)((char *)this + 48);
std::condition_variable::condition_variable(v3);
*((_QWORD *)this + 17) = 0LL;
*(_OWORD *)((char *)this + 120) = 0LL;
*((_QWORD *)this + 24) = 0LL;
*((_OWORD *)this + 11) = 0LL;
*((_QWORD *)this + 12) = 0LL;
*(_DWORD *)((char *)this + 103) = 0;
*((_QWORD *)this + 14) = t_us(v3);
std::vector<common_log_entry>::resize((char *)this + 120, a2);
v4 = (_QWORD *)*((_QWORD *)this + 15);
v5 = (_QWORD *)*((_QWORD *)this + 16);
while ( v4 != v5 )
{
v6 = v4 + 2;
std::vector<char>::resize(v6, 0x100uLL);
v4 = v6 + 4;
}
*((_OWORD *)this + 9) = 0LL;
common_log::resume(this);
}
| common_log:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R12,RSI
MOV RBX,RDI
LEA R14,[RDI + 0x30]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,R14
CALL 0x00124e70
AND qword ptr [RBX + 0x88],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x78],XMM0
AND qword ptr [RBX + 0xc0],0x0
MOVUPS xmmword ptr [RBX + 0xb0],XMM0
AND qword ptr [RBX + 0x60],0x0
LEA R15,[RBX + 0x78]
AND dword ptr [RBX + 0x67],0x0
CALL 0x00199176
MOV qword ptr [RBX + 0x70],RAX
LAB_00199691:
MOV RDI,R15
MOV RSI,R12
CALL 0x00199714
MOV R12,qword ptr [RBX + 0x78]
MOV R13,qword ptr [RBX + 0x80]
LAB_001996a7:
CMP R12,R13
JZ 0x001996c3
ADD R12,0x10
LAB_001996b0:
MOV ESI,0x100
MOV RDI,R12
CALL 0x0015eeba
ADD R12,0x20
JMP 0x001996a7
LAB_001996c3:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x90],XMM0
LAB_001996cd:
MOV RDI,RBX
CALL 0x00199258
LAB_001996d5:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* common_log::common_log(unsigned long) */
void __thiscall common_log::common_log(common_log *this,ulong param_1)
{
long lVar1;
int8 uVar2;
long lVar3;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
std::condition_variable::condition_variable((condition_variable *)(this + 0x30));
*(int8 *)(this + 0x88) = 0;
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0xc0) = 0;
*(int8 *)(this + 0xb0) = 0;
*(int8 *)(this + 0xb8) = 0;
*(int8 *)(this + 0x60) = 0;
*(int4 *)(this + 0x67) = 0;
uVar2 = t_us();
*(int8 *)(this + 0x70) = uVar2;
/* try { // try from 00199691 to 0019969b has its CatchHandler @ 001996df */
std::vector<common_log_entry,std::allocator<common_log_entry>>::resize
((vector<common_log_entry,std::allocator<common_log_entry>> *)(this + 0x78),param_1);
lVar1 = *(long *)(this + 0x80);
for (lVar3 = *(long *)(this + 0x78); lVar3 != lVar1; lVar3 = lVar3 + 0x30) {
/* try { // try from 001996b0 to 001996bc has its CatchHandler @ 001996e1 */
std::vector<char,std::allocator<char>>::resize
((vector<char,std::allocator<char>> *)(lVar3 + 0x10),0x100);
}
*(int8 *)(this + 0x90) = 0;
*(int8 *)(this + 0x98) = 0;
/* try { // try from 001996cd to 001996d4 has its CatchHandler @ 001996df */
resume(this);
return;
}
| |
32,108 | ggml_backend_init_best | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend-reg.cpp | ggml_backend_t ggml_backend_init_best(void) {
ggml_backend_dev_t dev = ggml_backend_dev_by_type(GGML_BACKEND_DEVICE_TYPE_GPU);
if (!dev) {
dev = ggml_backend_dev_by_type(GGML_BACKEND_DEVICE_TYPE_CPU);
}
if (!dev) {
return nullptr;
}
return ggml_backend_dev_init(dev, nullptr);
} | O0 | cpp | ggml_backend_init_best:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
callq 0x1a570
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b2e8
xorl %edi, %edi
callq 0x1a570
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b2f9
movq $0x0, -0x8(%rbp)
jmp 0x1b30a
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1a540
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ggml_backend_init_best:
push rbp
mov rbp, rsp
sub rsp, 10h
mov edi, 1
call _ggml_backend_dev_by_type
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jnz short loc_1B2E8
xor edi, edi
call _ggml_backend_dev_by_type
mov [rbp+var_10], rax
loc_1B2E8:
cmp [rbp+var_10], 0
jnz short loc_1B2F9
mov [rbp+var_8], 0
jmp short loc_1B30A
loc_1B2F9:
mov rdi, [rbp+var_10]
xor eax, eax
mov esi, eax
call _ggml_backend_dev_init
mov [rbp+var_8], rax
loc_1B30A:
mov rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
| long long ggml_backend_init_best()
{
long long v1; // [rsp+0h] [rbp-10h]
v1 = ggml_backend_dev_by_type(1);
if ( !v1 )
v1 = ggml_backend_dev_by_type(0);
if ( v1 )
return ggml_backend_dev_init(v1, 0LL);
else
return 0LL;
}
| ggml_backend_init_best:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV EDI,0x1
CALL 0x0011a570
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x0011b2e8
XOR EDI,EDI
CALL 0x0011a570
MOV qword ptr [RBP + -0x10],RAX
LAB_0011b2e8:
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x0011b2f9
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0011b30a
LAB_0011b2f9:
MOV RDI,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0011a540
MOV qword ptr [RBP + -0x8],RAX
LAB_0011b30a:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
int8 ggml_backend_init_best(void)
{
int8 local_18;
int8 local_10;
local_18 = ggml_backend_dev_by_type(1);
if (local_18 == 0) {
local_18 = ggml_backend_dev_by_type(0);
}
if (local_18 == 0) {
local_10 = 0;
}
else {
local_10 = ggml_backend_dev_init(local_18,0);
}
return local_10;
}
| |
32,109 | ggml_backend_init_best | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend-reg.cpp | ggml_backend_t ggml_backend_init_best(void) {
ggml_backend_dev_t dev = ggml_backend_dev_by_type(GGML_BACKEND_DEVICE_TYPE_GPU);
if (!dev) {
dev = ggml_backend_dev_by_type(GGML_BACKEND_DEVICE_TYPE_CPU);
}
if (!dev) {
return nullptr;
}
return ggml_backend_dev_init(dev, nullptr);
} | O1 | cpp | ggml_backend_init_best:
pushq %rax
movl $0x1, %edi
callq 0x6750
testq %rax, %rax
jne 0x714d
xorl %edi, %edi
callq 0x6750
testq %rax, %rax
je 0x715d
movq %rax, %rdi
xorl %esi, %esi
popq %rax
jmp 0x6730
xorl %eax, %eax
popq %rcx
retq
| ggml_backend_init_best:
push rax
mov edi, 1
call _ggml_backend_dev_by_type
test rax, rax
jnz short loc_714D
xor edi, edi
call _ggml_backend_dev_by_type
loc_714D:
test rax, rax
jz short loc_715D
mov rdi, rax
xor esi, esi
pop rax
jmp _ggml_backend_dev_init
loc_715D:
xor eax, eax
pop rcx
retn
| long long ggml_backend_init_best()
{
long long v0; // rax
v0 = ggml_backend_dev_by_type(1);
if ( !v0 )
v0 = ggml_backend_dev_by_type(0);
if ( v0 )
return ggml_backend_dev_init(v0, 0LL);
else
return 0LL;
}
| ggml_backend_init_best:
PUSH RAX
MOV EDI,0x1
CALL 0x00106750
TEST RAX,RAX
JNZ 0x0010714d
XOR EDI,EDI
CALL 0x00106750
LAB_0010714d:
TEST RAX,RAX
JZ 0x0010715d
MOV RDI,RAX
XOR ESI,ESI
POP RAX
JMP 0x00106730
LAB_0010715d:
XOR EAX,EAX
POP RCX
RET
|
int8 ggml_backend_init_best(void)
{
long lVar1;
int8 uVar2;
lVar1 = ggml_backend_dev_by_type(1);
if (lVar1 == 0) {
lVar1 = ggml_backend_dev_by_type(0);
}
if (lVar1 != 0) {
uVar2 = ggml_backend_dev_init(lVar1,0);
return uVar2;
}
return 0;
}
| |
32,110 | ggml_backend_init_best | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend-reg.cpp | ggml_backend_t ggml_backend_init_best(void) {
ggml_backend_dev_t dev = ggml_backend_dev_by_type(GGML_BACKEND_DEVICE_TYPE_GPU);
if (!dev) {
dev = ggml_backend_dev_by_type(GGML_BACKEND_DEVICE_TYPE_CPU);
}
if (!dev) {
return nullptr;
}
return ggml_backend_dev_init(dev, nullptr);
} | O3 | cpp | ggml_backend_init_best:
pushq %rax
movl $0x1, %edi
callq 0x6750
testq %rax, %rax
jne 0x717c
xorl %edi, %edi
callq 0x6750
testq %rax, %rax
je 0x7187
movq %rax, %rdi
xorl %esi, %esi
popq %rax
jmp 0x6730
xorl %eax, %eax
popq %rcx
retq
| ggml_backend_init_best:
push rax
mov edi, 1
call _ggml_backend_dev_by_type
test rax, rax
jnz short loc_717C
xor edi, edi
call _ggml_backend_dev_by_type
test rax, rax
jz short loc_7187
loc_717C:
mov rdi, rax
xor esi, esi
pop rax
jmp _ggml_backend_dev_init
loc_7187:
xor eax, eax
pop rcx
retn
| long long ggml_backend_init_best()
{
long long v0; // rax
v0 = ggml_backend_dev_by_type(1);
if ( v0 )
return ggml_backend_dev_init(v0, 0LL);
v0 = ggml_backend_dev_by_type(0);
if ( v0 )
return ggml_backend_dev_init(v0, 0LL);
else
return 0LL;
}
| ggml_backend_init_best:
PUSH RAX
MOV EDI,0x1
CALL 0x00106750
TEST RAX,RAX
JNZ 0x0010717c
XOR EDI,EDI
CALL 0x00106750
TEST RAX,RAX
JZ 0x00107187
LAB_0010717c:
MOV RDI,RAX
XOR ESI,ESI
POP RAX
JMP 0x00106730
LAB_00107187:
XOR EAX,EAX
POP RCX
RET
|
int8 ggml_backend_init_best(void)
{
long lVar1;
int8 uVar2;
lVar1 = ggml_backend_dev_by_type(1);
if (lVar1 == 0) {
lVar1 = ggml_backend_dev_by_type(0);
if (lVar1 == 0) {
return 0;
}
}
uVar2 = ggml_backend_dev_init(lVar1,0);
return uVar2;
}
| |
32,111 | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | hkr04[P]cpp-mcp/common/json.hpp | bool key(string_t& val)
{
BasicJsonType k = BasicJsonType(val);
// check callback for key
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later
if (keep && ref_stack.back())
{
object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
}
return true;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x3319c
leaq 0x80(%rbx), %rdi
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
pushq $0x4
popq %rdx
movq %r15, %rcx
callq 0x3269a
movl %eax, %ebp
leaq 0x48(%rbx), %rdi
movzbl %al, %esi
callq 0x31996
testb %bpl, %bpl
je 0x32226
movq 0x10(%rbx), %rax
cmpq $0x0, -0x8(%rax)
je 0x32226
leaq 0xa8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0xb622
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x331ca
movb (%rax), %cl
leaq 0x8(%rsp), %rdi
movb (%rdi), %dl
movb %dl, (%rax)
movb %cl, (%rdi)
movq 0x8(%rax), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
movq %rax, 0x70(%rbx)
callq 0xa80c
leaq 0x18(%rsp), %rdi
callq 0xa80c
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa80c
jmp 0x3224f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xa80c
movq %rbx, %rdi
callq 0x89c0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyERSB_:
push rbp
push r15
push r14
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+48h+var_30]
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
lea rdi, [rbx+80h]
mov rsi, [rbx+10h]
sub rsi, [rbx+8]
shr rsi, 3
push 4
pop rdx
mov rcx, r15
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov ebp, eax
lea rdi, [rbx+48h]
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
test bpl, bpl
jz short loc_32226
mov rax, [rbx+10h]
cmp qword ptr [rax-8], 0
jz short loc_32226
lea rsi, [rbx+0A8h]
lea rdi, [rsp+48h+var_40]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rdi, [rax+8]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEixERSH_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator[](std::string const&)
mov cl, [rax]
lea rdi, [rsp+48h+var_40]
mov dl, [rdi]
mov [rax], dl
mov [rdi], cl
mov rcx, [rax+8]
mov rdx, [rdi+8]
mov [rax+8], rdx
mov [rdi+8], rcx
mov [rbx+70h], rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_32226:
lea rdi, [rsp+48h+var_30]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov al, 1
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_3224F
mov rbx, rax
loc_3224F:
lea rdi, [rsp+arg_10]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
| char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::key(
long long a1,
long long a2)
{
unsigned __int8 v2; // bp
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
long long v7; // rax
char v8; // cl
long long v9; // rcx
_BYTE v11[8]; // [rsp+8h] [rbp-40h] BYREF
long long v12; // [rsp+10h] [rbp-38h]
_BYTE v13[48]; // [rsp+18h] [rbp-30h] BYREF
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(v13);
v2 = std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()(
a1 + 128,
(*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3,
4LL,
v13);
std::vector<bool>::push_back(a1 + 72, v2);
if ( v2 && *(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(long long)v11,
(unsigned __int8 *)(a1 + 168),
v3,
v4,
v5,
v6);
v7 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator[](
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) + 8LL),
a2);
v8 = *(_BYTE *)v7;
*(_BYTE *)v7 = v11[0];
v11[0] = v8;
v9 = *(_QWORD *)(v7 + 8);
*(_QWORD *)(v7 + 8) = v12;
v12 = v9;
*(_QWORD *)(a1 + 112) = v7;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v11);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v13);
return 1;
}
| key:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x18]
MOV RDI,R15
CALL 0x0013319c
LEA RDI,[RBX + 0x80]
MOV RSI,qword ptr [RBX + 0x10]
SUB RSI,qword ptr [RBX + 0x8]
SHR RSI,0x3
LAB_001321b2:
PUSH 0x4
POP RDX
MOV RCX,R15
CALL 0x0013269a
MOV EBP,EAX
LEA RDI,[RBX + 0x48]
MOVZX ESI,AL
CALL 0x00131996
TEST BPL,BPL
JZ 0x00132226
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RAX + -0x8],0x0
JZ 0x00132226
LEA RSI,[RBX + 0xa8]
LEA RDI,[RSP + 0x8]
CALL 0x0010b622
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
LAB_001321f8:
MOV RSI,R14
CALL 0x001331ca
LAB_00132200:
MOV CL,byte ptr [RAX]
LEA RDI,[RSP + 0x8]
MOV DL,byte ptr [RDI]
MOV byte ptr [RAX],DL
MOV byte ptr [RDI],CL
MOV RCX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RDI + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RDI + 0x8],RCX
MOV qword ptr [RBX + 0x70],RAX
CALL 0x0010a80c
LAB_00132226:
LEA RDI,[RSP + 0x18]
CALL 0x0010a80c
MOV AL,0x1
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::key(std::__cxx11::string&) */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::key(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,string *param_1)
{
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
int8 uVar2;
bool bVar3;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*pbVar4;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_40 [8];
int8 local_38;
data local_30 [16];
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_30);
/* try { // try from 001321b2 to 001321eb has its CatchHandler @ 0013224c */
bVar3 = (bool)std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()(this + 0x80,(ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3,
4,local_30);
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x48),bVar3);
if ((bVar3 != false) && (*(long *)(*(long *)(this + 0x10) + -8) != 0)) {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_40,(basic_json *)(this + 0xa8));
/* try { // try from 001321f8 to 001321ff has its CatchHandler @ 0013223d */
pbVar4 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::operator[](*(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(*(long *)(*(long *)(this + 0x10) + -8) + 8),param_1);
bVar1 = *pbVar4;
*pbVar4 = local_40[0];
uVar2 = *(int8 *)(pbVar4 + 8);
*(int8 *)(pbVar4 + 8) = local_38;
*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(this + 0x70) = pbVar4;
local_40[0] = bVar1;
local_38 = uVar2;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_40);
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_30);
return 1;
}
| |
32,112 | flux::parser::ReturnStmt::clone() const | kvthweatt[P]FluxLang/src/parser/ast.cpp | std::unique_ptr<Stmt> ReturnStmt::clone() const {
return std::make_unique<ReturnStmt>(
keyword, value ? value->clone() : nullptr, range);
} | O1 | cpp | flux::parser::ReturnStmt::clone() const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x88(%rsi), %rsi
testq %rsi, %rsi
je 0xe65f
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
jmp 0xe667
movq $0x0, (%rsp)
movl $0x90, %edi
callq 0x6270
movq %rax, %r14
leaq 0x28(%r15), %rax
movq (%rsp), %r12
movq $0x0, (%rsp)
leaq 0x2c625(%rip), %rcx # 0x3acb0
movq %rcx, (%r14)
movups 0x8(%r15), %xmm0
movups 0x18(%r15), %xmm1
movups %xmm0, 0x8(%r14)
movups %xmm1, 0x18(%r14)
leaq 0x2be2f(%rip), %rcx # 0x3a4d8
movq %rcx, (%r14)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movups %xmm0, 0x28(%r14)
movups %xmm1, 0x38(%r14)
movups %xmm2, 0x48(%r14)
movups %xmm3, 0x58(%r14)
leaq 0x68(%r14), %rdi
movq %r14, %rax
addq $0x78, %rax
movq %rax, 0x68(%r14)
movq 0x68(%r15), %rsi
movq 0x70(%r15), %rdx
addq %rsi, %rdx
callq 0x9160
movq %r12, 0x88(%r14)
movq %r14, (%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xe707
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
testq %r12, %r12
je 0xe728
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
movl $0x90, %esi
movq %r14, %rdi
callq 0x6280
jmp 0xe73a
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xe749
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x6440
nop
| _ZNK4flux6parser10ReturnStmt5cloneEv:
push r15
push r14
push r12
push rbx
push rax
mov r15, rsi
mov rbx, rdi
mov rsi, [rsi+88h]
test rsi, rsi
jz short loc_E65F
mov rax, [rsi]
mov rdi, rsp
call qword ptr [rax+18h]
jmp short loc_E667
loc_E65F:
mov [rsp+28h+var_28], 0
loc_E667:
mov edi, 90h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
lea rax, [r15+28h]
mov r12, [rsp+28h+var_28]
mov [rsp+28h+var_28], 0
lea rcx, off_3ACB0
mov [r14], rcx
movups xmm0, xmmword ptr [r15+8]
movups xmm1, xmmword ptr [r15+18h]
movups xmmword ptr [r14+8], xmm0
movups xmmword ptr [r14+18h], xmm1
lea rcx, off_3A4D8
mov [r14], rcx
movups xmm0, xmmword ptr [rax]
movups xmm1, xmmword ptr [rax+10h]
movups xmm2, xmmword ptr [rax+20h]
movups xmm3, xmmword ptr [rax+30h]
movups xmmword ptr [r14+28h], xmm0
movups xmmword ptr [r14+38h], xmm1
movups xmmword ptr [r14+48h], xmm2
movups xmmword ptr [r14+58h], xmm3
lea rdi, [r14+68h]
mov rax, r14
add rax, 78h ; 'x'
mov [r14+68h], rax
mov rsi, [r15+68h]
mov rdx, [r15+70h]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov [r14+88h], r12
mov [rbx], r14
mov rdi, [rsp+28h+var_28]
test rdi, rdi
jz short loc_E707
mov rax, [rdi]
call qword ptr [rax+8]
loc_E707:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
test r12, r12
jz short loc_E728
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+8]
loc_E728:
mov esi, 90h; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_E73A
mov rbx, rax
loc_E73A:
mov rdi, [rsp+0]
test rdi, rdi
jz short loc_E749
mov rax, [rdi]
call qword ptr [rax+8]
loc_E749:
mov rdi, rbx
call __Unwind_Resume
| flux::parser::ReturnStmt * flux::parser::ReturnStmt::clone(flux::parser::ReturnStmt *this, long long a2)
{
long long v2; // rax
long long v4; // rsi
long long v5; // r14
long long v6; // r12
__int128 v7; // xmm1
__int128 v8; // xmm1
__int128 v9; // xmm2
__int128 v10; // xmm3
_QWORD v12[5]; // [rsp+0h] [rbp-28h] BYREF
v12[0] = v2;
v4 = *(_QWORD *)(a2 + 136);
if ( v4 )
(*(void ( **)(_QWORD *))(*(_QWORD *)v4 + 24LL))(v12);
else
v12[0] = 0LL;
v5 = operator new(0x90uLL);
v6 = v12[0];
v12[0] = 0LL;
*(_QWORD *)v5 = &off_3ACB0;
v7 = *(_OWORD *)(a2 + 24);
*(_OWORD *)(v5 + 8) = *(_OWORD *)(a2 + 8);
*(_OWORD *)(v5 + 24) = v7;
*(_QWORD *)v5 = off_3A4D8;
v8 = *(_OWORD *)(a2 + 56);
v9 = *(_OWORD *)(a2 + 72);
v10 = *(_OWORD *)(a2 + 88);
*(_OWORD *)(v5 + 40) = *(_OWORD *)(a2 + 40);
*(_OWORD *)(v5 + 56) = v8;
*(_OWORD *)(v5 + 72) = v9;
*(_OWORD *)(v5 + 88) = v10;
*(_QWORD *)(v5 + 104) = v5 + 120;
std::string::_M_construct<char *>(
(_QWORD *)(v5 + 104),
*(_BYTE **)(a2 + 104),
*(_QWORD *)(a2 + 104) + *(_QWORD *)(a2 + 112));
*(_QWORD *)(v5 + 136) = v6;
*(_QWORD *)this = v5;
if ( v12[0] )
(*(void ( **)(_QWORD))(*(_QWORD *)v12[0] + 8LL))(v12[0]);
return this;
}
| clone:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RSI + 0x88]
TEST RSI,RSI
JZ 0x0010e65f
MOV RAX,qword ptr [RSI]
MOV RDI,RSP
CALL qword ptr [RAX + 0x18]
JMP 0x0010e667
LAB_0010e65f:
MOV qword ptr [RSP],0x0
LAB_0010e667:
MOV EDI,0x90
CALL 0x00106270
MOV R14,RAX
LEA RAX,[R15 + 0x28]
MOV R12,qword ptr [RSP]
MOV qword ptr [RSP],0x0
LEA RCX,[0x13acb0]
MOV qword ptr [R14],RCX
MOVUPS XMM0,xmmword ptr [R15 + 0x8]
MOVUPS XMM1,xmmword ptr [R15 + 0x18]
MOVUPS xmmword ptr [R14 + 0x8],XMM0
MOVUPS xmmword ptr [R14 + 0x18],XMM1
LEA RCX,[0x13a4d8]
MOV qword ptr [R14],RCX
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS XMM1,xmmword ptr [RAX + 0x10]
MOVUPS XMM2,xmmword ptr [RAX + 0x20]
MOVUPS XMM3,xmmword ptr [RAX + 0x30]
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOVUPS xmmword ptr [R14 + 0x38],XMM1
MOVUPS xmmword ptr [R14 + 0x48],XMM2
MOVUPS xmmword ptr [R14 + 0x58],XMM3
LEA RDI,[R14 + 0x68]
MOV RAX,R14
ADD RAX,0x78
MOV qword ptr [R14 + 0x68],RAX
MOV RSI,qword ptr [R15 + 0x68]
MOV RDX,qword ptr [R15 + 0x70]
ADD RDX,RSI
LAB_0010e6e9:
CALL 0x00109160
LAB_0010e6ee:
MOV qword ptr [R14 + 0x88],R12
MOV qword ptr [RBX],R14
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x0010e707
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010e707:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* flux::parser::ReturnStmt::clone() const */
void flux::parser::ReturnStmt::clone(void)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
int4 uVar8;
int4 uVar9;
int4 uVar10;
int4 uVar11;
int4 uVar12;
int4 uVar13;
int4 uVar14;
int4 uVar15;
int8 uVar16;
int8 uVar17;
int8 uVar18;
long *plVar19;
long *in_RAX;
int8 *puVar20;
long in_RSI;
int8 *in_RDI;
long *local_28;
if (*(long **)(in_RSI + 0x88) == (long *)0x0) {
local_28 = (long *)0x0;
}
else {
local_28 = in_RAX;
(**(code **)(**(long **)(in_RSI + 0x88) + 0x18))(&local_28);
}
/* try { // try from 0010e667 to 0010e670 has its CatchHandler @ 0010e737 */
puVar20 = (int8 *)operator_new(0x90);
plVar19 = local_28;
local_28 = (long *)0x0;
*puVar20 = &PTR__Stmt_0013acb0;
uVar16 = *(int8 *)(in_RSI + 0x10);
uVar17 = *(int8 *)(in_RSI + 0x18);
uVar18 = *(int8 *)(in_RSI + 0x20);
puVar20[1] = *(int8 *)(in_RSI + 8);
puVar20[2] = uVar16;
puVar20[3] = uVar17;
puVar20[4] = uVar18;
*puVar20 = &PTR__ReturnStmt_0013a4d8;
uVar1 = *(int4 *)(in_RSI + 0x2c);
uVar2 = *(int4 *)(in_RSI + 0x30);
uVar3 = *(int4 *)(in_RSI + 0x34);
uVar4 = *(int4 *)(in_RSI + 0x38);
uVar5 = *(int4 *)(in_RSI + 0x3c);
uVar6 = *(int4 *)(in_RSI + 0x40);
uVar7 = *(int4 *)(in_RSI + 0x44);
uVar8 = *(int4 *)(in_RSI + 0x48);
uVar9 = *(int4 *)(in_RSI + 0x4c);
uVar10 = *(int4 *)(in_RSI + 0x50);
uVar11 = *(int4 *)(in_RSI + 0x54);
uVar12 = *(int4 *)(in_RSI + 0x58);
uVar13 = *(int4 *)(in_RSI + 0x5c);
uVar14 = *(int4 *)(in_RSI + 0x60);
uVar15 = *(int4 *)(in_RSI + 100);
*(int4 *)(puVar20 + 5) = *(int4 *)(in_RSI + 0x28);
*(int4 *)((long)puVar20 + 0x2c) = uVar1;
*(int4 *)(puVar20 + 6) = uVar2;
*(int4 *)((long)puVar20 + 0x34) = uVar3;
*(int4 *)(puVar20 + 7) = uVar4;
*(int4 *)((long)puVar20 + 0x3c) = uVar5;
*(int4 *)(puVar20 + 8) = uVar6;
*(int4 *)((long)puVar20 + 0x44) = uVar7;
*(int4 *)(puVar20 + 9) = uVar8;
*(int4 *)((long)puVar20 + 0x4c) = uVar9;
*(int4 *)(puVar20 + 10) = uVar10;
*(int4 *)((long)puVar20 + 0x54) = uVar11;
*(int4 *)(puVar20 + 0xb) = uVar12;
*(int4 *)((long)puVar20 + 0x5c) = uVar13;
*(int4 *)(puVar20 + 0xc) = uVar14;
*(int4 *)((long)puVar20 + 100) = uVar15;
puVar20[0xd] = puVar20 + 0xf;
/* try { // try from 0010e6e9 to 0010e6ed has its CatchHandler @ 0010e716 */
std::__cxx11::string::_M_construct<char*>
(puVar20 + 0xd,*(long *)(in_RSI + 0x68),
*(long *)(in_RSI + 0x70) + *(long *)(in_RSI + 0x68));
puVar20[0x11] = plVar19;
*in_RDI = puVar20;
if (local_28 != (long *)0x0) {
(**(code **)(*local_28 + 8))();
}
return;
}
| |
32,113 | add_cfg_dir | eloqsql/libmariadb/libmariadb/ma_default.c | static int add_cfg_dir(char **cfg_dirs, const char *directory)
{
int i;
for (i = 0; i < MAX_CONFIG_DIRS && cfg_dirs[i]; i++)
if (!strcmp(cfg_dirs[i], directory)) /* already present */
return 0;
if (i < MAX_CONFIG_DIRS) {
cfg_dirs[i]= strdup(directory);
return 0;
}
return 1;
} | O0 | c | add_cfg_dir:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x6, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jge 0x61815
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x6181e
jmp 0x6184e
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x14600
cmpl $0x0, %eax
jne 0x61841
movl $0x0, -0x4(%rbp)
jmp 0x6187c
jmp 0x61843
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x617f7
cmpl $0x6, -0x1c(%rbp)
jge 0x61875
movq -0x18(%rbp), %rdi
callq 0x147c0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
jmp 0x6187c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| add_cfg_dir:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], 0
loc_617F7:
xor eax, eax
cmp [rbp+var_1C], 6
mov [rbp+var_1D], al
jge short loc_61815
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
cmp qword ptr [rax+rcx*8], 0
setnz al
mov [rbp+var_1D], al
loc_61815:
mov al, [rbp+var_1D]
test al, 1
jnz short loc_6181E
jmp short loc_6184E
loc_6181E:
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
mov rdi, [rax+rcx*8]
mov rsi, [rbp+var_18]
call _strcmp
cmp eax, 0
jnz short loc_61841
mov [rbp+var_4], 0
jmp short loc_6187C
loc_61841:
jmp short $+2
loc_61843:
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_617F7
loc_6184E:
cmp [rbp+var_1C], 6
jge short loc_61875
mov rdi, [rbp+var_18]
call _strdup
mov rdx, rax
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
mov [rax+rcx*8], rdx
mov [rbp+var_4], 0
jmp short loc_6187C
loc_61875:
mov [rbp+var_4], 1
loc_6187C:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long add_cfg_dir(long long a1, long long a2)
{
bool v3; // [rsp+3h] [rbp-1Dh]
int i; // [rsp+4h] [rbp-1Ch]
for ( i = 0; ; ++i )
{
v3 = 0;
if ( i < 6 )
v3 = *(_QWORD *)(a1 + 8LL * i) != 0LL;
if ( !v3 )
break;
if ( !(unsigned int)strcmp(*(_QWORD *)(a1 + 8LL * i), a2) )
return 0;
}
if ( i >= 6 )
{
return 1;
}
else
{
*(_QWORD *)(a1 + 8LL * i) = strdup(a2);
return 0;
}
}
| add_cfg_dir:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],0x0
LAB_001617f7:
XOR EAX,EAX
CMP dword ptr [RBP + -0x1c],0x6
MOV byte ptr [RBP + -0x1d],AL
JGE 0x00161815
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
CMP qword ptr [RAX + RCX*0x8],0x0
SETNZ AL
MOV byte ptr [RBP + -0x1d],AL
LAB_00161815:
MOV AL,byte ptr [RBP + -0x1d]
TEST AL,0x1
JNZ 0x0016181e
JMP 0x0016184e
LAB_0016181e:
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00114600
CMP EAX,0x0
JNZ 0x00161841
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016187c
LAB_00161841:
JMP 0x00161843
LAB_00161843:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001617f7
LAB_0016184e:
CMP dword ptr [RBP + -0x1c],0x6
JGE 0x00161875
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001147c0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016187c
LAB_00161875:
MOV dword ptr [RBP + -0x4],0x1
LAB_0016187c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 add_cfg_dir(long param_1,char *param_2)
{
int iVar1;
char *pcVar2;
bool bVar3;
int local_24;
local_24 = 0;
while( true ) {
bVar3 = false;
if (local_24 < 6) {
bVar3 = *(long *)(param_1 + (long)local_24 * 8) != 0;
}
if (!bVar3) break;
iVar1 = strcmp(*(char **)(param_1 + (long)local_24 * 8),param_2);
if (iVar1 == 0) {
return 0;
}
local_24 = local_24 + 1;
}
if (local_24 < 6) {
pcVar2 = strdup(param_2);
*(char **)(param_1 + (long)local_24 * 8) = pcVar2;
return 0;
}
return 1;
}
| |
32,114 | void ImPlot3D::RenderMarkers<ImPlot3D::Getter3DPoints>(ImPlot3D::Getter3DPoints const&, int, float, bool, unsigned int, bool, unsigned int, float) | zkingston[P]unknot/build_O1/_deps/implot3d-src/implot3d_items.cpp | void RenderMarkers(const _Getter& getter, ImPlot3DMarker marker, float size, bool rend_fill, ImU32 col_fill, bool rend_line, ImU32 col_line, float weight) {
if (rend_fill) {
switch (marker) {
case ImPlot3DMarker_Circle: RenderPrimitives<RendererMarkersFill>(getter, MARKER_FILL_CIRCLE, 10, size, col_fill); break;
case ImPlot3DMarker_Square: RenderPrimitives<RendererMarkersFill>(getter, MARKER_FILL_SQUARE, 4, size, col_fill); break;
case ImPlot3DMarker_Diamond: RenderPrimitives<RendererMarkersFill>(getter, MARKER_FILL_DIAMOND, 4, size, col_fill); break;
case ImPlot3DMarker_Up: RenderPrimitives<RendererMarkersFill>(getter, MARKER_FILL_UP, 3, size, col_fill); break;
case ImPlot3DMarker_Down: RenderPrimitives<RendererMarkersFill>(getter, MARKER_FILL_DOWN, 3, size, col_fill); break;
case ImPlot3DMarker_Left: RenderPrimitives<RendererMarkersFill>(getter, MARKER_FILL_LEFT, 3, size, col_fill); break;
case ImPlot3DMarker_Right: RenderPrimitives<RendererMarkersFill>(getter, MARKER_FILL_RIGHT, 3, size, col_fill); break;
}
}
if (rend_line) {
switch (marker) {
case ImPlot3DMarker_Circle: RenderPrimitives<RendererMarkersLine>(getter, MARKER_LINE_CIRCLE, 20, size, weight, col_line); break;
case ImPlot3DMarker_Square: RenderPrimitives<RendererMarkersLine>(getter, MARKER_LINE_SQUARE, 8, size, weight, col_line); break;
case ImPlot3DMarker_Diamond: RenderPrimitives<RendererMarkersLine>(getter, MARKER_LINE_DIAMOND, 8, size, weight, col_line); break;
case ImPlot3DMarker_Up: RenderPrimitives<RendererMarkersLine>(getter, MARKER_LINE_UP, 6, size, weight, col_line); break;
case ImPlot3DMarker_Down: RenderPrimitives<RendererMarkersLine>(getter, MARKER_LINE_DOWN, 6, size, weight, col_line); break;
case ImPlot3DMarker_Left: RenderPrimitives<RendererMarkersLine>(getter, MARKER_LINE_LEFT, 6, size, weight, col_line); break;
case ImPlot3DMarker_Right: RenderPrimitives<RendererMarkersLine>(getter, MARKER_LINE_RIGHT, 6, size, weight, col_line); break;
case ImPlot3DMarker_Asterisk: RenderPrimitives<RendererMarkersLine>(getter, MARKER_LINE_ASTERISK, 6, size, weight, col_line); break;
case ImPlot3DMarker_Plus: RenderPrimitives<RendererMarkersLine>(getter, MARKER_LINE_PLUS, 4, size, weight, col_line); break;
case ImPlot3DMarker_Cross: RenderPrimitives<RendererMarkersLine>(getter, MARKER_LINE_CROSS, 4, size, weight, col_line); break;
}
}
} | O1 | cpp | void ImPlot3D::RenderMarkers<ImPlot3D::Getter3DPoints>(ImPlot3D::Getter3DPoints const&, int, float, bool, unsigned int, bool, unsigned int, float):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r9d, %ebx
movl %r8d, %r15d
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r12d
testl %edx, %edx
je 0x65341
cmpl $0x6, %ebp
ja 0x65341
movss %xmm1, 0xc(%rsp)
leaq 0x230dc2(%rip), %rax # 0x296088
movslq (%rax,%r12,4), %rdx
addq %rax, %rdx
movss %xmm0, 0x8(%rsp)
jmpq *%rdx
leaq 0x234224(%rip), %rsi # 0x299500
movq %r14, %rdi
movl $0xa, %edx
jmp 0x6532a
leaq 0x2342c3(%rip), %rsi # 0x2995b0
jmp 0x65322
leaq 0x23427a(%rip), %rsi # 0x299570
jmp 0x65308
leaq 0x234291(%rip), %rsi # 0x299590
jmp 0x65322
leaq 0x234248(%rip), %rsi # 0x299550
movq %r14, %rdi
movl $0x4, %edx
jmp 0x6532a
leaq 0x2342b7(%rip), %rsi # 0x2995d0
jmp 0x65322
leaq 0x2342ce(%rip), %rsi # 0x2995f0
movq %r14, %rdi
movl $0x3, %edx
movss 0x8(%rsp), %xmm0
callq 0x653f3
movss 0x8(%rsp), %xmm0
movss 0xc(%rsp), %xmm1
testb %r15b, %r15b
je 0x6536c
cmpl $0x9, %ebp
ja 0x6536c
leaq 0x230d52(%rip), %rax # 0x2960a4
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x2342ae(%rip), %rsi # 0x299610
movq %r14, %rdi
movl $0x14, %edx
jmp 0x653e0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2343e0(%rip), %rsi # 0x299760
jmp 0x653c7
leaq 0x234467(%rip), %rsi # 0x2997f0
jmp 0x653c7
leaq 0x23435e(%rip), %rsi # 0x2996f0
jmp 0x653ad
leaq 0x234395(%rip), %rsi # 0x299730
jmp 0x653c7
leaq 0x23449c(%rip), %rsi # 0x299840
jmp 0x653d8
leaq 0x234303(%rip), %rsi # 0x2996b0
movq %r14, %rdi
movl $0x8, %edx
jmp 0x653e0
leaq 0x2343d2(%rip), %rsi # 0x299790
jmp 0x653c7
leaq 0x2343f9(%rip), %rsi # 0x2997c0
movq %r14, %rdi
movl $0x6, %edx
jmp 0x653e0
leaq 0x234448(%rip), %rsi # 0x299820
movq %r14, %rdi
movl $0x4, %edx
movl %ebx, %ecx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x659c8
| _ZN8ImPlot3D13RenderMarkersINS_9GetterXYZINS_10IndexerIdxIdEES3_S3_EEEEvRKT_ifbjbjf:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov ebx, r9d
mov r15d, r8d
mov ebp, esi
mov r14, rdi
mov r12d, esi
test edx, edx
jz def_652D3; jumptable 00000000000652D3 default case
cmp ebp, 6; switch 7 cases
ja def_652D3; jumptable 00000000000652D3 default case
movss [rsp+38h+var_2C], xmm1
lea rax, jpt_652D3
movsxd rdx, ds:(jpt_652D3 - 296088h)[rax+r12*4]
add rdx, rax
movss [rsp+38h+var_30], xmm0
jmp rdx; switch jump
loc_652D5:
lea rsi, _ZN8ImPlot3DL18MARKER_FILL_CIRCLEE; jumptable 00000000000652D3 case 0
mov rdi, r14
mov edx, 0Ah
jmp short loc_6532A
loc_652E6:
lea rsi, _ZN8ImPlot3DL16MARKER_FILL_DOWNE; jumptable 00000000000652D3 case 4
jmp short loc_65322
loc_652EF:
lea rsi, _ZN8ImPlot3DL19MARKER_FILL_DIAMONDE; jumptable 00000000000652D3 case 2
jmp short loc_65308
loc_652F8:
lea rsi, _ZN8ImPlot3DL14MARKER_FILL_UPE; jumptable 00000000000652D3 case 3
jmp short loc_65322
loc_65301:
lea rsi, _ZN8ImPlot3DL18MARKER_FILL_SQUAREE; jumptable 00000000000652D3 case 1
loc_65308:
mov rdi, r14
mov edx, 4
jmp short loc_6532A
loc_65312:
lea rsi, _ZN8ImPlot3DL16MARKER_FILL_LEFTE; jumptable 00000000000652D3 case 5
jmp short loc_65322
loc_6531B:
lea rsi, _ZN8ImPlot3DL17MARKER_FILL_RIGHTE; jumptable 00000000000652D3 case 6
loc_65322:
mov rdi, r14
mov edx, 3
loc_6532A:
movss xmm0, [rsp+38h+var_30]
call _ZN8ImPlot3D16RenderPrimitivesINS_19RendererMarkersFillENS_9GetterXYZINS_10IndexerIdxIdEES4_S4_EEJPK6ImVec2ifjEEEvRKT0_DpT1_; ImPlot3D::RenderPrimitives<ImPlot3D::RendererMarkersFill,ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>,ImVec2 const*,int,float,uint>(ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>> const&,ImVec2 const*,int,float,uint)
movss xmm0, [rsp+38h+var_30]
movss xmm1, [rsp+38h+var_2C]
def_652D3:
test r15b, r15b; jumptable 00000000000652D3 default case
jz short def_65359; jumptable 0000000000065359 default case
cmp ebp, 9; switch 10 cases
ja short def_65359; jumptable 0000000000065359 default case
lea rax, jpt_65359
movsxd rcx, ds:(jpt_65359 - 2960A4h)[rax+r12*4]
add rcx, rax
jmp rcx; switch jump
loc_6535B:
lea rsi, _ZN8ImPlot3DL18MARKER_LINE_CIRCLEE; jumptable 0000000000065359 case 0
mov rdi, r14
mov edx, 14h
jmp short loc_653E0
def_65359:
add rsp, 10h; jumptable 0000000000065359 default case
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_65379:
lea rsi, _ZN8ImPlot3DL16MARKER_LINE_DOWNE; jumptable 0000000000065359 case 4
jmp short loc_653C7
loc_65382:
lea rsi, _ZN8ImPlot3DL20MARKER_LINE_ASTERISKE; jumptable 0000000000065359 case 9
jmp short loc_653C7
loc_6538B:
lea rsi, _ZN8ImPlot3DL19MARKER_LINE_DIAMONDE; jumptable 0000000000065359 case 2
jmp short loc_653AD
loc_65394:
lea rsi, _ZN8ImPlot3DL14MARKER_LINE_UPE; jumptable 0000000000065359 case 3
jmp short loc_653C7
loc_6539D:
lea rsi, _ZN8ImPlot3DL17MARKER_LINE_CROSSE; jumptable 0000000000065359 case 7
jmp short loc_653D8
loc_653A6:
lea rsi, _ZN8ImPlot3DL18MARKER_LINE_SQUAREE; jumptable 0000000000065359 case 1
loc_653AD:
mov rdi, r14
mov edx, 8
jmp short loc_653E0
loc_653B7:
lea rsi, _ZN8ImPlot3DL16MARKER_LINE_LEFTE; jumptable 0000000000065359 case 5
jmp short loc_653C7
loc_653C0:
lea rsi, _ZN8ImPlot3DL17MARKER_LINE_RIGHTE; jumptable 0000000000065359 case 6
loc_653C7:
mov rdi, r14
mov edx, 6
jmp short loc_653E0
loc_653D1:
lea rsi, _ZN8ImPlot3DL16MARKER_LINE_PLUSE; jumptable 0000000000065359 case 8
loc_653D8:
mov rdi, r14
mov edx, 4
loc_653E0:
mov ecx, ebx
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _ZN8ImPlot3D16RenderPrimitivesINS_19RendererMarkersLineENS_9GetterXYZINS_10IndexerIdxIdEES4_S4_EEJPK6ImVec2iffjEEEvRKT0_DpT1_; ImPlot3D::RenderPrimitives<ImPlot3D::RendererMarkersLine,ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>,ImVec2 const*,int,float,float,uint>(ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>> const&,ImVec2 const*,int,float,float,uint)
| long long ImPlot3D::RenderMarkers<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>(
long long a1,
int a2,
int a3,
float a4,
long long a5,
char a6,
unsigned int a7)
{
void *v10; // rsi
long long v11; // rdx
long long result; // rax
void *v13; // rsi
long long v14; // rdx
if ( a3 )
{
switch ( a2 )
{
case 0:
v10 = &ImPlot3D::MARKER_FILL_CIRCLE;
v11 = 10LL;
goto LABEL_12;
case 1:
v10 = &ImPlot3D::MARKER_FILL_SQUARE;
goto LABEL_8;
case 2:
v10 = &ImPlot3D::MARKER_FILL_DIAMOND;
LABEL_8:
v11 = 4LL;
goto LABEL_12;
case 3:
v10 = &ImPlot3D::MARKER_FILL_UP;
goto LABEL_11;
case 4:
v10 = &ImPlot3D::MARKER_FILL_DOWN;
goto LABEL_11;
case 5:
v10 = &ImPlot3D::MARKER_FILL_LEFT;
goto LABEL_11;
case 6:
v10 = &ImPlot3D::MARKER_FILL_RIGHT;
LABEL_11:
v11 = 3LL;
LABEL_12:
result = ImPlot3D::RenderPrimitives<ImPlot3D::RendererMarkersFill,ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>,ImVec2 const*,int,float,unsigned int>(
a1,
v10,
v11,
a4);
break;
default:
break;
}
}
if ( a6 )
{
switch ( a2 )
{
case 0:
v13 = &ImPlot3D::MARKER_LINE_CIRCLE;
v14 = 20LL;
goto LABEL_29;
case 1:
v13 = &ImPlot3D::MARKER_LINE_SQUARE;
goto LABEL_23;
case 2:
v13 = &ImPlot3D::MARKER_LINE_DIAMOND;
LABEL_23:
v14 = 8LL;
goto LABEL_29;
case 3:
v13 = &ImPlot3D::MARKER_LINE_UP;
goto LABEL_26;
case 4:
v13 = &ImPlot3D::MARKER_LINE_DOWN;
goto LABEL_26;
case 5:
v13 = &ImPlot3D::MARKER_LINE_LEFT;
goto LABEL_26;
case 6:
v13 = &ImPlot3D::MARKER_LINE_RIGHT;
goto LABEL_26;
case 7:
v13 = &ImPlot3D::MARKER_LINE_CROSS;
goto LABEL_28;
case 8:
v13 = &ImPlot3D::MARKER_LINE_PLUS;
LABEL_28:
v14 = 4LL;
goto LABEL_29;
case 9:
v13 = &ImPlot3D::MARKER_LINE_ASTERISK;
LABEL_26:
v14 = 6LL;
LABEL_29:
result = ImPlot3D::RenderPrimitives<ImPlot3D::RendererMarkersLine,ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>,ImVec2 const*,int,float,float,unsigned int>(
a1,
v13,
v14,
a7);
break;
default:
return result;
}
}
return result;
}
| RenderMarkers<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV EBX,R9D
MOV R15D,R8D
MOV EBP,ESI
MOV R14,RDI
MOV R12D,ESI
TEST EDX,EDX
JZ 0x00165341
CMP EBP,0x6
JA 0x00165341
MOVSS dword ptr [RSP + 0xc],XMM1
LEA RAX,[0x396088]
MOVSXD RDX,dword ptr [RAX + R12*0x4]
ADD RDX,RAX
MOVSS dword ptr [RSP + 0x8],XMM0
switchD:
JMP RDX
caseD_0:
LEA RSI,[0x399500]
MOV RDI,R14
MOV EDX,0xa
JMP 0x0016532a
caseD_4:
LEA RSI,[0x3995b0]
JMP 0x00165322
caseD_2:
LEA RSI,[0x399570]
JMP 0x00165308
caseD_3:
LEA RSI,[0x399590]
JMP 0x00165322
caseD_1:
LEA RSI,[0x399550]
LAB_00165308:
MOV RDI,R14
MOV EDX,0x4
JMP 0x0016532a
caseD_5:
LEA RSI,[0x3995d0]
JMP 0x00165322
caseD_6:
LEA RSI,[0x3995f0]
LAB_00165322:
MOV RDI,R14
MOV EDX,0x3
LAB_0016532a:
MOVSS XMM0,dword ptr [RSP + 0x8]
CALL 0x001653f3
MOVSS XMM0,dword ptr [RSP + 0x8]
MOVSS XMM1,dword ptr [RSP + 0xc]
default:
TEST R15B,R15B
JZ 0x0016536c
CMP EBP,0x9
JA 0x0016536c
LEA RAX,[0x3960a4]
MOVSXD RCX,dword ptr [RAX + R12*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_0:
LEA RSI,[0x399610]
MOV RDI,R14
MOV EDX,0x14
JMP 0x001653e0
default:
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
caseD_4:
LEA RSI,[0x399760]
JMP 0x001653c7
caseD_9:
LEA RSI,[0x3997f0]
JMP 0x001653c7
caseD_2:
LEA RSI,[0x3996f0]
JMP 0x001653ad
caseD_3:
LEA RSI,[0x399730]
JMP 0x001653c7
caseD_7:
LEA RSI,[0x399840]
JMP 0x001653d8
caseD_1:
LEA RSI,[0x3996b0]
LAB_001653ad:
MOV RDI,R14
MOV EDX,0x8
JMP 0x001653e0
caseD_5:
LEA RSI,[0x399790]
JMP 0x001653c7
caseD_6:
LEA RSI,[0x3997c0]
LAB_001653c7:
MOV RDI,R14
MOV EDX,0x6
JMP 0x001653e0
caseD_8:
LEA RSI,[0x399820]
LAB_001653d8:
MOV RDI,R14
MOV EDX,0x4
LAB_001653e0:
MOV ECX,EBX
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x001659c8
|
/* void ImPlot3D::RenderMarkers<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,
ImPlot3D::IndexerIdx<double>, ImPlot3D::IndexerIdx<double> >
>(ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>, ImPlot3D::IndexerIdx<double>,
ImPlot3D::IndexerIdx<double> > const&, int, float, bool, unsigned int, bool, unsigned int, float)
*/
void ImPlot3D::
RenderMarkers<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>
(GetterXYZ *param_1,int param_2,float param_3,bool param_4,uint param_5,bool param_6,
uint param_7,float param_8)
{
int iVar1;
int7 in_register_00000011;
int1 *puVar2;
if ((int)CONCAT71(in_register_00000011,param_4) == 0) goto switchD_001652d3_default;
switch(param_2) {
case 0:
puVar2 = MARKER_FILL_CIRCLE;
iVar1 = 10;
goto LAB_0016532a;
case 1:
puVar2 = MARKER_FILL_SQUARE;
goto LAB_00165308;
case 2:
puVar2 = MARKER_FILL_DIAMOND;
LAB_00165308:
iVar1 = 4;
goto LAB_0016532a;
case 3:
puVar2 = MARKER_FILL_UP;
break;
case 4:
puVar2 = MARKER_FILL_DOWN;
break;
case 5:
puVar2 = MARKER_FILL_LEFT;
break;
case 6:
puVar2 = MARKER_FILL_RIGHT;
break;
default:
goto switchD_001652d3_default;
}
iVar1 = 3;
LAB_0016532a:
RenderPrimitives<ImPlot3D::RendererMarkersFill,ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>,ImVec2_const*,int,float,unsigned_int>
(param_1,puVar2,iVar1,param_3,param_5);
switchD_001652d3_default:
if (!param_6) {
switchD_00165359_default:
return;
}
switch(param_2) {
case 0:
puVar2 = MARKER_LINE_CIRCLE;
iVar1 = 0x14;
goto LAB_001653e0;
case 1:
puVar2 = MARKER_LINE_SQUARE;
goto LAB_001653ad;
case 2:
puVar2 = MARKER_LINE_DIAMOND;
LAB_001653ad:
iVar1 = 8;
goto LAB_001653e0;
case 3:
puVar2 = MARKER_LINE_UP;
break;
case 4:
puVar2 = MARKER_LINE_DOWN;
break;
case 5:
puVar2 = MARKER_LINE_LEFT;
break;
case 6:
puVar2 = MARKER_LINE_RIGHT;
break;
case 7:
puVar2 = MARKER_LINE_CROSS;
goto LAB_001653d8;
case 8:
puVar2 = MARKER_LINE_PLUS;
LAB_001653d8:
iVar1 = 4;
goto LAB_001653e0;
case 9:
puVar2 = MARKER_LINE_ASTERISK;
break;
default:
goto switchD_00165359_default;
}
iVar1 = 6;
LAB_001653e0:
RenderPrimitives<ImPlot3D::RendererMarkersLine,ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>,ImVec2_const*,int,float,float,unsigned_int>
(param_1,puVar2,iVar1,param_3,param_8,param_7);
return;
}
| |
32,115 | string_from[abi:cxx11](llama_context const*, std::vector<int, std::allocator<int>> const&) | monkey531[P]llama/common/common.cpp | std::string string_from(const struct llama_context * ctx, const std::vector<llama_token> & tokens) {
std::stringstream buf;
buf << "[ ";
bool first = true;
for (const auto & token : tokens) {
if (!first) {
buf << ", ";
} else {
first = false;
}
auto detokenized = common_token_to_piece(ctx, token);
detokenized.erase(
std::remove_if(
detokenized.begin(),
detokenized.end(),
[](const unsigned char c) { return !std::isprint(c); }),
detokenized.end());
buf << "'" << detokenized << "'"
<< ":" << std::to_string(token);
}
buf << " ]";
return buf.str();
} | O0 | cpp | string_from[abi:cxx11](llama_context const*, std::vector<int, std::allocator<int>> const&):
subq $0x2a8, %rsp # imm = 0x2A8
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x2a0(%rsp)
movq %rsi, 0x298(%rsp)
movq %rdx, 0x290(%rsp)
leaq 0x108(%rsp), %rdi
callq 0x5a560
leaq 0x118(%rsp), %rdi
leaq 0x1238cb(%rip), %rsi # 0x210833
callq 0x5aa20
jmp 0xecf6f
movb $0x1, 0xfb(%rsp)
movq 0x290(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rdi
callq 0x909f0
movq %rax, 0xe8(%rsp)
movq 0xf0(%rsp), %rdi
callq 0x90a20
movq %rax, 0xe0(%rsp)
leaq 0xe8(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0xf7870
testb $0x1, %al
jne 0xecfcf
jmp 0xed208
leaq 0xe8(%rsp), %rdi
callq 0xf78b0
movq %rax, 0xd8(%rsp)
testb $0x1, 0xfb(%rsp)
jne 0xed01f
leaq 0x118(%rsp), %rdi
leaq 0x1241ed(%rip), %rsi # 0x2111ea
callq 0x5aa20
jmp 0xed004
jmp 0xed027
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0xed24c
movb $0x0, 0xfb(%rsp)
movq 0x298(%rsp), %rsi
movq 0xd8(%rsp), %rax
movl (%rax), %edx
leaq 0xb8(%rsp), %rdi
movl $0x1, %ecx
callq 0xed270
jmp 0xed04d
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x5a860
movq 0x38(%rsp), %rdi
movq %rax, 0xa0(%rsp)
callq 0x5a960
movq %rax, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0xed2e0
movq %rax, 0x40(%rsp)
jmp 0xed095
movq 0x40(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xbe050
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x5a960
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xbe050
movq 0x28(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x5a7a0
movq %rax, 0x30(%rsp)
jmp 0xed107
movq 0x30(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0x118(%rsp), %rdi
leaq 0x12244b(%rip), %rsi # 0x20f56b
callq 0x5aa20
movq %rax, 0x20(%rsp)
jmp 0xed12c
movq 0x20(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x5a550
movq %rax, 0x18(%rsp)
jmp 0xed145
movq 0x18(%rsp), %rdi
leaq 0x12241a(%rip), %rsi # 0x20f56b
callq 0x5aa20
movq %rax, 0x10(%rsp)
jmp 0xed15d
movq 0x10(%rsp), %rdi
leaq 0x1241cc(%rip), %rsi # 0x211335
callq 0x5aa20
movq %rax, 0x8(%rsp)
jmp 0xed175
movq 0xd8(%rsp), %rax
movl (%rax), %esi
leaq 0x58(%rsp), %rdi
callq 0x62340
jmp 0xed18b
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x5a550
jmp 0xed19c
leaq 0x58(%rsp), %rdi
callq 0x5b598
leaq 0xb8(%rsp), %rdi
callq 0x5b598
leaq 0xe8(%rsp), %rdi
callq 0xf78c0
jmp 0xecfb1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0xed1f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5b598
leaq 0xb8(%rsp), %rdi
callq 0x5b598
jmp 0xed24c
leaq 0x118(%rsp), %rdi
leaq 0x12361f(%rip), %rsi # 0x210836
callq 0x5aa20
jmp 0xed21e
movq 0x48(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0x5ac90
jmp 0xed232
leaq 0x108(%rsp), %rdi
callq 0x5a680
movq 0x50(%rsp), %rax
addq $0x2a8, %rsp # imm = 0x2A8
retq
leaq 0x108(%rsp), %rdi
callq 0x5a680
movq 0x100(%rsp), %rdi
callq 0x5abc0
nopw %cs:(%rax,%rax)
| _Z11string_fromB5cxx11PK13llama_contextRKSt6vectorIiSaIiEE:
sub rsp, 2A8h
mov [rsp+2A8h+var_260], rdi
mov rax, rdi
mov [rsp+2A8h+var_258], rax
mov [rsp+2A8h+var_8], rdi
mov [rsp+2A8h+var_10], rsi
mov [rsp+2A8h+var_18], rdx
lea rdi, [rsp+2A8h+var_1A0]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea rdi, [rsp+2A8h+var_190]
lea rsi, asc_210833; "[ "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_ECF6F:
mov [rsp+2A8h+var_1AD], 1
mov rax, [rsp+2A8h+var_18]
mov [rsp+2A8h+var_1B8], rax
mov rdi, [rsp+2A8h+var_1B8]
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rsp+2A8h+var_1C0], rax
mov rdi, [rsp+2A8h+var_1B8]
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov [rsp+2A8h+var_1C8], rax
loc_ECFB1:
lea rdi, [rsp+2A8h+var_1C0]
lea rsi, [rsp+2A8h+var_1C8]
call _ZN9__gnu_cxxneIPKiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESB_; __gnu_cxx::operator!=<int const*,std::vector<int>>(__gnu_cxx::__normal_iterator<int const*,std::vector<int>> const&,__gnu_cxx::__normal_iterator<int const*,std::vector<int>> const&)
test al, 1
jnz short loc_ECFCF
jmp loc_ED208
loc_ECFCF:
lea rdi, [rsp+2A8h+var_1C0]
call _ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEdeEv; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator*(void)
mov [rsp+2A8h+var_1D0], rax
test [rsp+2A8h+var_1AD], 1
jnz short loc_ED01F
lea rdi, [rsp+2A8h+var_190]
lea rsi, aZuD+6; ", "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_ED004:
jmp short loc_ED027
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
jmp loc_ED24C
loc_ED01F:
mov [rsp+2A8h+var_1AD], 0
loc_ED027:
mov rsi, [rsp+2A8h+var_10]
mov rax, [rsp+2A8h+var_1D0]
mov edx, [rax]
lea rdi, [rsp+2A8h+var_1F0]
mov ecx, 1
call _Z21common_token_to_pieceB5cxx11PK13llama_contextib; common_token_to_piece(llama_context const*,int,bool)
jmp short $+2
loc_ED04D:
lea rdi, [rsp+2A8h+var_1F0]
mov [rsp+2A8h+var_270], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov rdi, [rsp+2A8h+var_270]
mov [rsp+2A8h+var_208], rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov [rsp+2A8h+var_210], rax
mov rdi, [rsp+2A8h+var_208]
mov rsi, [rsp+2A8h+var_210]
call _ZSt9remove_ifIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEZ11string_fromPK13llama_contextRKSt6vectorIiSaIiEEE3$_0ET_SJ_SJ_T0_; std::remove_if<__gnu_cxx::__normal_iterator<char *,std::string>,string_from(llama_context const*,std::vector<int> const&)::$_0>(__gnu_cxx::__normal_iterator<char *,std::string>,__gnu_cxx::__normal_iterator<char *,std::string>,string_from(llama_context const*,std::vector<int> const&)::$_0)
mov [rsp+2A8h+var_268], rax
jmp short $+2
loc_ED095:
mov rax, [rsp+2A8h+var_268]
mov [rsp+2A8h+var_200], rax
lea rdi, [rsp+2A8h+var_1F8]
lea rsi, [rsp+2A8h+var_200]
call _ZN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2IPcEERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameISC_SB_EE7__valueES8_E6__typeEEE
lea rdi, [rsp+2A8h+var_1F0]
mov [rsp+2A8h+var_280], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov [rsp+2A8h+var_228], rax
lea rdi, [rsp+2A8h+var_220]
lea rsi, [rsp+2A8h+var_228]
call _ZN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2IPcEERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameISC_SB_EE7__valueES8_E6__typeEEE
mov rdi, [rsp+2A8h+var_280]
mov rsi, [rsp+2A8h+var_1F8]
mov rdx, [rsp+2A8h+var_220]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5eraseEN9__gnu_cxx17__normal_iteratorIPKcS4_EES9_; std::string::erase(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>)
mov [rsp+2A8h+var_278], rax
jmp short $+2
loc_ED107:
mov rax, [rsp+2A8h+var_278]
mov [rsp+2A8h+var_230], rax
lea rdi, [rsp+2A8h+var_190]
lea rsi, asc_20F569+2; "'"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+2A8h+var_288], rax
jmp short $+2
loc_ED12C:
mov rdi, [rsp+2A8h+var_288]
lea rsi, [rsp+2A8h+var_1F0]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rsp+2A8h+var_290], rax
jmp short $+2
loc_ED145:
mov rdi, [rsp+2A8h+var_290]
lea rsi, asc_20F569+2; "'"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+2A8h+var_298], rax
jmp short $+2
loc_ED15D:
mov rdi, [rsp+2A8h+var_298]
lea rsi, aArgumentNeedle_0+11h; ":"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+2A8h+var_2A0], rax
jmp short $+2
loc_ED175:
mov rax, [rsp+2A8h+var_1D0]
mov esi, [rax]; int
lea rdi, [rsp+2A8h+var_250]; this
call _ZNSt7__cxx119to_stringEi; std::to_string(int)
jmp short $+2
loc_ED18B:
mov rdi, [rsp+2A8h+var_2A0]
lea rsi, [rsp+2A8h+var_250]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
jmp short $+2
loc_ED19C:
lea rdi, [rsp+2A8h+var_250]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+2A8h+var_1F0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+2A8h+var_1C0]
call _ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEppEv; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator++(void)
jmp loc_ECFB1
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
jmp short loc_ED1F9
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
lea rdi, [rsp+arg_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_ED1F9:
lea rdi, [rsp+arg_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_ED24C
loc_ED208:
lea rdi, [rsp+2A8h+var_190]
lea rsi, asc_210836; " ]"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_ED21E:
mov rdi, [rsp+2A8h+var_260]
lea rsi, [rsp+2A8h+var_1A0]
call __ZNKSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEE3strEv; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(void)
jmp short $+2
loc_ED232:
lea rdi, [rsp+2A8h+var_1A0]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rax, [rsp+2A8h+var_258]
add rsp, 2A8h
retn
loc_ED24C:
lea rdi, [rsp+arg_100]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rdi, [rsp+arg_F8]
call __Unwind_Resume
| long long string_from[abi:cxx11](long long a1, long long a2, long long a3)
{
long long v4; // [rsp+8h] [rbp-2A0h]
long long v5; // [rsp+10h] [rbp-298h]
long long v6; // [rsp+18h] [rbp-290h]
long long v7; // [rsp+20h] [rbp-288h]
_BYTE v8[32]; // [rsp+58h] [rbp-250h] BYREF
long long v9; // [rsp+78h] [rbp-230h]
long long v10; // [rsp+80h] [rbp-228h] BYREF
long long v11; // [rsp+88h] [rbp-220h] BYREF
long long v12; // [rsp+98h] [rbp-210h]
long long v13; // [rsp+A0h] [rbp-208h]
long long v14; // [rsp+A8h] [rbp-200h] BYREF
long long v15; // [rsp+B0h] [rbp-1F8h] BYREF
_BYTE v16[32]; // [rsp+B8h] [rbp-1F0h] BYREF
int *v17; // [rsp+D8h] [rbp-1D0h]
long long v18; // [rsp+E0h] [rbp-1C8h] BYREF
long long v19; // [rsp+E8h] [rbp-1C0h] BYREF
long long v20; // [rsp+F0h] [rbp-1B8h]
char v21; // [rsp+FBh] [rbp-1ADh]
_BYTE v22[16]; // [rsp+108h] [rbp-1A0h] BYREF
_BYTE v23[376]; // [rsp+118h] [rbp-190h] BYREF
long long v24; // [rsp+290h] [rbp-18h]
long long v25; // [rsp+298h] [rbp-10h]
long long v26; // [rsp+2A0h] [rbp-8h]
v26 = a1;
v25 = a2;
v24 = a3;
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v22);
std::operator<<<std::char_traits<char>>(v23, "[ ");
v21 = 1;
v20 = v24;
v19 = std::vector<int>::begin(v24);
v18 = std::vector<int>::end(v20);
while ( (__gnu_cxx::operator!=<int const*,std::vector<int>>(&v19, &v18) & 1) != 0 )
{
v17 = (int *)__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator*(&v19);
if ( (v21 & 1) != 0 )
v21 = 0;
else
std::operator<<<std::char_traits<char>>(v23, ", ");
common_token_to_piece[abi:cxx11](v16, v25, (unsigned int)*v17, 1LL);
v13 = std::string::begin(v16);
v12 = std::string::end(v16);
v14 = std::remove_if<__gnu_cxx::__normal_iterator<char *,std::string>,string_from(llama_context const*,std::vector<int> const&)::$_0>(
v13,
v12);
__gnu_cxx::__normal_iterator<char const*,std::string>::__normal_iterator<char *>(&v15, (long long)&v14);
v10 = std::string::end(v16);
__gnu_cxx::__normal_iterator<char const*,std::string>::__normal_iterator<char *>(&v11, (long long)&v10);
v9 = std::string::erase(v16, v15, v11);
v7 = std::operator<<<std::char_traits<char>>(v23, "'");
v6 = std::operator<<<char>(v7, v16);
v5 = std::operator<<<std::char_traits<char>>(v6, "'");
v4 = std::operator<<<std::char_traits<char>>(v5, ":");
std::to_string((std::__cxx11 *)v8, *v17);
std::operator<<<char>(v4, v8);
std::string::~string(v8);
std::string::~string(v16);
__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator++(&v19);
}
std::operator<<<std::char_traits<char>>(v23, " ]");
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(a1, v22);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v22);
return a1;
}
| string_from[abi:cxx11]:
SUB RSP,0x2a8
MOV qword ptr [RSP + 0x48],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x2a0],RDI
MOV qword ptr [RSP + 0x298],RSI
MOV qword ptr [RSP + 0x290],RDX
LEA RDI,[RSP + 0x108]
CALL 0x0015a560
LEA RDI,[RSP + 0x118]
LAB_001ecf61:
LEA RSI,[0x310833]
CALL 0x0015aa20
JMP 0x001ecf6f
LAB_001ecf6f:
MOV byte ptr [RSP + 0xfb],0x1
MOV RAX,qword ptr [RSP + 0x290]
MOV qword ptr [RSP + 0xf0],RAX
MOV RDI,qword ptr [RSP + 0xf0]
CALL 0x001909f0
MOV qword ptr [RSP + 0xe8],RAX
MOV RDI,qword ptr [RSP + 0xf0]
CALL 0x00190a20
MOV qword ptr [RSP + 0xe0],RAX
LAB_001ecfb1:
LEA RDI,[RSP + 0xe8]
LEA RSI,[RSP + 0xe0]
CALL 0x001f7870
TEST AL,0x1
JNZ 0x001ecfcf
JMP 0x001ed208
LAB_001ecfcf:
LEA RDI,[RSP + 0xe8]
CALL 0x001f78b0
MOV qword ptr [RSP + 0xd8],RAX
TEST byte ptr [RSP + 0xfb],0x1
JNZ 0x001ed01f
LEA RDI,[RSP + 0x118]
LEA RSI,[0x3111ea]
CALL 0x0015aa20
JMP 0x001ed004
LAB_001ed004:
JMP 0x001ed027
LAB_001ed01f:
MOV byte ptr [RSP + 0xfb],0x0
LAB_001ed027:
MOV RSI,qword ptr [RSP + 0x298]
MOV RAX,qword ptr [RSP + 0xd8]
MOV EDX,dword ptr [RAX]
LEA RDI,[RSP + 0xb8]
MOV ECX,0x1
CALL 0x001ed270
JMP 0x001ed04d
LAB_001ed04d:
LEA RDI,[RSP + 0xb8]
MOV qword ptr [RSP + 0x38],RDI
CALL 0x0015a860
MOV RDI,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0xa0],RAX
CALL 0x0015a960
MOV qword ptr [RSP + 0x98],RAX
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x98]
LAB_001ed089:
CALL 0x001ed2e0
MOV qword ptr [RSP + 0x40],RAX
JMP 0x001ed095
LAB_001ed095:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0xa8],RAX
LEA RDI,[RSP + 0xb0]
LEA RSI,[RSP + 0xa8]
CALL 0x001be050
LEA RDI,[RSP + 0xb8]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x0015a960
MOV qword ptr [RSP + 0x80],RAX
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x80]
CALL 0x001be050
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x0015a7a0
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001ed107
LAB_001ed107:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x78],RAX
LEA RDI,[RSP + 0x118]
LEA RSI,[0x30f56b]
CALL 0x0015aa20
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001ed12c
LAB_001ed12c:
MOV RDI,qword ptr [RSP + 0x20]
LEA RSI,[RSP + 0xb8]
CALL 0x0015a550
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001ed145
LAB_001ed145:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[0x30f56b]
CALL 0x0015aa20
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001ed15d
LAB_001ed15d:
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[0x311335]
CALL 0x0015aa20
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001ed175
LAB_001ed175:
MOV RAX,qword ptr [RSP + 0xd8]
MOV ESI,dword ptr [RAX]
LEA RDI,[RSP + 0x58]
CALL 0x00162340
JMP 0x001ed18b
LAB_001ed18b:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x58]
CALL 0x0015a550
JMP 0x001ed19c
LAB_001ed19c:
LEA RDI,[RSP + 0x58]
CALL 0x0015b598
LEA RDI,[RSP + 0xb8]
CALL 0x0015b598
LEA RDI,[RSP + 0xe8]
CALL 0x001f78c0
JMP 0x001ecfb1
LAB_001ed208:
LEA RDI,[RSP + 0x118]
LAB_001ed210:
LEA RSI,[0x310836]
CALL 0x0015aa20
JMP 0x001ed21e
LAB_001ed21e:
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[RSP + 0x108]
CALL 0x0015ac90
LAB_001ed230:
JMP 0x001ed232
LAB_001ed232:
LEA RDI,[RSP + 0x108]
CALL 0x0015a680
MOV RAX,qword ptr [RSP + 0x50]
ADD RSP,0x2a8
RET
|
/* string_from[abi:cxx11](llama_context const*, std::vector<int, std::allocator<int> > const&) */
llama_context * string_from_abi_cxx11_(llama_context *param_1,vector *param_2)
{
bool bVar1;
ostream *poVar2;
vector<int,std::allocator<int>> *in_RDX;
__cxx11 local_250 [32];
int8 local_230;
int8 local_228;
int8 local_220 [2];
int8 local_210;
int8 local_208;
int8 local_200;
int8 local_1f8;
llama_context local_1f0 [32];
int *local_1d0;
int8 local_1c8;
int8 local_1c0;
vector<int,std::allocator<int>> *local_1b8;
byte local_1ad;
stringstream local_1a0 [16];
ostream local_190 [376];
vector<int,std::allocator<int>> *local_18;
vector *local_10;
llama_context *local_8;
local_18 = in_RDX;
local_10 = param_2;
local_8 = param_1;
std::__cxx11::stringstream::stringstream(local_1a0);
/* try { // try from 001ecf61 to 001ed04a has its CatchHandler @ 001ed006 */
std::operator<<(local_190,"[ ");
local_1ad = 1;
local_1b8 = local_18;
local_1c0 = std::vector<int,std::allocator<int>>::begin(local_18);
local_1c8 = std::vector<int,std::allocator<int>>::end(local_1b8);
while( true ) {
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_1c0,(__normal_iterator *)&local_1c8);
if (!bVar1) break;
local_1d0 = (int *)__gnu_cxx::__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>
::operator*((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>
*)&local_1c0);
if ((local_1ad & 1) == 0) {
std::operator<<(local_190,", ");
}
else {
local_1ad = 0;
}
common_token_to_piece_abi_cxx11_(local_1f0,(int)local_10,SUB41(*local_1d0,0));
local_208 = std::__cxx11::string::begin();
local_210 = std::__cxx11::string::end();
/* try { // try from 001ed089 to 001ed188 has its CatchHandler @ 001ed1c5 */
local_200 = std::
remove_if<__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>,string_from(llama_context_const*,std::vector<int,std::allocator<int>>const&)::__0>
(local_208,local_210);
__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::__normal_iterator<char*>
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_1f8,
(__normal_iterator *)&local_200);
local_228 = std::__cxx11::string::end();
__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::__normal_iterator<char*>
((__normal_iterator<char_const*,std::__cxx11::string> *)local_220,
(__normal_iterator *)&local_228);
local_230 = std::__cxx11::string::erase(local_1f0,local_1f8,local_220[0]);
poVar2 = std::operator<<(local_190,"\'");
poVar2 = std::operator<<(poVar2,(string *)local_1f0);
poVar2 = std::operator<<(poVar2,"\'");
poVar2 = std::operator<<(poVar2,":");
std::__cxx11::to_string(local_250,*local_1d0);
/* try { // try from 001ed18b to 001ed199 has its CatchHandler @ 001ed1db */
std::operator<<(poVar2,(string *)local_250);
std::__cxx11::string::~string((string *)local_250);
std::__cxx11::string::~string((string *)local_1f0);
__gnu_cxx::__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::operator++
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *)&local_1c0);
}
/* try { // try from 001ed210 to 001ed22f has its CatchHandler @ 001ed006 */
std::operator<<(local_190," ]");
std::__cxx11::stringstream::str();
std::__cxx11::stringstream::~stringstream(local_1a0);
return param_1;
}
| |
32,116 | nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::decode(unsigned char&, unsigned int&, unsigned char) | monkey531[P]llama/common/json.hpp | static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
{
static const std::array<std::uint8_t, 400> utf8d =
{
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
}
};
JSON_ASSERT(byte < utf8d.size());
const std::uint8_t type = utf8d[byte];
codep = (state != UTF8_ACCEPT)
? (byte & 0x3fu) | (codep << 6u)
: (0xFFu >> type) & (byte);
const std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
JSON_ASSERT(index < utf8d.size());
state = utf8d[index];
return state;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::decode(unsigned char&, unsigned int&, unsigned char):
pushq %rax
movl %edx, %ecx
leaq 0x3b931(%rip), %rax # 0xf3add
movzbl (%rax,%rcx), %ecx
cmpb $0x0, (%rdi)
je 0xb81c6
andb $0x3f, %dl
movzbl %dl, %r8d
movl (%rsi), %edx
shll $0x6, %edx
orl %r8d, %edx
jmp 0xb81d5
movl $0xff, %r8d
shrl %cl, %r8d
movzbl %dl, %edx
andl %r8d, %edx
movl %edx, (%rsi)
movzbl (%rdi), %edx
shll $0x4, %edx
movl %ecx, %ecx
addq %rdx, %rcx
addq $0x100, %rcx # imm = 0x100
cmpq $0x190, %rcx # imm = 0x190
jae 0xb81f9
movb (%rax,%rcx), %al
movb %al, (%rdi)
popq %rcx
retq
leaq 0x33eff(%rip), %rdi # 0xec0ff
leaq 0x33f42(%rip), %rdx # 0xec149
leaq 0x3955a(%rip), %rcx # 0xf1768
movl $0x49fb, %esi # imm = 0x49FB
xorl %eax, %eax
callq 0x1ae30
movq %rax, %rdi
callq 0x2160f
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE6decodeERhRjh:
push rax
mov ecx, edx
lea rax, _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE6decodeERhRjhE5utf8d; nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::decode(uchar &,uint &,uchar)::utf8d
movzx ecx, byte ptr [rax+rcx]
cmp byte ptr [rdi], 0
jz short loc_B81C6
and dl, 3Fh
movzx r8d, dl
mov edx, [rsi]
shl edx, 6
or edx, r8d
jmp short loc_B81D5
loc_B81C6:
mov r8d, 0FFh
shr r8d, cl
movzx edx, dl
and edx, r8d
loc_B81D5:
mov [rsi], edx
movzx edx, byte ptr [rdi]
shl edx, 4
mov ecx, ecx
add rcx, rdx
add rcx, 100h
cmp rcx, 190h
jnb short loc_B81F9
mov al, [rax+rcx]
mov [rdi], al
pop rcx
retn
loc_B81F9:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aIndexUtf8dSize; "index < utf8d.size()"
mov esi, 49FBh
xor eax, eax
call _ggml_abort
mov rdi, rax
call __clang_call_terminate
| unsigned __int8 nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::decode(
unsigned __int8 *a1,
unsigned int *a2,
int a3)
{
unsigned int v3; // ecx
unsigned int v4; // edx
unsigned long long v5; // rcx
unsigned __int8 result; // al
void *v7; // rax
v3 = nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::decode(unsigned char &,unsigned int &,unsigned char)::utf8d[a3];
if ( *a1 )
v4 = a3 & 0x3F | (*a2 << 6);
else
v4 = (0xFFu >> v3) & (unsigned __int8)a3;
*a2 = v4;
v5 = 16 * (unsigned int)*a1 + (unsigned long long)v3 + 256;
if ( v5 >= 0x190 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
18939LL,
"GGML_ASSERT(%s) failed",
"index < utf8d.size()");
_clang_call_terminate(v7);
}
result = nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::decode(unsigned char &,unsigned int &,unsigned char)::utf8d[v5];
*a1 = result;
return result;
}
| decode:
PUSH RAX
MOV ECX,EDX
LEA RAX,[0x1f3add]
MOVZX ECX,byte ptr [RAX + RCX*0x1]
CMP byte ptr [RDI],0x0
JZ 0x001b81c6
AND DL,0x3f
MOVZX R8D,DL
MOV EDX,dword ptr [RSI]
SHL EDX,0x6
OR EDX,R8D
JMP 0x001b81d5
LAB_001b81c6:
MOV R8D,0xff
SHR R8D,CL
MOVZX EDX,DL
AND EDX,R8D
LAB_001b81d5:
MOV dword ptr [RSI],EDX
MOVZX EDX,byte ptr [RDI]
SHL EDX,0x4
MOV ECX,ECX
ADD RCX,RDX
ADD RCX,0x100
CMP RCX,0x190
JNC 0x001b81f9
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RDI],AL
POP RCX
RET
LAB_001b81f9:
LEA RDI,[0x1ec0ff]
LEA RDX,[0x1ec149]
LEA RCX,[0x1f1768]
MOV ESI,0x49fb
XOR EAX,EAX
CALL 0x0011ae30
|
/* nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::decode(unsigned char&, unsigned int&, unsigned char) */
void nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::decode(uchar *param_1,uint *param_2,uchar param_3)
{
byte bVar1;
long lVar2;
uint uVar3;
int7 in_register_00000011;
bVar1 = decode(unsigned_char&,unsigned_int&,unsigned_char)::utf8d
[CONCAT71(in_register_00000011,param_3) & 0xffffffff];
if (*param_1 == '\0') {
uVar3 = (uint)param_3 & 0xffU >> (bVar1 & 0x1f);
}
else {
uVar3 = *param_2 << 6 | (uint)(param_3 & 0x3f);
}
*param_2 = uVar3;
lVar2 = (ulong)bVar1 + (ulong)*param_1 * 0x10;
if (lVar2 + 0x100U < 400) {
*param_1 = decode(unsigned_char&,unsigned_int&,unsigned_char)::utf8d[lVar2 + 0x100];
return;
}
/* try { // try from 001b81f9 to 001b8219 has its CatchHandler @ 001b821a */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x49fb,
"GGML_ASSERT(%s) failed","index < utf8d.size()");
}
| |
32,117 | fn_ext2 | eloqsql/mysys/mf_fn_ext.c | char *fn_ext2(const char *name)
{
register const char *pos, *gpos;
DBUG_ENTER("fn_ext");
DBUG_PRINT("mfunkt",("name: '%s'",name));
#if defined(FN_DEVCHAR) || defined(BASKSLASH_MBTAIL)
{
char buff[FN_REFLEN];
size_t res_length;
gpos= name+ dirname_part(buff,(char*) name, &res_length);
}
#else
if (!(gpos= strrchr(name, FN_LIBCHAR)))
gpos= name;
#endif
// locate the last occurrence of FN_EXTCHAR
pos= strrchr(gpos, FN_EXTCHAR);
DBUG_RETURN((char*) (pos ? pos : strend(gpos)));
} | O3 | c | fn_ext2:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x2f, %esi
callq 0x243c0
movq %rax, %rbx
testq %rax, %rax
cmoveq %r14, %rbx
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x243c0
testq %rax, %rax
je 0x348a6
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6318c
nop
| fn_ext2:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rdi
mov esi, 2Fh ; '/'
call _strrchr
mov rbx, rax
test rax, rax
cmovz rbx, r14
mov rdi, rbx
mov esi, 2Eh ; '.'
call _strrchr
test rax, rax
jz short loc_348A6
pop rbx
pop r14
pop rbp
retn
loc_348A6:
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp strend
| long long fn_ext2(long long a1)
{
long long v1; // rbx
long long result; // rax
v1 = strrchr(a1, 47LL);
if ( !v1 )
v1 = a1;
result = strrchr(v1, 46LL);
if ( !result )
return strend(v1);
return result;
}
| fn_ext2:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RDI
MOV ESI,0x2f
CALL 0x001243c0
MOV RBX,RAX
TEST RAX,RAX
CMOVZ RBX,R14
MOV RDI,RBX
MOV ESI,0x2e
CALL 0x001243c0
TEST RAX,RAX
JZ 0x001348a6
POP RBX
POP R14
POP RBP
RET
LAB_001348a6:
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x0016318c
|
void fn_ext2(char *param_1)
{
char *__s;
char *pcVar1;
__s = strrchr(param_1,0x2f);
if (__s == (char *)0x0) {
__s = param_1;
}
pcVar1 = strrchr(__s,0x2e);
if (pcVar1 != (char *)0x0) {
return;
}
strend(__s);
return;
}
| |
32,118 | x2nmodp | 3fs/build_O3/src/apache-arrow-cpp/cpp/zlib_ep-prefix/src/zlib_ep/crc32.c | local z_crc_t x2nmodp(n, k)
z_off64_t n;
unsigned k;
{
z_crc_t p;
p = (z_crc_t)1 << 31; /* x^0 == 1 */
while (n) {
if (n & 1)
p = multmodp(x2n_table[k & 31], p);
n >>= 1;
k++;
}
return p;
} | O3 | c | x2nmodp:
testq %rdi, %rdi
je 0x3d88
movl $0x3, %ecx
movl $0x80000000, %esi # imm = 0x80000000
leaq 0xd6e7(%rip), %rdx # 0x11410
testb $0x1, %dil
jne 0x3d46
movl %esi, %eax
movq %rdi, %r8
sarq %r8
incl %ecx
movl %eax, %esi
cmpq $0x1, %rdi
movq %r8, %rdi
ja 0x3d29
jmp 0x3d87
movl %ecx, %eax
andl $0x1f, %eax
movl (%rdx,%rax,4), %r8d
xorl %eax, %eax
movl $0x80000000, %r9d # imm = 0x80000000
testl %r8d, %r9d
je 0x3d67
xorl %esi, %eax
leal -0x1(%r9), %r10d
testl %r8d, %r10d
je 0x3d31
shrl %r9d
movl %esi, %r10d
shrl %r10d
movl %r10d, %r11d
xorl $0xedb88320, %r11d # imm = 0xEDB88320
testb $0x1, %sil
cmovel %r10d, %r11d
movl %r11d, %esi
jmp 0x3d57
retq
movl $0x80000000, %eax # imm = 0x80000000
retq
| x2nmodp:
test rdi, rdi
jz short loc_3D88
mov ecx, 3
mov esi, 80000000h
lea rdx, x2n_table
loc_3D29:
test dil, 1
jnz short loc_3D46
mov eax, esi
loc_3D31:
mov r8, rdi
sar r8, 1
inc ecx
mov esi, eax
cmp rdi, 1
mov rdi, r8
ja short loc_3D29
jmp short locret_3D87
loc_3D46:
mov eax, ecx
and eax, 1Fh
mov r8d, [rdx+rax*4]
xor eax, eax
mov r9d, 80000000h
loc_3D57:
test r9d, r8d
jz short loc_3D67
xor eax, esi
lea r10d, [r9-1]
test r10d, r8d
jz short loc_3D31
loc_3D67:
shr r9d, 1
mov r10d, esi
shr r10d, 1
mov r11d, r10d
xor r11d, 0EDB88320h
test sil, 1
cmovz r11d, r10d
mov esi, r11d
jmp short loc_3D57
locret_3D87:
retn
loc_3D88:
mov eax, 80000000h
retn
| long long x2nmodp(long long a1)
{
char v1; // cl
unsigned int v2; // esi
long long result; // rax
bool v4; // cc
int v5; // r8d
unsigned int v6; // r9d
unsigned int v7; // r11d
if ( !a1 )
return 0x80000000LL;
v1 = 3;
v2 = 0x80000000;
do
{
if ( (a1 & 1) != 0 )
{
v5 = x2n_table[v1 & 0x1F];
LODWORD(result) = 0;
v6 = 0x80000000;
while ( 1 )
{
if ( (v5 & v6) != 0 )
{
result = v2 ^ (unsigned int)result;
if ( (v5 & (v6 - 1)) == 0 )
break;
}
v6 >>= 1;
v7 = (v2 >> 1) ^ 0xEDB88320;
if ( (v2 & 1) == 0 )
v7 = v2 >> 1;
v2 = v7;
}
}
else
{
result = v2;
}
++v1;
v2 = result;
v4 = (unsigned long long)a1 <= 1;
a1 >>= 1;
}
while ( !v4 );
return result;
}
| x2nmodp:
TEST RDI,RDI
JZ 0x00103d88
MOV ECX,0x3
MOV ESI,0x80000000
LEA RDX,[0x111410]
LAB_00103d29:
TEST DIL,0x1
JNZ 0x00103d46
MOV EAX,ESI
LAB_00103d31:
MOV R8,RDI
SAR R8,0x1
INC ECX
MOV ESI,EAX
CMP RDI,0x1
MOV RDI,R8
JA 0x00103d29
JMP 0x00103d87
LAB_00103d46:
MOV EAX,ECX
AND EAX,0x1f
MOV R8D,dword ptr [RDX + RAX*0x4]
XOR EAX,EAX
MOV R9D,0x80000000
LAB_00103d57:
TEST R9D,R8D
JZ 0x00103d67
XOR EAX,ESI
LEA R10D,[R9 + -0x1]
TEST R10D,R8D
JZ 0x00103d31
LAB_00103d67:
SHR R9D,0x1
MOV R10D,ESI
SHR R10D,0x1
MOV R11D,R10D
XOR R11D,0xedb88320
TEST SIL,0x1
CMOVZ R11D,R10D
MOV ESI,R11D
JMP 0x00103d57
LAB_00103d87:
RET
LAB_00103d88:
MOV EAX,0x80000000
RET
|
ulong x2nmodp(ulong param_1)
{
bool bVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
uint uVar5;
ulong uVar6;
ulong uVar7;
uint uVar8;
if (param_1 == 0) {
return 0x80000000;
}
uVar5 = 3;
uVar6 = 0x80000000;
do {
if ((param_1 & 1) != 0) {
uVar8 = 0x80000000;
uVar4 = 0;
uVar7 = uVar6;
while ((uVar6 = uVar4, (uVar8 & *(uint *)(x2n_table + (ulong)(uVar5 & 0x1f) * 4)) == 0 ||
(uVar6 = (ulong)((uint)uVar6 ^ (uint)uVar7),
(uVar8 - 1 & *(uint *)(x2n_table + (ulong)(uVar5 & 0x1f) * 4)) != 0))) {
uVar8 = uVar8 >> 1;
uVar2 = uVar7 >> 1;
uVar3 = uVar7 & 1;
uVar4 = uVar6;
uVar7 = (ulong)((uint)uVar2 ^ 0xedb88320);
if (uVar3 == 0) {
uVar7 = uVar2;
}
}
}
uVar5 = uVar5 + 1;
bVar1 = 1 < param_1;
param_1 = (long)param_1 >> 1;
} while (bVar1);
return uVar6;
}
| |
32,119 | Field::store_time_dec(st_mysql_time const*, unsigned int) | eloqsql/sql/field.cc | int Field::store_time_dec(const MYSQL_TIME *ltime, uint dec)
{
DBUG_ASSERT(marked_for_write_or_computed());
char buff[MAX_DATE_STRING_REP_LENGTH];
uint length= (uint) my_TIME_to_str(ltime, buff, dec);
/* Avoid conversion when field character set is ASCII compatible */
return store(buff, length, (charset()->state & MY_CS_NONASCII) ?
&my_charset_latin1 : charset());
} | O0 | cpp | Field::store_time_dec(st_mysql_time const*, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movl %edx, -0x44(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xbea94a
movq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl -0x44(%rbp), %edx
callq 0x12e2410
movq -0x50(%rbp), %rdi
movl %eax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x48(%rbp), %eax
movq %rax, -0x58(%rbp)
movq (%rdi), %rax
callq *0x348(%rax)
movl 0xc(%rax), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
je 0xbea993
leaq 0xfc9933(%rip), %rax # 0x1bb42c0
movq %rax, -0x68(%rbp)
jmp 0xbea9a4
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x348(%rax)
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdx
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rcx
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
movl %eax, -0x6c(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xbea9db
movl -0x6c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
callq 0x758480
| _ZN5Field14store_time_decEPK13st_mysql_timej:
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_44], edx
mov rax, [rbp+var_38]
mov [rbp+var_50], rax
jmp short $+2
loc_BEA94A:
mov rdi, [rbp+var_40]
lea rsi, [rbp+var_30]
mov edx, [rbp+var_44]
call my_TIME_to_str
mov rdi, [rbp+var_50]
mov [rbp+var_48], eax
lea rax, [rbp+var_30]
mov [rbp+var_60], rax
mov eax, [rbp+var_48]
mov [rbp+var_58], rax
mov rax, [rdi]
call qword ptr [rax+348h]
mov eax, [rax+0Ch]
and eax, 2000h
cmp eax, 0
jz short loc_BEA993
lea rax, my_charset_latin1
mov [rbp+var_68], rax
jmp short loc_BEA9A4
loc_BEA993:
mov rdi, [rbp+var_50]
mov rax, [rdi]
call qword ptr [rax+348h]
mov [rbp+var_68], rax
loc_BEA9A4:
mov rdx, [rbp+var_58]
mov rsi, [rbp+var_60]
mov rdi, [rbp+var_50]
mov rcx, [rbp+var_68]
mov rax, [rdi]
mov rax, [rax+60h]
call rax
mov [rbp+var_6C], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_BEA9DB
mov eax, [rbp+var_6C]
add rsp, 70h
pop rbp
retn
loc_BEA9DB:
call ___stack_chk_fail
| long long Field::store_time_dec(long long a1, long long a2, unsigned int a3)
{
long long result; // rax
long long v4; // [rsp+8h] [rbp-68h]
long long v5; // [rsp+18h] [rbp-58h]
_BYTE v6[40]; // [rsp+40h] [rbp-30h] BYREF
unsigned long long v7; // [rsp+68h] [rbp-8h]
v7 = __readfsqword(0x28u);
v5 = (unsigned int)my_TIME_to_str(a2, v6, a3);
if ( (*(_DWORD *)((*(long long ( **)(long long))(*(_QWORD *)a1 + 840LL))(a1) + 12) & 0x2000) != 0 )
{
LODWORD(result) = (*(long long ( **)(long long, _BYTE *, long long, void *))(*(_QWORD *)a1 + 96LL))(
a1,
v6,
v5,
&my_charset_latin1);
}
else
{
v4 = (*(long long ( **)(long long))(*(_QWORD *)a1 + 840LL))(a1);
LODWORD(result) = (*(long long ( **)(long long, _BYTE *, long long, long long))(*(_QWORD *)a1 + 96LL))(
a1,
v6,
v5,
v4);
}
return (unsigned int)result;
}
| version:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
CMP byte ptr [0x01dfb828],0x0
JNZ 0x00bea969
LEA RDI,[0x1dfb828]
CALL 0x008596e0
CMP EAX,0x0
JZ 0x00bea969
LAB_00bea946:
LEA RDI,[0x1dfb818]
LEA RSI,[0x14dc7da]
XOR EDX,EDX
CALL 0x00c05a50
LAB_00bea95b:
JMP 0x00bea95d
LAB_00bea95d:
LEA RDI,[0x1dfb828]
CALL 0x00859ad0
LAB_00bea969:
MOVUPS XMM0,xmmword ptr [0x01dfb818]
MOVAPS xmmword ptr [RBP + -0x10],XMM0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
/* Type_handler::version() const */
int1 [16] Type_handler::version(void)
{
int1 auVar1 [16];
int iVar2;
if (version()::ver == '\0') {
iVar2 = __cxa_guard_acquire(&version()::ver);
if (iVar2 != 0) {
/* try { // try from 00bea946 to 00bea95a has its CatchHandler @ 00bea982 */
Name::Name((Name *)version()::ver,"",0);
__cxa_guard_release(&version()::ver);
}
}
auVar1._8_8_ = version()::ver._8_8_;
auVar1._0_8_ = version()::ver._0_8_;
return auVar1;
}
| |
32,120 | llama_data_read_buffer::read(unsigned long) | monkey531[P]llama/src/llama-context.cpp | const uint8_t * read(size_t size) override {
const uint8_t * base_ptr = ptr;
if (size > buf_size) {
throw std::runtime_error("unexpectedly reached end of buffer");
}
ptr += size;
size_read += size;
buf_size -= size;
return base_ptr;
} | O3 | cpp | llama_data_read_buffer::read(unsigned long):
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rcx
subq %rsi, %rcx
jb 0xa0e27
movq 0x8(%rdi), %rax
leaq (%rax,%rsi), %rdx
movq %rdx, 0x8(%rdi)
addq %rsi, 0x18(%rdi)
movq %rcx, 0x10(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x65cb0
movq %rax, %rbx
leaq 0x73d39(%rip), %rsi # 0x114b74
movq %rax, %rdi
callq 0x655d0
movq 0xbc1a6(%rip), %rsi # 0x15cff0
movq 0xbbe9f(%rip), %rdx # 0x15ccf0
movq %rbx, %rdi
callq 0x6b270
movq %rax, %r14
movq %rbx, %rdi
callq 0x66d40
movq %r14, %rdi
callq 0x6b5d0
| _ZN22llama_data_read_buffer4readEm:
push r14
push rbx
push rax
mov rcx, [rdi+10h]
sub rcx, rsi
jb short loc_A0E27
mov rax, [rdi+8]
lea rdx, [rax+rsi]
mov [rdi+8], rdx
add [rdi+18h], rsi
mov [rdi+10h], rcx
add rsp, 8
pop rbx
pop r14
retn
loc_A0E27:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUnexpectedlyRe; "unexpectedly reached end of buffer"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
| long long llama_data_read_buffer::read(llama_data_read_buffer *this, unsigned long long a2)
{
unsigned long long v2; // rcx
bool v3; // cf
unsigned long long v4; // rcx
long long result; // rax
std::runtime_error *exception; // rbx
v2 = *((_QWORD *)this + 2);
v3 = v2 < a2;
v4 = v2 - a2;
if ( v3 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "unexpectedly reached end of buffer");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
result = *((_QWORD *)this + 1);
*((_QWORD *)this + 1) = result + a2;
*((_QWORD *)this + 3) += a2;
*((_QWORD *)this + 2) = v4;
return result;
}
| read:
PUSH R14
PUSH RBX
PUSH RAX
MOV RCX,qword ptr [RDI + 0x10]
SUB RCX,RSI
JC 0x001a0e27
MOV RAX,qword ptr [RDI + 0x8]
LEA RDX,[RAX + RSI*0x1]
MOV qword ptr [RDI + 0x8],RDX
ADD qword ptr [RDI + 0x18],RSI
MOV qword ptr [RDI + 0x10],RCX
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_001a0e27:
MOV EDI,0x10
CALL 0x00165cb0
MOV RBX,RAX
LAB_001a0e34:
LEA RSI,[0x214b74]
MOV RDI,RAX
CALL 0x001655d0
LAB_001a0e43:
MOV RSI,qword ptr [0x0025cff0]
MOV RDX,qword ptr [0x0025ccf0]
MOV RDI,RBX
CALL 0x0016b270
|
/* llama_data_read_buffer::read(unsigned long) */
void __thiscall llama_data_read_buffer::read(llama_data_read_buffer *this,ulong param_1)
{
runtime_error *this_00;
if (param_1 <= *(ulong *)(this + 0x10)) {
*(ulong *)(this + 8) = *(long *)(this + 8) + param_1;
*(ulong *)(this + 0x18) = *(long *)(this + 0x18) + param_1;
*(ulong *)(this + 0x10) = *(ulong *)(this + 0x10) - param_1;
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a0e34 to 001a0e42 has its CatchHandler @ 001a0e59 */
std::runtime_error::runtime_error(this_00,"unexpectedly reached end of buffer");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0025cff0,PTR__runtime_error_0025ccf0);
}
| |
32,121 | js_operator_typeof | bluesky950520[P]quickjs/quickjs.c | static __exception int js_operator_typeof(JSContext *ctx, JSValue op1)
{
JSAtom atom;
uint32_t tag;
tag = JS_VALUE_GET_NORM_TAG(op1);
switch(tag) {
case JS_TAG_BIG_INT:
atom = JS_ATOM_bigint;
break;
case JS_TAG_INT:
case JS_TAG_FLOAT64:
atom = JS_ATOM_number;
break;
case JS_TAG_UNDEFINED:
atom = JS_ATOM_undefined;
break;
case JS_TAG_BOOL:
atom = JS_ATOM_boolean;
break;
case JS_TAG_STRING:
atom = JS_ATOM_string;
break;
case JS_TAG_OBJECT:
{
JSObject *p;
p = JS_VALUE_GET_OBJ(op1);
if (unlikely(p->is_HTMLDDA))
atom = JS_ATOM_undefined;
else if (JS_IsFunction(ctx, op1))
atom = JS_ATOM_function;
else
goto obj_type;
}
break;
case JS_TAG_NULL:
obj_type:
atom = JS_ATOM_object;
break;
case JS_TAG_SYMBOL:
atom = JS_ATOM_symbol;
break;
default:
atom = JS_ATOM_unknown;
break;
}
return atom;
} | O0 | c | js_operator_typeof:
subq $0x38, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
addl $0x9, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x10, %eax
ja 0x735c9
movq 0x8(%rsp), %rax
leaq 0x9dba6(%rip), %rcx # 0x1110b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x8d, 0x1c(%rsp)
jmp 0x735d1
movl $0x47, 0x1c(%rsp)
jmp 0x735d1
movl $0x46, 0x1c(%rsp)
jmp 0x735d1
movl $0x48, 0x1c(%rsp)
jmp 0x735d1
movl $0x49, 0x1c(%rsp)
jmp 0x735d1
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movb 0x5(%rax), %al
shrb $0x7, %al
cmpb $0x0, %al
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x7358a
movl $0x46, 0x1c(%rsp)
jmp 0x735b1
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x34800
cmpl $0x0, %eax
je 0x735ad
movl $0x1b, 0x1c(%rsp)
jmp 0x735af
jmp 0x735b5
jmp 0x735b1
jmp 0x735d1
jmp 0x735b5
movl $0x4a, 0x1c(%rsp)
jmp 0x735d1
movl $0x4b, 0x1c(%rsp)
jmp 0x735d1
movl $0x4d, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
| js_operator_typeof:
sub rsp, 38h
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_8], rdx
mov [rsp+38h+var_18], rdi
mov eax, dword ptr [rsp+38h+var_8]
mov [rsp+38h+var_20], eax
mov eax, [rsp+38h+var_20]
add eax, 9; switch 17 cases
mov ecx, eax
mov [rsp+38h+var_30], rcx
sub eax, 10h
ja def_73515; jumptable 0000000000073515 default case, cases -6--2,4-6
mov rax, [rsp+38h+var_30]
lea rcx, jpt_73515
movsxd rax, ds:(jpt_73515 - 1110B4h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_73517:
mov [rsp+38h+var_1C], 8Dh; jumptable 0000000000073515 case -9
jmp loc_735D1
loc_73524:
mov [rsp+38h+var_1C], 47h ; 'G'; jumptable 0000000000073515 cases 0,7
jmp loc_735D1
loc_73531:
mov [rsp+38h+var_1C], 46h ; 'F'; jumptable 0000000000073515 case 3
jmp loc_735D1
loc_7353E:
mov [rsp+38h+var_1C], 48h ; 'H'; jumptable 0000000000073515 case 1
jmp loc_735D1
loc_7354B:
mov [rsp+38h+var_1C], 49h ; 'I'; jumptable 0000000000073515 case -7
jmp short loc_735D1
loc_73555:
mov rax, [rsp+38h+var_10]; jumptable 0000000000073515 case -1
mov [rsp+38h+var_28], rax
mov rax, [rsp+38h+var_28]
mov al, [rax+5]
shr al, 7
cmp al, 0
setnz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_7358A
mov [rsp+38h+var_1C], 46h ; 'F'
jmp short loc_735B1
loc_7358A:
mov rdi, [rsp+38h+var_18]
mov rsi, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_8]
call JS_IsFunction
cmp eax, 0
jz short loc_735AD
mov [rsp+38h+var_1C], 1Bh
jmp short loc_735AF
loc_735AD:
jmp short loc_735B5
loc_735AF:
jmp short $+2
loc_735B1:
jmp short loc_735D1
loc_735B3:
jmp short $+2; jumptable 0000000000073515 case 2
loc_735B5:
mov [rsp+38h+var_1C], 4Ah ; 'J'
jmp short loc_735D1
loc_735BF:
mov [rsp+38h+var_1C], 4Bh ; 'K'; jumptable 0000000000073515 case -8
jmp short loc_735D1
def_73515:
mov [rsp+38h+var_1C], 4Dh ; 'M'; jumptable 0000000000073515 default case, cases -6--2,4-6
loc_735D1:
mov eax, [rsp+38h+var_1C]
add rsp, 38h
retn
| long long js_operator_typeof(long long a1, long long a2, int a3)
{
unsigned int v4; // [rsp+1Ch] [rbp-1Ch]
switch ( a3 )
{
case -9:
v4 = 141;
break;
case -8:
v4 = 75;
break;
case -7:
v4 = 73;
break;
case -1:
if ( *(char *)(a2 + 5) >= 0 )
{
if ( !(unsigned int)JS_IsFunction(a1, a2, a3) )
goto LABEL_11;
v4 = 27;
}
else
{
v4 = 70;
}
break;
case 0:
case 7:
v4 = 71;
break;
case 1:
v4 = 72;
break;
case 2:
LABEL_11:
v4 = 74;
break;
case 3:
v4 = 70;
break;
default:
v4 = 77;
break;
}
return v4;
}
| js_operator_typeof:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV EAX,dword ptr [RSP + 0x30]
MOV dword ptr [RSP + 0x18],EAX
MOV EAX,dword ptr [RSP + 0x18]
ADD EAX,0x9
MOV ECX,EAX
MOV qword ptr [RSP + 0x8],RCX
SUB EAX,0x10
JA 0x001735c9
MOV RAX,qword ptr [RSP + 0x8]
LEA RCX,[0x2110b4]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_fffffff7:
MOV dword ptr [RSP + 0x1c],0x8d
JMP 0x001735d1
caseD_0:
MOV dword ptr [RSP + 0x1c],0x47
JMP 0x001735d1
caseD_3:
MOV dword ptr [RSP + 0x1c],0x46
JMP 0x001735d1
caseD_1:
MOV dword ptr [RSP + 0x1c],0x48
JMP 0x001735d1
caseD_fffffff9:
MOV dword ptr [RSP + 0x1c],0x49
JMP 0x001735d1
caseD_ffffffff:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV AL,byte ptr [RAX + 0x5]
SHR AL,0x7
CMP AL,0x0
SETNZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0017358a
MOV dword ptr [RSP + 0x1c],0x46
JMP 0x001735b1
LAB_0017358a:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x00134800
CMP EAX,0x0
JZ 0x001735ad
MOV dword ptr [RSP + 0x1c],0x1b
JMP 0x001735af
LAB_001735ad:
JMP 0x001735b5
LAB_001735af:
JMP 0x001735b1
LAB_001735b1:
JMP 0x001735d1
caseD_2:
JMP 0x001735b5
LAB_001735b5:
MOV dword ptr [RSP + 0x1c],0x4a
JMP 0x001735d1
caseD_fffffff8:
MOV dword ptr [RSP + 0x1c],0x4b
JMP 0x001735d1
caseD_fffffffa:
MOV dword ptr [RSP + 0x1c],0x4d
LAB_001735d1:
MOV EAX,dword ptr [RSP + 0x1c]
ADD RSP,0x38
RET
|
int4 js_operator_typeof(int8 param_1,long param_2,int8 param_3)
{
int iVar1;
int4 local_1c;
int4 local_8;
local_8 = (int4)param_3;
switch(local_8) {
case 0:
case 7:
local_1c = 0x47;
break;
case 1:
local_1c = 0x48;
break;
case 2:
LAB_001735b5:
local_1c = 0x4a;
break;
case 3:
local_1c = 0x46;
break;
case 0xfffffff7:
local_1c = 0x8d;
break;
case 0xfffffff8:
local_1c = 0x4b;
break;
case 0xfffffff9:
local_1c = 0x49;
break;
default:
local_1c = 0x4d;
break;
case 0xffffffff:
if (*(char *)(param_2 + 5) < '\0') {
return 0x46;
}
iVar1 = JS_IsFunction(param_1,param_2,param_3);
if (iVar1 != 0) {
return 0x1b;
}
goto LAB_001735b5;
}
return local_1c;
}
| |
32,122 | get_dynamic | eloqsql/mysys/array.c | void get_dynamic(DYNAMIC_ARRAY *array, void *element, uint idx)
{
if (idx >= array->elements)
{
DBUG_PRINT("warning",("To big array idx: %d, array size is %d",
idx,array->elements));
bzero(element,array->size_of_element);
return;
}
memcpy(element,array->buffer+idx*array->size_of_element,
(size_t) array->size_of_element);
} | O3 | c | get_dynamic:
pushq %rbp
movq %rsp, %rbp
cmpl %edx, 0x8(%rdi)
jbe 0x2d652
movl 0x14(%rdi), %eax
imull %eax, %edx
addq (%rdi), %rdx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
popq %rbp
jmp 0x24250
movl 0x14(%rdi), %edx
movq %rsi, %rdi
xorl %esi, %esi
popq %rbp
jmp 0x24190
| get_dynamic:
push rbp
mov rbp, rsp
cmp [rdi+8], edx
jbe short loc_2D652
mov eax, [rdi+14h]
imul edx, eax
add rdx, [rdi]
mov rdi, rsi
mov rsi, rdx
mov rdx, rax
pop rbp
jmp _memcpy
loc_2D652:
mov edx, [rdi+14h]
mov rdi, rsi
xor esi, esi
pop rbp
jmp _memset
| long long get_dynamic(long long a1, long long a2, unsigned int a3)
{
if ( *(_DWORD *)(a1 + 8) <= a3 )
return memset(a2, 0LL, *(unsigned int *)(a1 + 20));
else
return memcpy(a2, *(_QWORD *)a1 + *(_DWORD *)(a1 + 20) * a3, *(unsigned int *)(a1 + 20));
}
| get_dynamic:
PUSH RBP
MOV RBP,RSP
CMP dword ptr [RDI + 0x8],EDX
JBE 0x0012d652
MOV EAX,dword ptr [RDI + 0x14]
IMUL EDX,EAX
ADD RDX,qword ptr [RDI]
MOV RDI,RSI
MOV RSI,RDX
MOV RDX,RAX
POP RBP
JMP 0x00124250
LAB_0012d652:
MOV EDX,dword ptr [RDI + 0x14]
MOV RDI,RSI
XOR ESI,ESI
POP RBP
JMP 0x00124190
|
void get_dynamic(long *param_1,void *param_2,uint param_3)
{
if (param_3 < *(uint *)(param_1 + 1)) {
memcpy(param_2,(void *)((ulong)(param_3 * *(uint *)((long)param_1 + 0x14)) + *param_1),
(ulong)*(uint *)((long)param_1 + 0x14));
return;
}
memset(param_2,0,(ulong)*(uint *)((long)param_1 + 0x14));
return;
}
| |
32,123 | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::insert(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&) | monkey531[P]llama/common/json.hpp | std::pair<iterator, bool> insert( const value_type& value )
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, value.first))
{
return {it, false};
}
}
Container::push_back(value);
return {--this->end(), true};
} | O2 | cpp | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::insert(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
cmpq 0x8(%r14), %rbx
je 0x81409
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3123c
testb %al, %al
jne 0x81420
addq $0x30, %rbx
jmp 0x813ee
movq %r14, %rdi
movq %r15, %rsi
callq 0x8142c
movq 0x8(%r14), %rbx
addq $-0x30, %rbx
movb $0x1, %dl
jmp 0x81422
xorl %edx, %edx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE6insertERKSI_:
push r15
push r14
push rbx
mov r15, rsi
mov r14, rdi
mov rbx, [rdi]
loc_813EE:
cmp rbx, [r14+8]
jz short loc_81409
mov rdi, rbx
mov rsi, r15
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
test al, al
jnz short loc_81420
add rbx, 30h ; '0'
jmp short loc_813EE
loc_81409:
mov rdi, r14
mov rsi, r15
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE9push_backERKSG_; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::push_back(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
mov rbx, [r14+8]
add rbx, 0FFFFFFFFFFFFFFD0h
mov dl, 1
jmp short loc_81422
loc_81420:
xor edx, edx
loc_81422:
mov rax, rbx
pop rbx
pop r14
pop r15
retn
| long long nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::insert(
_QWORD **a1,
_QWORD *a2)
{
_QWORD *i; // rbx
for ( i = *a1; i != a1[1]; i += 6 )
{
if ( std::operator==<char>(i, a2) )
return (long long)i;
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::push_back(
a1,
a2);
return (long long)(a1[1] - 6);
}
| insert:
PUSH R15
PUSH R14
PUSH RBX
MOV R15,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
LAB_001813ee:
CMP RBX,qword ptr [R14 + 0x8]
JZ 0x00181409
MOV RDI,RBX
MOV RSI,R15
CALL 0x0013123c
TEST AL,AL
JNZ 0x00181420
ADD RBX,0x30
JMP 0x001813ee
LAB_00181409:
MOV RDI,R14
MOV RSI,R15
CALL 0x0018142c
MOV RBX,qword ptr [R14 + 0x8]
ADD RBX,-0x30
MOV DL,0x1
JMP 0x00181422
LAB_00181420:
XOR EDX,EDX
LAB_00181422:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > >::insert(std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > const&) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::insert(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this,pair *param_1)
{
char cVar1;
int8 extraout_RDX;
int8 uVar2;
string *psVar3;
int1 auVar4 [16];
psVar3 = *(string **)this;
do {
if (psVar3 == *(string **)(this + 8)) {
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::push_back((vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)this,param_1);
psVar3 = (string *)(*(long *)(this + 8) + -0x30);
uVar2 = CONCAT71((int7)((ulong)extraout_RDX >> 8),1);
LAB_00181422:
auVar4._8_8_ = uVar2;
auVar4._0_8_ = psVar3;
return auVar4;
}
cVar1 = std::operator==(psVar3,(string *)param_1);
if (cVar1 != '\0') {
uVar2 = 0;
goto LAB_00181422;
}
psVar3 = psVar3 + 0x30;
} while( true );
}
| |
32,124 | stbi__convert_format | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h | static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
{
int i,j;
unsigned char *good;
if (req_comp == img_n) return data;
STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
if (good == NULL) {
STBI_FREE(data);
return stbi__errpuc("outofmem", "Out of memory");
}
for (j=0; j < (int) y; ++j) {
unsigned char *src = data + j * x * img_n ;
unsigned char *dest = good + j * x * req_comp;
#define STBI__COMBO(a,b) ((a)*8+(b))
#define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
// convert source image with img_n components to one with req_comp components;
// avoid switch per pixel, so use switch per scanline and massive macros
switch (STBI__COMBO(img_n, req_comp)) {
STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break;
STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break;
STBI__CASE(2,1) { dest[0]=src[0]; } break;
STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;
STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break;
STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break;
STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;
STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;
default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion");
}
#undef STBI__CASE
}
STBI_FREE(data);
return good;
} | O1 | c | stbi__convert_format:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
cmpl $0x4, %esi
je 0x1593b
movl %ecx, %ebp
movl %edx, %r14d
movl $0x4, %edi
movl %edx, %esi
movl %ecx, %edx
xorl %ecx, %ecx
callq 0x16932
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x15917
movq %r14, (%rsp)
testl %ebp, %ebp
jle 0x15908
movq 0x10(%rsp), %rax
leal 0x4(,%rax,8), %eax
cmpl $0x1c, %eax
ja 0x1594d
movl $0x10101000, %ecx # imm = 0x10101000
btl %eax, %ecx
jae 0x1594d
cmpl $0x2, %ebp
movl $0x1, %ecx
cmovgel %ebp, %ecx
movq (%rsp), %r8
leal -0x1(%r8), %edx
movq 0x8(%rsp), %rsi
addq $0x3, %rsi
leal (,%r8,4), %edi
imull 0x10(%rsp), %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
xorl %r11d, %r11d
movl %r10d, %r13d
addq %rsi, %r13
movl %r9d, %ebp
addq %rbx, %rbp
cmpl $0x14, %eax
je 0x15889
cmpl $0x1c, %eax
jne 0x158c3
testl %edx, %edx
js 0x158f6
movl %r11d, %r13d
movq (%rsp), %r14
imull %r14d, %r13d
movl %r13d, %ebp
imull 0x10(%rsp), %ebp
addq %rbx, %rbp
shll $0x2, %r13d
addq 0x8(%rsp), %r13
movl %r14d, %r12d
movb (%rbp), %r14b
movb %r14b, (%r13)
movb 0x1(%rbp), %r14b
movb %r14b, 0x1(%r13)
movb 0x2(%rbp), %r14b
movb %r14b, 0x2(%r13)
movb $-0x1, 0x3(%r13)
addq $0x3, %rbp
addq $0x4, %r13
decl %r12d
testl %r12d, %r12d
jg 0x1585a
jmp 0x158f6
testl %edx, %edx
js 0x158f6
xorl %r12d, %r12d
movq (%rsp), %r14
movl %r14d, %r15d
movb (%rbp,%r12), %r14b
movb %r14b, -0x1(%r13,%r12,2)
movb %r14b, -0x2(%r13,%r12,2)
movb %r14b, -0x3(%r13,%r12,2)
movb 0x1(%rbp,%r12), %r14b
movb %r14b, (%r13,%r12,2)
decl %r15d
addq $0x2, %r12
testl %r15d, %r15d
jg 0x15897
jmp 0x158f6
testl %edx, %edx
js 0x158f6
xorl %r12d, %r12d
movq (%rsp), %r14
movl %r14d, %r15d
movb (%rbp,%r12), %r14b
movb %r14b, -0x1(%r13,%r12,4)
movb %r14b, -0x2(%r13,%r12,4)
movb %r14b, -0x3(%r13,%r12,4)
movb $-0x1, (%r13,%r12,4)
decl %r15d
incq %r12
testl %r15d, %r15d
jg 0x158d1
incq %r11
addl %edi, %r10d
addl %r8d, %r9d
cmpq %rcx, %r11
jne 0x15816
movq %rbx, %rdi
callq 0x32c0
movq 0x8(%rsp), %rbx
jmp 0x1593b
movq %rbx, %rdi
callq 0x32c0
movq %fs:0x0, %rax
leaq 0x10981(%rip), %rcx # 0x262b3
movq %rcx, -0x8(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11562(%rip), %rdi # 0x26eb6
leaq 0x10767(%rip), %rsi # 0x260c2
leaq 0x10bd6(%rip), %rcx # 0x26538
movl $0x6fe, %edx # imm = 0x6FE
callq 0x30b0
| stbi__convert_format:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov [rsp+48h+var_38], rsi
cmp esi, 4
jz loc_1593B
mov ebp, ecx
mov r14d, edx
mov edi, 4
mov esi, edx
mov edx, ecx
xor ecx, ecx
call stbi__malloc_mad3
mov [rsp+48h+var_40], rax
test rax, rax
jz loc_15917
mov [rsp+48h+var_48], r14
test ebp, ebp
jle loc_15908
mov rax, [rsp+48h+var_38]
lea eax, ds:4[rax*8]
cmp eax, 1Ch
ja loc_1594D
mov ecx, 10101000h
bt ecx, eax
jnb loc_1594D
cmp ebp, 2
mov ecx, 1
cmovge ecx, ebp
mov r8, [rsp+48h+var_48]
lea edx, [r8-1]
mov rsi, [rsp+48h+var_40]
add rsi, 3
lea edi, ds:0[r8*4]
imul r8d, dword ptr [rsp+48h+var_38]
xor r9d, r9d
xor r10d, r10d
xor r11d, r11d
loc_15816:
mov r13d, r10d
add r13, rsi
mov ebp, r9d
add rbp, rbx
cmp eax, 14h
jz short loc_15889
cmp eax, 1Ch
jnz loc_158C3
test edx, edx
js loc_158F6
mov r13d, r11d
mov r14, [rsp+48h+var_48]
imul r13d, r14d
mov ebp, r13d
imul ebp, dword ptr [rsp+48h+var_38]
add rbp, rbx
shl r13d, 2
add r13, [rsp+48h+var_40]
mov r12d, r14d
loc_1585A:
mov r14b, [rbp+0]
mov [r13+0], r14b
mov r14b, [rbp+1]
mov [r13+1], r14b
mov r14b, [rbp+2]
mov [r13+2], r14b
mov byte ptr [r13+3], 0FFh
add rbp, 3
add r13, 4
dec r12d
test r12d, r12d
jg short loc_1585A
jmp short loc_158F6
loc_15889:
test edx, edx
js short loc_158F6
xor r12d, r12d
mov r14, [rsp+48h+var_48]
mov r15d, r14d
loc_15897:
mov r14b, [rbp+r12+0]
mov [r13+r12*2-1], r14b
mov [r13+r12*2-2], r14b
mov [r13+r12*2-3], r14b
mov r14b, [rbp+r12+1]
mov [r13+r12*2+0], r14b
dec r15d
add r12, 2
test r15d, r15d
jg short loc_15897
jmp short loc_158F6
loc_158C3:
test edx, edx
js short loc_158F6
xor r12d, r12d
mov r14, [rsp+48h+var_48]
mov r15d, r14d
loc_158D1:
mov r14b, [rbp+r12+0]
mov [r13+r12*4-1], r14b
mov [r13+r12*4-2], r14b
mov [r13+r12*4-3], r14b
mov byte ptr [r13+r12*4+0], 0FFh
dec r15d
inc r12
test r15d, r15d
jg short loc_158D1
loc_158F6:
inc r11
add r10d, edi
add r9d, r8d
cmp r11, rcx
jnz loc_15816
loc_15908:
mov rdi, rbx
call free
mov rbx, [rsp+48h+var_40]
jmp short loc_1593B
loc_15917:
mov rdi, rbx
call free
mov rax, fs:0
lea rcx, aOutofmem; "outofmem"
mov [rax-8], rcx
xor ebx, ebx
loc_1593B:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1594D:
lea rdi, aPvgFtOutlineCh+21h; "0"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aUnsignedCharSt_0; "unsigned char *stbi__convert_format(uns"...
mov edx, 6FEh
call ___assert_fail
| long long stbi__convert_format(long long a1, int a2, unsigned int a3, int a4)
{
long long v4; // rbx
unsigned int v7; // eax
int v8; // ecx
long long v9; // rcx
int v10; // edx
int v11; // edi
int v12; // r8d
unsigned int v13; // r9d
unsigned int v14; // r10d
long long i; // r11
long long v16; // r13
long long v17; // rbp
_BYTE *v18; // rbp
_BYTE *v19; // r13
int v20; // r12d
long long v21; // r12
int v22; // r15d
char v23; // r14
long long v24; // r12
int v25; // r15d
char v26; // r14
int v28; // [rsp+0h] [rbp-48h]
long long v29; // [rsp+8h] [rbp-40h]
v4 = a1;
if ( a2 != 4 )
{
v29 = stbi__malloc_mad3(4LL, a3, (unsigned int)a4, 0LL);
if ( v29 )
{
v28 = a3;
if ( a4 > 0 )
{
v7 = 8 * a2 + 4;
if ( v7 > 0x1C || (v8 = 269488128, !_bittest(&v8, v7)) )
__assert_fail(
"0",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h",
1790LL,
"unsigned char *stbi__convert_format(unsigned char *, int, int, unsigned int, unsigned int)");
v9 = 1LL;
if ( a4 >= 2 )
v9 = (unsigned int)a4;
v10 = a3 - 1;
v11 = 4 * a3;
v12 = a2 * a3;
v13 = 0;
v14 = 0;
for ( i = 0LL; i != v9; ++i )
{
v16 = v29 + 3 + v14;
v17 = v4 + v13;
if ( 8 * a2 == 16 )
{
if ( v10 >= 0 )
{
v21 = 0LL;
v22 = v28;
do
{
v23 = *(_BYTE *)(v17 + v21);
*(_BYTE *)(v16 + 2 * v21 - 1) = v23;
*(_BYTE *)(v16 + 2 * v21 - 2) = v23;
*(_BYTE *)(v29 + v14 + 2 * v21) = v23;
*(_BYTE *)(v16 + 2 * v21) = *(_BYTE *)(v17 + v21 + 1);
--v22;
v21 += 2LL;
}
while ( v22 > 0 );
}
}
else if ( 8 * a2 == 24 )
{
if ( v10 >= 0 )
{
v18 = (_BYTE *)(v4 + (unsigned int)(a2 * v28 * i));
v19 = (_BYTE *)(v29 + (unsigned int)(4 * v28 * i));
v20 = v28;
do
{
*v19 = *v18;
v19[1] = v18[1];
v19[2] = v18[2];
v19[3] = -1;
v18 += 3;
v19 += 4;
--v20;
}
while ( v20 > 0 );
}
}
else if ( v10 >= 0 )
{
v24 = 0LL;
v25 = v28;
do
{
v26 = *(_BYTE *)(v17 + v24);
*(_BYTE *)(v16 + 4 * v24 - 1) = v26;
*(_BYTE *)(v16 + 4 * v24 - 2) = v26;
*(_BYTE *)(v29 + v14 + 4 * v24) = v26;
*(_BYTE *)(v16 + 4 * v24) = -1;
--v25;
++v24;
}
while ( v25 > 0 );
}
v14 += v11;
v13 += v12;
}
}
free(v4);
return v29;
}
else
{
free(a1);
*(_QWORD *)(__readfsqword(0) - 8) = "outofmem";
return 0LL;
}
}
return v4;
}
| stbi__convert_format:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV qword ptr [RSP + 0x10],RSI
CMP ESI,0x4
JZ 0x0011593b
MOV EBP,ECX
MOV R14D,EDX
MOV EDI,0x4
MOV ESI,EDX
MOV EDX,ECX
XOR ECX,ECX
CALL 0x00116932
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JZ 0x00115917
MOV qword ptr [RSP],R14
TEST EBP,EBP
JLE 0x00115908
MOV RAX,qword ptr [RSP + 0x10]
LEA EAX,[0x4 + RAX*0x8]
CMP EAX,0x1c
JA 0x0011594d
MOV ECX,0x10101000
BT ECX,EAX
JNC 0x0011594d
CMP EBP,0x2
MOV ECX,0x1
CMOVGE ECX,EBP
MOV R8,qword ptr [RSP]
LEA EDX,[R8 + -0x1]
MOV RSI,qword ptr [RSP + 0x8]
ADD RSI,0x3
LEA EDI,[R8*0x4]
IMUL R8D,dword ptr [RSP + 0x10]
XOR R9D,R9D
XOR R10D,R10D
XOR R11D,R11D
LAB_00115816:
MOV R13D,R10D
ADD R13,RSI
MOV EBP,R9D
ADD RBP,RBX
CMP EAX,0x14
JZ 0x00115889
CMP EAX,0x1c
JNZ 0x001158c3
TEST EDX,EDX
JS 0x001158f6
MOV R13D,R11D
MOV R14,qword ptr [RSP]
IMUL R13D,R14D
MOV EBP,R13D
IMUL EBP,dword ptr [RSP + 0x10]
ADD RBP,RBX
SHL R13D,0x2
ADD R13,qword ptr [RSP + 0x8]
MOV R12D,R14D
LAB_0011585a:
MOV R14B,byte ptr [RBP]
MOV byte ptr [R13],R14B
MOV R14B,byte ptr [RBP + 0x1]
MOV byte ptr [R13 + 0x1],R14B
MOV R14B,byte ptr [RBP + 0x2]
MOV byte ptr [R13 + 0x2],R14B
MOV byte ptr [R13 + 0x3],0xff
ADD RBP,0x3
ADD R13,0x4
DEC R12D
TEST R12D,R12D
JG 0x0011585a
JMP 0x001158f6
LAB_00115889:
TEST EDX,EDX
JS 0x001158f6
XOR R12D,R12D
MOV R14,qword ptr [RSP]
MOV R15D,R14D
LAB_00115897:
MOV R14B,byte ptr [RBP + R12*0x1]
MOV byte ptr [R13 + R12*0x2 + -0x1],R14B
MOV byte ptr [R13 + R12*0x2 + -0x2],R14B
MOV byte ptr [R13 + R12*0x2 + -0x3],R14B
MOV R14B,byte ptr [RBP + R12*0x1 + 0x1]
MOV byte ptr [R13 + R12*0x2],R14B
DEC R15D
ADD R12,0x2
TEST R15D,R15D
JG 0x00115897
JMP 0x001158f6
LAB_001158c3:
TEST EDX,EDX
JS 0x001158f6
XOR R12D,R12D
MOV R14,qword ptr [RSP]
MOV R15D,R14D
LAB_001158d1:
MOV R14B,byte ptr [RBP + R12*0x1]
MOV byte ptr [R13 + R12*0x4 + -0x1],R14B
MOV byte ptr [R13 + R12*0x4 + -0x2],R14B
MOV byte ptr [R13 + R12*0x4 + -0x3],R14B
MOV byte ptr [R13 + R12*0x4],0xff
DEC R15D
INC R12
TEST R15D,R15D
JG 0x001158d1
LAB_001158f6:
INC R11
ADD R10D,EDI
ADD R9D,R8D
CMP R11,RCX
JNZ 0x00115816
LAB_00115908:
MOV RDI,RBX
CALL 0x001032c0
MOV RBX,qword ptr [RSP + 0x8]
JMP 0x0011593b
LAB_00115917:
MOV RDI,RBX
CALL 0x001032c0
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x1262b3]
MOV qword ptr [RAX + -0x8],RCX
XOR EBX,EBX
LAB_0011593b:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011594d:
LEA RDI,[0x126eb6]
LEA RSI,[0x1260c2]
LEA RCX,[0x126538]
MOV EDX,0x6fe
CALL 0x001030b0
|
void * stbi__convert_format(void *param_1,int param_2,int param_3,uint param_4)
{
int1 uVar1;
uint uVar2;
void *pvVar3;
ulong uVar4;
int iVar5;
int1 *puVar6;
ulong uVar7;
uint uVar8;
ulong uVar9;
long lVar10;
int iVar11;
ulong uVar12;
int1 *puVar13;
long *in_FS_OFFSET;
pvVar3 = param_1;
if (param_2 != 4) {
pvVar3 = (void *)stbi__malloc_mad3(4,param_3,param_4,0);
if (pvVar3 == (void *)0x0) {
free(param_1);
*(char **)(*in_FS_OFFSET + -8) = "outofmem";
pvVar3 = (void *)0x0;
}
else {
if (0 < (int)param_4) {
uVar2 = param_2 * 8 + 4;
if ((0x1c < uVar2) || ((0x10101000U >> (uVar2 & 0x1f) & 1) == 0)) {
/* WARNING: Subroutine does not return */
__assert_fail("0",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h"
,0x6fe,
"unsigned char *stbi__convert_format(unsigned char *, int, int, unsigned int, unsigned int)"
);
}
uVar4 = 1;
if (1 < (int)param_4) {
uVar4 = (ulong)param_4;
}
iVar5 = param_3 + -1;
uVar7 = 0;
uVar8 = 0;
uVar9 = 0;
do {
uVar12 = (ulong)uVar8;
if (uVar2 == 0x14) {
if (-1 < iVar5) {
lVar10 = 0;
iVar11 = param_3;
do {
uVar1 = *(int1 *)((long)param_1 + lVar10 + uVar7);
*(int1 *)((long)pvVar3 + lVar10 * 2 + uVar12 + 2) = uVar1;
*(int1 *)((long)pvVar3 + lVar10 * 2 + uVar12 + 1) = uVar1;
*(int1 *)((long)pvVar3 + lVar10 * 2 + uVar12) = uVar1;
*(int1 *)((long)pvVar3 + lVar10 * 2 + uVar12 + 3) =
*(int1 *)((long)param_1 + lVar10 + uVar7 + 1);
iVar11 = iVar11 + -1;
lVar10 = lVar10 + 2;
} while (0 < iVar11);
}
}
else if (uVar2 == 0x1c) {
if (-1 < iVar5) {
iVar11 = (int)uVar9 * param_3;
puVar6 = (int1 *)((ulong)(uint)(iVar11 * param_2) + (long)param_1);
puVar13 = (int1 *)((ulong)(uint)(iVar11 * 4) + (long)pvVar3);
iVar11 = param_3;
do {
*puVar13 = *puVar6;
puVar13[1] = puVar6[1];
puVar13[2] = puVar6[2];
puVar13[3] = 0xff;
puVar6 = puVar6 + 3;
puVar13 = puVar13 + 4;
iVar11 = iVar11 + -1;
} while (0 < iVar11);
}
}
else if (-1 < iVar5) {
lVar10 = 0;
iVar11 = param_3;
do {
uVar1 = *(int1 *)((long)param_1 + lVar10 + uVar7);
*(int1 *)((long)pvVar3 + lVar10 * 4 + uVar12 + 2) = uVar1;
*(int1 *)((long)pvVar3 + lVar10 * 4 + uVar12 + 1) = uVar1;
*(int1 *)((long)pvVar3 + lVar10 * 4 + uVar12) = uVar1;
*(int1 *)((long)pvVar3 + lVar10 * 4 + uVar12 + 3) = 0xff;
iVar11 = iVar11 + -1;
lVar10 = lVar10 + 1;
} while (0 < iVar11);
}
uVar9 = uVar9 + 1;
uVar8 = uVar8 + param_3 * 4;
uVar7 = (ulong)(uint)((int)uVar7 + param_3 * param_2);
} while (uVar9 != uVar4);
}
free(param_1);
}
}
return pvVar3;
}
| |
32,125 | stbi__convert_format | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h | static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
{
int i,j;
unsigned char *good;
if (req_comp == img_n) return data;
STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
if (good == NULL) {
STBI_FREE(data);
return stbi__errpuc("outofmem", "Out of memory");
}
for (j=0; j < (int) y; ++j) {
unsigned char *src = data + j * x * img_n ;
unsigned char *dest = good + j * x * req_comp;
#define STBI__COMBO(a,b) ((a)*8+(b))
#define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
// convert source image with img_n components to one with req_comp components;
// avoid switch per pixel, so use switch per scanline and massive macros
switch (STBI__COMBO(img_n, req_comp)) {
STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break;
STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break;
STBI__CASE(2,1) { dest[0]=src[0]; } break;
STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;
STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break;
STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break;
STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;
STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;
STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;
default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion");
}
#undef STBI__CASE
}
STBI_FREE(data);
return good;
} | O2 | c | stbi__convert_format:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
cmpl $0x4, %esi
jne 0x12089
movq %rbx, %rax
jmp 0x121ef
movl %ecx, %r14d
movl %edx, %r15d
pushq $0x4
popq %rdi
xorl %ebp, %ebp
movl %edx, %esi
movl %ecx, %edx
xorl %ecx, %ecx
callq 0x12f8b
testq %rax, %rax
je 0x121cb
testl %r14d, %r14d
cmovlel %ebp, %r14d
movq 0x8(%rsp), %rcx
leal 0x4(,%rcx,8), %esi
leal -0x1(%r15), %r12d
movl %r15d, %edx
imull %ecx, %edx
movq %rax, (%rsp)
addq $0x3, %rax
movq %r15, 0x10(%rsp)
leal (,%r15,4), %edi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq %r14, %r9
je 0x121bd
cmpl $0x1c, %esi
je 0x12165
movl %r8d, %r10d
addq %rbx, %r10
movl %ebp, %r11d
addq %rax, %r11
cmpl $0x14, %esi
je 0x12136
cmpl $0xc, %esi
jne 0x121fe
xorl %ecx, %ecx
movl %r12d, %r15d
testl %r15d, %r15d
js 0x121b0
movb (%r10,%rcx), %r13b
movb %r13b, -0x1(%r11,%rcx,4)
movb %r13b, -0x2(%r11,%rcx,4)
movb %r13b, -0x3(%r11,%rcx,4)
movb $-0x1, (%r11,%rcx,4)
decl %r15d
incq %rcx
jmp 0x1210d
xorl %ecx, %ecx
movl %r12d, %r15d
testl %r15d, %r15d
js 0x121b0
movb (%r10,%rcx), %r13b
movb %r13b, -0x1(%r11,%rcx,2)
movb %r13b, -0x2(%r11,%rcx,2)
movb %r13b, -0x3(%r11,%rcx,2)
movb 0x1(%r10,%rcx), %r13b
movb %r13b, (%r11,%rcx,2)
decl %r15d
addq $0x2, %rcx
jmp 0x1213b
movl %r9d, %r10d
imull 0x10(%rsp), %r10d
movl %r10d, %r11d
imull 0x8(%rsp), %r11d
addq %rbx, %r11
shll $0x2, %r10d
addq (%rsp), %r10
movl %r12d, %ecx
testl %ecx, %ecx
js 0x121b0
movb (%r11), %r15b
movb %r15b, (%r10)
movb 0x1(%r11), %r15b
movb %r15b, 0x1(%r10)
movb 0x2(%r11), %r15b
movb %r15b, 0x2(%r10)
movb $-0x1, 0x3(%r10)
addq $0x3, %r11
addq $0x4, %r10
decl %ecx
jmp 0x12185
incq %r9
addl %edx, %r8d
addl %edi, %ebp
jmp 0x120e0
movq %rbx, %rdi
callq 0x32b0
movq (%rsp), %rax
jmp 0x121ef
movq %rbx, %rdi
callq 0x32b0
movq %fs:0x0, %rax
leaq 0xf0f9(%rip), %rcx # 0x212df
movq %rcx, -0x8(%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfcd1(%rip), %rdi # 0x21ed6
leaq 0xeee2(%rip), %rsi # 0x210ee
leaq 0xf351(%rip), %rcx # 0x21564
movl $0x6fe, %edx # imm = 0x6FE
callq 0x30a0
| stbi__convert_format:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov [rsp+48h+var_40], rsi
cmp esi, 4
jnz short loc_12089
mov rax, rbx
jmp loc_121EF
loc_12089:
mov r14d, ecx
mov r15d, edx
push 4
pop rdi
xor ebp, ebp
mov esi, edx
mov edx, ecx
xor ecx, ecx
call stbi__malloc_mad3
test rax, rax
jz loc_121CB
test r14d, r14d
cmovle r14d, ebp
mov rcx, [rsp+48h+var_40]
lea esi, ds:4[rcx*8]
lea r12d, [r15-1]
mov edx, r15d
imul edx, ecx
mov [rsp+48h+var_48], rax
add rax, 3
mov [rsp+48h+var_38], r15
lea edi, ds:0[r15*4]
xor r8d, r8d
xor r9d, r9d
loc_120E0:
cmp r9, r14
jz loc_121BD
cmp esi, 1Ch
jz short loc_12165
mov r10d, r8d
add r10, rbx
mov r11d, ebp
add r11, rax
cmp esi, 14h
jz short loc_12136
cmp esi, 0Ch
jnz loc_121FE
xor ecx, ecx
mov r15d, r12d
loc_1210D:
test r15d, r15d
js loc_121B0
mov r13b, [r10+rcx]
mov [r11+rcx*4-1], r13b
mov [r11+rcx*4-2], r13b
mov [r11+rcx*4-3], r13b
mov byte ptr [r11+rcx*4], 0FFh
dec r15d
inc rcx
jmp short loc_1210D
loc_12136:
xor ecx, ecx
mov r15d, r12d
loc_1213B:
test r15d, r15d
js short loc_121B0
mov r13b, [r10+rcx]
mov [r11+rcx*2-1], r13b
mov [r11+rcx*2-2], r13b
mov [r11+rcx*2-3], r13b
mov r13b, [r10+rcx+1]
mov [r11+rcx*2], r13b
dec r15d
add rcx, 2
jmp short loc_1213B
loc_12165:
mov r10d, r9d
imul r10d, dword ptr [rsp+48h+var_38]
mov r11d, r10d
imul r11d, dword ptr [rsp+48h+var_40]
add r11, rbx
shl r10d, 2
add r10, [rsp+48h+var_48]
mov ecx, r12d
loc_12185:
test ecx, ecx
js short loc_121B0
mov r15b, [r11]
mov [r10], r15b
mov r15b, [r11+1]
mov [r10+1], r15b
mov r15b, [r11+2]
mov [r10+2], r15b
mov byte ptr [r10+3], 0FFh
add r11, 3
add r10, 4
dec ecx
jmp short loc_12185
loc_121B0:
inc r9
add r8d, edx
add ebp, edi
jmp loc_120E0
loc_121BD:
mov rdi, rbx
call free
mov rax, [rsp+48h+var_48]
jmp short loc_121EF
loc_121CB:
mov rdi, rbx
call free
mov rax, fs:0
lea rcx, aOutofmem; "outofmem"
mov [rax-8], rcx
xor eax, eax
loc_121EF:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_121FE:
lea rdi, aPvgFtOutlineCh+21h; "0"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aUnsignedCharSt_0; "unsigned char *stbi__convert_format(uns"...
mov edx, 6FEh
call ___assert_fail
| long long stbi__convert_format(long long a1, int a2, unsigned int a3, unsigned int a4)
{
long long v6; // r14
unsigned int v8; // ebp
long long v9; // rax
int v10; // esi
int v11; // r12d
int v12; // edx
long long v13; // rax
int v14; // edi
unsigned int v15; // r8d
long long i; // r9
long long v17; // r10
long long v18; // r11
long long v19; // rcx
int m; // r15d
char v21; // r13
long long v22; // rcx
int k; // r15d
char v24; // r13
_BYTE *v25; // r11
_BYTE *v26; // r10
int j; // ecx
long long v28; // [rsp+0h] [rbp-48h]
unsigned int v30; // [rsp+10h] [rbp-38h]
if ( a2 == 4 )
return a1;
v6 = a4;
v8 = 0;
v9 = stbi__malloc_mad3(4LL, a3, a4, 0LL);
if ( v9 )
{
if ( (int)v6 <= 0 )
v6 = 0LL;
v10 = 8 * a2 + 4;
v11 = a3 - 1;
v12 = a2 * a3;
v28 = v9;
v13 = v9 + 3;
v30 = a3;
v14 = 4 * a3;
v15 = 0;
for ( i = 0LL; i != v6; ++i )
{
if ( v10 == 28 )
{
v25 = (_BYTE *)(a1 + a2 * v30 * (unsigned int)i);
v26 = (_BYTE *)(v28 + 4 * v30 * (unsigned int)i);
for ( j = v11; j >= 0; --j )
{
*v26 = *v25;
v26[1] = v25[1];
v26[2] = v25[2];
v26[3] = -1;
v25 += 3;
v26 += 4;
}
}
else
{
v17 = a1 + v15;
v18 = v13 + v8;
if ( v10 == 20 )
{
v22 = 0LL;
for ( k = v11; k >= 0; --k )
{
v24 = *(_BYTE *)(v17 + v22);
*(_BYTE *)(v18 + 2 * v22 - 1) = v24;
*(_BYTE *)(v18 + 2 * v22 - 2) = v24;
*(_BYTE *)(v18 + 2 * v22 - 3) = v24;
*(_BYTE *)(v18 + 2 * v22) = *(_BYTE *)(v17 + v22 + 1);
v22 += 2LL;
}
}
else
{
if ( v10 != 12 )
__assert_fail(
"0",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h",
1790LL,
"unsigned char *stbi__convert_format(unsigned char *, int, int, unsigned int, unsigned int)");
v19 = 0LL;
for ( m = v11; m >= 0; --m )
{
v21 = *(_BYTE *)(v17 + v19);
*(_BYTE *)(v18 + 4 * v19 - 1) = v21;
*(_BYTE *)(v18 + 4 * v19 - 2) = v21;
*(_BYTE *)(v18 + 4 * v19 - 3) = v21;
*(_BYTE *)(v18 + 4 * v19++) = -1;
}
}
}
v15 += v12;
v8 += v14;
}
free(a1);
return v28;
}
else
{
free(a1);
*(_QWORD *)(__readfsqword(0) - 8) = "outofmem";
return 0LL;
}
}
| stbi__convert_format:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV qword ptr [RSP + 0x8],RSI
CMP ESI,0x4
JNZ 0x00112089
MOV RAX,RBX
JMP 0x001121ef
LAB_00112089:
MOV R14D,ECX
MOV R15D,EDX
PUSH 0x4
POP RDI
XOR EBP,EBP
MOV ESI,EDX
MOV EDX,ECX
XOR ECX,ECX
CALL 0x00112f8b
TEST RAX,RAX
JZ 0x001121cb
TEST R14D,R14D
CMOVLE R14D,EBP
MOV RCX,qword ptr [RSP + 0x8]
LEA ESI,[0x4 + RCX*0x8]
LEA R12D,[R15 + -0x1]
MOV EDX,R15D
IMUL EDX,ECX
MOV qword ptr [RSP],RAX
ADD RAX,0x3
MOV qword ptr [RSP + 0x10],R15
LEA EDI,[R15*0x4]
XOR R8D,R8D
XOR R9D,R9D
LAB_001120e0:
CMP R9,R14
JZ 0x001121bd
CMP ESI,0x1c
JZ 0x00112165
MOV R10D,R8D
ADD R10,RBX
MOV R11D,EBP
ADD R11,RAX
CMP ESI,0x14
JZ 0x00112136
CMP ESI,0xc
JNZ 0x001121fe
XOR ECX,ECX
MOV R15D,R12D
LAB_0011210d:
TEST R15D,R15D
JS 0x001121b0
MOV R13B,byte ptr [R10 + RCX*0x1]
MOV byte ptr [R11 + RCX*0x4 + -0x1],R13B
MOV byte ptr [R11 + RCX*0x4 + -0x2],R13B
MOV byte ptr [R11 + RCX*0x4 + -0x3],R13B
MOV byte ptr [R11 + RCX*0x4],0xff
DEC R15D
INC RCX
JMP 0x0011210d
LAB_00112136:
XOR ECX,ECX
MOV R15D,R12D
LAB_0011213b:
TEST R15D,R15D
JS 0x001121b0
MOV R13B,byte ptr [R10 + RCX*0x1]
MOV byte ptr [R11 + RCX*0x2 + -0x1],R13B
MOV byte ptr [R11 + RCX*0x2 + -0x2],R13B
MOV byte ptr [R11 + RCX*0x2 + -0x3],R13B
MOV R13B,byte ptr [R10 + RCX*0x1 + 0x1]
MOV byte ptr [R11 + RCX*0x2],R13B
DEC R15D
ADD RCX,0x2
JMP 0x0011213b
LAB_00112165:
MOV R10D,R9D
IMUL R10D,dword ptr [RSP + 0x10]
MOV R11D,R10D
IMUL R11D,dword ptr [RSP + 0x8]
ADD R11,RBX
SHL R10D,0x2
ADD R10,qword ptr [RSP]
MOV ECX,R12D
LAB_00112185:
TEST ECX,ECX
JS 0x001121b0
MOV R15B,byte ptr [R11]
MOV byte ptr [R10],R15B
MOV R15B,byte ptr [R11 + 0x1]
MOV byte ptr [R10 + 0x1],R15B
MOV R15B,byte ptr [R11 + 0x2]
MOV byte ptr [R10 + 0x2],R15B
MOV byte ptr [R10 + 0x3],0xff
ADD R11,0x3
ADD R10,0x4
DEC ECX
JMP 0x00112185
LAB_001121b0:
INC R9
ADD R8D,EDX
ADD EBP,EDI
JMP 0x001120e0
LAB_001121bd:
MOV RDI,RBX
CALL 0x001032b0
MOV RAX,qword ptr [RSP]
JMP 0x001121ef
LAB_001121cb:
MOV RDI,RBX
CALL 0x001032b0
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x1212df]
MOV qword ptr [RAX + -0x8],RCX
XOR EAX,EAX
LAB_001121ef:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001121fe:
LEA RDI,[0x121ed6]
LEA RSI,[0x1210ee]
LEA RCX,[0x121564]
MOV EDX,0x6fe
CALL 0x001030a0
|
void * stbi__convert_format(void *param_1,int param_2,int param_3,uint param_4)
{
int1 uVar1;
int iVar2;
void *pvVar3;
long lVar4;
uint uVar5;
ulong uVar6;
ulong uVar7;
int1 *puVar8;
ulong uVar9;
int1 *puVar10;
int iVar11;
ulong uVar12;
int iVar13;
long *in_FS_OFFSET;
if (param_2 != 4) {
uVar12 = (ulong)param_4;
uVar5 = 0;
pvVar3 = (void *)stbi__malloc_mad3(4,param_3,param_4,0);
if (pvVar3 == (void *)0x0) {
free(param_1);
*(char **)(*in_FS_OFFSET + -8) = "outofmem";
param_1 = (void *)0x0;
}
else {
if ((int)param_4 < 1) {
uVar12 = 0;
}
iVar2 = param_2 * 8;
iVar11 = param_3 + -1;
uVar6 = 0;
for (uVar7 = 0; uVar7 != uVar12; uVar7 = uVar7 + 1) {
if (iVar2 == 0x18) {
iVar13 = (int)uVar7 * param_3;
puVar10 = (int1 *)((ulong)(uint)(iVar13 * param_2) + (long)param_1);
puVar8 = (int1 *)((ulong)(uint)(iVar13 * 4) + (long)pvVar3);
for (iVar13 = iVar11; -1 < iVar13; iVar13 = iVar13 + -1) {
*puVar8 = *puVar10;
puVar8[1] = puVar10[1];
puVar8[2] = puVar10[2];
puVar8[3] = 0xff;
puVar10 = puVar10 + 3;
puVar8 = puVar8 + 4;
}
}
else {
uVar9 = (ulong)uVar5;
if (iVar2 == 0x10) {
lVar4 = 0;
for (iVar13 = iVar11; -1 < iVar13; iVar13 = iVar13 + -1) {
uVar1 = *(int1 *)((long)param_1 + lVar4 + uVar6);
*(int1 *)((long)pvVar3 + lVar4 * 2 + uVar9 + 2) = uVar1;
*(int1 *)((long)pvVar3 + lVar4 * 2 + uVar9 + 1) = uVar1;
*(int1 *)((long)pvVar3 + lVar4 * 2 + uVar9) = uVar1;
*(int1 *)((long)pvVar3 + lVar4 * 2 + uVar9 + 3) =
*(int1 *)((long)param_1 + lVar4 + uVar6 + 1);
lVar4 = lVar4 + 2;
}
}
else {
if (iVar2 != 8) {
/* WARNING: Subroutine does not return */
__assert_fail("0",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h"
,0x6fe,
"unsigned char *stbi__convert_format(unsigned char *, int, int, unsigned int, unsigned int)"
);
}
lVar4 = 0;
for (iVar13 = iVar11; -1 < iVar13; iVar13 = iVar13 + -1) {
uVar1 = *(int1 *)((long)param_1 + lVar4 + uVar6);
*(int1 *)((long)pvVar3 + lVar4 * 4 + uVar9 + 2) = uVar1;
*(int1 *)((long)pvVar3 + lVar4 * 4 + uVar9 + 1) = uVar1;
*(int1 *)((long)pvVar3 + lVar4 * 4 + uVar9) = uVar1;
*(int1 *)((long)pvVar3 + lVar4 * 4 + uVar9 + 3) = 0xff;
lVar4 = lVar4 + 1;
}
}
}
uVar6 = (ulong)(uint)((int)uVar6 + param_3 * param_2);
uVar5 = uVar5 + param_3 * 4;
}
free(param_1);
param_1 = pvVar3;
}
}
return param_1;
}
| |
32,126 | common_kv_cache_dump_view(llama_kv_cache_view const&, int) | monkey531[P]llama/common/common.cpp | void common_kv_cache_dump_view(const llama_kv_cache_view & view, int row_size) {
static const char slot_chars[] = ".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+";
printf("=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, largest empty slot=%d @ %d",
view.n_cells, view.n_seq_max, view.used_cells, view.token_count, view.max_contiguous, view.max_contiguous_idx);
llama_kv_cache_view_cell * c_curr = view.cells;
llama_seq_id * cs_curr = view.cells_sequences;
for (int i = 0; i < view.n_cells; i++, c_curr++, cs_curr += view.n_seq_max) {
if (i % row_size == 0) {
printf("\n%5d: ", i);
}
int seq_count = 0;
for (int j = 0; j < view.n_seq_max; j++) {
if (cs_curr[j] >= 0) { seq_count++; }
}
putchar(slot_chars[std::min(sizeof(slot_chars) - 2, size_t(seq_count))]);
}
printf("\n=== Done dumping\n");
} | O1 | cpp | common_kv_cache_dump_view(llama_kv_cache_view const&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %esi
movl 0x4(%rdi), %edx
movl 0xc(%rdi), %ecx
movl 0x8(%rdi), %r8d
movl 0x10(%rdi), %r9d
movl 0x14(%rdi), %eax
movl %eax, (%rsp)
leaq 0x87b61(%rip), %rdi # 0xac854
xorl %eax, %eax
callq 0x18070
cmpl $0x0, (%r14)
jle 0x24d70
movq 0x20(%r14), %r12
movl $0x3e, %r13d
leaq 0x8bbef(%rip), %r15 # 0xb0900
xorl %ebp, %ebp
movl %ebp, %eax
cltd
idivl %ebx
testl %edx, %edx
jne 0x24d2c
leaq 0x87bbb(%rip), %rdi # 0xac8de
movl %ebp, %esi
xorl %eax, %eax
callq 0x18070
movslq 0x4(%r14), %rcx
testq %rcx, %rcx
jle 0x24d4e
xorl %edx, %edx
xorl %eax, %eax
movl (%r12,%rdx,4), %esi
notl %esi
shrl $0x1f, %esi
addl %esi, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x24d39
jmp 0x24d50
xorl %eax, %eax
cmpl $0x3e, %eax
cmovael %r13d, %eax
movsbl (%rax,%r15), %edi
callq 0x18920
incl %ebp
movslq 0x4(%r14), %rax
leaq (%r12,%rax,4), %r12
cmpl (%r14), %ebp
jl 0x24d13
leaq 0x8bb68(%rip), %rdi # 0xb08df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18a30
| _Z25common_kv_cache_dump_viewRK19llama_kv_cache_viewi:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, esi
mov r14, rdi
mov esi, [rdi]
mov edx, [rdi+4]
mov ecx, [rdi+0Ch]
mov r8d, [rdi+8]
mov r9d, [rdi+10h]
mov eax, [rdi+14h]
mov [rsp+38h+var_38], eax
lea rdi, aDumpingKvCache; "=== Dumping KV cache. total cells %d, m"...
xor eax, eax
call _printf
cmp dword ptr [r14], 0
jle short loc_24D70
mov r12, [r14+20h]
mov r13d, 3Eh ; '>'
lea r15, _ZZ25common_kv_cache_dump_viewRK19llama_kv_cache_viewiE10slot_chars; ".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabc"...
xor ebp, ebp
loc_24D13:
mov eax, ebp
cdq
idiv ebx
test edx, edx
jnz short loc_24D2C
lea rdi, a5d; "\n%5d: "
mov esi, ebp
xor eax, eax
call _printf
loc_24D2C:
movsxd rcx, dword ptr [r14+4]
test rcx, rcx
jle short loc_24D4E
xor edx, edx
xor eax, eax
loc_24D39:
mov esi, [r12+rdx*4]
not esi
shr esi, 1Fh
add eax, esi
inc rdx
cmp rcx, rdx
jnz short loc_24D39
jmp short loc_24D50
loc_24D4E:
xor eax, eax
loc_24D50:
cmp eax, 3Eh ; '>'
cmovnb eax, r13d
movsx edi, byte ptr [rax+r15]
call _putchar
inc ebp
movsxd rax, dword ptr [r14+4]
lea r12, [r12+rax*4]
cmp ebp, [r14]
jl short loc_24D13
loc_24D70:
lea rdi, aDoneDumping; "\n=== Done dumping"
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _puts
| long long common_kv_cache_dump_view(long long a1, int a2)
{
long long v2; // r12
int v3; // ebp
long long v4; // rcx
long long v5; // rdx
long long v6; // rax
printf(
"=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, large"
"st empty slot=%d @ %d",
*(_DWORD *)a1,
*(_DWORD *)(a1 + 4),
*(_DWORD *)(a1 + 12),
*(_DWORD *)(a1 + 8),
*(_DWORD *)(a1 + 16),
*(_DWORD *)(a1 + 20));
if ( *(int *)a1 > 0 )
{
v2 = *(_QWORD *)(a1 + 32);
v3 = 0;
do
{
if ( !(v3 % a2) )
printf("\n%5d: ", v3);
v4 = *(int *)(a1 + 4);
if ( v4 <= 0 )
{
v6 = 0LL;
}
else
{
v5 = 0LL;
LODWORD(v6) = 0;
do
v6 = (*(_DWORD *)(v2 + 4 * v5++) >= 0) + (unsigned int)v6;
while ( v4 != v5 );
}
if ( (unsigned int)v6 >= 0x3E )
v6 = 62LL;
putchar((unsigned int)common_kv_cache_dump_view(llama_kv_cache_view const&,int)::slot_chars[v6]);
++v3;
v2 += 4LL * *(int *)(a1 + 4);
}
while ( v3 < *(_DWORD *)a1 );
}
return puts("\n=== Done dumping");
}
| common_kv_cache_dump_view:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
MOV ESI,dword ptr [RDI]
MOV EDX,dword ptr [RDI + 0x4]
MOV ECX,dword ptr [RDI + 0xc]
MOV R8D,dword ptr [RDI + 0x8]
MOV R9D,dword ptr [RDI + 0x10]
MOV EAX,dword ptr [RDI + 0x14]
MOV dword ptr [RSP],EAX
LEA RDI,[0x1ac854]
XOR EAX,EAX
CALL 0x00118070
CMP dword ptr [R14],0x0
JLE 0x00124d70
MOV R12,qword ptr [R14 + 0x20]
MOV R13D,0x3e
LEA R15,[0x1b0900]
XOR EBP,EBP
LAB_00124d13:
MOV EAX,EBP
CDQ
IDIV EBX
TEST EDX,EDX
JNZ 0x00124d2c
LEA RDI,[0x1ac8de]
MOV ESI,EBP
XOR EAX,EAX
CALL 0x00118070
LAB_00124d2c:
MOVSXD RCX,dword ptr [R14 + 0x4]
TEST RCX,RCX
JLE 0x00124d4e
XOR EDX,EDX
XOR EAX,EAX
LAB_00124d39:
MOV ESI,dword ptr [R12 + RDX*0x4]
NOT ESI
SHR ESI,0x1f
ADD EAX,ESI
INC RDX
CMP RCX,RDX
JNZ 0x00124d39
JMP 0x00124d50
LAB_00124d4e:
XOR EAX,EAX
LAB_00124d50:
CMP EAX,0x3e
CMOVNC EAX,R13D
MOVSX EDI,byte ptr [RAX + R15*0x1]
CALL 0x00118920
INC EBP
MOVSXD RAX,dword ptr [R14 + 0x4]
LEA R12,[R12 + RAX*0x4]
CMP EBP,dword ptr [R14]
JL 0x00124d13
LAB_00124d70:
LEA RDI,[0x1b08df]
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00118a30
|
/* common_kv_cache_dump_view(llama_kv_cache_view const&, int) */
void common_kv_cache_dump_view(llama_kv_cache_view *param_1,int param_2)
{
uint uVar1;
int8 in_RAX;
ulong uVar2;
long lVar3;
uint uVar4;
long lVar5;
printf("=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, largest empty slot=%d @ %d"
,(ulong)*(uint *)param_1,(ulong)*(uint *)(param_1 + 4),(ulong)*(uint *)(param_1 + 0xc),
(ulong)*(uint *)(param_1 + 8),(ulong)*(uint *)(param_1 + 0x10),
CONCAT44((int)((ulong)in_RAX >> 0x20),*(int4 *)(param_1 + 0x14)));
if (0 < *(int *)param_1) {
lVar5 = *(long *)(param_1 + 0x20);
uVar4 = 0;
do {
if ((int)uVar4 % param_2 == 0) {
printf("\n%5d: ",(ulong)uVar4);
}
if ((long)*(int *)(param_1 + 4) < 1) {
uVar1 = 0;
}
else {
lVar3 = 0;
uVar1 = 0;
do {
uVar1 = uVar1 - ((int)~*(uint *)(lVar5 + lVar3 * 4) >> 0x1f);
lVar3 = lVar3 + 1;
} while (*(int *)(param_1 + 4) != lVar3);
}
uVar2 = (ulong)uVar1;
if (0x3d < uVar1) {
uVar2 = 0x3e;
}
putchar((int)".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+"[uVar2]);
uVar4 = uVar4 + 1;
lVar5 = lVar5 + (long)*(int *)(param_1 + 4) * 4;
} while ((int)uVar4 < *(int *)param_1);
}
puts("\n=== Done dumping");
return;
}
| |
32,127 | mysql_stat | eloqsql/libmariadb/libmariadb/mariadb_lib.c | char * STDCALL
mysql_stat(MYSQL *mysql)
{
if (ma_simple_command(mysql, COM_STATISTICS,0,0,0,0))
return mysql->net.last_error;
mysql->net.read_pos[mysql->packet_length]=0; /* End of stat string */
if (!mysql->net.read_pos[0])
{
SET_CLIENT_ERROR(mysql, CR_WRONG_HOST_INFO , SQLSTATE_UNKNOWN, 0);
return mysql->net.last_error;
}
return((char*) mysql->net.read_pos);
} | O0 | c | mysql_stat:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x9, %esi
xorl %eax, %eax
movl %eax, %r9d
xorl %r8d, %r8d
movq %r9, %rdx
movq %r9, %rcx
callq 0x16fa0
cmpl $0x0, %eax
je 0x207f0
movq -0x10(%rbp), %rax
addq $0x97, %rax
movq %rax, -0x8(%rbp)
jmp 0x20895
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x358(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpb $0x0, (%rax)
jne 0x20889
jmp 0x20816
movq -0x10(%rbp), %rax
movl $0x7d9, 0x90(%rax) # imm = 0x7D9
movq -0x10(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x3f6aa(%rip), %rax # 0x5fee0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x10(%rbp), %rdi
addq $0x97, %rdi
leaq 0x3f690(%rip), %rax # 0x5fef0
movq 0x48(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x296(%rax)
movq -0x10(%rbp), %rax
addq $0x97, %rax
movq %rax, -0x8(%rbp)
jmp 0x20895
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
| mysql_stat:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
mov esi, 9
xor eax, eax
mov r9d, eax
xor r8d, r8d
mov rdx, r9
mov rcx, r9
call ma_simple_command
cmp eax, 0
jz short loc_207F0
mov rax, [rbp+var_10]
add rax, 97h
mov [rbp+var_8], rax
jmp loc_20895
loc_207F0:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+358h]
mov byte ptr [rax+rcx], 0
mov rax, [rbp+var_10]
mov rax, [rax+20h]
cmp byte ptr [rax], 0
jnz short loc_20889
jmp short $+2
loc_20816:
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 7D9h
mov rdi, [rbp+var_10]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+29Ch], 0
mov rdi, [rbp+var_10]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+48h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+296h], 0
mov rax, [rbp+var_10]
add rax, 97h
mov [rbp+var_8], rax
jmp short loc_20895
loc_20889:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov [rbp+var_8], rax
loc_20895:
mov rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
| long long mysql_stat(long long a1)
{
if ( (unsigned int)ma_simple_command(a1, 9u, 0LL, 0LL, 0, 0LL) )
return a1 + 151;
*(_BYTE *)(*(_QWORD *)(a1 + 32) + *(_QWORD *)(a1 + 856)) = 0;
if ( **(_BYTE **)(a1 + 32) )
return *(_QWORD *)(a1 + 32);
*(_DWORD *)(a1 + 144) = 2009;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[9], 511LL);
*(_BYTE *)(a1 + 662) = 0;
return a1 + 151;
}
| mysql_stat:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x9
XOR EAX,EAX
MOV R9D,EAX
XOR R8D,R8D
MOV RDX,R9
MOV RCX,R9
CALL 0x00116fa0
CMP EAX,0x0
JZ 0x001207f0
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x97
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00120895
LAB_001207f0:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x358]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
CMP byte ptr [RAX],0x0
JNZ 0x00120889
JMP 0x00120816
LAB_00120816:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x7d9
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x297
LEA RAX,[0x15fee0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x97
LEA RAX,[0x15fef0]
MOV RSI,qword ptr [RAX + 0x48]
MOV EDX,0x1ff
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x296],0x0
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x97
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00120895
LAB_00120889:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_00120895:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
long mysql_stat(long param_1)
{
int iVar1;
int8 local_10;
iVar1 = ma_simple_command(param_1,9,0,0,0);
if (iVar1 == 0) {
*(int1 *)(*(long *)(param_1 + 0x20) + *(long *)(param_1 + 0x358)) = 0;
if (**(char **)(param_1 + 0x20) == '\0') {
*(int4 *)(param_1 + 0x90) = 0x7d9;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),PTR_s_Wrong_host_info_0015ff38,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
local_10 = param_1 + 0x97;
}
else {
local_10 = *(long *)(param_1 + 0x20);
}
}
else {
local_10 = param_1 + 0x97;
}
return local_10;
}
| |
32,128 | get_key_cache_statistics | eloqsql/mysys/mf_keycache.c | void get_key_cache_statistics(KEY_CACHE *keycache, uint partition_no,
KEY_CACHE_STATISTICS *key_cache_stats)
{
if (keycache->key_cache_inited)
{
pthread_mutex_lock(&keycache->op_lock);
keycache->interface_funcs->get_stats(keycache->keycache_cb,
partition_no, key_cache_stats);
pthread_mutex_unlock(&keycache->op_lock);
}
} | O0 | c | get_key_cache_statistics:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x48(%rax)
je 0xef2e4
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq *%rax
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a1f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| get_key_cache_statistics:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
cmp byte ptr [rax+48h], 0
jz short loc_EF2E4
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
call _pthread_mutex_lock
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rax, [rax+48h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
call rax
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
call _pthread_mutex_unlock
loc_EF2E4:
add rsp, 20h
pop rbp
retn
| long long get_key_cache_statistics(long long a1, unsigned int a2, long long a3)
{
long long result; // rax
result = a1;
if ( *(_BYTE *)(a1 + 72) )
{
pthread_mutex_lock(a1 + 88);
(*(void ( **)(_QWORD, _QWORD, long long))(*(_QWORD *)(a1 + 16) + 72LL))(*(_QWORD *)(a1 + 8), a2, a3);
return pthread_mutex_unlock(a1 + 88);
}
return result;
}
| get_key_cache_statistics:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x48],0x0
JZ 0x001ef2e4
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
CALL 0x0012a210
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
CALL RAX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
CALL 0x0012a1f0
LAB_001ef2e4:
ADD RSP,0x20
POP RBP
RET
|
void get_key_cache_statistics(long param_1,int4 param_2,int8 param_3)
{
if (*(char *)(param_1 + 0x48) != '\0') {
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x58));
(**(code **)(*(long *)(param_1 + 0x10) + 0x48))(*(int8 *)(param_1 + 8),param_2,param_3);
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x58));
}
return;
}
| |
32,129 | my_pread | eloqsql/mysys/my_pread.c | size_t my_pread(File Filedes, uchar *Buffer, size_t Count, my_off_t offset,
myf MyFlags)
{
size_t readbytes, save_count= 0;
DBUG_ENTER("my_pread");
DBUG_PRINT("my",("fd: %d Seek: %llu Buffer: %p Count: %lu MyFlags: %lu",
Filedes, (ulonglong)offset, Buffer, (ulong)Count, MyFlags));
if (!(MyFlags & (MY_WME | MY_FAE | MY_FNABP)))
MyFlags|= my_global_flags;
for (;;)
{
errno= 0; /* Linux, Windows don't reset this on EOF/success */
#ifdef _WIN32
readbytes= my_win_pread(Filedes, Buffer, Count, offset);
#else
readbytes= pread(Filedes, Buffer, Count, offset);
#endif
if (readbytes != Count)
{
/* We should never read with wrong file descriptor! */
DBUG_ASSERT(readbytes != (size_t)-1 || errno != EBADF);
my_errno= errno;
if (errno == 0 || (readbytes != (size_t) -1 &&
(MyFlags & (MY_NABP | MY_FNABP))))
my_errno= HA_ERR_FILE_TOO_SHORT;
DBUG_PRINT("warning",("Read only %d bytes off %u from %d, errno: %d",
(int) readbytes, (uint) Count,Filedes,my_errno));
if ((readbytes == 0 || readbytes == (size_t) -1) && errno == EINTR)
{
DBUG_PRINT("debug", ("my_pread() was interrupted and returned %d",
(int) readbytes));
continue; /* Interrupted */
}
/* Do a read retry if we didn't get enough data on first read */
if (readbytes != (size_t) -1 && readbytes != 0 &&
(MyFlags & MY_FULL_IO))
{
Buffer+= readbytes;
Count-= readbytes;
save_count+= readbytes;
offset+= readbytes;
continue;
}
if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
{
if (readbytes == (size_t) -1)
my_error(EE_READ,
MYF(ME_BELL | (MyFlags & (ME_NOTE | ME_ERROR_LOG))),
my_filename(Filedes),my_errno);
else if (MyFlags & (MY_NABP | MY_FNABP))
my_error(EE_EOFERR,
MYF(ME_BELL | (MyFlags & (ME_NOTE | ME_ERROR_LOG))),
my_filename(Filedes),my_errno);
}
if (readbytes == (size_t) -1 || (MyFlags & (MY_FNABP | MY_NABP)))
DBUG_RETURN(MY_FILE_ERROR); /* Return with error */
}
if (MyFlags & (MY_NABP | MY_FNABP))
readbytes= 0; /* Read went ok; Return 0 */
else
readbytes+= save_count;
DBUG_RETURN(readbytes);
}
} | O0 | c | my_pread:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
jmp 0xf4625
movq -0x30(%rbp), %rax
andq $0x1a, %rax
cmpq $0x0, %rax
jne 0xf4645
leaq 0xb8e44e(%rip), %rax # 0xc82a88
movq (%rax), %rax
orq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xf4647
callq 0x2a740
movl $0x0, (%rax)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x2a600
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xf47f7
jmp 0xf467a
jmp 0xf467c
callq 0x2a740
movl (%rax), %eax
movl %eax, -0x44(%rbp)
callq 0xf6060
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
callq 0x2a740
cmpl $0x0, (%rax)
je 0xf46af
cmpq $-0x1, -0x38(%rbp)
je 0xf46ba
movq -0x30(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xf46ba
callq 0xf6060
movl $0xaf, (%rax)
jmp 0xf46bc
jmp 0xf46be
cmpq $0x0, -0x38(%rbp)
je 0xf46cc
cmpq $-0x1, -0x38(%rbp)
jne 0xf46df
callq 0x2a740
cmpl $0x4, (%rax)
jne 0xf46df
jmp 0xf46d8
jmp 0xf46da
jmp 0xf4647
cmpq $-0x1, -0x38(%rbp)
je 0xf4735
cmpq $0x0, -0x38(%rbp)
je 0xf4735
movq -0x30(%rbp), %rax
andq $0x200, %rax # imm = 0x200
cmpq $0x0, %rax
je 0xf4735
movq -0x38(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xf4647
movq -0x30(%rbp), %rax
andq $0x1a, %rax
cmpq $0x0, %rax
je 0xf47d4
cmpq $-0x1, -0x38(%rbp)
jne 0xf4789
movq -0x30(%rbp), %rax
andq $0x440, %rax # imm = 0x440
orq $0x4, %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %edi
callq 0x1034b0
movq %rax, -0x50(%rbp)
callq 0xf6060
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl (%rax), %ecx
movl $0x2, %edi
movb $0x0, %al
callq 0xef890
jmp 0xf47d2
movq -0x30(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xf47d0
movq -0x30(%rbp), %rax
andq $0x440, %rax # imm = 0x440
orq $0x4, %rax
movq %rax, -0x68(%rbp)
movl -0xc(%rbp), %edi
callq 0x1034b0
movq %rax, -0x60(%rbp)
callq 0xf6060
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movl (%rax), %ecx
movl $0x9, %edi
movb $0x0, %al
callq 0xef890
jmp 0xf47d2
jmp 0xf47d4
cmpq $-0x1, -0x38(%rbp)
je 0xf47e9
movq -0x30(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xf47f5
jmp 0xf47eb
movq $-0x1, -0x8(%rbp)
jmp 0xf4825
jmp 0xf47f7
movq -0x30(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xf480f
movq $0x0, -0x38(%rbp)
jmp 0xf481b
movq -0x40(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xf481d
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
| my_pread:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_C], edi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_40], 0
jmp short $+2
loc_F4625:
mov rax, [rbp+var_30]
and rax, 1Ah
cmp rax, 0
jnz short loc_F4645
lea rax, my_global_flags
mov rax, [rax]
or rax, [rbp+var_30]
mov [rbp+var_30], rax
loc_F4645:
jmp short $+2
loc_F4647:
call ___errno_location
mov dword ptr [rax], 0
mov edi, [rbp+var_C]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
call _pread64
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
cmp rax, [rbp+var_20]
jz loc_F47F7
jmp short $+2
loc_F467A:
jmp short $+2
loc_F467C:
call ___errno_location
mov eax, [rax]
mov [rbp+var_44], eax
call _my_thread_var
mov ecx, [rbp+var_44]
mov [rax], ecx
call ___errno_location
cmp dword ptr [rax], 0
jz short loc_F46AF
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_F46BA
mov rax, [rbp+var_30]
and rax, 6
cmp rax, 0
jz short loc_F46BA
loc_F46AF:
call _my_thread_var
mov dword ptr [rax], 0AFh
loc_F46BA:
jmp short $+2
loc_F46BC:
jmp short $+2
loc_F46BE:
cmp [rbp+var_38], 0
jz short loc_F46CC
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jnz short loc_F46DF
loc_F46CC:
call ___errno_location
cmp dword ptr [rax], 4
jnz short loc_F46DF
jmp short $+2
loc_F46D8:
jmp short $+2
loc_F46DA:
jmp loc_F4647
loc_F46DF:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_F4735
cmp [rbp+var_38], 0
jz short loc_F4735
mov rax, [rbp+var_30]
and rax, 200h
cmp rax, 0
jz short loc_F4735
mov rax, [rbp+var_38]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rcx, [rbp+var_38]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_38]
add rax, [rbp+var_40]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
add rax, [rbp+var_28]
mov [rbp+var_28], rax
jmp loc_F4647
loc_F4735:
mov rax, [rbp+var_30]
and rax, 1Ah
cmp rax, 0
jz loc_F47D4
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jnz short loc_F4789
mov rax, [rbp+var_30]
and rax, 440h
or rax, 4
mov [rbp+var_58], rax
mov edi, [rbp+var_C]
call my_filename
mov [rbp+var_50], rax
call _my_thread_var
mov rsi, [rbp+var_58]
mov rdx, [rbp+var_50]
mov ecx, [rax]
mov edi, 2
mov al, 0
call my_error
jmp short loc_F47D2
loc_F4789:
mov rax, [rbp+var_30]
and rax, 6
cmp rax, 0
jz short loc_F47D0
mov rax, [rbp+var_30]
and rax, 440h
or rax, 4
mov [rbp+var_68], rax
mov edi, [rbp+var_C]
call my_filename
mov [rbp+var_60], rax
call _my_thread_var
mov rsi, [rbp+var_68]
mov rdx, [rbp+var_60]
mov ecx, [rax]
mov edi, 9
mov al, 0
call my_error
loc_F47D0:
jmp short $+2
loc_F47D2:
jmp short $+2
loc_F47D4:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_F47E9
mov rax, [rbp+var_30]
and rax, 6
cmp rax, 0
jz short loc_F47F5
loc_F47E9:
jmp short $+2
loc_F47EB:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_F4825
loc_F47F5:
jmp short $+2
loc_F47F7:
mov rax, [rbp+var_30]
and rax, 6
cmp rax, 0
jz short loc_F480F
mov [rbp+var_38], 0
jmp short loc_F481B
loc_F480F:
mov rax, [rbp+var_40]
add rax, [rbp+var_38]
mov [rbp+var_38], rax
loc_F481B:
jmp short $+2
loc_F481D:
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_F4825:
mov rax, [rbp+var_8]
add rsp, 70h
pop rbp
retn
| long long my_pread(unsigned int a1, const char *a2, long long a3, long long a4, __int16 a5)
{
unsigned int *v5; // rax
unsigned int *v6; // rax
long long v8; // [rsp+10h] [rbp-60h]
long long v9; // [rsp+20h] [rbp-50h]
int v10; // [rsp+2Ch] [rbp-44h]
long long v11; // [rsp+30h] [rbp-40h]
long long v12; // [rsp+38h] [rbp-38h]
__int16 v14; // [rsp+40h] [rbp-30h]
v14 = a5;
v11 = 0LL;
if ( (a5 & 0x1A) == 0 )
v14 = a5 | my_global_flags;
while ( 1 )
{
*(_DWORD *)__errno_location() = 0;
v12 = pread64(a1, a2, a3, a4);
if ( v12 == a3 )
break;
v10 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a1, a2) = v10;
if ( !*(_DWORD *)__errno_location() || v12 != -1 && (v14 & 6) != 0 )
*(_DWORD *)my_thread_var(a1, a2) = 175;
if ( v12 && v12 != -1 || *(_DWORD *)__errno_location() != 4 )
{
if ( v12 == -1 || !v12 || (v14 & 0x200) == 0 )
{
if ( (v14 & 0x1A) != 0 )
{
if ( v12 == -1 )
{
v9 = my_filename(a1);
v5 = (unsigned int *)my_thread_var(a1, a2);
my_error(2u, v14 & 0x440 | 4LL, v9, *v5);
}
else if ( (v14 & 6) != 0 )
{
v8 = my_filename(a1);
v6 = (unsigned int *)my_thread_var(a1, a2);
my_error(9u, v14 & 0x440 | 4LL, v8, *v6);
}
}
if ( v12 == -1 || (v14 & 6) != 0 )
return -1LL;
break;
}
a2 += v12;
a3 -= v12;
v11 += v12;
a4 += v12;
}
}
if ( (v14 & 6) != 0 )
return 0LL;
else
return v12 + v11;
}
| my_pread:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV dword ptr [RBP + -0xc],EDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x40],0x0
JMP 0x001f4625
LAB_001f4625:
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x1a
CMP RAX,0x0
JNZ 0x001f4645
LEA RAX,[0xd82a88]
MOV RAX,qword ptr [RAX]
OR RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RAX
LAB_001f4645:
JMP 0x001f4647
LAB_001f4647:
CALL 0x0012a740
MOV dword ptr [RAX],0x0
MOV EDI,dword ptr [RBP + -0xc]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
CALL 0x0012a600
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001f47f7
JMP 0x001f467a
LAB_001f467a:
JMP 0x001f467c
LAB_001f467c:
CALL 0x0012a740
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x44],EAX
CALL 0x001f6060
MOV ECX,dword ptr [RBP + -0x44]
MOV dword ptr [RAX],ECX
CALL 0x0012a740
CMP dword ptr [RAX],0x0
JZ 0x001f46af
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001f46ba
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001f46ba
LAB_001f46af:
CALL 0x001f6060
MOV dword ptr [RAX],0xaf
LAB_001f46ba:
JMP 0x001f46bc
LAB_001f46bc:
JMP 0x001f46be
LAB_001f46be:
CMP qword ptr [RBP + -0x38],0x0
JZ 0x001f46cc
CMP qword ptr [RBP + -0x38],-0x1
JNZ 0x001f46df
LAB_001f46cc:
CALL 0x0012a740
CMP dword ptr [RAX],0x4
JNZ 0x001f46df
JMP 0x001f46d8
LAB_001f46d8:
JMP 0x001f46da
LAB_001f46da:
JMP 0x001f4647
LAB_001f46df:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001f4735
CMP qword ptr [RBP + -0x38],0x0
JZ 0x001f4735
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x200
CMP RAX,0x0
JZ 0x001f4735
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001f4647
LAB_001f4735:
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x1a
CMP RAX,0x0
JZ 0x001f47d4
CMP qword ptr [RBP + -0x38],-0x1
JNZ 0x001f4789
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x440
OR RAX,0x4
MOV qword ptr [RBP + -0x58],RAX
MOV EDI,dword ptr [RBP + -0xc]
CALL 0x002034b0
MOV qword ptr [RBP + -0x50],RAX
CALL 0x001f6060
MOV RSI,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RAX]
MOV EDI,0x2
MOV AL,0x0
CALL 0x001ef890
JMP 0x001f47d2
LAB_001f4789:
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001f47d0
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x440
OR RAX,0x4
MOV qword ptr [RBP + -0x68],RAX
MOV EDI,dword ptr [RBP + -0xc]
CALL 0x002034b0
MOV qword ptr [RBP + -0x60],RAX
CALL 0x001f6060
MOV RSI,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x60]
MOV ECX,dword ptr [RAX]
MOV EDI,0x9
MOV AL,0x0
CALL 0x001ef890
LAB_001f47d0:
JMP 0x001f47d2
LAB_001f47d2:
JMP 0x001f47d4
LAB_001f47d4:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001f47e9
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001f47f5
LAB_001f47e9:
JMP 0x001f47eb
LAB_001f47eb:
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x001f4825
LAB_001f47f5:
JMP 0x001f47f7
LAB_001f47f7:
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001f480f
MOV qword ptr [RBP + -0x38],0x0
JMP 0x001f481b
LAB_001f480f:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
LAB_001f481b:
JMP 0x001f481d
LAB_001f481d:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001f4825:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x70
POP RBP
RET
|
long my_pread(int param_1,void *param_2,size_t param_3,long param_4,ulong param_5)
{
int iVar1;
int *piVar2;
size_t sVar3;
int4 *puVar4;
int8 uVar5;
long local_48;
long local_40;
ulong local_38;
long local_30;
size_t local_28;
void *local_20;
local_48 = 0;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_38 = param_5;
if ((param_5 & 0x1a) == 0) {
local_38 = my_global_flags | param_5;
}
do {
do {
piVar2 = __errno_location();
*piVar2 = 0;
sVar3 = pread64(param_1,local_20,local_28,local_30);
if (sVar3 == local_28) {
LAB_001f47f7:
if ((local_38 & 6) == 0) {
local_40 = local_48 + sVar3;
}
else {
local_40 = 0;
}
return local_40;
}
piVar2 = __errno_location();
iVar1 = *piVar2;
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar1;
piVar2 = __errno_location();
if ((*piVar2 == 0) || ((sVar3 != 0xffffffffffffffff && ((local_38 & 6) != 0)))) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0xaf;
}
} while (((sVar3 == 0) || (sVar3 == 0xffffffffffffffff)) &&
(piVar2 = __errno_location(), *piVar2 == 4));
if (((sVar3 == 0xffffffffffffffff) || (sVar3 == 0)) || ((local_38 & 0x200) == 0)) {
if ((local_38 & 0x1a) != 0) {
if (sVar3 == 0xffffffffffffffff) {
uVar5 = my_filename(param_1);
puVar4 = (int4 *)_my_thread_var();
my_error(2,local_38 & 0x440 | 4,uVar5,*puVar4);
}
else if ((local_38 & 6) != 0) {
uVar5 = my_filename(param_1);
puVar4 = (int4 *)_my_thread_var();
my_error(9,local_38 & 0x440 | 4,uVar5,*puVar4);
}
}
if ((sVar3 == 0xffffffffffffffff) || ((local_38 & 6) != 0)) {
return -1;
}
goto LAB_001f47f7;
}
local_20 = (void *)(sVar3 + (long)local_20);
local_28 = local_28 - sVar3;
local_48 = sVar3 + local_48;
local_30 = sVar3 + local_30;
} while( true );
}
| |
32,130 | end_server | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static void
end_server(MYSQL *mysql)
{
/* if net->error 2 and reconnect is activated, we need to inform
connection handler */
if (mysql->net.pvio != 0)
{
ma_pvio_close(mysql->net.pvio);
mysql->net.pvio= 0; /* Marker */
}
ma_net_end(&mysql->net);
free_old_query(mysql);
return;
} | O0 | c | end_server:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x20b3d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2e700
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x1e1e0
movq -0x8(%rbp), %rdi
callq 0x28d00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| end_server:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz short loc_20B3D
mov rax, [rbp+var_8]
mov rdi, [rax]
call ma_pvio_close
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
loc_20B3D:
mov rdi, [rbp+var_8]
call ma_net_end
mov rdi, [rbp+var_8]
call free_old_query
add rsp, 10h
pop rbp
retn
| long long end_server(_QWORD *a1)
{
if ( *a1 )
{
ma_pvio_close(*a1);
*a1 = 0LL;
}
ma_net_end((long long)a1);
return free_old_query(a1);
}
| end_server:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX],0x0
JZ 0x00120b3d
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
CALL 0x0012e700
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
LAB_00120b3d:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0011e1e0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00128d00
ADD RSP,0x10
POP RBP
RET
|
void end_server(long *param_1)
{
if (*param_1 != 0) {
ma_pvio_close(*param_1);
*param_1 = 0;
}
ma_net_end(param_1);
free_old_query(param_1);
return;
}
| |
32,131 | OpenSubdiv::v3_6_0::Far::PatchTableBuilder::isFVarChannelLinear(int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp | bool isFVarChannelLinear(int fvcInTable) const {
if (_options.generateFVarLegacyLinearPatches) return true;
return (_refiner.GetFVarLinearInterpolation(
getRefinerFVarChannel(fvcInTable)) == Sdc::Options::FVAR_LINEAR_ALL);
} | O2 | cpp | OpenSubdiv::v3_6_0::Far::PatchTableBuilder::isFVarChannelLinear(int) const:
movb $0x1, %al
testb $0x8, 0xa(%rdi)
jne 0x808cb
movq %rdi, %rcx
movq (%rdi), %rdi
testl %esi, %esi
js 0x808b8
movl %esi, %eax
movq 0xa8(%rcx), %rcx
movl (%rcx,%rax,4), %esi
jmp 0x808bb
pushq $-0x1
popq %rsi
pushq %rax
callq 0x53f20
cmpl $0x5, %eax
sete %al
addq $0x8, %rsp
retq
| _ZNK10OpenSubdiv6v3_6_03Far17PatchTableBuilder19isFVarChannelLinearEi:
mov al, 1
test byte ptr [rdi+0Ah], 8
jnz short locret_808CB
mov rcx, rdi
mov rdi, [rdi]; this
test esi, esi
js short loc_808B8
mov eax, esi
mov rcx, [rcx+0A8h]
mov esi, [rcx+rax*4]
jmp short loc_808BB
loc_808B8:
push 0FFFFFFFFFFFFFFFFh
pop rsi; int
loc_808BB:
push rax
call __ZNK10OpenSubdiv6v3_6_03Far15TopologyRefiner26GetFVarLinearInterpolationEi; OpenSubdiv::v3_6_0::Far::TopologyRefiner::GetFVarLinearInterpolation(int)
cmp eax, 5
setz al
add rsp, 8
locret_808CB:
retn
| bool OpenSubdiv::v3_6_0::Far::PatchTableBuilder::isFVarChannelLinear(
OpenSubdiv::v3_6_0::Far::TopologyRefiner **this,
int a2)
{
bool result; // al
OpenSubdiv::v3_6_0::Far::TopologyRefiner *v4; // rdi
int v5; // esi
result = 1;
if ( (*((_BYTE *)this + 10) & 8) == 0 )
{
v4 = *this;
if ( a2 < 0 )
v5 = -1;
else
v5 = *((_DWORD *)this[21] + (unsigned int)a2);
return (unsigned int)OpenSubdiv::v3_6_0::Far::TopologyRefiner::GetFVarLinearInterpolation(v4, v5) == 5;
}
return result;
}
| isFVarChannelLinear:
MOV AL,0x1
TEST byte ptr [RDI + 0xa],0x8
JNZ 0x001808cb
MOV RCX,RDI
MOV RDI,qword ptr [RDI]
TEST ESI,ESI
JS 0x001808b8
MOV EAX,ESI
MOV RCX,qword ptr [RCX + 0xa8]
MOV ESI,dword ptr [RCX + RAX*0x4]
JMP 0x001808bb
LAB_001808b8:
PUSH -0x1
POP RSI
LAB_001808bb:
PUSH RAX
CALL 0x00153f20
CMP EAX,0x5
SETZ AL
ADD RSP,0x8
LAB_001808cb:
RET
|
/* OpenSubdiv::v3_6_0::Far::PatchTableBuilder::isFVarChannelLinear(int) const */
bool __thiscall
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::isFVarChannelLinear(PatchTableBuilder *this,int param_1)
{
int iVar1;
bool bVar2;
bVar2 = true;
if (((byte)this[10] & 8) == 0) {
if (param_1 < 0) {
iVar1 = -1;
}
else {
iVar1 = *(int *)(*(long *)(this + 0xa8) + (ulong)(uint)param_1 * 4);
}
iVar1 = TopologyRefiner::GetFVarLinearInterpolation(*(TopologyRefiner **)this,iVar1);
bVar2 = iVar1 == 5;
}
return bVar2;
}
| |
32,132 | OpenSubdiv::v3_6_0::Far::PatchTableBuilder::isFVarChannelLinear(int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTableFactory.cpp | bool isFVarChannelLinear(int fvcInTable) const {
if (_options.generateFVarLegacyLinearPatches) return true;
return (_refiner.GetFVarLinearInterpolation(
getRefinerFVarChannel(fvcInTable)) == Sdc::Options::FVAR_LINEAR_ALL);
} | O3 | cpp | OpenSubdiv::v3_6_0::Far::PatchTableBuilder::isFVarChannelLinear(int) const:
movb $0x1, %al
testb $0x8, 0xa(%rdi)
jne 0x704a2
movq (%rdi), %rax
testl %esi, %esi
js 0x7047f
movl %esi, %ecx
movq 0xa8(%rdi), %rdx
movl (%rdx,%rcx,4), %esi
jmp 0x70484
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
pushq %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
callq 0x39220
andl $0xff00, %eax # imm = 0xFF00
cmpl $0x500, %eax # imm = 0x500
sete %al
addq $0x8, %rsp
retq
nop
| _ZNK10OpenSubdiv6v3_6_03Far17PatchTableBuilder19isFVarChannelLinearEi:
mov al, 1
test byte ptr [rdi+0Ah], 8
jnz short locret_704A2
mov rax, [rdi]
test esi, esi
js short loc_7047F
mov ecx, esi
mov rdx, [rdi+0A8h]
mov esi, [rdx+rcx*4]
jmp short loc_70484
loc_7047F:
mov esi, 0FFFFFFFFh; int
loc_70484:
push rax
mov rax, [rax+30h]
mov rdi, [rax]; this
call __ZNK10OpenSubdiv6v3_6_03Vtr8internal5Level14getFVarOptionsEi; OpenSubdiv::v3_6_0::Vtr::internal::Level::getFVarOptions(int)
and eax, 0FF00h
cmp eax, 500h
setz al
add rsp, 8
locret_704A2:
retn
| bool OpenSubdiv::v3_6_0::Far::PatchTableBuilder::isFVarChannelLinear(
OpenSubdiv::v3_6_0::Far::PatchTableBuilder *this,
int a2)
{
bool result; // al
int v3; // esi
result = 1;
if ( (*((_BYTE *)this + 10) & 8) == 0 )
{
if ( a2 < 0 )
v3 = -1;
else
v3 = *(_DWORD *)(*((_QWORD *)this + 21) + 4LL * (unsigned int)a2);
return (OpenSubdiv::v3_6_0::Vtr::internal::Level::getFVarOptions(
**(OpenSubdiv::v3_6_0::Vtr::internal::Level ***)(*(_QWORD *)this + 48LL),
v3) & 0xFF00) == 1280;
}
return result;
}
| isFVarChannelLinear:
MOV AL,0x1
TEST byte ptr [RDI + 0xa],0x8
JNZ 0x001704a2
MOV RAX,qword ptr [RDI]
TEST ESI,ESI
JS 0x0017047f
MOV ECX,ESI
MOV RDX,qword ptr [RDI + 0xa8]
MOV ESI,dword ptr [RDX + RCX*0x4]
JMP 0x00170484
LAB_0017047f:
MOV ESI,0xffffffff
LAB_00170484:
PUSH RAX
MOV RAX,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RAX]
CALL 0x00139220
AND EAX,0xff00
CMP EAX,0x500
SETZ AL
ADD RSP,0x8
LAB_001704a2:
RET
|
/* OpenSubdiv::v3_6_0::Far::PatchTableBuilder::isFVarChannelLinear(int) const */
bool __thiscall
OpenSubdiv::v3_6_0::Far::PatchTableBuilder::isFVarChannelLinear(PatchTableBuilder *this,int param_1)
{
uint uVar1;
int iVar2;
bool bVar3;
bVar3 = true;
if (((byte)this[10] & 8) == 0) {
if (param_1 < 0) {
iVar2 = -1;
}
else {
iVar2 = *(int *)(*(long *)(this + 0xa8) + (ulong)(uint)param_1 * 4);
}
uVar1 = Vtr::internal::Level::getFVarOptions
((Level *)**(int8 **)(*(long *)this + 0x30),iVar2);
bVar3 = (uVar1 & 0xff00) == 0x500;
}
return bVar3;
}
| |
32,133 | my_xml_enter | eloqsql/strings/xml.c | static int my_xml_enter(MY_XML_PARSER *st, const char *str, size_t len)
{
if (my_xml_attr_ensure_space(st, len + 1 /* the separator char */))
return MY_XML_ERROR;
if (st->attr.end > st->attr.start)
{
st->attr.end[0]= '/';
st->attr.end++;
}
memcpy(st->attr.end, str, len);
st->attr.end+= len;
st->attr.end[0]= '\0';
if (st->flags & MY_XML_FLAG_RELATIVE_NAMES)
return st->enter ? st->enter(st, str, len) : MY_XML_OK;
else
return st->enter ?
st->enter(st, st->attr.start, st->attr.end - st->attr.start) : MY_XML_OK;
} | O0 | c | my_xml_enter:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0xd7880
cmpl $0x0, %eax
je 0xd73b6
movl $0x1, -0x4(%rbp)
jmp 0xd74cc
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x118(%rcx), %rax
jbe 0xd73f2
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movb $0x2f, (%rax)
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x120(%rax)
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x28290
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x120(%rax), %rcx
movq %rcx, 0x120(%rax)
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xd7477
movq -0x10(%rbp), %rax
cmpq $0x0, 0x148(%rax)
je 0xd7468
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movl %eax, -0x24(%rbp)
jmp 0xd746f
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0xd746f
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd74cc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x148(%rax)
je 0xd74bf
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x118(%rcx), %rsi
movq -0x10(%rbp), %rcx
movq 0x120(%rcx), %rdx
movq -0x10(%rbp), %rcx
movq 0x118(%rcx), %rcx
subq %rcx, %rdx
callq *%rax
movl %eax, -0x28(%rbp)
jmp 0xd74c6
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0xd74c6
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_xml_enter:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
add rsi, 1
call my_xml_attr_ensure_space
cmp eax, 0
jz short loc_D73B6
mov [rbp+var_4], 1
jmp loc_D74CC
loc_D73B6:
mov rax, [rbp+var_10]
mov rax, [rax+120h]
mov rcx, [rbp+var_10]
cmp rax, [rcx+118h]
jbe short loc_D73F2
mov rax, [rbp+var_10]
mov rax, [rax+120h]
mov byte ptr [rax], 2Fh ; '/'
mov rax, [rbp+var_10]
mov rcx, [rax+120h]
add rcx, 1
mov [rax+120h], rcx
loc_D73F2:
mov rax, [rbp+var_10]
mov rdi, [rax+120h]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _memcpy
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
add rcx, [rax+120h]
mov [rax+120h], rcx
mov rax, [rbp+var_10]
mov rax, [rax+120h]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 1
cmp eax, 0
jz short loc_D7477
mov rax, [rbp+var_10]
cmp qword ptr [rax+148h], 0
jz short loc_D7468
mov rax, [rbp+var_10]
mov rax, [rax+148h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call rax
mov [rbp+var_24], eax
jmp short loc_D746F
loc_D7468:
xor eax, eax
mov [rbp+var_24], eax
jmp short $+2
loc_D746F:
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_D74CC
loc_D7477:
mov rax, [rbp+var_10]
cmp qword ptr [rax+148h], 0
jz short loc_D74BF
mov rax, [rbp+var_10]
mov rax, [rax+148h]
mov rdi, [rbp+var_10]
mov rcx, [rbp+var_10]
mov rsi, [rcx+118h]
mov rcx, [rbp+var_10]
mov rdx, [rcx+120h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+118h]
sub rdx, rcx
call rax
mov [rbp+var_28], eax
jmp short loc_D74C6
loc_D74BF:
xor eax, eax
mov [rbp+var_28], eax
jmp short $+2
loc_D74C6:
mov eax, [rbp+var_28]
mov [rbp+var_4], eax
loc_D74CC:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_xml_enter(long long a1, long long a2, long long a3)
{
if ( (unsigned int)my_xml_attr_ensure_space(a1, a3 + 1) )
{
return 1;
}
else
{
if ( *(_QWORD *)(a1 + 288) > *(_QWORD *)(a1 + 280) )
*(_BYTE *)(*(_QWORD *)(a1 + 288))++ = 47;
memcpy(*(_QWORD *)(a1 + 288), a2, a3);
*(_QWORD *)(a1 + 288) += a3;
**(_BYTE **)(a1 + 288) = 0;
if ( (*(_DWORD *)a1 & 1) != 0 )
{
if ( *(_QWORD *)(a1 + 328) )
return (unsigned int)(*(long long ( **)(long long, long long, long long))(a1 + 328))(a1, a2, a3);
else
return 0;
}
else if ( *(_QWORD *)(a1 + 328) )
{
return (unsigned int)(*(long long ( **)(long long, _QWORD, _QWORD))(a1 + 328))(
a1,
*(_QWORD *)(a1 + 280),
*(_QWORD *)(a1 + 288) - *(_QWORD *)(a1 + 280));
}
else
{
return 0;
}
}
}
| my_xml_enter:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x1
CALL 0x001d7880
CMP EAX,0x0
JZ 0x001d73b6
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001d74cc
LAB_001d73b6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x120]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x118]
JBE 0x001d73f2
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x120]
MOV byte ptr [RAX],0x2f
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x120]
ADD RCX,0x1
MOV qword ptr [RAX + 0x120],RCX
LAB_001d73f2:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x120]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00128290
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x120]
MOV qword ptr [RAX + 0x120],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x120]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001d7477
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x148],0x0
JZ 0x001d7468
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x148]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL RAX
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001d746f
LAB_001d7468:
XOR EAX,EAX
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001d746f
LAB_001d746f:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001d74cc
LAB_001d7477:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x148],0x0
JZ 0x001d74bf
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x148]
MOV RDI,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX + 0x118]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX + 0x120]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x118]
SUB RDX,RCX
CALL RAX
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001d74c6
LAB_001d74bf:
XOR EAX,EAX
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001d74c6
LAB_001d74c6:
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x4],EAX
LAB_001d74cc:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_xml_enter(uint *param_1,void *param_2,size_t param_3)
{
int iVar1;
int4 local_30;
int4 local_2c;
int4 local_c;
iVar1 = my_xml_attr_ensure_space(param_1,param_3 + 1);
if (iVar1 == 0) {
if (*(ulong *)(param_1 + 0x46) < *(ulong *)(param_1 + 0x48)) {
**(int1 **)(param_1 + 0x48) = 0x2f;
*(long *)(param_1 + 0x48) = *(long *)(param_1 + 0x48) + 1;
}
memcpy(*(void **)(param_1 + 0x48),param_2,param_3);
*(size_t *)(param_1 + 0x48) = param_3 + *(long *)(param_1 + 0x48);
**(int1 **)(param_1 + 0x48) = 0;
if ((*param_1 & 1) == 0) {
if (*(long *)(param_1 + 0x52) == 0) {
local_30 = 0;
}
else {
local_30 = (**(code **)(param_1 + 0x52))
(param_1,*(int8 *)(param_1 + 0x46),
*(long *)(param_1 + 0x48) - *(long *)(param_1 + 0x46));
}
local_c = local_30;
}
else {
if (*(long *)(param_1 + 0x52) == 0) {
local_2c = 0;
}
else {
local_2c = (**(code **)(param_1 + 0x52))(param_1,param_2,param_3);
}
local_c = local_2c;
}
}
else {
local_c = 1;
}
return local_c;
}
| |
32,134 | minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!expr) throw std::runtime_error("UnaryOpExpr.expr is null");
auto e = expr->evaluate(context);
switch (op) {
case Op::Plus: return e;
case Op::Minus: return -e;
case Op::LogicalNot: return !e.to_bool();
case Op::Expansion:
case Op::ExpansionDict:
throw std::runtime_error("Expansion operator is only supported in function calls and collections");
}
throw std::runtime_error("Unknown unary operator");
} | O0 | cpp | minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
subq $0xc8, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0x20, %rdi
callq 0x115a80
testb $0x1, %al
jne 0x11b934
movl $0x10, %edi
callq 0x5c740
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
leaq 0xfe0b5(%rip), %rsi # 0x2199a7
callq 0x5c4e0
jmp 0x11b8f9
movq 0x28(%rsp), %rdi
movq 0x1916a3(%rip), %rsi # 0x2acfa8
movq 0x191664(%rip), %rdx # 0x2acf70
callq 0x5cbf0
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
callq 0x5d110
jmp 0x11baee
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
callq 0x11bbb0
movq %rax, %rsi
movq 0xb0(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x11bbc0
movq 0x40(%rsp), %rax
movl 0x30(%rax), %eax
movq %rax, 0x20(%rsp)
subq $0x4, %rax
ja 0x11ba70
movq 0x20(%rsp), %rax
leaq 0xfc8c6(%rip), %rcx # 0x218240
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x11bdf0
movl $0x1, 0x4c(%rsp)
jmp 0x11bacd
movq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x11be70
jmp 0x11b9b0
movl $0x1, 0x4c(%rsp)
jmp 0x11bacd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x11bae4
leaq 0x50(%rsp), %rdi
callq 0x11bf10
movb %al, 0x1f(%rsp)
jmp 0x11b9e6
movq 0x30(%rsp), %rdi
movb 0x1f(%rsp), %al
notb %al
andb $0x1, %al
movb %al, 0x4b(%rsp)
leaq 0x4b(%rsp), %rsi
callq 0x11c000
jmp 0x11ba03
movl $0x1, 0x4c(%rsp)
jmp 0x11bacd
movl $0x10, %edi
callq 0x5c740
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0xfdf94(%rip), %rsi # 0x2199c0
callq 0x5c4e0
jmp 0x11ba33
movq 0x10(%rsp), %rdi
movq 0x191569(%rip), %rsi # 0x2acfa8
movq 0x19152a(%rip), %rdx # 0x2acf70
callq 0x5cbf0
jmp 0x11bafb
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
callq 0x5d110
jmp 0x11bae4
movl $0x10, %edi
callq 0x5c740
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0xfdf7b(%rip), %rsi # 0x219a07
callq 0x5c4e0
jmp 0x11ba93
movq 0x8(%rsp), %rdi
movq 0x191509(%rip), %rsi # 0x2acfa8
movq 0x1914ca(%rip), %rdx # 0x2acf70
callq 0x5cbf0
jmp 0x11bafb
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
callq 0x5d110
jmp 0x11bae4
leaq 0x50(%rsp), %rdi
callq 0x11c060
movq 0x38(%rsp), %rax
addq $0xc8, %rsp
retq
leaq 0x50(%rsp), %rdi
callq 0x11c060
movq 0xa8(%rsp), %rdi
callq 0x5ccd0
nopl (%rax,%rax)
| _ZNK5minja11UnaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
sub rsp, 0C8h
mov [rsp+0C8h+var_98], rdi
mov rax, rdi
mov [rsp+0C8h+var_90], rax
mov [rsp+0C8h+var_8], rdi
mov [rsp+0C8h+var_10], rsi
mov [rsp+0C8h+var_18], rdx
mov rdi, [rsp+0C8h+var_10]
mov [rsp+0C8h+var_88], rdi
add rdi, 20h ; ' '
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_11B934
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0C8h+var_A0], rax
lea rsi, aUnaryopexprExp; "UnaryOpExpr.expr is null"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_11B8F9:
mov rdi, [rsp+0C8h+var_A0]; void *
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+0C8h+var_A0]; void *
mov rcx, rax
mov eax, edx
mov [rsp+0C8h+var_20], rcx
mov [rsp+0C8h+var_24], eax
call ___cxa_free_exception
jmp loc_11BAEE
loc_11B934:
mov rdi, [rsp+0C8h+var_88]
add rdi, 20h ; ' '
call _ZNKSt19__shared_ptr_accessIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rsi, rax
mov rdx, [rsp+0C8h+var_18]
lea rdi, [rsp+0C8h+var_78]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov rax, [rsp+0C8h+var_88]
mov eax, [rax+30h]
mov [rsp+0C8h+var_A8], rax
sub rax, 4; switch 5 cases
ja def_11B981; jumptable 000000000011B981 default case
mov rax, [rsp+0C8h+var_A8]
lea rcx, jpt_11B981
movsxd rax, ds:(jpt_11B981 - 218240h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_11B983:
mov rdi, [rsp+0C8h+var_98]; jumptable 000000000011B981 case 0
lea rsi, [rsp+0C8h+var_78]
call _ZN5minja5ValueC2EOS0_; minja::Value::Value(minja::Value&&)
mov [rsp+0C8h+var_7C], 1
jmp loc_11BACD
loc_11B99F:
mov rdi, [rsp+0C8h+var_98]; jumptable 000000000011B981 case 1
lea rsi, [rsp+0C8h+var_78]
call _ZNK5minja5ValuengEv; minja::Value::operator-(void)
jmp short $+2
loc_11B9B0:
mov [rsp+0C8h+var_7C], 1
jmp loc_11BACD
mov rcx, rax
mov eax, edx
mov [rsp+0C8h+var_20], rcx
mov [rsp+0C8h+var_24], eax
jmp loc_11BAE4
loc_11B9D6:
lea rdi, [rsp+0C8h+var_78]; jumptable 000000000011B981 case 2
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
mov [rsp+0C8h+var_A9], al
jmp short $+2
loc_11B9E6:
mov rdi, [rsp+0C8h+var_98]; this
mov al, [rsp+0C8h+var_A9]
not al
and al, 1
mov [rsp+0C8h+var_7D], al
lea rsi, [rsp+0C8h+var_7D]; bool *
call _ZN5minja5ValueC2ERKb; minja::Value::Value(bool const&)
jmp short $+2
loc_11BA03:
mov [rsp+0C8h+var_7C], 1
jmp loc_11BACD
loc_11BA10:
mov edi, 10h; jumptable 000000000011B981 cases 3,4
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0C8h+var_B8], rax
lea rsi, aExpansionOpera; "Expansion operator is only supported in"...
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_11BA33:
mov rdi, [rsp+0C8h+var_B8]; void *
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_11BAFB
mov rdi, [rsp+0C8h+var_B8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+0C8h+var_20], rcx
mov [rsp+0C8h+var_24], eax
call ___cxa_free_exception
jmp short loc_11BAE4
def_11B981:
mov edi, 10h; jumptable 000000000011B981 default case
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0C8h+var_C0], rax
lea rsi, aUnknownUnaryOp; "Unknown unary operator"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_11BA93:
mov rdi, [rsp+0C8h+var_C0]; void *
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp short loc_11BAFB
mov rdi, [rsp+0C8h+var_C0]; void *
mov rcx, rax
mov eax, edx
mov [rsp+0C8h+var_20], rcx
mov [rsp+0C8h+var_24], eax
call ___cxa_free_exception
jmp short loc_11BAE4
loc_11BACD:
lea rdi, [rsp+0C8h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rax, [rsp+0C8h+var_90]
add rsp, 0C8h
retn
loc_11BAE4:
lea rdi, [rsp+0C8h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_11BAEE:
mov rdi, [rsp+0C8h+var_20]
call __Unwind_Resume
loc_11BAFB:
nop dword ptr [rax+rax+00h]
| minja::Value * minja::UnaryOpExpr::do_evaluate(minja::Value *a1, long long a2, long long a3)
{
long long v3; // rax
std::runtime_error *v5; // [rsp+8h] [rbp-C0h]
std::runtime_error *v6; // [rsp+10h] [rbp-B8h]
std::runtime_error *exception; // [rsp+28h] [rbp-A0h]
bool v8; // [rsp+4Bh] [rbp-7Dh] BYREF
int v9; // [rsp+4Ch] [rbp-7Ch]
_BYTE v10[84]; // [rsp+50h] [rbp-78h] BYREF
long long v11; // [rsp+B0h] [rbp-18h]
long long v12; // [rsp+B8h] [rbp-10h]
minja::Value *v13; // [rsp+C0h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool((_QWORD *)(a2 + 32)) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "UnaryOpExpr.expr is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(a2 + 32);
minja::Expression::evaluate(v10, v3, v11);
switch ( *(_DWORD *)(a2 + 48) )
{
case 0:
minja::Value::Value(a1, v10);
v9 = 1;
break;
case 1:
minja::Value::operator-(a1, v10);
v9 = 1;
break;
case 2:
v8 = (minja::Value::to_bool((minja::Value *)v10) & 1) == 0;
minja::Value::Value(a1, &v8);
v9 = 1;
break;
case 3:
case 4:
v6 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v6, "Expansion operator is only supported in function calls and collections");
__cxa_throw(
v6,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
default:
v5 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v5, "Unknown unary operator");
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Value::~Value((minja::Value *)v10);
return a1;
}
| |||
32,135 | minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!expr) throw std::runtime_error("UnaryOpExpr.expr is null");
auto e = expr->evaluate(context);
switch (op) {
case Op::Plus: return e;
case Op::Minus: return -e;
case Op::LogicalNot: return !e.to_bool();
case Op::Expansion:
case Op::ExpansionDict:
throw std::runtime_error("Expansion operator is only supported in function calls and collections");
}
throw std::runtime_error("Unknown unary operator");
} | O1 | cpp | minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x89e02
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x89f5e
movl 0x30(%r14), %eax
cmpq $0x4, %rax
ja 0x89e52
leaq 0x6a031(%rip), %rcx # 0xf3ce8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %r12d, %r12d
movq %r12, 0x18(%rbx)
leaq 0x48(%rsp), %r15
movups -0x30(%r15), %xmm0
movq %r12, -0x28(%r15)
movups %xmm0, 0x10(%rbx)
movq %r12, -0x30(%r15)
movq %r12, 0x28(%rbx)
movups -0x20(%r15), %xmm0
movq %r12, -0x18(%r15)
movups %xmm0, 0x20(%rbx)
movq %r12, -0x20(%r15)
movq %r12, 0x38(%rbx)
movups -0x10(%r15), %xmm0
movq %r12, -0x8(%r15)
movups %xmm0, 0x30(%rbx)
movq %r12, -0x10(%r15)
leaq 0x40(%rbx), %r14
movups (%r15), %xmm0
movups %xmm0, 0x40(%rbx)
movq %r15, %rdi
xorl %esi, %esi
callq 0x5bbb4
movb $0x0, (%r15)
movq %r12, 0x8(%r15)
jmp 0x89d5e
leaq 0x8(%rsp), %rdi
callq 0x8a160
xorb $0x1, %al
leaq 0x40(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movzbl %al, %esi
movq %r14, %rdi
callq 0x63402
movq %r14, %rdi
movl $0x1, %esi
callq 0x5bbb4
jmp 0x89d7a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8a0dc
leaq 0x48(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5bbb4
movq %r14, %rdi
callq 0x6132e
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x89d9f
callq 0x70c16
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x89dae
callq 0x70c16
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x89dbd
callq 0x70c16
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x89df3
movq 0xa81aa(%rip), %rax # 0x131f78
cmpb $0x0, (%rax)
je 0x89dde
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x89de8
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x89df3
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x1b4d0
movq %rax, %r14
leaq 0x6b1a3(%rip), %rsi # 0xf4fb9
movq %rax, %rdi
callq 0x1b370
movq 0xa81c3(%rip), %rsi # 0x131fe8
movq 0xa8124(%rip), %rdx # 0x131f50
movq %r14, %rdi
callq 0x1c1c0
movl $0x10, %edi
callq 0x1b4d0
movq %rax, %r14
leaq 0x6b18a(%rip), %rsi # 0xf4fd2
movq %rax, %rdi
callq 0x1b370
jmp 0x89e6e
movl $0x10, %edi
callq 0x1b4d0
movq %rax, %r14
leaq 0x6b1b3(%rip), %rsi # 0xf5019
movq %rax, %rdi
callq 0x1b370
movq 0xa8173(%rip), %rsi # 0x131fe8
movq 0xa80d4(%rip), %rdx # 0x131f50
movq %r14, %rdi
callq 0x1c1c0
jmp 0x89e88
jmp 0x89ea2
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b760
jmp 0x89ea5
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b760
jmp 0x89eaf
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8a254
movq %rbx, %rdi
callq 0x1c250
nop
| _ZNK5minja11UnaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push r15
push r14
push r12
push rbx
sub rsp, 58h
mov r14, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz loc_89E02
mov rbx, rdi
lea rdi, [rsp+78h+var_70]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov eax, [r14+30h]
cmp rax, 4; switch 5 cases
ja def_89CBE; jumptable 0000000000089CBE default case
lea rcx, jpt_89CBE
movsxd rax, ds:(jpt_89CBE - 0F3CE8h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_89CC0:
xorps xmm0, xmm0; jumptable 0000000000089CBE case 0
movups xmmword ptr [rbx], xmm0
xor r12d, r12d
mov [rbx+18h], r12
lea r15, [rsp+78h+var_30]
movups xmm0, xmmword ptr [r15-30h]
mov [r15-28h], r12
movups xmmword ptr [rbx+10h], xmm0
mov [r15-30h], r12
mov [rbx+28h], r12
movups xmm0, xmmword ptr [r15-20h]
mov [r15-18h], r12
movups xmmword ptr [rbx+20h], xmm0
mov [r15-20h], r12
mov [rbx+38h], r12
movups xmm0, xmmword ptr [r15-10h]
mov [r15-8], r12
movups xmmword ptr [rbx+30h], xmm0
mov [r15-10h], r12
lea r14, [rbx+40h]
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rbx+40h], xmm0
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r15], 0
mov [r15+8], r12
jmp short loc_89D5E
loc_89D2D:
lea rdi, [rsp+78h+var_70]; jumptable 0000000000089CBE case 2
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
xor al, 1
lea r14, [rbx+40h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+40h], xmm0
movups xmmword ptr [rbx+30h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
movzx esi, al
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE4EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_9boolean_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::boolean_t)
loc_89D5E:
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_89D7A
loc_89D6D:
lea rsi, [rsp+78h+var_70]; jumptable 0000000000089CBE case 1
mov rdi, rbx
call _ZNK5minja5ValuengEv; minja::Value::operator-(void)
loc_89D7A:
lea r14, [rsp+78h+var_30]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_89D9F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_89D9F:
mov rdi, [rsp+78h+var_48]
test rdi, rdi
jz short loc_89DAE
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_89DAE:
mov rdi, [rsp+78h+var_58]
test rdi, rdi
jz short loc_89DBD
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_89DBD:
mov rdi, [rsp+78h+var_68]
test rdi, rdi
jz short loc_89DF3
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_89DDE
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_89DE8
loc_89DDE:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_89DE8:
cmp eax, 1
jnz short loc_89DF3
mov rax, [rdi]
call qword ptr [rax+18h]
loc_89DF3:
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r14
pop r15
retn
loc_89E02:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnaryopexprExp; "UnaryOpExpr.expr is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_89E34:
mov edi, 10h; jumptable 0000000000089CBE cases 3,4
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpansionOpera; "Expansion operator is only supported in"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_89E6E
def_89CBE:
mov edi, 10h; jumptable 0000000000089CBE default case
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnknownUnaryOp; "Unknown unary operator"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_89E6E:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_89E88
jmp short loc_89EA2
loc_89E88:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_89EA5
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_89EAF
loc_89EA2:
mov rbx, rax
loc_89EA5:
lea rdi, [rsp+78h+var_70]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_89EAF:
mov rdi, rbx
call __Unwind_Resume
| do_evaluate:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x00189e02
MOV RBX,RDI
LEA RDI,[RSP + 0x8]
CALL 0x00189f5e
MOV EAX,dword ptr [R14 + 0x30]
CMP RAX,0x4
JA 0x00189e52
LEA RCX,[0x1f3ce8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
XOR R12D,R12D
MOV qword ptr [RBX + 0x18],R12
LEA R15,[RSP + 0x48]
MOVUPS XMM0,xmmword ptr [R15 + -0x30]
MOV qword ptr [R15 + -0x28],R12
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOV qword ptr [R15 + -0x30],R12
MOV qword ptr [RBX + 0x28],R12
MOVUPS XMM0,xmmword ptr [R15 + -0x20]
MOV qword ptr [R15 + -0x18],R12
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOV qword ptr [R15 + -0x20],R12
MOV qword ptr [RBX + 0x38],R12
MOVUPS XMM0,xmmword ptr [R15 + -0x10]
MOV qword ptr [R15 + -0x8],R12
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV qword ptr [R15 + -0x10],R12
LEA R14,[RBX + 0x40]
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOV RDI,R15
XOR ESI,ESI
CALL 0x0015bbb4
MOV byte ptr [R15],0x0
MOV qword ptr [R15 + 0x8],R12
JMP 0x00189d5e
caseD_2:
LEA RDI,[RSP + 0x8]
CALL 0x0018a160
XOR AL,0x1
LEA R14,[RBX + 0x40]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVZX ESI,AL
MOV RDI,R14
CALL 0x00163402
LAB_00189d5e:
MOV RDI,R14
MOV ESI,0x1
CALL 0x0015bbb4
JMP 0x00189d7a
caseD_1:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0018a0dc
LAB_00189d7a:
LEA R14,[RSP + 0x48]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0015bbb4
MOV RDI,R14
CALL 0x0016132e
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x00189d9f
CALL 0x00170c16
LAB_00189d9f:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x00189dae
CALL 0x00170c16
LAB_00189dae:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x00189dbd
CALL 0x00170c16
LAB_00189dbd:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x00189df3
MOV RAX,qword ptr [0x00231f78]
CMP byte ptr [RAX],0x0
JZ 0x00189dde
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00189de8
LAB_00189dde:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00189de8:
CMP EAX,0x1
JNZ 0x00189df3
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00189df3:
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00189e02:
MOV EDI,0x10
CALL 0x0011b4d0
MOV R14,RAX
LAB_00189e0f:
LEA RSI,[0x1f4fb9]
MOV RDI,RAX
CALL 0x0011b370
LAB_00189e1e:
MOV RSI,qword ptr [0x00231fe8]
MOV RDX,qword ptr [0x00231f50]
MOV RDI,R14
CALL 0x0011c1c0
caseD_3:
MOV EDI,0x10
CALL 0x0011b4d0
MOV R14,RAX
LAB_00189e41:
LEA RSI,[0x1f4fd2]
MOV RDI,RAX
CALL 0x0011b370
LAB_00189e50:
JMP 0x00189e6e
default:
MOV EDI,0x10
CALL 0x0011b4d0
MOV R14,RAX
LAB_00189e5f:
LEA RSI,[0x1f5019]
MOV RDI,RAX
CALL 0x0011b370
LAB_00189e6e:
MOV RSI,qword ptr [0x00231fe8]
MOV RDX,qword ptr [0x00231f50]
MOV RDI,R14
CALL 0x0011c1c0
|
/* minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
UnaryOpExpr * __thiscall minja::UnaryOpExpr::do_evaluate(UnaryOpExpr *this,shared_ptr *param_1)
{
int *piVar1;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var2;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var3;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var4;
byte bVar5;
int iVar6;
runtime_error *prVar7;
Expression local_70 [8];
long *local_68;
int8 local_60;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_58;
int8 local_50;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_48;
int8 local_40;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_38;
data local_30;
int7 uStack_2f;
int8 uStack_28;
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00189e0f to 00189e1d has its CatchHandler @ 00189e95 */
std::runtime_error::runtime_error(prVar7,"UnaryOpExpr.expr is null");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar7,PTR_typeinfo_00231fe8,PTR__runtime_error_00231f50);
}
Expression::evaluate(local_70,*(shared_ptr **)(param_1 + 0x20));
p_Var4 = p_Stack_38;
p_Var3 = p_Stack_48;
p_Var2 = p_Stack_58;
switch(*(int4 *)(param_1 + 0x30)) {
case 0:
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x18) = 0;
p_Stack_58 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
*(int8 *)(this + 0x10) = local_60;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) = p_Var2;
local_60 = 0;
*(int8 *)(this + 0x28) = 0;
p_Stack_48 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
*(int8 *)(this + 0x20) = local_50;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28) = p_Var3;
local_50 = 0;
*(int8 *)(this + 0x38) = 0;
p_Stack_38 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
*(int8 *)(this + 0x30) = local_40;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) = p_Var4;
local_40 = 0;
*(ulong *)(this + 0x40) = CONCAT71(uStack_2f,local_30);
*(int8 *)(this + 0x48) = uStack_28;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_30,0));
local_30 = (data)0x0;
uStack_28 = 0;
break;
case 1:
/* try { // try from 00189d6d to 00189d79 has its CatchHandler @ 00189ea2 */
Value::operator-((Value *)this);
goto LAB_00189d7a;
case 2:
/* try { // try from 00189d2d to 00189d36 has its CatchHandler @ 00189e86 */
bVar5 = Value::to_bool((Value *)local_70);
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(this + 0x40,bVar5 ^ 1);
break;
case 3:
case 4:
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00189e41 to 00189e4f has its CatchHandler @ 00189e88 */
std::runtime_error::runtime_error
(prVar7,"Expansion operator is only supported in function calls and collections");
goto LAB_00189e6e;
default:
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00189e5f to 00189e6d has its CatchHandler @ 00189e84 */
std::runtime_error::runtime_error(prVar7,"Unknown unary operator");
LAB_00189e6e:
/* try { // try from 00189e6e to 00189e83 has its CatchHandler @ 00189ea2 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar7,PTR_typeinfo_00231fe8,PTR__runtime_error_00231f50);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant((bool)((char)this + '@'));
LAB_00189d7a:
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_30,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(&local_30);
if (p_Stack_38 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_38);
}
if (p_Stack_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_48);
}
if (p_Stack_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_58);
}
if (local_68 != (long *)0x0) {
if (*PTR___libc_single_threaded_00231f78 == '\0') {
LOCK();
piVar1 = (int *)((long)local_68 + 0xc);
iVar6 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar6 = *(int *)((long)local_68 + 0xc);
*(int *)((long)local_68 + 0xc) = iVar6 + -1;
}
if (iVar6 == 1) {
(**(code **)(*local_68 + 0x18))();
}
}
return this;
}
| ||
32,136 | string_split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | llama.cpp/common/common.cpp | std::vector<std::string> string_split(const std::string & str, const std::string & delimiter) {
std::vector<std::string> parts;
size_t start = 0;
size_t end = str.find(delimiter);
while (end != std::string::npos) {
parts.push_back(str.substr(start, end - start));
start = end + delimiter.length();
end = str.find(delimiter, start);
}
parts.push_back(str.substr(start));
return parts;
} | O3 | cpp | string_split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
xorl %ebp, %ebp
movq %r14, %rdi
xorl %edx, %edx
callq 0x215d0
cmpq $-0x1, %rax
je 0xffc18
movq %rax, %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq %r12, %rcx
subq %rbp, %rcx
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x22130
movq %rbx, %rdi
movq %r13, %rsi
callq 0x842a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xffbf7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r12, %rbp
addq %rcx, %rbp
movq %r14, %rdi
movq %rbp, %rdx
callq 0x215d0
movq %rax, %r12
cmpq $-0x1, %rax
jne 0xffbbc
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq $-0x1, %rcx
callq 0x22130
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x842a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xffc57
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0xffc8b
jmp 0xffc79
movq %rax, %r14
jmp 0xffc9d
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xffc9d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
movq %rbx, %rdi
callq 0x2c368
movq %r14, %rdi
callq 0x21b20
| _Z12string_splitRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rsi, [rdx]
mov rcx, [rdx+8]
xor ebp, ebp
mov rdi, r14
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_FFC18
mov r12, rax
xor ebp, ebp
lea r13, [rsp+58h+var_50]
loc_FFBBC:
mov rcx, r12
sub rcx, rbp
mov rdi, r13
mov rsi, r14
mov rdx, rbp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, rbx
mov rsi, r13
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+58h+var_50]; void *
lea rax, [rsp+58h+var_40]
cmp rdi, rax
jz short loc_FFBF7
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_FFBF7:
mov rsi, [r15]
mov rcx, [r15+8]
mov rbp, r12
add rbp, rcx
mov rdi, r14
mov rdx, rbp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
mov r12, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_FFBBC
loc_FFC18:
lea rdi, [rsp+58h+var_50]
mov rsi, r14
mov rdx, rbp
mov rcx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rsi, [rsp+58h+var_50]
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_FFC57
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_FFC57:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]
jmp short loc_FFC8B
jmp short $+2
loc_FFC79:
mov r14, rax
jmp short loc_FFC9D
mov r14, rax
mov rdi, [rsp+arg_0]; void *
lea rax, [rsp+arg_10]
loc_FFC8B:
cmp rdi, rax
jz short loc_FFC9D
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_FFC9D:
mov rdi, rbx; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __Unwind_Resume
| long long string_split(long long a1, long long a2, _QWORD *a3)
{
long long v4; // rbp
long long v5; // rax
long long v6; // r12
long long v7; // rcx
void *v9[2]; // [rsp+8h] [rbp-50h] BYREF
_QWORD v10[8]; // [rsp+18h] [rbp-40h] BYREF
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v4 = 0LL;
v5 = std::string::find(a2, *a3, 0LL, a3[1]);
if ( v5 != -1 )
{
v6 = v5;
v4 = 0LL;
do
{
std::string::substr(v9, a2, v4, v6 - v4);
std::vector<std::string>::emplace_back<std::string>(a1, v9);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
v7 = a3[1];
v4 = v7 + v6;
v6 = std::string::find(a2, *a3, v7 + v6, v7);
}
while ( v6 != -1 );
}
std::string::substr(v9, a2, v4, -1LL);
std::vector<std::string>::emplace_back<std::string>(a1, v9);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
return a1;
}
| string_split:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RSI,qword ptr [RDX]
MOV RCX,qword ptr [RDX + 0x8]
XOR EBP,EBP
MOV RDI,R14
XOR EDX,EDX
CALL 0x001215d0
CMP RAX,-0x1
JZ 0x001ffc18
MOV R12,RAX
XOR EBP,EBP
LEA R13,[RSP + 0x8]
LAB_001ffbbc:
MOV RCX,R12
SUB RCX,RBP
LAB_001ffbc2:
MOV RDI,R13
MOV RSI,R14
MOV RDX,RBP
CALL 0x00122130
LAB_001ffbd0:
MOV RDI,RBX
MOV RSI,R13
CALL 0x001842a0
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x001ffbf7
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00121180
LAB_001ffbf7:
MOV RSI,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV RBP,R12
ADD RBP,RCX
MOV RDI,R14
MOV RDX,RBP
CALL 0x001215d0
MOV R12,RAX
CMP RAX,-0x1
JNZ 0x001ffbbc
LAB_001ffc18:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV RDX,RBP
MOV RCX,-0x1
CALL 0x00122130
LAB_001ffc2f:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x001842a0
LAB_001ffc3c:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001ffc57
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00121180
LAB_001ffc57:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_split(std::__cxx11::string const&, std::__cxx11::string const&) */
string * string_split(string *param_1,string *param_2)
{
long lVar1;
ulong *in_RDX;
long *local_50 [2];
long local_40 [2];
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
lVar1 = std::__cxx11::string::find((char *)param_2,*in_RDX,0);
if (lVar1 != -1) {
do {
/* try { // try from 001ffbc2 to 001ffbcf has its CatchHandler @ 001ffc79 */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_2);
/* try { // try from 001ffbd0 to 001ffbda has its CatchHandler @ 001ffc7e */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
lVar1 = std::__cxx11::string::find((char *)param_2,*in_RDX,lVar1 + in_RDX[1]);
} while (lVar1 != -1);
}
/* try { // try from 001ffc18 to 001ffc2e has its CatchHandler @ 001ffc77 */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_2);
/* try { // try from 001ffc2f to 001ffc3b has its CatchHandler @ 001ffc69 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return param_1;
}
| |
32,137 | qdevtools::StyleSheetEdit::dropEvent(QDropEvent*) | HuaiminNotSleepYet[P]QDevTools/qdevtools.cpp | void dropEvent(QDropEvent* event) override
{
const auto urls = event->mimeData()->urls();
const auto file = urls.first().toLocalFile();
if (auto files = watcher_->files(); !files.empty())
watcher_->removePaths(files);
watcher_->addPath(file);
setQss(qss());
setState(Link);
} | O0 | cpp | qdevtools::StyleSheetEdit::dropEvent(QDropEvent*):
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37a50
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xfd00
movq -0xa0(%rbp), %rdi
callq 0x37a70
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0xf720
jmp 0x35fd4
movq -0xa8(%rbp), %rax
movq 0x28(%rax), %rsi
leaq -0x68(%rbp), %rdi
callq 0xfb70
jmp 0x35fea
leaq -0x68(%rbp), %rdi
callq 0x36a00
testb $0x1, %al
jne 0x36058
movq -0xa8(%rbp), %rax
movq 0x28(%rax), %rsi
leaq -0x80(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0xfdd0
jmp 0x36011
leaq -0x80(%rbp), %rdi
callq 0x1d730
jmp 0x36058
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x360fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x360f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1d730
jmp 0x360f3
leaq -0x68(%rbp), %rdi
callq 0x1d730
movq -0xa8(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0xfc80
jmp 0x36077
movq -0xa8(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x36780
jmp 0x3608c
movq -0xa8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x366f0
jmp 0x360a1
leaq -0x98(%rbp), %rdi
callq 0x1b1e0
movq -0xa8(%rbp), %rdi
movl $0x2, %esi
callq 0x35840
jmp 0x360c0
leaq -0x40(%rbp), %rdi
callq 0x1b1e0
leaq -0x28(%rbp), %rdi
callq 0x37ae0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1b1e0
leaq -0x40(%rbp), %rdi
callq 0x1b1e0
leaq -0x28(%rbp), %rdi
callq 0x37ae0
movq -0x48(%rbp), %rdi
callq 0xf410
nop
| _ZN9qdevtools14StyleSheetEdit9dropEventEP10QDropEvent:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_A8], rax
mov rdi, [rbp+var_10]; this
call _ZNK10QDropEvent8mimeDataEv; QDropEvent::mimeData(void)
mov rsi, rax
lea rdi, [rbp+var_28]; this
mov [rbp+var_A0], rdi
call __ZNK9QMimeData4urlsEv; QMimeData::urls(void)
mov rdi, [rbp+var_A0]
call _ZNK5QListI4QUrlE5firstEv; QList<QUrl>::first(void)
mov rsi, rax
lea rdi, [rbp+var_40]; this
call __ZNK4QUrl11toLocalFileEv; QUrl::toLocalFile(void)
jmp short $+2
loc_35FD4:
mov rax, [rbp+var_A8]
mov rsi, [rax+28h]
lea rdi, [rbp+var_68]; this
call __ZNK18QFileSystemWatcher5filesEv; QFileSystemWatcher::files(void)
jmp short $+2
loc_35FEA:
lea rdi, [rbp+var_68]
call _ZNK5QListI7QStringE5emptyEv; QList<QString>::empty(void)
test al, 1
jnz short loc_36058
mov rax, [rbp+var_A8]
mov rsi, [rax+28h]
lea rdi, [rbp+var_80]
lea rdx, [rbp+var_68]
call __ZN18QFileSystemWatcher11removePathsERK5QListI7QStringE; QFileSystemWatcher::removePaths(QList<QString> const&)
jmp short $+2
loc_36011:
lea rdi, [rbp+var_80]
call _ZN5QListI7QStringED2Ev; QList<QString>::~QList()
jmp short loc_36058
mov rcx, rax
mov eax, edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], eax
jmp loc_360FC
mov rcx, rax
mov eax, edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], eax
jmp loc_360F3
mov rcx, rax
mov eax, edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], eax
lea rdi, [rbp+var_68]
call _ZN5QListI7QStringED2Ev; QList<QString>::~QList()
jmp loc_360F3
loc_36058:
lea rdi, [rbp+var_68]
call _ZN5QListI7QStringED2Ev; QList<QString>::~QList()
mov rax, [rbp+var_A8]
mov rdi, [rax+28h]; this
lea rsi, [rbp+var_40]; QString *
call __ZN18QFileSystemWatcher7addPathERK7QString; QFileSystemWatcher::addPath(QString const&)
jmp short $+2
loc_36077:
mov rsi, [rbp+var_A8]
lea rdi, [rbp+var_98]; this
call _ZNK9qdevtools14StyleSheetEdit3qssEv; qdevtools::StyleSheetEdit::qss(void)
jmp short $+2
loc_3608C:
mov rdi, [rbp+var_A8]; this
lea rsi, [rbp+var_98]; QString *
call _ZN9qdevtools14StyleSheetEdit6setQssERK7QString; qdevtools::StyleSheetEdit::setQss(QString const&)
jmp short $+2
loc_360A1:
lea rdi, [rbp+var_98]; this
call _ZN7QStringD2Ev; QString::~QString()
mov rdi, [rbp+var_A8]
mov esi, 2
call _ZN9qdevtools14StyleSheetEdit8setStateENS0_5StateE; qdevtools::StyleSheetEdit::setState(qdevtools::StyleSheetEdit::State)
jmp short $+2
loc_360C0:
lea rdi, [rbp+var_40]; this
call _ZN7QStringD2Ev; QString::~QString()
lea rdi, [rbp+var_28]
call _ZN5QListI4QUrlED2Ev; QList<QUrl>::~QList()
add rsp, 0B0h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], eax
lea rdi, [rbp+var_98]; this
call _ZN7QStringD2Ev; QString::~QString()
loc_360F3:
lea rdi, [rbp+var_40]; this
call _ZN7QStringD2Ev; QString::~QString()
loc_360FC:
lea rdi, [rbp+var_28]
call _ZN5QListI4QUrlED2Ev; QList<QUrl>::~QList()
mov rdi, [rbp+var_48]
call __Unwind_Resume
| long long qdevtools::StyleSheetEdit::dropEvent(QFileSystemWatcher **this, QDropEvent *a2)
{
long long v2; // rsi
QFileSystemWatcher *v3; // rsi
_BYTE v5[24]; // [rsp+18h] [rbp-98h] BYREF
_BYTE v6[24]; // [rsp+30h] [rbp-80h] BYREF
_BYTE v7[28]; // [rsp+48h] [rbp-68h] BYREF
_BYTE v8[24]; // [rsp+70h] [rbp-40h] BYREF
_BYTE v9[24]; // [rsp+88h] [rbp-28h] BYREF
QDropEvent *v10; // [rsp+A0h] [rbp-10h]
qdevtools::StyleSheetEdit *v11; // [rsp+A8h] [rbp-8h]
v11 = (qdevtools::StyleSheetEdit *)this;
v10 = a2;
v2 = QDropEvent::mimeData(a2);
QMimeData::urls((QMimeData *)v9);
QList<QUrl>::first(v9, v2);
QUrl::toLocalFile((QUrl *)v8);
v3 = this[5];
QFileSystemWatcher::files((QFileSystemWatcher *)v7);
if ( (QList<QString>::empty(v7, v3) & 1) == 0 )
{
QFileSystemWatcher::removePaths(v6, this[5], v7);
QList<QString>::~QList((long long)v6);
}
QList<QString>::~QList((long long)v7);
QFileSystemWatcher::addPath(this[5], (const QString *)v8);
qdevtools::StyleSheetEdit::qss((qdevtools::StyleSheetEdit *)v5);
qdevtools::StyleSheetEdit::setQss((qdevtools::StyleSheetEdit *)this, (const QString *)v5);
QString::~QString((QString *)v5);
qdevtools::StyleSheetEdit::setState((QWidget *)this, 2);
QString::~QString((QString *)v8);
return QList<QUrl>::~QList(v9);
}
| dropEvent:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0xa8],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00137a50
MOV RSI,RAX
LEA RDI,[RBP + -0x28]
MOV qword ptr [RBP + -0xa0],RDI
CALL 0x0010fd00
MOV RDI,qword ptr [RBP + -0xa0]
CALL 0x00137a70
MOV RSI,RAX
LAB_00135fc9:
LEA RDI,[RBP + -0x40]
CALL 0x0010f720
JMP 0x00135fd4
LAB_00135fd4:
MOV RAX,qword ptr [RBP + -0xa8]
MOV RSI,qword ptr [RAX + 0x28]
LAB_00135fdf:
LEA RDI,[RBP + -0x68]
CALL 0x0010fb70
JMP 0x00135fea
LAB_00135fea:
LEA RDI,[RBP + -0x68]
CALL 0x00136a00
TEST AL,0x1
JNZ 0x00136058
MOV RAX,qword ptr [RBP + -0xa8]
MOV RSI,qword ptr [RAX + 0x28]
LAB_00136002:
LEA RDI,[RBP + -0x80]
LEA RDX,[RBP + -0x68]
CALL 0x0010fdd0
JMP 0x00136011
LAB_00136011:
LEA RDI,[RBP + -0x80]
CALL 0x0011d730
JMP 0x00136058
LAB_00136058:
LEA RDI,[RBP + -0x68]
CALL 0x0011d730
MOV RAX,qword ptr [RBP + -0xa8]
MOV RDI,qword ptr [RAX + 0x28]
LAB_0013606c:
LEA RSI,[RBP + -0x40]
CALL 0x0010fc80
JMP 0x00136077
LAB_00136077:
MOV RSI,qword ptr [RBP + -0xa8]
LEA RDI,[RBP + -0x98]
CALL 0x00136780
JMP 0x0013608c
LAB_0013608c:
MOV RDI,qword ptr [RBP + -0xa8]
LEA RSI,[RBP + -0x98]
CALL 0x001366f0
JMP 0x001360a1
LAB_001360a1:
LEA RDI,[RBP + -0x98]
CALL 0x0011b1e0
MOV RDI,qword ptr [RBP + -0xa8]
LAB_001360b4:
MOV ESI,0x2
CALL 0x00135840
LAB_001360be:
JMP 0x001360c0
LAB_001360c0:
LEA RDI,[RBP + -0x40]
CALL 0x0011b1e0
LEA RDI,[RBP + -0x28]
CALL 0x00137ae0
ADD RSP,0xb0
POP RBP
RET
|
/* qdevtools::StyleSheetEdit::dropEvent(QDropEvent*) */
void __thiscall qdevtools::StyleSheetEdit::dropEvent(StyleSheetEdit *this,QDropEvent *param_1)
{
ulong uVar1;
QString local_a0 [24];
QList local_88 [24];
QList<QString> local_70 [40];
QString local_48 [24];
QList<QUrl> local_30 [24];
QDropEvent *local_18;
StyleSheetEdit *local_10;
local_18 = param_1;
local_10 = this;
QDropEvent::mimeData(param_1);
QMimeData::urls();
QList<QUrl>::first(local_30);
/* try { // try from 00135fc9 to 00135fd1 has its CatchHandler @ 0013601c */
QUrl::toLocalFile();
/* try { // try from 00135fdf to 00135fe7 has its CatchHandler @ 0013602d */
QFileSystemWatcher::files();
uVar1 = QList<QString>::empty(local_70);
if ((uVar1 & 1) == 0) {
/* try { // try from 00136002 to 0013600e has its CatchHandler @ 0013603e */
QFileSystemWatcher::removePaths(local_88);
QList<QString>::~QList((QList<QString> *)local_88);
}
QList<QString>::~QList(local_70);
/* try { // try from 0013606c to 00136089 has its CatchHandler @ 0013602d */
QFileSystemWatcher::addPath(*(QString **)(this + 0x28));
qss();
/* try { // try from 0013608c to 0013609e has its CatchHandler @ 001360db */
setQss(this,local_a0);
QString::~QString(local_a0);
/* try { // try from 001360b4 to 001360bd has its CatchHandler @ 0013602d */
setState(this,2);
QString::~QString(local_48);
QList<QUrl>::~QList(local_30);
return;
}
| |
32,138 | qdevtools::StyleSheetEdit::dropEvent(QDropEvent*) | HuaiminNotSleepYet[P]QDevTools/qdevtools.cpp | void dropEvent(QDropEvent* event) override
{
const auto urls = event->mimeData()->urls();
const auto file = urls.first().toLocalFile();
if (auto files = watcher_->files(); !files.empty())
watcher_->removePaths(files);
watcher_->addPath(file);
setQss(qss());
setState(Link);
} | O2 | cpp | qdevtools::StyleSheetEdit::dropEvent(QDropEvent*):
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x38(%rsi), %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0xfd30
movq 0x8(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0xf730
movq 0x28(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0xfb80
cmpq $0x0, 0x18(%rsp)
je 0x1e542
movq 0x28(%rbx), %rsi
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xfe00
leaq 0x50(%rsp), %rdi
callq 0x1a896
leaq 0x8(%rsp), %rdi
callq 0x1a896
movq 0x28(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0xfc90
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1e7d6
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1e75a
leaq 0x8(%rsp), %rdi
callq 0x14530
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x1df94
leaq 0x20(%rsp), %rdi
callq 0x14530
leaq 0x38(%rsp), %rdi
callq 0x1ee44
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a896
jmp 0x1e5cf
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x14530
jmp 0x1e5cf
jmp 0x1e5cc
jmp 0x1e5cc
movq %rax, %rbx
jmp 0x1e5d9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x14530
leaq 0x38(%rsp), %rdi
callq 0x1ee44
movq %rbx, %rdi
callq 0xf410
nop
| _ZN9qdevtools14StyleSheetEdit9dropEventEP10QDropEvent:
push r14
push rbx
sub rsp, 68h
mov rbx, rdi
mov rsi, [rsi+38h]
lea r14, [rsp+78h+var_40]
mov rdi, r14; this
call __ZNK9QMimeData4urlsEv; QMimeData::urls(void)
mov rsi, [r14+8]
lea rdi, [rsp+78h+var_58]; this
call __ZNK4QUrl11toLocalFileEv; QUrl::toLocalFile(void)
mov rsi, [rbx+28h]
lea rdi, [rsp+78h+var_70]; this
call __ZNK18QFileSystemWatcher5filesEv; QFileSystemWatcher::files(void)
cmp [rsp+78h+var_60], 0
jz short loc_1E542
mov rsi, [rbx+28h]
lea rdi, [rsp+78h+var_28]
lea rdx, [rsp+78h+var_70]
call __ZN18QFileSystemWatcher11removePathsERK5QListI7QStringE; QFileSystemWatcher::removePaths(QList<QString> const&)
lea rdi, [rsp+78h+var_28]
call _ZN17QArrayDataPointerI7QStringED2Ev; QArrayDataPointer<QString>::~QArrayDataPointer()
loc_1E542:
lea rdi, [rsp+78h+var_70]
call _ZN17QArrayDataPointerI7QStringED2Ev; QArrayDataPointer<QString>::~QArrayDataPointer()
mov rdi, [rbx+28h]; this
lea rsi, [rsp+78h+var_58]; QString *
call __ZN18QFileSystemWatcher7addPathERK7QString; QFileSystemWatcher::addPath(QString const&)
lea rdi, [rsp+78h+var_70]; this
mov rsi, rbx
call _ZNK9qdevtools14StyleSheetEdit3qssEv; qdevtools::StyleSheetEdit::qss(void)
lea rsi, [rsp+78h+var_70]; QString *
mov rdi, rbx; this
call _ZN9qdevtools14StyleSheetEdit6setQssERK7QString; qdevtools::StyleSheetEdit::setQss(QString const&)
lea rdi, [rsp+78h+var_70]
call _ZN17QArrayDataPointerIDsED2Ev; QArrayDataPointer<char16_t>::~QArrayDataPointer()
push 2
pop rsi
mov rdi, rbx; this
call _ZN9qdevtools14StyleSheetEdit8setStateENS0_5StateE; qdevtools::StyleSheetEdit::setState(qdevtools::StyleSheetEdit::State)
lea rdi, [rsp+78h+var_58]
call _ZN17QArrayDataPointerIDsED2Ev; QArrayDataPointer<char16_t>::~QArrayDataPointer()
lea rdi, [rsp+78h+var_40]
call _ZN17QArrayDataPointerI4QUrlED2Ev; QArrayDataPointer<QUrl>::~QArrayDataPointer()
add rsp, 68h
pop rbx
pop r14
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZN17QArrayDataPointerI7QStringED2Ev; QArrayDataPointer<QString>::~QArrayDataPointer()
jmp short loc_1E5CF
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZN17QArrayDataPointerIDsED2Ev; QArrayDataPointer<char16_t>::~QArrayDataPointer()
jmp short loc_1E5CF
jmp short loc_1E5CC
jmp short loc_1E5CC
mov rbx, rax
jmp short loc_1E5D9
loc_1E5CC:
mov rbx, rax
loc_1E5CF:
lea rdi, [rsp+arg_18]
call _ZN17QArrayDataPointerIDsED2Ev; QArrayDataPointer<char16_t>::~QArrayDataPointer()
loc_1E5D9:
lea rdi, [rsp+arg_30]
call _ZN17QArrayDataPointerI4QUrlED2Ev; QArrayDataPointer<QUrl>::~QArrayDataPointer()
mov rdi, rbx
call __Unwind_Resume
| long long qdevtools::StyleSheetEdit::dropEvent(QWidget *this)
{
volatile signed __int32 *v2[3]; // [rsp+8h] [rbp-70h] BYREF
volatile signed __int32 *v3[3]; // [rsp+20h] [rbp-58h] BYREF
_BYTE v4[24]; // [rsp+38h] [rbp-40h] BYREF
volatile signed __int32 *v5[5]; // [rsp+50h] [rbp-28h] BYREF
QMimeData::urls((QMimeData *)v4);
QUrl::toLocalFile((QUrl *)v3);
QFileSystemWatcher::files((QFileSystemWatcher *)v2);
if ( v2[2] )
{
QFileSystemWatcher::removePaths(v5, *((_QWORD *)this + 5), v2);
QArrayDataPointer<QString>::~QArrayDataPointer(v5);
}
QArrayDataPointer<QString>::~QArrayDataPointer(v2);
QFileSystemWatcher::addPath(*((QFileSystemWatcher **)this + 5), (const QString *)v3);
qdevtools::StyleSheetEdit::qss((qdevtools::StyleSheetEdit *)v2);
qdevtools::StyleSheetEdit::setQss(this, (const QString *)v2);
QArrayDataPointer<char16_t>::~QArrayDataPointer(v2);
qdevtools::StyleSheetEdit::setState(this, 2);
QArrayDataPointer<char16_t>::~QArrayDataPointer(v3);
return QArrayDataPointer<QUrl>::~QArrayDataPointer(v4);
}
| dropEvent:
PUSH R14
PUSH RBX
SUB RSP,0x68
MOV RBX,RDI
MOV RSI,qword ptr [RSI + 0x38]
LEA R14,[RSP + 0x38]
MOV RDI,R14
CALL 0x0010fd30
MOV RSI,qword ptr [R14 + 0x8]
LAB_0011e505:
LEA RDI,[RSP + 0x20]
CALL 0x0010f730
MOV RSI,qword ptr [RBX + 0x28]
LAB_0011e513:
LEA RDI,[RSP + 0x8]
CALL 0x0010fb80
CMP qword ptr [RSP + 0x18],0x0
JZ 0x0011e542
MOV RSI,qword ptr [RBX + 0x28]
LAB_0011e529:
LEA RDI,[RSP + 0x50]
LEA RDX,[RSP + 0x8]
CALL 0x0010fe00
LEA RDI,[RSP + 0x50]
CALL 0x0011a896
LAB_0011e542:
LEA RDI,[RSP + 0x8]
CALL 0x0011a896
MOV RDI,qword ptr [RBX + 0x28]
LAB_0011e550:
LEA RSI,[RSP + 0x20]
CALL 0x0010fc90
LAB_0011e55a:
LEA RDI,[RSP + 0x8]
MOV RSI,RBX
CALL 0x0011e7d6
LAB_0011e567:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0011e75a
LEA RDI,[RSP + 0x8]
CALL 0x00114530
LAB_0011e57e:
PUSH 0x2
POP RSI
MOV RDI,RBX
CALL 0x0011df94
LAB_0011e589:
LEA RDI,[RSP + 0x20]
CALL 0x00114530
LEA RDI,[RSP + 0x38]
CALL 0x0011ee44
ADD RSP,0x68
POP RBX
POP R14
RET
|
/* qdevtools::StyleSheetEdit::dropEvent(QDropEvent*) */
void qdevtools::StyleSheetEdit::dropEvent(QDropEvent *param_1)
{
QArrayDataPointer<QString> local_70 [16];
long local_60;
QArrayDataPointer<char16_t> local_58 [24];
QArrayDataPointer<QUrl> local_40 [24];
QList local_28 [24];
QMimeData::urls();
/* try { // try from 0011e505 to 0011e50e has its CatchHandler @ 0011e5c7 */
QUrl::toLocalFile();
/* try { // try from 0011e513 to 0011e51c has its CatchHandler @ 0011e5c5 */
QFileSystemWatcher::files();
if (local_60 != 0) {
/* try { // try from 0011e529 to 0011e537 has its CatchHandler @ 0011e5a5 */
QFileSystemWatcher::removePaths(local_28);
QArrayDataPointer<QString>::~QArrayDataPointer((QArrayDataPointer<QString> *)local_28);
}
QArrayDataPointer<QString>::~QArrayDataPointer(local_70);
/* try { // try from 0011e550 to 0011e559 has its CatchHandler @ 0011e5cc */
QFileSystemWatcher::addPath(*(QString **)(param_1 + 0x28));
/* try { // try from 0011e55a to 0011e566 has its CatchHandler @ 0011e5c3 */
qss((StyleSheetEdit *)local_70);
/* try { // try from 0011e567 to 0011e573 has its CatchHandler @ 0011e5b4 */
setQss((StyleSheetEdit *)param_1,(QString *)local_70);
QArrayDataPointer<char16_t>::~QArrayDataPointer((QArrayDataPointer<char16_t> *)local_70);
/* try { // try from 0011e57e to 0011e588 has its CatchHandler @ 0011e5cc */
setState((StyleSheetEdit *)param_1,2);
QArrayDataPointer<char16_t>::~QArrayDataPointer(local_58);
QArrayDataPointer<QUrl>::~QArrayDataPointer(local_40);
return;
}
| |
32,139 | qdevtools::StyleSheetEdit::dropEvent(QDropEvent*) | HuaiminNotSleepYet[P]QDevTools/qdevtools.cpp | void dropEvent(QDropEvent* event) override
{
const auto urls = event->mimeData()->urls();
const auto file = urls.first().toLocalFile();
if (auto files = watcher_->files(); !files.empty())
watcher_->removePaths(files);
watcher_->addPath(file);
setQss(qss());
setState(Link);
} | O3 | cpp | qdevtools::StyleSheetEdit::dropEvent(QDropEvent*):
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x38(%rsi), %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0xfd00
movq 0x8(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0xf730
movq 0x28(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0xfb50
cmpq $0x0, 0x18(%rsp)
je 0x2078e
movq 0x28(%rbx), %rsi
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xfdd0
leaq 0x50(%rsp), %rdi
callq 0x1c968
leaq 0x8(%rsp), %rdi
callq 0x1c968
movq 0x28(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0xfc60
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x20b38
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x20a7c
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x207e3
lock
decl (%rax)
jne 0x207e3
movq 0x8(%rsp), %rdi
movl $0x2, %esi
movl $0x8, %edx
callq 0xf610
movq %rbx, %rdi
movl $0x2, %esi
callq 0x20092
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x20813
lock
decl (%rax)
jne 0x20813
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x8, %edx
callq 0xf610
leaq 0x38(%rsp), %rdi
callq 0x2110a
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1c968
jmp 0x20868
movq %rax, %rbx
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x20868
lock
decl (%rax)
jne 0x20868
movq 0x8(%rsp), %rdi
movl $0x2, %esi
movl $0x8, %edx
callq 0xf610
jmp 0x20868
jmp 0x20865
jmp 0x20865
movq %rax, %rbx
jmp 0x2088b
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2088b
lock
decl (%rax)
jne 0x2088b
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x8, %edx
callq 0xf610
leaq 0x38(%rsp), %rdi
callq 0x2110a
movq %rbx, %rdi
callq 0xf410
nop
| _ZN9qdevtools14StyleSheetEdit9dropEventEP10QDropEvent:
push r14
push rbx
sub rsp, 68h
mov rbx, rdi
mov rsi, [rsi+38h]
lea r14, [rsp+78h+var_40]
mov rdi, r14; this
call __ZNK9QMimeData4urlsEv; QMimeData::urls(void)
mov rsi, [r14+8]
lea rdi, [rsp+78h+var_58]; this
call __ZNK4QUrl11toLocalFileEv; QUrl::toLocalFile(void)
mov rsi, [rbx+28h]
lea rdi, [rsp+78h+var_70]; this
call __ZNK18QFileSystemWatcher5filesEv; QFileSystemWatcher::files(void)
cmp [rsp+78h+var_60], 0
jz short loc_2078E
mov rsi, [rbx+28h]
lea rdi, [rsp+78h+var_28]
lea rdx, [rsp+78h+var_70]
call __ZN18QFileSystemWatcher11removePathsERK5QListI7QStringE; QFileSystemWatcher::removePaths(QList<QString> const&)
lea rdi, [rsp+78h+var_28]
call _ZN17QArrayDataPointerI7QStringED2Ev; QArrayDataPointer<QString>::~QArrayDataPointer()
loc_2078E:
lea rdi, [rsp+78h+var_70]
call _ZN17QArrayDataPointerI7QStringED2Ev; QArrayDataPointer<QString>::~QArrayDataPointer()
mov rdi, [rbx+28h]; this
lea rsi, [rsp+78h+var_58]; QString *
call __ZN18QFileSystemWatcher7addPathERK7QString; QFileSystemWatcher::addPath(QString const&)
lea rdi, [rsp+78h+var_70]; this
mov rsi, rbx
call _ZNK9qdevtools14StyleSheetEdit3qssEv; qdevtools::StyleSheetEdit::qss(void)
lea rsi, [rsp+78h+var_70]; QString *
mov rdi, rbx; this
call _ZN9qdevtools14StyleSheetEdit6setQssERK7QString; qdevtools::StyleSheetEdit::setQss(QString const&)
mov rax, [rsp+78h+var_70]
test rax, rax
jz short loc_207E3
lock dec dword ptr [rax]
jnz short loc_207E3
mov rdi, [rsp+78h+var_70]
mov esi, 2
mov edx, 8
call __ZN10QArrayData10deallocateEPS_xx; QArrayData::deallocate(QArrayData*,long long,long long)
loc_207E3:
mov rdi, rbx; this
mov esi, 2
call _ZN9qdevtools14StyleSheetEdit8setStateENS0_5StateE; qdevtools::StyleSheetEdit::setState(qdevtools::StyleSheetEdit::State)
mov rax, [rsp+78h+var_58]
test rax, rax
jz short loc_20813
lock dec dword ptr [rax]
jnz short loc_20813
mov rdi, [rsp+78h+var_58]
mov esi, 2
mov edx, 8
call __ZN10QArrayData10deallocateEPS_xx; QArrayData::deallocate(QArrayData*,long long,long long)
loc_20813:
lea rdi, [rsp+78h+var_40]
call _ZN17QArrayDataPointerI4QUrlED2Ev; QArrayDataPointer<QUrl>::~QArrayDataPointer()
add rsp, 68h
pop rbx
pop r14
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZN17QArrayDataPointerI7QStringED2Ev; QArrayDataPointer<QString>::~QArrayDataPointer()
jmp short loc_20868
mov rbx, rax
mov rax, [rsp+arg_0]
test rax, rax
jz short loc_20868
lock dec dword ptr [rax]
jnz short loc_20868
mov rdi, [rsp+arg_0]
mov esi, 2
mov edx, 8
call __ZN10QArrayData10deallocateEPS_xx; QArrayData::deallocate(QArrayData*,long long,long long)
jmp short loc_20868
jmp short loc_20865
jmp short loc_20865
mov rbx, rax
jmp short loc_2088B
loc_20865:
mov rbx, rax
loc_20868:
mov rax, [rsp+arg_18]
test rax, rax
jz short loc_2088B
lock dec dword ptr [rax]
jnz short loc_2088B
mov rdi, [rsp+arg_18]
mov esi, 2
mov edx, 8
call __ZN10QArrayData10deallocateEPS_xx; QArrayData::deallocate(QArrayData*,long long,long long)
loc_2088B:
lea rdi, [rsp+arg_30]
call _ZN17QArrayDataPointerI4QUrlED2Ev; QArrayDataPointer<QUrl>::~QArrayDataPointer()
mov rdi, rbx
call __Unwind_Resume
| long long qdevtools::StyleSheetEdit::dropEvent(QWidget *this)
{
volatile signed __int32 *v2[3]; // [rsp+8h] [rbp-70h] BYREF
volatile signed __int32 *v3[3]; // [rsp+20h] [rbp-58h] BYREF
_BYTE v4[24]; // [rsp+38h] [rbp-40h] BYREF
volatile signed __int32 *v5[5]; // [rsp+50h] [rbp-28h] BYREF
QMimeData::urls((QMimeData *)v4);
QUrl::toLocalFile((QUrl *)v3);
QFileSystemWatcher::files((QFileSystemWatcher *)v2);
if ( v2[2] )
{
QFileSystemWatcher::removePaths(v5, *((_QWORD *)this + 5), v2);
QArrayDataPointer<QString>::~QArrayDataPointer(v5);
}
QArrayDataPointer<QString>::~QArrayDataPointer(v2);
QFileSystemWatcher::addPath(*((QFileSystemWatcher **)this + 5), (const QString *)v3);
qdevtools::StyleSheetEdit::qss((qdevtools::StyleSheetEdit *)v2);
qdevtools::StyleSheetEdit::setQss(this, (const QString *)v2);
if ( v2[0] && !_InterlockedDecrement(v2[0]) )
QArrayData::deallocate(v2[0], 2LL);
qdevtools::StyleSheetEdit::setState(this, 2);
if ( v3[0] && !_InterlockedDecrement(v3[0]) )
QArrayData::deallocate(v3[0], 2LL);
return QArrayDataPointer<QUrl>::~QArrayDataPointer(v4);
}
| dropEvent:
PUSH R14
PUSH RBX
SUB RSP,0x68
MOV RBX,RDI
MOV RSI,qword ptr [RSI + 0x38]
LEA R14,[RSP + 0x38]
MOV RDI,R14
CALL 0x0010fd00
MOV RSI,qword ptr [R14 + 0x8]
LAB_00120751:
LEA RDI,[RSP + 0x20]
CALL 0x0010f730
MOV RSI,qword ptr [RBX + 0x28]
LAB_0012075f:
LEA RDI,[RSP + 0x8]
CALL 0x0010fb50
CMP qword ptr [RSP + 0x18],0x0
JZ 0x0012078e
MOV RSI,qword ptr [RBX + 0x28]
LAB_00120775:
LEA RDI,[RSP + 0x50]
LEA RDX,[RSP + 0x8]
CALL 0x0010fdd0
LEA RDI,[RSP + 0x50]
CALL 0x0011c968
LAB_0012078e:
LEA RDI,[RSP + 0x8]
CALL 0x0011c968
MOV RDI,qword ptr [RBX + 0x28]
LAB_0012079c:
LEA RSI,[RSP + 0x20]
CALL 0x0010fc60
LAB_001207a6:
LEA RDI,[RSP + 0x8]
MOV RSI,RBX
CALL 0x00120b38
LAB_001207b3:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00120a7c
MOV RAX,qword ptr [RSP + 0x8]
TEST RAX,RAX
JZ 0x001207e3
DEC.LOCK dword ptr [RAX]
JNZ 0x001207e3
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x2
MOV EDX,0x8
CALL 0x0010f610
LAB_001207e3:
MOV RDI,RBX
MOV ESI,0x2
CALL 0x00120092
LAB_001207f0:
MOV RAX,qword ptr [RSP + 0x20]
TEST RAX,RAX
JZ 0x00120813
DEC.LOCK dword ptr [RAX]
JNZ 0x00120813
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,0x2
MOV EDX,0x8
CALL 0x0010f610
LAB_00120813:
LEA RDI,[RSP + 0x38]
CALL 0x0012110a
ADD RSP,0x68
POP RBX
POP R14
RET
|
/* qdevtools::StyleSheetEdit::dropEvent(QDropEvent*) */
void qdevtools::StyleSheetEdit::dropEvent(QDropEvent *param_1)
{
QArrayData *local_70 [2];
long local_60;
QArrayData *local_58;
QArrayDataPointer<QUrl> local_40 [24];
QList local_28 [24];
QMimeData::urls();
/* try { // try from 00120751 to 0012075a has its CatchHandler @ 00120860 */
QUrl::toLocalFile();
/* try { // try from 0012075f to 00120768 has its CatchHandler @ 0012085e */
QFileSystemWatcher::files();
if (local_60 != 0) {
/* try { // try from 00120775 to 00120783 has its CatchHandler @ 00120825 */
QFileSystemWatcher::removePaths(local_28);
QArrayDataPointer<QString>::~QArrayDataPointer((QArrayDataPointer<QString> *)local_28);
}
QArrayDataPointer<QString>::~QArrayDataPointer((QArrayDataPointer<QString> *)local_70);
/* try { // try from 0012079c to 001207a5 has its CatchHandler @ 00120865 */
QFileSystemWatcher::addPath(*(QString **)(param_1 + 0x28));
/* try { // try from 001207a6 to 001207b2 has its CatchHandler @ 0012085c */
qss((StyleSheetEdit *)local_70);
/* try { // try from 001207b3 to 001207bf has its CatchHandler @ 00120834 */
setQss((StyleSheetEdit *)param_1,(QString *)local_70);
if (local_70[0] != (QArrayData *)0x0) {
LOCK();
*(int *)local_70[0] = *(int *)local_70[0] + -1;
UNLOCK();
if (*(int *)local_70[0] == 0) {
QArrayData::deallocate(local_70[0],2,8);
}
}
/* try { // try from 001207e3 to 001207ef has its CatchHandler @ 00120865 */
setState((StyleSheetEdit *)param_1,2);
if (local_58 != (QArrayData *)0x0) {
LOCK();
*(int *)local_58 = *(int *)local_58 + -1;
UNLOCK();
if (*(int *)local_58 == 0) {
QArrayData::deallocate(local_58,2,8);
}
}
QArrayDataPointer<QUrl>::~QArrayDataPointer(local_40);
return;
}
| |
32,140 | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::start_object(unsigned long) | monkey531[P]llama/common/json.hpp | bool start_object(std::size_t len)
{
// check callback for object start
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
keep_stack.push_back(keep);
auto val = handle_value(BasicJsonType::value_t::object, true);
ref_stack.push_back(val.second);
// check object limit
if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
}
return true;
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::start_object(unsigned long):
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
addq $0x80, %rax
movq %rax, 0x18(%rsp)
addq $0x8, %rdi
callq 0xaef70
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rcx
movl %eax, %esi
addq $0xa8, %rcx
xorl %edx, %edx
callq 0xaef10
movq 0x20(%rsp), %rdi
andb $0x1, %al
movb %al, 0x97(%rsp)
addq $0x20, %rdi
movb 0x97(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xabbc0
movq 0x20(%rsp), %rdi
movb $0x1, 0x7f(%rsp)
leaq 0x7f(%rsp), %rsi
movl $0x1, %edx
callq 0xaef90
movq 0x20(%rsp), %rdi
movb %al, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
addq $0x8, %rdi
leaq 0x80(%rsp), %rsi
addq $0x8, %rsi
callq 0xaf4f0
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0xaf560
cmpq $0x0, (%rax)
je 0xae122
xorl %eax, %eax
cmpq $-0x1, 0x98(%rsp)
movb %al, 0x17(%rsp)
je 0xae038
movq 0x20(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0xaf560
movq (%rax), %rdi
callq 0xaf5a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
seta %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xae049
jmp 0xae122
movb $0x1, 0x2b(%rsp)
movl $0x20, %edi
callq 0x5a6b0
movq %rax, (%rsp)
movq 0x98(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xaf880
jmp 0xae070
leaq 0x160268(%rip), %rsi # 0x20e2df
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0xaf7d0
jmp 0xae088
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0xaf560
movq (%rsp), %rdi
movq (%rax), %rcx
movl $0x198, %esi # imm = 0x198
leaq 0x58(%rsp), %rdx
callq 0xaf620
jmp 0xae0ae
movq (%rsp), %rdi
movb $0x0, 0x2b(%rsp)
leaq 0x1f2c4a(%rip), %rsi # 0x2a0d08
leaq 0xb6b(%rip), %rdx # 0xaec30
callq 0x5ab30
jmp 0xae138
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xae10e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xae104
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5b588
leaq 0x38(%rsp), %rdi
callq 0x5b588
testb $0x1, 0x2b(%rsp)
jne 0xae117
jmp 0xae120
movq (%rsp), %rdi
callq 0x5af90
jmp 0xae12e
movb $0x1, %al
andb $0x1, %al
addq $0xa8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5abf0
nopl (%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12start_objectEm:
sub rsp, 0A8h
mov qword ptr [rsp+0A8h+var_8], rdi
mov [rsp+0A8h+var_10], rsi
mov rdi, qword ptr [rsp+0A8h+var_8]
mov qword ptr [rsp+0A8h+var_88], rdi; int
mov rax, rdi
add rax, 80h
mov qword ptr [rsp+0A8h+var_90], rax; char
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4sizeEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::size(void)
mov rdi, qword ptr [rsp+0A8h+var_90]
mov rcx, qword ptr [rsp+0A8h+var_88]
mov esi, eax
add rcx, 0A8h
xor edx, edx
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov rdi, qword ptr [rsp+0A8h+var_88]
and al, 1
mov [rsp+0A8h+var_11], al
add rdi, 20h ; ' '
mov al, [rsp+0A8h+var_11]
and al, 1
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
mov rdi, qword ptr [rsp+0A8h+var_88]
mov [rsp+0A8h+var_29], 1
lea rsi, [rsp+0A8h+var_29]
mov edx, 1
call _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueINS1_7value_tEEESt4pairIbPSF_EOT_b; nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t &&,bool)
mov rdi, qword ptr [rsp+0A8h+var_88]
mov byte ptr [rsp+0A8h+var_28], al; int
mov qword ptr [rsp+0A8h+var_20], rdx; int
add rdi, 8
lea rsi, [rsp+0A8h+var_28]
add rsi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE9push_backERKSE_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> * const&)
mov rdi, qword ptr [rsp+0A8h+var_88]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
cmp qword ptr [rax], 0
jz loc_AE122
xor eax, eax
cmp [rsp+0A8h+var_10], 0FFFFFFFFFFFFFFFFh
mov [rsp+0A8h+var_91], al
jz short loc_AE038
mov rdi, qword ptr [rsp+0A8h+var_88]
mov rax, [rsp+0A8h+var_10]
mov qword ptr [rsp+0A8h+var_A0], rax; int
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8max_sizeEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::max_size(void)
mov rcx, rax
mov rax, qword ptr [rsp+0A8h+var_A0]
cmp rax, rcx
setnbe al
mov [rsp+0A8h+var_91], al
loc_AE038:
mov al, [rsp+0A8h+var_91]
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_AE049
jmp loc_AE122
loc_AE049:
mov [rsp+0A8h+var_7D], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov [rsp+0A8h+var_A8], rax; int
mov rsi, [rsp+0A8h+var_10]; unsigned __int64
lea rdi, [rsp+0A8h+var_70]; this
call _ZNSt7__cxx119to_stringEm; std::to_string(ulong)
jmp short $+2
loc_AE070:
lea rsi, aExcessiveObjec; "excessive object size: "
lea rdi, [rsp+0A8h+var_50]
lea rdx, [rsp+0A8h+var_70]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA24_KcS8_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[24],std::string>(char const(&)[24],std::string &&)
jmp short $+2
loc_AE088:
mov rdi, qword ptr [rsp+0A8h+var_88]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rsp+0A8h+var_A8]; int
mov rcx, [rax]
mov esi, 198h
lea rdx, [rsp+0A8h+var_50]
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
jmp short $+2
loc_AE0AE:
mov rdi, [rsp+0A8h+var_A8]; void *
mov [rsp+0A8h+var_7D], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail12out_of_rangeD2Ev; void (*)(void *)
call ___cxa_throw
jmp short loc_AE138
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
jmp short loc_AE10E
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
jmp short loc_AE104
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_AE104:
lea rdi, [rsp+arg_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_AE10E:
test [rsp+arg_23], 1
jnz short loc_AE117
jmp short loc_AE120
loc_AE117:
mov rdi, [rsp+0]; void *
call ___cxa_free_exception
loc_AE120:
jmp short loc_AE12E
loc_AE122:
mov al, 1
and al, 1
add rsp, 0A8h
retn
loc_AE12E:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
loc_AE138:
nop dword ptr [rax+rax+00000000h]
| start_object:
SUB RSP,0xa8
MOV qword ptr [RSP + 0xa0],RDI
MOV qword ptr [RSP + 0x98],RSI
MOV RDI,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,RDI
ADD RAX,0x80
MOV qword ptr [RSP + 0x18],RAX
ADD RDI,0x8
CALL 0x001aef70
MOV RDI,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x20]
MOV ESI,EAX
ADD RCX,0xa8
XOR EDX,EDX
CALL 0x001aef10
MOV RDI,qword ptr [RSP + 0x20]
AND AL,0x1
MOV byte ptr [RSP + 0x97],AL
ADD RDI,0x20
MOV AL,byte ptr [RSP + 0x97]
AND AL,0x1
MOVZX ESI,AL
CALL 0x001abbc0
MOV RDI,qword ptr [RSP + 0x20]
MOV byte ptr [RSP + 0x7f],0x1
LEA RSI,[RSP + 0x7f]
MOV EDX,0x1
CALL 0x001aef90
MOV RDI,qword ptr [RSP + 0x20]
MOV byte ptr [RSP + 0x80],AL
MOV qword ptr [RSP + 0x88],RDX
ADD RDI,0x8
LEA RSI,[RSP + 0x80]
ADD RSI,0x8
CALL 0x001af4f0
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x8
CALL 0x001af560
CMP qword ptr [RAX],0x0
JZ 0x001ae122
XOR EAX,EAX
CMP qword ptr [RSP + 0x98],-0x1
MOV byte ptr [RSP + 0x17],AL
JZ 0x001ae038
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x8],RAX
ADD RDI,0x8
CALL 0x001af560
MOV RDI,qword ptr [RAX]
CALL 0x001af5a0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,RCX
SETA AL
MOV byte ptr [RSP + 0x17],AL
LAB_001ae038:
MOV AL,byte ptr [RSP + 0x17]
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x001ae049
JMP 0x001ae122
LAB_001ae049:
MOV byte ptr [RSP + 0x2b],0x1
MOV EDI,0x20
CALL 0x0015a6b0
MOV qword ptr [RSP],RAX
MOV RSI,qword ptr [RSP + 0x98]
LAB_001ae064:
LEA RDI,[RSP + 0x38]
CALL 0x001af880
JMP 0x001ae070
LAB_001ae070:
LEA RSI,[0x30e2df]
LEA RDI,[RSP + 0x58]
LEA RDX,[RSP + 0x38]
CALL 0x001af7d0
JMP 0x001ae088
LAB_001ae088:
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x8
CALL 0x001af560
MOV RDI,qword ptr [RSP]
MOV RCX,qword ptr [RAX]
LAB_001ae09d:
MOV ESI,0x198
LEA RDX,[RSP + 0x58]
CALL 0x001af620
JMP 0x001ae0ae
LAB_001ae0ae:
MOV RDI,qword ptr [RSP]
MOV byte ptr [RSP + 0x2b],0x0
LEA RSI,[0x3a0d08]
LEA RDX,[0x1aec30]
CALL 0x0015ab30
LAB_001ae122:
MOV AL,0x1
AND AL,0x1
ADD RSP,0xa8
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::start_object(unsigned long) */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::start_object(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,ulong param_1)
{
bool bVar1;
ulong uVar2;
byte bVar3;
int4 uVar4;
long *plVar5;
int8 *puVar6;
ulong uVar7;
int8 uVar8;
basic_json *extraout_RDX;
__cxx11 local_70 [32];
detail local_50 [39];
value_t local_29;
int1 local_28;
basic_json *local_20;
int1 local_11;
ulong local_10;
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*local_8;
local_10 = param_1;
local_8 = this;
uVar4 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::size((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
bVar3 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
*)(this + 0x80),uVar4,0,this + 0xa8);
local_11 = bVar3 & 1;
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x20),(bool)local_11);
local_29 = 1;
local_28 = handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(this,&local_29,true);
local_20 = extraout_RDX;
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::push_back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8),&local_20);
plVar5 = (long *)std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
uVar2 = local_10;
if (*plVar5 != 0) {
bVar1 = false;
if (local_10 != 0xffffffffffffffff) {
puVar6 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
uVar7 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::max_size((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar6);
bVar1 = uVar7 < uVar2;
}
if (bVar1) {
uVar8 = __cxa_allocate_exception(0x20);
/* try { // try from 001ae064 to 001ae06d has its CatchHandler @ 001ae0cc */
std::__cxx11::to_string(local_70,local_10);
/* try { // try from 001ae070 to 001ae085 has its CatchHandler @ 001ae0dc */
concat<std::__cxx11::string,char_const(&)[24],std::__cxx11::string>
(local_50,"excessive object size: ",(string *)local_70);
puVar6 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
/* try { // try from 001ae09d to 001ae0c9 has its CatchHandler @ 001ae0ec */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar8,0x198,local_50,*puVar6);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar8,&out_of_range::typeinfo,out_of_range::~out_of_range);
}
}
return 1;
}
| ||
32,141 | trnman_end_trn | eloqsql/storage/maria/trnman.c | my_bool trnman_end_trn(TRN *trn, my_bool commit)
{
int res= 1;
uint16 cached_short_id= trn->short_id; /* we have to cache it, see below */
TRN *free_me= 0;
LF_PINS *pins= trn->pins;
DBUG_ENTER("trnman_end_trn");
DBUG_PRINT("enter", ("trn: %p commit: %d", trn, commit));
/* if a rollback, all UNDO records should have been executed */
DBUG_ASSERT(commit || trn->undo_lsn == 0);
DBUG_ASSERT(trn != &dummy_transaction_object);
DBUG_ASSERT(trn->locked_tables == 0 && trn->used_instances == 0);
DBUG_PRINT("info", ("mysql_mutex_lock LOCK_trn_list"));
mysql_mutex_lock(&LOCK_trn_list);
/* remove from active list */
trn->next->prev= trn->prev;
trn->prev->next= trn->next;
/*
if trn was the oldest active transaction, now that it goes away there
may be committed transactions in the list which no active transaction
needs to bother about - clean up the committed list
*/
if (trn->prev == &active_list_min)
{
uint free_me_count;
TRN *t;
for (t= committed_list_min.next, free_me_count= 0;
t->commit_trid < active_list_min.next->min_read_from;
t= t->next, free_me_count++) /* no-op */;
DBUG_ASSERT((t != committed_list_min.next && free_me_count > 0) ||
(t == committed_list_min.next && free_me_count == 0));
/* found transactions committed before the oldest active one */
if (t != committed_list_min.next)
{
free_me= committed_list_min.next;
committed_list_min.next= t;
t->prev->next= 0;
t->prev= &committed_list_min;
trnman_committed_transactions-= free_me_count;
}
}
mysql_mutex_lock(&trn->state_lock);
if (commit)
trn->commit_trid= global_trid_generator;
wt_thd_release_self(trn);
mysql_mutex_unlock(&trn->state_lock);
/*
if transaction is committed and it was not the only active transaction -
add it to the committed list
*/
if (commit && active_list_min.next != &active_list_max)
{
trn->next= &committed_list_max;
trn->prev= committed_list_max.prev;
trnman_committed_transactions++;
committed_list_max.prev= trn->prev->next= trn;
}
else
{
trn->next= free_me;
free_me= trn;
}
trid_min_read_from= active_list_min.next->min_read_from;
if ((*trnman_end_trans_hook)(trn, commit,
active_list_min.next != &active_list_max))
res= -1;
trnman_active_transactions--;
DBUG_PRINT("info", ("mysql_mutex_unlock LOCK_trn_list"));
mysql_mutex_unlock(&LOCK_trn_list);
/*
the rest is done outside of a critical section
note that we don't own trn anymore, it may be in a shared list now.
Thus, we cannot dereference it, and must use cached_short_id below.
*/
my_atomic_storeptr((void **)&short_trid_to_active_trn[cached_short_id], 0);
/*
we, under the mutex, removed going-in-free_me transactions from the
active and committed lists, thus nobody else may see them when it scans
those lists, and thus nobody may want to free them. Now we don't
need a mutex to access free_me list
*/
/* QQ: send them to the purge thread */
while (free_me)
{
TRN *t= free_me;
free_me= free_me->next;
/* ignore OOM. it's harmless, and we can do nothing here anyway */
(void)lf_hash_delete(&trid_to_trn, pins, &t->trid, sizeof(TrID));
trnman_free_trn(t);
}
lf_hash_put_pins(pins);
DBUG_RETURN(res < 0);
} | O0 | c | trnman_end_trn:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw 0xac(%rax), %ax
movw %ax, -0x12(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x790bd
jmp 0x790bf
jmp 0x790c1
jmp 0x790c3
jmp 0x790c5
jmp 0x790c7
jmp 0x790c9
jmp 0x790cb
jmp 0x790cd
leaq 0xc00fbc(%rip), %rdi # 0xc7a090
leaq 0xd95ea(%rip), %rsi # 0x1526c5
movl $0x1b9, %edx # imm = 0x1B9
callq 0x78e20
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
leaq 0xc00bd0(%rip), %rcx # 0xc79ce8
cmpq %rcx, 0x70(%rax)
jne 0x791c1
movq 0xc00e37(%rip), %rax # 0xc79f60
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movq 0x88(%rax), %rax
movq 0xc00c0a(%rip), %rcx # 0xc79d50
cmpq 0x80(%rcx), %rax
jae 0x79168
jmp 0x79151
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x79134
jmp 0x7916a
jmp 0x7916c
movq -0x38(%rbp), %rax
cmpq 0xc00de9(%rip), %rax # 0xc79f60
je 0x791bf
movq 0xc00de0(%rip), %rax # 0xc79f60
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, 0xc00dd1(%rip) # 0xc79f60
movq -0x38(%rbp), %rax
movq 0x70(%rax), %rax
movq $0x0, 0x68(%rax)
movq -0x38(%rbp), %rax
leaq 0xc00d4e(%rip), %rcx # 0xc79ef8
movq %rcx, 0x70(%rax)
movl -0x2c(%rbp), %ecx
movl 0xc00df5(%rip), %eax # 0xc79fac
subl %ecx, %eax
movl %eax, 0xc00ded(%rip) # 0xc79fac
jmp 0x791c1
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq 0xd94f5(%rip), %rsi # 0x1526c5
movl $0x1d9, %edx # imm = 0x1D9
callq 0x78e20
cmpb $0x0, -0x9(%rbp)
je 0x791f2
movq 0xc00dd9(%rip), %rcx # 0xc79fc0
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x8(%rbp), %rdi
callq 0x793d0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x78e90
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
je 0x79267
leaq 0xc00b80(%rip), %rax # 0xc79d98
cmpq %rax, 0xc00b31(%rip) # 0xc79d50
je 0x79267
movq -0x8(%rbp), %rax
leaq 0xc00c1c(%rip), %rcx # 0xc79e48
movq %rcx, 0x68(%rax)
movq 0xc00c81(%rip), %rcx # 0xc79eb8
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
movl 0xc00d67(%rip), %eax # 0xc79fac
addl $0x1, %eax
movl %eax, 0xc00d5e(%rip) # 0xc79fac
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x70(%rcx), %rcx
movq %rax, 0x68(%rcx)
movq %rax, 0xc00c53(%rip) # 0xc79eb8
jmp 0x7927b
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0xc00ace(%rip), %rax # 0xc79d50
movq 0x80(%rax), %rax
movq %rax, 0x244f48(%rip) # 0x2be1d8
movq 0x244f39(%rip), %rax # 0x2be1d0
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %dl
leaq 0xc00af3(%rip), %rcx # 0xc79d98
cmpq %rcx, 0xc00aa4(%rip) # 0xc79d50
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
movsbl %dl, %esi
movsbl %cl, %edx
callq *%rax
cmpb $0x0, %al
je 0x792c8
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl 0xc00cda(%rip), %eax # 0xc79fa8
addl $-0x1, %eax
movl %eax, 0xc00cd1(%rip) # 0xc79fa8
jmp 0x792d9
leaq 0xc00db0(%rip), %rdi # 0xc7a090
callq 0x78e90
movq 0xc009f4(%rip), %rcx # 0xc79ce0
movzwl -0x12(%rbp), %eax
movl %eax, %edx
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
xchgq %rax, (%rcx,%rdx,8)
cmpq $0x0, -0x20(%rbp)
je 0x79345
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq $0x78, %rdx
leaq 0xc00c98(%rip), %rdi # 0xc79fc8
movl $0x8, %ecx
callq 0xfdb20
movq -0x48(%rbp), %rdi
callq 0x78ef0
jmp 0x79302
movq -0x28(%rbp), %rdi
callq 0xfc2f0
cmpl $0x0, -0x10(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| trnman_end_trn:
push rbp
mov rbp, rsp
sub rsp, 50h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
mov [rbp+var_10], 1
mov rax, [rbp+var_8]
mov ax, [rax+0ACh]
mov [rbp+var_12], ax
mov [rbp+var_20], 0
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_28], rax
jmp short $+2
loc_790BD:
jmp short $+2
loc_790BF:
jmp short $+2
loc_790C1:
jmp short $+2
loc_790C3:
jmp short $+2
loc_790C5:
jmp short $+2
loc_790C7:
jmp short $+2
loc_790C9:
jmp short $+2
loc_790CB:
jmp short $+2
loc_790CD:
lea rdi, LOCK_trn_list
lea rsi, aWorkspaceLlm4b_16; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 1B9h
call inline_mysql_mutex_lock_11
mov rax, [rbp+var_8]
mov rcx, [rax+70h]
mov rax, [rbp+var_8]
mov rax, [rax+68h]
mov [rax+70h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+68h]
mov rax, [rbp+var_8]
mov rax, [rax+70h]
mov [rax+68h], rcx
mov rax, [rbp+var_8]
lea rcx, active_list_min
cmp [rax+70h], rcx
jnz loc_791C1
mov rax, cs:qword_C79F60
mov [rbp+var_38], rax
mov [rbp+var_2C], 0
loc_79134:
mov rax, [rbp+var_38]
mov rax, [rax+88h]
mov rcx, cs:qword_C79D50
cmp rax, [rcx+80h]
jnb short loc_79168
jmp short $+2
loc_79151:
mov rax, [rbp+var_38]
mov rax, [rax+68h]
mov [rbp+var_38], rax
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp short loc_79134
loc_79168:
jmp short $+2
loc_7916A:
jmp short $+2
loc_7916C:
mov rax, [rbp+var_38]
cmp rax, cs:qword_C79F60
jz short loc_791BF
mov rax, cs:qword_C79F60
mov [rbp+var_20], rax
mov rax, [rbp+var_38]
mov cs:qword_C79F60, rax
mov rax, [rbp+var_38]
mov rax, [rax+70h]
mov qword ptr [rax+68h], 0
mov rax, [rbp+var_38]
lea rcx, committed_list_min
mov [rax+70h], rcx
mov ecx, [rbp+var_2C]
mov eax, cs:trnman_committed_transactions
sub eax, ecx
mov cs:trnman_committed_transactions, eax
loc_791BF:
jmp short $+2
loc_791C1:
mov rdi, [rbp+var_8]
add rdi, 10h
lea rsi, aWorkspaceLlm4b_16; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 1D9h
call inline_mysql_mutex_lock_11
cmp [rbp+var_9], 0
jz short loc_791F2
mov rcx, cs:global_trid_generator
mov rax, [rbp+var_8]
mov [rax+88h], rcx
loc_791F2:
mov rdi, [rbp+var_8]
call wt_thd_release_self
mov rdi, [rbp+var_8]
add rdi, 10h
call inline_mysql_mutex_unlock_12
movsx eax, [rbp+var_9]
cmp eax, 0
jz short loc_79267
lea rax, active_list_max
cmp cs:qword_C79D50, rax
jz short loc_79267
mov rax, [rbp+var_8]
lea rcx, committed_list_max
mov [rax+68h], rcx
mov rcx, cs:qword_C79EB8
mov rax, [rbp+var_8]
mov [rax+70h], rcx
mov eax, cs:trnman_committed_transactions
add eax, 1
mov cs:trnman_committed_transactions, eax
mov rax, [rbp+var_8]
mov rcx, [rbp+var_8]
mov rcx, [rcx+70h]
mov [rcx+68h], rax
mov cs:qword_C79EB8, rax
jmp short loc_7927B
loc_79267:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_8]
mov [rax+68h], rcx
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
loc_7927B:
mov rax, cs:qword_C79D50
mov rax, [rax+80h]
mov cs:trid_min_read_from, rax
mov rax, cs:trnman_end_trans_hook
mov rdi, [rbp+var_8]
mov dl, [rbp+var_9]
lea rcx, active_list_max
cmp cs:qword_C79D50, rcx
setnz cl
and cl, 1
movzx ecx, cl
movsx esi, dl
movsx edx, cl
call rax ; default_trnman_end_trans_hook
cmp al, 0
jz short loc_792C8
mov [rbp+var_10], 0FFFFFFFFh
loc_792C8:
mov eax, cs:trnman_active_transactions
add eax, 0FFFFFFFFh
mov cs:trnman_active_transactions, eax
jmp short $+2
loc_792D9:
lea rdi, LOCK_trn_list
call inline_mysql_mutex_unlock_12
mov rcx, cs:short_trid_to_active_trn
movzx eax, [rbp+var_12]
mov edx, eax
mov [rbp+var_40], 0
mov rax, [rbp+var_40]
xchg rax, [rcx+rdx*8]
loc_79302:
cmp [rbp+var_20], 0
jz short loc_79345
mov rax, [rbp+var_20]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov rax, [rax+68h]
mov [rbp+var_20], rax
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_48]
add rdx, 78h ; 'x'
lea rdi, trid_to_trn
mov ecx, 8
call lf_hash_delete
mov rdi, [rbp+var_48]
call trnman_free_trn
jmp short loc_79302
loc_79345:
mov rdi, [rbp+var_28]
call lf_pinbox_put_pins
cmp [rbp+var_10], 0
setl al
and al, 1
movzx eax, al
mov [rbp+var_49], al
mov al, [rbp+var_49]
add rsp, 50h
pop rbp
retn
| _BOOL8 trnman_end_trn(long long a1, char a2)
{
long long v2; // rsi
signed long long v4; // [rsp+8h] [rbp-48h]
_QWORD *v5; // [rsp+18h] [rbp-38h]
int v6; // [rsp+24h] [rbp-2Ch]
long long v7; // [rsp+28h] [rbp-28h]
long long v8; // [rsp+30h] [rbp-20h]
unsigned __int16 v9; // [rsp+3Eh] [rbp-12h]
int v10; // [rsp+40h] [rbp-10h]
v10 = 1;
v9 = *(_WORD *)(a1 + 172);
v8 = 0LL;
v7 = *(_QWORD *)a1;
inline_mysql_mutex_lock_11(
(long long)&LOCK_trn_list,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",
0x1B9u);
*(_QWORD *)(*(_QWORD *)(a1 + 104) + 112LL) = *(_QWORD *)(a1 + 112);
*(_QWORD *)(*(_QWORD *)(a1 + 112) + 104LL) = *(_QWORD *)(a1 + 104);
if ( *(_UNKNOWN **)(a1 + 112) == &active_list_min )
{
v5 = (_QWORD *)qword_C79F60;
v6 = 0;
while ( v5[17] < *(_QWORD *)(qword_C79D50 + 128) )
{
v5 = (_QWORD *)v5[13];
++v6;
}
if ( v5 != (_QWORD *)qword_C79F60 )
{
v8 = qword_C79F60;
qword_C79F60 = (long long)v5;
*(_QWORD *)(v5[14] + 104LL) = 0LL;
v5[14] = &committed_list_min;
trnman_committed_transactions -= v6;
}
}
inline_mysql_mutex_lock_11(
a1 + 16,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",
0x1D9u);
if ( a2 )
*(_QWORD *)(a1 + 136) = global_trid_generator;
wt_thd_release_self(a1);
inline_mysql_mutex_unlock_12(a1 + 16);
if ( !a2 || (_UNKNOWN *)qword_C79D50 == &active_list_max )
{
*(_QWORD *)(a1 + 104) = v8;
v8 = a1;
}
else
{
*(_QWORD *)(a1 + 104) = &committed_list_max;
*(_QWORD *)(a1 + 112) = qword_C79EB8;
++trnman_committed_transactions;
*(_QWORD *)(*(_QWORD *)(a1 + 112) + 104LL) = a1;
qword_C79EB8 = a1;
}
trid_min_read_from = *(_QWORD *)(qword_C79D50 + 128);
v2 = (unsigned int)a2;
if ( (unsigned __int8)trnman_end_trans_hook() )
v10 = -1;
--trnman_active_transactions;
inline_mysql_mutex_unlock_12((long long)&LOCK_trn_list);
_InterlockedExchange64((volatile long long *)(short_trid_to_active_trn + 8LL * v9), 0LL);
while ( v8 )
{
v4 = v8;
v8 = *(_QWORD *)(v8 + 104);
v2 = v7;
lf_hash_delete(&trid_to_trn, v7, v4 + 120, 8LL);
trnman_free_trn(v4);
}
lf_pinbox_put_pins(v7, v2);
return v10 < 0;
}
| trnman_end_trn:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
MOV dword ptr [RBP + -0x10],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV AX,word ptr [RAX + 0xac]
MOV word ptr [RBP + -0x12],AX
MOV qword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001790bd
LAB_001790bd:
JMP 0x001790bf
LAB_001790bf:
JMP 0x001790c1
LAB_001790c1:
JMP 0x001790c3
LAB_001790c3:
JMP 0x001790c5
LAB_001790c5:
JMP 0x001790c7
LAB_001790c7:
JMP 0x001790c9
LAB_001790c9:
JMP 0x001790cb
LAB_001790cb:
JMP 0x001790cd
LAB_001790cd:
LEA RDI,[0xd7a090]
LEA RSI,[0x2526c5]
MOV EDX,0x1b9
CALL 0x00178e20
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x70]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x68]
MOV qword ptr [RAX + 0x70],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x70]
MOV qword ptr [RAX + 0x68],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xd79ce8]
CMP qword ptr [RAX + 0x70],RCX
JNZ 0x001791c1
MOV RAX,qword ptr [0x00d79f60]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x2c],0x0
LAB_00179134:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x88]
MOV RCX,qword ptr [0x00d79d50]
CMP RAX,qword ptr [RCX + 0x80]
JNC 0x00179168
JMP 0x00179151
LAB_00179151:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x68]
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x00179134
LAB_00179168:
JMP 0x0017916a
LAB_0017916a:
JMP 0x0017916c
LAB_0017916c:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [0x00d79f60]
JZ 0x001791bf
MOV RAX,qword ptr [0x00d79f60]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [0x00d79f60],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x70]
MOV qword ptr [RAX + 0x68],0x0
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[0xd79ef8]
MOV qword ptr [RAX + 0x70],RCX
MOV ECX,dword ptr [RBP + -0x2c]
MOV EAX,dword ptr [0x00d79fac]
SUB EAX,ECX
MOV dword ptr [0x00d79fac],EAX
LAB_001791bf:
JMP 0x001791c1
LAB_001791c1:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x10
LEA RSI,[0x2526c5]
MOV EDX,0x1d9
CALL 0x00178e20
CMP byte ptr [RBP + -0x9],0x0
JZ 0x001791f2
MOV RCX,qword ptr [0x00d79fc0]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x88],RCX
LAB_001791f2:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001793d0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x10
CALL 0x00178e90
MOVSX EAX,byte ptr [RBP + -0x9]
CMP EAX,0x0
JZ 0x00179267
LEA RAX,[0xd79d98]
CMP qword ptr [0x00d79d50],RAX
JZ 0x00179267
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0xd79e48]
MOV qword ptr [RAX + 0x68],RCX
MOV RCX,qword ptr [0x00d79eb8]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x70],RCX
MOV EAX,dword ptr [0x00d79fac]
ADD EAX,0x1
MOV dword ptr [0x00d79fac],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x70]
MOV qword ptr [RCX + 0x68],RAX
MOV qword ptr [0x00d79eb8],RAX
JMP 0x0017927b
LAB_00179267:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x68],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_0017927b:
MOV RAX,qword ptr [0x00d79d50]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [0x003be1d8],RAX
MOV RAX,qword ptr [0x003be1d0]
MOV RDI,qword ptr [RBP + -0x8]
MOV DL,byte ptr [RBP + -0x9]
LEA RCX,[0xd79d98]
CMP qword ptr [0x00d79d50],RCX
SETNZ CL
AND CL,0x1
MOVZX ECX,CL
MOVSX ESI,DL
MOVSX EDX,CL
CALL RAX
CMP AL,0x0
JZ 0x001792c8
MOV dword ptr [RBP + -0x10],0xffffffff
LAB_001792c8:
MOV EAX,dword ptr [0x00d79fa8]
ADD EAX,-0x1
MOV dword ptr [0x00d79fa8],EAX
JMP 0x001792d9
LAB_001792d9:
LEA RDI,[0xd7a090]
CALL 0x00178e90
MOV RCX,qword ptr [0x00d79ce0]
MOVZX EAX,word ptr [RBP + -0x12]
MOV EDX,EAX
MOV qword ptr [RBP + -0x40],0x0
MOV RAX,qword ptr [RBP + -0x40]
XCHG qword ptr [RCX + RDX*0x8],RAX
LAB_00179302:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00179345
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x68]
MOV qword ptr [RBP + -0x20],RAX
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x48]
ADD RDX,0x78
LEA RDI,[0xd79fc8]
MOV ECX,0x8
CALL 0x001fdb20
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x00178ef0
JMP 0x00179302
LAB_00179345:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001fc2f0
CMP dword ptr [RBP + -0x10],0x0
SETL AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x49],AL
MOV AL,byte ptr [RBP + -0x49]
ADD RSP,0x50
POP RBP
RET
|
bool trnman_end_trn(int8 *param_1,char param_2)
{
ushort uVar1;
int8 uVar2;
int8 *puVar3;
char cVar4;
long local_40;
int local_34;
int8 *local_28;
int local_18;
local_18 = 1;
uVar1 = *(ushort *)((long)param_1 + 0xac);
local_28 = (int8 *)0x0;
uVar2 = *param_1;
inline_mysql_mutex_lock
(LOCK_trn_list,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x1b9);
*(int8 *)(param_1[0xd] + 0x70) = param_1[0xe];
*(int8 *)(param_1[0xe] + 0x68) = param_1[0xd];
if ((int1 *)param_1[0xe] == active_list_min) {
local_34 = 0;
for (local_40 = committed_list_min._104_8_;
*(ulong *)(local_40 + 0x88) < *(ulong *)(active_list_min._104_8_ + 0x80);
local_40 = *(long *)(local_40 + 0x68)) {
local_34 = local_34 + 1;
}
if (local_40 != committed_list_min._104_8_) {
local_28 = (int8 *)committed_list_min._104_8_;
committed_list_min._104_8_ = local_40;
*(int8 *)(*(long *)(local_40 + 0x70) + 0x68) = 0;
*(int1 **)(local_40 + 0x70) = committed_list_min;
trnman_committed_transactions = trnman_committed_transactions - local_34;
}
}
inline_mysql_mutex_lock
(param_1 + 2,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x1d9);
if (param_2 != '\0') {
param_1[0x11] = global_trid_generator;
}
wt_thd_release_self(param_1);
inline_mysql_mutex_unlock(param_1 + 2);
if ((param_2 == '\0') || ((int1 *)active_list_min._104_8_ == active_list_max)) {
param_1[0xd] = local_28;
local_28 = param_1;
}
else {
param_1[0xd] = committed_list_max;
param_1[0xe] = committed_list_max._112_8_;
trnman_committed_transactions = trnman_committed_transactions + 1;
*(int8 **)(param_1[0xe] + 0x68) = param_1;
committed_list_max._112_8_ = param_1;
}
trid_min_read_from = *(int8 *)(active_list_min._104_8_ + 0x80);
cVar4 = (*(code *)trnman_end_trans_hook)
(param_1,(int)param_2,(int1 *)active_list_min._104_8_ != active_list_max);
if (cVar4 != '\0') {
local_18 = -1;
}
trnman_active_transactions = trnman_active_transactions + -1;
inline_mysql_mutex_unlock(LOCK_trn_list);
LOCK();
*(int8 *)(short_trid_to_active_trn + (ulong)uVar1 * 8) = 0;
UNLOCK();
while (local_28 != (int8 *)0x0) {
puVar3 = (int8 *)local_28[0xd];
lf_hash_delete(trid_to_trn,uVar2,local_28 + 0xf,8);
trnman_free_trn(local_28);
local_28 = puVar3;
}
lf_pinbox_put_pins(uVar2);
return local_18 < 0;
}
| |
32,142 | trnman_end_trn | eloqsql/storage/maria/trnman.c | my_bool trnman_end_trn(TRN *trn, my_bool commit)
{
int res= 1;
uint16 cached_short_id= trn->short_id; /* we have to cache it, see below */
TRN *free_me= 0;
LF_PINS *pins= trn->pins;
DBUG_ENTER("trnman_end_trn");
DBUG_PRINT("enter", ("trn: %p commit: %d", trn, commit));
/* if a rollback, all UNDO records should have been executed */
DBUG_ASSERT(commit || trn->undo_lsn == 0);
DBUG_ASSERT(trn != &dummy_transaction_object);
DBUG_ASSERT(trn->locked_tables == 0 && trn->used_instances == 0);
DBUG_PRINT("info", ("mysql_mutex_lock LOCK_trn_list"));
mysql_mutex_lock(&LOCK_trn_list);
/* remove from active list */
trn->next->prev= trn->prev;
trn->prev->next= trn->next;
/*
if trn was the oldest active transaction, now that it goes away there
may be committed transactions in the list which no active transaction
needs to bother about - clean up the committed list
*/
if (trn->prev == &active_list_min)
{
uint free_me_count;
TRN *t;
for (t= committed_list_min.next, free_me_count= 0;
t->commit_trid < active_list_min.next->min_read_from;
t= t->next, free_me_count++) /* no-op */;
DBUG_ASSERT((t != committed_list_min.next && free_me_count > 0) ||
(t == committed_list_min.next && free_me_count == 0));
/* found transactions committed before the oldest active one */
if (t != committed_list_min.next)
{
free_me= committed_list_min.next;
committed_list_min.next= t;
t->prev->next= 0;
t->prev= &committed_list_min;
trnman_committed_transactions-= free_me_count;
}
}
mysql_mutex_lock(&trn->state_lock);
if (commit)
trn->commit_trid= global_trid_generator;
wt_thd_release_self(trn);
mysql_mutex_unlock(&trn->state_lock);
/*
if transaction is committed and it was not the only active transaction -
add it to the committed list
*/
if (commit && active_list_min.next != &active_list_max)
{
trn->next= &committed_list_max;
trn->prev= committed_list_max.prev;
trnman_committed_transactions++;
committed_list_max.prev= trn->prev->next= trn;
}
else
{
trn->next= free_me;
free_me= trn;
}
trid_min_read_from= active_list_min.next->min_read_from;
if ((*trnman_end_trans_hook)(trn, commit,
active_list_min.next != &active_list_max))
res= -1;
trnman_active_transactions--;
DBUG_PRINT("info", ("mysql_mutex_unlock LOCK_trn_list"));
mysql_mutex_unlock(&LOCK_trn_list);
/*
the rest is done outside of a critical section
note that we don't own trn anymore, it may be in a shared list now.
Thus, we cannot dereference it, and must use cached_short_id below.
*/
my_atomic_storeptr((void **)&short_trid_to_active_trn[cached_short_id], 0);
/*
we, under the mutex, removed going-in-free_me transactions from the
active and committed lists, thus nobody else may see them when it scans
those lists, and thus nobody may want to free them. Now we don't
need a mutex to access free_me list
*/
/* QQ: send them to the purge thread */
while (free_me)
{
TRN *t= free_me;
free_me= free_me->next;
/* ignore OOM. it's harmless, and we can do nothing here anyway */
(void)lf_hash_delete(&trid_to_trn, pins, &t->trid, sizeof(TrID));
trnman_free_trn(t);
}
lf_hash_put_pins(pins);
DBUG_RETURN(res < 0);
} | O3 | c | trnman_end_trn:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r12d
movq %rdi, %r15
movzwl 0xac(%rdi), %r13d
movq (%rdi), %rbx
cmpq $0x0, 0xb9ea10(%rip) # 0xbff350
jne 0x60b38
leaq 0xb9e9c3(%rip), %rdi # 0xbff310
callq 0x29200
movq 0x68(%r15), %rax
movq 0x70(%r15), %rcx
movq %rcx, 0x70(%rax)
movq 0x68(%r15), %rax
movq %rax, 0x68(%rcx)
leaq 0xb9e5fb(%rip), %rax # 0xbfef68
cmpq %rax, 0x70(%r15)
movq %r13, -0x30(%rbp)
jne 0x609d4
movq 0xb9e652(%rip), %rax # 0xbfefd0
movq 0x80(%rax), %rdx
movq 0xb9e854(%rip), %r14 # 0xbff1e0
xorl %eax, %eax
cmpq %rdx, 0x88(%r14)
jae 0x609d4
movq %r14, %rcx
movq 0x68(%rcx), %rcx
decl %eax
cmpq %rdx, 0x88(%rcx)
jb 0x6099a
cmpq %r14, %rcx
je 0x609d4
movq %rcx, 0xb9e82b(%rip) # 0xbff1e0
leaq 0xb9e7bc(%rip), %rdx # 0xbff178
movq 0x70(%rcx), %rsi
movq $0x0, 0x68(%rsi)
movq %rdx, 0x70(%rcx)
addl %eax, 0xb9e85a(%rip) # 0xbff22c
jmp 0x609d7
xorl %r14d, %r14d
leaq 0x10(%r15), %r13
cmpq $0x0, 0x50(%r15)
jne 0x60b42
movq %r13, %rdi
callq 0x29200
testb %r12b, %r12b
je 0x60a01
movq 0xb9e846(%rip), %rax # 0xbff240
movq %rax, 0x88(%r15)
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x60a29
leaq 0x323697(%rip), %rax # 0x3840a8
leaq -0x40(%rbp), %rsi
movq %rax, 0x8(%rsi)
movq %r15, (%rsi)
callq 0xa7156
movq $0x0, 0x8(%r15)
movq 0x50(%r15), %rdi
testq %rdi, %rdi
jne 0x60b5b
movq %r13, %rdi
callq 0x291c0
leaq 0xb9e5d3(%rip), %rax # 0xbff018
testb %r12b, %r12b
je 0x60a7c
cmpq %rax, 0xb9e57f(%rip) # 0xbfefd0
je 0x60a7c
leaq 0xb9e66e(%rip), %rcx # 0xbff0c8
movq %rcx, 0x68(%r15)
movq 0xb9e6d3(%rip), %rcx # 0xbff138
movq %rcx, 0x70(%r15)
incl 0xb9e7bd(%rip) # 0xbff22c
movq %r15, 0x68(%rcx)
movq %r15, 0xb9e6be(%rip) # 0xbff138
jmp 0x60a83
movq %r14, 0x68(%r15)
movq %r15, %r14
movq -0x30(%rbp), %r13
movq 0xb9e542(%rip), %rcx # 0xbfefd0
movq 0x80(%rcx), %rdx
movq %rdx, 0x32373c(%rip) # 0x3841d8
xorl %edx, %edx
cmpq %rax, %rcx
setne %dl
movsbl %r12b, %esi
movq %r15, %rdi
callq *0x32371f(%rip) # 0x3841d0
decl 0xb9e771(%rip) # 0xbff228
movl %eax, %r15d
movq 0xb9e88f(%rip), %rdi # 0xbff350
testq %rdi, %rdi
jne 0x60b70
leaq 0xb9e83f(%rip), %rdi # 0xbff310
callq 0x291c0
movq 0xb9e483(%rip), %rax # 0xbfef60
xorl %ecx, %ecx
xchgq %rcx, (%rax,%r13,8)
testq %r14, %r14
je 0x60b17
leaq 0xb9e759(%rip), %r12 # 0xbff248
movq 0x68(%r14), %r13
leaq 0x78(%r14), %rdx
movq %r12, %rdi
movq %rbx, %rsi
movl $0x8, %ecx
callq 0x2f711
movq %r14, %rdi
callq 0x6089c
movq %r13, %r14
testq %r13, %r13
jne 0x60aef
testb %r15b, %r15b
setne %r14b
movq %rbx, %rdi
callq 0xa5517
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2cf9c
jmp 0x60952
leaq 0x79b7c(%rip), %rsi # 0xda6c5
movq %r13, %rdi
movl $0x1d9, %edx # imm = 0x1D9
callq 0x2eb6f
jmp 0x609ee
leaq 0x3254ae(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x60a36
leaq 0x325499(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x60aca
| trnman_end_trn:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12d, esi
mov r15, rdi
movzx r13d, word ptr [rdi+0ACh]
mov rbx, [rdi]
cmp cs:qword_BFF350, 0
jnz loc_60B38
lea rdi, LOCK_trn_list
call _pthread_mutex_lock
loc_60952:
mov rax, [r15+68h]
mov rcx, [r15+70h]
mov [rax+70h], rcx
mov rax, [r15+68h]
mov [rcx+68h], rax
lea rax, active_list_min
cmp [r15+70h], rax
mov [rbp+var_30], r13
jnz short loc_609D4
mov rax, cs:qword_BFEFD0
mov rdx, [rax+80h]
mov r14, cs:qword_BFF1E0
xor eax, eax
cmp [r14+88h], rdx
jnb short loc_609D4
mov rcx, r14
loc_6099A:
mov rcx, [rcx+68h]
dec eax
cmp [rcx+88h], rdx
jb short loc_6099A
cmp rcx, r14
jz short loc_609D4
mov cs:qword_BFF1E0, rcx
lea rdx, committed_list_min
mov rsi, [rcx+70h]
mov qword ptr [rsi+68h], 0
mov [rcx+70h], rdx
add cs:trnman_committed_transactions, eax
jmp short loc_609D7
loc_609D4:
xor r14d, r14d
loc_609D7:
lea r13, [r15+10h]
cmp qword ptr [r15+50h], 0
jnz loc_60B42
mov rdi, r13
call _pthread_mutex_lock
loc_609EE:
test r12b, r12b
jz short loc_60A01
mov rax, cs:global_trid_generator
mov [r15+88h], rax
loc_60A01:
mov rdi, [r15+8]
test rdi, rdi
jz short loc_60A29
lea rax, ma_rc_dup_unique
lea rsi, [rbp+var_40]
mov [rsi+8], rax
mov [rsi], r15
call wt_thd_release
mov qword ptr [r15+8], 0
loc_60A29:
mov rdi, [r15+50h]
test rdi, rdi
jnz loc_60B5B
loc_60A36:
mov rdi, r13
call _pthread_mutex_unlock
lea rax, active_list_max
test r12b, r12b
jz short loc_60A7C
cmp cs:qword_BFEFD0, rax
jz short loc_60A7C
lea rcx, committed_list_max
mov [r15+68h], rcx
mov rcx, cs:qword_BFF138
mov [r15+70h], rcx
inc cs:trnman_committed_transactions
mov [rcx+68h], r15
mov cs:qword_BFF138, r15
jmp short loc_60A83
loc_60A7C:
mov [r15+68h], r14
mov r14, r15
loc_60A83:
mov r13, [rbp+var_30]
mov rcx, cs:qword_BFEFD0
mov rdx, [rcx+80h]
mov cs:trid_min_read_from, rdx
xor edx, edx
cmp rcx, rax
setnz dl
movsx esi, r12b
mov rdi, r15
call cs:trnman_end_trans_hook
dec cs:trnman_active_transactions
mov r15d, eax
mov rdi, cs:qword_BFF350
test rdi, rdi
jnz loc_60B70
loc_60ACA:
lea rdi, LOCK_trn_list
call _pthread_mutex_unlock
mov rax, cs:short_trid_to_active_trn
xor ecx, ecx
xchg rcx, [rax+r13*8]
test r14, r14
jz short loc_60B17
lea r12, trid_to_trn
loc_60AEF:
mov r13, [r14+68h]
lea rdx, [r14+78h]
mov rdi, r12
mov rsi, rbx
mov ecx, 8
call lf_hash_delete
mov rdi, r14
call trnman_free_trn
mov r14, r13
test r13, r13
jnz short loc_60AEF
loc_60B17:
test r15b, r15b
setnz r14b
mov rdi, rbx
call lf_pinbox_put_pins
mov eax, r14d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_60B38:
call trnman_end_trn_cold_1
jmp loc_60952
loc_60B42:
lea rsi, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r13
mov edx, 1D9h
call psi_mutex_lock
jmp loc_609EE
loc_60B5B:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_60A36
loc_60B70:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_60ACA
| long long trnman_end_trn(long long a1, char a2)
{
long long v3; // r13
volatile long long *v4; // rbx
long long v5; // rcx
bool v6; // zf
unsigned long long v7; // rdx
signed long long v8; // r14
int v9; // eax
_QWORD *v10; // rcx
long long v11; // rdi
long long v12; // rcx
long long v13; // r13
volatile long long *v14; // rsi
char v15; // al
char v16; // r15
long long v17; // rdx
long long v18; // rcx
signed long long v19; // r13
_QWORD v21[2]; // [rsp+0h] [rbp-40h] BYREF
long long v22; // [rsp+10h] [rbp-30h]
v3 = *(unsigned __int16 *)(a1 + 172);
v4 = *(volatile long long **)a1;
if ( qword_BFF350 )
trnman_end_trn_cold_1();
else
pthread_mutex_lock(&LOCK_trn_list);
v5 = *(_QWORD *)(a1 + 112);
*(_QWORD *)(*(_QWORD *)(a1 + 104) + 112LL) = v5;
*(_QWORD *)(v5 + 104) = *(_QWORD *)(a1 + 104);
v6 = *(_QWORD *)(a1 + 112) == (_QWORD)&active_list_min;
v22 = v3;
if ( !v6 )
goto LABEL_9;
v7 = *(_QWORD *)(qword_BFEFD0 + 128);
v8 = qword_BFF1E0;
v9 = 0;
if ( *(_QWORD *)(qword_BFF1E0 + 136) >= v7 )
goto LABEL_9;
v10 = (_QWORD *)qword_BFF1E0;
do
{
v10 = (_QWORD *)v10[13];
--v9;
}
while ( v10[17] < v7 );
if ( v10 == (_QWORD *)qword_BFF1E0 )
{
LABEL_9:
v8 = 0LL;
}
else
{
qword_BFF1E0 = (long long)v10;
*(_QWORD *)(v10[14] + 104LL) = 0LL;
v10[14] = &committed_list_min;
trnman_committed_transactions += v9;
}
if ( *(_QWORD *)(a1 + 80) )
psi_mutex_lock(a1 + 16, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c", 0x1D9u);
else
pthread_mutex_lock(a1 + 16);
if ( a2 )
*(_QWORD *)(a1 + 136) = global_trid_generator;
v11 = *(_QWORD *)(a1 + 8);
if ( v11 )
{
v21[1] = &ma_rc_dup_unique;
v21[0] = a1;
wt_thd_release(v11, v21);
*(_QWORD *)(a1 + 8) = 0LL;
}
if ( *(_QWORD *)(a1 + 80) )
PSI_server[44]();
pthread_mutex_unlock(a1 + 16);
if ( !a2 || (_UNKNOWN *)qword_BFEFD0 == &active_list_max )
{
*(_QWORD *)(a1 + 104) = v8;
v8 = a1;
}
else
{
*(_QWORD *)(a1 + 104) = &committed_list_max;
v12 = qword_BFF138;
*(_QWORD *)(a1 + 112) = qword_BFF138;
++trnman_committed_transactions;
*(_QWORD *)(v12 + 104) = a1;
qword_BFF138 = a1;
}
v13 = v22;
trid_min_read_from = *(_QWORD *)(qword_BFEFD0 + 128);
v14 = (volatile long long *)(unsigned int)a2;
v15 = trnman_end_trans_hook();
--trnman_active_transactions;
v16 = v15;
if ( qword_BFF350 )
((void ( *)(long long, volatile long long *))PSI_server[44])(qword_BFF350, v14);
pthread_mutex_unlock(&LOCK_trn_list);
v18 = _InterlockedExchange64((volatile long long *)(short_trid_to_active_trn + 8 * v13), 0LL);
if ( v8 )
{
do
{
v19 = *(_QWORD *)(v8 + 104);
v14 = v4;
lf_hash_delete((long long)&trid_to_trn, v4, v8 + 120, 8u);
trnman_free_trn(v8);
v8 = v19;
}
while ( v19 );
}
LOBYTE(v8) = v16 != 0;
lf_pinbox_put_pins(v4, v14, v17, v18);
return (unsigned int)v8;
}
| trnman_end_trn:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12D,ESI
MOV R15,RDI
MOVZX R13D,word ptr [RDI + 0xac]
MOV RBX,qword ptr [RDI]
CMP qword ptr [0x00cff350],0x0
JNZ 0x00160b38
LEA RDI,[0xcff310]
CALL 0x00129200
LAB_00160952:
MOV RAX,qword ptr [R15 + 0x68]
MOV RCX,qword ptr [R15 + 0x70]
MOV qword ptr [RAX + 0x70],RCX
MOV RAX,qword ptr [R15 + 0x68]
MOV qword ptr [RCX + 0x68],RAX
LEA RAX,[0xcfef68]
CMP qword ptr [R15 + 0x70],RAX
MOV qword ptr [RBP + -0x30],R13
JNZ 0x001609d4
MOV RAX,qword ptr [0x00cfefd0]
MOV RDX,qword ptr [RAX + 0x80]
MOV R14,qword ptr [0x00cff1e0]
XOR EAX,EAX
CMP qword ptr [R14 + 0x88],RDX
JNC 0x001609d4
MOV RCX,R14
LAB_0016099a:
MOV RCX,qword ptr [RCX + 0x68]
DEC EAX
CMP qword ptr [RCX + 0x88],RDX
JC 0x0016099a
CMP RCX,R14
JZ 0x001609d4
MOV qword ptr [0x00cff1e0],RCX
LEA RDX,[0xcff178]
MOV RSI,qword ptr [RCX + 0x70]
MOV qword ptr [RSI + 0x68],0x0
MOV qword ptr [RCX + 0x70],RDX
ADD dword ptr [0x00cff22c],EAX
JMP 0x001609d7
LAB_001609d4:
XOR R14D,R14D
LAB_001609d7:
LEA R13,[R15 + 0x10]
CMP qword ptr [R15 + 0x50],0x0
JNZ 0x00160b42
MOV RDI,R13
CALL 0x00129200
LAB_001609ee:
TEST R12B,R12B
JZ 0x00160a01
MOV RAX,qword ptr [0x00cff240]
MOV qword ptr [R15 + 0x88],RAX
LAB_00160a01:
MOV RDI,qword ptr [R15 + 0x8]
TEST RDI,RDI
JZ 0x00160a29
LEA RAX,[0x4840a8]
LEA RSI,[RBP + -0x40]
MOV qword ptr [RSI + 0x8],RAX
MOV qword ptr [RSI],R15
CALL 0x001a7156
MOV qword ptr [R15 + 0x8],0x0
LAB_00160a29:
MOV RDI,qword ptr [R15 + 0x50]
TEST RDI,RDI
JNZ 0x00160b5b
LAB_00160a36:
MOV RDI,R13
CALL 0x001291c0
LEA RAX,[0xcff018]
TEST R12B,R12B
JZ 0x00160a7c
CMP qword ptr [0x00cfefd0],RAX
JZ 0x00160a7c
LEA RCX,[0xcff0c8]
MOV qword ptr [R15 + 0x68],RCX
MOV RCX,qword ptr [0x00cff138]
MOV qword ptr [R15 + 0x70],RCX
INC dword ptr [0x00cff22c]
MOV qword ptr [RCX + 0x68],R15
MOV qword ptr [0x00cff138],R15
JMP 0x00160a83
LAB_00160a7c:
MOV qword ptr [R15 + 0x68],R14
MOV R14,R15
LAB_00160a83:
MOV R13,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [0x00cfefd0]
MOV RDX,qword ptr [RCX + 0x80]
MOV qword ptr [0x004841d8],RDX
XOR EDX,EDX
CMP RCX,RAX
SETNZ DL
MOVSX ESI,R12B
MOV RDI,R15
CALL qword ptr [0x004841d0]
DEC dword ptr [0x00cff228]
MOV R15D,EAX
MOV RDI,qword ptr [0x00cff350]
TEST RDI,RDI
JNZ 0x00160b70
LAB_00160aca:
LEA RDI,[0xcff310]
CALL 0x001291c0
MOV RAX,qword ptr [0x00cfef60]
XOR ECX,ECX
XCHG qword ptr [RAX + R13*0x8],RCX
TEST R14,R14
JZ 0x00160b17
LEA R12,[0xcff248]
LAB_00160aef:
MOV R13,qword ptr [R14 + 0x68]
LEA RDX,[R14 + 0x78]
MOV RDI,R12
MOV RSI,RBX
MOV ECX,0x8
CALL 0x0012f711
MOV RDI,R14
CALL 0x0016089c
MOV R14,R13
TEST R13,R13
JNZ 0x00160aef
LAB_00160b17:
TEST R15B,R15B
SETNZ R14B
MOV RDI,RBX
CALL 0x001a5517
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00160b38:
CALL 0x0012cf9c
JMP 0x00160952
LAB_00160b42:
LEA RSI,[0x1da6c5]
MOV RDI,R13
MOV EDX,0x1d9
CALL 0x0012eb6f
JMP 0x001609ee
LAB_00160b5b:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00160a36
LAB_00160b70:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00160aca
|
bool trnman_end_trn(int8 *param_1,char param_2)
{
pthread_mutex_t *__mutex;
ushort uVar1;
int8 uVar2;
int8 *puVar3;
char cVar4;
int iVar5;
long lVar6;
int8 *puVar7;
uVar1 = *(ushort *)((long)param_1 + 0xac);
uVar2 = *param_1;
if (LOCK_trn_list._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)LOCK_trn_list);
}
else {
trnman_end_trn_cold_1();
}
lVar6 = param_1[0xe];
*(long *)(param_1[0xd] + 0x70) = lVar6;
*(int8 *)(lVar6 + 0x68) = param_1[0xd];
puVar7 = (int8 *)committed_list_min._104_8_;
if ((int1 *)param_1[0xe] == active_list_min) {
iVar5 = 0;
lVar6 = committed_list_min._104_8_;
if (*(ulong *)(committed_list_min._104_8_ + 0x88) < *(ulong *)(active_list_min._104_8_ + 0x80))
{
do {
lVar6 = *(long *)(lVar6 + 0x68);
iVar5 = iVar5 + -1;
} while (*(ulong *)(lVar6 + 0x88) < *(ulong *)(active_list_min._104_8_ + 0x80));
if (lVar6 != committed_list_min._104_8_) {
committed_list_min._104_8_ = lVar6;
*(int8 *)(*(long *)(lVar6 + 0x70) + 0x68) = 0;
*(int1 **)(lVar6 + 0x70) = committed_list_min;
trnman_committed_transactions = trnman_committed_transactions + iVar5;
goto LAB_001609d7;
}
}
}
puVar7 = (int8 *)0x0;
LAB_001609d7:
__mutex = (pthread_mutex_t *)(param_1 + 2);
if (param_1[10] == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x1d9);
}
if (param_2 != '\0') {
param_1[0x11] = global_trid_generator;
}
if (param_1[1] != 0) {
wt_thd_release();
param_1[1] = 0;
}
if (param_1[10] != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
if ((param_2 == '\0') || ((int1 *)active_list_min._104_8_ == active_list_max)) {
param_1[0xd] = puVar7;
puVar7 = param_1;
}
else {
param_1[0xd] = committed_list_max;
param_1[0xe] = committed_list_max._112_8_;
trnman_committed_transactions = trnman_committed_transactions + 1;
*(int8 **)(committed_list_max._112_8_ + 0x68) = param_1;
committed_list_max._112_8_ = param_1;
}
trid_min_read_from = *(int8 *)(active_list_min._104_8_ + 0x80);
cVar4 = (*(code *)trnman_end_trans_hook)
(param_1,(int)param_2,(int1 *)active_list_min._104_8_ != active_list_max);
trnman_active_transactions = trnman_active_transactions + -1;
if (LOCK_trn_list._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)LOCK_trn_list);
LOCK();
*(int8 *)(short_trid_to_active_trn + (ulong)uVar1 * 8) = 0;
UNLOCK();
while (puVar7 != (int8 *)0x0) {
puVar3 = (int8 *)puVar7[0xd];
lf_hash_delete(trid_to_trn,uVar2,puVar7 + 0xf,8);
trnman_free_trn(puVar7);
puVar7 = puVar3;
}
lf_pinbox_put_pins(uVar2);
return cVar4 != '\0';
}
| |
32,143 | host_call | corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_evmone.c | static void host_call(void* context, const struct evmone_message* msg, const uint8_t* code, size_t code_size, struct evmone_result* result) {
evmone_context_t* ctx = (evmone_context_t*) context;
EVM_LOG("========Executing child call...");
debug_print_address("call from", &msg->sender);
debug_print_address("call to", &msg->destination);
debug_print_address("code from", &msg->code_address);
EVM_LOG("call gas: %zu, depth: %d, is_static: %s", (size_t) msg->gas, msg->depth, msg->is_static ? "true" : "false");
if (bytes_all_zero(bytes(msg->code_address.bytes, 19)) && msg->code_address.bytes[19]) {
buffer_t output = {0};
uint64_t gas_used = 0;
pre_result_t pre_result = eth_execute_precompile(msg->code_address.bytes, bytes(msg->input_data, msg->input_size), &output, &gas_used);
result->output_data = output.data.data;
result->output_size = output.data.len;
result->gas_left = msg->gas - gas_used;
result->gas_refund = 0;
result->status_code = pre_result;
if (pre_result != PRE_SUCCESS) {
EVM_LOG("Precompile failed with status code: %d", pre_result);
result->gas_left = 0;
}
add_evm_result(ctx, result);
return;
}
// If code isn't provided (which happens during DELEGATECALL and CALLCODE),
// we need to fetch it from the account specified by code_address
const uint8_t* execution_code = code;
size_t execution_code_size = code_size;
bytes_t fetched_code = {0};
if ((execution_code == NULL || execution_code_size == 0) && msg->kind != CALL_KIND_CREATE && msg->kind != CALL_KIND_CREATE2) {
EVM_LOG("Code not provided, fetching from code_address");
fetched_code = get_code(ctx, msg->code_address.bytes);
execution_code = fetched_code.data;
execution_code_size = fetched_code.len;
EVM_LOG("Fetched code size: %zu bytes", execution_code_size);
}
EVM_LOG("call code size: %zu bytes", execution_code_size);
if (msg->input_data && msg->input_size > 0) {
EVM_LOG("call input data (%zu bytes): 0x", msg->input_size);
if (EVM_DEBUG) {
for (size_t i = 0; i < (msg->input_size > 64 ? 64 : msg->input_size); i++) {
fprintf(stderr, "%02x", msg->input_data[i]);
}
if (msg->input_size > 64) fprintf(stderr, "...");
fprintf(stderr, "\n");
}
}
evmone_context_t child = *ctx;
child.parent = ctx;
child.changed_accounts = NULL;
// Execute the code (now using fetched code if needed)
evmone_result exec_result = evmone_execute(
ctx->executor,
&host_interface,
&child,
14, // Revision - using CANCUN
msg,
execution_code,
execution_code_size);
EVM_LOG("Child call complete. Status: %d, Gas left: %zu", exec_result.status_code, (size_t) exec_result.gas_left);
if (exec_result.output_data && exec_result.output_size > 0) {
EVM_LOG("Child call output (%zu bytes): 0x", exec_result.output_size);
if (EVM_DEBUG) {
for (size_t i = 0; i < (exec_result.output_size > 64 ? 64 : exec_result.output_size); i++) {
fprintf(stderr, "%02x", exec_result.output_data[i]);
}
if (exec_result.output_size > 64) fprintf(stderr, "...");
fprintf(stderr, "\n");
}
}
add_evm_result(ctx, &exec_result);
if (exec_result.status_code == 0) {
context_apply(&child);
}
EVM_LOG("========/child call complete ====");
context_free(&child);
*result = exec_result;
} | O0 | c | host_call:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x2e189
movq -0x10(%rbp), %rsi
addq $0x2c, %rsi
leaq 0xaf845(%rip), %rdi # 0xdd9dd
callq 0x2db70
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq 0xaf83b(%rip), %rdi # 0xdd9e7
callq 0x2db70
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
leaq 0xaf82c(%rip), %rdi # 0xdd9ef
callq 0x2db70
jmp 0x2e1ca
movl $0x13, -0x40(%rbp)
movq -0x10(%rbp), %rax
addq $0x90, %rax
movq %rax, -0x38(%rbp)
movl -0x40(%rbp), %edi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x9e340
testb $0x1, %al
jne 0x2e1f6
jmp 0x2e2c5
movq -0x10(%rbp), %rax
movzbl 0xa3(%rax), %eax
cmpl $0x0, %eax
je 0x2e2c5
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x231c0
movq $0x0, -0x60(%rbp)
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl %eax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x70(%rbp)
movl -0x78(%rbp), %esi
movq -0x70(%rbp), %rdx
leaq -0x58(%rbp), %rcx
leaq -0x60(%rbp), %r8
callq 0x9d720
movl %eax, -0x64(%rbp)
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x58(%rbp), %eax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
subq -0x60(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movl -0x64(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x64(%rbp)
je 0x2e2b3
jmp 0x2e2a5
jmp 0x2e2a7
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2ed10
jmp 0x2e45b
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x231c0
cmpq $0x0, -0x80(%rbp)
je 0x2e2fc
cmpq $0x0, -0x88(%rbp)
jne 0x2e36b
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
je 0x2e36b
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
je 0x2e36b
jmp 0x2e310
jmp 0x2e312
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
callq 0x2d250
movl %eax, -0xa8(%rbp)
movq %rdx, -0xa0(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x98(%rbp), %eax
movq %rax, -0x88(%rbp)
jmp 0x2e369
jmp 0x2e36b
jmp 0x2e36d
jmp 0x2e36f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2e38b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jbe 0x2e38b
jmp 0x2e387
jmp 0x2e389
jmp 0x2e38b
movq -0x30(%rbp), %rsi
leaq -0x148(%rbp), %rdi
movl $0xa0, %edx
callq 0x230a0
movq -0x30(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq $0x0, -0x120(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %r9
movq -0x80(%rbp), %r10
movq -0x88(%rbp), %rax
leaq -0x188(%rbp), %rdi
leaq 0xf7666(%rip), %rdx # 0x125a40
leaq -0x148(%rbp), %rcx
movl $0xe, %r8d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x36ad0
jmp 0x2e3f7
cmpq $0x0, -0x170(%rbp)
je 0x2e411
cmpq $0x0, -0x168(%rbp)
jbe 0x2e411
jmp 0x2e40d
jmp 0x2e40f
jmp 0x2e411
movq -0x30(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x2ed10
cmpl $0x0, -0x188(%rbp)
jne 0x2e436
leaq -0x148(%rbp), %rdi
callq 0x2ed70
jmp 0x2e438
jmp 0x2e43a
leaq -0x148(%rbp), %rdi
callq 0x2d910
movq -0x28(%rbp), %rdi
leaq -0x188(%rbp), %rsi
movl $0x40, %edx
callq 0x230a0
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
| host_call:
push rbp
mov rbp, rsp
sub rsp, 1A0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_8]
mov [rbp+var_30], rax
jmp short $+2
loc_2E189:
mov rsi, [rbp+var_10]
add rsi, 2Ch ; ','
lea rdi, aCallFrom; "call from"
call debug_print_address
mov rsi, [rbp+var_10]
add rsi, 18h
lea rdi, aCallTo; "call to"
call debug_print_address
mov rsi, [rbp+var_10]
add rsi, 90h
lea rdi, aCodeFrom; "code from"
call debug_print_address
jmp short $+2
loc_2E1CA:
mov [rbp+var_40], 13h
mov rax, [rbp+var_10]
add rax, 90h
mov [rbp+var_38], rax
mov edi, [rbp+var_40]
mov rsi, [rbp+var_38]
xor edx, edx
call bytes_all_equal
test al, 1
jnz short loc_2E1F6
jmp loc_2E2C5
loc_2E1F6:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+0A3h]
cmp eax, 0
jz loc_2E2C5
lea rdi, [rbp+var_58]
xor esi, esi
mov edx, 18h
call _memset
mov [rbp+var_60], 0
mov rdi, [rbp+var_10]
add rdi, 90h
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov [rbp+var_78], eax
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov [rbp+var_70], rax
mov esi, [rbp+var_78]
mov rdx, [rbp+var_70]
lea rcx, [rbp+var_58]
lea r8, [rbp+var_60]
call eth_execute_precompile
mov [rbp+var_64], eax
mov rcx, [rbp+var_50]
mov rax, [rbp+var_28]
mov [rax+18h], rcx
mov eax, [rbp+var_58]
mov ecx, eax
mov rax, [rbp+var_28]
mov [rax+20h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
sub rcx, [rbp+var_60]
mov rax, [rbp+var_28]
mov [rax+8], rcx
mov rax, [rbp+var_28]
mov qword ptr [rax+10h], 0
mov ecx, [rbp+var_64]
mov rax, [rbp+var_28]
mov [rax], ecx
cmp [rbp+var_64], 0
jz short loc_2E2B3
jmp short $+2
loc_2E2A5:
jmp short $+2
loc_2E2A7:
mov rax, [rbp+var_28]
mov qword ptr [rax+8], 0
loc_2E2B3:
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_28]
call add_evm_result
jmp loc_2E45B
loc_2E2C5:
mov rax, [rbp+var_18]
mov [rbp+var_80], rax
mov rax, [rbp+var_20]
mov [rbp+var_88], rax
lea rdi, [rbp+var_98]
xor esi, esi
mov edx, 10h
call _memset
cmp [rbp+var_80], 0
jz short loc_2E2FC
cmp [rbp+var_88], 0
jnz short loc_2E36B
loc_2E2FC:
mov rax, [rbp+var_10]
cmp dword ptr [rax], 3
jz short loc_2E36B
mov rax, [rbp+var_10]
cmp dword ptr [rax], 4
jz short loc_2E36B
jmp short $+2
loc_2E310:
jmp short $+2
loc_2E312:
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_10]
add rsi, 90h
call get_code
mov dword ptr [rbp+var_A8], eax
mov [rbp+var_A0], rdx
mov rax, [rbp+var_A8]
mov [rbp+var_98], rax
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
mov rax, [rbp+var_90]
mov [rbp+var_80], rax
mov eax, dword ptr [rbp+var_98]
mov [rbp+var_88], rax
jmp short $+2
loc_2E369:
jmp short $+2
loc_2E36B:
jmp short $+2
loc_2E36D:
jmp short $+2
loc_2E36F:
mov rax, [rbp+var_10]
cmp qword ptr [rax+40h], 0
jz short loc_2E38B
mov rax, [rbp+var_10]
cmp qword ptr [rax+48h], 0
jbe short loc_2E38B
jmp short $+2
loc_2E387:
jmp short $+2
loc_2E389:
jmp short $+2
loc_2E38B:
mov rsi, [rbp+var_30]
lea rdi, [rbp+var_148]
mov edx, 0A0h
call _memcpy
mov rax, [rbp+var_30]
mov [rbp+var_B8], rax
mov [rbp+var_120], 0
mov rax, [rbp+var_30]
mov rsi, [rax]
mov r9, [rbp+var_10]
mov r10, [rbp+var_80]
mov rax, [rbp+var_88]
lea rdi, [rbp+var_188]
lea rdx, host_interface
lea rcx, [rbp+var_148]
mov r8d, 0Eh
mov [rsp+1A0h+var_1A0], r10
mov [rsp+1A0h+var_198], rax
call evmone_execute
jmp short $+2
loc_2E3F7:
cmp [rbp+var_170], 0
jz short loc_2E411
cmp [rbp+var_168], 0
jbe short loc_2E411
jmp short $+2
loc_2E40D:
jmp short $+2
loc_2E40F:
jmp short $+2
loc_2E411:
mov rdi, [rbp+var_30]
lea rsi, [rbp+var_188]
call add_evm_result
cmp [rbp+var_188], 0
jnz short loc_2E436
lea rdi, [rbp+var_148]
call context_apply
loc_2E436:
jmp short $+2
loc_2E438:
jmp short $+2
loc_2E43A:
lea rdi, [rbp+var_148]
call context_free
mov rdi, [rbp+var_28]
lea rsi, [rbp+var_188]
mov edx, 40h ; '@'
call _memcpy
loc_2E45B:
add rsp, 1A0h
pop rbp
retn
| long long host_call(_QWORD *a1, long long a2, long long a3, long long a4, long long a5)
{
long long v6; // rdx
_DWORD v7[6]; // [rsp+18h] [rbp-188h] BYREF
_BYTE v8[40]; // [rsp+58h] [rbp-148h] BYREF
long long v9; // [rsp+80h] [rbp-120h]
_QWORD *v10; // [rsp+E8h] [rbp-B8h]
long long v11; // [rsp+F8h] [rbp-A8h]
long long v12; // [rsp+100h] [rbp-A0h]
_QWORD v13[2]; // [rsp+108h] [rbp-98h] BYREF
long long v14; // [rsp+118h] [rbp-88h]
long long v15; // [rsp+120h] [rbp-80h]
unsigned int v16; // [rsp+128h] [rbp-78h]
long long v17; // [rsp+130h] [rbp-70h]
int v18; // [rsp+13Ch] [rbp-64h]
long long v19; // [rsp+140h] [rbp-60h] BYREF
unsigned int v20; // [rsp+148h] [rbp-58h] BYREF
long long v21; // [rsp+150h] [rbp-50h]
int v22; // [rsp+160h] [rbp-40h]
long long v23; // [rsp+168h] [rbp-38h]
_QWORD *v24; // [rsp+170h] [rbp-30h]
long long v25; // [rsp+178h] [rbp-28h]
long long v26; // [rsp+180h] [rbp-20h]
long long v27; // [rsp+188h] [rbp-18h]
long long v28; // [rsp+190h] [rbp-10h]
_QWORD *v29; // [rsp+198h] [rbp-8h]
v29 = a1;
v28 = a2;
v27 = a3;
v26 = a4;
v25 = a5;
v24 = a1;
debug_print_address();
debug_print_address();
debug_print_address();
v22 = 19;
v23 = a2 + 144;
if ( (bytes_all_equal(19LL, a2 + 144, 0LL) & 1) != 0 && *(_BYTE *)(v28 + 163) )
{
memset(&v20, 0LL, 24LL);
v19 = 0LL;
v16 = *(_QWORD *)(v28 + 72);
v17 = *(_QWORD *)(v28 + 64);
v18 = eth_execute_precompile(v28 + 144, v16, v17, &v20, &v19);
*(_QWORD *)(v25 + 24) = v21;
*(_QWORD *)(v25 + 32) = v20;
*(_QWORD *)(v25 + 8) = *(_QWORD *)(v28 + 16) - v19;
*(_QWORD *)(v25 + 16) = 0LL;
*(_DWORD *)v25 = v18;
if ( v18 )
*(_QWORD *)(v25 + 8) = 0LL;
return add_evm_result(v24, v25);
}
else
{
v15 = v27;
v14 = v26;
memset(v13, 0LL, sizeof(v13));
if ( (!v15 || !v14) && *(_DWORD *)v28 != 3 && *(_DWORD *)v28 != 4 )
{
LODWORD(v11) = get_code((long long)v24, v28 + 144);
v12 = v6;
v13[0] = v11;
v13[1] = v6;
v15 = v6;
v14 = (unsigned int)v11;
}
memcpy(v8, v24, 160LL);
v10 = v24;
v9 = 0LL;
evmone_execute((unsigned int)v7, *v24, (unsigned int)host_interface, (unsigned int)v8, 14, v28, v15, v14);
add_evm_result(v24, v7);
if ( !v7[0] )
context_apply(v8);
context_free((long long)v8);
return memcpy(v25, v7, 64LL);
}
}
| host_call:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1a0
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0012e189
LAB_0012e189:
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x2c
LEA RDI,[0x1dd9dd]
CALL 0x0012db70
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x18
LEA RDI,[0x1dd9e7]
CALL 0x0012db70
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x90
LEA RDI,[0x1dd9ef]
CALL 0x0012db70
JMP 0x0012e1ca
LAB_0012e1ca:
MOV dword ptr [RBP + -0x40],0x13
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x90
MOV qword ptr [RBP + -0x38],RAX
MOV EDI,dword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x38]
XOR EDX,EDX
CALL 0x0019e340
TEST AL,0x1
JNZ 0x0012e1f6
JMP 0x0012e2c5
LAB_0012e1f6:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0xa3]
CMP EAX,0x0
JZ 0x0012e2c5
LEA RDI,[RBP + -0x58]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x001231c0
MOV qword ptr [RBP + -0x60],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x90
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV dword ptr [RBP + -0x78],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RBP + -0x70],RAX
MOV ESI,dword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x70]
LEA RCX,[RBP + -0x58]
LEA R8,[RBP + -0x60]
CALL 0x0019d720
MOV dword ptr [RBP + -0x64],EAX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x18],RCX
MOV EAX,dword ptr [RBP + -0x58]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x10],0x0
MOV ECX,dword ptr [RBP + -0x64]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],ECX
CMP dword ptr [RBP + -0x64],0x0
JZ 0x0012e2b3
JMP 0x0012e2a5
LAB_0012e2a5:
JMP 0x0012e2a7
LAB_0012e2a7:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x8],0x0
LAB_0012e2b3:
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x0012ed10
JMP 0x0012e45b
LAB_0012e2c5:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x88],RAX
LEA RDI,[RBP + -0x98]
XOR ESI,ESI
MOV EDX,0x10
CALL 0x001231c0
CMP qword ptr [RBP + -0x80],0x0
JZ 0x0012e2fc
CMP qword ptr [RBP + -0x88],0x0
JNZ 0x0012e36b
LAB_0012e2fc:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX],0x3
JZ 0x0012e36b
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX],0x4
JZ 0x0012e36b
JMP 0x0012e310
LAB_0012e310:
JMP 0x0012e312
LAB_0012e312:
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x90
CALL 0x0012d250
MOV dword ptr [RBP + -0xa8],EAX
MOV qword ptr [RBP + -0xa0],RDX
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x80],RAX
MOV EAX,dword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x88],RAX
JMP 0x0012e369
LAB_0012e369:
JMP 0x0012e36b
LAB_0012e36b:
JMP 0x0012e36d
LAB_0012e36d:
JMP 0x0012e36f
LAB_0012e36f:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x40],0x0
JZ 0x0012e38b
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x48],0x0
JBE 0x0012e38b
JMP 0x0012e387
LAB_0012e387:
JMP 0x0012e389
LAB_0012e389:
JMP 0x0012e38b
LAB_0012e38b:
MOV RSI,qword ptr [RBP + -0x30]
LEA RDI,[RBP + -0x148]
MOV EDX,0xa0
CALL 0x001230a0
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0xb8],RAX
MOV qword ptr [RBP + -0x120],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RAX]
MOV R9,qword ptr [RBP + -0x10]
MOV R10,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RBP + -0x88]
LEA RDI,[RBP + -0x188]
LEA RDX,[0x225a40]
LEA RCX,[RBP + -0x148]
MOV R8D,0xe
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00136ad0
JMP 0x0012e3f7
LAB_0012e3f7:
CMP qword ptr [RBP + -0x170],0x0
JZ 0x0012e411
CMP qword ptr [RBP + -0x168],0x0
JBE 0x0012e411
JMP 0x0012e40d
LAB_0012e40d:
JMP 0x0012e40f
LAB_0012e40f:
JMP 0x0012e411
LAB_0012e411:
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[RBP + -0x188]
CALL 0x0012ed10
CMP dword ptr [RBP + -0x188],0x0
JNZ 0x0012e436
LEA RDI,[RBP + -0x148]
CALL 0x0012ed70
LAB_0012e436:
JMP 0x0012e438
LAB_0012e438:
JMP 0x0012e43a
LAB_0012e43a:
LEA RDI,[RBP + -0x148]
CALL 0x0012d910
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x188]
MOV EDX,0x40
CALL 0x001230a0
LAB_0012e45b:
ADD RSP,0x1a0
POP RBP
RET
|
void host_call(int8 *param_1,int *param_2,long param_3,ulong param_4,int *param_5)
{
ulong uVar1;
long extraout_RDX;
int local_190 [16];
int1 local_150 [40];
int8 local_128;
int8 *local_c0;
uint local_b0;
int4 uStack_ac;
long local_a8;
int8 local_a0;
long local_98;
ulong local_90;
long local_88;
int4 local_80;
int8 local_78;
int local_6c;
long local_68;
uint local_60 [2];
int8 local_58;
int4 local_48;
int *local_40;
int8 *local_38;
int *local_30;
ulong local_28;
long local_20;
int *local_18;
int8 *local_10;
local_38 = param_1;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
debug_print_address("call from",param_2 + 0xb);
debug_print_address("call to",local_18 + 6);
debug_print_address("code from",local_18 + 0x24);
local_48 = 0x13;
local_40 = local_18 + 0x24;
uVar1 = bytes_all_equal(0x13,local_40,0);
if (((uVar1 & 1) == 0) || (*(char *)((long)local_18 + 0xa3) == '\0')) {
local_88 = local_20;
local_90 = local_28;
memset(&local_a0,0,0x10);
if (((local_88 == 0) || (local_90 == 0)) && ((*local_18 != 3 && (*local_18 != 4)))) {
local_b0 = get_code(local_38,local_18 + 0x24);
local_a0 = CONCAT44(uStack_ac,local_b0);
local_90 = (ulong)local_b0;
local_a8 = extraout_RDX;
local_98 = extraout_RDX;
local_88 = extraout_RDX;
}
memcpy(local_150,local_38,0xa0);
local_c0 = local_38;
local_128 = 0;
evmone_execute(local_190,*local_38,host_interface,local_150,0xe,local_18,local_88,local_90);
add_evm_result(local_38,local_190);
if (local_190[0] == 0) {
context_apply(local_150);
}
context_free(local_150);
memcpy(local_30,local_190,0x40);
}
else {
memset(local_60,0,0x18);
local_68 = 0;
local_80 = (int4)*(ulong *)(local_18 + 0x12);
local_78 = *(int8 *)(local_18 + 0x10);
local_6c = eth_execute_precompile
(local_18 + 0x24,*(ulong *)(local_18 + 0x12) & 0xffffffff,local_78,local_60
,&local_68);
*(int8 *)(local_30 + 6) = local_58;
*(ulong *)(local_30 + 8) = (ulong)local_60[0];
*(long *)(local_30 + 2) = *(long *)(local_18 + 4) - local_68;
local_30[4] = 0;
local_30[5] = 0;
*local_30 = local_6c;
if (local_6c != 0) {
local_30[2] = 0;
local_30[3] = 0;
}
add_evm_result(local_38,local_30);
}
return;
}
| |
32,144 | host_call | corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_evmone.c | static void host_call(void* context, const struct evmone_message* msg, const uint8_t* code, size_t code_size, struct evmone_result* result) {
evmone_context_t* ctx = (evmone_context_t*) context;
EVM_LOG("========Executing child call...");
debug_print_address("call from", &msg->sender);
debug_print_address("call to", &msg->destination);
debug_print_address("code from", &msg->code_address);
EVM_LOG("call gas: %zu, depth: %d, is_static: %s", (size_t) msg->gas, msg->depth, msg->is_static ? "true" : "false");
if (bytes_all_zero(bytes(msg->code_address.bytes, 19)) && msg->code_address.bytes[19]) {
buffer_t output = {0};
uint64_t gas_used = 0;
pre_result_t pre_result = eth_execute_precompile(msg->code_address.bytes, bytes(msg->input_data, msg->input_size), &output, &gas_used);
result->output_data = output.data.data;
result->output_size = output.data.len;
result->gas_left = msg->gas - gas_used;
result->gas_refund = 0;
result->status_code = pre_result;
if (pre_result != PRE_SUCCESS) {
EVM_LOG("Precompile failed with status code: %d", pre_result);
result->gas_left = 0;
}
add_evm_result(ctx, result);
return;
}
// If code isn't provided (which happens during DELEGATECALL and CALLCODE),
// we need to fetch it from the account specified by code_address
const uint8_t* execution_code = code;
size_t execution_code_size = code_size;
bytes_t fetched_code = {0};
if ((execution_code == NULL || execution_code_size == 0) && msg->kind != CALL_KIND_CREATE && msg->kind != CALL_KIND_CREATE2) {
EVM_LOG("Code not provided, fetching from code_address");
fetched_code = get_code(ctx, msg->code_address.bytes);
execution_code = fetched_code.data;
execution_code_size = fetched_code.len;
EVM_LOG("Fetched code size: %zu bytes", execution_code_size);
}
EVM_LOG("call code size: %zu bytes", execution_code_size);
if (msg->input_data && msg->input_size > 0) {
EVM_LOG("call input data (%zu bytes): 0x", msg->input_size);
if (EVM_DEBUG) {
for (size_t i = 0; i < (msg->input_size > 64 ? 64 : msg->input_size); i++) {
fprintf(stderr, "%02x", msg->input_data[i]);
}
if (msg->input_size > 64) fprintf(stderr, "...");
fprintf(stderr, "\n");
}
}
evmone_context_t child = *ctx;
child.parent = ctx;
child.changed_accounts = NULL;
// Execute the code (now using fetched code if needed)
evmone_result exec_result = evmone_execute(
ctx->executor,
&host_interface,
&child,
14, // Revision - using CANCUN
msg,
execution_code,
execution_code_size);
EVM_LOG("Child call complete. Status: %d, Gas left: %zu", exec_result.status_code, (size_t) exec_result.gas_left);
if (exec_result.output_data && exec_result.output_size > 0) {
EVM_LOG("Child call output (%zu bytes): 0x", exec_result.output_size);
if (EVM_DEBUG) {
for (size_t i = 0; i < (exec_result.output_size > 64 ? 64 : exec_result.output_size); i++) {
fprintf(stderr, "%02x", exec_result.output_data[i]);
}
if (exec_result.output_size > 64) fprintf(stderr, "...");
fprintf(stderr, "\n");
}
}
add_evm_result(ctx, &exec_result);
if (exec_result.status_code == 0) {
context_apply(&child);
}
EVM_LOG("========/child call complete ====");
context_free(&child);
*result = exec_result;
} | O2 | c | host_call:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
leaq 0x90(%rsi), %rbp
pushq $0x13
popq %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x4b20e
testb %al, %al
je 0x296d9
cmpb $0x0, 0xa3(%r15)
je 0x296d9
leaq 0x50(%rsp), %r12
andq $0x0, 0x10(%r12)
leaq 0x10(%rsp), %r13
andq $0x0, (%r13)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
movl 0x48(%r15), %esi
movq 0x40(%r15), %rdx
movq %rbp, %rdi
movq %r12, %rcx
movq %r13, %r8
callq 0x4ae82
movq 0x8(%r12), %rcx
movq %rcx, 0x18(%rbx)
movl (%r12), %ecx
movq %rcx, 0x20(%rbx)
movq 0x10(%r15), %rcx
subq (%r13), %rcx
movq %rcx, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movl %eax, (%rbx)
testl %eax, %eax
je 0x296c9
andq $0x0, 0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29adf
jmp 0x29821
testq %r12, %r12
setne %al
testq %r13, %r13
setne %cl
testb %cl, %al
movq %rbx, 0x8(%rsp)
jne 0x2970a
movl (%r15), %eax
addl $-0x3, %eax
cmpl $0x2, %eax
jb 0x2970a
movq %r14, %rdi
movq %rbp, %rsi
callq 0x28fca
movq %rdx, %r12
movl %eax, %r13d
leaq 0x50(%rsp), %rbp
movl $0xa0, %edx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x22090
movq %r14, 0x90(%rbp)
andq $0x0, 0x28(%rbp)
movq (%r14), %rsi
leaq 0x7f46b(%rip), %rdx # 0xa8ba0
leaq 0x10(%rsp), %rbx
pushq $0xe
popq %r8
movq %rbx, %rdi
movq %rbp, %rcx
movq %r15, %r9
pushq %r13
pushq %r12
callq 0x2e25f
popq %rax
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29adf
cmpl $0x0, (%rbx)
movq 0x8(%rsp), %rbx
jne 0x297f4
cmpq $0x0, 0xe0(%rsp)
je 0x297f4
leaq 0x78(%rsp), %r14
leaq 0x7(%rsp), %r15
movq (%r14), %r14
testq %r14, %r14
je 0x297f4
movq 0xe0(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x29937
movups 0x14(%r14), %xmm0
movups 0x24(%r14), %xmm1
movups %xmm1, 0x24(%rax)
movups %xmm0, 0x14(%rax)
movups 0x38(%r14), %xmm0
movups %xmm0, 0x38(%rax)
movb 0x59(%r14), %cl
movb %cl, 0x59(%rax)
leaq 0x50(%r14), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x297ee
movq 0xe0(%rsp), %rdi
leaq 0x20(%r12), %rcx
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %r8
movq %r15, %r9
callq 0x2989a
addq $0x40, %r12
jmp 0x297c1
addq $0x48, %r14
jmp 0x29780
leaq 0x50(%rsp), %rdi
callq 0x290bf
movups 0x10(%rsp), %xmm0
movups 0x20(%rsp), %xmm1
movups 0x30(%rsp), %xmm2
movups 0x40(%rsp), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| host_call:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov rbx, r8
mov r13, rcx
mov r12, rdx
mov r15, rsi
mov r14, rdi
lea rbp, [rsi+90h]
push 13h
pop rdi
mov rsi, rbp
xor edx, edx
call bytes_all_equal
test al, al
jz short loc_296D9
cmp byte ptr [r15+0A3h], 0
jz short loc_296D9
lea r12, [rsp+128h+var_D8]
and qword ptr [r12+10h], 0
lea r13, [rsp+128h+var_118]
and qword ptr [r13+0], 0
xorps xmm0, xmm0
movaps xmmword ptr [r12], xmm0
mov esi, [r15+48h]
mov rdx, [r15+40h]
mov rdi, rbp
mov rcx, r12
mov r8, r13
call eth_execute_precompile
mov rcx, [r12+8]
mov [rbx+18h], rcx
mov ecx, [r12]
mov [rbx+20h], rcx
mov rcx, [r15+10h]
sub rcx, [r13+0]
mov [rbx+8], rcx
and qword ptr [rbx+10h], 0
mov [rbx], eax
test eax, eax
jz short loc_296C9
and qword ptr [rbx+8], 0
loc_296C9:
mov rdi, r14
mov rsi, rbx
call add_evm_result
jmp loc_29821
loc_296D9:
test r12, r12
setnz al
test r13, r13
setnz cl
test al, cl
mov [rsp+128h+var_120], rbx
jnz short loc_2970A
mov eax, [r15]
add eax, 0FFFFFFFDh
cmp eax, 2
jb short loc_2970A
mov rdi, r14
mov rsi, rbp
call get_code
mov r12, rdx
mov r13d, eax
loc_2970A:
lea rbp, [rsp+128h+var_D8]
mov edx, 0A0h
mov rdi, rbp
mov rsi, r14
call _memcpy
mov [rbp+90h], r14
and qword ptr [rbp+28h], 0
mov rsi, [r14]
lea rdx, host_interface
lea rbx, [rsp+128h+var_118]
push 0Eh
pop r8
mov rdi, rbx
mov rcx, rbp
mov r9, r15
push r13
push r12
call evmone_execute
pop rax
pop rcx
mov rdi, r14
mov rsi, rbx
call add_evm_result
cmp dword ptr [rbx], 0
mov rbx, [rsp+128h+var_120]
jnz loc_297F4
cmp [rsp+128h+var_48], 0
jz short loc_297F4
lea r14, [rsp+128h+var_B0]
lea r15, [rsp+128h+var_121]
loc_29780:
mov r14, [r14]
test r14, r14
jz short loc_297F4
mov rdi, [rsp+128h+var_48]
mov rsi, r14
mov rdx, r15
call create_changed_account
movups xmm0, xmmword ptr [r14+14h]
movups xmm1, xmmword ptr [r14+24h]
movups xmmword ptr [rax+24h], xmm1
movups xmmword ptr [rax+14h], xmm0
movups xmm0, xmmword ptr [r14+38h]
movups xmmword ptr [rax+38h], xmm0
mov cl, [r14+59h]
mov [rax+59h], cl
lea r12, [r14+50h]
loc_297C1:
mov r12, [r12]
test r12, r12
jz short loc_297EE
mov rdi, [rsp+128h+var_48]
lea rcx, [r12+20h]
mov rsi, r14
mov rdx, r12
mov r8, r15
mov r9, r15
call set_changed_storage
add r12, 40h ; '@'
jmp short loc_297C1
loc_297EE:
add r14, 48h ; 'H'
jmp short loc_29780
loc_297F4:
lea rdi, [rsp+128h+var_D8]
call context_free
movups xmm0, [rsp+128h+var_118]
movups xmm1, [rsp+128h+var_108]
movups xmm2, [rsp+128h+var_F8]
movups xmm3, [rsp+128h+var_E8]
movups xmmword ptr [rbx+30h], xmm3
movups xmmword ptr [rbx+20h], xmm2
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
loc_29821:
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long host_call(_QWORD *a1, long long a2, long long a3, long long a4, long long a5)
{
long long v8; // rbp
long long v9; // rcx
int v10; // eax
long long result; // rax
unsigned int code; // eax
long long v13; // rdx
_OWORD *v14; // rbx
long long *i; // r14
long long v16; // r14
long long v17; // rax
__int128 v18; // xmm0
long long *j; // r12
long long v20; // r12
__int128 v21; // xmm0
__int128 v22; // xmm1
__int128 v23; // xmm2
__int128 v24; // [rsp-10h] [rbp-138h]
char v25; // [rsp+7h] [rbp-121h] BYREF
_OWORD *v26; // [rsp+8h] [rbp-120h]
_OWORD v27[4]; // [rsp+10h] [rbp-118h] BYREF
__int128 v28; // [rsp+50h] [rbp-D8h] BYREF
long long v29; // [rsp+60h] [rbp-C8h]
long long v30; // [rsp+78h] [rbp-B0h] BYREF
_QWORD *v31; // [rsp+E0h] [rbp-48h]
v8 = a2 + 144;
if ( (unsigned __int8)bytes_all_equal(19LL, a2 + 144, 0LL) && *(_BYTE *)(a2 + 163) )
{
v29 = 0LL;
*(_QWORD *)&v27[0] = 0LL;
v28 = 0LL;
v10 = eth_execute_precompile(v8, *(unsigned int *)(a2 + 72), *(_QWORD *)(a2 + 64), &v28, v27);
*(_QWORD *)(a5 + 24) = *((_QWORD *)&v28 + 1);
*(_QWORD *)(a5 + 32) = (unsigned int)v28;
*(_QWORD *)(a5 + 8) = *(_QWORD *)(a2 + 16) - *(_QWORD *)&v27[0];
*(_QWORD *)(a5 + 16) = 0LL;
*(_DWORD *)a5 = v10;
if ( v10 )
*(_QWORD *)(a5 + 8) = 0LL;
return add_evm_result(a1, a5);
}
else
{
LOBYTE(v9) = a4 != 0;
v26 = (_OWORD *)a5;
if ( (a4 == 0 || a3 == 0) && (unsigned int)(*(_DWORD *)a2 - 3) >= 2 )
{
code = get_code((long long)a1, v8);
a3 = v13;
a4 = code;
}
memcpy(&v28, a1, 160LL, v9);
v31 = a1;
v30 = 0LL;
*((_QWORD *)&v24 + 1) = a4;
*(_QWORD *)&v24 = a3;
evmone_execute((unsigned int)v27, *a1, (unsigned int)host_interface, (unsigned int)&v28, 14, a2, v24);
add_evm_result(a1, v27);
v14 = v26;
if ( !LODWORD(v27[0]) && v31 )
{
for ( i = &v30; ; i = (long long *)(v16 + 72) )
{
v16 = *i;
if ( !v16 )
break;
v17 = create_changed_account(v31, v16, &v25);
v18 = *(_OWORD *)(v16 + 20);
*(_OWORD *)(v17 + 36) = *(_OWORD *)(v16 + 36);
*(_OWORD *)(v17 + 20) = v18;
*(_OWORD *)(v17 + 56) = *(_OWORD *)(v16 + 56);
*(_BYTE *)(v17 + 89) = *(_BYTE *)(v16 + 89);
for ( j = (long long *)(v16 + 80); ; j = (long long *)(v20 + 64) )
{
v20 = *j;
if ( !v20 )
break;
set_changed_storage(v31, v16, v20, v20 + 32, &v25, &v25);
}
}
}
result = context_free((long long)&v28);
v21 = v27[0];
v22 = v27[1];
v23 = v27[2];
v14[3] = v27[3];
v14[2] = v23;
v14[1] = v22;
*v14 = v21;
}
return result;
}
| host_call:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV RBX,R8
MOV R13,RCX
MOV R12,RDX
MOV R15,RSI
MOV R14,RDI
LEA RBP,[RSI + 0x90]
PUSH 0x13
POP RDI
MOV RSI,RBP
XOR EDX,EDX
CALL 0x0014b20e
TEST AL,AL
JZ 0x001296d9
CMP byte ptr [R15 + 0xa3],0x0
JZ 0x001296d9
LEA R12,[RSP + 0x50]
AND qword ptr [R12 + 0x10],0x0
LEA R13,[RSP + 0x10]
AND qword ptr [R13],0x0
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R12],XMM0
MOV ESI,dword ptr [R15 + 0x48]
MOV RDX,qword ptr [R15 + 0x40]
MOV RDI,RBP
MOV RCX,R12
MOV R8,R13
CALL 0x0014ae82
MOV RCX,qword ptr [R12 + 0x8]
MOV qword ptr [RBX + 0x18],RCX
MOV ECX,dword ptr [R12]
MOV qword ptr [RBX + 0x20],RCX
MOV RCX,qword ptr [R15 + 0x10]
SUB RCX,qword ptr [R13]
MOV qword ptr [RBX + 0x8],RCX
AND qword ptr [RBX + 0x10],0x0
MOV dword ptr [RBX],EAX
TEST EAX,EAX
JZ 0x001296c9
AND qword ptr [RBX + 0x8],0x0
LAB_001296c9:
MOV RDI,R14
MOV RSI,RBX
CALL 0x00129adf
JMP 0x00129821
LAB_001296d9:
TEST R12,R12
SETNZ AL
TEST R13,R13
SETNZ CL
TEST AL,CL
MOV qword ptr [RSP + 0x8],RBX
JNZ 0x0012970a
MOV EAX,dword ptr [R15]
ADD EAX,-0x3
CMP EAX,0x2
JC 0x0012970a
MOV RDI,R14
MOV RSI,RBP
CALL 0x00128fca
MOV R12,RDX
MOV R13D,EAX
LAB_0012970a:
LEA RBP,[RSP + 0x50]
MOV EDX,0xa0
MOV RDI,RBP
MOV RSI,R14
CALL 0x00122090
MOV qword ptr [RBP + 0x90],R14
AND qword ptr [RBP + 0x28],0x0
MOV RSI,qword ptr [R14]
LEA RDX,[0x1a8ba0]
LEA RBX,[RSP + 0x10]
PUSH 0xe
POP R8
MOV RDI,RBX
MOV RCX,RBP
MOV R9,R15
PUSH R13
PUSH R12
CALL 0x0012e25f
POP RAX
POP RCX
MOV RDI,R14
MOV RSI,RBX
CALL 0x00129adf
CMP dword ptr [RBX],0x0
MOV RBX,qword ptr [RSP + 0x8]
JNZ 0x001297f4
CMP qword ptr [RSP + 0xe0],0x0
JZ 0x001297f4
LEA R14,[RSP + 0x78]
LEA R15,[RSP + 0x7]
LAB_00129780:
MOV R14,qword ptr [R14]
TEST R14,R14
JZ 0x001297f4
MOV RDI,qword ptr [RSP + 0xe0]
MOV RSI,R14
MOV RDX,R15
CALL 0x00129937
MOVUPS XMM0,xmmword ptr [R14 + 0x14]
MOVUPS XMM1,xmmword ptr [R14 + 0x24]
MOVUPS xmmword ptr [RAX + 0x24],XMM1
MOVUPS xmmword ptr [RAX + 0x14],XMM0
MOVUPS XMM0,xmmword ptr [R14 + 0x38]
MOVUPS xmmword ptr [RAX + 0x38],XMM0
MOV CL,byte ptr [R14 + 0x59]
MOV byte ptr [RAX + 0x59],CL
LEA R12,[R14 + 0x50]
LAB_001297c1:
MOV R12,qword ptr [R12]
TEST R12,R12
JZ 0x001297ee
MOV RDI,qword ptr [RSP + 0xe0]
LEA RCX,[R12 + 0x20]
MOV RSI,R14
MOV RDX,R12
MOV R8,R15
MOV R9,R15
CALL 0x0012989a
ADD R12,0x40
JMP 0x001297c1
LAB_001297ee:
ADD R14,0x48
JMP 0x00129780
LAB_001297f4:
LEA RDI,[RSP + 0x50]
CALL 0x001290bf
MOVUPS XMM0,xmmword ptr [RSP + 0x10]
MOVUPS XMM1,xmmword ptr [RSP + 0x20]
MOVUPS XMM2,xmmword ptr [RSP + 0x30]
MOVUPS XMM3,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [RBX + 0x30],XMM3
MOVUPS xmmword ptr [RBX + 0x20],XMM2
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
LAB_00129821:
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void host_call(int8 *param_1,int *param_2,long param_3,ulong param_4,long *param_5)
{
int *piVar1;
long lVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
long *plVar9;
char cVar10;
int iVar11;
uint uVar12;
long lVar13;
long extraout_RDX;
int8 extraout_RDX_00;
long *plVar14;
int1 local_121;
long *local_120;
long local_118;
long lStack_110;
long local_108;
long lStack_100;
long local_f8;
long lStack_f0;
long local_e8;
long lStack_e0;
ulong local_d8;
long lStack_d0;
int8 local_c8;
long local_b0 [13];
int8 *local_48;
piVar1 = param_2 + 0x24;
cVar10 = bytes_all_equal(0x13,piVar1,0);
if ((cVar10 == '\0') || (*(char *)((long)param_2 + 0xa3) == '\0')) {
local_120 = param_5;
if ((param_3 == 0 || param_4 == 0) && (1 < *param_2 - 3U)) {
uVar12 = get_code(param_1,piVar1);
param_4 = (ulong)uVar12;
param_3 = extraout_RDX;
}
memcpy(&local_d8,param_1,0xa0);
local_b0[0] = 0;
local_48 = param_1;
evmone_execute(&local_118,*param_1,host_interface,&local_d8,0xe,param_2,param_3);
add_evm_result(param_1,&local_118,extraout_RDX_00,param_4);
plVar9 = local_120;
if (((int)local_118 == 0) && (local_48 != (int8 *)0x0)) {
plVar14 = local_b0;
while (lVar2 = *plVar14, lVar2 != 0) {
lVar13 = create_changed_account(local_48,lVar2,&local_121);
uVar6 = *(int8 *)(lVar2 + 0x14);
uVar7 = *(int8 *)(lVar2 + 0x1c);
uVar8 = *(int8 *)(lVar2 + 0x2c);
*(int8 *)(lVar13 + 0x24) = *(int8 *)(lVar2 + 0x24);
*(int8 *)(lVar13 + 0x2c) = uVar8;
*(int8 *)(lVar13 + 0x14) = uVar6;
*(int8 *)(lVar13 + 0x1c) = uVar7;
uVar3 = *(int4 *)(lVar2 + 0x3c);
uVar4 = *(int4 *)(lVar2 + 0x40);
uVar5 = *(int4 *)(lVar2 + 0x44);
*(int4 *)(lVar13 + 0x38) = *(int4 *)(lVar2 + 0x38);
*(int4 *)(lVar13 + 0x3c) = uVar3;
*(int4 *)(lVar13 + 0x40) = uVar4;
*(int4 *)(lVar13 + 0x44) = uVar5;
*(int1 *)(lVar13 + 0x59) = *(int1 *)(lVar2 + 0x59);
plVar14 = (long *)(lVar2 + 0x50);
while (lVar13 = *plVar14, lVar13 != 0) {
set_changed_storage(local_48,lVar2,lVar13,lVar13 + 0x20,&local_121,&local_121);
plVar14 = (long *)(lVar13 + 0x40);
}
plVar14 = (long *)(lVar2 + 0x48);
}
}
context_free(&local_d8);
plVar9[6] = local_e8;
plVar9[7] = lStack_e0;
plVar9[4] = local_f8;
plVar9[5] = lStack_f0;
plVar9[2] = local_108;
plVar9[3] = lStack_100;
*plVar9 = local_118;
plVar9[1] = lStack_110;
}
else {
local_c8 = 0;
local_118 = 0;
local_d8 = 0;
lStack_d0 = 0;
iVar11 = eth_execute_precompile
(piVar1,param_2[0x12],*(int8 *)(param_2 + 0x10),&local_d8,&local_118);
param_5[3] = lStack_d0;
param_5[4] = local_d8 & 0xffffffff;
param_5[1] = *(long *)(param_2 + 4) - local_118;
param_5[2] = 0;
*(int *)param_5 = iVar11;
if (iVar11 != 0) {
param_5[1] = 0;
}
add_evm_result(param_1,param_5);
}
return;
}
| |
32,145 | host_call | corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_evmone.c | static void host_call(void* context, const struct evmone_message* msg, const uint8_t* code, size_t code_size, struct evmone_result* result) {
evmone_context_t* ctx = (evmone_context_t*) context;
EVM_LOG("========Executing child call...");
debug_print_address("call from", &msg->sender);
debug_print_address("call to", &msg->destination);
debug_print_address("code from", &msg->code_address);
EVM_LOG("call gas: %zu, depth: %d, is_static: %s", (size_t) msg->gas, msg->depth, msg->is_static ? "true" : "false");
if (bytes_all_zero(bytes(msg->code_address.bytes, 19)) && msg->code_address.bytes[19]) {
buffer_t output = {0};
uint64_t gas_used = 0;
pre_result_t pre_result = eth_execute_precompile(msg->code_address.bytes, bytes(msg->input_data, msg->input_size), &output, &gas_used);
result->output_data = output.data.data;
result->output_size = output.data.len;
result->gas_left = msg->gas - gas_used;
result->gas_refund = 0;
result->status_code = pre_result;
if (pre_result != PRE_SUCCESS) {
EVM_LOG("Precompile failed with status code: %d", pre_result);
result->gas_left = 0;
}
add_evm_result(ctx, result);
return;
}
// If code isn't provided (which happens during DELEGATECALL and CALLCODE),
// we need to fetch it from the account specified by code_address
const uint8_t* execution_code = code;
size_t execution_code_size = code_size;
bytes_t fetched_code = {0};
if ((execution_code == NULL || execution_code_size == 0) && msg->kind != CALL_KIND_CREATE && msg->kind != CALL_KIND_CREATE2) {
EVM_LOG("Code not provided, fetching from code_address");
fetched_code = get_code(ctx, msg->code_address.bytes);
execution_code = fetched_code.data;
execution_code_size = fetched_code.len;
EVM_LOG("Fetched code size: %zu bytes", execution_code_size);
}
EVM_LOG("call code size: %zu bytes", execution_code_size);
if (msg->input_data && msg->input_size > 0) {
EVM_LOG("call input data (%zu bytes): 0x", msg->input_size);
if (EVM_DEBUG) {
for (size_t i = 0; i < (msg->input_size > 64 ? 64 : msg->input_size); i++) {
fprintf(stderr, "%02x", msg->input_data[i]);
}
if (msg->input_size > 64) fprintf(stderr, "...");
fprintf(stderr, "\n");
}
}
evmone_context_t child = *ctx;
child.parent = ctx;
child.changed_accounts = NULL;
// Execute the code (now using fetched code if needed)
evmone_result exec_result = evmone_execute(
ctx->executor,
&host_interface,
&child,
14, // Revision - using CANCUN
msg,
execution_code,
execution_code_size);
EVM_LOG("Child call complete. Status: %d, Gas left: %zu", exec_result.status_code, (size_t) exec_result.gas_left);
if (exec_result.output_data && exec_result.output_size > 0) {
EVM_LOG("Child call output (%zu bytes): 0x", exec_result.output_size);
if (EVM_DEBUG) {
for (size_t i = 0; i < (exec_result.output_size > 64 ? 64 : exec_result.output_size); i++) {
fprintf(stderr, "%02x", exec_result.output_data[i]);
}
if (exec_result.output_size > 64) fprintf(stderr, "...");
fprintf(stderr, "\n");
}
}
add_evm_result(ctx, &exec_result);
if (exec_result.status_code == 0) {
context_apply(&child);
}
EVM_LOG("========/child call complete ====");
context_free(&child);
*result = exec_result;
} | O3 | c | host_call:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
leaq 0x90(%rsi), %rbp
movl $0x13, %edi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x531b1
testb %al, %al
je 0x2a984
cmpb $0x0, 0xa3(%r15)
je 0x2a984
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r12
movaps %xmm0, (%r12)
xorl %eax, %eax
movq %rax, 0x10(%r12)
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movl 0x48(%r15), %esi
movq 0x40(%r15), %rdx
movq %rbp, %rdi
movq %r12, %rcx
movq %r13, %r8
callq 0x52eb4
movq 0x8(%r12), %rcx
movq %rcx, 0x18(%rbx)
movl (%r12), %ecx
movq %rcx, 0x20(%rbx)
movq 0x10(%r15), %rcx
subq (%r13), %rcx
movq %rcx, 0x8(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movl %eax, (%rbx)
testl %eax, %eax
je 0x2a945
movq $0x0, 0x8(%rbx)
movl $0x48, %edi
callq 0x52f18
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x30(%rbx), %xmm3
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm3, 0x30(%rax)
movq 0x98(%r14), %rcx
movq %rcx, 0x40(%rax)
movq %rax, 0x98(%r14)
jmp 0x2ab01
testq %r12, %r12
setne %al
testq %r13, %r13
setne %cl
testb %cl, %al
jne 0x2a9b0
movl (%r15), %eax
addl $-0x3, %eax
cmpl $0x2, %eax
jb 0x2a9b0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2a1be
movq %rdx, %r12
movl %eax, %r13d
leaq 0x50(%rsp), %rbp
movl $0xa0, %edx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x22090
movq %r14, 0x90(%rbp)
movq $0x0, 0x28(%rbp)
movq (%r14), %rsi
leaq 0x831c2(%rip), %rdx # 0xadba0
movq %r12, %rax
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rcx
movl $0xe, %r8d
movq %r15, %r9
pushq %r13
pushq %rax
callq 0x2fa67
addq $0x10, %rsp
movl $0x48, %edi
callq 0x52f18
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups 0x30(%r12), %xmm3
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm3, 0x30(%rax)
movq 0x98(%r14), %rcx
movq %rcx, 0x40(%rax)
movq %rax, 0x98(%r14)
cmpl $0x0, (%r12)
jne 0x2aad4
cmpq $0x0, 0xe0(%rsp)
je 0x2aad4
movq 0x78(%rsp), %r14
testq %r14, %r14
je 0x2aad4
leaq 0xf(%rsp), %r15
movq 0xe0(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2ac21
movups 0x14(%r14), %xmm0
movups 0x24(%r14), %xmm1
movups %xmm0, 0x14(%rax)
movups %xmm1, 0x24(%rax)
movups 0x38(%r14), %xmm0
movups %xmm0, 0x38(%rax)
movb 0x59(%r14), %cl
movb %cl, 0x59(%rax)
movq 0x50(%r14), %r12
testq %r12, %r12
je 0x2aacb
movq 0xe0(%rsp), %rdi
leaq 0x20(%r12), %rcx
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %r8
movq %r15, %r9
callq 0x2ab80
movq 0x40(%r12), %r12
jmp 0x2aaa1
movq 0x48(%r14), %r14
testq %r14, %r14
jne 0x2aa68
leaq 0x50(%rsp), %rdi
callq 0x2a2b8
movups 0x10(%rsp), %xmm0
movups 0x20(%rsp), %xmm1
movups 0x30(%rsp), %xmm2
movups 0x40(%rsp), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| host_call:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov rbx, r8
mov r13, rcx
mov r12, rdx
mov r15, rsi
mov r14, rdi
lea rbp, [rsi+90h]
mov edi, 13h
mov rsi, rbp
xor edx, edx
call bytes_all_equal
test al, al
jz loc_2A984
cmp byte ptr [r15+0A3h], 0
jz loc_2A984
xorps xmm0, xmm0
lea r12, [rsp+128h+var_D8]
movaps xmmword ptr [r12], xmm0
xor eax, eax
mov [r12+10h], rax
lea r13, [rsp+128h+var_118]
mov [r13+0], rax
mov esi, [r15+48h]
mov rdx, [r15+40h]
mov rdi, rbp
mov rcx, r12
mov r8, r13
call eth_execute_precompile
mov rcx, [r12+8]
mov [rbx+18h], rcx
mov ecx, [r12]
mov [rbx+20h], rcx
mov rcx, [r15+10h]
sub rcx, [r13+0]
mov [rbx+8], rcx
xor ecx, ecx
mov [rbx+10h], rcx
mov [rbx], eax
test eax, eax
jz short loc_2A945
mov qword ptr [rbx+8], 0
loc_2A945:
mov edi, 48h ; 'H'
call safe_malloc
movups xmm0, xmmword ptr [rbx]
movups xmm1, xmmword ptr [rbx+10h]
movups xmm2, xmmword ptr [rbx+20h]
movups xmm3, xmmword ptr [rbx+30h]
movups xmmword ptr [rax], xmm0
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax+20h], xmm2
movups xmmword ptr [rax+30h], xmm3
mov rcx, [r14+98h]
mov [rax+40h], rcx
mov [r14+98h], rax
jmp loc_2AB01
loc_2A984:
test r12, r12
setnz al
test r13, r13
setnz cl
test al, cl
jnz short loc_2A9B0
mov eax, [r15]
add eax, 0FFFFFFFDh
cmp eax, 2
jb short loc_2A9B0
mov rdi, r14
mov rsi, rbp
call get_code
mov r12, rdx
mov r13d, eax
loc_2A9B0:
lea rbp, [rsp+128h+var_D8]
mov edx, 0A0h
mov rdi, rbp
mov rsi, r14
call _memcpy
mov [rbp+90h], r14
mov qword ptr [rbp+28h], 0
mov rsi, [r14]
lea rdx, host_interface
mov rax, r12
lea r12, [rsp+128h+var_118]
mov rdi, r12
mov rcx, rbp
mov r8d, 0Eh
mov r9, r15
push r13
push rax
call evmone_execute
add rsp, 10h
mov edi, 48h ; 'H'
call safe_malloc
movups xmm0, xmmword ptr [r12]
movups xmm1, xmmword ptr [r12+10h]
movups xmm2, xmmword ptr [r12+20h]
movups xmm3, xmmword ptr [r12+30h]
movups xmmword ptr [rax], xmm0
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax+20h], xmm2
movups xmmword ptr [rax+30h], xmm3
mov rcx, [r14+98h]
mov [rax+40h], rcx
mov [r14+98h], rax
cmp dword ptr [r12], 0
jnz loc_2AAD4
cmp [rsp+128h+var_48], 0
jz short loc_2AAD4
mov r14, [rsp+128h+var_B0]
test r14, r14
jz short loc_2AAD4
lea r15, [rsp+128h+var_119]
loc_2AA68:
mov rdi, [rsp+128h+var_48]
mov rsi, r14
mov rdx, r15
call create_changed_account
movups xmm0, xmmword ptr [r14+14h]
movups xmm1, xmmword ptr [r14+24h]
movups xmmword ptr [rax+14h], xmm0
movups xmmword ptr [rax+24h], xmm1
movups xmm0, xmmword ptr [r14+38h]
movups xmmword ptr [rax+38h], xmm0
mov cl, [r14+59h]
mov [rax+59h], cl
mov r12, [r14+50h]
loc_2AAA1:
test r12, r12
jz short loc_2AACB
mov rdi, [rsp+128h+var_48]
lea rcx, [r12+20h]
mov rsi, r14
mov rdx, r12
mov r8, r15
mov r9, r15
call set_changed_storage
mov r12, [r12+40h]
jmp short loc_2AAA1
loc_2AACB:
mov r14, [r14+48h]
test r14, r14
jnz short loc_2AA68
loc_2AAD4:
lea rdi, [rsp+128h+var_D8]
call context_free
movups xmm0, [rsp+128h+var_118]
movups xmm1, [rsp+128h+var_108]
movups xmm2, [rsp+128h+var_F8]
movups xmm3, [rsp+128h+var_E8]
movups xmmword ptr [rbx+30h], xmm3
movups xmmword ptr [rbx+20h], xmm2
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
loc_2AB01:
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long host_call(_QWORD *a1, long long a2, long long a3, long long a4, long long a5)
{
long long v8; // rbp
int v9; // eax
long long result; // rax
__int128 v11; // xmm1
__int128 v12; // xmm2
__int128 v13; // xmm3
unsigned int code; // eax
long long v15; // rdx
long long v16; // rax
__int128 v17; // xmm1
__int128 v18; // xmm2
__int128 v19; // xmm3
long long i; // r14
long long v21; // rax
__int128 v22; // xmm1
long long j; // r12
__int128 v24; // xmm0
__int128 v25; // xmm1
__int128 v26; // xmm2
__int128 v27; // [rsp-10h] [rbp-138h]
char v28; // [rsp+Fh] [rbp-119h] BYREF
__int128 v29; // [rsp+10h] [rbp-118h] BYREF
__int128 v30; // [rsp+20h] [rbp-108h]
__int128 v31; // [rsp+30h] [rbp-F8h]
__int128 v32; // [rsp+40h] [rbp-E8h]
__int128 v33; // [rsp+50h] [rbp-D8h] BYREF
long long v34; // [rsp+60h] [rbp-C8h]
long long v35; // [rsp+78h] [rbp-B0h]
_QWORD *v36; // [rsp+E0h] [rbp-48h]
v8 = a2 + 144;
if ( (unsigned __int8)bytes_all_equal(19LL, a2 + 144, 0LL) && *(_BYTE *)(a2 + 163) )
{
v33 = 0LL;
v34 = 0LL;
*(_QWORD *)&v29 = 0LL;
v9 = eth_execute_precompile(v8, *(unsigned int *)(a2 + 72), *(_QWORD *)(a2 + 64), &v33, &v29);
*(_QWORD *)(a5 + 24) = *((_QWORD *)&v33 + 1);
*(_QWORD *)(a5 + 32) = (unsigned int)v33;
*(_QWORD *)(a5 + 8) = *(_QWORD *)(a2 + 16) - v29;
*(_QWORD *)(a5 + 16) = 0LL;
*(_DWORD *)a5 = v9;
if ( v9 )
*(_QWORD *)(a5 + 8) = 0LL;
result = safe_malloc(72LL);
v11 = *(_OWORD *)(a5 + 16);
v12 = *(_OWORD *)(a5 + 32);
v13 = *(_OWORD *)(a5 + 48);
*(_OWORD *)result = *(_OWORD *)a5;
*(_OWORD *)(result + 16) = v11;
*(_OWORD *)(result + 32) = v12;
*(_OWORD *)(result + 48) = v13;
*(_QWORD *)(result + 64) = a1[19];
a1[19] = result;
}
else
{
if ( (a4 == 0 || a3 == 0) && (unsigned int)(*(_DWORD *)a2 - 3) >= 2 )
{
code = get_code((long long)a1, v8);
a3 = v15;
a4 = code;
}
memcpy(&v33);
v36 = a1;
v35 = 0LL;
*((_QWORD *)&v27 + 1) = a4;
*(_QWORD *)&v27 = a3;
evmone_execute((unsigned int)&v29, *a1, (unsigned int)host_interface, (unsigned int)&v33, 14, a2, v27);
v16 = safe_malloc(72LL);
v17 = v30;
v18 = v31;
v19 = v32;
*(_OWORD *)v16 = v29;
*(_OWORD *)(v16 + 16) = v17;
*(_OWORD *)(v16 + 32) = v18;
*(_OWORD *)(v16 + 48) = v19;
*(_QWORD *)(v16 + 64) = a1[19];
a1[19] = v16;
if ( !(_DWORD)v29 )
{
if ( v36 )
{
for ( i = v35; i; i = *(_QWORD *)(i + 72) )
{
v21 = create_changed_account(v36, i, &v28);
v22 = *(_OWORD *)(i + 36);
*(_OWORD *)(v21 + 20) = *(_OWORD *)(i + 20);
*(_OWORD *)(v21 + 36) = v22;
*(_OWORD *)(v21 + 56) = *(_OWORD *)(i + 56);
*(_BYTE *)(v21 + 89) = *(_BYTE *)(i + 89);
for ( j = *(_QWORD *)(i + 80); j; j = *(_QWORD *)(j + 64) )
set_changed_storage(v36, i, j, j + 32, &v28, &v28);
}
}
}
result = context_free((long long)&v33);
v24 = v29;
v25 = v30;
v26 = v31;
*(_OWORD *)(a5 + 48) = v32;
*(_OWORD *)(a5 + 32) = v26;
*(_OWORD *)(a5 + 16) = v25;
*(_OWORD *)a5 = v24;
}
return result;
}
| host_call:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV RBX,R8
MOV R13,RCX
MOV R12,RDX
MOV R15,RSI
MOV R14,RDI
LEA RBP,[RSI + 0x90]
MOV EDI,0x13
MOV RSI,RBP
XOR EDX,EDX
CALL 0x001531b1
TEST AL,AL
JZ 0x0012a984
CMP byte ptr [R15 + 0xa3],0x0
JZ 0x0012a984
XORPS XMM0,XMM0
LEA R12,[RSP + 0x50]
MOVAPS xmmword ptr [R12],XMM0
XOR EAX,EAX
MOV qword ptr [R12 + 0x10],RAX
LEA R13,[RSP + 0x10]
MOV qword ptr [R13],RAX
MOV ESI,dword ptr [R15 + 0x48]
MOV RDX,qword ptr [R15 + 0x40]
MOV RDI,RBP
MOV RCX,R12
MOV R8,R13
CALL 0x00152eb4
MOV RCX,qword ptr [R12 + 0x8]
MOV qword ptr [RBX + 0x18],RCX
MOV ECX,dword ptr [R12]
MOV qword ptr [RBX + 0x20],RCX
MOV RCX,qword ptr [R15 + 0x10]
SUB RCX,qword ptr [R13]
MOV qword ptr [RBX + 0x8],RCX
XOR ECX,ECX
MOV qword ptr [RBX + 0x10],RCX
MOV dword ptr [RBX],EAX
TEST EAX,EAX
JZ 0x0012a945
MOV qword ptr [RBX + 0x8],0x0
LAB_0012a945:
MOV EDI,0x48
CALL 0x00152f18
MOVUPS XMM0,xmmword ptr [RBX]
MOVUPS XMM1,xmmword ptr [RBX + 0x10]
MOVUPS XMM2,xmmword ptr [RBX + 0x20]
MOVUPS XMM3,xmmword ptr [RBX + 0x30]
MOVUPS xmmword ptr [RAX],XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX + 0x20],XMM2
MOVUPS xmmword ptr [RAX + 0x30],XMM3
MOV RCX,qword ptr [R14 + 0x98]
MOV qword ptr [RAX + 0x40],RCX
MOV qword ptr [R14 + 0x98],RAX
JMP 0x0012ab01
LAB_0012a984:
TEST R12,R12
SETNZ AL
TEST R13,R13
SETNZ CL
TEST AL,CL
JNZ 0x0012a9b0
MOV EAX,dword ptr [R15]
ADD EAX,-0x3
CMP EAX,0x2
JC 0x0012a9b0
MOV RDI,R14
MOV RSI,RBP
CALL 0x0012a1be
MOV R12,RDX
MOV R13D,EAX
LAB_0012a9b0:
LEA RBP,[RSP + 0x50]
MOV EDX,0xa0
MOV RDI,RBP
MOV RSI,R14
CALL 0x00122090
MOV qword ptr [RBP + 0x90],R14
MOV qword ptr [RBP + 0x28],0x0
MOV RSI,qword ptr [R14]
LEA RDX,[0x1adba0]
MOV RAX,R12
LEA R12,[RSP + 0x10]
MOV RDI,R12
MOV RCX,RBP
MOV R8D,0xe
MOV R9,R15
PUSH R13
PUSH RAX
CALL 0x0012fa67
ADD RSP,0x10
MOV EDI,0x48
CALL 0x00152f18
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS XMM1,xmmword ptr [R12 + 0x10]
MOVUPS XMM2,xmmword ptr [R12 + 0x20]
MOVUPS XMM3,xmmword ptr [R12 + 0x30]
MOVUPS xmmword ptr [RAX],XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX + 0x20],XMM2
MOVUPS xmmword ptr [RAX + 0x30],XMM3
MOV RCX,qword ptr [R14 + 0x98]
MOV qword ptr [RAX + 0x40],RCX
MOV qword ptr [R14 + 0x98],RAX
CMP dword ptr [R12],0x0
JNZ 0x0012aad4
CMP qword ptr [RSP + 0xe0],0x0
JZ 0x0012aad4
MOV R14,qword ptr [RSP + 0x78]
TEST R14,R14
JZ 0x0012aad4
LEA R15,[RSP + 0xf]
LAB_0012aa68:
MOV RDI,qword ptr [RSP + 0xe0]
MOV RSI,R14
MOV RDX,R15
CALL 0x0012ac21
MOVUPS XMM0,xmmword ptr [R14 + 0x14]
MOVUPS XMM1,xmmword ptr [R14 + 0x24]
MOVUPS xmmword ptr [RAX + 0x14],XMM0
MOVUPS xmmword ptr [RAX + 0x24],XMM1
MOVUPS XMM0,xmmword ptr [R14 + 0x38]
MOVUPS xmmword ptr [RAX + 0x38],XMM0
MOV CL,byte ptr [R14 + 0x59]
MOV byte ptr [RAX + 0x59],CL
MOV R12,qword ptr [R14 + 0x50]
LAB_0012aaa1:
TEST R12,R12
JZ 0x0012aacb
MOV RDI,qword ptr [RSP + 0xe0]
LEA RCX,[R12 + 0x20]
MOV RSI,R14
MOV RDX,R12
MOV R8,R15
MOV R9,R15
CALL 0x0012ab80
MOV R12,qword ptr [R12 + 0x40]
JMP 0x0012aaa1
LAB_0012aacb:
MOV R14,qword ptr [R14 + 0x48]
TEST R14,R14
JNZ 0x0012aa68
LAB_0012aad4:
LEA RDI,[RSP + 0x50]
CALL 0x0012a2b8
MOVUPS XMM0,xmmword ptr [RSP + 0x10]
MOVUPS XMM1,xmmword ptr [RSP + 0x20]
MOVUPS XMM2,xmmword ptr [RSP + 0x30]
MOVUPS XMM3,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [RBX + 0x30],XMM3
MOVUPS xmmword ptr [RBX + 0x20],XMM2
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
LAB_0012ab01:
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void host_call(int8 *param_1,int *param_2,long param_3,ulong param_4,int *param_5)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
int8 uVar9;
int8 uVar10;
char cVar11;
int iVar12;
uint uVar13;
int8 *puVar14;
int *piVar15;
long lVar16;
long extraout_RDX;
long lVar17;
int1 local_119;
int8 local_118;
int iStack_110;
int iStack_10c;
int8 local_108;
int8 uStack_100;
int8 local_f8;
int8 uStack_f0;
int8 local_e8;
int8 uStack_e0;
ulong local_d8;
int8 uStack_d0;
int8 local_c8;
long local_b0;
int8 *local_48;
piVar15 = param_2 + 0x24;
cVar11 = bytes_all_equal(0x13,piVar15,0);
if ((cVar11 == '\0') || (*(char *)((long)param_2 + 0xa3) == '\0')) {
if ((param_3 == 0 || param_4 == 0) && (1 < *param_2 - 3U)) {
uVar13 = get_code(param_1,piVar15);
param_4 = (ulong)uVar13;
param_3 = extraout_RDX;
}
memcpy(&local_d8,param_1,0xa0);
local_b0 = 0;
local_48 = param_1;
evmone_execute(&local_118,*param_1,host_interface,&local_d8,0xe,param_2,param_3,param_4);
piVar15 = (int *)safe_malloc(0x48);
*piVar15 = (int)local_118;
piVar15[1] = local_118._4_4_;
piVar15[2] = iStack_110;
piVar15[3] = iStack_10c;
*(int8 *)(piVar15 + 4) = local_108;
*(int8 *)(piVar15 + 6) = uStack_100;
*(int8 *)(piVar15 + 8) = local_f8;
*(int8 *)(piVar15 + 10) = uStack_f0;
*(int8 *)(piVar15 + 0xc) = local_e8;
*(int8 *)(piVar15 + 0xe) = uStack_e0;
*(int8 *)(piVar15 + 0x10) = param_1[0x13];
param_1[0x13] = piVar15;
if ((((int)local_118 == 0) && (local_48 != (int8 *)0x0)) && (local_b0 != 0)) {
lVar17 = local_b0;
do {
lVar16 = create_changed_account(local_48,lVar17,&local_119);
uVar4 = *(int8 *)(lVar17 + 0x1c);
uVar5 = *(int8 *)(lVar17 + 0x24);
uVar6 = *(int8 *)(lVar17 + 0x2c);
*(int8 *)(lVar16 + 0x14) = *(int8 *)(lVar17 + 0x14);
*(int8 *)(lVar16 + 0x1c) = uVar4;
*(int8 *)(lVar16 + 0x24) = uVar5;
*(int8 *)(lVar16 + 0x2c) = uVar6;
uVar1 = *(int4 *)(lVar17 + 0x3c);
uVar2 = *(int4 *)(lVar17 + 0x40);
uVar3 = *(int4 *)(lVar17 + 0x44);
*(int4 *)(lVar16 + 0x38) = *(int4 *)(lVar17 + 0x38);
*(int4 *)(lVar16 + 0x3c) = uVar1;
*(int4 *)(lVar16 + 0x40) = uVar2;
*(int4 *)(lVar16 + 0x44) = uVar3;
*(int1 *)(lVar16 + 0x59) = *(int1 *)(lVar17 + 0x59);
for (lVar16 = *(long *)(lVar17 + 0x50); lVar16 != 0; lVar16 = *(long *)(lVar16 + 0x40)) {
set_changed_storage(local_48,lVar17,lVar16,lVar16 + 0x20,&local_119,&local_119);
}
lVar17 = *(long *)(lVar17 + 0x48);
} while (lVar17 != 0);
}
context_free(&local_d8);
*(int8 *)(param_5 + 0xc) = local_e8;
*(int8 *)(param_5 + 0xe) = uStack_e0;
*(int8 *)(param_5 + 8) = local_f8;
*(int8 *)(param_5 + 10) = uStack_f0;
*(int8 *)(param_5 + 4) = local_108;
*(int8 *)(param_5 + 6) = uStack_100;
*(long *)param_5 = local_118;
*(ulong *)(param_5 + 2) = CONCAT44(iStack_10c,iStack_110);
}
else {
local_d8 = 0;
uStack_d0 = 0;
local_c8 = 0;
local_118 = 0;
iVar12 = eth_execute_precompile
(piVar15,param_2[0x12],*(int8 *)(param_2 + 0x10),&local_d8,&local_118);
*(int8 *)(param_5 + 6) = uStack_d0;
*(ulong *)(param_5 + 8) = local_d8 & 0xffffffff;
*(long *)(param_5 + 2) = *(long *)(param_2 + 4) - local_118;
param_5[4] = 0;
param_5[5] = 0;
*param_5 = iVar12;
if (iVar12 != 0) {
param_5[2] = 0;
param_5[3] = 0;
}
puVar14 = (int8 *)safe_malloc(0x48);
uVar4 = *(int8 *)(param_5 + 2);
uVar5 = *(int8 *)(param_5 + 4);
uVar6 = *(int8 *)(param_5 + 6);
uVar7 = *(int8 *)(param_5 + 8);
uVar8 = *(int8 *)(param_5 + 10);
uVar9 = *(int8 *)(param_5 + 0xc);
uVar10 = *(int8 *)(param_5 + 0xe);
*puVar14 = *(int8 *)param_5;
puVar14[1] = uVar4;
puVar14[2] = uVar5;
puVar14[3] = uVar6;
puVar14[4] = uVar7;
puVar14[5] = uVar8;
puVar14[6] = uVar9;
puVar14[7] = uVar10;
puVar14[8] = param_1[0x13];
param_1[0x13] = puVar14;
}
return;
}
| |
32,146 | JS_CopySubArray | bluesky950520[P]quickjs/quickjs.c | static int JS_CopySubArray(JSContext *ctx,
JSValue obj, int64_t to_pos,
int64_t from_pos, int64_t count, int dir)
{
JSObject *p;
int64_t i, from, to, len;
JSValue val;
int fromPresent;
p = NULL;
if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
p = JS_VALUE_GET_OBJ(obj);
if (p->class_id != JS_CLASS_ARRAY || !p->fast_array) {
p = NULL;
}
}
for (i = 0; i < count; ) {
if (dir < 0) {
from = from_pos + count - i - 1;
to = to_pos + count - i - 1;
} else {
from = from_pos + i;
to = to_pos + i;
}
if (p && p->fast_array &&
from >= 0 && from < (len = p->u.array.count) &&
to >= 0 && to < len) {
int64_t l, j;
/* Fast path for fast arrays. Since we don't look at the
prototype chain, we can optimize only the cases where
all the elements are present in the array. */
l = count - i;
if (dir < 0) {
l = min_int64(l, from + 1);
l = min_int64(l, to + 1);
for(j = 0; j < l; j++) {
set_value(ctx, &p->u.array.u.values[to - j],
js_dup(p->u.array.u.values[from - j]));
}
} else {
l = min_int64(l, len - from);
l = min_int64(l, len - to);
for(j = 0; j < l; j++) {
set_value(ctx, &p->u.array.u.values[to + j],
js_dup(p->u.array.u.values[from + j]));
}
}
i += l;
} else {
fromPresent = JS_TryGetPropertyInt64(ctx, obj, from, &val);
if (fromPresent < 0)
goto exception;
if (fromPresent) {
if (JS_SetPropertyInt64(ctx, obj, to, val) < 0)
goto exception;
} else {
if (JS_DeletePropertyInt64(ctx, obj, to, JS_PROP_THROW) < 0)
goto exception;
}
i++;
}
}
return 0;
exception:
return -1;
} | O0 | c | JS_CopySubArray:
subq $0xc8, %rsp
movl 0xd0(%rsp), %eax
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xb8(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rcx, 0xa0(%rsp)
movq %r8, 0x98(%rsp)
movq %r9, 0x90(%rsp)
movq $0x0, 0x88(%rsp)
movq 0xb8(%rsp), %rax
cmpl $-0x1, %eax
jne 0x864ba
movq 0xb0(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x2, %eax
jne 0x864ac
movq 0x88(%rsp), %rax
movb 0x5(%rax), %al
shrb $0x3, %al
andb $0x1, %al
cmpb $0x0, %al
jne 0x864b8
movq $0x0, 0x88(%rsp)
jmp 0x864ba
movq $0x0, 0x80(%rsp)
movq 0x80(%rsp), %rax
cmpq 0x90(%rsp), %rax
jge 0x86874
cmpl $0x0, 0xd0(%rsp)
jge 0x8652a
movq 0x98(%rsp), %rax
addq 0x90(%rsp), %rax
subq 0x80(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x78(%rsp)
movq 0xa0(%rsp), %rax
addq 0x90(%rsp), %rax
subq 0x80(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0x86554
movq 0x98(%rsp), %rax
addq 0x80(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0xa0(%rsp), %rax
addq 0x80(%rsp), %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x88(%rsp)
je 0x867b7
movq 0x88(%rsp), %rax
movb 0x5(%rax), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x867b7
cmpq $0x0, 0x78(%rsp)
jl 0x867b7
movq 0x78(%rsp), %rax
movq 0x88(%rsp), %rcx
movl 0x40(%rcx), %ecx
movq %rcx, 0x68(%rsp)
cmpq %rcx, %rax
jge 0x867b7
cmpq $0x0, 0x70(%rsp)
jl 0x867b7
movq 0x70(%rsp), %rax
cmpq 0x68(%rsp), %rax
jge 0x867b7
movq 0x90(%rsp), %rax
subq 0x80(%rsp), %rax
movq %rax, 0x48(%rsp)
cmpl $0x0, 0xd0(%rsp)
jge 0x866c4
movq 0x48(%rsp), %rdi
movq 0x78(%rsp), %rsi
addq $0x1, %rsi
callq 0x868a0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq 0x70(%rsp), %rsi
addq $0x1, %rsi
callq 0x868a0
movq %rax, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
jge 0x866bf
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x70(%rsp), %rcx
subq 0x40(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x88(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x78(%rsp), %rcx
subq 0x40(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x20410
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x26780
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x86621
jmp 0x8679d
movq 0x48(%rsp), %rdi
movq 0x68(%rsp), %rsi
subq 0x78(%rsp), %rsi
callq 0x868a0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq 0x68(%rsp), %rsi
subq 0x70(%rsp), %rsi
callq 0x868a0
movq %rax, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
jge 0x8679b
movq 0xa8(%rsp), %rax
movq %rax, (%rsp)
movq 0x88(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x70(%rsp), %rcx
addq 0x40(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x88(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x78(%rsp), %rcx
addq 0x40(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x20410
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x26780
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x866ff
jmp 0x8679d
movq 0x48(%rsp), %rax
addq 0x80(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x8686f
movq 0xa8(%rsp), %rdi
movq 0x78(%rsp), %rcx
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
leaq 0x58(%rsp), %r8
callq 0x868e0
movl %eax, 0x54(%rsp)
cmpl $0x0, 0x54(%rsp)
jge 0x867ee
jmp 0x86881
cmpl $0x0, 0x54(%rsp)
je 0x8682a
movq 0xa8(%rsp), %rdi
movq 0x70(%rsp), %rcx
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
movq 0x58(%rsp), %r8
movq 0x60(%rsp), %r9
callq 0x328f0
cmpl $0x0, %eax
jge 0x86828
jmp 0x86881
jmp 0x8685b
movq 0xa8(%rsp), %rdi
movq 0x70(%rsp), %rcx
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
movl $0x4000, %r8d # imm = 0x4000
callq 0x36cd0
cmpl $0x0, %eax
jge 0x86859
jmp 0x86881
jmp 0x8685b
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0x864c6
movl $0x0, 0xc4(%rsp)
jmp 0x8688c
movl $0xffffffff, 0xc4(%rsp) # imm = 0xFFFFFFFF
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
nopl (%rax,%rax)
| JS_CopySubArray:
sub rsp, 0C8h
mov eax, [rsp+0C8h+arg_0]
mov [rsp+0C8h+var_18], rsi
mov [rsp+0C8h+var_10], rdx
mov [rsp+0C8h+var_20], rdi
mov [rsp+0C8h+var_28], rcx
mov [rsp+0C8h+var_30], r8
mov [rsp+0C8h+var_38], r9
mov [rsp+0C8h+var_40], 0
mov rax, [rsp+0C8h+var_10]
cmp eax, 0FFFFFFFFh
jnz short loc_864BA
mov rax, [rsp+0C8h+var_18]
mov [rsp+0C8h+var_40], rax
mov rax, [rsp+0C8h+var_40]
movzx eax, word ptr [rax+6]
cmp eax, 2
jnz short loc_864AC
mov rax, [rsp+0C8h+var_40]
mov al, [rax+5]
shr al, 3
and al, 1
cmp al, 0
jnz short loc_864B8
loc_864AC:
mov [rsp+0C8h+var_40], 0
loc_864B8:
jmp short $+2
loc_864BA:
mov [rsp+0C8h+var_48], 0
loc_864C6:
mov rax, [rsp+0C8h+var_48]
cmp rax, [rsp+0C8h+var_38]
jge loc_86874
cmp [rsp+0C8h+arg_0], 0
jge short loc_8652A
mov rax, [rsp+0C8h+var_30]
add rax, [rsp+0C8h+var_38]
sub rax, [rsp+0C8h+var_48]
sub rax, 1
mov [rsp+0C8h+var_50], rax
mov rax, [rsp+0C8h+var_28]
add rax, [rsp+0C8h+var_38]
sub rax, [rsp+0C8h+var_48]
sub rax, 1
mov [rsp+0C8h+var_58], rax
jmp short loc_86554
loc_8652A:
mov rax, [rsp+0C8h+var_30]
add rax, [rsp+0C8h+var_48]
mov [rsp+0C8h+var_50], rax
mov rax, [rsp+0C8h+var_28]
add rax, [rsp+0C8h+var_48]
mov [rsp+0C8h+var_58], rax
loc_86554:
cmp [rsp+0C8h+var_40], 0
jz loc_867B7
mov rax, [rsp+0C8h+var_40]
mov al, [rax+5]
shr al, 3
and al, 1
movzx eax, al
cmp eax, 0
jz loc_867B7
cmp [rsp+0C8h+var_50], 0
jl loc_867B7
mov rax, [rsp+0C8h+var_50]
mov rcx, [rsp+0C8h+var_40]
mov ecx, [rcx+40h]
mov [rsp+0C8h+var_60], rcx
cmp rax, rcx
jge loc_867B7
cmp [rsp+0C8h+var_58], 0
jl loc_867B7
mov rax, [rsp+0C8h+var_58]
cmp rax, [rsp+0C8h+var_60]
jge loc_867B7
mov rax, [rsp+0C8h+var_38]
sub rax, [rsp+0C8h+var_48]
mov [rsp+0C8h+var_80], rax
cmp [rsp+0C8h+arg_0], 0
jge loc_866C4
mov rdi, [rsp+0C8h+var_80]
mov rsi, [rsp+0C8h+var_50]
add rsi, 1
call min_int64
mov [rsp+0C8h+var_80], rax
mov rdi, [rsp+0C8h+var_80]
mov rsi, [rsp+0C8h+var_58]
add rsi, 1
call min_int64
mov [rsp+0C8h+var_80], rax
mov [rsp+0C8h+var_88], 0
loc_86621:
mov rax, [rsp+0C8h+var_88]
cmp rax, [rsp+0C8h+var_80]
jge loc_866BF
mov rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_B8], rax
mov rax, [rsp+0C8h+var_40]
mov rax, [rax+38h]
mov rcx, [rsp+0C8h+var_58]
sub rcx, [rsp+0C8h+var_88]
shl rcx, 4
add rax, rcx
mov [rsp+0C8h+var_B0], rax
mov rax, [rsp+0C8h+var_40]
mov rax, [rax+38h]
mov rcx, [rsp+0C8h+var_50]
sub rcx, [rsp+0C8h+var_88]
shl rcx, 4
add rax, rcx
mov rdi, [rax]
mov rsi, [rax+8]
call js_dup
mov rdi, [rsp+0C8h+var_B8]
mov rsi, [rsp+0C8h+var_B0]
mov [rsp+0C8h+var_98], rax
mov [rsp+0C8h+var_90], rdx
mov rdx, [rsp+0C8h+var_98]
mov rcx, [rsp+0C8h+var_90]
call set_value
mov rax, [rsp+0C8h+var_88]
add rax, 1
mov [rsp+0C8h+var_88], rax
jmp loc_86621
loc_866BF:
jmp loc_8679D
loc_866C4:
mov rdi, [rsp+0C8h+var_80]
mov rsi, [rsp+0C8h+var_60]
sub rsi, [rsp+0C8h+var_50]
call min_int64
mov [rsp+0C8h+var_80], rax
mov rdi, [rsp+0C8h+var_80]
mov rsi, [rsp+0C8h+var_60]
sub rsi, [rsp+0C8h+var_58]
call min_int64
mov [rsp+0C8h+var_80], rax
mov [rsp+0C8h+var_88], 0
loc_866FF:
mov rax, [rsp+0C8h+var_88]
cmp rax, [rsp+0C8h+var_80]
jge loc_8679B
mov rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_C8], rax
mov rax, [rsp+0C8h+var_40]
mov rax, [rax+38h]
mov rcx, [rsp+0C8h+var_58]
add rcx, [rsp+0C8h+var_88]
shl rcx, 4
add rax, rcx
mov [rsp+0C8h+var_C0], rax
mov rax, [rsp+0C8h+var_40]
mov rax, [rax+38h]
mov rcx, [rsp+0C8h+var_50]
add rcx, [rsp+0C8h+var_88]
shl rcx, 4
add rax, rcx
mov rdi, [rax]
mov rsi, [rax+8]
call js_dup
mov rdi, [rsp+0C8h+var_C8]
mov rsi, [rsp+0C8h+var_C0]
mov [rsp+0C8h+var_A8], rax
mov [rsp+0C8h+var_A0], rdx
mov rdx, [rsp+0C8h+var_A8]
mov rcx, [rsp+0C8h+var_A0]
call set_value
mov rax, [rsp+0C8h+var_88]
add rax, 1
mov [rsp+0C8h+var_88], rax
jmp loc_866FF
loc_8679B:
jmp short $+2
loc_8679D:
mov rax, [rsp+0C8h+var_80]
add rax, [rsp+0C8h+var_48]
mov [rsp+0C8h+var_48], rax
jmp loc_8686F
loc_867B7:
mov rdi, [rsp+0C8h+var_20]
mov rcx, [rsp+0C8h+var_50]
mov rsi, [rsp+0C8h+var_18]
mov rdx, [rsp+0C8h+var_10]
lea r8, [rsp+0C8h+var_70]
call JS_TryGetPropertyInt64
mov [rsp+0C8h+var_74], eax
cmp [rsp+0C8h+var_74], 0
jge short loc_867EE
jmp loc_86881
loc_867EE:
cmp [rsp+0C8h+var_74], 0
jz short loc_8682A
mov rdi, [rsp+0C8h+var_20]
mov rcx, [rsp+0C8h+var_58]
mov rsi, [rsp+0C8h+var_18]
mov rdx, [rsp+0C8h+var_10]
mov r8, [rsp+0C8h+var_70]
mov r9, [rsp+0C8h+var_68]
call JS_SetPropertyInt64
cmp eax, 0
jge short loc_86828
jmp short loc_86881
loc_86828:
jmp short loc_8685B
loc_8682A:
mov rdi, [rsp+0C8h+var_20]
mov rcx, [rsp+0C8h+var_58]
mov rsi, [rsp+0C8h+var_18]
mov rdx, [rsp+0C8h+var_10]
mov r8d, 4000h
call JS_DeletePropertyInt64
cmp eax, 0
jge short loc_86859
jmp short loc_86881
loc_86859:
jmp short $+2
loc_8685B:
mov rax, [rsp+0C8h+var_48]
add rax, 1
mov [rsp+0C8h+var_48], rax
loc_8686F:
jmp loc_864C6
loc_86874:
mov [rsp+0C8h+var_4], 0
jmp short loc_8688C
loc_86881:
mov [rsp+0C8h+var_4], 0FFFFFFFFh
loc_8688C:
mov eax, [rsp+0C8h+var_4]
add rsp, 0C8h
retn
| long long JS_CopySubArray(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
int a15)
{
long long v15; // rax
long long v16; // rax
long long v17; // rdx
long long v18; // rax
long long v19; // rax
long long v20; // rdx
double v21; // xmm4_8
double v22; // xmm5_8
long long v24; // [rsp+0h] [rbp-C8h]
long long *v25; // [rsp+8h] [rbp-C0h]
long long v26; // [rsp+10h] [rbp-B8h]
long long *v27; // [rsp+18h] [rbp-B0h]
_DWORD *v28; // [rsp+20h] [rbp-A8h]
_DWORD *v29; // [rsp+30h] [rbp-98h]
long long k; // [rsp+40h] [rbp-88h]
long long j; // [rsp+40h] [rbp-88h]
long long v32; // [rsp+48h] [rbp-80h]
long long v33; // [rsp+48h] [rbp-80h]
int PropertyInt64; // [rsp+54h] [rbp-74h]
long long v35[2]; // [rsp+58h] [rbp-70h] BYREF
signed long long v36; // [rsp+68h] [rbp-60h]
signed long long v37; // [rsp+70h] [rbp-58h]
long long v38; // [rsp+78h] [rbp-50h]
long long i; // [rsp+80h] [rbp-48h]
long long v40; // [rsp+88h] [rbp-40h]
long long v41; // [rsp+90h] [rbp-38h]
long long v42; // [rsp+98h] [rbp-30h]
long long v43; // [rsp+A0h] [rbp-28h]
long long v44; // [rsp+A8h] [rbp-20h]
long long v45; // [rsp+B0h] [rbp-18h]
long long v46; // [rsp+B8h] [rbp-10h]
v45 = a2;
v46 = a3;
v44 = a1;
v43 = a4;
v42 = a5;
v41 = a6;
v40 = 0LL;
if ( (_DWORD)a3 == -1 )
{
v40 = v45;
if ( *(_WORD *)(v45 + 6) != 2 || (*(_BYTE *)(v40 + 5) & 8) == 0 )
v40 = 0LL;
}
for ( i = 0LL; ; ++i )
{
while ( 1 )
{
if ( i >= v41 )
return 0;
if ( a15 >= 0 )
{
v38 = i + v42;
v37 = i + v43;
}
else
{
v38 = v41 + v42 - i - 1;
v37 = v41 + v43 - i - 1;
}
if ( !v40 )
break;
if ( (*(_BYTE *)(v40 + 5) & 8) == 0 )
break;
if ( v38 < 0 )
break;
v36 = *(unsigned int *)(v40 + 64);
if ( v38 >= v36 || v37 < 0 || v37 >= v36 )
break;
v32 = v41 - i;
if ( a15 >= 0 )
{
v18 = min_int64(v32, v36 - v38);
v33 = min_int64(v18, v36 - v37);
for ( j = 0LL; j < v33; ++j )
{
v24 = v44;
v25 = (long long *)(16 * (j + v37) + *(_QWORD *)(v40 + 56));
v19 = 16 * (j + v38) + *(_QWORD *)(v40 + 56);
v28 = js_dup(*(_DWORD **)v19, *(_QWORD *)(v19 + 8));
set_value(v24, v25, (long long)v28, v20);
}
}
else
{
v15 = min_int64(v32, v38 + 1);
v33 = min_int64(v15, v37 + 1);
for ( k = 0LL; k < v33; ++k )
{
v26 = v44;
v27 = (long long *)(16 * (v37 - k) + *(_QWORD *)(v40 + 56));
v16 = 16 * (v38 - k) + *(_QWORD *)(v40 + 56);
v29 = js_dup(*(_DWORD **)v16, *(_QWORD *)(v16 + 8));
set_value(v26, v27, (long long)v29, v17);
}
}
i += v33;
}
PropertyInt64 = JS_TryGetPropertyInt64(v44, v45, v46, v38, v35);
if ( PropertyInt64 < 0 )
break;
if ( PropertyInt64 )
{
if ( (int)JS_SetPropertyInt64(v44, v45, v46, v37, v35[0], v35[1]) < 0 )
break;
}
else if ( (int)JS_DeletePropertyInt64(v44, v45, v46, v37, 0x4000, a7, a8, a9, a10, v21, v22, a13, a14) < 0 )
{
break;
}
}
return (unsigned int)-1;
}
| JS_CopySubArray:
SUB RSP,0xc8
MOV EAX,dword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0xb0],RSI
MOV qword ptr [RSP + 0xb8],RDX
MOV qword ptr [RSP + 0xa8],RDI
MOV qword ptr [RSP + 0xa0],RCX
MOV qword ptr [RSP + 0x98],R8
MOV qword ptr [RSP + 0x90],R9
MOV qword ptr [RSP + 0x88],0x0
MOV RAX,qword ptr [RSP + 0xb8]
CMP EAX,-0x1
JNZ 0x001864ba
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0x2
JNZ 0x001864ac
MOV RAX,qword ptr [RSP + 0x88]
MOV AL,byte ptr [RAX + 0x5]
SHR AL,0x3
AND AL,0x1
CMP AL,0x0
JNZ 0x001864b8
LAB_001864ac:
MOV qword ptr [RSP + 0x88],0x0
LAB_001864b8:
JMP 0x001864ba
LAB_001864ba:
MOV qword ptr [RSP + 0x80],0x0
LAB_001864c6:
MOV RAX,qword ptr [RSP + 0x80]
CMP RAX,qword ptr [RSP + 0x90]
JGE 0x00186874
CMP dword ptr [RSP + 0xd0],0x0
JGE 0x0018652a
MOV RAX,qword ptr [RSP + 0x98]
ADD RAX,qword ptr [RSP + 0x90]
SUB RAX,qword ptr [RSP + 0x80]
SUB RAX,0x1
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0xa0]
ADD RAX,qword ptr [RSP + 0x90]
SUB RAX,qword ptr [RSP + 0x80]
SUB RAX,0x1
MOV qword ptr [RSP + 0x70],RAX
JMP 0x00186554
LAB_0018652a:
MOV RAX,qword ptr [RSP + 0x98]
ADD RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0xa0]
ADD RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x70],RAX
LAB_00186554:
CMP qword ptr [RSP + 0x88],0x0
JZ 0x001867b7
MOV RAX,qword ptr [RSP + 0x88]
MOV AL,byte ptr [RAX + 0x5]
SHR AL,0x3
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x001867b7
CMP qword ptr [RSP + 0x78],0x0
JL 0x001867b7
MOV RAX,qword ptr [RSP + 0x78]
MOV RCX,qword ptr [RSP + 0x88]
MOV ECX,dword ptr [RCX + 0x40]
MOV qword ptr [RSP + 0x68],RCX
CMP RAX,RCX
JGE 0x001867b7
CMP qword ptr [RSP + 0x70],0x0
JL 0x001867b7
MOV RAX,qword ptr [RSP + 0x70]
CMP RAX,qword ptr [RSP + 0x68]
JGE 0x001867b7
MOV RAX,qword ptr [RSP + 0x90]
SUB RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x48],RAX
CMP dword ptr [RSP + 0xd0],0x0
JGE 0x001866c4
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x78]
ADD RSI,0x1
CALL 0x001868a0
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x70]
ADD RSI,0x1
CALL 0x001868a0
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x40],0x0
LAB_00186621:
MOV RAX,qword ptr [RSP + 0x40]
CMP RAX,qword ptr [RSP + 0x48]
JGE 0x001866bf
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV RAX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RSP + 0x70]
SUB RCX,qword ptr [RSP + 0x40]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV RAX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RSP + 0x78]
SUB RCX,qword ptr [RSP + 0x40]
SHL RCX,0x4
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00120410
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RDX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x38]
CALL 0x00126780
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x1
MOV qword ptr [RSP + 0x40],RAX
JMP 0x00186621
LAB_001866bf:
JMP 0x0018679d
LAB_001866c4:
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x68]
SUB RSI,qword ptr [RSP + 0x78]
CALL 0x001868a0
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x68]
SUB RSI,qword ptr [RSP + 0x70]
CALL 0x001868a0
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x40],0x0
LAB_001866ff:
MOV RAX,qword ptr [RSP + 0x40]
CMP RAX,qword ptr [RSP + 0x48]
JGE 0x0018679b
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV RAX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RSP + 0x70]
ADD RCX,qword ptr [RSP + 0x40]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV RAX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RSP + 0x78]
ADD RCX,qword ptr [RSP + 0x40]
SHL RCX,0x4
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00120410
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
CALL 0x00126780
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x1
MOV qword ptr [RSP + 0x40],RAX
JMP 0x001866ff
LAB_0018679b:
JMP 0x0018679d
LAB_0018679d:
MOV RAX,qword ptr [RSP + 0x48]
ADD RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x80],RAX
JMP 0x0018686f
LAB_001867b7:
MOV RDI,qword ptr [RSP + 0xa8]
MOV RCX,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0xb8]
LEA R8,[RSP + 0x58]
CALL 0x001868e0
MOV dword ptr [RSP + 0x54],EAX
CMP dword ptr [RSP + 0x54],0x0
JGE 0x001867ee
JMP 0x00186881
LAB_001867ee:
CMP dword ptr [RSP + 0x54],0x0
JZ 0x0018682a
MOV RDI,qword ptr [RSP + 0xa8]
MOV RCX,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0xb8]
MOV R8,qword ptr [RSP + 0x58]
MOV R9,qword ptr [RSP + 0x60]
CALL 0x001328f0
CMP EAX,0x0
JGE 0x00186828
JMP 0x00186881
LAB_00186828:
JMP 0x0018685b
LAB_0018682a:
MOV RDI,qword ptr [RSP + 0xa8]
MOV RCX,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0xb8]
MOV R8D,0x4000
CALL 0x00136cd0
CMP EAX,0x0
JGE 0x00186859
JMP 0x00186881
LAB_00186859:
JMP 0x0018685b
LAB_0018685b:
MOV RAX,qword ptr [RSP + 0x80]
ADD RAX,0x1
MOV qword ptr [RSP + 0x80],RAX
LAB_0018686f:
JMP 0x001864c6
LAB_00186874:
MOV dword ptr [RSP + 0xc4],0x0
JMP 0x0018688c
LAB_00186881:
MOV dword ptr [RSP + 0xc4],0xffffffff
LAB_0018688c:
MOV EAX,dword ptr [RSP + 0xc4]
ADD RSP,0xc8
RET
|
int4
JS_CopySubArray(int8 param_1,long param_2,int8 param_3,long param_4,long param_5,
long param_6,int param_7)
{
long lVar1;
int iVar2;
int8 uVar3;
int8 *puVar4;
long lVar5;
int1 auVar6 [16];
long local_88;
long local_80;
int8 local_70;
int8 local_68;
ulong local_60;
long local_58;
long local_50;
long local_48;
long local_40;
long local_38;
long local_30;
long local_28;
int8 local_20;
long local_18;
int8 local_10;
local_40 = 0;
if (((int)param_3 == -1) &&
((*(short *)(param_2 + 6) != 2 || (local_40 = param_2, (*(byte *)(param_2 + 5) >> 3 & 1) == 0))
)) {
local_40 = 0;
}
local_48 = 0;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_1;
local_18 = param_2;
local_10 = param_3;
while( true ) {
while( true ) {
if (local_38 <= local_48) {
return 0;
}
if (param_7 < 0) {
local_50 = ((local_30 + local_38) - local_48) + -1;
local_58 = ((local_28 + local_38) - local_48) + -1;
}
else {
local_50 = local_30 + local_48;
local_58 = local_28 + local_48;
}
if ((((local_40 == 0) || ((*(byte *)(local_40 + 5) >> 3 & 1) == 0)) || (local_50 < 0)) ||
(((local_60 = (ulong)*(uint *)(local_40 + 0x40), (long)local_60 <= local_50 ||
(local_58 < 0)) || ((long)local_60 <= local_58)))) break;
if (param_7 < 0) {
uVar3 = min_int64(local_38 - local_48,local_50 + 1);
local_80 = min_int64(uVar3,local_58 + 1);
for (local_88 = 0; uVar3 = local_20, local_88 < local_80; local_88 = local_88 + 1) {
lVar1 = *(long *)(local_40 + 0x38);
lVar5 = local_58 - local_88;
puVar4 = (int8 *)(*(long *)(local_40 + 0x38) + (local_50 - local_88) * 0x10);
auVar6 = js_dup(*puVar4,puVar4[1]);
set_value(uVar3,lVar1 + lVar5 * 0x10,auVar6._0_8_,auVar6._8_8_);
}
}
else {
uVar3 = min_int64(local_38 - local_48,local_60 - local_50);
local_80 = min_int64(uVar3,local_60 - local_58);
for (local_88 = 0; uVar3 = local_20, local_88 < local_80; local_88 = local_88 + 1) {
lVar1 = *(long *)(local_40 + 0x38);
lVar5 = local_58 + local_88;
puVar4 = (int8 *)(*(long *)(local_40 + 0x38) + (local_50 + local_88) * 0x10);
auVar6 = js_dup(*puVar4,puVar4[1]);
set_value(uVar3,lVar1 + lVar5 * 0x10,auVar6._0_8_,auVar6._8_8_);
}
}
local_48 = local_80 + local_48;
}
iVar2 = JS_TryGetPropertyInt64(local_20,local_18,local_10,local_50,&local_70);
if (iVar2 < 0) break;
if (iVar2 == 0) {
iVar2 = JS_DeletePropertyInt64(local_20,local_18,local_10,local_58,0x4000);
}
else {
iVar2 = JS_SetPropertyInt64(local_20,local_18,local_10,local_58,local_70,local_68);
}
if (iVar2 < 0) {
return 0xffffffff;
}
local_48 = local_48 + 1;
}
return 0xffffffff;
}
| |
32,147 | JS_CopySubArray | bluesky950520[P]quickjs/quickjs.c | static int JS_CopySubArray(JSContext *ctx,
JSValue obj, int64_t to_pos,
int64_t from_pos, int64_t count, int dir)
{
JSObject *p;
int64_t i, from, to, len;
JSValue val;
int fromPresent;
p = NULL;
if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
p = JS_VALUE_GET_OBJ(obj);
if (p->class_id != JS_CLASS_ARRAY || !p->fast_array) {
p = NULL;
}
}
for (i = 0; i < count; ) {
if (dir < 0) {
from = from_pos + count - i - 1;
to = to_pos + count - i - 1;
} else {
from = from_pos + i;
to = to_pos + i;
}
if (p && p->fast_array &&
from >= 0 && from < (len = p->u.array.count) &&
to >= 0 && to < len) {
int64_t l, j;
/* Fast path for fast arrays. Since we don't look at the
prototype chain, we can optimize only the cases where
all the elements are present in the array. */
l = count - i;
if (dir < 0) {
l = min_int64(l, from + 1);
l = min_int64(l, to + 1);
for(j = 0; j < l; j++) {
set_value(ctx, &p->u.array.u.values[to - j],
js_dup(p->u.array.u.values[from - j]));
}
} else {
l = min_int64(l, len - from);
l = min_int64(l, len - to);
for(j = 0; j < l; j++) {
set_value(ctx, &p->u.array.u.values[to + j],
js_dup(p->u.array.u.values[from + j]));
}
}
i += l;
} else {
fromPresent = JS_TryGetPropertyInt64(ctx, obj, from, &val);
if (fromPresent < 0)
goto exception;
if (fromPresent) {
if (JS_SetPropertyInt64(ctx, obj, to, val) < 0)
goto exception;
} else {
if (JS_DeletePropertyInt64(ctx, obj, to, JS_PROP_THROW) < 0)
goto exception;
}
i++;
}
}
return 0;
exception:
return -1;
} | O2 | c | JS_CopySubArray:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r12
movq %r8, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdi, %rbp
movq %rdx, 0x10(%rsp)
cmpl $-0x1, %edx
jne 0x41926
cmpw $0x2, 0x6(%rsi)
jne 0x41926
testb $0x8, 0x5(%rsi)
movq %rsi, %r13
jne 0x41929
xorl %r13d, %r13d
movq %rsi, 0x8(%rsp)
movq 0x28(%rsp), %rax
addq %r12, %rax
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rax
addq %r12, %rax
movq %rax, 0x30(%rsp)
xorl %r14d, %r14d
movq %r12, 0x18(%rsp)
movq %r12, %rax
subq %r14, %rax
jle 0x41afb
cmpl $0x0, 0x90(%rsp)
movq %r14, 0x40(%rsp)
js 0x4197e
movq 0x28(%rsp), %rcx
leaq (%r14,%rcx), %r15
movq 0x20(%rsp), %rcx
addq %rcx, %r14
jmp 0x4198f
notq %r14
movq 0x38(%rsp), %rcx
leaq (%rcx,%r14), %r15
addq 0x30(%rsp), %r14
testq %r13, %r13
je 0x41a1d
testb $0x8, 0x5(%r13)
je 0x41a1d
testq %r15, %r15
js 0x41a1d
movl 0x40(%r13), %ecx
movq %rcx, %rbx
subq %r15, %rbx
jbe 0x41a1d
subq %r14, %rcx
jbe 0x41a1d
cmpl $0x0, 0x90(%rsp)
js 0x41a91
cmpq %rbx, %rax
cmovlq %rax, %rbx
cmpq %rcx, %rbx
cmovgeq %rcx, %rbx
testq %rbx, %rbx
movl $0x0, %r12d
cmovgq %rbx, %r12
shlq $0x4, %r15
orq $0x8, %r15
shlq $0x4, %r14
subq $0x1, %r12
jb 0x41aef
movq 0x38(%r13), %rsi
movq -0x8(%rsi,%r15), %rdx
movq (%rsi,%r15), %rcx
cmpl $-0x9, %ecx
jb 0x41a08
incl (%rdx)
addq %r14, %rsi
movq %rbp, %rdi
callq 0x19370
addq $0x10, %r15
addq $0x10, %r14
jmp 0x419ea
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rcx
leaq 0x48(%rsp), %r8
callq 0x41b0c
testl %eax, %eax
js 0x41af6
je 0x41a62
movq 0x48(%rsp), %r8
movq 0x50(%rsp), %r9
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
callq 0x1e52a
jmp 0x41a7d
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
movl $0x4000, %r8d # imm = 0x4000
callq 0x2052d
pushq $0x1
popq %rbx
testl %eax, %eax
js 0x41af6
movq 0x40(%rsp), %r14
addq %rbx, %r14
jmp 0x41950
leaq 0x1(%r15), %rbx
cmpq %rbx, %rax
cmovlq %rax, %rbx
leaq 0x1(%r14), %rax
cmpq %rax, %rbx
cmovgeq %rax, %rbx
testq %rbx, %rbx
movl $0x0, %r12d
cmovgq %rbx, %r12
shlq $0x4, %r14
shlq $0x4, %r15
orq $0x8, %r15
subq $0x1, %r12
jb 0x41aef
movq 0x38(%r13), %rsi
movq -0x8(%rsi,%r15), %rdx
movq (%rsi,%r15), %rcx
cmpl $-0x9, %ecx
jb 0x41ada
incl (%rdx)
addq %r14, %rsi
movq %rbp, %rdi
callq 0x19370
addq $-0x10, %r14
addq $-0x10, %r15
jmp 0x41ac0
movq 0x18(%rsp), %r12
jmp 0x41a84
pushq $-0x1
popq %rax
jmp 0x41afd
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| JS_CopySubArray:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r12, r9
mov [rsp+88h+var_60], r8
mov [rsp+88h+var_68], rcx
mov rbp, rdi
mov [rsp+88h+var_78], rdx
cmp edx, 0FFFFFFFFh
jnz short loc_41926
cmp word ptr [rsi+6], 2
jnz short loc_41926
test byte ptr [rsi+5], 8
mov r13, rsi
jnz short loc_41929
loc_41926:
xor r13d, r13d
loc_41929:
mov [rsp+88h+var_80], rsi
mov rax, [rsp+88h+var_60]
add rax, r12
mov [rsp+88h+var_50], rax
mov rax, [rsp+88h+var_68]
add rax, r12
mov [rsp+88h+var_58], rax
xor r14d, r14d
mov [rsp+88h+var_70], r12
loc_41950:
mov rax, r12
sub rax, r14
jle loc_41AFB
cmp [rsp+88h+arg_0], 0
mov [rsp+88h+var_48], r14
js short loc_4197E
mov rcx, [rsp+88h+var_60]
lea r15, [r14+rcx]
mov rcx, [rsp+88h+var_68]
add r14, rcx
jmp short loc_4198F
loc_4197E:
not r14
mov rcx, [rsp+88h+var_50]
lea r15, [rcx+r14]
add r14, [rsp+88h+var_58]
loc_4198F:
test r13, r13
jz loc_41A1D
test byte ptr [r13+5], 8
jz short loc_41A1D
test r15, r15
js short loc_41A1D
mov ecx, [r13+40h]
mov rbx, rcx
sub rbx, r15
jbe short loc_41A1D
sub rcx, r14
jbe short loc_41A1D
cmp [rsp+88h+arg_0], 0
js loc_41A91
cmp rax, rbx
cmovl rbx, rax
cmp rbx, rcx
cmovge rbx, rcx
test rbx, rbx
mov r12d, 0
cmovg r12, rbx
shl r15, 4
or r15, 8
shl r14, 4
loc_419EA:
sub r12, 1
jb loc_41AEF
mov rsi, [r13+38h]
mov rdx, [rsi+r15-8]
mov rcx, [rsi+r15]
cmp ecx, 0FFFFFFF7h
jb short loc_41A08
inc dword ptr [rdx]
loc_41A08:
add rsi, r14
mov rdi, rbp
call set_value
add r15, 10h
add r14, 10h
jmp short loc_419EA
loc_41A1D:
mov rdi, rbp
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rcx, r15
lea r8, [rsp+88h+var_40]
call JS_TryGetPropertyInt64
test eax, eax
js loc_41AF6
jz short loc_41A62
mov r8, [rsp+88h+var_40]
mov r9, [rsp+88h+var_38]
mov rdi, rbp
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rcx, r14
call JS_SetPropertyInt64
jmp short loc_41A7D
loc_41A62:
mov rdi, rbp
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rcx, r14
mov r8d, 4000h
call JS_DeletePropertyInt64
loc_41A7D:
push 1
pop rbx
test eax, eax
js short loc_41AF6
loc_41A84:
mov r14, [rsp+88h+var_48]
add r14, rbx
jmp loc_41950
loc_41A91:
lea rbx, [r15+1]
cmp rax, rbx
cmovl rbx, rax
lea rax, [r14+1]
cmp rbx, rax
cmovge rbx, rax
test rbx, rbx
mov r12d, 0
cmovg r12, rbx
shl r14, 4
shl r15, 4
or r15, 8
loc_41AC0:
sub r12, 1
jb short loc_41AEF
mov rsi, [r13+38h]
mov rdx, [rsi+r15-8]
mov rcx, [rsi+r15]
cmp ecx, 0FFFFFFF7h
jb short loc_41ADA
inc dword ptr [rdx]
loc_41ADA:
add rsi, r14
mov rdi, rbp
call set_value
add r14, 0FFFFFFFFFFFFFFF0h
add r15, 0FFFFFFFFFFFFFFF0h
jmp short loc_41AC0
loc_41AEF:
mov r12, [rsp+88h+var_70]
jmp short loc_41A84
loc_41AF6:
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_41AFD
loc_41AFB:
xor eax, eax
loc_41AFD:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long JS_CopySubArray(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
int a15)
{
long long v15; // r12
long long v16; // r13
long long i; // r14
long long v18; // rax
long long v19; // r15
unsigned long long v20; // r14
long long v21; // r14
unsigned long long v22; // rcx
long long v23; // rbx
bool v24; // cc
long long v25; // rcx
long long v26; // r12
long long v27; // r15
long long k; // r14
bool v29; // cf
long long v30; // rsi
_DWORD *v31; // rdx
long long v32; // rcx
int PropertyInt64; // eax
double v34; // xmm4_8
double v35; // xmm5_8
int v36; // eax
long long v37; // r12
long long v38; // r14
long long j; // r15
long long v40; // rsi
_DWORD *v41; // rdx
long long v42; // rcx
long long v49; // [rsp+30h] [rbp-58h]
long long v50; // [rsp+38h] [rbp-50h]
long long v51; // [rsp+40h] [rbp-48h]
long long v52[8]; // [rsp+48h] [rbp-40h] BYREF
v15 = a6;
if ( (_DWORD)a3 != -1 || *(_WORD *)(a2 + 6) != 2 || (v16 = a2, (*(_BYTE *)(a2 + 5) & 8) == 0) )
v16 = 0LL;
v50 = a6 + a5;
v49 = a6 + a4;
for ( i = 0LL; ; i = v23 + v51 )
{
v18 = v15 - i;
if ( v15 <= i )
break;
v51 = i;
if ( a15 < 0 )
{
v21 = ~i;
v19 = v50 + v21;
v20 = v49 + v21;
}
else
{
v19 = i + a5;
v20 = a4 + i;
}
if ( v16
&& (*(_BYTE *)(v16 + 5) & 8) != 0
&& v19 >= 0
&& (v22 = *(unsigned int *)(v16 + 64), v23 = v22 - v19, v22 > v19)
&& (v24 = v22 <= v20, v25 = v22 - v20, !v24) )
{
if ( a15 < 0 )
{
v23 = v19 + 1;
if ( v18 < v19 + 1 )
v23 = v18;
if ( v23 >= (long long)(v20 + 1) )
v23 = v20 + 1;
v37 = 0LL;
if ( v23 > 0 )
v37 = v23;
v38 = 16 * v20;
for ( j = (16 * v19) | 8; ; j -= 16LL )
{
v29 = v37-- == 0;
if ( v29 )
break;
v40 = *(_QWORD *)(v16 + 56);
v41 = *(_DWORD **)(v40 + j - 8);
v42 = *(_QWORD *)(v40 + j);
if ( (unsigned int)v42 >= 0xFFFFFFF7 )
++*v41;
set_value(a1, (long long *)(v38 + v40), (long long)v41, v42);
v38 -= 16LL;
}
}
else
{
if ( v18 < v23 )
v23 = v18;
if ( v23 >= v25 )
v23 = v25;
v26 = 0LL;
if ( v23 > 0 )
v26 = v23;
v27 = (16 * v19) | 8;
for ( k = 16 * v20; ; k += 16LL )
{
v29 = v26-- == 0;
if ( v29 )
break;
v30 = *(_QWORD *)(v16 + 56);
v31 = *(_DWORD **)(v30 + v27 - 8);
v32 = *(_QWORD *)(v30 + v27);
if ( (unsigned int)v32 >= 0xFFFFFFF7 )
++*v31;
set_value(a1, (long long *)(k + v30), (long long)v31, v32);
v27 += 16LL;
}
}
v15 = a6;
}
else
{
PropertyInt64 = JS_TryGetPropertyInt64(a1, a2, a3, v19, v52);
if ( PropertyInt64 < 0 )
return -1LL;
v36 = PropertyInt64
? JS_SetPropertyInt64(a1, a2, a3, v20, v52[0], v52[1])
: JS_DeletePropertyInt64(a1, a2, a3, v20, 0x4000, a7, a8, a9, a10, v34, v35, a13, a14);
v23 = 1LL;
if ( v36 < 0 )
return -1LL;
}
}
return 0LL;
}
| JS_CopySubArray:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R12,R9
MOV qword ptr [RSP + 0x28],R8
MOV qword ptr [RSP + 0x20],RCX
MOV RBP,RDI
MOV qword ptr [RSP + 0x10],RDX
CMP EDX,-0x1
JNZ 0x00141926
CMP word ptr [RSI + 0x6],0x2
JNZ 0x00141926
TEST byte ptr [RSI + 0x5],0x8
MOV R13,RSI
JNZ 0x00141929
LAB_00141926:
XOR R13D,R13D
LAB_00141929:
MOV qword ptr [RSP + 0x8],RSI
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,R12
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,R12
MOV qword ptr [RSP + 0x30],RAX
XOR R14D,R14D
MOV qword ptr [RSP + 0x18],R12
LAB_00141950:
MOV RAX,R12
SUB RAX,R14
JLE 0x00141afb
CMP dword ptr [RSP + 0x90],0x0
MOV qword ptr [RSP + 0x40],R14
JS 0x0014197e
MOV RCX,qword ptr [RSP + 0x28]
LEA R15,[R14 + RCX*0x1]
MOV RCX,qword ptr [RSP + 0x20]
ADD R14,RCX
JMP 0x0014198f
LAB_0014197e:
NOT R14
MOV RCX,qword ptr [RSP + 0x38]
LEA R15,[RCX + R14*0x1]
ADD R14,qword ptr [RSP + 0x30]
LAB_0014198f:
TEST R13,R13
JZ 0x00141a1d
TEST byte ptr [R13 + 0x5],0x8
JZ 0x00141a1d
TEST R15,R15
JS 0x00141a1d
MOV ECX,dword ptr [R13 + 0x40]
MOV RBX,RCX
SUB RBX,R15
JBE 0x00141a1d
SUB RCX,R14
JBE 0x00141a1d
CMP dword ptr [RSP + 0x90],0x0
JS 0x00141a91
CMP RAX,RBX
CMOVL RBX,RAX
CMP RBX,RCX
CMOVGE RBX,RCX
TEST RBX,RBX
MOV R12D,0x0
CMOVG R12,RBX
SHL R15,0x4
OR R15,0x8
SHL R14,0x4
LAB_001419ea:
SUB R12,0x1
JC 0x00141aef
MOV RSI,qword ptr [R13 + 0x38]
MOV RDX,qword ptr [RSI + R15*0x1 + -0x8]
MOV RCX,qword ptr [RSI + R15*0x1]
CMP ECX,-0x9
JC 0x00141a08
INC dword ptr [RDX]
LAB_00141a08:
ADD RSI,R14
MOV RDI,RBP
CALL 0x00119370
ADD R15,0x10
ADD R14,0x10
JMP 0x001419ea
LAB_00141a1d:
MOV RDI,RBP
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,R15
LEA R8,[RSP + 0x48]
CALL 0x00141b0c
TEST EAX,EAX
JS 0x00141af6
JZ 0x00141a62
MOV R8,qword ptr [RSP + 0x48]
MOV R9,qword ptr [RSP + 0x50]
MOV RDI,RBP
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,R14
CALL 0x0011e52a
JMP 0x00141a7d
LAB_00141a62:
MOV RDI,RBP
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,R14
MOV R8D,0x4000
CALL 0x0012052d
LAB_00141a7d:
PUSH 0x1
POP RBX
TEST EAX,EAX
JS 0x00141af6
LAB_00141a84:
MOV R14,qword ptr [RSP + 0x40]
ADD R14,RBX
JMP 0x00141950
LAB_00141a91:
LEA RBX,[R15 + 0x1]
CMP RAX,RBX
CMOVL RBX,RAX
LEA RAX,[R14 + 0x1]
CMP RBX,RAX
CMOVGE RBX,RAX
TEST RBX,RBX
MOV R12D,0x0
CMOVG R12,RBX
SHL R14,0x4
SHL R15,0x4
OR R15,0x8
LAB_00141ac0:
SUB R12,0x1
JC 0x00141aef
MOV RSI,qword ptr [R13 + 0x38]
MOV RDX,qword ptr [RSI + R15*0x1 + -0x8]
MOV RCX,qword ptr [RSI + R15*0x1]
CMP ECX,-0x9
JC 0x00141ada
INC dword ptr [RDX]
LAB_00141ada:
ADD RSI,R14
MOV RDI,RBP
CALL 0x00119370
ADD R14,-0x10
ADD R15,-0x10
JMP 0x00141ac0
LAB_00141aef:
MOV R12,qword ptr [RSP + 0x18]
JMP 0x00141a84
LAB_00141af6:
PUSH -0x1
POP RAX
JMP 0x00141afd
LAB_00141afb:
XOR EAX,EAX
LAB_00141afd:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
JS_CopySubArray(int8 param_1,long param_2,int8 param_3,long param_4,long param_5,
long param_6,int param_7)
{
long lVar1;
int *piVar2;
int iVar3;
long lVar4;
ulong uVar5;
long lVar6;
long lVar7;
long lVar8;
ulong uVar9;
ulong uVar10;
ulong uVar11;
bool bVar12;
int8 local_40;
int8 local_38;
if ((((int)param_3 != -1) || (*(short *)(param_2 + 6) != 2)) ||
(lVar8 = param_2, (*(byte *)(param_2 + 5) & 8) == 0)) {
lVar8 = 0;
}
uVar10 = 0;
do {
lVar4 = param_6 - uVar10;
if (lVar4 == 0 || param_6 < (long)uVar10) {
return 0;
}
if (param_7 < 0) {
uVar11 = param_5 + param_6 + ~uVar10;
uVar9 = ~uVar10 + param_4 + param_6;
}
else {
uVar11 = uVar10 + param_5;
uVar9 = uVar10 + param_4;
}
if (((lVar8 == 0) || ((*(byte *)(lVar8 + 5) & 8) == 0)) || ((long)uVar11 < 0)) {
LAB_00141a1d:
iVar3 = JS_TryGetPropertyInt64(param_1,param_2,param_3,uVar11,&local_40);
if (iVar3 < 0) {
return 0xffffffffffffffff;
}
if (iVar3 == 0) {
iVar3 = JS_DeletePropertyInt64(param_1,param_2,param_3,uVar9,0x4000);
}
else {
iVar3 = JS_SetPropertyInt64(param_1,param_2,param_3,uVar9,local_40,local_38);
}
lVar7 = 1;
if (iVar3 < 0) {
return 0xffffffffffffffff;
}
}
else {
uVar5 = (ulong)*(uint *)(lVar8 + 0x40);
lVar7 = uVar5 - uVar11;
if ((uVar5 < uVar11 || lVar7 == 0) || (lVar6 = uVar5 - uVar9, uVar5 < uVar9 || lVar6 == 0))
goto LAB_00141a1d;
if (param_7 < 0) {
lVar7 = uVar11 + 1;
if (lVar4 < (long)(uVar11 + 1)) {
lVar7 = lVar4;
}
if ((long)(uVar9 + 1) <= lVar7) {
lVar7 = uVar9 + 1;
}
lVar4 = 0;
if (0 < lVar7) {
lVar4 = lVar7;
}
lVar6 = uVar9 << 4;
uVar11 = uVar11 << 4 | 8;
while (bVar12 = lVar4 != 0, lVar4 = lVar4 + -1, bVar12) {
lVar1 = *(long *)(lVar8 + 0x38);
piVar2 = *(int **)(lVar1 + -8 + uVar11);
if (0xfffffff6 < (uint)*(int8 *)(lVar1 + uVar11)) {
*piVar2 = *piVar2 + 1;
}
set_value(param_1,lVar1 + lVar6);
lVar6 = lVar6 + -0x10;
uVar11 = uVar11 - 0x10;
}
}
else {
if (lVar4 < lVar7) {
lVar7 = lVar4;
}
if (lVar6 <= lVar7) {
lVar7 = lVar6;
}
lVar4 = 0;
if (0 < lVar7) {
lVar4 = lVar7;
}
uVar11 = uVar11 << 4 | 8;
lVar6 = uVar9 << 4;
while (bVar12 = lVar4 != 0, lVar4 = lVar4 + -1, bVar12) {
lVar1 = *(long *)(lVar8 + 0x38);
piVar2 = *(int **)(lVar1 + -8 + uVar11);
if (0xfffffff6 < (uint)*(int8 *)(lVar1 + uVar11)) {
*piVar2 = *piVar2 + 1;
}
set_value(param_1,lVar1 + lVar6);
uVar11 = uVar11 + 0x10;
lVar6 = lVar6 + 0x10;
}
}
}
uVar10 = uVar10 + lVar7;
} while( true );
}
| |
32,148 | JS_CopySubArray | bluesky950520[P]quickjs/quickjs.c | static int JS_CopySubArray(JSContext *ctx,
JSValue obj, int64_t to_pos,
int64_t from_pos, int64_t count, int dir)
{
JSObject *p;
int64_t i, from, to, len;
JSValue val;
int fromPresent;
p = NULL;
if (JS_VALUE_GET_TAG(obj) == JS_TAG_OBJECT) {
p = JS_VALUE_GET_OBJ(obj);
if (p->class_id != JS_CLASS_ARRAY || !p->fast_array) {
p = NULL;
}
}
for (i = 0; i < count; ) {
if (dir < 0) {
from = from_pos + count - i - 1;
to = to_pos + count - i - 1;
} else {
from = from_pos + i;
to = to_pos + i;
}
if (p && p->fast_array &&
from >= 0 && from < (len = p->u.array.count) &&
to >= 0 && to < len) {
int64_t l, j;
/* Fast path for fast arrays. Since we don't look at the
prototype chain, we can optimize only the cases where
all the elements are present in the array. */
l = count - i;
if (dir < 0) {
l = min_int64(l, from + 1);
l = min_int64(l, to + 1);
for(j = 0; j < l; j++) {
set_value(ctx, &p->u.array.u.values[to - j],
js_dup(p->u.array.u.values[from - j]));
}
} else {
l = min_int64(l, len - from);
l = min_int64(l, len - to);
for(j = 0; j < l; j++) {
set_value(ctx, &p->u.array.u.values[to + j],
js_dup(p->u.array.u.values[from + j]));
}
}
i += l;
} else {
fromPresent = JS_TryGetPropertyInt64(ctx, obj, from, &val);
if (fromPresent < 0)
goto exception;
if (fromPresent) {
if (JS_SetPropertyInt64(ctx, obj, to, val) < 0)
goto exception;
} else {
if (JS_DeletePropertyInt64(ctx, obj, to, JS_PROP_THROW) < 0)
goto exception;
}
i++;
}
}
return 0;
exception:
return -1;
} | O3 | c | JS_CopySubArray:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movq %r8, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x8(%rsp)
xorl %r15d, %r15d
cmpl $-0x1, %edx
jne 0x4e742
cmpw $0x2, 0x6(%rsi)
jne 0x4e742
testb $0x8, 0x5(%rsi)
movq %rsi, %r13
jne 0x4e745
xorl %r13d, %r13d
movq %rsi, 0x10(%rsp)
testq %rbx, %rbx
jle 0x4e978
movq 0x28(%rsp), %rax
addq %rbx, %rax
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rax
addq %rbx, %rax
movq %rax, 0x30(%rsp)
xorl %r12d, %r12d
movq %rbx, 0x18(%rsp)
cmpl $0x0, 0x90(%rsp)
js 0x4e793
movq 0x28(%rsp), %rax
leaq (%r12,%rax), %r15
movq 0x20(%rsp), %rax
leaq (%r12,%rax), %r14
jmp 0x4e7a7
movq %r12, %r14
notq %r14
movq 0x38(%rsp), %rax
leaq (%rax,%r14), %r15
addq 0x30(%rsp), %r14
testq %r13, %r13
je 0x4e86a
testb $0x8, 0x5(%r13)
je 0x4e86a
testq %r15, %r15
js 0x4e86a
movl 0x40(%r13), %eax
movq %rax, %rbp
subq %r15, %rbp
jbe 0x4e86a
subq %r14, %rax
jbe 0x4e86a
movq %rbx, %rcx
subq %r12, %rcx
cmpl $0x0, 0x90(%rsp)
js 0x4e8f3
cmpq %rbp, %rcx
cmovlq %rcx, %rbp
cmpq %rax, %rbp
cmovgeq %rax, %rbp
testq %rbp, %rbp
jle 0x4e8e2
shlq $0x4, %r14
shlq $0x4, %r15
movq %rbp, %rbx
movq 0x38(%r13), %rax
movq (%rax,%r15), %rcx
movq 0x8(%rax,%r15), %rdi
cmpl $-0x9, %edi
jb 0x4e827
incl (%rcx)
movq (%rax,%r14), %rsi
movq 0x8(%rax,%r14), %rdx
movq %rcx, (%rax,%r14)
movq %rdi, 0x8(%rax,%r14)
cmpl $-0x9, %edx
jb 0x4e858
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x4e858
callq 0x20d90
addq $0x10, %r14
addq $0x10, %r15
decq %rbx
jne 0x4e813
jmp 0x4e96b
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x40(%rsp), %rbp
movq %rbp, %rdx
movq %r15, %rcx
leaq 0x48(%rsp), %r8
callq 0x4e98a
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x4e978
je 0x4e8ba
movq 0x48(%rsp), %r8
movq 0x50(%rsp), %r9
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x24d20
jmp 0x4e8d5
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
movq %r14, %rcx
movl $0x4000, %r8d # imm = 0x4000
callq 0x26f31
movl $0x1, %ebp
testl %eax, %eax
js 0x4e978
addq %rbp, %r12
cmpq %rbx, %r12
jl 0x4e775
jmp 0x4e975
leaq 0x1(%r15), %rbp
cmpq %rbp, %rcx
cmovlq %rcx, %rbp
leaq 0x1(%r14), %rax
cmpq %rax, %rbp
cmovgeq %rax, %rbp
testq %rbp, %rbp
jle 0x4e8e2
shlq $0x4, %r15
shlq $0x4, %r14
movq %rbp, %rbx
movq 0x38(%r13), %rax
movq (%rax,%r15), %rcx
movq 0x8(%rax,%r15), %rdi
cmpl $-0x9, %edi
jb 0x4e92d
incl (%rcx)
movq (%rax,%r14), %rsi
movq 0x8(%rax,%r14), %rdx
movq %rcx, (%rax,%r14)
movq %rdi, 0x8(%rax,%r14)
cmpl $-0x9, %edx
jb 0x4e95e
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x4e95e
callq 0x20d90
addq $-0x10, %r15
addq $-0x10, %r14
decq %rbx
jne 0x4e919
movq 0x18(%rsp), %rbx
jmp 0x4e8e2
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| JS_CopySubArray:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, r9
mov [rsp+88h+var_60], r8
mov [rsp+88h+var_68], rcx
mov [rsp+88h+var_48], rdx
mov [rsp+88h+var_80], rdi
xor r15d, r15d
cmp edx, 0FFFFFFFFh
jnz short loc_4E742
cmp word ptr [rsi+6], 2
jnz short loc_4E742
test byte ptr [rsi+5], 8
mov r13, rsi
jnz short loc_4E745
loc_4E742:
xor r13d, r13d
loc_4E745:
mov [rsp+88h+var_78], rsi
test rbx, rbx
jle loc_4E978
mov rax, [rsp+88h+var_60]
add rax, rbx
mov [rsp+88h+var_50], rax
mov rax, [rsp+88h+var_68]
add rax, rbx
mov [rsp+88h+var_58], rax
xor r12d, r12d
mov [rsp+88h+var_70], rbx
loc_4E775:
cmp [rsp+88h+arg_0], 0
js short loc_4E793
mov rax, [rsp+88h+var_60]
lea r15, [r12+rax]
mov rax, [rsp+88h+var_68]
lea r14, [r12+rax]
jmp short loc_4E7A7
loc_4E793:
mov r14, r12
not r14
mov rax, [rsp+88h+var_50]
lea r15, [rax+r14]
add r14, [rsp+88h+var_58]
loc_4E7A7:
test r13, r13
jz loc_4E86A
test byte ptr [r13+5], 8
jz loc_4E86A
test r15, r15
js loc_4E86A
mov eax, [r13+40h]
mov rbp, rax
sub rbp, r15
jbe loc_4E86A
sub rax, r14
jbe loc_4E86A
mov rcx, rbx
sub rcx, r12
cmp [rsp+88h+arg_0], 0
js loc_4E8F3
cmp rcx, rbp
cmovl rbp, rcx
cmp rbp, rax
cmovge rbp, rax
test rbp, rbp
jle loc_4E8E2
shl r14, 4
shl r15, 4
mov rbx, rbp
loc_4E813:
mov rax, [r13+38h]
mov rcx, [rax+r15]
mov rdi, [rax+r15+8]
cmp edi, 0FFFFFFF7h
jb short loc_4E827
inc dword ptr [rcx]
loc_4E827:
mov rsi, [rax+r14]
mov rdx, [rax+r14+8]
mov [rax+r14], rcx
mov [rax+r14+8], rdi
cmp edx, 0FFFFFFF7h
jb short loc_4E858
mov rax, [rsp+88h+var_80]
mov rdi, [rax+18h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_4E858
call js_free_value_rt
loc_4E858:
add r14, 10h
add r15, 10h
dec rbx
jnz short loc_4E813
jmp loc_4E96B
loc_4E86A:
mov rdi, [rsp+88h+var_80]
mov rsi, [rsp+88h+var_78]
mov rbp, [rsp+88h+var_48]
mov rdx, rbp
mov rcx, r15
lea r8, [rsp+88h+var_40]
call JS_TryGetPropertyInt64
mov r15d, 0FFFFFFFFh
test eax, eax
js loc_4E978
jz short loc_4E8BA
mov r8, [rsp+88h+var_40]
mov r9, [rsp+88h+var_38]
mov rdi, [rsp+88h+var_80]
mov rsi, [rsp+88h+var_78]
mov rdx, rbp
mov rcx, r14
call JS_SetPropertyInt64
jmp short loc_4E8D5
loc_4E8BA:
mov rdi, [rsp+88h+var_80]
mov rsi, [rsp+88h+var_78]
mov rdx, rbp
mov rcx, r14
mov r8d, 4000h
call JS_DeletePropertyInt64
loc_4E8D5:
mov ebp, 1
test eax, eax
js loc_4E978
loc_4E8E2:
add r12, rbp
cmp r12, rbx
jl loc_4E775
jmp loc_4E975
loc_4E8F3:
lea rbp, [r15+1]
cmp rcx, rbp
cmovl rbp, rcx
lea rax, [r14+1]
cmp rbp, rax
cmovge rbp, rax
test rbp, rbp
jle short loc_4E8E2
shl r15, 4
shl r14, 4
mov rbx, rbp
loc_4E919:
mov rax, [r13+38h]
mov rcx, [rax+r15]
mov rdi, [rax+r15+8]
cmp edi, 0FFFFFFF7h
jb short loc_4E92D
inc dword ptr [rcx]
loc_4E92D:
mov rsi, [rax+r14]
mov rdx, [rax+r14+8]
mov [rax+r14], rcx
mov [rax+r14+8], rdi
cmp edx, 0FFFFFFF7h
jb short loc_4E95E
mov rax, [rsp+88h+var_80]
mov rdi, [rax+18h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_4E95E
call js_free_value_rt
loc_4E95E:
add r15, 0FFFFFFFFFFFFFFF0h
add r14, 0FFFFFFFFFFFFFFF0h
dec rbx
jnz short loc_4E919
loc_4E96B:
mov rbx, [rsp+88h+var_70]
jmp loc_4E8E2
loc_4E975:
xor r15d, r15d
loc_4E978:
mov eax, r15d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long JS_CopySubArray(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
int a15)
{
long long v15; // rbx
unsigned int v16; // r15d
long long v17; // r13
long long v18; // r12
long long v19; // r15
unsigned long long v20; // r14
unsigned long long v21; // rax
long long v22; // rbp
bool v23; // cc
long long v24; // rax
long long v25; // rcx
long long v26; // r14
long long v27; // r15
long long v28; // rbx
long long v29; // rax
_DWORD *v30; // rcx
long long v31; // rdi
_QWORD *v32; // rsi
long long v33; // rdx
long long v34; // rdi
int v35; // eax
long long v36; // rcx
int PropertyInt64; // eax
double v38; // xmm4_8
double v39; // xmm5_8
int v40; // eax
long long v41; // r15
long long v42; // r14
long long v43; // rbx
long long v44; // rax
_DWORD *v45; // rcx
long long v46; // rdi
_QWORD *v47; // rsi
long long v48; // rdx
long long v49; // rdi
int v50; // eax
long long v51; // rcx
long long v58; // [rsp+30h] [rbp-58h]
long long v59; // [rsp+38h] [rbp-50h]
_QWORD *v61[8]; // [rsp+48h] [rbp-40h] BYREF
v15 = a6;
v16 = 0;
if ( (_DWORD)a3 != -1 || *(_WORD *)(a2 + 6) != 2 || (v17 = a2, (*(_BYTE *)(a2 + 5) & 8) == 0) )
v17 = 0LL;
if ( a6 > 0 )
{
v59 = a6 + a5;
v58 = a6 + a4;
v18 = 0LL;
while ( 1 )
{
if ( a15 < 0 )
{
v19 = v59 + ~v18;
v20 = v58 + ~v18;
}
else
{
v19 = v18 + a5;
v20 = v18 + a4;
}
if ( !v17
|| (*(_BYTE *)(v17 + 5) & 8) == 0
|| v19 < 0
|| (v21 = *(unsigned int *)(v17 + 64), v22 = v21 - v19, v21 <= v19)
|| (v23 = v21 <= v20, v24 = v21 - v20, v23) )
{
PropertyInt64 = JS_TryGetPropertyInt64(a1, a2, a3, v19, v61);
v16 = -1;
if ( PropertyInt64 < 0 )
return v16;
v40 = PropertyInt64
? JS_SetPropertyInt64(
a1,
a2,
a3,
(int *)v20,
v61[0],
(long long)v61[1],
*(double *)a7.m128_u64,
a8,
a9,
a10,
v38,
v39,
a13,
a14)
: JS_DeletePropertyInt64(a1, a2, a3, v20, 0x4000, a7, a8, a9, a10, v38, v39, a13, a14);
v22 = 1LL;
if ( v40 < 0 )
return v16;
goto LABEL_34;
}
v25 = v15 - v18;
if ( a15 < 0 )
{
v22 = v19 + 1;
if ( v25 < v19 + 1 )
v22 = v15 - v18;
if ( v22 >= (long long)(v20 + 1) )
v22 = v20 + 1;
if ( v22 <= 0 )
goto LABEL_34;
v41 = 16 * v19;
v42 = 16 * v20;
v43 = v22;
do
{
v44 = *(_QWORD *)(v17 + 56);
v45 = *(_DWORD **)(v44 + v41);
v46 = *(_QWORD *)(v44 + v41 + 8);
if ( (unsigned int)v46 >= 0xFFFFFFF7 )
++*v45;
v47 = *(_QWORD **)(v44 + v42);
v48 = *(_QWORD *)(v44 + v42 + 8);
*(_QWORD *)(v44 + v42) = v45;
*(_QWORD *)(v44 + v42 + 8) = v46;
if ( (unsigned int)v48 >= 0xFFFFFFF7 )
{
v49 = *(_QWORD *)(a1 + 24);
v50 = *(_DWORD *)v47;
v51 = (unsigned int)(*(_DWORD *)v47 - 1);
*(_DWORD *)v47 = v51;
if ( v50 <= 1 )
js_free_value_rt(v49, v47, v48, v51, a5, a6);
}
v41 -= 16LL;
v42 -= 16LL;
--v43;
}
while ( v43 );
}
else
{
if ( v25 < v22 )
v22 = v15 - v18;
if ( v22 >= v24 )
v22 = v24;
if ( v22 <= 0 )
goto LABEL_34;
v26 = 16 * v20;
v27 = 16 * v19;
v28 = v22;
do
{
v29 = *(_QWORD *)(v17 + 56);
v30 = *(_DWORD **)(v29 + v27);
v31 = *(_QWORD *)(v29 + v27 + 8);
if ( (unsigned int)v31 >= 0xFFFFFFF7 )
++*v30;
v32 = *(_QWORD **)(v29 + v26);
v33 = *(_QWORD *)(v29 + v26 + 8);
*(_QWORD *)(v29 + v26) = v30;
*(_QWORD *)(v29 + v26 + 8) = v31;
if ( (unsigned int)v33 >= 0xFFFFFFF7 )
{
v34 = *(_QWORD *)(a1 + 24);
v35 = *(_DWORD *)v32;
v36 = (unsigned int)(*(_DWORD *)v32 - 1);
*(_DWORD *)v32 = v36;
if ( v35 <= 1 )
js_free_value_rt(v34, v32, v33, v36, a5, a6);
}
v26 += 16LL;
v27 += 16LL;
--v28;
}
while ( v28 );
}
v15 = a6;
LABEL_34:
v18 += v22;
if ( v18 >= v15 )
return 0;
}
}
return v16;
}
| JS_CopySubArray:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,R9
MOV qword ptr [RSP + 0x28],R8
MOV qword ptr [RSP + 0x20],RCX
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x8],RDI
XOR R15D,R15D
CMP EDX,-0x1
JNZ 0x0014e742
CMP word ptr [RSI + 0x6],0x2
JNZ 0x0014e742
TEST byte ptr [RSI + 0x5],0x8
MOV R13,RSI
JNZ 0x0014e745
LAB_0014e742:
XOR R13D,R13D
LAB_0014e745:
MOV qword ptr [RSP + 0x10],RSI
TEST RBX,RBX
JLE 0x0014e978
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,RBX
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,RBX
MOV qword ptr [RSP + 0x30],RAX
XOR R12D,R12D
MOV qword ptr [RSP + 0x18],RBX
LAB_0014e775:
CMP dword ptr [RSP + 0x90],0x0
JS 0x0014e793
MOV RAX,qword ptr [RSP + 0x28]
LEA R15,[R12 + RAX*0x1]
MOV RAX,qword ptr [RSP + 0x20]
LEA R14,[R12 + RAX*0x1]
JMP 0x0014e7a7
LAB_0014e793:
MOV R14,R12
NOT R14
MOV RAX,qword ptr [RSP + 0x38]
LEA R15,[RAX + R14*0x1]
ADD R14,qword ptr [RSP + 0x30]
LAB_0014e7a7:
TEST R13,R13
JZ 0x0014e86a
TEST byte ptr [R13 + 0x5],0x8
JZ 0x0014e86a
TEST R15,R15
JS 0x0014e86a
MOV EAX,dword ptr [R13 + 0x40]
MOV RBP,RAX
SUB RBP,R15
JBE 0x0014e86a
SUB RAX,R14
JBE 0x0014e86a
MOV RCX,RBX
SUB RCX,R12
CMP dword ptr [RSP + 0x90],0x0
JS 0x0014e8f3
CMP RCX,RBP
CMOVL RBP,RCX
CMP RBP,RAX
CMOVGE RBP,RAX
TEST RBP,RBP
JLE 0x0014e8e2
SHL R14,0x4
SHL R15,0x4
MOV RBX,RBP
LAB_0014e813:
MOV RAX,qword ptr [R13 + 0x38]
MOV RCX,qword ptr [RAX + R15*0x1]
MOV RDI,qword ptr [RAX + R15*0x1 + 0x8]
CMP EDI,-0x9
JC 0x0014e827
INC dword ptr [RCX]
LAB_0014e827:
MOV RSI,qword ptr [RAX + R14*0x1]
MOV RDX,qword ptr [RAX + R14*0x1 + 0x8]
MOV qword ptr [RAX + R14*0x1],RCX
MOV qword ptr [RAX + R14*0x1 + 0x8],RDI
CMP EDX,-0x9
JC 0x0014e858
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x18]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0014e858
CALL 0x00120d90
LAB_0014e858:
ADD R14,0x10
ADD R15,0x10
DEC RBX
JNZ 0x0014e813
JMP 0x0014e96b
LAB_0014e86a:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
MOV RBP,qword ptr [RSP + 0x40]
MOV RDX,RBP
MOV RCX,R15
LEA R8,[RSP + 0x48]
CALL 0x0014e98a
MOV R15D,0xffffffff
TEST EAX,EAX
JS 0x0014e978
JZ 0x0014e8ba
MOV R8,qword ptr [RSP + 0x48]
MOV R9,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,RBP
MOV RCX,R14
CALL 0x00124d20
JMP 0x0014e8d5
LAB_0014e8ba:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,RBP
MOV RCX,R14
MOV R8D,0x4000
CALL 0x00126f31
LAB_0014e8d5:
MOV EBP,0x1
TEST EAX,EAX
JS 0x0014e978
LAB_0014e8e2:
ADD R12,RBP
CMP R12,RBX
JL 0x0014e775
JMP 0x0014e975
LAB_0014e8f3:
LEA RBP,[R15 + 0x1]
CMP RCX,RBP
CMOVL RBP,RCX
LEA RAX,[R14 + 0x1]
CMP RBP,RAX
CMOVGE RBP,RAX
TEST RBP,RBP
JLE 0x0014e8e2
SHL R15,0x4
SHL R14,0x4
MOV RBX,RBP
LAB_0014e919:
MOV RAX,qword ptr [R13 + 0x38]
MOV RCX,qword ptr [RAX + R15*0x1]
MOV RDI,qword ptr [RAX + R15*0x1 + 0x8]
CMP EDI,-0x9
JC 0x0014e92d
INC dword ptr [RCX]
LAB_0014e92d:
MOV RSI,qword ptr [RAX + R14*0x1]
MOV RDX,qword ptr [RAX + R14*0x1 + 0x8]
MOV qword ptr [RAX + R14*0x1],RCX
MOV qword ptr [RAX + R14*0x1 + 0x8],RDI
CMP EDX,-0x9
JC 0x0014e95e
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x18]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0014e95e
CALL 0x00120d90
LAB_0014e95e:
ADD R15,-0x10
ADD R14,-0x10
DEC RBX
JNZ 0x0014e919
LAB_0014e96b:
MOV RBX,qword ptr [RSP + 0x18]
JMP 0x0014e8e2
LAB_0014e975:
XOR R15D,R15D
LAB_0014e978:
MOV EAX,R15D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
JS_CopySubArray(long param_1,long param_2,int8 param_3,long param_4,long param_5,long param_6,
int param_7)
{
long lVar1;
int *piVar2;
int8 uVar3;
int *piVar4;
int8 uVar5;
int iVar6;
ulong uVar7;
long lVar8;
long lVar9;
long lVar10;
ulong uVar11;
long lVar12;
ulong uVar13;
ulong uVar14;
long lVar15;
int8 local_40;
int8 local_38;
if ((((int)param_3 != -1) || (*(short *)(param_2 + 6) != 2)) ||
(lVar12 = param_2, (*(byte *)(param_2 + 5) & 8) == 0)) {
lVar12 = 0;
}
if (0 < param_6) {
uVar11 = 0;
do {
if (param_7 < 0) {
uVar14 = param_5 + param_6 + ~uVar11;
uVar13 = ~uVar11 + param_4 + param_6;
}
else {
uVar14 = uVar11 + param_5;
uVar13 = uVar11 + param_4;
}
if (((lVar12 == 0) || ((*(byte *)(lVar12 + 5) & 8) == 0)) || ((long)uVar14 < 0)) {
LAB_0014e86a:
iVar6 = JS_TryGetPropertyInt64(param_1,param_2,param_3,uVar14,&local_40);
if (iVar6 < 0) {
return 0xffffffff;
}
if (iVar6 == 0) {
iVar6 = JS_DeletePropertyInt64(param_1,param_2,param_3,uVar13,0x4000);
}
else {
iVar6 = JS_SetPropertyInt64(param_1,param_2,param_3,uVar13,local_40,local_38);
}
lVar10 = 1;
if (iVar6 < 0) {
return 0xffffffff;
}
}
else {
uVar7 = (ulong)*(uint *)(lVar12 + 0x40);
lVar10 = uVar7 - uVar14;
if ((uVar7 < uVar14 || lVar10 == 0) ||
(lVar8 = uVar7 - uVar13, uVar7 < uVar13 || lVar8 == 0)) goto LAB_0014e86a;
lVar9 = param_6 - uVar11;
if (param_7 < 0) {
lVar10 = uVar14 + 1;
if (lVar9 < (long)(uVar14 + 1)) {
lVar10 = lVar9;
}
if ((long)(uVar13 + 1) <= lVar10) {
lVar10 = uVar13 + 1;
}
if (0 < lVar10) {
lVar15 = uVar14 << 4;
lVar9 = uVar13 << 4;
lVar8 = lVar10;
do {
lVar1 = *(long *)(lVar12 + 0x38);
piVar2 = *(int **)(lVar1 + lVar15);
uVar3 = *(int8 *)(lVar1 + 8 + lVar15);
if (0xfffffff6 < (uint)uVar3) {
*piVar2 = *piVar2 + 1;
}
piVar4 = *(int **)(lVar1 + lVar9);
uVar5 = *(int8 *)(lVar1 + 8 + lVar9);
*(int **)(lVar1 + lVar9) = piVar2;
*(int8 *)(lVar1 + 8 + lVar9) = uVar3;
if (0xfffffff6 < (uint)uVar5) {
uVar3 = *(int8 *)(param_1 + 0x18);
iVar6 = *piVar4;
*piVar4 = iVar6 + -1;
if (iVar6 < 2) {
js_free_value_rt(uVar3);
}
}
lVar15 = lVar15 + -0x10;
lVar9 = lVar9 + -0x10;
lVar8 = lVar8 + -1;
} while (lVar8 != 0);
}
}
else {
if (lVar9 < lVar10) {
lVar10 = lVar9;
}
if (lVar8 <= lVar10) {
lVar10 = lVar8;
}
if (0 < lVar10) {
lVar9 = uVar13 << 4;
lVar15 = uVar14 << 4;
lVar8 = lVar10;
do {
lVar1 = *(long *)(lVar12 + 0x38);
piVar2 = *(int **)(lVar1 + lVar15);
uVar3 = *(int8 *)(lVar1 + 8 + lVar15);
if (0xfffffff6 < (uint)uVar3) {
*piVar2 = *piVar2 + 1;
}
piVar4 = *(int **)(lVar1 + lVar9);
uVar5 = *(int8 *)(lVar1 + 8 + lVar9);
*(int **)(lVar1 + lVar9) = piVar2;
*(int8 *)(lVar1 + 8 + lVar9) = uVar3;
if (0xfffffff6 < (uint)uVar5) {
uVar3 = *(int8 *)(param_1 + 0x18);
iVar6 = *piVar4;
*piVar4 = iVar6 + -1;
if (iVar6 < 2) {
js_free_value_rt(uVar3);
}
}
lVar9 = lVar9 + 0x10;
lVar15 = lVar15 + 0x10;
lVar8 = lVar8 + -1;
} while (lVar8 != 0);
}
}
}
uVar11 = uVar11 + lVar10;
} while ((long)uVar11 < param_6);
}
return 0;
}
| |
32,149 | my_realpath | eloqsql/mysys/my_symlink.c | int my_realpath(char *to, const char *filename, myf MyFlags)
{
#if defined(HAVE_REALPATH) && !defined(HAVE_BROKEN_REALPATH)
int result=0;
char buff[BUFF_LEN];
char *ptr;
DBUG_ENTER("my_realpath");
DBUG_PRINT("info",("executing realpath"));
if ((ptr=realpath(filename,buff)))
strmake(to, ptr, FN_REFLEN-1);
else
{
/*
Realpath didn't work; Use my_load_path() which is a poor substitute
original name but will at least be able to resolve paths that starts
with '.'.
*/
if (MyFlags)
DBUG_PRINT("error",("realpath failed with errno: %d", errno));
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_REALPATH, MYF(0), filename, my_errno);
my_load_path(to, filename, NullS);
if (my_errno == ENOENT)
result= 1;
else
result= -1;
}
DBUG_RETURN(result);
#elif defined(_WIN32)
int ret= GetFullPathName(filename,FN_REFLEN, to, NULL);
if (ret == 0 || ret > FN_REFLEN)
{
my_errno= (ret > FN_REFLEN) ? ENAMETOOLONG : GetLastError();
if (MyFlags & MY_WME)
my_error(EE_REALPATH, MYF(0), filename, my_errno);
/*
GetFullPathName didn't work : use my_load_path() which is a poor
substitute original name but will at least be able to resolve
paths that starts with '.'.
*/
my_load_path(to, filename, NullS);
return -1;
}
#else
my_load_path(to, filename, NullS);
#endif
return 0;
} | O0 | c | my_realpath:
pushq %rbp
movq %rsp, %rbp
subq $0x1060, %rsp # imm = 0x1060
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x1020(%rbp)
movq %rsi, -0x1028(%rbp)
movq %rdx, -0x1030(%rbp)
movl $0x0, -0x1034(%rbp)
jmp 0x39729
movq -0x1028(%rbp), %rdi
leaq -0x1010(%rbp), %rsi
callq 0x250f0
movq %rax, -0x1040(%rbp)
cmpq $0x0, %rax
je 0x39766
movq -0x1020(%rbp), %rdi
movq -0x1040(%rbp), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x7fd40
jmp 0x39806
cmpq $0x0, -0x1030(%rbp)
je 0x39776
jmp 0x39772
jmp 0x39774
jmp 0x39776
callq 0x25050
movl (%rax), %eax
movl %eax, -0x1044(%rbp)
callq 0x2c180
movl -0x1044(%rbp), %ecx
movl %ecx, (%rax)
movq -0x1030(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x397cd
movq -0x1028(%rbp), %rax
movq %rax, -0x1050(%rbp)
callq 0x2c180
movq -0x1050(%rbp), %rdx
movl (%rax), %ecx
movl $0x1a, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x37670
movq -0x1020(%rbp), %rdi
movq -0x1028(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3b020
callq 0x2c180
cmpl $0x2, (%rax)
jne 0x397fa
movl $0x1, -0x1034(%rbp)
jmp 0x39804
movl $0xffffffff, -0x1034(%rbp) # imm = 0xFFFFFFFF
jmp 0x39806
jmp 0x39808
movl -0x1034(%rbp), %eax
movl %eax, -0x1014(%rbp)
movl -0x1014(%rbp), %eax
movl %eax, -0x1054(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x39841
movl -0x1054(%rbp), %eax
addq $0x1060, %rsp # imm = 0x1060
popq %rbp
retq
callq 0x25330
nopw %cs:(%rax,%rax)
| my_realpath:
push rbp
mov rbp, rsp
sub rsp, 1060h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_1020], rdi
mov [rbp+var_1028], rsi
mov [rbp+var_1030], rdx
mov [rbp+var_1034], 0
jmp short $+2
loc_39729:
mov rdi, [rbp+var_1028]
lea rsi, [rbp+var_1010]
call _realpath
mov [rbp+var_1040], rax
cmp rax, 0
jz short loc_39766
mov rdi, [rbp+var_1020]
mov rsi, [rbp+var_1040]
mov edx, 1FFh
call strmake
jmp loc_39806
loc_39766:
cmp [rbp+var_1030], 0
jz short loc_39776
jmp short $+2
loc_39772:
jmp short $+2
loc_39774:
jmp short $+2
loc_39776:
call ___errno_location
mov eax, [rax]
mov [rbp+var_1044], eax
call _my_thread_var
mov ecx, [rbp+var_1044]
mov [rax], ecx
mov rax, [rbp+var_1030]
and rax, 10h
cmp rax, 0
jz short loc_397CD
mov rax, [rbp+var_1028]
mov [rbp+var_1050], rax
call _my_thread_var
mov rdx, [rbp+var_1050]
mov ecx, [rax]
mov edi, 1Ah
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_397CD:
mov rdi, [rbp+var_1020]
mov rsi, [rbp+var_1028]
xor eax, eax
mov edx, eax
call my_load_path
call _my_thread_var
cmp dword ptr [rax], 2
jnz short loc_397FA
mov [rbp+var_1034], 1
jmp short loc_39804
loc_397FA:
mov [rbp+var_1034], 0FFFFFFFFh
loc_39804:
jmp short $+2
loc_39806:
jmp short $+2
loc_39808:
mov eax, [rbp+var_1034]
mov [rbp+var_1014], eax
mov eax, [rbp+var_1014]
mov [rbp+var_1054], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_39841
mov eax, [rbp+var_1054]
add rsp, 1060h
pop rbp
retn
loc_39841:
call ___stack_chk_fail
| long long my_realpath(long long a1, long long a2, char a3)
{
unsigned int *v3; // rax
long long v5; // [rsp+1Ch] [rbp-1044h]
long long v6; // [rsp+20h] [rbp-1040h]
unsigned int v7; // [rsp+2Ch] [rbp-1034h]
_BYTE v9[4104]; // [rsp+50h] [rbp-1010h] BYREF
unsigned long long v10; // [rsp+1058h] [rbp-8h]
v10 = __readfsqword(0x28u);
v7 = 0;
v6 = realpath(a2, v9);
if ( v6 )
{
strmake(a1, v6, 511LL);
}
else
{
v5 = *(unsigned int *)__errno_location();
*(_DWORD *)my_thread_var() = v5;
if ( (a3 & 0x10) != 0 )
{
v3 = (unsigned int *)my_thread_var();
my_error(0x1Au, 0LL, a2, *v3);
}
my_load_path(a1, a2, 0LL);
if ( *(_DWORD *)my_thread_var() == 2 )
return 1;
else
return (unsigned int)-1;
}
return v7;
}
| my_realpath:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1060
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x1020],RDI
MOV qword ptr [RBP + -0x1028],RSI
MOV qword ptr [RBP + -0x1030],RDX
MOV dword ptr [RBP + -0x1034],0x0
JMP 0x00139729
LAB_00139729:
MOV RDI,qword ptr [RBP + -0x1028]
LEA RSI,[RBP + -0x1010]
CALL 0x001250f0
MOV qword ptr [RBP + -0x1040],RAX
CMP RAX,0x0
JZ 0x00139766
MOV RDI,qword ptr [RBP + -0x1020]
MOV RSI,qword ptr [RBP + -0x1040]
MOV EDX,0x1ff
CALL 0x0017fd40
JMP 0x00139806
LAB_00139766:
CMP qword ptr [RBP + -0x1030],0x0
JZ 0x00139776
JMP 0x00139772
LAB_00139772:
JMP 0x00139774
LAB_00139774:
JMP 0x00139776
LAB_00139776:
CALL 0x00125050
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1044],EAX
CALL 0x0012c180
MOV ECX,dword ptr [RBP + -0x1044]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x1030]
AND RAX,0x10
CMP RAX,0x0
JZ 0x001397cd
MOV RAX,qword ptr [RBP + -0x1028]
MOV qword ptr [RBP + -0x1050],RAX
CALL 0x0012c180
MOV RDX,qword ptr [RBP + -0x1050]
MOV ECX,dword ptr [RAX]
MOV EDI,0x1a
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x00137670
LAB_001397cd:
MOV RDI,qword ptr [RBP + -0x1020]
MOV RSI,qword ptr [RBP + -0x1028]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x0013b020
CALL 0x0012c180
CMP dword ptr [RAX],0x2
JNZ 0x001397fa
MOV dword ptr [RBP + -0x1034],0x1
JMP 0x00139804
LAB_001397fa:
MOV dword ptr [RBP + -0x1034],0xffffffff
LAB_00139804:
JMP 0x00139806
LAB_00139806:
JMP 0x00139808
LAB_00139808:
MOV EAX,dword ptr [RBP + -0x1034]
MOV dword ptr [RBP + -0x1014],EAX
MOV EAX,dword ptr [RBP + -0x1014]
MOV dword ptr [RBP + -0x1054],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00139841
MOV EAX,dword ptr [RBP + -0x1054]
ADD RSP,0x1060
POP RBP
RET
LAB_00139841:
CALL 0x00125330
|
int4 my_realpath(int8 param_1,char *param_2,ulong param_3)
{
int iVar1;
char *pcVar2;
int *piVar3;
int4 *puVar4;
long in_FS_OFFSET;
int4 local_103c;
char local_1018 [4104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_103c = 0;
pcVar2 = realpath(param_2,local_1018);
if (pcVar2 == (char *)0x0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((param_3 & 0x10) != 0) {
puVar4 = (int4 *)_my_thread_var();
my_error(0x1a,0,param_2,*puVar4);
}
my_load_path(param_1,param_2,0);
piVar3 = (int *)_my_thread_var();
if (*piVar3 == 2) {
local_103c = 1;
}
else {
local_103c = 0xffffffff;
}
}
else {
strmake(param_1,pcVar2,0x1ff);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_103c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
32,150 | evmone::(anonymous namespace)::HistogramTracer::on_execution_end(evmc_result const&) | corpus-core[P]colibri-stateless/build_O3/_deps/evmone_external-src/lib/evmone/tracing.cpp | void on_execution_end(const evmc_result& /*result*/) noexcept override
{
const auto& ctx = m_contexts.top();
m_out << "--- # HISTOGRAM depth=" << ctx.depth << "\nopcode,count\n";
for (size_t i = 0; i < std::size(ctx.counts); ++i)
{
if (ctx.counts[i] != 0)
m_out << get_name(static_cast<uint8_t>(i)) << ',' << ctx.counts[i] << '\n';
}
m_contexts.pop();
} | O3 | cpp | evmone::(anonymous namespace)::HistogramTracer::on_execution_end(evmc_result const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %r13
cmpq 0x48(%rdi), %r13
jne 0x49dd5
movq 0x58(%rbx), %rax
movl $0x410, %r13d # imm = 0x410
addq -0x8(%rax), %r13
movq 0x60(%rbx), %r14
leaq 0x3d751(%rip), %rsi # 0x87531
movl $0x16, %edx
movq %r14, %rdi
callq 0x21240
movl -0x410(%r13), %esi
movq %r14, %rdi
callq 0x213a0
leaq 0x3d745(%rip), %rsi # 0x87548
movl $0xe, %edx
movq %rax, %rdi
callq 0x21240
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %r15
cmpl $0x0, -0x400(%r13,%rbp,4)
je 0x49e9f
movq 0x60(%rbx), %r12
movzbl %bpl, %esi
movq %r14, %rdi
callq 0x49f0a
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x21240
movb $0x2c, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21240
movl -0x400(%r13,%rbp,4), %esi
movq %rax, %rdi
callq 0x21150
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21240
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x49e9f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21200
incq %rbp
cmpq $0x100, %rbp # imm = 0x100
jne 0x49e1c
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rdi
cmpq %rdi, %rax
je 0x49ec4
addq $-0x410, %rax # imm = 0xFBF0
jmp 0x49eed
movl $0x410, %esi # imm = 0x410
callq 0x21200
movq 0x58(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x58(%rbx)
movq -0x8(%rax), %rax
movq %rax, 0x48(%rbx)
leaq 0x410(%rax), %rcx
movq %rcx, 0x50(%rbx)
movq %rax, 0x40(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49f02
movq %rax, %rdi
callq 0x2e015
| _ZN6evmone12_GLOBAL__N_115HistogramTracer16on_execution_endERK11evmc_result:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
mov r13, [rdi+40h]
cmp r13, [rdi+48h]
jnz short loc_49DD5
mov rax, [rbx+58h]
mov r13d, 410h
add r13, [rax-8]
loc_49DD5:
mov r14, [rbx+60h]
lea rsi, aHistogramDepth; "--- # HISTOGRAM depth="
mov edx, 16h
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov esi, [r13-410h]
mov rdi, r14
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, aOpcodeCount; "\nopcode,count\n"
mov edx, 0Eh
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
xor ebp, ebp
lea r14, [rsp+58h+var_50]
lea r15, [rsp+58h+var_51]
loc_49E1C:
cmp dword ptr [r13+rbp*4-400h], 0
jz short loc_49E9F
mov r12, [rbx+60h]
movzx esi, bpl; int
mov rdi, r14; int
call _ZN6evmone12_GLOBAL__N_18get_nameB5cxx11Eh; evmone::`anonymous namespace'::get_name(uchar)
mov rsi, [rsp+58h+var_50]
mov rdx, [rsp+58h+var_48]
mov rdi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov [rsp+58h+var_51], 2Ch ; ','
mov edx, 1
mov rdi, rax
mov rsi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov esi, [r13+rbp*4-400h]
mov rdi, rax
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
mov [rsp+58h+var_51], 0Ah
mov edx, 1
mov rdi, rax
mov rsi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+58h+var_50]; void *
lea rax, [rsp+58h+var_40]
cmp rdi, rax
jz short loc_49E9F
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_49E9F:
inc rbp
cmp rbp, 100h
jnz loc_49E1C
mov rax, [rbx+40h]
mov rdi, [rbx+48h]; void *
cmp rax, rdi
jz short loc_49EC4
add rax, 0FFFFFFFFFFFFFBF0h
jmp short loc_49EED
loc_49EC4:
mov esi, 410h; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [rbx+58h]
lea rcx, [rax-8]
mov [rbx+58h], rcx
mov rax, [rax-8]
mov [rbx+48h], rax
lea rcx, [rax+410h]
mov [rbx+50h], rcx
loc_49EED:
mov [rbx+40h], rax
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_49F02:
mov rdi, rax
call __clang_call_terminate
| char * evmone::`anonymous namespace'::HistogramTracer::on_execution_end(_QWORD *a1)
{
long long v2; // r13
long long v3; // r14
long long v4; // rax
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
long long i; // rbp
long long v10; // r12
long long v11; // rax
long long v12; // rax
long long v13; // rax
char *v14; // rax
char *v15; // rdi
char *result; // rax
char **v17; // rcx
void *v18; // [rsp+0h] [rbp-58h] BYREF
void *v19; // [rsp+8h] [rbp-50h] BYREF
long long v20; // [rsp+10h] [rbp-48h]
long long v21; // [rsp+18h] [rbp-40h] BYREF
v2 = a1[8];
if ( v2 == a1[9] )
v2 = *(_QWORD *)(a1[11] - 8LL) + 1040LL;
v3 = a1[12];
std::__ostream_insert<char,std::char_traits<char>>(v3, "--- # HISTOGRAM depth=", 22LL);
v4 = std::ostream::operator<<(v3, *(unsigned int *)(v2 - 1040));
std::__ostream_insert<char,std::char_traits<char>>(v4, "\nopcode,count\n", 14LL);
for ( i = 0LL; i != 256; ++i )
{
if ( *(_DWORD *)(v2 + 4 * i - 1024) )
{
v10 = a1[12];
evmone::`anonymous namespace'::get_name[abi:cxx11](
(int)&v19,
(unsigned __int8)i,
v5,
v6,
v7,
v8,
v18,
(int)v19,
v20);
v11 = std::__ostream_insert<char,std::char_traits<char>>(v10, v19, v20);
HIBYTE(v18) = 44;
v12 = std::__ostream_insert<char,std::char_traits<char>>(v11, (char *)&v18 + 7, 1LL);
v13 = std::ostream::_M_insert<unsigned long>(v12, *(unsigned int *)(v2 + 4 * i - 1024));
HIBYTE(v18) = 10;
std::__ostream_insert<char,std::char_traits<char>>(v13, (char *)&v18 + 7, 1LL);
if ( v19 != &v21 )
operator delete(v19, v21 + 1);
}
}
v14 = (char *)a1[8];
v15 = (char *)a1[9];
if ( v14 == v15 )
{
operator delete(v15, 0x410uLL);
v17 = (char **)(a1[11] - 8LL);
a1[11] = v17;
result = *v17;
a1[9] = *v17;
a1[10] = result + 1040;
}
else
{
result = v14 - 1040;
}
a1[8] = result;
return result;
}
| on_execution_end:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV R13,qword ptr [RDI + 0x40]
CMP R13,qword ptr [RDI + 0x48]
JNZ 0x00149dd5
MOV RAX,qword ptr [RBX + 0x58]
MOV R13D,0x410
ADD R13,qword ptr [RAX + -0x8]
LAB_00149dd5:
MOV R14,qword ptr [RBX + 0x60]
LAB_00149dd9:
LEA RSI,[0x187531]
MOV EDX,0x16
MOV RDI,R14
CALL 0x00121240
MOV ESI,dword ptr [R13 + -0x410]
MOV RDI,R14
CALL 0x001213a0
LEA RSI,[0x187548]
MOV EDX,0xe
MOV RDI,RAX
CALL 0x00121240
XOR EBP,EBP
LEA R14,[RSP + 0x8]
LEA R15,[RSP + 0x7]
LAB_00149e1c:
CMP dword ptr [R13 + RBP*0x4 + -0x400],0x0
JZ 0x00149e9f
MOV R12,qword ptr [RBX + 0x60]
LAB_00149e2b:
MOVZX ESI,BPL
MOV RDI,R14
CALL 0x00149f0a
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV RDI,R12
CALL 0x00121240
MOV byte ptr [RSP + 0x7],0x2c
MOV EDX,0x1
MOV RDI,RAX
MOV RSI,R15
CALL 0x00121240
MOV ESI,dword ptr [R13 + RBP*0x4 + -0x400]
MOV RDI,RAX
CALL 0x00121150
MOV byte ptr [RSP + 0x7],0xa
MOV EDX,0x1
MOV RDI,RAX
MOV RSI,R15
CALL 0x00121240
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x00149e9f
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00121200
LAB_00149e9f:
INC RBP
CMP RBP,0x100
JNZ 0x00149e1c
MOV RAX,qword ptr [RBX + 0x40]
MOV RDI,qword ptr [RBX + 0x48]
CMP RAX,RDI
JZ 0x00149ec4
ADD RAX,-0x410
JMP 0x00149eed
LAB_00149ec4:
MOV ESI,0x410
CALL 0x00121200
MOV RAX,qword ptr [RBX + 0x58]
LEA RCX,[RAX + -0x8]
MOV qword ptr [RBX + 0x58],RCX
MOV RAX,qword ptr [RAX + -0x8]
MOV qword ptr [RBX + 0x48],RAX
LEA RCX,[RAX + 0x410]
MOV qword ptr [RBX + 0x50],RCX
LAB_00149eed:
MOV qword ptr [RBX + 0x40],RAX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* evmone::(anonymous namespace)::HistogramTracer::on_execution_end(evmc_result const&) */
void evmone::(anonymous_namespace)::HistogramTracer::on_execution_end(evmc_result *param_1)
{
ostream *poVar1;
long lVar2;
long lVar3;
char local_51;
long *local_50;
long local_48;
long local_40 [2];
lVar3 = *(long *)(param_1 + 0x40);
if (lVar3 == *(long *)(param_1 + 0x48)) {
lVar3 = *(long *)(*(long *)(param_1 + 0x58) + -8) + 0x410;
}
poVar1 = *(ostream **)(param_1 + 0x60);
/* try { // try from 00149dd9 to 00149e0f has its CatchHandler @ 00149f00 */
std::__ostream_insert<char,std::char_traits<char>>(poVar1,"--- # HISTOGRAM depth=",0x16);
poVar1 = (ostream *)std::ostream::operator<<(poVar1,*(int *)(lVar3 + -0x410));
std::__ostream_insert<char,std::char_traits<char>>(poVar1,"\nopcode,count\n",0xe);
lVar2 = 0;
do {
if (*(int *)(lVar3 + -0x400 + lVar2 * 4) != 0) {
poVar1 = *(ostream **)(param_1 + 0x60);
/* try { // try from 00149e2b to 00149e82 has its CatchHandler @ 00149f02 */
get_name_abi_cxx11_((_anonymous_namespace_ *)&local_50,(uchar)lVar2);
poVar1 = std::__ostream_insert<char,std::char_traits<char>>(poVar1,(char *)local_50,local_48);
local_51 = ',';
poVar1 = std::__ostream_insert<char,std::char_traits<char>>(poVar1,&local_51,1);
poVar1 = std::ostream::_M_insert<unsigned_long>((ulong)poVar1);
local_51 = '\n';
std::__ostream_insert<char,std::char_traits<char>>(poVar1,&local_51,1);
if (local_50 != local_40) {
operator_delete(local_50,local_40[0] + 1);
}
}
lVar2 = lVar2 + 1;
} while (lVar2 != 0x100);
if (*(void **)(param_1 + 0x40) == *(void **)(param_1 + 0x48)) {
operator_delete(*(void **)(param_1 + 0x48),0x410);
lVar3 = *(long *)(param_1 + 0x58);
*(long *)(param_1 + 0x58) = lVar3 + -8;
lVar3 = *(long *)(lVar3 + -8);
*(long *)(param_1 + 0x48) = lVar3;
*(long *)(param_1 + 0x50) = lVar3 + 0x410;
}
else {
lVar3 = (long)*(void **)(param_1 + 0x40) + -0x410;
}
*(long *)(param_1 + 0x40) = lVar3;
return;
}
| |
32,151 | intern_filename | eloqsql/mysys/mf_pack.c | char *intern_filename(char *to, const char *from)
{
size_t length, to_length;
char buff[FN_REFLEN + 1];
if (from == to)
{ /* Dirname may destroy from */
(void) strnmov(buff, from, FN_REFLEN);
from=buff;
}
length= dirname_part(to, from, &to_length); /* Copy dirname & fix chars */
(void) strnmov(to + to_length, from + length, FN_REFLEN - to_length);
return (to);
} | O3 | c | intern_filename:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
cmpq %rdi, %rsi
jne 0x9b173
leaq -0x230(%rbp), %r15
movl $0x200, %edx # imm = 0x200
movq %r15, %rdi
movq %r14, %rsi
callq 0xd7208
movq %r15, %r14
leaq -0x238(%rbp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x94929
movq (%r15), %rcx
leaq (%rbx,%rcx), %rdi
addq %rax, %r14
movl $0x200, %edx # imm = 0x200
subq %rcx, %rdx
movq %r14, %rsi
callq 0xd7208
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x9b1c2
movq %rbx, %rax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
| intern_filename:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 228h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
cmp rsi, rdi
jnz short loc_9B173
lea r15, [rbp+var_230]
mov edx, 200h
mov rdi, r15
mov rsi, r14
call strnmov
mov r14, r15
loc_9B173:
lea r15, [rbp+var_238]
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call dirname_part
mov rcx, [r15]
lea rdi, [rbx+rcx]
add r14, rax
mov edx, 200h
sub rdx, rcx
mov rsi, r14
call strnmov
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_9B1C2
mov rax, rbx
add rsp, 228h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_9B1C2:
call ___stack_chk_fail
| long long intern_filename(long long a1, _BYTE *a2)
{
_BYTE *v2; // r14
long long v3; // rax
long long v5; // [rsp+8h] [rbp-238h] BYREF
_BYTE v6[528]; // [rsp+10h] [rbp-230h] BYREF
unsigned long long v7; // [rsp+220h] [rbp-20h]
v2 = a2;
v7 = __readfsqword(0x28u);
if ( a2 == (_BYTE *)a1 )
{
strnmov(v6, a2, 512LL);
v2 = v6;
}
v3 = dirname_part(a1, v2, &v5);
strnmov(a1 + v5, &v2[v3], 512 - v5);
return a1;
}
| intern_filename:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x228
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
CMP RSI,RDI
JNZ 0x0019b173
LEA R15,[RBP + -0x230]
MOV EDX,0x200
MOV RDI,R15
MOV RSI,R14
CALL 0x001d7208
MOV R14,R15
LAB_0019b173:
LEA R15,[RBP + -0x238]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x00194929
MOV RCX,qword ptr [R15]
LEA RDI,[RBX + RCX*0x1]
ADD R14,RAX
MOV EDX,0x200
SUB RDX,RCX
MOV RSI,R14
CALL 0x001d7208
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0019b1c2
MOV RAX,RBX
ADD RSP,0x228
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0019b1c2:
CALL 0x00129270
|
int1 * intern_filename(int1 *param_1,int1 *param_2)
{
long lVar1;
int1 *puVar2;
long in_FS_OFFSET;
long local_240;
int1 local_238 [528];
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
puVar2 = param_2;
if (param_2 == param_1) {
puVar2 = local_238;
strnmov(puVar2,param_2,0x200);
}
lVar1 = dirname_part(param_1,puVar2,&local_240);
strnmov(param_1 + local_240,puVar2 + lVar1,0x200 - local_240);
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
32,152 | mi_nommap_pread | eloqsql/storage/myisam/mi_dynrec.c | size_t mi_nommap_pread(MI_INFO *info, uchar *Buffer,
size_t Count, my_off_t offset, myf MyFlags)
{
return mysql_file_pread(info->dfile, Buffer, Count, offset, MyFlags);
} | O3 | c | mi_nommap_pread:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, -0x30(%rbp)
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movl 0x1c0(%rdi), %ebx
leaq 0x30f12d(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x78(%rbp), %rdi
movl %ebx, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x76f25
movl %ebx, %edi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq -0x30(%rbp), %r8
callq 0xa0638
movq %rax, %rbx
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x30f0e1(%rip), %rax # 0x386010
movq (%rax), %rax
leaq 0x64c71(%rip), %rdx # 0xdbbaa
movq %r15, %rdi
movq %r14, %rsi
movl $0xca, %ecx
callq *0x210(%rax)
movl %ebx, %edi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq -0x30(%rbp), %r12
movq %r12, %r8
callq 0xa0638
movq %rax, %rbx
xorl %esi, %esi
testq %rax, %rax
cmovneq %rsi, %r14
cmpq $-0x1, %rax
cmovneq %rax, %rsi
testb $0x6, %r12b
cmovneq %r14, %rsi
leaq 0x30f08c(%rip), %rax # 0x386010
movq (%rax), %rax
movq %r15, %rdi
callq *0x218(%rax)
jmp 0x76f13
| mi_nommap_pread:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_30], r8
mov r12, rcx
mov r14, rdx
mov r13, rsi
mov ebx, [rdi+1C0h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_78]
mov esi, ebx
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz short loc_76F25
mov edi, ebx
mov rsi, r13
mov rdx, r14
mov rcx, r12
mov r8, [rbp+var_30]
call my_pread
mov rbx, rax
loc_76F13:
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_76F25:
mov r15, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_12; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov rsi, r14
mov ecx, 0CAh
call qword ptr [rax+210h]
mov edi, ebx
mov rsi, r13
mov rdx, r14
mov rcx, r12
mov r12, [rbp+var_30]
mov r8, r12
call my_pread
mov rbx, rax
xor esi, esi
test rax, rax
cmovnz r14, rsi
cmp rax, 0FFFFFFFFFFFFFFFFh
cmovnz rsi, rax
test r12b, 6
cmovnz rsi, r14
lea rax, PSI_server
mov rax, [rax]
mov rdi, r15
call qword ptr [rax+218h]
jmp short loc_76F13
| long long mi_nommap_pread(long long a1, long long a2, long long a3, long long a4, long long a5)
{
unsigned int v7; // ebx
long long v8; // rax
long long v9; // rbx
long long v11; // r15
_BYTE v12[72]; // [rsp+8h] [rbp-78h] BYREF
long long v13; // [rsp+50h] [rbp-30h]
v13 = a5;
v7 = *(_DWORD *)(a1 + 448);
v8 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v12, v7, 6LL);
if ( !v8 )
return my_pread(v7, a2, a3, a4, v13);
v11 = v8;
((void ( *)(long long, long long, const char *, long long))PSI_server[66])(
v8,
a3,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
202LL);
v9 = my_pread(v7, a2, a3, a4, v13);
((void ( *)(long long))PSI_server[67])(v11);
return v9;
}
| mi_nommap_pread:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x30],R8
MOV R12,RCX
MOV R14,RDX
MOV R13,RSI
MOV EBX,dword ptr [RDI + 0x1c0]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x78]
MOV ESI,EBX
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00176f25
MOV EDI,EBX
MOV RSI,R13
MOV RDX,R14
MOV RCX,R12
MOV R8,qword ptr [RBP + -0x30]
CALL 0x001a0638
MOV RBX,RAX
LAB_00176f13:
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00176f25:
MOV R15,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1dbbaa]
MOV RDI,R15
MOV RSI,R14
MOV ECX,0xca
CALL qword ptr [RAX + 0x210]
MOV EDI,EBX
MOV RSI,R13
MOV RDX,R14
MOV RCX,R12
MOV R12,qword ptr [RBP + -0x30]
MOV R8,R12
CALL 0x001a0638
MOV RBX,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVNZ R14,RSI
CMP RAX,-0x1
CMOVNZ RSI,RAX
TEST R12B,0x6
CMOVNZ RSI,R14
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,R15
CALL qword ptr [RAX + 0x218]
JMP 0x00176f13
|
long mi_nommap_pread(long param_1,int8 param_2,long param_3,int8 param_4,ulong param_5)
{
int4 uVar1;
ulong uVar2;
long lVar3;
long lVar4;
long lVar5;
int1 local_80 [72];
ulong local_38;
uVar1 = *(int4 *)(param_1 + 0x1c0);
local_38 = param_5;
lVar3 = (**(code **)(PSI_server + 0x158))(local_80,uVar1,6);
if (lVar3 == 0) {
lVar4 = my_pread(uVar1,param_2,param_3,param_4,local_38);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar3,param_3,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
0xca);
uVar2 = local_38;
lVar4 = my_pread(uVar1,param_2,param_3,param_4,local_38);
if (lVar4 != 0) {
param_3 = 0;
}
lVar5 = 0;
if (lVar4 != -1) {
lVar5 = lVar4;
}
if ((uVar2 & 6) != 0) {
lVar5 = param_3;
}
(**(code **)(PSI_server + 0x218))(lVar3,lVar5);
}
return lVar4;
}
| |
32,153 | maria_rtree_fill_reinsert_list | eloqsql/storage/maria/ma_rt_index.c | static my_bool maria_rtree_fill_reinsert_list(stPageList *ReinsertList,
my_off_t page, int level)
{
DBUG_ENTER("maria_rtree_fill_reinsert_list");
DBUG_PRINT("rtree", ("page: %lu level: %d", (ulong) page, level));
if (ReinsertList->n_pages == ReinsertList->m_pages)
{
ReinsertList->m_pages += REINSERT_BUFFER_INC;
if (!(ReinsertList->pages= (stPageLevel*)my_realloc(PSI_INSTRUMENT_ME, (uchar*)ReinsertList->pages,
ReinsertList->m_pages * sizeof(stPageLevel), MYF(MY_ALLOW_ZERO_PTR))))
goto err;
}
/* save page to ReinsertList */
ReinsertList->pages[ReinsertList->n_pages].offs= page;
ReinsertList->pages[ReinsertList->n_pages].level= level;
ReinsertList->n_pages++;
DBUG_RETURN(0);
err:
DBUG_RETURN(1); /* purecov: inspected */
} | O0 | c | maria_rtree_fill_reinsert_list:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
jmp 0x7b495
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x7b4e4
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0xa, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
shlq $0x4, %rdx
xorl %edi, %edi
movl $0x40, %ecx
callq 0xf9bc0
movq -0x10(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x7b4e2
jmp 0x7b52c
jmp 0x7b4e4
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdx
movl (%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdx
movl (%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x7b532
jmp 0x7b52e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| maria_rtree_fill_reinsert_list:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
jmp short $+2
loc_7B495:
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_10]
cmp eax, [rcx+4]
jnz short loc_7B4E4
mov rax, [rbp+var_10]
mov ecx, [rax+4]
add ecx, 0Ah
mov [rax+4], ecx
mov rax, [rbp+var_10]
mov rsi, [rax+8]
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov edx, eax
shl rdx, 4
xor edi, edi
mov ecx, 40h ; '@'
call my_realloc
mov rcx, [rbp+var_10]
mov [rcx+8], rax
cmp rax, 0
jnz short loc_7B4E2
jmp short loc_7B52C
loc_7B4E2:
jmp short $+2
loc_7B4E4:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rdx, [rbp+var_10]
mov edx, [rdx]
shl rdx, 4
add rax, rdx
mov [rax+8], rcx
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rdx, [rbp+var_10]
mov edx, [rdx]
shl rdx, 4
add rax, rdx
mov [rax], ecx
mov rax, [rbp+var_10]
mov ecx, [rax]
add ecx, 1
mov [rax], ecx
mov [rbp+var_1], 0
jmp short loc_7B532
loc_7B52C:
jmp short $+2
loc_7B52E:
mov [rbp+var_1], 1
loc_7B532:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char maria_rtree_fill_reinsert_list(unsigned int *a1, long long a2, int a3)
{
long long v3; // rax
if ( *a1 == a1[1] )
{
a1[1] += 10;
v3 = my_realloc(0LL, *((_QWORD *)a1 + 1), 16LL * a1[1], 64LL);
*((_QWORD *)a1 + 1) = v3;
if ( !v3 )
return 1;
}
*(_QWORD *)(16LL * *a1 + *((_QWORD *)a1 + 1) + 8) = a2;
*(_DWORD *)(16LL * (*a1)++ + *((_QWORD *)a1 + 1)) = a3;
return 0;
}
| maria_rtree_fill_reinsert_list:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
JMP 0x0017b495
LAB_0017b495:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x4]
JNZ 0x0017b4e4
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x4]
ADD ECX,0xa
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV EDX,EAX
SHL RDX,0x4
XOR EDI,EDI
MOV ECX,0x40
CALL 0x001f9bc0
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x8],RAX
CMP RAX,0x0
JNZ 0x0017b4e2
JMP 0x0017b52c
LAB_0017b4e2:
JMP 0x0017b4e4
LAB_0017b4e4:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RDX]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RDX]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
MOV dword ptr [RAX],ECX
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0017b532
LAB_0017b52c:
JMP 0x0017b52e
LAB_0017b52e:
MOV byte ptr [RBP + -0x1],0x1
LAB_0017b532:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 maria_rtree_fill_reinsert_list(uint *param_1,int8 param_2,int4 param_3)
{
long lVar1;
if (*param_1 == param_1[1]) {
param_1[1] = param_1[1] + 10;
lVar1 = my_realloc(0,*(int8 *)(param_1 + 2),(ulong)param_1[1] << 4,0x40);
*(long *)(param_1 + 2) = lVar1;
if (lVar1 == 0) {
return 1;
}
}
*(int8 *)(*(long *)(param_1 + 2) + (ulong)*param_1 * 0x10 + 8) = param_2;
*(int4 *)(*(long *)(param_1 + 2) + (ulong)*param_1 * 0x10) = param_3;
*param_1 = *param_1 + 1;
return 0;
}
| |
32,154 | minja::FilterNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const | llama.cpp/common/minja/minja.hpp | void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
if (!filter) throw std::runtime_error("FilterNode.filter is null");
if (!body) throw std::runtime_error("FilterNode.body is null");
auto filter_value = filter->evaluate(context);
if (!filter_value.is_callable()) {
throw std::runtime_error("Filter must be a callable: " + filter_value.dump());
}
std::string rendered_body = body->render(context);
ArgumentsValue filter_args = {{Value(rendered_body)}, {}};
auto result = filter_value.call(context, filter_args);
out << result.to_str();
} | O3 | cpp | minja::FilterNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %rbx
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0xf580f
movq %rdi, %r14
cmpq $0x0, 0x30(%rdi)
je 0xf582d
movq %rdx, %r15
leaq 0xc0(%rsp), %r12
movq %r12, %rdi
callq 0xe1958
cmpq $0x0, 0x30(%r12)
je 0xf585f
movq 0x30(%r14), %rsi
leaq 0xa0(%rsp), %rdi
movq %r15, %rdx
callq 0xbc604
leaq 0x50(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0xbc4a2
movq %rsp, %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rcx
movl $0x1, %edx
callq 0xc2fa0
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movq $0x0, 0x28(%rsp)
leaq 0x90(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x858ca
movq %r14, %rdi
callq 0x89fe4
leaq 0x88(%rsp), %rdi
callq 0x71092
leaq 0x78(%rsp), %rdi
callq 0x71092
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x71092
movq -0x10(%r14), %rdi
testq %rdi, %rdi
je 0xf5689
movq 0x6c934(%rip), %rax # 0x161f98
cmpb $0x0, (%rax)
je 0xf5674
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xf567e
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xf5689
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x18(%rsp), %r14
leaq 0x50(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movq %rsp, %rcx
movq %r15, %rdx
callq 0xca75c
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xc76c0
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x21020
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf56e2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x20170
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x858ca
movq %rbx, %rdi
callq 0x89fe4
leaq 0x88(%rsp), %rdi
callq 0x71092
leaq 0x78(%rsp), %rdi
callq 0x71092
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0x71092
movq -0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xf5755
movq 0x6c868(%rip), %rax # 0x161f98
cmpb $0x0, (%rax)
je 0xf5740
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xf574a
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xf5755
movq (%rdi), %rax
callq *0x18(%rax)
movq %r14, %rdi
callq 0xcae26
movq %rsp, %rdi
callq 0xbe5c0
leaq 0xb0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf5786
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x20170
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x858ca
movq %rbx, %rdi
callq 0x89fe4
leaq 0xf8(%rsp), %rdi
callq 0x71092
leaq 0xe8(%rsp), %rdi
callq 0x71092
leaq 0xd8(%rsp), %rbx
movq %rbx, %rdi
callq 0x71092
movq -0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xf57ff
movq 0x6c7be(%rip), %rax # 0x161f98
cmpb $0x0, (%rax)
je 0xf57ea
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xf57f4
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xf57ff
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20620
movq %rax, %r14
leaq 0x2ca93(%rip), %rsi # 0x1222b6
movq %rax, %rdi
callq 0x20400
jmp 0xf5849
movl $0x10, %edi
callq 0x20620
movq %rax, %r14
leaq 0x2ca8f(%rip), %rsi # 0x1222d0
movq %rax, %rdi
callq 0x20400
movq 0x6c770(%rip), %rsi # 0x161fc0
movq 0x6c729(%rip), %rdx # 0x161f80
movq %r14, %rdi
callq 0x20a30
movl $0x10, %edi
callq 0x20620
movq %rax, %r14
movq %rsp, %rdi
leaq 0xc0(%rsp), %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xb669c
leaq 0x2ca5e(%rip), %rsi # 0x1222e8
leaq 0x50(%rsp), %rdi
movq %rsp, %rdx
callq 0xb0110
movb $0x1, %bpl
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x20450
xorl %ebp, %ebp
movq 0x6c710(%rip), %rsi # 0x161fc0
movq 0x6c6c9(%rip), %rdx # 0x161f80
movq %r14, %rdi
callq 0x20a30
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf58dd
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x20170
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf58f8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20170
testb %bpl, %bpl
jne 0xf5925
jmp 0xf59c0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf5925
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20170
jmp 0xf5925
movq %rax, %rbx
movq %r14, %rdi
callq 0x20eb0
jmp 0xf59c0
jmp 0xf5934
movq %rax, %rbx
movq %r14, %rdi
callq 0x20eb0
jmp 0xf59cd
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf5967
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x20170
jmp 0xf5967
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xb6738
jmp 0xf5976
movq %rax, %rbx
movq %r14, %rdi
callq 0xcae26
movq %rsp, %rdi
callq 0xbe5c0
jmp 0xf599a
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xb6738
jmp 0xf599a
movq %rax, %rbx
leaq 0xb0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf59c0
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x20170
jmp 0xf59c0
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0xb6738
movq %rbx, %rdi
callq 0x20ad0
nop
| _ZNK5minja10FilterNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 110h
mov rbx, rsi
mov rsi, [rdi+20h]
test rsi, rsi
jz loc_F580F
mov r14, rdi
cmp qword ptr [rdi+30h], 0
jz loc_F582D
mov r15, rdx
lea r12, [rsp+138h+var_78]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
cmp qword ptr [r12+30h], 0
jz loc_F585F
mov rsi, [r14+30h]
lea rdi, [rsp+138h+var_98]
mov rdx, r15
call _ZNK5minja12TemplateNode6renderB5cxx11ERKSt10shared_ptrINS_7ContextEE; minja::TemplateNode::render(std::shared_ptr<minja::Context> const&)
lea rdi, [rsp+138h+var_E8]
lea rsi, [rsp+138h+var_98]
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, rsp
lea rsi, [rsp+138h+var_E8]
lea rcx, [rsp+138h+var_108]
mov edx, 1
call _ZNSt6vectorIN5minja5ValueESaIS1_EEC2ESt16initializer_listIS1_ERKS2_; std::vector<minja::Value>::vector(std::initializer_list<minja::Value>,std::allocator<minja::Value> const&)
xorps xmm0, xmm0
movups [rsp+138h+var_120], xmm0
mov [rsp+138h+var_110], 0
lea r14, [rsp+138h+var_A8]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+138h+var_B0]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+138h+var_C0]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea r14, [rsp+138h+var_D0]
mov rdi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, [r14-10h]
test rdi, rdi
jz short loc_F5689
mov rax, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rax], 0
jz short loc_F5674
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_F567E
loc_F5674:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_F567E:
cmp eax, 1
jnz short loc_F5689
mov rax, [rdi]
call qword ptr [rax+18h]
loc_F5689:
lea r14, [rsp+138h+var_120]
lea rdi, [rsp+138h+var_E8]
lea rsi, [rsp+138h+var_78]
mov rcx, rsp
mov rdx, r15
call _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE; minja::Value::call(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
lea rdi, [rsp+138h+var_108]
lea rsi, [rsp+138h+var_E8]
call _ZNK5minja5Value6to_strB5cxx11Ev; minja::Value::to_str(void)
mov rsi, [rsp+138h+var_108]
mov rdx, [rsp+138h+var_100]
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rax, [rsp+138h+var_F8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F56E2
mov rsi, [rsp+138h+var_F8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F56E2:
lea rbx, [rsp+138h+var_A8]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+138h+var_B0]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+138h+var_C0]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rbx, [rsp+138h+var_D0]
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, [rbx-10h]
test rdi, rdi
jz short loc_F5755
mov rax, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rax], 0
jz short loc_F5740
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_F574A
loc_F5740:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_F574A:
cmp eax, 1
jnz short loc_F5755
mov rax, [rdi]
call qword ptr [rax+18h]
loc_F5755:
mov rdi, r14
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
mov rdi, rsp
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
lea rax, [rsp+138h+var_88]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F5786
mov rsi, [rsp+138h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F5786:
lea rbx, [rsp+138h+var_38]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+138h+var_40]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+138h+var_50]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rbx, [rsp+138h+var_60]
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, [rbx-10h]
test rdi, rdi
jz short loc_F57FF
mov rax, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rax], 0
jz short loc_F57EA
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_F57F4
loc_F57EA:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_F57F4:
cmp eax, 1
jnz short loc_F57FF
mov rax, [rdi]
call qword ptr [rax+18h]
loc_F57FF:
add rsp, 110h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_F580F:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFilternodeFilt; "FilterNode.filter is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_F5849
loc_F582D:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFilternodeBody; "FilterNode.body is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_F5849:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_F585F:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
lea rsi, [rsp+138h+var_78]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aFilterMustBeAC; "Filter must be a callable: "
lea rdi, [rsp+138h+var_E8]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+138h+var_E8]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rax, [rsp+138h+var_D8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F58DD
mov rsi, [rsp+138h+var_D8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F58DD:
lea rax, [rsp+138h+var_128]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F58F8
mov rsi, [rsp+138h+var_128]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F58F8:
test bpl, bpl
jnz short loc_F5925
jmp loc_F59C0
mov rbx, rax
lea rax, [rsp+138h+var_128]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F5925
mov rsi, [rsp+138h+var_128]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_F5925
mov rbx, rax
loc_F5925:
mov rdi, r14; void *
call ___cxa_free_exception
jmp loc_F59C0
jmp short $+2
loc_F5934:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp loc_F59CD
mov rbx, rax
lea rax, [rsp+138h+var_F8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F5967
mov rsi, [rsp+138h+var_F8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_F5967
mov rbx, rax
loc_F5967:
lea rdi, [rsp+138h+var_E8]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_F5976
mov rbx, rax
loc_F5976:
mov rdi, r14
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
mov rdi, rsp
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
jmp short loc_F599A
mov rbx, rax
lea rdi, [rsp+138h+var_E8]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_F599A
mov rbx, rax
loc_F599A:
lea rax, [rsp+138h+var_88]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F59C0
mov rsi, [rsp+138h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_F59C0
mov rbx, rax
loc_F59C0:
lea rdi, [rsp+138h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_F59CD:
mov rdi, rbx
call __Unwind_Resume
| void minja::FilterNode::do_render(long long a1, long long a2, int a3)
{
void (***v4)(void); // rsi
long long v6; // rdi
signed __int32 v7; // eax
long long v8; // rdi
signed __int32 v9; // eax
long long v10; // rdi
signed __int32 v11; // eax
std::runtime_error *exception; // r14
void *v13; // r14
_QWORD v14[2]; // [rsp+0h] [rbp-138h] BYREF
__int128 v15; // [rsp+18h] [rbp-120h] BYREF
long long v16; // [rsp+28h] [rbp-110h]
void *v17[2]; // [rsp+30h] [rbp-108h] BYREF
long long v18; // [rsp+40h] [rbp-F8h] BYREF
long long v19; // [rsp+50h] [rbp-E8h] BYREF
long long v20; // [rsp+58h] [rbp-E0h]
volatile signed __int32 *v21[2]; // [rsp+68h] [rbp-D0h] BYREF
volatile signed __int32 *v22[2]; // [rsp+78h] [rbp-C0h] BYREF
volatile signed __int32 *v23; // [rsp+88h] [rbp-B0h] BYREF
char v24[16]; // [rsp+90h] [rbp-A8h] BYREF
void *v25[2]; // [rsp+A0h] [rbp-98h] BYREF
long long v26; // [rsp+B0h] [rbp-88h] BYREF
_BYTE v27[8]; // [rsp+C0h] [rbp-78h] BYREF
long long v28; // [rsp+C8h] [rbp-70h]
volatile signed __int32 *v29; // [rsp+D8h] [rbp-60h] BYREF
volatile signed __int32 *v30[2]; // [rsp+E8h] [rbp-50h] BYREF
volatile signed __int32 *v31; // [rsp+F8h] [rbp-40h] BYREF
char v32[56]; // [rsp+100h] [rbp-38h] BYREF
v4 = *(void (****)(void))(a1 + 32);
if ( !v4 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "FilterNode.filter is null");
goto LABEL_29;
}
if ( !*(_QWORD *)(a1 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "FilterNode.body is null");
LABEL_29:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v27, v4);
if ( !v30[1] )
{
v13 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v14, (long long)v27, 0xFFFFFFFF, 0);
std::operator+<char>(&v19, (long long)"Filter must be a callable: ", (long long)v14);
std::runtime_error::runtime_error(v13, &v19);
__cxa_throw(
v13,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::TemplateNode::render[abi:cxx11]((long long)v25, *(_QWORD *)(a1 + 48), a3);
minja::Value::Value((long long)&v19, (long long)v25);
std::vector<minja::Value>::vector((long long)v14, (long long)&v19, 1LL);
v15 = 0LL;
v16 = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v24);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v24);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v23);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v22);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v21);
v6 = v20;
if ( v20 )
{
if ( _libc_single_threaded )
{
v7 = *(_DWORD *)(v20 + 12);
*(_DWORD *)(v20 + 12) = v7 - 1;
}
else
{
v7 = _InterlockedExchangeAdd((volatile signed __int32 *)(v20 + 12), 0xFFFFFFFF);
}
if ( v7 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v6 + 24LL))(v6, 0LL);
}
minja::Value::call((long long)&v19, (long long)v27);
minja::Value::to_str[abi:cxx11](v17, (long long)&v19);
std::__ostream_insert<char,std::char_traits<char>>(a2, v17[0], v17[1]);
if ( v17[0] != &v18 )
operator delete(v17[0], v18 + 1);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v24);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v24);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v23);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v22);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v21);
v8 = v20;
if ( v20 )
{
if ( _libc_single_threaded )
{
v9 = *(_DWORD *)(v20 + 12);
*(_DWORD *)(v20 + 12) = v9 - 1;
}
else
{
v9 = _InterlockedExchangeAdd((volatile signed __int32 *)(v20 + 12), 0xFFFFFFFF);
}
if ( v9 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v8 + 24LL))(v8, 0LL);
}
std::vector<std::pair<std::string,minja::Value>>::~vector(&v15);
std::vector<minja::Value>::~vector(v14);
if ( v25[0] != &v26 )
operator delete(v25[0], v26 + 1);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v32);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v32);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v31);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v30);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v29);
v10 = v28;
if ( v28 )
{
if ( _libc_single_threaded )
{
v11 = *(_DWORD *)(v28 + 12);
*(_DWORD *)(v28 + 12) = v11 - 1;
}
else
{
v11 = _InterlockedExchangeAdd((volatile signed __int32 *)(v28 + 12), 0xFFFFFFFF);
}
if ( v11 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v10 + 24LL))(v10, 0LL);
}
}
| do_render:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV RBX,RSI
MOV RSI,qword ptr [RDI + 0x20]
TEST RSI,RSI
JZ 0x001f580f
MOV R14,RDI
CMP qword ptr [RDI + 0x30],0x0
JZ 0x001f582d
MOV R15,RDX
LEA R12,[RSP + 0xc0]
MOV RDI,R12
CALL 0x001e1958
CMP qword ptr [R12 + 0x30],0x0
JZ 0x001f585f
MOV RSI,qword ptr [R14 + 0x30]
LAB_001f55cc:
LEA RDI,[RSP + 0xa0]
MOV RDX,R15
CALL 0x001bc604
LAB_001f55dc:
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0xa0]
CALL 0x001bc4a2
LAB_001f55ee:
MOV RDI,RSP
LEA RSI,[RSP + 0x50]
LEA RCX,[RSP + 0x30]
MOV EDX,0x1
CALL 0x001c2fa0
LAB_001f5605:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV qword ptr [RSP + 0x28],0x0
LEA R14,[RSP + 0x90]
MOV RDI,R14
XOR ESI,ESI
CALL 0x001858ca
MOV RDI,R14
CALL 0x00189fe4
LEA RDI,[RSP + 0x88]
CALL 0x00171092
LEA RDI,[RSP + 0x78]
CALL 0x00171092
LEA R14,[RSP + 0x68]
MOV RDI,R14
CALL 0x00171092
MOV RDI,qword ptr [R14 + -0x10]
TEST RDI,RDI
JZ 0x001f5689
MOV RAX,qword ptr [0x00261f98]
CMP byte ptr [RAX],0x0
JZ 0x001f5674
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001f567e
LAB_001f5674:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001f567e:
CMP EAX,0x1
JNZ 0x001f5689
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001f5689:
LEA R14,[RSP + 0x18]
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0xc0]
MOV RCX,RSP
MOV RDX,R15
CALL 0x001ca75c
LAB_001f56a6:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x50]
CALL 0x001c76c0
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
LAB_001f56bf:
MOV RDI,RBX
CALL 0x00121020
LAB_001f56c7:
LEA RAX,[RSP + 0x40]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001f56e2
MOV RSI,qword ptr [RSP + 0x40]
INC RSI
CALL 0x00120170
LAB_001f56e2:
LEA RBX,[RSP + 0x90]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001858ca
MOV RDI,RBX
CALL 0x00189fe4
LEA RDI,[RSP + 0x88]
CALL 0x00171092
LEA RDI,[RSP + 0x78]
CALL 0x00171092
LEA RBX,[RSP + 0x68]
MOV RDI,RBX
CALL 0x00171092
MOV RDI,qword ptr [RBX + -0x10]
TEST RDI,RDI
JZ 0x001f5755
MOV RAX,qword ptr [0x00261f98]
CMP byte ptr [RAX],0x0
JZ 0x001f5740
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001f574a
LAB_001f5740:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001f574a:
CMP EAX,0x1
JNZ 0x001f5755
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001f5755:
MOV RDI,R14
CALL 0x001cae26
MOV RDI,RSP
CALL 0x001be5c0
LEA RAX,[RSP + 0xb0]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001f5786
MOV RSI,qword ptr [RSP + 0xb0]
INC RSI
CALL 0x00120170
LAB_001f5786:
LEA RBX,[RSP + 0x100]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001858ca
MOV RDI,RBX
CALL 0x00189fe4
LEA RDI,[RSP + 0xf8]
CALL 0x00171092
LEA RDI,[RSP + 0xe8]
CALL 0x00171092
LEA RBX,[RSP + 0xd8]
MOV RDI,RBX
CALL 0x00171092
MOV RDI,qword ptr [RBX + -0x10]
TEST RDI,RDI
JZ 0x001f57ff
MOV RAX,qword ptr [0x00261f98]
CMP byte ptr [RAX],0x0
JZ 0x001f57ea
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001f57f4
LAB_001f57ea:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001f57f4:
CMP EAX,0x1
JNZ 0x001f57ff
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001f57ff:
ADD RSP,0x110
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001f580f:
MOV EDI,0x10
CALL 0x00120620
MOV R14,RAX
LAB_001f581c:
LEA RSI,[0x2222b6]
MOV RDI,RAX
CALL 0x00120400
LAB_001f582b:
JMP 0x001f5849
LAB_001f582d:
MOV EDI,0x10
CALL 0x00120620
MOV R14,RAX
LAB_001f583a:
LEA RSI,[0x2222d0]
MOV RDI,RAX
CALL 0x00120400
LAB_001f5849:
MOV RSI,qword ptr [0x00261fc0]
MOV RDX,qword ptr [0x00261f80]
MOV RDI,R14
CALL 0x00120a30
LAB_001f585f:
MOV EDI,0x10
CALL 0x00120620
MOV R14,RAX
LAB_001f586c:
MOV RDI,RSP
LEA RSI,[RSP + 0xc0]
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001b669c
LAB_001f5883:
LEA RSI,[0x2222e8]
LEA RDI,[RSP + 0x50]
MOV RDX,RSP
CALL 0x001b0110
MOV BPL,0x1
LAB_001f589a:
LEA RSI,[RSP + 0x50]
MOV RDI,R14
CALL 0x00120450
XOR EBP,EBP
MOV RSI,qword ptr [0x00261fc0]
MOV RDX,qword ptr [0x00261f80]
MOV RDI,R14
CALL 0x00120a30
|
/* minja::FilterNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context>
const&) const */
void minja::FilterNode::do_render(ostringstream *param_1,shared_ptr *param_2)
{
int *piVar1;
int iVar2;
runtime_error *prVar3;
vector<minja::Value,std::allocator<minja::Value>> avStack_138 [24];
int8 local_120;
int8 uStack_118;
int8 local_110;
long *local_108;
long local_100;
long local_f8 [2];
Value local_e8 [8];
long *local_e0;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_d0 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_c0 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_b0 [8];
data local_a8 [16];
long *local_98 [2];
long local_88 [2];
Expression local_78 [8];
long *local_70;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_60 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_50 [8];
long local_48;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_40 [8];
data local_38 [16];
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001f581c to 001f582a has its CatchHandler @ 001f5934 */
std::runtime_error::runtime_error(prVar3,"FilterNode.filter is null");
}
else {
if (*(long *)(param_1 + 0x30) != 0) {
Expression::evaluate(local_78,*(shared_ptr **)(param_1 + 0x20));
if (local_48 != 0) {
/* try { // try from 001f55cc to 001f55db has its CatchHandler @ 001f59bd */
TemplateNode::render_abi_cxx11_((TemplateNode *)local_98,*(shared_ptr **)(param_1 + 0x30));
/* try { // try from 001f55dc to 001f55ed has its CatchHandler @ 001f5997 */
Value::Value(local_e8,(string *)local_98);
/* try { // try from 001f55ee to 001f5604 has its CatchHandler @ 001f5988 */
std::vector<minja::Value,std::allocator<minja::Value>>::vector
(avStack_138,local_e8,1,&local_108);
local_120 = 0;
uStack_118 = 0;
local_110 = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_a8,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_a8);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_b0);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_c0);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_d0);
if (local_e0 != (long *)0x0) {
if (*PTR___libc_single_threaded_00261f98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_e0 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_e0 + 0xc);
*(int *)((long)local_e0 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_e0 + 0x18))();
}
}
/* try { // try from 001f5689 to 001f56a5 has its CatchHandler @ 001f5973 */
Value::call(local_e8,(ArgumentsValue *)local_78);
/* try { // try from 001f56a6 to 001f56b4 has its CatchHandler @ 001f5964 */
Value::to_str_abi_cxx11_();
/* try { // try from 001f56bf to 001f56c6 has its CatchHandler @ 001f5944 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)param_2,(char *)local_108,local_100);
if (local_108 != local_f8) {
operator_delete(local_108,local_f8[0] + 1);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_a8,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_a8);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_b0);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_c0);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_d0);
if (local_e0 != (long *)0x0) {
if (*PTR___libc_single_threaded_00261f98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_e0 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_e0 + 0xc);
*(int *)((long)local_e0 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_e0 + 0x18))();
}
}
std::
vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
::~vector((vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
*)&local_120);
std::vector<minja::Value,std::allocator<minja::Value>>::~vector(avStack_138);
if (local_98[0] != local_88) {
operator_delete(local_98[0],local_88[0] + 1);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_38,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_38);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_50);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_60);
if (local_70 != (long *)0x0) {
if (*PTR___libc_single_threaded_00261f98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_70 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_70 + 0xc);
*(int *)((long)local_70 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_70 + 0x18))();
}
}
return;
}
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001f586c to 001f5882 has its CatchHandler @ 001f5922 */
Value::dump_abi_cxx11_((int)avStack_138,SUB81(local_78,0));
/* try { // try from 001f5883 to 001f5896 has its CatchHandler @ 001f5902 */
std::operator+((char *)local_e8,(string *)"Filter must be a callable: ");
/* try { // try from 001f589a to 001f58be has its CatchHandler @ 001f58bf */
std::runtime_error::runtime_error(prVar3,(string *)local_e8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00261fc0,PTR__runtime_error_00261f80);
}
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001f583a to 001f5848 has its CatchHandler @ 001f5932 */
std::runtime_error::runtime_error(prVar3,"FilterNode.body is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00261fc0,PTR__runtime_error_00261f80);
}
| |
32,155 | serial_cpp::MillisecondTimer::remaining() | ami-iit[P]serial_cpp/src/impl/unix.cc | int64_t
MillisecondTimer::remaining ()
{
timespec now(timespec_now());
int64_t millis = (expiry.tv_sec - now.tv_sec) * 1e3;
millis += (expiry.tv_nsec - now.tv_nsec) / 1e6;
return millis;
} | O1 | cpp | serial_cpp::MillisecondTimer::remaining():
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x3260
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq (%r14), %rax
cvtsi2sd %rax, %xmm0
mulsd 0x5dcb(%rip), %xmm0 # 0xb268
cvttsd2si %xmm0, %rax
subq 0x8(%r14), %rcx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
divsd 0x5daa(%rip), %xmm0 # 0xb260
cvtsi2sd %rax, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| _ZN10serial_cpp16MillisecondTimer9remainingEv:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
lea r14, [rsp+28h+var_20]
mov edi, 1
mov rsi, r14
call _clock_gettime
mov rax, [rbx]
mov rcx, [rbx+8]
sub rax, [r14]
cvtsi2sd xmm0, rax
mulsd xmm0, cs:qword_B268
cvttsd2si rax, xmm0
sub rcx, [r14+8]
xorps xmm0, xmm0
cvtsi2sd xmm0, rcx
divsd xmm0, cs:qword_B260
cvtsi2sd xmm1, rax
addsd xmm1, xmm0
cvttsd2si rax, xmm1
add rsp, 18h
pop rbx
pop r14
retn
| long long serial_cpp::MillisecondTimer::remaining(serial_cpp::MillisecondTimer *this)
{
int v2; // [rsp+8h] [rbp-20h] BYREF
int v3; // [rsp+10h] [rbp-18h]
clock_gettime(1LL, &v2);
return (unsigned int)(int)((double)(int)((double)(*(_DWORD *)this - v2) * 1000.0)
+ (double)(int)(*((_QWORD *)this + 1) - v3) / 1000000.0);
}
| remaining:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA R14,[RSP + 0x8]
MOV EDI,0x1
MOV RSI,R14
CALL 0x00103260
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
SUB RAX,qword ptr [R14]
CVTSI2SD XMM0,RAX
MULSD XMM0,qword ptr [0x0010b268]
CVTTSD2SI RAX,XMM0
SUB RCX,qword ptr [R14 + 0x8]
XORPS XMM0,XMM0
CVTSI2SD XMM0,RCX
DIVSD XMM0,qword ptr [0x0010b260]
CVTSI2SD XMM1,RAX
ADDSD XMM1,XMM0
CVTTSD2SI RAX,XMM1
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* serial_cpp::MillisecondTimer::remaining() */
long __thiscall serial_cpp::MillisecondTimer::remaining(MillisecondTimer *this)
{
timespec local_20;
clock_gettime(1,&local_20);
return (long)((double)(long)((double)(*(long *)this - local_20.tv_sec) * DAT_0010b268) +
(double)(*(long *)(this + 8) - local_20.tv_nsec) / DAT_0010b260);
}
| |
32,156 | JS_EvalThis | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_EvalInternal(JSContext *ctx, JSValue this_obj,
const char *input, size_t input_len,
const char *filename, int flags, int scope_idx)
{
if (unlikely(!ctx->eval_internal)) {
return JS_ThrowTypeError(ctx, "eval is not supported");
}
return ctx->eval_internal(ctx, this_obj, input, input_len, filename,
flags, scope_idx);
} | O1 | c | JS_EvalThis:
pushq %rbx
movq 0x1f8(%rdi), %r10
testq %r10, %r10
je 0x355cf
movl %r8d, %eax
movq %rcx, %r9
movq %rdx, %r8
movq %rsi, %rcx
movq 0x1a0(%rdi), %rsi
movq 0x1a8(%rdi), %rdx
pushq $-0x1
pushq %rax
callq *%r10
addq $0x10, %rsp
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
leaq 0x6e4ba(%rip), %rsi # 0xa3a90
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x265c3
movl $0x6, %edx
jmp 0x355ca
| JS_Eval:
push rbx
mov r10, [rdi+1F8h]
test r10, r10
jz short loc_355CF
mov eax, r8d
mov r9, rcx
mov r8, rdx
mov rcx, rsi
mov rsi, [rdi+1A0h]
mov rdx, [rdi+1A8h]
push 0FFFFFFFFFFFFFFFFh
push rax
call r10
add rsp, 10h
mov rbx, rax
loc_355CA:
mov rax, rbx
pop rbx
retn
loc_355CF:
lea rsi, aEvalIsNotSuppo; "eval is not supported"
xor ebx, ebx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
jmp short loc_355CA
| long long JS_Eval(
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long ( *v14)(_QWORD *, _QWORD, _QWORD, long long, long long, long long, _QWORD, long long); // r10
long long v15; // rbx
char v17; // [rsp+0h] [rbp-8h]
v14 = (long long ( *)(_QWORD *, _QWORD, _QWORD, long long, long long, long long, _QWORD, long long))a1[63];
if ( v14 )
return v14(a1, a1[52], a1[53], a2, a3, a4, (unsigned int)a5, -1LL);
v15 = 0LL;
JS_ThrowTypeError(
(long long)a1,
(long long)"eval is not supported",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v17);
return v15;
}
| JS_Eval:
PUSH RBX
MOV R10,qword ptr [RDI + 0x1f8]
TEST R10,R10
JZ 0x001355cf
MOV EAX,R8D
MOV R9,RCX
MOV R8,RDX
MOV RCX,RSI
MOV RSI,qword ptr [RDI + 0x1a0]
MOV RDX,qword ptr [RDI + 0x1a8]
PUSH -0x1
PUSH RAX
CALL R10
ADD RSP,0x10
MOV RBX,RAX
LAB_001355ca:
MOV RAX,RBX
POP RBX
RET
LAB_001355cf:
LEA RSI,[0x1a3a90]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x001265c3
MOV EDX,0x6
JMP 0x001355ca
|
int8
JS_Eval(long param_1,int8 param_2,int8 param_3,int8 param_4,int4 param_5)
{
int8 uVar1;
if (*(code **)(param_1 + 0x1f8) == (code *)0x0) {
uVar1 = 0;
JS_ThrowTypeError(param_1,"eval is not supported");
}
else {
uVar1 = (**(code **)(param_1 + 0x1f8))
(param_1,*(int8 *)(param_1 + 0x1a0),*(int8 *)(param_1 + 0x1a8),
param_2,param_3,param_4,param_5,0xffffffffffffffff);
}
return uVar1;
}
| |
32,157 | minja::Expression::evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | Value evaluate(const std::shared_ptr<Context> & context) const {
try {
return do_evaluate(context);
} catch (const std::exception & e) {
std::ostringstream out;
out << e.what();
if (location.source) out << error_location_suffix(*location.source, location.pos);
throw std::runtime_error(out.str());
}
} | O2 | cpp | minja::Expression::evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
callq *(%rax)
movq %rbx, %rax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x610cb
movq %rbx, %rdi
callq 0x21310
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x21ac0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x217e0
movq 0x8(%r14), %rsi
testq %rsi, %rsi
jne 0x61059
pushq $0x10
popq %rdi
callq 0x213f0
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21ce0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x21d30
xorl %ebp, %ebp
movq 0x78fa6(%rip), %rsi # 0xd9ff0
movq 0x78f17(%rip), %rdx # 0xd9f68
movq %r14, %rdi
callq 0x21de0
movq 0x18(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x4d24e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x216f0
leaq 0x8(%rsp), %rdi
callq 0x22078
jmp 0x61017
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22078
jmp 0x610b7
jmp 0x610b4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22078
testb %bpl, %bpl
jne 0x610aa
jmp 0x610b7
movq %rax, %rbx
movq %r14, %rdi
callq 0x215c0
jmp 0x610b7
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x21190
jmp 0x610c6
movq %rax, %rbx
callq 0x21d50
movq %rbx, %rdi
callq 0x21e50
movq %rax, %rdi
callq 0x24faa
nop
| _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r14
push rbx
sub rsp, 1A0h
mov r14, rsi
mov rbx, rdi
mov rax, [rsi]
call qword ptr [rax]
mov rax, rbx
add rsp, 1A0h
pop rbx
pop r14
pop rbp
retn
mov rbx, rax
cmp edx, 1
jnz loc_610CB
mov rdi, rbx; void *
call ___cxa_begin_catch
mov rbx, rax
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+10h]
lea rdi, [rsp+arg_20]
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rsi, [r14+8]
test rsi, rsi
jnz short loc_61059
loc_61017:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, [rsp+arg_28]
lea rdi, [rsp+arg_0]
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov bpl, 1
lea rsi, [rsp+arg_0]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_61059:
mov rdx, [r14+18h]
lea rdi, [rsp+arg_0]
call _ZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm_0; minja::error_location_suffix(std::string const&,ulong)
lea rdi, [rsp+arg_20]
lea rsi, [rsp+arg_0]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_61017
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_610B7
jmp short loc_610B4
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_610AA
jmp short loc_610B7
mov rbx, rax
loc_610AA:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_610B7
loc_610B4:
mov rbx, rax
loc_610B7:
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
jmp short loc_610C6
mov rbx, rax
loc_610C6:
call ___cxa_end_catch
loc_610CB:
mov rdi, rbx
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long minja::Expression::evaluate(long long a1, void (***a2)(void))
{
(**a2)();
return a1;
}
| evaluate:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x1a0
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI]
LAB_00160fc6:
CALL qword ptr [RAX]
LAB_00160fc8:
MOV RAX,RBX
ADD RSP,0x1a0
POP RBX
POP R14
POP RBP
RET
|
/* minja::Expression::evaluate(std::shared_ptr<minja::Context> const&) const */
Expression * __thiscall minja::Expression::evaluate(Expression *this,shared_ptr *param_1)
{
/* try { // try from 00160fc6 to 00160fc7 has its CatchHandler @ 00160fd7 */
(*(code *)**(int8 **)param_1)();
return this;
}
| |
32,158 | LEX::sp_pop_loop_label(THD*, st_mysql_const_lex_string const*) | eloqsql/sql/sql_lex.cc | bool LEX::sp_pop_loop_label(THD *thd, const LEX_CSTRING *label_name)
{
sp_label *lab= spcont->pop_label();
sphead->backpatch(lab);
if (label_name->str &&
lex_string_cmp(system_charset_info, label_name,
&lab->name) != 0)
{
my_error(ER_SP_LABEL_MISMATCH, MYF(0), label_name->str);
return true;
}
return false;
} | O3 | cpp | LEX::sp_pop_loop_label(THD*, st_mysql_const_lex_string const*):
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq 0x1970(%rdi), %rcx
movq 0xe8(%rcx), %rax
cmpq 0xd505b3(%rip), %rax # 0x149ae28
je 0x74a89d
movq (%rax), %rdx
movq %rdx, 0xe8(%rcx)
decl 0xf8(%rcx)
jne 0x74a897
leaq 0xe8(%rcx), %rdx
movq %rdx, 0xf0(%rcx)
movq 0x8(%rax), %r14
jmp 0x74a8a0
xorl %r14d, %r14d
movq 0x1960(%rdi), %rdi
movq %r14, %rsi
callq 0x6e773c
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x74a8e7
leaq 0xe0cdca(%rip), %rax # 0x1557688
movq (%rax), %rdi
movq (%r14), %rdx
movq 0xc0(%rdi), %rax
callq *0x40(%rax)
testl %eax, %eax
je 0x74a8e7
movq (%rbx), %rdx
movl $0x51e, %edi # imm = 0x51E
xorl %esi, %esi
xorl %eax, %eax
callq 0xcbf683
movb $0x1, %al
jmp 0x74a8e9
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
| _ZN3LEX17sp_pop_loop_labelEP3THDPK25st_mysql_const_lex_string:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdx
mov rcx, [rdi+1970h]
mov rax, [rcx+0E8h]
cmp rax, cs:end_of_list_ptr
jz short loc_74A89D
mov rdx, [rax]
mov [rcx+0E8h], rdx
dec dword ptr [rcx+0F8h]
jnz short loc_74A897
lea rdx, [rcx+0E8h]
mov [rcx+0F0h], rdx
loc_74A897:
mov r14, [rax+8]
jmp short loc_74A8A0
loc_74A89D:
xor r14d, r14d
loc_74A8A0:
mov rdi, [rdi+1960h]
mov rsi, r14
call _ZN7sp_head9backpatchEP8sp_label; sp_head::backpatch(sp_label *)
mov rsi, [rbx]
test rsi, rsi
jz short loc_74A8E7
lea rax, system_charset_info
mov rdi, [rax]
mov rdx, [r14]
mov rax, [rdi+0C0h]
call qword ptr [rax+40h]
test eax, eax
jz short loc_74A8E7
mov rdx, [rbx]
mov edi, 51Eh
xor esi, esi
xor eax, eax
call my_error
mov al, 1
jmp short loc_74A8E9
loc_74A8E7:
xor eax, eax
loc_74A8E9:
pop rbx
pop r14
pop rbp
retn
| char LEX::sp_pop_loop_label(long long a1, long long a2, _QWORD *a3)
{
long long v4; // rcx
long long v5; // rax
_QWORD *v7; // r14
int v8; // ecx
int v9; // r8d
int v10; // r9d
v4 = *(_QWORD *)(a1 + 6512);
v5 = *(_QWORD *)(v4 + 232);
if ( (unsigned int *)v5 == &end_of_list )
{
v7 = 0LL;
}
else
{
*(_QWORD *)(v4 + 232) = *(_QWORD *)v5;
if ( (*(_DWORD *)(v4 + 248))-- == 1 )
*(_QWORD *)(v4 + 240) = v4 + 232;
v7 = *(_QWORD **)(v5 + 8);
}
sp_head::backpatch(*(_QWORD *)(a1 + 6496), (long long)v7);
if ( !*a3
|| !(*(unsigned int ( **)(long long, _QWORD, _QWORD))(*(_QWORD *)(system_charset_info + 192) + 64LL))(
system_charset_info,
*a3,
*v7) )
{
return 0;
}
my_error(1310, 0, *a3, v8, v9, v10);
return 1;
}
| do_apply_event:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RCX
MOV RBX,RDX
MOV R15,RSI
LEA R12,[0x15dd548]
MOV RAX,qword ptr [R12]
LEA RSI,[0xe84436]
MOV EDX,0x12bd
CALL qword ptr [RAX + 0x1f0]
PUSH 0x10
POP RCX
MOV RDI,R15
XOR ESI,ESI
MOV EDX,0x20081
CALL 0x00dbf338
MOV dword ptr [R14],EAX
MOV RCX,qword ptr [R12]
MOV RDI,qword ptr [RBX]
MOV ESI,EAX
CALL qword ptr [RCX + 0x200]
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* Append_block_log_event::do_apply_event(rpl_group_info*) [clone .cold.2] */
void Append_block_log_event::do_apply_event(rpl_group_info *param_1)
{
int4 uVar1;
int4 *in_RCX;
int8 *in_RDX;
(**(code **)(PSI_server + 0x1f0))
(param_1,"/workspace/llm4binary/github2025/eloqsql/sql/log_event_server.cc",0x12bd);
uVar1 = my_create();
*in_RCX = uVar1;
(**(code **)(PSI_server + 0x200))(*in_RDX,uVar1);
return;
}
| |
32,159 | mi_read_rnd_mempack_record | eloqsql/storage/myisam/mi_packrec.c | static int _mi_read_rnd_mempack_record(MI_INFO *info, uchar *buf,
register my_off_t filepos,
my_bool skip_deleted_blocks
__attribute__((unused)))
{
MI_BLOCK_INFO block_info;
MYISAM_SHARE *share=info->s;
uchar *pos,*start;
DBUG_ENTER("_mi_read_rnd_mempack_record");
if (filepos >= share->state.state.data_file_length)
{
my_errno=HA_ERR_END_OF_FILE;
goto err;
}
if (!(pos= (uchar*) _mi_mempack_get_block_info(info, &info->bit_buff,
&block_info, &info->rec_buff,
(uchar*)
(start=share->file_map+
filepos))))
goto err;
#ifndef DBUG_OFF
if (block_info.rec_len > info->s->max_pack_length)
{
my_errno=HA_ERR_WRONG_IN_RECORD;
goto err;
}
#endif
info->packed_length=block_info.rec_len;
info->lastpos=filepos;
info->nextpos=filepos+(uint) (pos-start)+block_info.rec_len;
info->update|= HA_STATE_AKTIV | HA_STATE_KEY_CHANGED;
DBUG_RETURN (_mi_pack_rec_unpack(info, &info->bit_buff, buf,
pos, block_info.rec_len));
err:
DBUG_RETURN(my_errno);
} | O0 | c | mi_read_rnd_mempack_record:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %cl, %al
movq %fs:0x28, %rcx
movq %rcx, -0x8(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq %rdx, -0x80(%rbp)
movb %al, -0x81(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x80(%rbp), %rax
movq -0x90(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jb 0xbc08b
callq 0xf6090
movl $0x89, (%rax)
jmp 0xbc158
movq -0x70(%rbp), %rdi
movq -0x70(%rbp), %rsi
addq $0x50, %rsi
movq -0x70(%rbp), %rcx
addq $0x120, %rcx # imm = 0x120
movq -0x90(%rbp), %rax
movq 0x270(%rax), %r8
addq -0x80(%rbp), %r8
movq %r8, -0xa0(%rbp)
leaq -0x60(%rbp), %rdx
callq 0xbdf30
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
jne 0xbc0d6
jmp 0xbc158
movq -0x48(%rbp), %rcx
movq -0x70(%rbp), %rax
movq %rcx, 0x1b0(%rax)
movq -0x80(%rbp), %rcx
movq -0x70(%rbp), %rax
movq %rcx, 0x170(%rax)
movq -0x80(%rbp), %rcx
movq -0x98(%rbp), %rax
movq -0xa0(%rbp), %rdx
subq %rdx, %rax
movl %eax, %eax
addq %rax, %rcx
addq -0x48(%rbp), %rcx
movq -0x70(%rbp), %rax
movq %rcx, 0x178(%rax)
movq -0x70(%rbp), %rax
movl 0x1d0(%rax), %ecx
orl $0x82, %ecx
movl %ecx, 0x1d0(%rax)
movq -0x70(%rbp), %rdi
movq -0x70(%rbp), %rsi
addq $0x50, %rsi
movq -0x78(%rbp), %rdx
movq -0x98(%rbp), %rcx
movq -0x48(%rbp), %r8
callq 0xbb6c0
movl %eax, -0x64(%rbp)
jmp 0xbc164
jmp 0xbc15a
callq 0xf6090
movl (%rax), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0xa4(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xbc18e
movl -0xa4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
callq 0x2a270
nopw %cs:(%rax,%rax)
| _mi_read_rnd_mempack_record:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov al, cl
mov rcx, fs:28h
mov [rbp+var_8], rcx
mov [rbp+var_70], rdi
mov [rbp+var_78], rsi
mov [rbp+var_80], rdx
mov [rbp+var_81], al
mov rax, [rbp+var_70]
mov rax, [rax]
mov [rbp+var_90], rax
mov rax, [rbp+var_80]
mov rcx, [rbp+var_90]
cmp rax, [rcx+40h]
jb short loc_BC08B
call _my_thread_var
mov dword ptr [rax], 89h
jmp loc_BC158
loc_BC08B:
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_70]
add rsi, 50h ; 'P'
mov rcx, [rbp+var_70]
add rcx, 120h
mov rax, [rbp+var_90]
mov r8, [rax+270h]
add r8, [rbp+var_80]
mov [rbp+var_A0], r8
lea rdx, [rbp+var_60]
call _mi_mempack_get_block_info
mov [rbp+var_98], rax
cmp rax, 0
jnz short loc_BC0D6
jmp loc_BC158
loc_BC0D6:
mov rcx, [rbp+var_48]
mov rax, [rbp+var_70]
mov [rax+1B0h], rcx
mov rcx, [rbp+var_80]
mov rax, [rbp+var_70]
mov [rax+170h], rcx
mov rcx, [rbp+var_80]
mov rax, [rbp+var_98]
mov rdx, [rbp+var_A0]
sub rax, rdx
mov eax, eax
add rcx, rax
add rcx, [rbp+var_48]
mov rax, [rbp+var_70]
mov [rax+178h], rcx
mov rax, [rbp+var_70]
mov ecx, [rax+1D0h]
or ecx, 82h
mov [rax+1D0h], ecx
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_70]
add rsi, 50h ; 'P'
mov rdx, [rbp+var_78]
mov rcx, [rbp+var_98]
mov r8, [rbp+var_48]
call _mi_pack_rec_unpack
mov [rbp+var_64], eax
jmp short loc_BC164
loc_BC158:
jmp short $+2
loc_BC15A:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_64], eax
loc_BC164:
mov eax, [rbp+var_64]
mov [rbp+var_A4], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_BC18E
mov eax, [rbp+var_A4]
add rsp, 0B0h
pop rbp
retn
loc_BC18E:
call ___stack_chk_fail
| long long mi_read_rnd_mempack_record(long long *a1, const char *a2, unsigned long long a3)
{
unsigned long long v4; // [rsp+10h] [rbp-A0h]
long long block_info; // [rsp+18h] [rbp-98h]
long long v7; // [rsp+38h] [rbp-78h]
char v9[24]; // [rsp+50h] [rbp-60h] BYREF
long long v10; // [rsp+68h] [rbp-48h]
unsigned long long v11; // [rsp+A8h] [rbp-8h]
v11 = __readfsqword(0x28u);
v7 = (long long)a2;
if ( a3 >= *(_QWORD *)(*a1 + 64) )
{
*(_DWORD *)my_thread_var(a1, a2) = 137;
return *(unsigned int *)my_thread_var(a1, a2);
}
a2 = (const char *)(a1 + 10);
v4 = a3 + *(_QWORD *)(*a1 + 624);
block_info = mi_mempack_get_block_info(a1, a1 + 10, v9, a1 + 36, v4);
if ( !block_info )
return *(unsigned int *)my_thread_var(a1, a2);
a1[54] = v10;
a1[46] = a3;
a1[47] = v10 + (unsigned int)(block_info - v4) + a3;
*((_DWORD *)a1 + 116) |= 0x82u;
return (unsigned int)mi_pack_rec_unpack(a1, (long long)(a1 + 10), v7, block_info, v10);
}
| _mi_read_rnd_mempack_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV AL,CL
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RCX
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x78],RSI
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RBP + -0x81],AL
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x90]
CMP RAX,qword ptr [RCX + 0x40]
JC 0x001bc08b
CALL 0x001f6090
MOV dword ptr [RAX],0x89
JMP 0x001bc158
LAB_001bc08b:
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x70]
ADD RSI,0x50
MOV RCX,qword ptr [RBP + -0x70]
ADD RCX,0x120
MOV RAX,qword ptr [RBP + -0x90]
MOV R8,qword ptr [RAX + 0x270]
ADD R8,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0xa0],R8
LEA RDX,[RBP + -0x60]
CALL 0x001bdf30
MOV qword ptr [RBP + -0x98],RAX
CMP RAX,0x0
JNZ 0x001bc0d6
JMP 0x001bc158
LAB_001bc0d6:
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX + 0x1b0],RCX
MOV RCX,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX + 0x170],RCX
MOV RCX,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RBP + -0x98]
MOV RDX,qword ptr [RBP + -0xa0]
SUB RAX,RDX
MOV EAX,EAX
ADD RCX,RAX
ADD RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX + 0x178],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,dword ptr [RAX + 0x1d0]
OR ECX,0x82
MOV dword ptr [RAX + 0x1d0],ECX
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x70]
ADD RSI,0x50
MOV RDX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x98]
MOV R8,qword ptr [RBP + -0x48]
CALL 0x001bb6c0
MOV dword ptr [RBP + -0x64],EAX
JMP 0x001bc164
LAB_001bc158:
JMP 0x001bc15a
LAB_001bc15a:
CALL 0x001f6090
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x64],EAX
LAB_001bc164:
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0xa4],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001bc18e
MOV EAX,dword ptr [RBP + -0xa4]
ADD RSP,0xb0
POP RBP
RET
LAB_001bc18e:
CALL 0x0012a270
|
int4 _mi_read_rnd_mempack_record(long *param_1,int8 param_2,ulong param_3)
{
int8 uVar1;
int4 *puVar2;
long lVar3;
long in_FS_OFFSET;
int4 local_6c;
int1 local_68 [24];
long local_50;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_3 < *(ulong *)(*param_1 + 0x40)) {
uVar1 = *(int8 *)(*param_1 + 0x270);
lVar3 = _mi_mempack_get_block_info(param_1,param_1 + 10,local_68,param_1 + 0x24);
if (lVar3 != 0) {
param_1[0x36] = local_50;
param_1[0x2e] = param_3;
param_1[0x2f] = param_3 + (uint)((int)lVar3 - ((int)uVar1 + (int)param_3)) + local_50;
*(uint *)(param_1 + 0x3a) = *(uint *)(param_1 + 0x3a) | 0x82;
local_6c = _mi_pack_rec_unpack(param_1,param_1 + 10,param_2,lVar3,local_50);
goto LAB_001bc164;
}
}
else {
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x89;
}
puVar2 = (int4 *)_my_thread_var();
local_6c = *puVar2;
LAB_001bc164:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_6c;
}
| |
32,160 | string_buffer_putc8 | bluesky950520[P]quickjs/quickjs.c | static int string_buffer_putc8(StringBuffer *s, uint32_t c)
{
if (unlikely(s->len >= s->size)) {
if (string_buffer_realloc(s, s->len + 1, c))
return -1;
}
if (s->is_wide_char) {
s->str->u.str16[s->len++] = c;
} else {
s->str->u.str8[s->len++] = c;
}
return 0;
} | O0 | c | string_buffer_putc8:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x14(%rcx), %eax
setge %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x832db
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
addl $0x1, %esi
movl 0x4(%rsp), %edx
callq 0x6ea10
cmpl $0x0, %eax
je 0x832d9
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x8333e
jmp 0x832db
movq 0x8(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x83310
movl 0x4(%rsp), %eax
movw %ax, %dx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rsi
movl 0x10(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x10(%rsi)
movslq %ecx, %rcx
movw %dx, 0x18(%rax,%rcx,2)
jmp 0x83336
movl 0x4(%rsp), %eax
movb %al, %dl
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rsi
movl 0x10(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x10(%rsi)
movslq %ecx, %rcx
movb %dl, 0x18(%rax,%rcx)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| string_buffer_putc8:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
mov [rsp+18h+var_14], esi
mov rax, [rsp+18h+var_10]
mov eax, [rax+10h]
mov rcx, [rsp+18h+var_10]
cmp eax, [rcx+14h]
setnl al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_832DB
mov rdi, [rsp+18h+var_10]
mov rax, [rsp+18h+var_10]
mov esi, [rax+10h]
add esi, 1
mov edx, [rsp+18h+var_14]
call string_buffer_realloc
cmp eax, 0
jz short loc_832D9
mov [rsp+18h+var_4], 0FFFFFFFFh
jmp short loc_8333E
loc_832D9:
jmp short $+2
loc_832DB:
mov rax, [rsp+18h+var_10]
cmp dword ptr [rax+18h], 0
jz short loc_83310
mov eax, [rsp+18h+var_14]
mov dx, ax
mov rax, [rsp+18h+var_10]
mov rax, [rax+8]
mov rsi, [rsp+18h+var_10]
mov ecx, [rsi+10h]
mov edi, ecx
add edi, 1
mov [rsi+10h], edi
movsxd rcx, ecx
mov [rax+rcx*2+18h], dx
jmp short loc_83336
loc_83310:
mov eax, [rsp+18h+var_14]
mov dl, al
mov rax, [rsp+18h+var_10]
mov rax, [rax+8]
mov rsi, [rsp+18h+var_10]
mov ecx, [rsi+10h]
mov edi, ecx
add edi, 1
mov [rsi+10h], edi
movsxd rcx, ecx
mov [rax+rcx+18h], dl
loc_83336:
mov [rsp+18h+var_4], 0
loc_8333E:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long string_buffer_putc8(
long long a1,
unsigned int a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
long long v14; // rax
int v15; // ecx
if ( *(_DWORD *)(a1 + 16) >= *(_DWORD *)(a1 + 20)
&& (unsigned int)string_buffer_realloc(
a1,
*(_DWORD *)(a1 + 16) + 1,
a2,
a1,
a13,
a14,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10) )
{
return (unsigned int)-1;
}
else
{
v14 = *(_QWORD *)(a1 + 8);
v15 = *(_DWORD *)(a1 + 16);
if ( *(_DWORD *)(a1 + 24) )
{
++*(_DWORD *)(a1 + 16);
*(_WORD *)(v14 + 2LL * v15 + 24) = a2;
}
else
{
++*(_DWORD *)(a1 + 16);
*(_BYTE *)(v14 + v15 + 24) = a2;
}
return 0;
}
}
| string_buffer_putc8:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV dword ptr [RSP + 0x4],ESI
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX + 0x10]
MOV RCX,qword ptr [RSP + 0x8]
CMP EAX,dword ptr [RCX + 0x14]
SETGE AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001832db
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RAX + 0x10]
ADD ESI,0x1
MOV EDX,dword ptr [RSP + 0x4]
CALL 0x0016ea10
CMP EAX,0x0
JZ 0x001832d9
MOV dword ptr [RSP + 0x14],0xffffffff
JMP 0x0018333e
LAB_001832d9:
JMP 0x001832db
LAB_001832db:
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x18],0x0
JZ 0x00183310
MOV EAX,dword ptr [RSP + 0x4]
MOV DX,AX
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RSI + 0x10]
MOV EDI,ECX
ADD EDI,0x1
MOV dword ptr [RSI + 0x10],EDI
MOVSXD RCX,ECX
MOV word ptr [RAX + RCX*0x2 + 0x18],DX
JMP 0x00183336
LAB_00183310:
MOV EAX,dword ptr [RSP + 0x4]
MOV DL,AL
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RSI + 0x10]
MOV EDI,ECX
ADD EDI,0x1
MOV dword ptr [RSI + 0x10],EDI
MOVSXD RCX,ECX
MOV byte ptr [RAX + RCX*0x1 + 0x18],DL
LAB_00183336:
MOV dword ptr [RSP + 0x14],0x0
LAB_0018333e:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
int4 string_buffer_putc8(long param_1,int4 param_2)
{
int iVar1;
int4 local_4;
if ((*(int *)(param_1 + 0x10) < *(int *)(param_1 + 0x14)) ||
(iVar1 = string_buffer_realloc(param_1,*(int *)(param_1 + 0x10) + 1,param_2), iVar1 == 0)) {
if (*(int *)(param_1 + 0x18) == 0) {
iVar1 = *(int *)(param_1 + 0x10);
*(int *)(param_1 + 0x10) = iVar1 + 1;
*(char *)(*(long *)(param_1 + 8) + 0x18 + (long)iVar1) = (char)param_2;
}
else {
iVar1 = *(int *)(param_1 + 0x10);
*(int *)(param_1 + 0x10) = iVar1 + 1;
*(short *)(*(long *)(param_1 + 8) + 0x18 + (long)iVar1 * 2) = (short)param_2;
}
local_4 = 0;
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
| |
32,161 | string_buffer_putc8 | bluesky950520[P]quickjs/quickjs.c | static int string_buffer_putc8(StringBuffer *s, uint32_t c)
{
if (unlikely(s->len >= s->size)) {
if (string_buffer_realloc(s, s->len + 1, c))
return -1;
}
if (s->is_wide_char) {
s->str->u.str16[s->len++] = c;
} else {
s->str->u.str8[s->len++] = c;
}
return 0;
} | O1 | c | string_buffer_putc8:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x10(%rdi), %esi
cmpl 0x14(%rdi), %esi
jge 0x4ac89
movslq 0x10(%r14), %rax
leal 0x1(%rax), %edx
cmpl $0x0, 0x18(%r14)
movq 0x8(%r14), %rcx
movl %edx, 0x10(%r14)
je 0x4ac7b
movw %bx, 0x18(%rcx,%rax,2)
jmp 0x4ac7f
movb %bl, 0x18(%rcx,%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incl %esi
movq %r14, %rdi
movl %ebx, %edx
callq 0x4158f
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x4ac81
jmp 0x4ac5e
| string_buffer_putc8:
push r14
push rbx
push rax
mov ebx, esi
mov r14, rdi
mov esi, [rdi+10h]
cmp esi, [rdi+14h]
jge short loc_4AC89
loc_4AC5E:
movsxd rax, dword ptr [r14+10h]
lea edx, [rax+1]
cmp dword ptr [r14+18h], 0
mov rcx, [r14+8]
mov [r14+10h], edx
jz short loc_4AC7B
mov [rcx+rax*2+18h], bx
jmp short loc_4AC7F
loc_4AC7B:
mov [rcx+rax+18h], bl
loc_4AC7F:
xor eax, eax
loc_4AC81:
add rsp, 8
pop rbx
pop r14
retn
loc_4AC89:
inc esi
mov rdi, r14
mov edx, ebx
call string_buffer_realloc
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jnz short loc_4AC81
jmp short loc_4AC5E
| long long string_buffer_putc8(
long long a1,
unsigned int a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
int v15; // esi
long long v16; // rax
bool v17; // zf
long long v18; // rcx
long long result; // rax
int v20; // ecx
v15 = *(_DWORD *)(a1 + 16);
if ( v15 < *(_DWORD *)(a1 + 20)
|| (v20 = string_buffer_realloc(a1, v15 + 1, a2, a12, a13, a14, a3, a4, a5, a6, a7, a8, a9, a10),
result = 0xFFFFFFFFLL,
!v20) )
{
v16 = *(int *)(a1 + 16);
v17 = *(_DWORD *)(a1 + 24) == 0;
v18 = *(_QWORD *)(a1 + 8);
*(_DWORD *)(a1 + 16) = v16 + 1;
if ( v17 )
*(_BYTE *)(v18 + v16 + 24) = a2;
else
*(_WORD *)(v18 + 2 * v16 + 24) = a2;
return 0LL;
}
return result;
}
| string_buffer_putc8:
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
MOV ESI,dword ptr [RDI + 0x10]
CMP ESI,dword ptr [RDI + 0x14]
JGE 0x0014ac89
LAB_0014ac5e:
MOVSXD RAX,dword ptr [R14 + 0x10]
LEA EDX,[RAX + 0x1]
CMP dword ptr [R14 + 0x18],0x0
MOV RCX,qword ptr [R14 + 0x8]
MOV dword ptr [R14 + 0x10],EDX
JZ 0x0014ac7b
MOV word ptr [RCX + RAX*0x2 + 0x18],BX
JMP 0x0014ac7f
LAB_0014ac7b:
MOV byte ptr [RCX + RAX*0x1 + 0x18],BL
LAB_0014ac7f:
XOR EAX,EAX
LAB_0014ac81:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0014ac89:
INC ESI
MOV RDI,R14
MOV EDX,EBX
CALL 0x0014158f
MOV ECX,EAX
MOV EAX,0xffffffff
TEST ECX,ECX
JNZ 0x0014ac81
JMP 0x0014ac5e
|
int8 string_buffer_putc8(long param_1,int4 param_2)
{
int iVar1;
if ((*(int *)(param_1 + 0x14) <= *(int *)(param_1 + 0x10)) &&
(iVar1 = string_buffer_realloc(param_1,*(int *)(param_1 + 0x10) + 1,param_2), iVar1 != 0)) {
return 0xffffffff;
}
iVar1 = *(int *)(param_1 + 0x10);
*(int *)(param_1 + 0x10) = iVar1 + 1;
if (*(int *)(param_1 + 0x18) == 0) {
*(char *)(*(long *)(param_1 + 8) + 0x18 + (long)iVar1) = (char)param_2;
}
else {
*(short *)(*(long *)(param_1 + 8) + 0x18 + (long)iVar1 * 2) = (short)param_2;
}
return 0;
}
| |
32,162 | LefDefParser::defiVia::layer(int, char**, int*, int*, int*, int*) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiVia.cpp | void defiVia::layer(int index, char** layer, int* xl, int* yl,
int* xh, int* yh) const {
if (index >= 0 && index < numLayers_) {
if (layer) *layer = layers_[index];
if (xl) *xl = xl_[index];
if (yl) *yl = yl_[index];
if (xh) *xh = xh_[index];
if (yh) *yh = yh_[index];
}
} | O0 | cpp | LefDefParser::defiVia::layer(int, char**, int*, int*, int*, int*) const:
movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x38(%rsp)
cmpl $0x0, -0xc(%rsp)
jl 0x4147d
movq -0x38(%rsp), %rcx
movl -0xc(%rsp), %eax
cmpl 0x54(%rcx), %eax
jge 0x4147d
cmpq $0x0, -0x18(%rsp)
je 0x413fb
movq -0x38(%rsp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rsp)
je 0x4141b
movq -0x38(%rsp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rsp)
je 0x4143b
movq -0x38(%rsp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x28(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x30(%rsp)
je 0x4145b
movq -0x38(%rsp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x30(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x8(%rsp)
je 0x4147b
movq -0x38(%rsp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
jmp 0x4147d
retq
nop
| _ZNK12LefDefParser7defiVia5layerEiPPcPiS3_S3_S3_:
mov rax, [rsp+arg_0]
mov [rsp+var_8], rdi
mov [rsp+var_C], esi
mov [rsp+var_18], rdx
mov [rsp+var_20], rcx
mov [rsp+var_28], r8
mov [rsp+var_30], r9
mov rax, [rsp+var_8]
mov [rsp+var_38], rax
cmp [rsp+var_C], 0
jl locret_4147D
mov rcx, [rsp+var_38]
mov eax, [rsp+var_C]
cmp eax, [rcx+54h]
jge locret_4147D
cmp [rsp+var_18], 0
jz short loc_413FB
mov rax, [rsp+var_38]
mov rax, [rax+20h]
movsxd rcx, [rsp+var_C]
mov rcx, [rax+rcx*8]
mov rax, [rsp+var_18]
mov [rax], rcx
loc_413FB:
cmp [rsp+var_20], 0
jz short loc_4141B
mov rax, [rsp+var_38]
mov rax, [rax+30h]
movsxd rcx, [rsp+var_C]
mov ecx, [rax+rcx*4]
mov rax, [rsp+var_20]
mov [rax], ecx
loc_4141B:
cmp [rsp+var_28], 0
jz short loc_4143B
mov rax, [rsp+var_38]
mov rax, [rax+38h]
movsxd rcx, [rsp+var_C]
mov ecx, [rax+rcx*4]
mov rax, [rsp+var_28]
mov [rax], ecx
loc_4143B:
cmp [rsp+var_30], 0
jz short loc_4145B
mov rax, [rsp+var_38]
mov rax, [rax+40h]
movsxd rcx, [rsp+var_C]
mov ecx, [rax+rcx*4]
mov rax, [rsp+var_30]
mov [rax], ecx
loc_4145B:
cmp [rsp+arg_0], 0
jz short loc_4147B
mov rax, [rsp+var_38]
mov rax, [rax+48h]
movsxd rcx, [rsp+var_C]
mov ecx, [rax+rcx*4]
mov rax, [rsp+arg_0]
mov [rax], ecx
loc_4147B:
jmp short $+2
locret_4147D:
retn
| unsigned long long LefDefParser::defiVia::layer(
LefDefParser::defiVia *this,
int a2,
char **a3,
int *a4,
int *a5,
int *a6,
int *a7)
{
unsigned long long result; // rax
result = (unsigned long long)this;
if ( a2 >= 0 )
{
result = (unsigned int)a2;
if ( a2 < *((_DWORD *)this + 21) )
{
if ( a3 )
{
result = (unsigned long long)a3;
*a3 = *(char **)(*((_QWORD *)this + 4) + 8LL * a2);
}
if ( a4 )
{
result = (unsigned long long)a4;
*a4 = *(_DWORD *)(*((_QWORD *)this + 6) + 4LL * a2);
}
if ( a5 )
{
result = (unsigned long long)a5;
*a5 = *(_DWORD *)(*((_QWORD *)this + 7) + 4LL * a2);
}
if ( a6 )
{
result = (unsigned long long)a6;
*a6 = *(_DWORD *)(*((_QWORD *)this + 8) + 4LL * a2);
}
if ( a7 )
{
result = (unsigned long long)a7;
*a7 = *(_DWORD *)(*((_QWORD *)this + 9) + 4LL * a2);
}
}
}
return result;
}
| layer:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + -0x8],RDI
MOV dword ptr [RSP + -0xc],ESI
MOV qword ptr [RSP + -0x18],RDX
MOV qword ptr [RSP + -0x20],RCX
MOV qword ptr [RSP + -0x28],R8
MOV qword ptr [RSP + -0x30],R9
MOV RAX,qword ptr [RSP + -0x8]
MOV qword ptr [RSP + -0x38],RAX
CMP dword ptr [RSP + -0xc],0x0
JL 0x0014147d
MOV RCX,qword ptr [RSP + -0x38]
MOV EAX,dword ptr [RSP + -0xc]
CMP EAX,dword ptr [RCX + 0x54]
JGE 0x0014147d
CMP qword ptr [RSP + -0x18],0x0
JZ 0x001413fb
MOV RAX,qword ptr [RSP + -0x38]
MOV RAX,qword ptr [RAX + 0x20]
MOVSXD RCX,dword ptr [RSP + -0xc]
MOV RCX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RSP + -0x18]
MOV qword ptr [RAX],RCX
LAB_001413fb:
CMP qword ptr [RSP + -0x20],0x0
JZ 0x0014141b
MOV RAX,qword ptr [RSP + -0x38]
MOV RAX,qword ptr [RAX + 0x30]
MOVSXD RCX,dword ptr [RSP + -0xc]
MOV ECX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + -0x20]
MOV dword ptr [RAX],ECX
LAB_0014141b:
CMP qword ptr [RSP + -0x28],0x0
JZ 0x0014143b
MOV RAX,qword ptr [RSP + -0x38]
MOV RAX,qword ptr [RAX + 0x38]
MOVSXD RCX,dword ptr [RSP + -0xc]
MOV ECX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + -0x28]
MOV dword ptr [RAX],ECX
LAB_0014143b:
CMP qword ptr [RSP + -0x30],0x0
JZ 0x0014145b
MOV RAX,qword ptr [RSP + -0x38]
MOV RAX,qword ptr [RAX + 0x40]
MOVSXD RCX,dword ptr [RSP + -0xc]
MOV ECX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + -0x30]
MOV dword ptr [RAX],ECX
LAB_0014145b:
CMP qword ptr [RSP + 0x8],0x0
JZ 0x0014147b
MOV RAX,qword ptr [RSP + -0x38]
MOV RAX,qword ptr [RAX + 0x48]
MOVSXD RCX,dword ptr [RSP + -0xc]
MOV ECX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],ECX
LAB_0014147b:
JMP 0x0014147d
LAB_0014147d:
RET
|
/* LefDefParser::defiVia::layer(int, char**, int*, int*, int*, int*) const */
void __thiscall
LefDefParser::defiVia::layer
(defiVia *this,int param_1,char **param_2,int *param_3,int *param_4,int *param_5,
int *param_6)
{
if ((-1 < param_1) && (param_1 < *(int *)(this + 0x54))) {
if (param_2 != (char **)0x0) {
*param_2 = *(char **)(*(long *)(this + 0x20) + (long)param_1 * 8);
}
if (param_3 != (int *)0x0) {
*param_3 = *(int *)(*(long *)(this + 0x30) + (long)param_1 * 4);
}
if (param_4 != (int *)0x0) {
*param_4 = *(int *)(*(long *)(this + 0x38) + (long)param_1 * 4);
}
if (param_5 != (int *)0x0) {
*param_5 = *(int *)(*(long *)(this + 0x40) + (long)param_1 * 4);
}
if (param_6 != (int *)0x0) {
*param_6 = *(int *)(*(long *)(this + 0x48) + (long)param_1 * 4);
}
}
return;
}
| |
32,163 | js_iterator_proto_set_toStringTag | bluesky950520[P]quickjs/quickjs.c | static JSValue js_iterator_proto_set_toStringTag(JSContext *ctx, JSValue this_val, JSValue val)
{
int res;
if (check_iterator(ctx, this_val) < 0)
return JS_EXCEPTION;
if (js_same_value(ctx, this_val, ctx->class_proto[JS_CLASS_ITERATOR]))
return JS_ThrowTypeError(ctx, "Cannot assign to read only property");
res = JS_GetOwnProperty(ctx, NULL, this_val, JS_ATOM_Symbol_toStringTag);
if (res < 0)
return JS_EXCEPTION;
if (res) {
if (JS_SetProperty(ctx, this_val, JS_ATOM_Symbol_toStringTag, js_dup(val)) < 0)
return JS_EXCEPTION;
} else {
if (JS_DefinePropertyValue(ctx, this_val, JS_ATOM_Symbol_toStringTag, js_dup(val), JS_PROP_C_W_E) < 0)
return JS_EXCEPTION;
}
return JS_UNDEFINED;
} | O0 | c | js_iterator_proto_set_toStringTag:
subq $0x78, %rsp
movq %rsi, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0xc41f0
cmpl $0x0, %eax
jge 0xc406c
movl $0x0, 0x68(%rsp)
movq $0x6, 0x70(%rsp)
jmp 0xc41dc
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x270(%rax), %rcx
movq 0x278(%rax), %r8
callq 0x34850
cmpl $0x0, %eax
je 0xc40be
movq 0x40(%rsp), %rdi
leaq 0x4b47f(%rip), %rsi # 0x10f527
movb $0x0, %al
callq 0x2c040
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
jmp 0xc41dc
movq 0x40(%rsp), %rdi
movq 0x58(%rsp), %rdx
movq 0x60(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
movl $0xda, %r8d
callq 0x2ee90
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
jge 0xc40fd
movl $0x0, 0x68(%rsp)
movq $0x6, 0x70(%rsp)
jmp 0xc41dc
cmpl $0x0, 0x3c(%rsp)
je 0xc4164
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x20410
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x28(%rsp), %r8
movq 0x30(%rsp), %r9
movl $0xda, %ecx
callq 0x30c40
cmpl $0x0, %eax
jge 0xc4162
movl $0x0, 0x68(%rsp)
movq $0x6, 0x70(%rsp)
jmp 0xc41dc
jmp 0xc41cb
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x20410
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
movl $0xda, %ecx
movl $0x7, (%rsp)
callq 0x35ef0
cmpl $0x0, %eax
jge 0xc41c9
movl $0x0, 0x68(%rsp)
movq $0x6, 0x70(%rsp)
jmp 0xc41dc
jmp 0xc41cb
movl $0x0, 0x68(%rsp)
movq $0x3, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rdx
addq $0x78, %rsp
retq
nopl (%rax,%rax)
| js_iterator_proto_set_toStringTag:
sub rsp, 78h
mov [rsp+78h+var_20], rsi
mov [rsp+78h+var_18], rdx
mov [rsp+78h+var_30], rcx
mov [rsp+78h+var_28], r8
mov [rsp+78h+var_38], rdi
mov rdi, [rsp+78h+var_38]
mov rsi, [rsp+78h+var_20]
mov rdx, [rsp+78h+var_18]
call check_iterator
cmp eax, 0
jge short loc_C406C
mov dword ptr [rsp+78h+var_10], 0
mov [rsp+78h+var_8], 6
jmp loc_C41DC
loc_C406C:
mov rdi, [rsp+78h+var_38]
mov rax, [rsp+78h+var_38]
mov rax, [rax+40h]
mov rsi, [rsp+78h+var_20]
mov rdx, [rsp+78h+var_18]
mov rcx, [rax+270h]
mov r8, [rax+278h]
call js_same_value
cmp eax, 0
jz short loc_C40BE
mov rdi, [rsp+78h+var_38]
lea rsi, aCannotAssignTo; "Cannot assign to read only property"
mov al, 0
call JS_ThrowTypeError
mov [rsp+78h+var_10], rax
mov [rsp+78h+var_8], rdx
jmp loc_C41DC
loc_C40BE:
mov rdi, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_20]
mov rcx, [rsp+78h+var_18]
xor eax, eax
mov esi, eax
mov r8d, 0DAh
call JS_GetOwnProperty
mov [rsp+78h+var_3C], eax
cmp [rsp+78h+var_3C], 0
jge short loc_C40FD
mov dword ptr [rsp+78h+var_10], 0
mov [rsp+78h+var_8], 6
jmp loc_C41DC
loc_C40FD:
cmp [rsp+78h+var_3C], 0
jz short loc_C4164
mov rax, [rsp+78h+var_38]
mov [rsp+78h+var_68], rax
mov rdi, [rsp+78h+var_30]
mov rsi, [rsp+78h+var_28]
call js_dup
mov rdi, [rsp+78h+var_68]
mov [rsp+78h+var_50], rax
mov [rsp+78h+var_48], rdx
mov rsi, [rsp+78h+var_20]
mov rdx, [rsp+78h+var_18]
mov r8, [rsp+78h+var_50]
mov r9, [rsp+78h+var_48]
mov ecx, 0DAh
call JS_SetProperty
cmp eax, 0
jge short loc_C4162
mov dword ptr [rsp+78h+var_10], 0
mov [rsp+78h+var_8], 6
jmp short loc_C41DC
loc_C4162:
jmp short loc_C41CB
loc_C4164:
mov rax, [rsp+78h+var_38]
mov [rsp+78h+var_70], rax
mov rdi, [rsp+78h+var_30]
mov rsi, [rsp+78h+var_28]
call js_dup
mov rdi, [rsp+78h+var_70]
mov [rsp+78h+var_60], rax
mov [rsp+78h+var_58], rdx
mov rsi, [rsp+78h+var_20]
mov rdx, [rsp+78h+var_18]
mov r8, [rsp+78h+var_60]
mov r9, [rsp+78h+var_58]
mov ecx, 0DAh
mov [rsp+78h+var_78], 7
call JS_DefinePropertyValue
cmp eax, 0
jge short loc_C41C9
mov dword ptr [rsp+78h+var_10], 0
mov [rsp+78h+var_8], 6
jmp short loc_C41DC
loc_C41C9:
jmp short $+2
loc_C41CB:
mov dword ptr [rsp+78h+var_10], 0
mov [rsp+78h+var_8], 3
loc_C41DC:
mov rax, [rsp+78h+var_10]
mov rdx, [rsp+78h+var_8]
add rsp, 78h
retn
| long long js_iterator_proto_set_toStringTag(
long long a1,
_DWORD *a2,
long long a3,
_DWORD *a4,
unsigned int a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rdx
long long v14; // rcx
long long v15; // r8
long long v16; // r9
__m128 v17; // xmm4
__m128 v18; // xmm5
int v19; // edx
long long v20; // rdx
__m128 v21; // xmm4
__m128 v22; // xmm5
char v24; // [rsp+0h] [rbp-78h]
_DWORD *v25; // [rsp+18h] [rbp-60h]
int v26; // [rsp+28h] [rbp-50h]
int OwnProperty; // [rsp+3Ch] [rbp-3Ch]
long long v31; // [rsp+68h] [rbp-10h]
if ( (int)check_iterator(a1, a2, a3) >= 0 )
{
if ( (unsigned int)js_same_value(
a1,
a2,
a3,
*(_DWORD **)(*(_QWORD *)(a1 + 64) + 624LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 632LL)) )
{
return JS_ThrowTypeError(
a1,
(long long)"Cannot assign to read only property",
v13,
v14,
v15,
v16,
a6,
a7,
a8,
a9,
v17,
v18,
a12,
a13,
v24);
}
else
{
OwnProperty = JS_GetOwnProperty(a1, 0LL, (long long)a2, a3, 218LL, v16, a6, a7, a8, a9, v17, v18, a12, a13);
if ( OwnProperty >= 0 )
{
if ( OwnProperty )
{
v26 = (unsigned int)js_dup(a4, a5);
if ( (int)JS_SetProperty(a1, (int)a2, a3, 218, v26, v19) < 0 )
{
LODWORD(v31) = 0;
return v31;
}
}
else
{
v25 = js_dup(a4, a5);
if ( (int)JS_DefinePropertyValue(a1, (long long)a2, a3, 0xDAu, v25, v20, a6, a7, a8, a9, v21, v22, a12, a13, 7) < 0 )
{
LODWORD(v31) = 0;
return v31;
}
}
LODWORD(v31) = 0;
return v31;
}
LODWORD(v31) = 0;
}
}
else
{
LODWORD(v31) = 0;
}
return v31;
}
| js_iterator_proto_set_toStringTag:
SUB RSP,0x78
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x60],RDX
MOV qword ptr [RSP + 0x48],RCX
MOV qword ptr [RSP + 0x50],R8
MOV qword ptr [RSP + 0x40],RDI
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
CALL 0x001c41f0
CMP EAX,0x0
JGE 0x001c406c
MOV dword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x6
JMP 0x001c41dc
LAB_001c406c:
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RAX + 0x270]
MOV R8,qword ptr [RAX + 0x278]
CALL 0x00134850
CMP EAX,0x0
JZ 0x001c40be
MOV RDI,qword ptr [RSP + 0x40]
LEA RSI,[0x20f527]
MOV AL,0x0
CALL 0x0012c040
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
JMP 0x001c41dc
LAB_001c40be:
MOV RDI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x58]
MOV RCX,qword ptr [RSP + 0x60]
XOR EAX,EAX
MOV ESI,EAX
MOV R8D,0xda
CALL 0x0012ee90
MOV dword ptr [RSP + 0x3c],EAX
CMP dword ptr [RSP + 0x3c],0x0
JGE 0x001c40fd
MOV dword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x6
JMP 0x001c41dc
LAB_001c40fd:
CMP dword ptr [RSP + 0x3c],0x0
JZ 0x001c4164
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x50]
CALL 0x00120410
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
MOV R8,qword ptr [RSP + 0x28]
MOV R9,qword ptr [RSP + 0x30]
MOV ECX,0xda
CALL 0x00130c40
CMP EAX,0x0
JGE 0x001c4162
MOV dword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x6
JMP 0x001c41dc
LAB_001c4162:
JMP 0x001c41cb
LAB_001c4164:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x50]
CALL 0x00120410
MOV RDI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
MOV R8,qword ptr [RSP + 0x18]
MOV R9,qword ptr [RSP + 0x20]
MOV ECX,0xda
MOV dword ptr [RSP],0x7
CALL 0x00135ef0
CMP EAX,0x0
JGE 0x001c41c9
MOV dword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x6
JMP 0x001c41dc
LAB_001c41c9:
JMP 0x001c41cb
LAB_001c41cb:
MOV dword ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x70],0x3
LAB_001c41dc:
MOV RAX,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
ADD RSP,0x78
RET
|
int1 [16]
js_iterator_proto_set_toStringTag
(long param_1,int8 param_2,int8 param_3,int8 param_4,int8 param_5)
{
int iVar1;
int1 auVar2 [16];
int4 local_10;
int4 uStack_c;
int8 local_8;
iVar1 = check_iterator(param_1,param_2,param_3);
if (iVar1 < 0) {
local_10 = 0;
local_8 = 6;
}
else {
iVar1 = js_same_value(param_1,param_2,param_3,*(int8 *)(*(long *)(param_1 + 0x40) + 0x270)
,*(int8 *)(*(long *)(param_1 + 0x40) + 0x278));
if (iVar1 == 0) {
iVar1 = JS_GetOwnProperty(param_1,0,param_2,param_3,0xda);
if (iVar1 < 0) {
local_10 = 0;
local_8 = 6;
}
else {
if (iVar1 == 0) {
auVar2 = js_dup(param_4,param_5);
iVar1 = JS_DefinePropertyValue(param_1,param_2,param_3,0xda,auVar2._0_8_,auVar2._8_8_,7);
if (iVar1 < 0) {
local_10 = 0;
local_8 = 6;
goto LAB_001c41dc;
}
}
else {
auVar2 = js_dup(param_4,param_5);
iVar1 = JS_SetProperty(param_1,param_2,param_3,0xda,auVar2._0_8_,auVar2._8_8_);
if (iVar1 < 0) {
local_10 = 0;
local_8 = 6;
goto LAB_001c41dc;
}
}
local_10 = 0;
local_8 = 3;
}
}
else {
auVar2 = JS_ThrowTypeError(param_1,"Cannot assign to read only property");
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
}
LAB_001c41dc:
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
| |
32,164 | js_iterator_proto_set_toStringTag | bluesky950520[P]quickjs/quickjs.c | static JSValue js_iterator_proto_set_toStringTag(JSContext *ctx, JSValue this_val, JSValue val)
{
int res;
if (check_iterator(ctx, this_val) < 0)
return JS_EXCEPTION;
if (js_same_value(ctx, this_val, ctx->class_proto[JS_CLASS_ITERATOR]))
return JS_ThrowTypeError(ctx, "Cannot assign to read only property");
res = JS_GetOwnProperty(ctx, NULL, this_val, JS_ATOM_Symbol_toStringTag);
if (res < 0)
return JS_EXCEPTION;
if (res) {
if (JS_SetProperty(ctx, this_val, JS_ATOM_Symbol_toStringTag, js_dup(val)) < 0)
return JS_EXCEPTION;
} else {
if (JS_DefinePropertyValue(ctx, this_val, JS_ATOM_Symbol_toStringTag, js_dup(val), JS_PROP_C_W_E) < 0)
return JS_EXCEPTION;
}
return JS_UNDEFINED;
} | O1 | c | js_iterator_proto_set_toStringTag:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r13
movq %rdi, %r15
cmpl $-0x1, %r13d
jne 0x724e9
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %rbp
movq 0x40(%r15), %rax
movq 0x270(%rax), %rcx
movq 0x278(%rax), %r8
movq %r15, %rdi
movq %r13, %rdx
callq 0x2584d
testl %eax, %eax
je 0x72514
leaq 0x2e02d(%rip), %rsi # 0xa0514
jmp 0x724f0
leaq 0x2b42d(%rip), %rsi # 0x9d91d
movq %r15, %rdi
xorl %eax, %eax
callq 0x21953
movl $0x6, %r12d
xorl %eax, %eax
movq %r12, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
xorl %esi, %esi
movq %rbp, %rdx
movq %r13, %rcx
movl $0xda, %r8d
callq 0x22f9c
movl $0x6, %r12d
testl %eax, %eax
js 0x72500
je 0x72586
movq %r14, 0x28(%rsp)
cmpl $-0x9, %ebx
jb 0x72547
movq 0x28(%rsp), %rax
incl (%rax)
movq %rbp, 0x28(%rsp)
movq %r13, 0x30(%rsp)
movups 0x28(%rsp), %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x18(%rsp)
movl $0x4000, 0x10(%rsp) # imm = 0x4000
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movl $0xda, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x23774
jmp 0x725b7
movq %r14, 0x28(%rsp)
cmpl $-0x9, %ebx
jb 0x72597
movq 0x28(%rsp), %rax
incl (%rax)
movl $0x7, (%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movl $0xda, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x25ea7
testl %eax, %eax
js 0x72500
movl $0x3, %r12d
jmp 0x72500
| js_iterator_proto_set_toStringTag:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r13, rdx
mov r15, rdi
cmp r13d, 0FFFFFFFFh
jnz short loc_724E9
mov rbx, r8
mov r14, rcx
mov rbp, rsi
mov rax, [r15+40h]
mov rcx, [rax+270h]
mov r8, [rax+278h]
mov rdi, r15
mov rdx, r13
call js_same_value
test eax, eax
jz short loc_72514
lea rsi, aCannotAssignTo; "Cannot assign to read only property"
jmp short loc_724F0
loc_724E9:
lea rsi, aOperandPrototy+20h; "not an object"
loc_724F0:
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
mov r12d, 6
loc_72500:
xor eax, eax
mov rdx, r12
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_72514:
mov rdi, r15
xor esi, esi
mov rdx, rbp
mov rcx, r13
mov r8d, 0DAh
call JS_GetOwnProperty
mov r12d, 6
test eax, eax
js short loc_72500
jz short loc_72586
mov qword ptr [rsp+68h+var_40], r14
cmp ebx, 0FFFFFFF7h
jb short loc_72547
mov rax, qword ptr [rsp+68h+var_40]
inc dword ptr [rax]
loc_72547:
mov qword ptr [rsp+68h+var_40], rbp
mov qword ptr [rsp+68h+var_40+8], r13
movups xmm0, [rsp+68h+var_40]
movups [rsp+68h+var_68], xmm0
mov [rsp+68h+var_50], 0
mov [rsp+68h+var_58], 4000h
mov rdi, r15
mov rsi, rbp
mov rdx, r13
mov ecx, 0DAh
mov r8, r14
mov r9, rbx
call JS_SetPropertyInternal2
jmp short loc_725B7
loc_72586:
mov qword ptr [rsp+68h+var_40], r14
cmp ebx, 0FFFFFFF7h
jb short loc_72597
mov rax, qword ptr [rsp+68h+var_40]
inc dword ptr [rax]
loc_72597:
mov dword ptr [rsp+68h+var_68], 7
mov rdi, r15
mov rsi, rbp
mov rdx, r13
mov ecx, 0DAh
mov r8, r14
mov r9, rbx
call JS_DefinePropertyValue
loc_725B7:
test eax, eax
js loc_72500
mov r12d, 3
jmp loc_72500
| long long js_iterator_proto_set_toStringTag(
long long a1,
_DWORD *a2,
unsigned long long a3,
_DWORD *a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char *v17; // rsi
int OwnProperty; // eax
__m128 v20; // xmm4
__m128 v21; // xmm5
char v22; // [rsp+0h] [rbp-68h]
__m128 v23; // [rsp+28h] [rbp-40h]
if ( (_DWORD)a3 != -1 )
{
v17 = "not an object";
goto LABEL_5;
}
if ( (unsigned int)js_same_value(
a1,
a2,
a3,
*(_DWORD **)(*(_QWORD *)(a1 + 64) + 624LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 632LL)) )
{
v17 = "Cannot assign to read only property";
LABEL_5:
JS_ThrowTypeError(a1, (long long)v17, a3, (long long)a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v22);
return 0LL;
}
OwnProperty = JS_GetOwnProperty(a1, 0LL, (long long)a2, a3, 218LL, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( OwnProperty >= 0 )
{
if ( OwnProperty )
{
if ( (unsigned int)a5 >= 0xFFFFFFF7 )
++*a4;
v23.m128_u64[0] = (unsigned long long)a2;
v23.m128_u64[1] = a3;
JS_SetPropertyInternal2(
a1,
(long long)a2,
a3,
0xDAu,
a4,
a5,
v23,
a8,
a9,
a10,
*(double *)v20.m128_u64,
*(double *)v21.m128_u64,
a13,
a14,
(long long)a2,
a3,
0x4000u,
0LL);
}
else
{
if ( (unsigned int)a5 >= 0xFFFFFFF7 )
++*a4;
JS_DefinePropertyValue(
a1,
(unsigned long long)a2,
a3,
218LL,
a4,
a5,
*(double *)a7.m128_u64,
a8,
a9,
a10,
v20,
v21,
a13,
a14,
7);
}
}
return 0LL;
}
| js_iterator_proto_set_toStringTag:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R13,RDX
MOV R15,RDI
CMP R13D,-0x1
JNZ 0x001724e9
MOV RBX,R8
MOV R14,RCX
MOV RBP,RSI
MOV RAX,qword ptr [R15 + 0x40]
MOV RCX,qword ptr [RAX + 0x270]
MOV R8,qword ptr [RAX + 0x278]
MOV RDI,R15
MOV RDX,R13
CALL 0x0012584d
TEST EAX,EAX
JZ 0x00172514
LEA RSI,[0x1a0514]
JMP 0x001724f0
LAB_001724e9:
LEA RSI,[0x19d91d]
LAB_001724f0:
MOV RDI,R15
XOR EAX,EAX
CALL 0x00121953
MOV R12D,0x6
LAB_00172500:
XOR EAX,EAX
MOV RDX,R12
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00172514:
MOV RDI,R15
XOR ESI,ESI
MOV RDX,RBP
MOV RCX,R13
MOV R8D,0xda
CALL 0x00122f9c
MOV R12D,0x6
TEST EAX,EAX
JS 0x00172500
JZ 0x00172586
MOV qword ptr [RSP + 0x28],R14
CMP EBX,-0x9
JC 0x00172547
MOV RAX,qword ptr [RSP + 0x28]
INC dword ptr [RAX]
LAB_00172547:
MOV qword ptr [RSP + 0x28],RBP
MOV qword ptr [RSP + 0x30],R13
MOVUPS XMM0,xmmword ptr [RSP + 0x28]
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x10],0x4000
MOV RDI,R15
MOV RSI,RBP
MOV RDX,R13
MOV ECX,0xda
MOV R8,R14
MOV R9,RBX
CALL 0x00123774
JMP 0x001725b7
LAB_00172586:
MOV qword ptr [RSP + 0x28],R14
CMP EBX,-0x9
JC 0x00172597
MOV RAX,qword ptr [RSP + 0x28]
INC dword ptr [RAX]
LAB_00172597:
MOV dword ptr [RSP],0x7
MOV RDI,R15
MOV RSI,RBP
MOV RDX,R13
MOV ECX,0xda
MOV R8,R14
MOV R9,RBX
CALL 0x00125ea7
LAB_001725b7:
TEST EAX,EAX
JS 0x00172500
MOV R12D,0x3
JMP 0x00172500
|
int1 [16]
js_iterator_proto_set_toStringTag
(long param_1,int8 param_2,int8 param_3,int *param_4,int8 param_5)
{
int1 auVar1 [16];
int iVar2;
char *pcVar3;
ulong uVar4;
int4 local_40;
if ((int)param_3 == -1) {
iVar2 = js_same_value(param_1,param_2,param_3,*(int8 *)(*(long *)(param_1 + 0x40) + 0x270)
,*(int8 *)(*(long *)(param_1 + 0x40) + 0x278));
if (iVar2 == 0) {
iVar2 = JS_GetOwnProperty(param_1,0,param_2,param_3,0xda);
uVar4 = 6;
if (-1 < iVar2) {
if (iVar2 == 0) {
if (0xfffffff6 < (uint)param_5) {
*param_4 = *param_4 + 1;
}
iVar2 = JS_DefinePropertyValue(param_1,param_2,param_3,0xda,param_4,param_5,7);
}
else {
if (0xfffffff6 < (uint)param_5) {
*param_4 = *param_4 + 1;
}
local_40 = (int4)param_2;
iVar2 = JS_SetPropertyInternal2
(param_1,param_2,param_3,0xda,param_4,param_5,local_40,0xffffffff,0x4000
,0);
}
if (-1 < iVar2) {
uVar4 = 3;
}
}
goto LAB_00172500;
}
pcVar3 = "Cannot assign to read only property";
}
else {
pcVar3 = "not an object";
}
JS_ThrowTypeError(param_1,pcVar3);
uVar4 = 6;
LAB_00172500:
auVar1._8_8_ = 0;
auVar1._0_8_ = uVar4;
return auVar1 << 0x40;
}
| |
32,165 | js_iterator_proto_set_toStringTag | bluesky950520[P]quickjs/quickjs.c | static JSValue js_iterator_proto_set_toStringTag(JSContext *ctx, JSValue this_val, JSValue val)
{
int res;
if (check_iterator(ctx, this_val) < 0)
return JS_EXCEPTION;
if (js_same_value(ctx, this_val, ctx->class_proto[JS_CLASS_ITERATOR]))
return JS_ThrowTypeError(ctx, "Cannot assign to read only property");
res = JS_GetOwnProperty(ctx, NULL, this_val, JS_ATOM_Symbol_toStringTag);
if (res < 0)
return JS_EXCEPTION;
if (res) {
if (JS_SetProperty(ctx, this_val, JS_ATOM_Symbol_toStringTag, js_dup(val)) < 0)
return JS_EXCEPTION;
} else {
if (JS_DefinePropertyValue(ctx, this_val, JS_ATOM_Symbol_toStringTag, js_dup(val), JS_PROP_C_W_E) < 0)
return JS_EXCEPTION;
}
return JS_UNDEFINED;
} | O3 | c | js_iterator_proto_set_toStringTag:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r13
movq %rdi, %r15
cmpl $-0x1, %r13d
jne 0x74d0b
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %rbp
movq 0x40(%r15), %rax
movq 0x270(%rax), %rcx
movq 0x278(%rax), %r8
movq %r15, %rdi
movq %r13, %rdx
callq 0x25ea9
testl %eax, %eax
je 0x74d36
leaq 0x2e7c5(%rip), %rsi # 0xa34ce
jmp 0x74d12
leaq 0x2bbdb(%rip), %rsi # 0xa08ed
movq %r15, %rdi
xorl %eax, %eax
callq 0x2214f
movl $0x6, %r12d
xorl %eax, %eax
movq %r12, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
xorl %esi, %esi
movq %rbp, %rdx
movq %r13, %rcx
movl $0xda, %r8d
callq 0x2379d
movl $0x6, %r12d
testl %eax, %eax
js 0x74d22
je 0x74d9f
cmpl $-0x9, %ebx
jb 0x74d60
incl (%r14)
movq %rbp, 0x28(%rsp)
movq %r13, 0x30(%rsp)
movups 0x28(%rsp), %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x18(%rsp)
movl $0x4000, 0x10(%rsp) # imm = 0x4000
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movl $0xda, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x23d7f
jmp 0x74dc7
cmpl $-0x9, %ebx
jb 0x74da7
incl (%r14)
movl $0x7, (%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movl $0xda, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x26541
testl %eax, %eax
js 0x74d22
movl $0x3, %r12d
jmp 0x74d22
| js_iterator_proto_set_toStringTag:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r13, rdx
mov r15, rdi
cmp r13d, 0FFFFFFFFh
jnz short loc_74D0B
mov rbx, r8
mov r14, rcx
mov rbp, rsi
mov rax, [r15+40h]
mov rcx, [rax+270h]
mov r8, [rax+278h]
mov rdi, r15
mov rdx, r13
call js_same_value
test eax, eax
jz short loc_74D36
lea rsi, aCannotAssignTo; "Cannot assign to read only property"
jmp short loc_74D12
loc_74D0B:
lea rsi, aOperandPrototy+20h; "not an object"
loc_74D12:
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
mov r12d, 6
loc_74D22:
xor eax, eax
mov rdx, r12
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_74D36:
mov rdi, r15
xor esi, esi
mov rdx, rbp
mov rcx, r13
mov r8d, 0DAh
call JS_GetOwnProperty
mov r12d, 6
test eax, eax
js short loc_74D22
jz short loc_74D9F
cmp ebx, 0FFFFFFF7h
jb short loc_74D60
inc dword ptr [r14]
loc_74D60:
mov qword ptr [rsp+68h+var_40], rbp
mov qword ptr [rsp+68h+var_40+8], r13
movups xmm0, [rsp+68h+var_40]
movups [rsp+68h+var_68], xmm0
mov [rsp+68h+var_50], 0
mov [rsp+68h+var_58], 4000h
mov rdi, r15
mov rsi, rbp
mov rdx, r13
mov ecx, 0DAh
mov r8, r14
mov r9, rbx
call JS_SetPropertyInternal2
jmp short loc_74DC7
loc_74D9F:
cmp ebx, 0FFFFFFF7h
jb short loc_74DA7
inc dword ptr [r14]
loc_74DA7:
mov dword ptr [rsp+68h+var_68], 7
mov rdi, r15
mov rsi, rbp
mov rdx, r13
mov ecx, 0DAh
mov r8, r14
mov r9, rbx
call JS_DefinePropertyValue
loc_74DC7:
test eax, eax
js loc_74D22
mov r12d, 3
jmp loc_74D22
| long long js_iterator_proto_set_toStringTag(
long long a1,
_DWORD *a2,
long long a3,
int *a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char *v17; // rsi
int OwnProperty; // eax
__m128 v20; // xmm4
__m128 v21; // xmm5
char v22; // [rsp+0h] [rbp-68h]
__m128 v23; // [rsp+28h] [rbp-40h]
if ( (_DWORD)a3 != -1 )
{
v17 = "not an object";
goto LABEL_5;
}
if ( (unsigned int)js_same_value(
a1,
a2,
a3,
*(_DWORD **)(*(_QWORD *)(a1 + 64) + 624LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 632LL)) )
{
v17 = "Cannot assign to read only property";
LABEL_5:
JS_ThrowTypeError(a1, (long long)v17, a3, (long long)a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v22);
return 0LL;
}
OwnProperty = JS_GetOwnProperty(a1, 0LL, (long long)a2, a3, 218LL, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( OwnProperty >= 0 )
{
if ( OwnProperty )
{
if ( (unsigned int)a5 >= 0xFFFFFFF7 )
++*a4;
v23.m128_u64[0] = (unsigned long long)a2;
v23.m128_u64[1] = a3;
JS_SetPropertyInternal2(
a1,
(long long)a2,
a3,
0xDAu,
(long long)a4,
a5,
v23,
a8,
a9,
a10,
*(double *)v20.m128_u64,
*(double *)v21.m128_u64,
a13,
a14,
(long long)a2,
a3,
0x4000u,
0LL);
}
else
{
if ( (unsigned int)a5 >= 0xFFFFFFF7 )
++*a4;
JS_DefinePropertyValue(
a1,
(long long)a2,
a3,
218LL,
a4,
a5,
*(double *)a7.m128_u64,
a8,
a9,
a10,
v20,
v21,
a13,
a14,
7);
}
}
return 0LL;
}
| js_iterator_proto_set_toStringTag:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R13,RDX
MOV R15,RDI
CMP R13D,-0x1
JNZ 0x00174d0b
MOV RBX,R8
MOV R14,RCX
MOV RBP,RSI
MOV RAX,qword ptr [R15 + 0x40]
MOV RCX,qword ptr [RAX + 0x270]
MOV R8,qword ptr [RAX + 0x278]
MOV RDI,R15
MOV RDX,R13
CALL 0x00125ea9
TEST EAX,EAX
JZ 0x00174d36
LEA RSI,[0x1a34ce]
JMP 0x00174d12
LAB_00174d0b:
LEA RSI,[0x1a08ed]
LAB_00174d12:
MOV RDI,R15
XOR EAX,EAX
CALL 0x0012214f
MOV R12D,0x6
LAB_00174d22:
XOR EAX,EAX
MOV RDX,R12
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00174d36:
MOV RDI,R15
XOR ESI,ESI
MOV RDX,RBP
MOV RCX,R13
MOV R8D,0xda
CALL 0x0012379d
MOV R12D,0x6
TEST EAX,EAX
JS 0x00174d22
JZ 0x00174d9f
CMP EBX,-0x9
JC 0x00174d60
INC dword ptr [R14]
LAB_00174d60:
MOV qword ptr [RSP + 0x28],RBP
MOV qword ptr [RSP + 0x30],R13
MOVUPS XMM0,xmmword ptr [RSP + 0x28]
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x10],0x4000
MOV RDI,R15
MOV RSI,RBP
MOV RDX,R13
MOV ECX,0xda
MOV R8,R14
MOV R9,RBX
CALL 0x00123d7f
JMP 0x00174dc7
LAB_00174d9f:
CMP EBX,-0x9
JC 0x00174da7
INC dword ptr [R14]
LAB_00174da7:
MOV dword ptr [RSP],0x7
MOV RDI,R15
MOV RSI,RBP
MOV RDX,R13
MOV ECX,0xda
MOV R8,R14
MOV R9,RBX
CALL 0x00126541
LAB_00174dc7:
TEST EAX,EAX
JS 0x00174d22
MOV R12D,0x3
JMP 0x00174d22
|
int1 [16]
js_iterator_proto_set_toStringTag
(long param_1,int8 param_2,int8 param_3,int *param_4,int8 param_5)
{
int1 auVar1 [16];
int iVar2;
char *pcVar3;
ulong uVar4;
int4 local_40;
if ((int)param_3 == -1) {
iVar2 = js_same_value(param_1,param_2,param_3,*(int8 *)(*(long *)(param_1 + 0x40) + 0x270)
,*(int8 *)(*(long *)(param_1 + 0x40) + 0x278));
if (iVar2 == 0) {
iVar2 = JS_GetOwnProperty(param_1,0,param_2,param_3,0xda);
uVar4 = 6;
if (-1 < iVar2) {
if (iVar2 == 0) {
if (0xfffffff6 < (uint)param_5) {
*param_4 = *param_4 + 1;
}
iVar2 = JS_DefinePropertyValue(param_1,param_2,param_3,0xda,param_4,param_5,7);
}
else {
if (0xfffffff6 < (uint)param_5) {
*param_4 = *param_4 + 1;
}
local_40 = (int4)param_2;
iVar2 = JS_SetPropertyInternal2
(param_1,param_2,param_3,0xda,param_4,param_5,local_40,0xffffffff,0x4000
,0);
}
if (-1 < iVar2) {
uVar4 = 3;
}
}
goto LAB_00174d22;
}
pcVar3 = "Cannot assign to read only property";
}
else {
pcVar3 = "not an object";
}
JS_ThrowTypeError(param_1,pcVar3);
uVar4 = 6;
LAB_00174d22:
auVar1._8_8_ = 0;
auVar1._0_8_ = uVar4;
return auVar1 << 0x40;
}
| |
32,166 | my_caseup_utf8mb3 | eloqsql/strings/ctype-utf8.c | static size_t my_caseup_utf8mb3(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int srcres, dstres;
const char *srcend= src + srclen;
char *dstend= dst + dstlen, *dst0= dst;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(src != dst || cs->caseup_multiply == 1);
while ((src < srcend) &&
(srcres= my_utf8mb3_uni(cs, &wc, (uchar *) src, (uchar*) srcend)) > 0)
{
my_toupper_utf8mb3(uni_plane, &wc);
if ((dstres= my_uni_utf8mb3(cs, wc, (uchar*) dst, (uchar*) dstend)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
return (size_t) (dst - dst0);
} | O0 | c | my_caseup_utf8mb3:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x64f1a
jmp 0x64f1c
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0x64f4c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x64bb0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x64f55
jmp 0x64fa8
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x65d20
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x64be0
movl %eax, -0x38(%rbp)
cmpl $0x0, %eax
jg 0x64f81
jmp 0x64fa8
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x38(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x64f1c
movq -0x20(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| my_caseup_utf8mb3:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_58], rax
jmp short $+2
loc_64F1A:
jmp short $+2
loc_64F1C:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_59], al
jnb short loc_64F4C
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_utf8mb3_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_59], al
loc_64F4C:
mov al, [rbp+var_59]
test al, 1
jnz short loc_64F55
jmp short loc_64FA8
loc_64F55:
mov rdi, [rbp+var_58]
lea rsi, [rbp+var_30]
call my_toupper_utf8mb3
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_uni_utf8mb3
mov [rbp+var_38], eax
cmp eax, 0
jg short loc_64F81
jmp short loc_64FA8
loc_64F81:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_38]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_64F1C
loc_64FA8:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_50]
sub rax, rcx
add rsp, 60h
pop rbp
retn
| _BYTE * my_caseup_utf8mb3(long long a1, unsigned long long a2, long long a3, _BYTE *a4, long long a5, long long a6)
{
bool v7; // [rsp+7h] [rbp-59h]
long long v8; // [rsp+8h] [rbp-58h]
unsigned long long v10; // [rsp+18h] [rbp-48h]
unsigned long long v11; // [rsp+20h] [rbp-40h]
int v12; // [rsp+28h] [rbp-38h]
int v13; // [rsp+2Ch] [rbp-34h]
unsigned long long v14[2]; // [rsp+30h] [rbp-30h] BYREF
_BYTE *v15; // [rsp+40h] [rbp-20h]
long long v16; // [rsp+48h] [rbp-18h]
unsigned long long v17; // [rsp+50h] [rbp-10h]
long long v18; // [rsp+58h] [rbp-8h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14[1] = a5;
v11 = a3 + a2;
v10 = (unsigned long long)&a4[a5];
v8 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( v17 < v11 )
{
v13 = my_utf8mb3_uni(v18, (long long)v14, v17, v11, a5, a6);
v7 = v13 > 0;
}
if ( !v7 )
break;
my_toupper_utf8mb3(v8, v14);
v12 = my_uni_utf8mb3(v18, v14[0], v15, v10);
if ( v12 <= 0 )
break;
v17 += v13;
v15 += v12;
}
return (_BYTE *)(v15 - a4);
}
| my_caseup_utf8mb3:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00164f1a
LAB_00164f1a:
JMP 0x00164f1c
LAB_00164f1c:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x59],AL
JNC 0x00164f4c
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x00164bb0
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x59],AL
LAB_00164f4c:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x00164f55
JMP 0x00164fa8
LAB_00164f55:
MOV RDI,qword ptr [RBP + -0x58]
LEA RSI,[RBP + -0x30]
CALL 0x00165d20
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x00164be0
MOV dword ptr [RBP + -0x38],EAX
CMP EAX,0x0
JG 0x00164f81
JMP 0x00164fa8
LAB_00164f81:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00164f1c
LAB_00164fa8:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long my_caseup_utf8mb3(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
int8 uVar1;
bool bVar2;
int iVar3;
int local_3c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_utf8mb3_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_toupper_utf8mb3(uVar1,&local_38);
iVar3 = my_uni_utf8mb3(local_10,local_38,local_28,param_4 + param_5);
if (iVar3 < 1) break;
local_18 = local_18 + (long)local_3c;
local_28 = local_28 + iVar3;
}
return local_28 - param_4;
}
| |
32,167 | my_caseup_utf8mb3 | eloqsql/strings/ctype-utf8.c | static size_t my_caseup_utf8mb3(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int srcres, dstres;
const char *srcend= src + srclen;
char *dstend= dst + dstlen, *dst0= dst;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(src != dst || cs->caseup_multiply == 1);
while ((src < srcend) &&
(srcres= my_utf8mb3_uni(cs, &wc, (uchar *) src, (uchar*) srcend)) > 0)
{
my_toupper_utf8mb3(uni_plane, &wc);
if ((dstres= my_uni_utf8mb3(cs, wc, (uchar*) dst, (uchar*) dstend)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
return (size_t) (dst - dst0);
} | O3 | c | my_caseup_utf8mb3:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rcx, -0x30(%rbp)
testq %rdx, %rdx
jle 0x4ec4f
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
addq %rsi, %r15
movq -0x30(%rbp), %r13
addq %r13, %r14
movq 0x78(%rdi), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x4e88f
testl %eax, %eax
jle 0x4ec4f
movl %eax, %ebx
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movzbl %ah, %edx
movq (%rcx,%rdx,8), %rcx
testq %rcx, %rcx
je 0x4ec2e
movzbl %al, %eax
leaq (%rax,%rax,2), %rax
movl (%rcx,%rax,4), %eax
movq %rax, -0x38(%rbp)
movq %rax, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x4e954
testl %eax, %eax
jle 0x4ec4f
movl %ebx, %ecx
addq %rcx, %r12
movl %eax, %eax
addq %rax, %r13
cmpq %r15, %r12
jb 0x4ebf3
subq -0x30(%rbp), %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_caseup_utf8mb3:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13, rcx
mov [rbp+var_30], rcx
test rdx, rdx
jle short loc_4EC4F
mov r14, r8
mov r15, rdx
mov r12, rsi
add r15, rsi
mov r13, [rbp+var_30]
add r14, r13
mov rax, [rdi+78h]
mov [rbp+var_40], rax
loc_4EBF3:
lea rsi, [rbp+var_38]
mov rdx, r12
mov rcx, r15
call my_utf8mb3_uni
test eax, eax
jle short loc_4EC4F
mov ebx, eax
mov rax, [rbp+var_40]
mov rcx, [rax+8]
mov rax, [rbp+var_38]
movzx edx, ah
mov rcx, [rcx+rdx*8]
test rcx, rcx
jz short loc_4EC2E
movzx eax, al
lea rax, [rax+rax*2]
mov eax, [rcx+rax*4]
mov [rbp+var_38], rax
loc_4EC2E:
mov rsi, rax
mov rdx, r13
mov rcx, r14
call my_uni_utf8mb3
test eax, eax
jle short loc_4EC4F
mov ecx, ebx
add r12, rcx
mov eax, eax
add r13, rax
cmp r12, r15
jb short loc_4EBF3
loc_4EC4F:
sub r13, [rbp+var_30]
mov rax, r13
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _BYTE * my_caseup_utf8mb3(long long a1, unsigned __int8 *a2, long long a3, _BYTE *a4, long long a5)
{
_BYTE *v5; // r13
unsigned __int8 *v6; // r12
unsigned long long v7; // r15
unsigned long long v8; // r14
int v9; // eax
unsigned int v10; // ebx
unsigned long long v11; // rax
long long v12; // rcx
int v13; // eax
long long v15; // [rsp+0h] [rbp-40h]
unsigned long long v16; // [rsp+8h] [rbp-38h] BYREF
_BYTE *v17; // [rsp+10h] [rbp-30h]
v5 = a4;
v17 = a4;
if ( a3 > 0 )
{
v6 = a2;
v7 = (unsigned long long)&a2[a3];
v5 = v17;
v8 = (unsigned long long)&v17[a5];
v15 = *(_QWORD *)(a1 + 120);
do
{
v9 = my_utf8mb3_uni(a1, &v16, v6, v7);
if ( v9 <= 0 )
break;
v10 = v9;
v11 = v16;
v12 = *(_QWORD *)(*(_QWORD *)(v15 + 8) + 8LL * BYTE1(v16));
if ( v12 )
{
v11 = *(unsigned int *)(v12 + 12LL * (unsigned __int8)v16);
v16 = v11;
}
v13 = my_uni_utf8mb3(a1, v11, v5, v8);
if ( v13 <= 0 )
break;
v6 += v10;
v5 += (unsigned int)v13;
}
while ( (unsigned long long)v6 < v7 );
}
return (_BYTE *)(v5 - v17);
}
| my_caseup_utf8mb3:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13,RCX
MOV qword ptr [RBP + -0x30],RCX
TEST RDX,RDX
JLE 0x0014ec4f
MOV R14,R8
MOV R15,RDX
MOV R12,RSI
ADD R15,RSI
MOV R13,qword ptr [RBP + -0x30]
ADD R14,R13
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RBP + -0x40],RAX
LAB_0014ebf3:
LEA RSI,[RBP + -0x38]
MOV RDX,R12
MOV RCX,R15
CALL 0x0014e88f
TEST EAX,EAX
JLE 0x0014ec4f
MOV EBX,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EDX,AH
MOV RCX,qword ptr [RCX + RDX*0x8]
TEST RCX,RCX
JZ 0x0014ec2e
MOVZX EAX,AL
LEA RAX,[RAX + RAX*0x2]
MOV EAX,dword ptr [RCX + RAX*0x4]
MOV qword ptr [RBP + -0x38],RAX
LAB_0014ec2e:
MOV RSI,RAX
MOV RDX,R13
MOV RCX,R14
CALL 0x0014e954
TEST EAX,EAX
JLE 0x0014ec4f
MOV ECX,EBX
ADD R12,RCX
MOV EAX,EAX
ADD R13,RAX
CMP R12,R15
JC 0x0014ebf3
LAB_0014ec4f:
SUB R13,qword ptr [RBP + -0x30]
MOV RAX,R13
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_caseup_utf8mb3(long param_1,ulong param_2,long param_3,long param_4)
{
long lVar1;
long lVar2;
uint uVar3;
uint uVar4;
long lVar5;
ulong uVar6;
int8 local_40;
lVar5 = param_4;
if (0 < param_3) {
uVar6 = param_3 + param_2;
lVar1 = *(long *)(param_1 + 0x78);
do {
uVar3 = my_utf8mb3_uni();
if ((int)uVar3 < 1) break;
lVar2 = *(long *)(*(long *)(lVar1 + 8) + (local_40 >> 8 & 0xff) * 8);
if (lVar2 != 0) {
local_40 = (ulong)*(uint *)(lVar2 + (local_40 & 0xff) * 0xc);
}
uVar4 = my_uni_utf8mb3();
if ((int)uVar4 < 1) break;
param_2 = param_2 + uVar3;
lVar5 = lVar5 + (ulong)uVar4;
} while (param_2 < uVar6);
}
return lVar5 - param_4;
}
| |
32,168 | rw_pr_rdlock | eloqsql/mysys/thr_rwlock.c | int rw_pr_rdlock(rw_pr_lock_t *rwlock)
{
pthread_mutex_lock(&rwlock->lock);
/*
The fact that we were able to acquire 'lock' mutex means
that there are no active writers and we can acquire rd-lock.
Increment active readers counter to prevent requests for
wr-lock from succeeding and unlock mutex.
*/
rwlock->active_readers++;
pthread_mutex_unlock(&rwlock->lock);
return 0;
} | O3 | c | rw_pr_rdlock:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x24440
incl 0x58(%rbx)
movq %rbx, %rdi
callq 0x24200
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| rw_pr_rdlock:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call _pthread_mutex_lock
inc dword ptr [rbx+58h]
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
| long long rw_pr_rdlock(long long a1)
{
pthread_mutex_lock(a1);
++*(_DWORD *)(a1 + 88);
pthread_mutex_unlock(a1);
return 0LL;
}
| rw_pr_rdlock:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00124440
INC dword ptr [RBX + 0x58]
MOV RDI,RBX
CALL 0x00124200
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 rw_pr_rdlock(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
*(int *)((long)param_1 + 0x58) = *(int *)((long)param_1 + 0x58) + 1;
pthread_mutex_unlock(param_1);
return 0;
}
| |
32,169 | quantize_q4_0 | ngxson[P]ggml-easy/ggml/src/ggml-quants.c | size_t quantize_q4_0(const float * GGML_RESTRICT src, void * GGML_RESTRICT dst, int64_t nrow, int64_t n_per_row, const float * quant_weights) {
if (!quant_weights) {
quantize_row_q4_0_ref(src, dst, (int64_t)nrow*n_per_row);
return nrow * ggml_row_size(GGML_TYPE_Q4_0, n_per_row);
}
size_t row_size = ggml_row_size(GGML_TYPE_Q4_0, n_per_row);
char * qrow = (char *)dst;
for (int64_t row = 0; row < nrow; ++row) {
quantize_row_q4_0_impl(src, (block_q4_0*)qrow, n_per_row, quant_weights);
src += n_per_row;
qrow += row_size;
}
return nrow * row_size;
} | O0 | c | quantize_q4_0:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x77d2e
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
imulq 0x30(%rsp), %rdx
callq 0x44930
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movl $0x2, %edi
callq 0x45820
movq %rax, %rcx
movq 0x8(%rsp), %rax
imulq %rcx, %rax
movq %rax, 0x50(%rsp)
jmp 0x77dbc
movq 0x30(%rsp), %rsi
movl $0x2, %edi
callq 0x45820
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x38(%rsp), %rax
jge 0x77dac
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x77dd0
movq 0x30(%rsp), %rax
shlq $0x2, %rax
addq 0x48(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x20(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x77d55
movq 0x38(%rsp), %rax
imulq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
| quantize_q4_0:
sub rsp, 58h
mov [rsp+58h+var_10], rdi
mov [rsp+58h+var_18], rsi
mov [rsp+58h+var_20], rdx
mov [rsp+58h+var_28], rcx
mov [rsp+58h+var_30], r8
cmp [rsp+58h+var_30], 0
jnz short loc_77D2E
mov rdi, [rsp+58h+var_10]
mov rsi, [rsp+58h+var_18]
mov rdx, [rsp+58h+var_20]
imul rdx, [rsp+58h+var_28]
call _quantize_row_q4_0_ref
mov rax, [rsp+58h+var_20]
mov [rsp+58h+var_50], rax
mov rsi, [rsp+58h+var_28]
mov edi, 2
call _ggml_row_size
mov rcx, rax
mov rax, [rsp+58h+var_50]
imul rax, rcx
mov [rsp+58h+var_8], rax
jmp loc_77DBC
loc_77D2E:
mov rsi, [rsp+58h+var_28]
mov edi, 2
call _ggml_row_size
mov [rsp+58h+var_38], rax
mov rax, [rsp+58h+var_18]
mov [rsp+58h+var_40], rax
mov [rsp+58h+var_48], 0
loc_77D55:
mov rax, [rsp+58h+var_48]
cmp rax, [rsp+58h+var_20]
jge short loc_77DAC
mov rdi, [rsp+58h+var_10]
mov rsi, [rsp+58h+var_40]
mov rdx, [rsp+58h+var_28]
mov rcx, [rsp+58h+var_30]
call quantize_row_q4_0_impl
mov rax, [rsp+58h+var_28]
shl rax, 2
add rax, [rsp+58h+var_10]
mov [rsp+58h+var_10], rax
mov rax, [rsp+58h+var_38]
add rax, [rsp+58h+var_40]
mov [rsp+58h+var_40], rax
mov rax, [rsp+58h+var_48]
add rax, 1
mov [rsp+58h+var_48], rax
jmp short loc_77D55
loc_77DAC:
mov rax, [rsp+58h+var_20]
imul rax, [rsp+58h+var_38]
mov [rsp+58h+var_8], rax
loc_77DBC:
mov rax, [rsp+58h+var_8]
add rsp, 58h
retn
| unsigned long long quantize_q4_0(long long a1, long long a2, long long a3, long long a4, long long a5)
{
long long i; // [rsp+10h] [rbp-48h]
long long v7; // [rsp+18h] [rbp-40h]
unsigned long long v8; // [rsp+20h] [rbp-38h]
long long v12; // [rsp+48h] [rbp-10h]
v12 = a1;
if ( a5 )
{
v8 = ggml_row_size(2u, a4);
v7 = a2;
for ( i = 0LL; i < a3; ++i )
{
quantize_row_q4_0_impl(v12, v7, a4, a5);
v12 += 4 * a4;
v7 += v8;
}
return v8 * a3;
}
else
{
quantize_row_q4_0_ref(a1, a2, a4 * a3);
return ggml_row_size(2u, a4) * a3;
}
}
| quantize_q4_0:
SUB RSP,0x58
MOV qword ptr [RSP + 0x48],RDI
MOV qword ptr [RSP + 0x40],RSI
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x30],RCX
MOV qword ptr [RSP + 0x28],R8
CMP qword ptr [RSP + 0x28],0x0
JNZ 0x00177d2e
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x38]
IMUL RDX,qword ptr [RSP + 0x30]
CALL 0x00144930
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x8],RAX
MOV RSI,qword ptr [RSP + 0x30]
MOV EDI,0x2
CALL 0x00145820
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
IMUL RAX,RCX
MOV qword ptr [RSP + 0x50],RAX
JMP 0x00177dbc
LAB_00177d2e:
MOV RSI,qword ptr [RSP + 0x30]
MOV EDI,0x2
CALL 0x00145820
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x10],0x0
LAB_00177d55:
MOV RAX,qword ptr [RSP + 0x10]
CMP RAX,qword ptr [RSP + 0x38]
JGE 0x00177dac
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x28]
CALL 0x00177dd0
MOV RAX,qword ptr [RSP + 0x30]
SHL RAX,0x2
ADD RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,0x1
MOV qword ptr [RSP + 0x10],RAX
JMP 0x00177d55
LAB_00177dac:
MOV RAX,qword ptr [RSP + 0x38]
IMUL RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x50],RAX
LAB_00177dbc:
MOV RAX,qword ptr [RSP + 0x50]
ADD RSP,0x58
RET
|
long quantize_q4_0(long param_1,long param_2,long param_3,long param_4,long param_5)
{
int8 local_48;
int8 local_40;
int8 local_10;
int8 local_8;
if (param_5 == 0) {
quantize_row_q4_0_ref(param_1,param_2,param_3 * param_4);
local_8 = ggml_row_size(2,param_4);
}
else {
local_8 = ggml_row_size(2,param_4);
local_40 = param_2;
local_10 = param_1;
for (local_48 = 0; local_48 < param_3; local_48 = local_48 + 1) {
quantize_row_q4_0_impl(local_10,local_40,param_4,param_5);
local_10 = param_4 * 4 + local_10;
local_40 = local_8 + local_40;
}
}
local_8 = param_3 * local_8;
return local_8;
}
| |
32,170 | quantize_q4_0 | ngxson[P]ggml-easy/ggml/src/ggml-quants.c | size_t quantize_q4_0(const float * GGML_RESTRICT src, void * GGML_RESTRICT dst, int64_t nrow, int64_t n_per_row, const float * quant_weights) {
if (!quant_weights) {
quantize_row_q4_0_ref(src, dst, (int64_t)nrow*n_per_row);
return nrow * ggml_row_size(GGML_TYPE_Q4_0, n_per_row);
}
size_t row_size = ggml_row_size(GGML_TYPE_Q4_0, n_per_row);
char * qrow = (char *)dst;
for (int64_t row = 0; row < nrow; ++row) {
quantize_row_q4_0_impl(src, (block_q4_0*)qrow, n_per_row, quant_weights);
src += n_per_row;
qrow += row_size;
}
return nrow * row_size;
} | O1 | c | quantize_q4_0:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
movq %r8, 0x18(%rsp)
testq %r8, %r8
je 0x315df
movl $0x2, %edi
movq %r15, %rsi
callq 0x17850
testq %r14, %r14
jle 0x315fe
cvtsi2ss %r15, %xmm0
movss %xmm0, 0x10(%rsp)
leaq 0x1f(%r15), %rcx
testq %r15, %r15
cmovnsq %r15, %rcx
sarq $0x5, %rcx
movq %rcx, 0x48(%rsp)
leaq (,%r15,4), %rcx
movq %rcx, 0x20(%rsp)
xorl %ecx, %ecx
movq %r14, 0x38(%rsp)
movq %r15, 0x30(%rsp)
movq %rax, 0x28(%rsp)
movq %rcx, 0x40(%rsp)
xorps %xmm1, %xmm1
testq %r15, %r15
jle 0x31451
xorl %eax, %eax
movss (%rbx,%rax,4), %xmm0
mulss %xmm0, %xmm0
addss %xmm0, %xmm1
incq %rax
cmpq %rax, %r15
jne 0x3143c
movq %rbx, 0x8(%rsp)
cmpq $0x20, %r15
jl 0x315b0
divss 0x10(%rsp), %xmm1
movq 0x18(%rsp), %r13
movq 0x8(%rsp), %r12
xorl %r14d, %r14d
movss %xmm1, 0x4(%rsp)
movq %rbp, %rbx
movq %r14, %rbp
shlq $0x7, %rbp
addq 0x8(%rsp), %rbp
xorl %r15d, %r15d
movss (%r13,%r15,4), %xmm2
movss (%r12,%r15,4), %xmm0
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
ucomiss 0x1d67d(%rip), %xmm0 # 0x4eb24
jb 0x314af
sqrtss %xmm0, %xmm0
jmp 0x314c6
movss %xmm2, 0x14(%rsp)
callq 0x17f30
movss 0x14(%rsp), %xmm2
movss 0x4(%rsp), %xmm1
mulss %xmm0, %xmm2
movss %xmm2, 0x70(%rsp,%r15,4)
incq %r15
cmpq $0x20, %r15
jne 0x3148b
movl $0x20, %edi
movl $0x8, %esi
movq %rbp, %rdx
leaq 0x50(%rsp), %rcx
leaq 0x70(%rsp), %r8
callq 0x30a3c
movd %xmm0, %eax
andps 0x18b1f(%rip), %xmm0 # 0x4a020
mulss 0x18bdf(%rip), %xmm0 # 0x4a0e8
mulss 0x18bdb(%rip), %xmm0 # 0x4a0ec
leal (%rax,%rax), %ecx
movl %eax, %edx
andl $0x7f800000, %edx # imm = 0x7F800000
addl $0x7800000, %edx # imm = 0x7800000
cmpl $0x71000000, %ecx # imm = 0x71000000
movl $0x40000000, %esi # imm = 0x40000000
cmovbl %esi, %edx
movd %edx, %xmm1
addss %xmm0, %xmm1
movd %xmm1, %edx
movss 0x4(%rsp), %xmm1
movl %edx, %esi
shrl $0xd, %esi
andl $0x7c00, %esi # imm = 0x7C00
andl $0xfff, %edx # imm = 0xFFF
addl %esi, %edx
shrl $0x10, %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0xff000001, %ecx # imm = 0xFF000001
movl $0x7e00, %ecx # imm = 0x7E00
cmovael %ecx, %edx
orl %eax, %edx
leaq (%r14,%r14,8), %rax
movq %rbx, %rbp
movw %dx, (%rbx,%rax,2)
movdqa 0x60(%rsp), %xmm0
psllw $0x4, %xmm0
pand 0x1d015(%rip), %xmm0 # 0x4e5a0
por 0x50(%rsp), %xmm0
movdqu %xmm0, 0x2(%rbx,%rax,2)
incq %r14
movl $0x80, %eax
addq %rax, %r12
addq %rax, %r13
cmpq 0x48(%rsp), %r14
jne 0x31479
movq 0x8(%rsp), %rbx
addq 0x20(%rsp), %rbx
movq 0x28(%rsp), %rax
addq %rax, %rbp
movq 0x40(%rsp), %rcx
incq %rcx
movq 0x38(%rsp), %r14
cmpq %r14, %rcx
movq 0x30(%rsp), %r15
jne 0x3142d
jmp 0x315fe
movq %r15, %rdx
imulq %r14, %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x173d0
movl $0x2, %edi
movq %r15, %rsi
callq 0x17850
imulq %r14, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| quantize_q4_0:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov r15, rcx
mov r14, rdx
mov rbp, rsi
mov rbx, rdi
mov [rsp+128h+var_110], r8
test r8, r8
jz loc_315DF
mov edi, 2
mov rsi, r15
call _ggml_row_size
test r14, r14
jle loc_315FE
cvtsi2ss xmm0, r15
movss [rsp+128h+var_118], xmm0
lea rcx, [r15+1Fh]
test r15, r15
cmovns rcx, r15
sar rcx, 5
mov [rsp+128h+var_E0], rcx
lea rcx, ds:0[r15*4]
mov [rsp+128h+var_108], rcx
xor ecx, ecx
mov [rsp+128h+var_F0], r14
mov [rsp+128h+var_F8], r15
mov [rsp+128h+var_100], rax
loc_3142D:
mov [rsp+128h+var_E8], rcx
xorps xmm1, xmm1
test r15, r15
jle short loc_31451
xor eax, eax
loc_3143C:
movss xmm0, dword ptr [rbx+rax*4]
mulss xmm0, xmm0
addss xmm1, xmm0
inc rax
cmp r15, rax
jnz short loc_3143C
loc_31451:
mov [rsp+128h+var_120], rbx
cmp r15, 20h ; ' '
jl loc_315B0
divss xmm1, [rsp+128h+var_118]
mov r13, [rsp+128h+var_110]
mov r12, [rsp+128h+var_120]
xor r14d, r14d
movss [rsp+128h+var_124], xmm1
loc_31479:
mov rbx, rbp
mov rbp, r14
shl rbp, 7
add rbp, [rsp+128h+var_120]
xor r15d, r15d
loc_3148B:
movss xmm2, dword ptr [r13+r15*4+0]
movss xmm0, dword ptr [r12+r15*4]
mulss xmm0, xmm0
addss xmm0, xmm1
ucomiss xmm0, cs:dword_4EB24
jb short loc_314AF
sqrtss xmm0, xmm0
jmp short loc_314C6
loc_314AF:
movss [rsp+128h+var_114], xmm2
call _sqrtf
movss xmm2, [rsp+128h+var_114]
movss xmm1, [rsp+128h+var_124]
loc_314C6:
mulss xmm2, xmm0
movss [rsp+r15*4+128h+var_B8], xmm2
inc r15
cmp r15, 20h ; ' '
jnz short loc_3148B
mov edi, 20h ; ' '
mov esi, 8
mov rdx, rbp
lea rcx, [rsp+128h+var_D8]
lea r8, [rsp+128h+var_B8]
call make_qx_quants
movd eax, xmm0
andps xmm0, cs:xmmword_4A020
mulss xmm0, cs:dword_4A0E8
mulss xmm0, cs:dword_4A0EC
lea ecx, [rax+rax]
mov edx, eax
and edx, 7F800000h
add edx, 7800000h
cmp ecx, 71000000h
mov esi, 40000000h
cmovb edx, esi
movd xmm1, edx
addss xmm1, xmm0
movd edx, xmm1
movss xmm1, [rsp+128h+var_124]
mov esi, edx
shr esi, 0Dh
and esi, 7C00h
and edx, 0FFFh
add edx, esi
shr eax, 10h
and eax, 8000h
cmp ecx, 0FF000001h
mov ecx, 7E00h
cmovnb edx, ecx
or edx, eax
lea rax, [r14+r14*8]
mov rbp, rbx
mov [rbx+rax*2], dx
movdqa xmm0, [rsp+128h+var_C8]
psllw xmm0, 4
pand xmm0, cs:xmmword_4E5A0
por xmm0, [rsp+128h+var_D8]
movdqu xmmword ptr [rbx+rax*2+2], xmm0
inc r14
mov eax, 80h
add r12, rax
add r13, rax
cmp r14, [rsp+128h+var_E0]
jnz loc_31479
loc_315B0:
mov rbx, [rsp+128h+var_120]
add rbx, [rsp+128h+var_108]
mov rax, [rsp+128h+var_100]
add rbp, rax
mov rcx, [rsp+128h+var_E8]
inc rcx
mov r14, [rsp+128h+var_F0]
cmp rcx, r14
mov r15, [rsp+128h+var_F8]
jnz loc_3142D
jmp short loc_315FE
loc_315DF:
mov rdx, r15
imul rdx, r14
mov rdi, rbx
mov rsi, rbp
call _quantize_row_q4_0_ref
mov edi, 2
mov rsi, r15
call _ggml_row_size
loc_315FE:
imul rax, r14
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long quantize_q4_0(long long a1, long long a2, long long a3, long long a4, long long a5)
{
long long v5; // r15
long long v6; // r14
long long v7; // rbp
long long v8; // rbx
unsigned long long v9; // rax
long long v10; // rcx
float v11; // xmm1_4
long long i; // rax
float v13; // xmm1_4
long long v14; // r13
long long v15; // r12
long long v16; // r14
long long j; // r15
float v18; // xmm2_4
__m128i v19; // xmm0
unsigned int v20; // eax
float v21; // xmm0_4
unsigned int v22; // ecx
unsigned int v23; // edx
__m128i v24; // xmm1
unsigned int v25; // edx
int v26; // edx
int v27; // eax
__int16 v28; // dx
long long v29; // rax
float v31; // [rsp+4h] [rbp-124h]
float v32; // [rsp+10h] [rbp-118h]
float v33; // [rsp+14h] [rbp-114h]
long long v35; // [rsp+20h] [rbp-108h]
unsigned long long v36; // [rsp+28h] [rbp-100h]
long long v37; // [rsp+30h] [rbp-F8h]
long long v38; // [rsp+38h] [rbp-F0h]
long long v39; // [rsp+40h] [rbp-E8h]
long long v40; // [rsp+48h] [rbp-E0h]
__m128i v41; // [rsp+50h] [rbp-D8h] BYREF
__m128i v42; // [rsp+60h] [rbp-C8h] BYREF
float v43[46]; // [rsp+70h] [rbp-B8h] BYREF
v5 = a4;
v6 = a3;
v7 = a2;
v8 = a1;
if ( a5 )
{
v9 = ggml_row_size(2u, a4);
if ( v6 > 0 )
{
v32 = (float)(int)v5;
v40 = v5 / 32;
v35 = 4 * v5;
v10 = 0LL;
v38 = v6;
v37 = v5;
v36 = v9;
do
{
v39 = v10;
v11 = 0.0;
if ( v5 > 0 )
{
for ( i = 0LL; i != v5; ++i )
v11 = v11 + (float)(*(float *)(v8 + 4 * i) * *(float *)(v8 + 4 * i));
}
if ( v5 >= 32 )
{
v13 = v11 / v32;
v14 = a5;
v15 = v8;
v16 = 0LL;
v31 = v13;
do
{
for ( j = 0LL; j != 32; ++j )
{
v18 = *(float *)(v14 + 4 * j);
v19 = (__m128i)*(unsigned int *)(v15 + 4 * j);
*(float *)v19.m128i_i32 = (float)(*(float *)v19.m128i_i32 * *(float *)v19.m128i_i32) + v13;
if ( *(float *)v19.m128i_i32 < 0.0 )
{
v33 = *(float *)(v14 + 4 * j);
*(double *)v19.m128i_i64 = sqrtf(*(double *)v19.m128i_i64);
v18 = v33;
v13 = v31;
}
else
{
*(float *)v19.m128i_i32 = fsqrt(*(float *)v19.m128i_i32);
}
v43[j] = v18 * *(float *)v19.m128i_i32;
}
make_qx_quants(32, 8, v8 + (v16 << 7), (long long)&v41, (long long)v43);
v20 = _mm_cvtsi128_si32(v19);
v21 = (float)(fabs(*(float *)v19.m128i_i32) * 5.1922969e33) * 7.7037198e-34;
v22 = 2 * v20;
v23 = (v20 & 0x7F800000) + 125829120;
if ( 2 * v20 < 0x71000000 )
v23 = 0x40000000;
v24 = _mm_cvtsi32_si128(v23);
*(float *)v24.m128i_i32 = *(float *)v24.m128i_i32 + v21;
v25 = _mm_cvtsi128_si32(v24);
v13 = v31;
v26 = ((v25 >> 13) & 0x7C00) + (v25 & 0xFFF);
v27 = HIWORD(v20) & 0x8000;
if ( v22 >= 0xFF000001 )
LOWORD(v26) = 32256;
v28 = v27 | v26;
v29 = 9 * v16;
*(_WORD *)(v7 + 2 * v29) = v28;
*(__m128i *)(v7 + 2 * v29 + 2) = _mm_or_si128(
_mm_and_si128(
_mm_slli_epi16(_mm_load_si128(&v42), 4u),
(__m128i)xmmword_4E5A0),
v41);
++v16;
v15 += 128LL;
v14 += 128LL;
}
while ( v16 != v40 );
}
v8 += v35;
v9 = v36;
v7 += v36;
v10 = v39 + 1;
v6 = v38;
v5 = v37;
}
while ( v39 + 1 != v38 );
}
}
else
{
quantize_row_q4_0_ref(a1, a2, a3 * a4);
v9 = ggml_row_size(2u, v5);
}
return v6 * v9;
}
| quantize_q4_0:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV R15,RCX
MOV R14,RDX
MOV RBP,RSI
MOV RBX,RDI
MOV qword ptr [RSP + 0x18],R8
TEST R8,R8
JZ 0x001315df
MOV EDI,0x2
MOV RSI,R15
CALL 0x00117850
TEST R14,R14
JLE 0x001315fe
CVTSI2SS XMM0,R15
MOVSS dword ptr [RSP + 0x10],XMM0
LEA RCX,[R15 + 0x1f]
TEST R15,R15
CMOVNS RCX,R15
SAR RCX,0x5
MOV qword ptr [RSP + 0x48],RCX
LEA RCX,[R15*0x4]
MOV qword ptr [RSP + 0x20],RCX
XOR ECX,ECX
MOV qword ptr [RSP + 0x38],R14
MOV qword ptr [RSP + 0x30],R15
MOV qword ptr [RSP + 0x28],RAX
LAB_0013142d:
MOV qword ptr [RSP + 0x40],RCX
XORPS XMM1,XMM1
TEST R15,R15
JLE 0x00131451
XOR EAX,EAX
LAB_0013143c:
MOVSS XMM0,dword ptr [RBX + RAX*0x4]
MULSS XMM0,XMM0
ADDSS XMM1,XMM0
INC RAX
CMP R15,RAX
JNZ 0x0013143c
LAB_00131451:
MOV qword ptr [RSP + 0x8],RBX
CMP R15,0x20
JL 0x001315b0
DIVSS XMM1,dword ptr [RSP + 0x10]
MOV R13,qword ptr [RSP + 0x18]
MOV R12,qword ptr [RSP + 0x8]
XOR R14D,R14D
MOVSS dword ptr [RSP + 0x4],XMM1
LAB_00131479:
MOV RBX,RBP
MOV RBP,R14
SHL RBP,0x7
ADD RBP,qword ptr [RSP + 0x8]
XOR R15D,R15D
LAB_0013148b:
MOVSS XMM2,dword ptr [R13 + R15*0x4]
MOVSS XMM0,dword ptr [R12 + R15*0x4]
MULSS XMM0,XMM0
ADDSS XMM0,XMM1
UCOMISS XMM0,dword ptr [0x0014eb24]
JC 0x001314af
SQRTSS XMM0,XMM0
JMP 0x001314c6
LAB_001314af:
MOVSS dword ptr [RSP + 0x14],XMM2
CALL 0x00117f30
MOVSS XMM2,dword ptr [RSP + 0x14]
MOVSS XMM1,dword ptr [RSP + 0x4]
LAB_001314c6:
MULSS XMM2,XMM0
MOVSS dword ptr [RSP + R15*0x4 + 0x70],XMM2
INC R15
CMP R15,0x20
JNZ 0x0013148b
MOV EDI,0x20
MOV ESI,0x8
MOV RDX,RBP
LEA RCX,[RSP + 0x50]
LEA R8,[RSP + 0x70]
CALL 0x00130a3c
MOVD EAX,XMM0
ANDPS XMM0,xmmword ptr [0x0014a020]
MULSS XMM0,dword ptr [0x0014a0e8]
MULSS XMM0,dword ptr [0x0014a0ec]
LEA ECX,[RAX + RAX*0x1]
MOV EDX,EAX
AND EDX,0x7f800000
ADD EDX,0x7800000
CMP ECX,0x71000000
MOV ESI,0x40000000
CMOVC EDX,ESI
MOVD XMM1,EDX
ADDSS XMM1,XMM0
MOVD EDX,XMM1
MOVSS XMM1,dword ptr [RSP + 0x4]
MOV ESI,EDX
SHR ESI,0xd
AND ESI,0x7c00
AND EDX,0xfff
ADD EDX,ESI
SHR EAX,0x10
AND EAX,0x8000
CMP ECX,0xff000001
MOV ECX,0x7e00
CMOVNC EDX,ECX
OR EDX,EAX
LEA RAX,[R14 + R14*0x8]
MOV RBP,RBX
MOV word ptr [RBX + RAX*0x2],DX
MOVDQA XMM0,xmmword ptr [RSP + 0x60]
PSLLW XMM0,0x4
PAND XMM0,xmmword ptr [0x0014e5a0]
POR XMM0,xmmword ptr [RSP + 0x50]
MOVDQU xmmword ptr [RBX + RAX*0x2 + 0x2],XMM0
INC R14
MOV EAX,0x80
ADD R12,RAX
ADD R13,RAX
CMP R14,qword ptr [RSP + 0x48]
JNZ 0x00131479
LAB_001315b0:
MOV RBX,qword ptr [RSP + 0x8]
ADD RBX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x28]
ADD RBP,RAX
MOV RCX,qword ptr [RSP + 0x40]
INC RCX
MOV R14,qword ptr [RSP + 0x38]
CMP RCX,R14
MOV R15,qword ptr [RSP + 0x30]
JNZ 0x0013142d
JMP 0x001315fe
LAB_001315df:
MOV RDX,R15
IMUL RDX,R14
MOV RDI,RBX
MOV RSI,RBP
CALL 0x001173d0
MOV EDI,0x2
MOV RSI,R15
CALL 0x00117850
LAB_001315fe:
IMUL RAX,R14
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
long quantize_q4_0(long param_1,long param_2,long param_3,long param_4,long param_5)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
ushort uVar5;
float fVar6;
long lVar7;
long lVar8;
long lVar9;
float fVar10;
uint uVar11;
int1 auVar12 [16];
float fVar13;
int1 local_d8 [16];
int1 local_c8 [16];
float local_b8 [34];
if (param_5 == 0) {
quantize_row_q4_0_ref(param_1,param_2,param_4 * param_3);
lVar1 = ggml_row_size(2,param_4);
}
else {
lVar1 = ggml_row_size(2,param_4);
if (0 < param_3) {
lVar3 = param_4 + 0x1f;
if (-1 < param_4) {
lVar3 = param_4;
}
lVar4 = 0;
do {
fVar13 = 0.0;
if (0 < param_4) {
lVar2 = 0;
do {
fVar6 = *(float *)(param_1 + lVar2 * 4);
fVar13 = fVar13 + fVar6 * fVar6;
lVar2 = lVar2 + 1;
} while (param_4 != lVar2);
}
if (0x1f < param_4) {
lVar8 = 0;
lVar2 = param_1;
lVar7 = param_5;
do {
lVar9 = 0;
do {
fVar6 = *(float *)(lVar7 + lVar9 * 4);
fVar10 = *(float *)(lVar2 + lVar9 * 4);
fVar10 = fVar10 * fVar10 + fVar13 / (float)param_4;
if (fVar10 < DAT_0014eb24) {
fVar10 = sqrtf(fVar10);
}
else {
fVar10 = SQRT(fVar10);
}
local_b8[lVar9] = fVar6 * fVar10;
lVar9 = lVar9 + 1;
} while (lVar9 != 0x20);
uVar11 = make_qx_quants(0x20,8,lVar8 * 0x80 + param_1,local_d8,local_b8);
fVar6 = (float)((uVar11 & 0x7f800000) + 0x7800000);
if (uVar11 * 2 < 0x71000000) {
fVar6 = 2.0;
}
fVar6 = fVar6 + (float)(uVar11 & _DAT_0014a020) * DAT_0014a0e8 * DAT_0014a0ec;
uVar5 = (SUB42(fVar6,0) & 0xfff) + ((ushort)((uint)fVar6 >> 0xd) & 0x7c00);
if (0xff000000 < uVar11 * 2) {
uVar5 = 0x7e00;
}
*(ushort *)(param_2 + lVar8 * 0x12) = uVar5 | (ushort)(uVar11 >> 0x10) & 0x8000;
auVar12 = psllw(local_c8,4);
*(int1 (*) [16])(param_2 + 2 + lVar8 * 0x12) = auVar12 & _DAT_0014e5a0 | local_d8;
lVar8 = lVar8 + 1;
lVar2 = lVar2 + 0x80;
lVar7 = lVar7 + 0x80;
} while (lVar8 != lVar3 >> 5);
}
param_1 = param_1 + param_4 * 4;
param_2 = param_2 + lVar1;
lVar4 = lVar4 + 1;
} while (lVar4 != param_3);
}
}
return lVar1 * param_3;
}
| |
32,171 | translog_lock | eloqsql/storage/maria/ma_loghandler.c | void translog_lock()
{
uint8 current_buffer;
DBUG_ENTER("translog_lock");
/*
Locking the loghandler mean locking current buffer, but it can change
during locking, so we should check it
*/
for (;;)
{
/*
log_descriptor.bc.buffer_no is only one byte so its reading is
an atomic operation
*/
current_buffer= log_descriptor.bc.buffer_no;
translog_buffer_lock(log_descriptor.buffers + current_buffer);
if (log_descriptor.bc.buffer_no == current_buffer)
break;
translog_buffer_unlock(log_descriptor.buffers + current_buffer);
}
DBUG_VOID_RETURN;
} | O3 | c | translog_lock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movzbl 0xbb9b18(%rip), %r15d # 0xbfdde6
leaq 0x3b8e8b(%rip), %r14 # 0x3fd160
imulq $0x100120, %r15, %rax # imm = 0x100120
leaq (%rax,%r14), %rbx
addq $0x2f8, %rbx # imm = 0x2F8
movq %rbx, %rdi
callq 0x4435b
cmpb %r15b, 0xbb9af0(%rip) # 0xbfdde6
jne 0x44301
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x340d08(%rip), %r15 # 0x385010
movq 0x1000d0(%rbx), %rdi
testq %rdi, %rdi
jne 0x44350
addq $0x100090, %rbx # imm = 0x100090
movq %rbx, %rdi
callq 0x291e0
movzbl 0xbb9abb(%rip), %r12d # 0xbfdde6
imulq $0x100120, %r12, %rax # imm = 0x100120
leaq (%rax,%r14), %rbx
addq $0x2f8, %rbx # imm = 0x2F8
movq %rbx, %rdi
callq 0x4435b
cmpb %r12b, 0xbb9a9a(%rip) # 0xbfdde6
jne 0x44308
jmp 0x442f8
movq (%r15), %rax
callq *0x160(%rax)
jmp 0x44314
| translog_lock:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
movzx r15d, byte ptr cs:xmmword_BFDDE0+6
lea r14, log_descriptor
imul rax, r15, 100120h
lea rbx, [rax+r14]
add rbx, 2F8h
mov rdi, rbx
call translog_buffer_lock
cmp byte ptr cs:xmmword_BFDDE0+6, r15b
jnz short loc_44301
loc_442F8:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_44301:
lea r15, PSI_server
loc_44308:
mov rdi, ds:qword_1000D0[rbx]
test rdi, rdi
jnz short loc_44350
loc_44314:
add rbx, 100090h
mov rdi, rbx
call _pthread_mutex_unlock
movzx r12d, byte ptr cs:xmmword_BFDDE0+6
imul rax, r12, 100120h
lea rbx, [rax+r14]
add rbx, 2F8h
mov rdi, rbx
call translog_buffer_lock
cmp byte ptr cs:xmmword_BFDDE0+6, r12b
jnz short loc_44308
jmp short loc_442F8
loc_44350:
mov rax, [r15]
call qword ptr [rax+160h]
jmp short loc_44314
| long long translog_lock()
{
char v0; // r15
long long *v1; // rbx
long long result; // rax
char v3; // r12
v0 = BYTE6(xmmword_BFDDE0);
v1 = &log_descriptor[131108 * BYTE6(xmmword_BFDDE0) + 95];
result = translog_buffer_lock(v1);
if ( BYTE6(xmmword_BFDDE0) != v0 )
{
do
{
if ( *(long long *)((char *)&qword_1000D0 + (_QWORD)v1) )
PSI_server[44]();
pthread_mutex_unlock(v1 + 131090);
v3 = BYTE6(xmmword_BFDDE0);
v1 = &log_descriptor[131108 * BYTE6(xmmword_BFDDE0) + 95];
result = translog_buffer_lock(v1);
}
while ( BYTE6(xmmword_BFDDE0) != v3 );
}
return result;
}
| translog_lock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOVZX R15D,byte ptr [0x00cfdde6]
LEA R14,[0x4fd160]
IMUL RAX,R15,0x100120
LEA RBX,[RAX + R14*0x1]
ADD RBX,0x2f8
MOV RDI,RBX
CALL 0x0014435b
CMP byte ptr [0x00cfdde6],R15B
JNZ 0x00144301
LAB_001442f8:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00144301:
LEA R15,[0x485010]
LAB_00144308:
MOV RDI,qword ptr [RBX + 0x1000d0]
TEST RDI,RDI
JNZ 0x00144350
LAB_00144314:
ADD RBX,0x100090
MOV RDI,RBX
CALL 0x001291e0
MOVZX R12D,byte ptr [0x00cfdde6]
IMUL RAX,R12,0x100120
LEA RBX,[RAX + R14*0x1]
ADD RBX,0x2f8
MOV RDI,RBX
CALL 0x0014435b
CMP byte ptr [0x00cfdde6],R12B
JNZ 0x00144308
JMP 0x001442f8
LAB_00144350:
MOV RAX,qword ptr [R15]
CALL qword ptr [RAX + 0x160]
JMP 0x00144314
|
void translog_lock(void)
{
byte bVar1;
int *puVar2;
bVar1 = DAT_00cfdde6;
puVar2 = &DAT_004fd458 + (ulong)DAT_00cfdde6 * 0x100120;
translog_buffer_lock(puVar2);
if (DAT_00cfdde6 != bVar1) {
do {
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_filesz + (long)puVar2) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock
((pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + (long)puVar2));
bVar1 = DAT_00cfdde6;
puVar2 = &DAT_004fd458 + (ulong)DAT_00cfdde6 * 0x100120;
translog_buffer_lock(puVar2);
} while (DAT_00cfdde6 != bVar1);
}
return;
}
| |
32,172 | ma_write_init_block_record | eloqsql/storage/maria/ma_blockrec.c | MARIA_RECORD_POS _ma_write_init_block_record(MARIA_HA *info,
const uchar *record)
{
DBUG_ENTER("_ma_write_init_block_record");
calc_record_size(info, record, &info->cur_row);
if (allocate_and_write_block_record(info, record,
&info->cur_row, LSN_ERROR))
DBUG_RETURN(HA_OFFSET_ERROR);
DBUG_RETURN(info->cur_row.lastpos);
} | O0 | c | ma_write_init_block_record:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x80, %rdx
callq 0x76460
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x80, %rdx
movl $0x1, %ecx
callq 0x76a80
cmpb $0x0, %al
je 0x76445
jmp 0x7643b
movq $-0x1, -0x8(%rbp)
jmp 0x76456
jmp 0x76447
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
| _ma_write_init_block_record:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_10]
add rdx, 80h
call calc_record_size
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_10]
add rdx, 80h
mov ecx, 1
call allocate_and_write_block_record
cmp al, 0
jz short loc_76445
jmp short $+2
loc_7643B:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_76456
loc_76445:
jmp short $+2
loc_76447:
mov rax, [rbp+var_10]
mov rax, [rax+98h]
mov [rbp+var_8], rax
loc_76456:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| long long ma_write_init_block_record(long long a1, long long a2)
{
calc_record_size(a1, a2, a1 + 128);
if ( (unsigned __int8)allocate_and_write_block_record(a1, a2, a1 + 128, 1LL) )
return -1LL;
else
return *(_QWORD *)(a1 + 152);
}
| _ma_write_init_block_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,0x80
CALL 0x00176460
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,0x80
MOV ECX,0x1
CALL 0x00176a80
CMP AL,0x0
JZ 0x00176445
JMP 0x0017643b
LAB_0017643b:
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x00176456
LAB_00176445:
JMP 0x00176447
LAB_00176447:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RBP + -0x8],RAX
LAB_00176456:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
int8 _ma_write_init_block_record(long param_1,int8 param_2)
{
char cVar1;
int8 local_10;
calc_record_size(param_1,param_2,param_1 + 0x80);
cVar1 = allocate_and_write_block_record(param_1,param_2,param_1 + 0x80,1);
if (cVar1 == '\0') {
local_10 = *(int8 *)(param_1 + 0x98);
}
else {
local_10 = 0xffffffffffffffff;
}
return local_10;
}
| |
32,173 | stbi__parse_huffman_block(stbi__zbuf*) | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | static int stbi__parse_huffman_block(stbi__zbuf *a)
{
char *zout = a->zout;
for(;;) {
int z = stbi__zhuffman_decode(a, &a->z_length);
if (z < 256) {
if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
if (zout >= a->zout_end) {
if (!stbi__zexpand(a, zout, 1)) return 0;
zout = a->zout;
}
*zout++ = (char) z;
} else {
stbi_uc *p;
int len,dist;
if (z == 256) {
a->zout = zout;
return 1;
}
if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data
z -= 257;
len = stbi__zlength_base[z];
if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
z = stbi__zhuffman_decode(a, &a->z_distance);
if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data
dist = stbi__zdist_base[z];
if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
if (zout + len > a->zout_end) {
if (!stbi__zexpand(a, zout, len)) return 0;
zout = a->zout;
}
p = (stbi_uc *) (zout - dist);
if (dist == 1) { // run of one byte; common in images.
stbi_uc v = *p;
if (len) { do *zout++ = v; while (--len); }
} else {
if (len) { do *zout++ = *p++; while (--len); }
}
}
}
} | O0 | c | stbi__parse_huffman_block(stbi__zbuf*):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x34, %rsi
callq 0x2cba0
movl %eax, 0x1c(%rsp)
cmpl $0x100, 0x1c(%rsp) # imm = 0x100
jge 0x2c676
cmpl $0x0, 0x1c(%rsp)
jge 0x2c614
leaq 0x152850(%rip), %rdi # 0x17ee56
callq 0xddd0
movl %eax, 0x34(%rsp)
jmp 0x2c8b2
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x2c658
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x2c9a0
cmpl $0x0, %eax
jne 0x2c64a
movl $0x0, 0x34(%rsp)
jmp 0x2c8b2
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movl 0x1c(%rsp), %eax
movb %al, %cl
movq 0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rsp)
movb %cl, (%rax)
jmp 0x2c8ad
cmpl $0x100, 0x1c(%rsp) # imm = 0x100
jne 0x2c69b
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movl $0x1, 0x34(%rsp)
jmp 0x2c8b2
cmpl $0x11e, 0x1c(%rsp) # imm = 0x11E
jl 0x2c6ba
leaq 0x1527aa(%rip), %rdi # 0x17ee56
callq 0xddd0
movl %eax, 0x34(%rsp)
jmp 0x2c8b2
movl 0x1c(%rsp), %eax
subl $0x101, %eax # imm = 0x101
movl %eax, 0x1c(%rsp)
movslq 0x1c(%rsp), %rcx
leaq 0x150dfd(%rip), %rax # 0x17d4d0
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movslq 0x1c(%rsp), %rcx
leaq 0x150e6a(%rip), %rax # 0x17d550
cmpl $0x0, (%rax,%rcx,4)
je 0x2c70d
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rcx
leaq 0x150e53(%rip), %rax # 0x17d550
movl (%rax,%rcx,4), %esi
callq 0x2bc80
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x818, %rsi # imm = 0x818
callq 0x2cba0
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jl 0x2c735
cmpl $0x1e, 0x1c(%rsp)
jl 0x2c74a
leaq 0x15271a(%rip), %rdi # 0x17ee56
callq 0xddd0
movl %eax, 0x34(%rsp)
jmp 0x2c8b2
movslq 0x1c(%rsp), %rcx
leaq 0x150e7a(%rip), %rax # 0x17d5d0
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movslq 0x1c(%rsp), %rcx
leaq 0x150ee7(%rip), %rax # 0x17d650
cmpl $0x0, (%rax,%rcx,4)
je 0x2c790
movq 0x28(%rsp), %rdi
movslq 0x1c(%rsp), %rcx
leaq 0x150ed0(%rip), %rax # 0x17d650
movl (%rax,%rcx,4), %esi
callq 0x2bc80
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movslq 0x8(%rsp), %rcx
cmpq %rcx, %rax
jge 0x2c7c0
leaq 0x152801(%rip), %rdi # 0x17efb3
callq 0xddd0
movl %eax, 0x34(%rsp)
jmp 0x2c8b2
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
addq %rcx, %rax
movq 0x28(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0x2c80b
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x2c9a0
cmpl $0x0, %eax
jne 0x2c7fd
movl $0x0, 0x34(%rsp)
jmp 0x2c8b2
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, 0x8(%rsp)
jne 0x2c868
movq 0x10(%rsp), %rax
movb (%rax), %al
movb %al, 0x7(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x2c866
jmp 0x2c83d
movb 0x7(%rsp), %cl
movq 0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rsp)
movb %cl, (%rax)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
jne 0x2c83d
jmp 0x2c866
jmp 0x2c8ab
cmpl $0x0, 0xc(%rsp)
je 0x2c8a9
jmp 0x2c871
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb (%rax), %cl
movq 0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rsp)
movb %cl, (%rax)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, %eax
jne 0x2c871
jmp 0x2c8a9
jmp 0x2c8ab
jmp 0x2c8ad
jmp 0x2c5d7
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| _ZL25stbi__parse_huffman_blockP10stbi__zbuf:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov rax, [rsp+38h+var_10]
mov rax, [rax+18h]
mov [rsp+38h+var_18], rax
loc_2C5D7:
mov rdi, [rsp+38h+var_10]
mov rsi, [rsp+38h+var_10]
add rsi, 34h ; '4'
call _ZL21stbi__zhuffman_decodeP10stbi__zbufP14stbi__zhuffman; stbi__zhuffman_decode(stbi__zbuf *,stbi__zhuffman *)
mov [rsp+38h+var_1C], eax
cmp [rsp+38h+var_1C], 100h
jge short loc_2C676
cmp [rsp+38h+var_1C], 0
jge short loc_2C614
lea rdi, aBadHuffmanCode; "bad huffman code"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov [rsp+38h+var_4], eax
jmp loc_2C8B2
loc_2C614:
mov rax, [rsp+38h+var_18]
mov rcx, [rsp+38h+var_10]
cmp rax, [rcx+28h]
jb short loc_2C658
mov rdi, [rsp+38h+var_10]
mov rsi, [rsp+38h+var_18]
mov edx, 1
call _ZL13stbi__zexpandP10stbi__zbufPci; stbi__zexpand(stbi__zbuf *,char *,int)
cmp eax, 0
jnz short loc_2C64A
mov [rsp+38h+var_4], 0
jmp loc_2C8B2
loc_2C64A:
mov rax, [rsp+38h+var_10]
mov rax, [rax+18h]
mov [rsp+38h+var_18], rax
loc_2C658:
mov eax, [rsp+38h+var_1C]
mov cl, al
mov rax, [rsp+38h+var_18]
mov rdx, rax
add rdx, 1
mov [rsp+38h+var_18], rdx
mov [rax], cl
jmp loc_2C8AD
loc_2C676:
cmp [rsp+38h+var_1C], 100h
jnz short loc_2C69B
mov rcx, [rsp+38h+var_18]
mov rax, [rsp+38h+var_10]
mov [rax+18h], rcx
mov [rsp+38h+var_4], 1
jmp loc_2C8B2
loc_2C69B:
cmp [rsp+38h+var_1C], 11Eh
jl short loc_2C6BA
lea rdi, aBadHuffmanCode; "bad huffman code"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov [rsp+38h+var_4], eax
jmp loc_2C8B2
loc_2C6BA:
mov eax, [rsp+38h+var_1C]
sub eax, 101h
mov [rsp+38h+var_1C], eax
movsxd rcx, [rsp+38h+var_1C]
lea rax, _ZL18stbi__zlength_base; stbi__zlength_base
mov eax, [rax+rcx*4]
mov [rsp+38h+var_2C], eax
movsxd rcx, [rsp+38h+var_1C]
lea rax, _ZL19stbi__zlength_extra; stbi__zlength_extra
cmp dword ptr [rax+rcx*4], 0
jz short loc_2C70D
mov rdi, [rsp+38h+var_10]
movsxd rcx, [rsp+38h+var_1C]
lea rax, _ZL19stbi__zlength_extra; stbi__zlength_extra
mov esi, [rax+rcx*4]
call _ZL14stbi__zreceiveP10stbi__zbufi; stbi__zreceive(stbi__zbuf *,int)
add eax, [rsp+38h+var_2C]
mov [rsp+38h+var_2C], eax
loc_2C70D:
mov rdi, [rsp+38h+var_10]
mov rsi, [rsp+38h+var_10]
add rsi, 818h
call _ZL21stbi__zhuffman_decodeP10stbi__zbufP14stbi__zhuffman; stbi__zhuffman_decode(stbi__zbuf *,stbi__zhuffman *)
mov [rsp+38h+var_1C], eax
cmp [rsp+38h+var_1C], 0
jl short loc_2C735
cmp [rsp+38h+var_1C], 1Eh
jl short loc_2C74A
loc_2C735:
lea rdi, aBadHuffmanCode; "bad huffman code"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov [rsp+38h+var_4], eax
jmp loc_2C8B2
loc_2C74A:
movsxd rcx, [rsp+38h+var_1C]
lea rax, _ZL16stbi__zdist_base; stbi__zdist_base
mov eax, [rax+rcx*4]
mov [rsp+38h+var_30], eax
movsxd rcx, [rsp+38h+var_1C]
lea rax, _ZL17stbi__zdist_extra; stbi__zdist_extra
cmp dword ptr [rax+rcx*4], 0
jz short loc_2C790
mov rdi, [rsp+38h+var_10]
movsxd rcx, [rsp+38h+var_1C]
lea rax, _ZL17stbi__zdist_extra; stbi__zdist_extra
mov esi, [rax+rcx*4]
call _ZL14stbi__zreceiveP10stbi__zbufi; stbi__zreceive(stbi__zbuf *,int)
add eax, [rsp+38h+var_30]
mov [rsp+38h+var_30], eax
loc_2C790:
mov rax, [rsp+38h+var_18]
mov rcx, [rsp+38h+var_10]
mov rcx, [rcx+20h]
sub rax, rcx
movsxd rcx, [rsp+38h+var_30]
cmp rax, rcx
jge short loc_2C7C0
lea rdi, aBadDist; "bad dist"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov [rsp+38h+var_4], eax
jmp loc_2C8B2
loc_2C7C0:
mov rax, [rsp+38h+var_18]
movsxd rcx, [rsp+38h+var_2C]
add rax, rcx
mov rcx, [rsp+38h+var_10]
cmp rax, [rcx+28h]
jbe short loc_2C80B
mov rdi, [rsp+38h+var_10]
mov rsi, [rsp+38h+var_18]
mov edx, [rsp+38h+var_2C]
call _ZL13stbi__zexpandP10stbi__zbufPci; stbi__zexpand(stbi__zbuf *,char *,int)
cmp eax, 0
jnz short loc_2C7FD
mov [rsp+38h+var_4], 0
jmp loc_2C8B2
loc_2C7FD:
mov rax, [rsp+38h+var_10]
mov rax, [rax+18h]
mov [rsp+38h+var_18], rax
loc_2C80B:
mov rax, [rsp+38h+var_18]
movsxd rdx, [rsp+38h+var_30]
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rsp+38h+var_28], rax
cmp [rsp+38h+var_30], 1
jnz short loc_2C868
mov rax, [rsp+38h+var_28]
mov al, [rax]
mov [rsp+38h+var_31], al
cmp [rsp+38h+var_2C], 0
jz short loc_2C866
jmp short $+2
loc_2C83D:
mov cl, [rsp+38h+var_31]
mov rax, [rsp+38h+var_18]
mov rdx, rax
add rdx, 1
mov [rsp+38h+var_18], rdx
mov [rax], cl
mov eax, [rsp+38h+var_2C]
add eax, 0FFFFFFFFh
mov [rsp+38h+var_2C], eax
cmp eax, 0
jnz short loc_2C83D
jmp short $+2
loc_2C866:
jmp short loc_2C8AB
loc_2C868:
cmp [rsp+38h+var_2C], 0
jz short loc_2C8A9
jmp short $+2
loc_2C871:
mov rax, [rsp+38h+var_28]
mov rcx, rax
add rcx, 1
mov [rsp+38h+var_28], rcx
mov cl, [rax]
mov rax, [rsp+38h+var_18]
mov rdx, rax
add rdx, 1
mov [rsp+38h+var_18], rdx
mov [rax], cl
mov eax, [rsp+38h+var_2C]
add eax, 0FFFFFFFFh
mov [rsp+38h+var_2C], eax
cmp eax, 0
jnz short loc_2C871
jmp short $+2
loc_2C8A9:
jmp short $+2
loc_2C8AB:
jmp short $+2
loc_2C8AD:
jmp loc_2C5D7
loc_2C8B2:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| long long stbi__parse_huffman_block(_QWORD *a1)
{
_BYTE *v1; // rax
_BYTE *v2; // rax
char *v3; // rax
char v4; // cl
_BYTE *v5; // rax
char i; // [rsp+7h] [rbp-31h]
int v8; // [rsp+8h] [rbp-30h]
unsigned int v9; // [rsp+Ch] [rbp-2Ch]
char *v10; // [rsp+10h] [rbp-28h]
int v11; // [rsp+1Ch] [rbp-1Ch]
int v12; // [rsp+1Ch] [rbp-1Ch]
signed int v13; // [rsp+1Ch] [rbp-1Ch]
_BYTE *v14; // [rsp+20h] [rbp-18h]
v14 = (_BYTE *)a1[3];
while ( 1 )
{
while ( 1 )
{
v11 = stbi__zhuffman_decode(a1, (char *)a1 + 52);
if ( v11 >= 256 )
break;
if ( v11 < 0 )
return (unsigned int)stbi__err("bad huffman code");
if ( (unsigned long long)v14 >= a1[5] )
{
if ( !(unsigned int)stbi__zexpand(a1, v14, 1LL) )
return 0;
v14 = (_BYTE *)a1[3];
}
v1 = v14++;
*v1 = v11;
}
if ( v11 == 256 )
{
a1[3] = v14;
return 1;
}
if ( v11 >= 286 )
return (unsigned int)stbi__err("bad huffman code");
v12 = v11 - 257;
v9 = stbi__zlength_base[v12];
if ( stbi__zlength_extra[v12] )
v9 += stbi__zreceive((long long)a1, stbi__zlength_extra[v12]);
v13 = stbi__zhuffman_decode(a1, a1 + 259);
if ( (unsigned int)v13 >= 0x1E )
return (unsigned int)stbi__err("bad huffman code");
v8 = stbi__zdist_base[v13];
if ( stbi__zdist_extra[v13] )
v8 += stbi__zreceive((long long)a1, stbi__zdist_extra[v13]);
if ( (long long)&v14[-a1[4]] < v8 )
return (unsigned int)stbi__err("bad dist");
if ( (unsigned long long)&v14[v9] > a1[5] )
break;
LABEL_25:
v10 = &v14[-v8];
if ( v8 == 1 )
{
for ( i = *v10; v9; --v9 )
{
v2 = v14++;
*v2 = i;
}
}
else
{
for ( ; v9; --v9 )
{
v3 = v10++;
v4 = *v3;
v5 = v14++;
*v5 = v4;
}
}
}
if ( (unsigned int)stbi__zexpand(a1, v14, v9) )
{
v14 = (_BYTE *)a1[3];
goto LABEL_25;
}
return 0;
}
| stbi__parse_huffman_block:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x20],RAX
LAB_0012c5d7:
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x28]
ADD RSI,0x34
CALL 0x0012cba0
MOV dword ptr [RSP + 0x1c],EAX
CMP dword ptr [RSP + 0x1c],0x100
JGE 0x0012c676
CMP dword ptr [RSP + 0x1c],0x0
JGE 0x0012c614
LEA RDI,[0x27ee56]
CALL 0x0010ddd0
MOV dword ptr [RSP + 0x34],EAX
JMP 0x0012c8b2
LAB_0012c614:
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
CMP RAX,qword ptr [RCX + 0x28]
JC 0x0012c658
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x20]
MOV EDX,0x1
CALL 0x0012c9a0
CMP EAX,0x0
JNZ 0x0012c64a
MOV dword ptr [RSP + 0x34],0x0
JMP 0x0012c8b2
LAB_0012c64a:
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x20],RAX
LAB_0012c658:
MOV EAX,dword ptr [RSP + 0x1c]
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RSP + 0x20],RDX
MOV byte ptr [RAX],CL
JMP 0x0012c8ad
LAB_0012c676:
CMP dword ptr [RSP + 0x1c],0x100
JNZ 0x0012c69b
MOV RCX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0x18],RCX
MOV dword ptr [RSP + 0x34],0x1
JMP 0x0012c8b2
LAB_0012c69b:
CMP dword ptr [RSP + 0x1c],0x11e
JL 0x0012c6ba
LEA RDI,[0x27ee56]
CALL 0x0010ddd0
MOV dword ptr [RSP + 0x34],EAX
JMP 0x0012c8b2
LAB_0012c6ba:
MOV EAX,dword ptr [RSP + 0x1c]
SUB EAX,0x101
MOV dword ptr [RSP + 0x1c],EAX
MOVSXD RCX,dword ptr [RSP + 0x1c]
LEA RAX,[0x27d4d0]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RSP + 0xc],EAX
MOVSXD RCX,dword ptr [RSP + 0x1c]
LEA RAX,[0x27d550]
CMP dword ptr [RAX + RCX*0x4],0x0
JZ 0x0012c70d
MOV RDI,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0x1c]
LEA RAX,[0x27d550]
MOV ESI,dword ptr [RAX + RCX*0x4]
CALL 0x0012bc80
ADD EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0xc],EAX
LAB_0012c70d:
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x28]
ADD RSI,0x818
CALL 0x0012cba0
MOV dword ptr [RSP + 0x1c],EAX
CMP dword ptr [RSP + 0x1c],0x0
JL 0x0012c735
CMP dword ptr [RSP + 0x1c],0x1e
JL 0x0012c74a
LAB_0012c735:
LEA RDI,[0x27ee56]
CALL 0x0010ddd0
MOV dword ptr [RSP + 0x34],EAX
JMP 0x0012c8b2
LAB_0012c74a:
MOVSXD RCX,dword ptr [RSP + 0x1c]
LEA RAX,[0x27d5d0]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RSP + 0x8],EAX
MOVSXD RCX,dword ptr [RSP + 0x1c]
LEA RAX,[0x27d650]
CMP dword ptr [RAX + RCX*0x4],0x0
JZ 0x0012c790
MOV RDI,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0x1c]
LEA RAX,[0x27d650]
MOV ESI,dword ptr [RAX + RCX*0x4]
CALL 0x0012bc80
ADD EAX,dword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x8],EAX
LAB_0012c790:
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RCX + 0x20]
SUB RAX,RCX
MOVSXD RCX,dword ptr [RSP + 0x8]
CMP RAX,RCX
JGE 0x0012c7c0
LEA RDI,[0x27efb3]
CALL 0x0010ddd0
MOV dword ptr [RSP + 0x34],EAX
JMP 0x0012c8b2
LAB_0012c7c0:
MOV RAX,qword ptr [RSP + 0x20]
MOVSXD RCX,dword ptr [RSP + 0xc]
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x28]
CMP RAX,qword ptr [RCX + 0x28]
JBE 0x0012c80b
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x20]
MOV EDX,dword ptr [RSP + 0xc]
CALL 0x0012c9a0
CMP EAX,0x0
JNZ 0x0012c7fd
MOV dword ptr [RSP + 0x34],0x0
JMP 0x0012c8b2
LAB_0012c7fd:
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x20],RAX
LAB_0012c80b:
MOV RAX,qword ptr [RSP + 0x20]
MOVSXD RDX,dword ptr [RSP + 0x8]
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RSP + 0x10],RAX
CMP dword ptr [RSP + 0x8],0x1
JNZ 0x0012c868
MOV RAX,qword ptr [RSP + 0x10]
MOV AL,byte ptr [RAX]
MOV byte ptr [RSP + 0x7],AL
CMP dword ptr [RSP + 0xc],0x0
JZ 0x0012c866
JMP 0x0012c83d
LAB_0012c83d:
MOV CL,byte ptr [RSP + 0x7]
MOV RAX,qword ptr [RSP + 0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RSP + 0x20],RDX
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,-0x1
MOV dword ptr [RSP + 0xc],EAX
CMP EAX,0x0
JNZ 0x0012c83d
JMP 0x0012c866
LAB_0012c866:
JMP 0x0012c8ab
LAB_0012c868:
CMP dword ptr [RSP + 0xc],0x0
JZ 0x0012c8a9
JMP 0x0012c871
LAB_0012c871:
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0x10],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RSP + 0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RSP + 0x20],RDX
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,-0x1
MOV dword ptr [RSP + 0xc],EAX
CMP EAX,0x0
JNZ 0x0012c871
JMP 0x0012c8a9
LAB_0012c8a9:
JMP 0x0012c8ab
LAB_0012c8ab:
JMP 0x0012c8ad
LAB_0012c8ad:
JMP 0x0012c5d7
LAB_0012c8b2:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
/* stbi__parse_huffman_block(stbi__zbuf*) */
int4 stbi__parse_huffman_block(stbi__zbuf *param_1)
{
char cVar1;
int iVar2;
int4 uVar3;
int iVar4;
char *pcVar5;
int local_30;
int local_2c;
char *local_18;
local_18 = *(char **)(param_1 + 0x18);
while( true ) {
while (iVar2 = stbi__zhuffman_decode(param_1,(stbi__zhuffman *)(param_1 + 0x34)), iVar2 < 0x100)
{
if (iVar2 < 0) {
uVar3 = stbi__err("bad huffman code");
return uVar3;
}
if (*(char **)(param_1 + 0x28) <= local_18) {
iVar4 = stbi__zexpand(param_1,local_18,1);
if (iVar4 == 0) {
return 0;
}
local_18 = *(char **)(param_1 + 0x18);
}
*local_18 = (char)iVar2;
local_18 = local_18 + 1;
}
if (iVar2 == 0x100) {
*(char **)(param_1 + 0x18) = local_18;
return 1;
}
if (0x11d < iVar2) {
uVar3 = stbi__err("bad huffman code");
return uVar3;
}
iVar2 = iVar2 + -0x101;
local_2c = *(int *)(stbi__zlength_base + (long)iVar2 * 4);
if (*(int *)(stbi__zlength_extra + (long)iVar2 * 4) != 0) {
iVar2 = stbi__zreceive(param_1,*(int *)(stbi__zlength_extra + (long)iVar2 * 4));
local_2c = iVar2 + local_2c;
}
iVar2 = stbi__zhuffman_decode(param_1,(stbi__zhuffman *)(param_1 + 0x818));
if ((iVar2 < 0) || (0x1d < iVar2)) {
uVar3 = stbi__err("bad huffman code");
return uVar3;
}
local_30 = *(int *)(stbi__zdist_base + (long)iVar2 * 4);
if (*(int *)(stbi__zdist_extra + (long)iVar2 * 4) != 0) {
iVar2 = stbi__zreceive(param_1,*(int *)(stbi__zdist_extra + (long)iVar2 * 4));
local_30 = iVar2 + local_30;
}
if ((long)local_18 - *(long *)(param_1 + 0x20) < (long)local_30) break;
if (*(char **)(param_1 + 0x28) < local_18 + local_2c) {
iVar2 = stbi__zexpand(param_1,local_18,local_2c);
if (iVar2 == 0) {
return 0;
}
local_18 = *(char **)(param_1 + 0x18);
}
pcVar5 = local_18 + -(long)local_30;
if (local_30 == 1) {
cVar1 = *pcVar5;
for (; local_2c != 0; local_2c = local_2c + -1) {
*local_18 = cVar1;
local_18 = local_18 + 1;
}
}
else {
for (; local_2c != 0; local_2c = local_2c + -1) {
*local_18 = *pcVar5;
pcVar5 = pcVar5 + 1;
local_18 = local_18 + 1;
}
}
}
uVar3 = stbi__err("bad dist");
return uVar3;
}
| |
32,174 | js_std_add_helpers | bluesky950520[P]quickjs/quickjs-libc.c | void js_std_add_helpers(JSContext *ctx, int argc, char **argv)
{
JSValue global_obj, console, args;
int i;
/* XXX: should these global definitions be enumerable? */
global_obj = JS_GetGlobalObject(ctx);
console = JS_NewObject(ctx);
JS_SetPropertyStr(ctx, console, "log",
JS_NewCFunction(ctx, js_print, "log", 1));
JS_SetPropertyStr(ctx, global_obj, "console", console);
/* same methods as the mozilla JS shell */
if (argc >= 0) {
args = JS_NewArray(ctx);
for(i = 0; i < argc; i++) {
JS_SetPropertyUint32(ctx, args, i, JS_NewString(ctx, argv[i]));
}
JS_SetPropertyStr(ctx, global_obj, "scriptArgs", args);
}
JS_SetPropertyStr(ctx, global_obj, "print",
JS_NewCFunction(ctx, js_print, "print", 1));
JS_FreeValue(ctx, global_obj);
} | O2 | c | js_std_add_helpers:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
callq 0x1c430
movq %rax, %r15
movq %rdx, %rbp
movq %rbx, %rdi
callq 0x1b2c9
movq %rax, %r14
movq %rdx, %r13
leaq 0x72a70(%rip), %rsi # 0x82918
movq %rbx, %rdi
callq 0xffa5
movq %rdx, %r9
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
leaq 0x72a55(%rip), %rcx # 0x82918
movq %rax, %r8
callq 0x1f151
leaq 0x72a4a(%rip), %rcx # 0x8291c
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r14, %r8
movl 0x4(%rsp), %r14d
movq %r13, %r9
callq 0x1f151
testl %r14d, %r14d
js 0xff60
movq %rbp, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq %rbx, %rdi
callq 0x1b2bb
movq %rax, %r13
movq %rdx, %rbp
movl %r14d, %r15d
xorl %r14d, %r14d
cmpq %r14, %r15
je 0xff3b
movq (%r12,%r14,8), %rsi
movq %rbx, %rdi
callq 0xf98d
movq %rdx, %r9
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movl %r14d, %ecx
movq %rax, %r8
callq 0x1ece3
incq %r14
jmp 0xff0e
leaq 0x729e2(%rip), %rcx # 0x82924
movq %rbx, %rdi
movq 0x10(%rsp), %r15
movq %r15, %rsi
movq 0x8(%rsp), %rdx
movq %r13, %r8
movq %rbp, %r9
movq %rdx, %rbp
callq 0x1f151
leaq 0x729c8(%rip), %r14 # 0x8292f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xffa5
movq %rdx, %r9
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x1f151
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1801e
| js_std_add_helpers:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdx
mov [rsp+48h+var_44], esi
mov rbx, rdi
call JS_GetGlobalObject
mov r15, rax
mov rbp, rdx
mov rdi, rbx
call JS_NewObject
mov r14, rax
mov r13, rdx
lea rsi, aLog_0; "log"
mov rdi, rbx
call JS_NewCFunction
mov r9, rdx
mov rdi, rbx
mov rsi, r14
mov rdx, r13
lea rcx, aLog_0; "log"
mov r8, rax
call JS_SetPropertyStr
lea rcx, aConsole; "console"
mov rdi, rbx
mov rsi, r15
mov rdx, rbp
mov r8, r14
mov r14d, [rsp+48h+var_44]
mov r9, r13
call JS_SetPropertyStr
test r14d, r14d
js short loc_FF60
mov [rsp+48h+var_40], rbp
mov [rsp+48h+var_38], r15
mov rdi, rbx
call JS_NewArray
mov r13, rax
mov rbp, rdx
mov r15d, r14d
xor r14d, r14d
loc_FF0E:
cmp r15, r14
jz short loc_FF3B
mov rsi, [r12+r14*8]
mov rdi, rbx
call JS_NewString
mov r9, rdx
mov rdi, rbx
mov rsi, r13
mov rdx, rbp
mov ecx, r14d
mov r8, rax
call JS_SetPropertyUint32
inc r14
jmp short loc_FF0E
loc_FF3B:
lea rcx, aScriptargs; "scriptArgs"
mov rdi, rbx
mov r15, [rsp+48h+var_38]
mov rsi, r15
mov rdx, [rsp+48h+var_40]
mov r8, r13
mov r9, rbp
mov rbp, rdx
call JS_SetPropertyStr
loc_FF60:
lea r14, aPrint; "print"
mov rdi, rbx
mov rsi, r14
call JS_NewCFunction
mov r9, rdx
mov rdi, rbx
mov rsi, r15
mov rdx, rbp
mov rcx, r14
mov r8, rax
call JS_SetPropertyStr
mov rdi, rbx
mov rsi, r15
mov rdx, rbp
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_FreeValue
| long long js_std_add_helpers(long long a1, int a2, long long a3)
{
long long GlobalObject; // r15
long long v5; // rdx
long long v6; // rbp
long long v7; // r14
long long v8; // rdx
long long v9; // r13
long long v10; // rax
long long v11; // rdx
long long v12; // r13
long long v13; // rdx
long long v14; // rbp
long long i; // r14
long long v16; // rax
long long v17; // rdx
long long v18; // r9
long long v19; // rax
long long v20; // rdx
long long v22; // [rsp+8h] [rbp-40h]
GlobalObject = JS_GetGlobalObject();
v6 = v5;
v7 = JS_NewObject(a1);
v9 = v8;
v10 = JS_NewCFunction(a1, "log");
JS_SetPropertyStr(a1, v7, v9, "log", v10, v11);
JS_SetPropertyStr(a1, GlobalObject, v6, "console", v7, v9);
if ( a2 >= 0 )
{
v22 = v6;
v12 = JS_NewArray(a1);
v14 = v13;
for ( i = 0LL; a2 != i; ++i )
{
v16 = JS_NewString(a1, *(_QWORD *)(a3 + 8 * i));
JS_SetPropertyUint32(a1, v12, v14, (unsigned int)i, v16, v17);
}
v18 = v14;
v6 = v22;
JS_SetPropertyStr(a1, GlobalObject, v22, "scriptArgs", v12, v18);
}
v19 = JS_NewCFunction(a1, "print");
JS_SetPropertyStr(a1, GlobalObject, v6, "print", v19, v20);
return JS_FreeValue(a1, GlobalObject, v6);
}
| js_std_add_helpers:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDX
MOV dword ptr [RSP + 0x4],ESI
MOV RBX,RDI
CALL 0x0011c430
MOV R15,RAX
MOV RBP,RDX
MOV RDI,RBX
CALL 0x0011b2c9
MOV R14,RAX
MOV R13,RDX
LEA RSI,[0x182918]
MOV RDI,RBX
CALL 0x0010ffa5
MOV R9,RDX
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R13
LEA RCX,[0x182918]
MOV R8,RAX
CALL 0x0011f151
LEA RCX,[0x18291c]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,RBP
MOV R8,R14
MOV R14D,dword ptr [RSP + 0x4]
MOV R9,R13
CALL 0x0011f151
TEST R14D,R14D
JS 0x0010ff60
MOV qword ptr [RSP + 0x8],RBP
MOV qword ptr [RSP + 0x10],R15
MOV RDI,RBX
CALL 0x0011b2bb
MOV R13,RAX
MOV RBP,RDX
MOV R15D,R14D
XOR R14D,R14D
LAB_0010ff0e:
CMP R15,R14
JZ 0x0010ff3b
MOV RSI,qword ptr [R12 + R14*0x8]
MOV RDI,RBX
CALL 0x0010f98d
MOV R9,RDX
MOV RDI,RBX
MOV RSI,R13
MOV RDX,RBP
MOV ECX,R14D
MOV R8,RAX
CALL 0x0011ece3
INC R14
JMP 0x0010ff0e
LAB_0010ff3b:
LEA RCX,[0x182924]
MOV RDI,RBX
MOV R15,qword ptr [RSP + 0x10]
MOV RSI,R15
MOV RDX,qword ptr [RSP + 0x8]
MOV R8,R13
MOV R9,RBP
MOV RBP,RDX
CALL 0x0011f151
LAB_0010ff60:
LEA R14,[0x18292f]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0010ffa5
MOV R9,RDX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,RBP
MOV RCX,R14
MOV R8,RAX
CALL 0x0011f151
MOV RDI,RBX
MOV RSI,R15
MOV RDX,RBP
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0011801e
|
void js_std_add_helpers(int8 param_1,uint param_2,long param_3)
{
int8 uVar1;
int8 uVar2;
ulong uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
auVar4 = JS_GetGlobalObject();
uVar2 = auVar4._8_8_;
uVar1 = auVar4._0_8_;
auVar4 = JS_NewObject(param_1);
auVar5 = JS_NewCFunction(param_1,&DAT_00182918);
JS_SetPropertyStr(param_1,auVar4._0_8_,auVar4._8_8_,&DAT_00182918,auVar5._0_8_,auVar5._8_8_);
JS_SetPropertyStr(param_1,uVar1,uVar2,"console",auVar4._0_8_,auVar4._8_8_);
if (-1 < (int)param_2) {
auVar4 = JS_NewArray(param_1);
for (uVar3 = 0; param_2 != uVar3; uVar3 = uVar3 + 1) {
auVar5 = JS_NewString(param_1,*(int8 *)(param_3 + uVar3 * 8));
JS_SetPropertyUint32
(param_1,auVar4._0_8_,auVar4._8_8_,uVar3 & 0xffffffff,auVar5._0_8_,auVar5._8_8_);
}
JS_SetPropertyStr(param_1,uVar1,uVar2,"scriptArgs",auVar4._0_8_,auVar4._8_8_);
}
auVar4 = JS_NewCFunction(param_1,"print");
JS_SetPropertyStr(param_1,uVar1,uVar2,"print",auVar4._0_8_,auVar4._8_8_);
JS_FreeValue(param_1,uVar1,uVar2);
return;
}
| |
32,175 | adjust_callback(THD*, unsigned long long*) | eloqsql/sql/sql_repl.cc | static my_bool adjust_callback(THD *thd, my_off_t *purge_offset)
{
mysql_mutex_lock(&thd->LOCK_thd_data);
if (auto linfo= thd->current_linfo)
{
/*
Index file offset can be less that purge offset only if
we just started reading the index file. In that case
we have nothing to adjust
*/
if (linfo->index_file_offset < *purge_offset)
linfo->fatal= (linfo->index_file_offset != 0);
else
linfo->index_file_offset-= *purge_offset;
}
mysql_mutex_unlock(&thd->LOCK_thd_data);
return 0;
} | O0 | cpp | adjust_callback(THD*, unsigned long long*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1cf0, %rdi # imm = 0x1CF0
leaq 0xa6fe6c(%rip), %rsi # 0x1396c4e
movl $0x234, %edx # imm = 0x234
callq 0xb44d40
movq -0x8(%rbp), %rax
movq 0x6288(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x926e52
movq -0x18(%rbp), %rax
movq 0x200(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x926e34
movq -0x18(%rbp), %rax
cmpq $0x0, 0x200(%rax)
setne %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x218(%rax)
jmp 0x926e50
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x200(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x200(%rax)
jmp 0x926e52
movq -0x8(%rbp), %rdi
addq $0x1cf0, %rdi # imm = 0x1CF0
callq 0xb44fa0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZL15adjust_callbackP3THDPy:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]
add rdi, 1CF0h
lea rsi, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 234h
call _Z15coro_mutex_lockP14st_mysql_mutexPKcj; coro_mutex_lock(st_mysql_mutex *,char const*,uint)
mov rax, [rbp+var_8]
mov rax, [rax+6288h]
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_926E52
mov rax, [rbp+var_18]
mov rax, [rax+200h]
mov rcx, [rbp+var_10]
cmp rax, [rcx]
jnb short loc_926E34
mov rax, [rbp+var_18]
cmp qword ptr [rax+200h], 0
setnz cl
mov rax, [rbp+var_18]
and cl, 1
mov [rax+218h], cl
jmp short loc_926E50
loc_926E34:
mov rax, [rbp+var_10]
mov rdx, [rax]
mov rax, [rbp+var_18]
mov rcx, [rax+200h]
sub rcx, rdx
mov [rax+200h], rcx
loc_926E50:
jmp short $+2
loc_926E52:
mov rdi, [rbp+var_8]
add rdi, 1CF0h
call _Z17coro_mutex_unlockP14st_mysql_mutex; coro_mutex_unlock(st_mysql_mutex *)
xor eax, eax
add rsp, 20h
pop rbp
retn
| long long adjust_callback(THD *a1, unsigned long long *a2)
{
long long v3; // [rsp+8h] [rbp-18h]
coro_mutex_lock((char *)a1 + 7408, "/workspace/llm4binary/github2025/eloqsql/sql/sql_repl.cc", 564LL);
v3 = *((_QWORD *)a1 + 3153);
if ( v3 )
{
if ( *(_QWORD *)(v3 + 512) >= *a2 )
*(_QWORD *)(v3 + 512) -= *a2;
else
*(_BYTE *)(v3 + 536) = *(_QWORD *)(v3 + 512) != 0LL;
}
coro_mutex_unlock((char *)a1 + 7408);
return 0LL;
}
| vers_select_conds_t:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RDI
ADD RDI,0x10
CALL 0x00926e10
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x20
CALL 0x00926e10
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30
CALL 0x00926e30
ADD RSP,0x10
POP RBP
RET
|
/* vers_select_conds_t::vers_select_conds_t() */
void __thiscall vers_select_conds_t::vers_select_conds_t(vers_select_conds_t *this)
{
Vers_history_point::Vers_history_point((Vers_history_point *)(this + 0x10));
Vers_history_point::Vers_history_point((Vers_history_point *)(this + 0x20));
Lex_cstring_with_compare<Compare_identifiers>::Lex_cstring_with_compare
((Lex_cstring_with_compare<Compare_identifiers> *)(this + 0x30));
return;
}
| |
32,176 | set_dynamic | eloqsql/mysys/array.c | my_bool set_dynamic(DYNAMIC_ARRAY *array, const void *element, uint idx)
{
if (idx >= array->elements)
{
if (idx >= array->max_element && allocate_dynamic(array, idx))
return TRUE;
bzero((uchar*) (array->buffer+array->elements*array->size_of_element),
(idx - array->elements)*array->size_of_element);
array->elements=idx+1;
}
memcpy(array->buffer+(idx * array->size_of_element),element,
(size_t) array->size_of_element);
return FALSE;
} | O0 | c | set_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x6c80a
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x6c7c5
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6c840
movsbl %al, %eax
cmpl $0x0, %eax
je 0x6c7c5
movb $0x1, -0x1(%rbp)
jmp 0x6c837
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x291f0
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %edx
callq 0x292d0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
| set_dynamic:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp eax, [rcx+8]
jb short loc_6C80A
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp eax, [rcx+0Ch]
jb short loc_6C7C5
mov rdi, [rbp+var_10]
mov esi, [rbp+var_1C]
call allocate_dynamic
movsx eax, al
cmp eax, 0
jz short loc_6C7C5
mov [rbp+var_1], 1
jmp short loc_6C837
loc_6C7C5:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
add rdi, rax
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
sub eax, [rcx+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
xor esi, esi
call _memset
mov ecx, [rbp+var_1C]
add ecx, 1
mov rax, [rbp+var_10]
mov [rax+8], ecx
loc_6C80A:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
add rdi, rax
mov rsi, [rbp+var_18]
mov rax, [rbp+var_10]
mov eax, [rax+14h]
mov edx, eax
call _memcpy
mov [rbp+var_1], 0
loc_6C837:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char set_dynamic(long long a1, long long a2, unsigned int a3)
{
if ( a3 < *(_DWORD *)(a1 + 8) )
goto LABEL_6;
if ( a3 < *(_DWORD *)(a1 + 12) || !(unsigned __int8)allocate_dynamic(a1, a3) )
{
memset(
(unsigned int)(*(_DWORD *)(a1 + 20) * *(_DWORD *)(a1 + 8)) + *(_QWORD *)a1,
0LL,
*(_DWORD *)(a1 + 20) * (a3 - *(_DWORD *)(a1 + 8)));
*(_DWORD *)(a1 + 8) = a3 + 1;
LABEL_6:
memcpy(*(_DWORD *)(a1 + 20) * a3 + *(_QWORD *)a1, a2, *(unsigned int *)(a1 + 20));
return 0;
}
return 1;
}
| set_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x8]
JC 0x0016c80a
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0xc]
JC 0x0016c7c5
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x1c]
CALL 0x0016c840
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x0016c7c5
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0016c837
LAB_0016c7c5:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
ADD RDI,RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
SUB EAX,dword ptr [RCX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
XOR ESI,ESI
CALL 0x001291f0
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x8],ECX
LAB_0016c80a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
MOV EDX,EAX
CALL 0x001292d0
MOV byte ptr [RBP + -0x1],0x0
LAB_0016c837:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 set_dynamic(long *param_1,void *param_2,uint param_3)
{
char cVar1;
if (*(uint *)(param_1 + 1) <= param_3) {
if ((*(uint *)((long)param_1 + 0xc) <= param_3) &&
(cVar1 = allocate_dynamic(param_1), cVar1 != '\0')) {
return 1;
}
memset((void *)(*param_1 + (ulong)(uint)((int)param_1[1] * *(int *)((long)param_1 + 0x14))),0,
(ulong)((param_3 - (int)param_1[1]) * *(int *)((long)param_1 + 0x14)));
*(uint *)(param_1 + 1) = param_3 + 1;
}
memcpy((void *)(*param_1 + (ulong)(param_3 * *(int *)((long)param_1 + 0x14))),param_2,
(ulong)*(uint *)((long)param_1 + 0x14));
return 0;
}
| |
32,177 | parse_connection_string | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static int parse_connection_string(MYSQL *mysql, const char *unused __attribute__((unused)),
const char *conn_str, ssize_t len)
{
char *conn_save,
*end, *pos,
*key= NULL, *val= NULL;
my_bool in_curly_brace= 0;
if (len == -1)
len= strlen(conn_str);
/* don't modify original dsn */
conn_save= (char *)malloc(len + 1);
memcpy(conn_save, conn_str, len);
conn_save[len]= 0;
/* start and end */
pos= conn_save;
end= conn_save + len;
while (pos <= end)
{
/* ignore white space, unless it is between curly braces */
if (isspace(*pos) && !in_curly_brace)
{
pos++;
continue;
}
switch (*pos) {
case '{':
if (!key)
goto error;
if (!in_curly_brace)
{
in_curly_brace= 1;
if (pos < end)
{
pos++;
val= pos;
continue;
}
}
break;
case '}':
if (in_curly_brace)
{
if (!key)
goto error;
if (pos < end && *(pos + 1) == '}')
{
memmove(pos, pos + 1, end - pos - 1);
end--;
pos += 2;
continue;
}
if (in_curly_brace)
in_curly_brace= 0;
else
goto error;
*pos++= 0;
continue;
}
break;
case '=':
if (in_curly_brace)
{
pos++;
continue;
}
if (!key)
goto error;
*pos++= 0;
if (pos < end)
val= pos;
continue;
break;
case ';':
if (in_curly_brace)
{
pos++;
continue;
}
if (!key)
goto error;
*pos++= 0;
if (key && strcasecmp(key, "connection") != 0)
_mariadb_set_conf_option(mysql, key, val);
key= val= NULL;
continue;
break;
}
if (!key && *pos)
key= pos;
pos++;
}
if (key && strcasecmp(key, "connection") != 0)
_mariadb_set_conf_option(mysql, key, val);
free(conn_save);
return 0;
error:
my_set_error(mysql, CR_CONNSTR_PARSE_ERROR, SQLSTATE_UNKNOWN, 0, pos - conn_save);
free(conn_save);
return 1;
} | O3 | c | parse_connection_string:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
cmpq $-0x1, %rcx
jne 0x5a329
movq %r14, %rdi
callq 0x3a4c0
movq %rax, %r15
leaq 0x1(%r15), %rdi
callq 0x3aa90
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3a0c0
movb $0x0, (%r12,%r15)
testq %r15, %r15
js 0x5a4e4
movq %rbx, -0x38(%rbp)
addq %r12, %r15
xorl %ebx, %ebx
callq 0x3a180
movq %rax, %r14
xorl %esi, %esi
xorl %r13d, %r13d
movq %r12, -0x30(%rbp)
movq (%r14), %rcx
movsbq (%r12), %rax
testb $0x20, 0x1(%rcx,%rax,2)
sete %cl
testb %bl, %bl
setne %dl
orb %cl, %dl
je 0x5a44e
movzbl %al, %eax
cmpl $0x7a, %eax
jg 0x5a3bf
cmpl $0x3b, %eax
je 0x5a3f8
cmpl $0x3d, %eax
jne 0x5a494
testb %bl, %bl
jne 0x5a3fc
testq %r13, %r13
je 0x5a4ef
movb $0x0, (%r12)
incq %r12
cmpq %r15, %r12
cmovbq %r12, %rsi
jmp 0x5a451
cmpl $0x7d, %eax
je 0x5a406
cmpl $0x7b, %eax
jne 0x5a494
testq %r13, %r13
je 0x5a4ef
testb %bl, %bl
setne %al
cmpq %r15, %r12
setae %cl
orb %al, %cl
movb $0x1, %bl
jne 0x5a4a5
incq %r12
movb $0x1, %bl
movq %r12, %rsi
jmp 0x5a4a8
testb %bl, %bl
je 0x5a455
incq %r12
movb $0x1, %bl
jmp 0x5a4a8
testb %bl, %bl
je 0x5a492
testq %r13, %r13
je 0x5a4ef
cmpq %r15, %r12
jae 0x5a449
cmpb $0x7d, 0x1(%r12)
jne 0x5a449
movq %rsi, %rbx
leaq 0x1(%r12), %rsi
movq %r12, %rdx
notq %rdx
addq %r15, %rdx
movq %r12, %rdi
callq 0x3a1d0
movq %rbx, %rsi
decq %r15
addq $0x2, %r12
jmp 0x5a3ff
movb $0x0, (%r12)
incq %r12
xorl %ebx, %ebx
jmp 0x5a4a8
testq %r13, %r13
je 0x5a4ef
movq %rsi, %rbx
movb $0x0, (%r12)
incq %r12
movq %r13, %rdi
leaq 0x63369(%rip), %rsi # 0xbd7dc
callq 0x3a980
testl %eax, %eax
je 0x5a48b
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x5a538
xorl %r13d, %r13d
xorl %esi, %esi
jmp 0x5a451
xorl %ebx, %ebx
testq %r13, %r13
jne 0x5a4a5
testl %eax, %eax
je 0x5a4a2
movq %r12, %r13
jmp 0x5a4a5
xorl %r13d, %r13d
incq %r12
cmpq %r15, %r12
jbe 0x5a36b
xorl %r14d, %r14d
testq %r13, %r13
je 0x5a4e9
movq %rsi, %rbx
leaq 0x63319(%rip), %rsi # 0xbd7dc
movq %r13, %rdi
callq 0x3a980
testl %eax, %eax
movq -0x30(%rbp), %r12
je 0x5a51e
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x5a538
jmp 0x5a51e
xorl %r14d, %r14d
jmp 0x5a51e
movq -0x30(%rbp), %r12
jmp 0x5a51e
leaq 0x3135ba(%rip), %rax # 0x36dab0
movq (%rax), %rdx
movq -0x30(%rbp), %rax
subq %rax, %r12
movq -0x38(%rbp), %rdi
movl $0x1393, %esi # imm = 0x1393
xorl %ecx, %ecx
movq %r12, %r8
movq %rax, %r12
xorl %eax, %eax
callq 0x5986d
movl $0x1, %r14d
movq %r12, %rdi
callq 0x3a210
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| parse_connection_string:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rcx
mov r14, rdx
mov rbx, rdi
cmp rcx, 0FFFFFFFFFFFFFFFFh
jnz short loc_5A329
mov rdi, r14
call _strlen
mov r15, rax
loc_5A329:
lea rdi, [r15+1]
call _malloc
mov r12, rax
mov rdi, rax
mov rsi, r14
mov rdx, r15
call _memcpy
mov byte ptr [r12+r15], 0
test r15, r15
js loc_5A4E4
mov [rbp+var_38], rbx
add r15, r12
xor ebx, ebx
call ___ctype_b_loc
mov r14, rax
xor esi, esi
xor r13d, r13d
mov [rbp+var_30], r12
loc_5A36B:
mov rcx, [r14]
movsx rax, byte ptr [r12]
test byte ptr [rcx+rax*2+1], 20h
setz cl
test bl, bl
setnz dl
or dl, cl
jz loc_5A44E
movzx eax, al
cmp eax, 7Ah ; 'z'
jg short loc_5A3BF
cmp eax, 3Bh ; ';'
jz short loc_5A3F8
cmp eax, 3Dh ; '='
jnz loc_5A494
test bl, bl
jnz short loc_5A3FC
test r13, r13
jz loc_5A4EF
mov byte ptr [r12], 0
inc r12
cmp r12, r15
cmovb rsi, r12
jmp loc_5A451
loc_5A3BF:
cmp eax, 7Dh ; '}'
jz short loc_5A406
cmp eax, 7Bh ; '{'
jnz loc_5A494
test r13, r13
jz loc_5A4EF
test bl, bl
setnz al
cmp r12, r15
setnb cl
or cl, al
mov bl, 1
jnz loc_5A4A5
inc r12
mov bl, 1
mov rsi, r12
jmp loc_5A4A8
loc_5A3F8:
test bl, bl
jz short loc_5A455
loc_5A3FC:
inc r12
loc_5A3FF:
mov bl, 1
jmp loc_5A4A8
loc_5A406:
test bl, bl
jz loc_5A492
test r13, r13
jz loc_5A4EF
cmp r12, r15
jnb short loc_5A449
cmp byte ptr [r12+1], 7Dh ; '}'
jnz short loc_5A449
mov rbx, rsi
lea rsi, [r12+1]
mov rdx, r12
not rdx
add rdx, r15
mov rdi, r12
call _memmove
mov rsi, rbx
dec r15
add r12, 2
jmp short loc_5A3FF
loc_5A449:
mov byte ptr [r12], 0
loc_5A44E:
inc r12
loc_5A451:
xor ebx, ebx
jmp short loc_5A4A8
loc_5A455:
test r13, r13
jz loc_5A4EF
mov rbx, rsi
mov byte ptr [r12], 0
inc r12
mov rdi, r13
lea rsi, aConnection; "connection"
call _strcasecmp
test eax, eax
jz short loc_5A48B
mov rdi, [rbp+var_38]
mov rsi, r13
mov rdx, rbx
call _mariadb_set_conf_option
loc_5A48B:
xor r13d, r13d
xor esi, esi
jmp short loc_5A451
loc_5A492:
xor ebx, ebx
loc_5A494:
test r13, r13
jnz short loc_5A4A5
test eax, eax
jz short loc_5A4A2
mov r13, r12
jmp short loc_5A4A5
loc_5A4A2:
xor r13d, r13d
loc_5A4A5:
inc r12
loc_5A4A8:
cmp r12, r15
jbe loc_5A36B
xor r14d, r14d
test r13, r13
jz short loc_5A4E9
mov rbx, rsi
lea rsi, aConnection; "connection"
mov rdi, r13
call _strcasecmp
test eax, eax
mov r12, [rbp+var_30]
jz short loc_5A51E
mov rdi, [rbp+var_38]
mov rsi, r13
mov rdx, rbx
call _mariadb_set_conf_option
jmp short loc_5A51E
loc_5A4E4:
xor r14d, r14d
jmp short loc_5A51E
loc_5A4E9:
mov r12, [rbp+var_30]
jmp short loc_5A51E
loc_5A4EF:
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov rax, [rbp+var_30]
sub r12, rax
mov rdi, [rbp+var_38]
mov esi, 1393h
xor ecx, ecx
mov r8, r12
mov r12, rax
xor eax, eax
call my_set_error
mov r14d, 1
loc_5A51E:
mov rdi, r12
call _free
mov eax, r14d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long parse_connection_string(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // r15
unsigned long long v6; // r12
long long v7; // rcx
long long v8; // r8
long long v9; // r9
unsigned long long v10; // r15
char v11; // bl
_QWORD *v12; // r14
unsigned long long v13; // rsi
unsigned long long v14; // r13
long long v15; // rax
bool v16; // zf
unsigned int v17; // r14d
unsigned long long v18; // r8
unsigned long long v20; // [rsp+10h] [rbp-30h]
v4 = a4;
if ( a4 == -1 )
v4 = strlen(a3);
v6 = malloc(v4 + 1);
memcpy(v6, a3, v4, v7, v8, v9);
*(_BYTE *)(v6 + v4) = 0;
if ( v4 < 0 )
{
v17 = 0;
goto LABEL_47;
}
v10 = v6 + v4;
v11 = 0;
v12 = (_QWORD *)__ctype_b_loc();
v13 = 0LL;
v14 = 0LL;
v20 = v6;
do
{
v15 = *(char *)v6;
if ( (*(_BYTE *)(*v12 + 2 * v15 + 1) & 0x20) != 0 && v11 == 0 )
goto LABEL_28;
if ( (unsigned __int8)v15 > 0x7Au )
{
if ( (unsigned __int8)v15 == 125 )
{
if ( v11 )
{
if ( !v14 )
goto LABEL_46;
if ( v6 < v10 && *(_BYTE *)(v6 + 1) == 125 )
{
memmove(v6, v6 + 1, v10 + ~v6);
--v10;
v6 += 2LL;
goto LABEL_21;
}
*(_BYTE *)v6 = 0;
LABEL_28:
++v6;
LABEL_29:
v11 = 0;
continue;
}
v11 = 0;
}
else if ( (unsigned __int8)v15 == 123 )
{
if ( !v14 )
goto LABEL_46;
v16 = v11 == 0 && v6 < v10;
v11 = 1;
if ( v16 )
{
++v6;
v11 = 1;
v13 = v6;
continue;
}
goto LABEL_39;
}
}
else
{
if ( (unsigned __int8)v15 == 59 )
{
if ( v11 )
{
LABEL_20:
++v6;
LABEL_21:
v11 = 1;
continue;
}
if ( !v14 )
{
LABEL_46:
v18 = v6 - v20;
v6 = v20;
my_set_error(a1, 5011, (long long)SQLSTATE_UNKNOWN, 0LL, v18);
v17 = 1;
goto LABEL_47;
}
*(_BYTE *)v6++ = 0;
if ( (unsigned int)strcasecmp(v14, "connection") )
mariadb_set_conf_option(a1, v14, v13);
v14 = 0LL;
v13 = 0LL;
goto LABEL_29;
}
if ( (unsigned __int8)v15 == 61 )
{
if ( v11 )
goto LABEL_20;
if ( !v14 )
goto LABEL_46;
*(_BYTE *)v6++ = 0;
if ( v6 < v10 )
v13 = v6;
goto LABEL_29;
}
}
if ( !v14 )
{
if ( (_BYTE)v15 )
v14 = v6;
else
v14 = 0LL;
}
LABEL_39:
++v6;
}
while ( v6 <= v10 );
v17 = 0;
if ( v14 )
{
v6 = v20;
if ( (unsigned int)strcasecmp(v14, "connection") )
mariadb_set_conf_option(a1, v14, v13);
}
else
{
v6 = v20;
}
LABEL_47:
free(v6);
return v17;
}
| parse_connection_string:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,RCX
MOV R14,RDX
MOV RBX,RDI
CMP RCX,-0x1
JNZ 0x0015a329
MOV RDI,R14
CALL 0x0013a4c0
MOV R15,RAX
LAB_0015a329:
LEA RDI,[R15 + 0x1]
CALL 0x0013aa90
MOV R12,RAX
MOV RDI,RAX
MOV RSI,R14
MOV RDX,R15
CALL 0x0013a0c0
MOV byte ptr [R12 + R15*0x1],0x0
TEST R15,R15
JS 0x0015a4e4
MOV qword ptr [RBP + -0x38],RBX
ADD R15,R12
XOR EBX,EBX
CALL 0x0013a180
MOV R14,RAX
XOR ESI,ESI
XOR R13D,R13D
MOV qword ptr [RBP + -0x30],R12
LAB_0015a36b:
MOV RCX,qword ptr [R14]
MOVSX RAX,byte ptr [R12]
TEST byte ptr [RCX + RAX*0x2 + 0x1],0x20
SETZ CL
TEST BL,BL
SETNZ DL
OR DL,CL
JZ 0x0015a44e
MOVZX EAX,AL
CMP EAX,0x7a
JG 0x0015a3bf
CMP EAX,0x3b
JZ 0x0015a3f8
CMP EAX,0x3d
JNZ 0x0015a494
TEST BL,BL
JNZ 0x0015a3fc
TEST R13,R13
JZ 0x0015a4ef
MOV byte ptr [R12],0x0
INC R12
CMP R12,R15
CMOVC RSI,R12
JMP 0x0015a451
LAB_0015a3bf:
CMP EAX,0x7d
JZ 0x0015a406
CMP EAX,0x7b
JNZ 0x0015a494
TEST R13,R13
JZ 0x0015a4ef
TEST BL,BL
SETNZ AL
CMP R12,R15
SETNC CL
OR CL,AL
MOV BL,0x1
JNZ 0x0015a4a5
INC R12
MOV BL,0x1
MOV RSI,R12
JMP 0x0015a4a8
LAB_0015a3f8:
TEST BL,BL
JZ 0x0015a455
LAB_0015a3fc:
INC R12
LAB_0015a3ff:
MOV BL,0x1
JMP 0x0015a4a8
LAB_0015a406:
TEST BL,BL
JZ 0x0015a492
TEST R13,R13
JZ 0x0015a4ef
CMP R12,R15
JNC 0x0015a449
CMP byte ptr [R12 + 0x1],0x7d
JNZ 0x0015a449
MOV RBX,RSI
LEA RSI,[R12 + 0x1]
MOV RDX,R12
NOT RDX
ADD RDX,R15
MOV RDI,R12
CALL 0x0013a1d0
MOV RSI,RBX
DEC R15
ADD R12,0x2
JMP 0x0015a3ff
LAB_0015a449:
MOV byte ptr [R12],0x0
LAB_0015a44e:
INC R12
LAB_0015a451:
XOR EBX,EBX
JMP 0x0015a4a8
LAB_0015a455:
TEST R13,R13
JZ 0x0015a4ef
MOV RBX,RSI
MOV byte ptr [R12],0x0
INC R12
MOV RDI,R13
LEA RSI,[0x1bd7dc]
CALL 0x0013a980
TEST EAX,EAX
JZ 0x0015a48b
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,R13
MOV RDX,RBX
CALL 0x0015a538
LAB_0015a48b:
XOR R13D,R13D
XOR ESI,ESI
JMP 0x0015a451
LAB_0015a492:
XOR EBX,EBX
LAB_0015a494:
TEST R13,R13
JNZ 0x0015a4a5
TEST EAX,EAX
JZ 0x0015a4a2
MOV R13,R12
JMP 0x0015a4a5
LAB_0015a4a2:
XOR R13D,R13D
LAB_0015a4a5:
INC R12
LAB_0015a4a8:
CMP R12,R15
JBE 0x0015a36b
XOR R14D,R14D
TEST R13,R13
JZ 0x0015a4e9
MOV RBX,RSI
LEA RSI,[0x1bd7dc]
MOV RDI,R13
CALL 0x0013a980
TEST EAX,EAX
MOV R12,qword ptr [RBP + -0x30]
JZ 0x0015a51e
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,R13
MOV RDX,RBX
CALL 0x0015a538
JMP 0x0015a51e
LAB_0015a4e4:
XOR R14D,R14D
JMP 0x0015a51e
LAB_0015a4e9:
MOV R12,qword ptr [RBP + -0x30]
JMP 0x0015a51e
LAB_0015a4ef:
LEA RAX,[0x46dab0]
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
SUB R12,RAX
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,0x1393
XOR ECX,ECX
MOV R8,R12
MOV R12,RAX
XOR EAX,EAX
CALL 0x0015986d
MOV R14D,0x1
LAB_0015a51e:
MOV RDI,R12
CALL 0x0013a210
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
parse_connection_string(int8 param_1,int8 param_2,char *param_3,size_t param_4)
{
byte bVar1;
bool bVar2;
bool bVar3;
int iVar4;
byte *__dest;
ushort **ppuVar5;
byte *pbVar6;
byte *__dest_00;
byte *__s1;
int8 uVar7;
byte *pbVar8;
if (param_4 == 0xffffffffffffffff) {
param_4 = strlen(param_3);
}
__dest = (byte *)malloc(param_4 + 1);
memcpy(__dest,param_3,param_4);
__dest[param_4] = 0;
if ((long)param_4 < 0) {
uVar7 = 0;
}
else {
pbVar8 = __dest + param_4;
bVar2 = false;
ppuVar5 = __ctype_b_loc();
pbVar6 = (byte *)0x0;
__s1 = (byte *)0x0;
__dest_00 = __dest;
do {
bVar1 = *__dest_00;
if (!bVar2 && (*(byte *)((long)*ppuVar5 + (long)(char)bVar1 * 2 + 1) & 0x20) != 0)
goto LAB_0015a451;
if (bVar1 < 0x7b) {
if (bVar1 == 0x3b) {
if (bVar2) {
LAB_0015a3fc:
__dest_00 = __dest_00 + 1;
LAB_0015a3ff:
bVar2 = true;
goto LAB_0015a4a8;
}
if (__s1 == (byte *)0x0) goto LAB_0015a4ef;
*__dest_00 = 0;
iVar4 = strcasecmp((char *)__s1,"connection");
if (iVar4 != 0) {
_mariadb_set_conf_option(param_1,__s1,pbVar6);
}
__s1 = (byte *)0x0;
pbVar6 = (byte *)0x0;
}
else {
if (bVar1 != 0x3d) goto LAB_0015a494;
if (bVar2) goto LAB_0015a3fc;
if (__s1 == (byte *)0x0) goto LAB_0015a4ef;
*__dest_00 = 0;
if (__dest_00 + 1 < pbVar8) {
pbVar6 = __dest_00 + 1;
}
}
LAB_0015a451:
bVar2 = false;
__dest_00 = __dest_00 + 1;
}
else {
if (bVar1 == 0x7d) {
if (bVar2) {
if (__s1 == (byte *)0x0) goto LAB_0015a4ef;
if ((pbVar8 <= __dest_00) || (__dest_00[1] != 0x7d)) {
*__dest_00 = 0;
goto LAB_0015a451;
}
memmove(__dest_00,__dest_00 + 1,(size_t)(pbVar8 + ~(ulong)__dest_00));
pbVar8 = pbVar8 + -1;
__dest_00 = __dest_00 + 2;
goto LAB_0015a3ff;
}
bVar2 = false;
LAB_0015a494:
if ((__s1 == (byte *)0x0) && (__s1 = __dest_00, bVar1 == 0)) {
__s1 = (byte *)0x0;
}
}
else {
if (bVar1 != 0x7b) goto LAB_0015a494;
if (__s1 == (byte *)0x0) {
LAB_0015a4ef:
my_set_error(param_1,0x1393,SQLSTATE_UNKNOWN,0,(long)__dest_00 - (long)__dest);
uVar7 = 1;
goto LAB_0015a51e;
}
bVar3 = !bVar2;
bVar2 = true;
if (__dest_00 < pbVar8 && bVar3) {
pbVar6 = __dest_00 + 1;
bVar2 = true;
__dest_00 = pbVar6;
goto LAB_0015a4a8;
}
}
__dest_00 = __dest_00 + 1;
}
LAB_0015a4a8:
} while (__dest_00 <= pbVar8);
uVar7 = 0;
if ((__s1 != (byte *)0x0) && (iVar4 = strcasecmp((char *)__s1,"connection"), iVar4 != 0)) {
_mariadb_set_conf_option(param_1,__s1,pbVar6);
}
}
LAB_0015a51e:
free(__dest);
return uVar7;
}
| |
32,178 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [39], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const (&) [39], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | hkr04[P]cpp-mcp/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O1 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [39], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const (&) [39], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0xa2b0
addq 0x8(%r14), %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa910
movq %rbx, %rdi
movq %r15, %rsi
callq 0xab20
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xa1c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x518ef
movq (%r12), %rsi
incq %rsi
callq 0xa630
movq %r14, %rdi
callq 0xaa60
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA39_KcS8_EEET_DpOT0_:
push r15
push r14
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
call _strlen
add rax, [r14+8]
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_518EF
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_518EF:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[39],std::string>(
long long a1,
long long a2,
_QWORD *a3)
{
long long v4; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = strlen(a2);
std::string::reserve(a1, a3[1] + v4);
std::string::append(a1, a2);
std::string::_M_append(a1, *a3, a3[1]);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[39],std::__cxx11::string>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
CALL 0x0010a2b0
ADD RAX,qword ptr [R14 + 0x8]
LAB_001518a4:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0010a910
MOV RDI,RBX
MOV RSI,R15
CALL 0x0010ab20
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x0010a1c0
LAB_001518c9:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [39], std::__cxx11::string >(char const (&) [39], std::__cxx11::string&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[39],std::__cxx11::string>
(detail *this,char *param_1,string *param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_1);
/* try { // try from 001518a4 to 001518c8 has its CatchHandler @ 001518d8 */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::_M_append((char *)this,*(ulong *)param_2);
return this;
}
| |
32,179 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [39], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const (&) [39], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | hkr04[P]cpp-mcp/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O2 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [39], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const (&) [39], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x3ffe7
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa970
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x40f50
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xac20
movq %r14, %rdi
callq 0xaac0
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA15_KcRKS8_cEEET_DpOT0_:
push r15
push r14
push r12
push rbx
push rax
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
and qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
mov rsi, rdx
mov rdx, rcx
call _ZN8nlohmann16json_abi_v3_11_36detail13concat_lengthIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcEEEmPKcDpRKT_; nlohmann::json_abi_v3_11_3::detail::concat_length<std::string,char>(char const*,std::string,char const&)
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r12
mov rdx, r15
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA15_KcJRKS8_cETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSF_OSG_DpOT1_
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[15],std::string const&,char>(
long long a1,
long long a2,
long long a3,
long long a4)
{
long long v6; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v6 = nlohmann::json_abi_v3_11_3::detail::concat_length<std::string,char>(a2, a3);
std::string::reserve(a1, v6);
ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA15_KcJRKS8_cETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSF_OSG_DpOT1_(
a1,
a2,
a3,
a4);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[15],std::__cxx11::string_const&,char>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
AND qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
LAB_00140e0f:
MOV RDI,RSI
MOV RSI,RDX
MOV RDX,RCX
CALL 0x0013ffe7
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0010a970
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x00140f50
LAB_00140e39:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [15], std::__cxx11::string const&, char>(char const (&) [15], std::__cxx11::string const&,
char&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[15],std::__cxx11::string_const&,char>
(detail *this,char *param_1,string *param_2,char *param_3)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
/* try { // try from 00140e0f to 00140e38 has its CatchHandler @ 00140e48 */
concat_length<std::__cxx11::string,char>(param_1,param_2,param_3);
std::__cxx11::string::reserve((ulong)this);
_ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA15_KcJRKS8_cETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSF_OSG_DpOT1_
(this,param_1,param_2,param_3);
return this;
}
| |
32,180 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [39], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const (&) [39], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | hkr04[P]cpp-mcp/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O3 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [39], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const (&) [39], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0xa2b0
addq 0x8(%r14), %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa900
movq %rbx, %rdi
movq %r15, %rsi
callq 0xab10
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xa1c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x503eb
movq (%r12), %rsi
incq %rsi
callq 0xa630
movq %r14, %rdi
callq 0xaa50
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA39_KcS8_EEET_DpOT0_:
push r15
push r14
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
call _strlen
add rax, [r14+8]
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_503EB
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_503EB:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[39],std::string>(
long long a1,
long long a2,
_QWORD *a3)
{
long long v4; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = strlen(a2);
std::string::reserve(a1, a3[1] + v4);
std::string::append(a1, a2);
std::string::_M_append(a1, *a3, a3[1]);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[39],std::__cxx11::string>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
CALL 0x0010a2b0
ADD RAX,qword ptr [R14 + 0x8]
LAB_001503a0:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0010a900
MOV RDI,RBX
MOV RSI,R15
CALL 0x0010ab10
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x0010a1c0
LAB_001503c5:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [39], std::__cxx11::string >(char const (&) [39], std::__cxx11::string&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[39],std::__cxx11::string>
(detail *this,char *param_1,string *param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_1);
/* try { // try from 001503a0 to 001503c4 has its CatchHandler @ 001503d4 */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::_M_append((char *)this,*(ulong *)param_2);
return this;
}
| |
32,181 | minja::Value::call(std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&) const | monkey531[P]llama/common/minja.hpp | Value call(const std::shared_ptr<Context> & context, ArgumentsValue & args) const {
if (!callable_) throw std::runtime_error("Value is not callable: " + dump());
return (*callable_)(context, args);
} | O2 | cpp | minja::Value::call(std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq 0x30(%rsi), %rsi
testq %rsi, %rsi
je 0x6d8ec
movq %rdi, %rbx
callq 0x6e84e
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %rbx
movq %rsp, %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x63320
leaq 0x48cd4(%rip), %rsi # 0xb65e2
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x58a46
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x24e10
xorl %ebp, %ebp
movq 0x926bc(%rip), %rsi # 0xffff0
movq 0x92615(%rip), %rdx # 0xfff50
movq %rbx, %rdi
callq 0x24ee0
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x251b8
jmp 0x6d958
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x251b8
testb %bpl, %bpl
jne 0x6d96a
jmp 0x6d972
movq %rax, %r14
movq %rbx, %rdi
callq 0x24670
movq %r14, %rdi
callq 0x24f60
| _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rsi
mov rsi, [rsi+30h]
test rsi, rsi
jz short loc_6D8EC
mov rbx, rdi
call _ZNKSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEEclES6_S8_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::operator()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_6D8EC:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotCall; "Value is not callable: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+58h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6D958
mov r14, rax
mov bpl, 1
loc_6D958:
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_6D96A
jmp short loc_6D972
mov r14, rax
loc_6D96A:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_6D972:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::call(long long a1, long long a2)
{
void *exception; // rbx
_BYTE v4[32]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v5[56]; // [rsp+20h] [rbp-38h] BYREF
if ( !*(_QWORD *)(a2 + 48) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v4, a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v5, (long long)"Value is not callable: ", (long long)v4);
std::runtime_error::runtime_error(exception, v5);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::operator()();
return a1;
}
| call:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
MOV RSI,qword ptr [RSI + 0x30]
TEST RSI,RSI
JZ 0x0016d8ec
MOV RBX,RDI
CALL 0x0016e84e
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_0016d8ec:
PUSH 0x10
POP RDI
CALL 0x00124460
MOV RBX,RAX
LAB_0016d8f7:
MOV RDI,RSP
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x00163320
LAB_0016d907:
LEA RSI,[0x1b65e2]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00158a46
MOV BPL,0x1
LAB_0016d91e:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00124e10
XOR EBP,EBP
MOV RSI,qword ptr [0x001ffff0]
MOV RDX,qword ptr [0x001fff50]
MOV RDI,RBX
CALL 0x00124ee0
|
/* minja::Value::call(std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&) const */
shared_ptr * minja::Value::call(shared_ptr *param_1,ArgumentsValue *param_2)
{
runtime_error *this;
int1 auStack_58 [32];
string local_38 [32];
if (*(ArgumentsValue **)(param_2 + 0x30) != (ArgumentsValue *)0x0) {
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>::
operator()(param_1,*(ArgumentsValue **)(param_2 + 0x30));
return param_1;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016d8f7 to 0016d906 has its CatchHandler @ 0016d967 */
dump_abi_cxx11_((int)auStack_58,SUB81(param_2,0));
/* try { // try from 0016d907 to 0016d91a has its CatchHandler @ 0016d952 */
std::operator+((char *)local_38,(string *)"Value is not callable: ");
/* try { // try from 0016d91e to 0016d942 has its CatchHandler @ 0016d943 */
std::runtime_error::runtime_error(this,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001ffff0,PTR__runtime_error_001fff50);
}
| |
32,182 | stbi__tga_info(stbi__context*, int*, int*, int*) | mnn-tts/MNN/3rd_party/imageHelper/stb_image.h | static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
{
int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
int sz, tga_colormap_type;
stbi__get8(s); // discard Offset
tga_colormap_type = stbi__get8(s); // colormap type
if( tga_colormap_type > 1 ) {
stbi__rewind(s);
return 0; // only RGB or indexed allowed
}
tga_image_type = stbi__get8(s); // image type
if ( tga_colormap_type == 1 ) { // colormapped (paletted) image
if (tga_image_type != 1 && tga_image_type != 9) {
stbi__rewind(s);
return 0;
}
stbi__skip(s,4); // skip index of first colormap entry and number of entries
sz = stbi__get8(s); // check bits per palette color entry
if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
stbi__rewind(s);
return 0;
}
stbi__skip(s,4); // skip image x and y origin
tga_colormap_bpp = sz;
} else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE
if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
stbi__rewind(s);
return 0; // only RGB or grey allowed, +/- RLE
}
stbi__skip(s,9); // skip colormap specification and image x/y origin
tga_colormap_bpp = 0;
}
tga_w = stbi__get16le(s);
if( tga_w < 1 ) {
stbi__rewind(s);
return 0; // test width
}
tga_h = stbi__get16le(s);
if( tga_h < 1 ) {
stbi__rewind(s);
return 0; // test height
}
tga_bits_per_pixel = stbi__get8(s); // bits per pixel
stbi__get8(s); // ignore alpha bits
if (tga_colormap_bpp != 0) {
if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
// when using a colormap, tga_bits_per_pixel is the size of the indexes
// I don't think anything but 8 or 16bit indexes makes sense
stbi__rewind(s);
return 0;
}
tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
} else {
tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
}
if(!tga_comp) {
stbi__rewind(s);
return 0;
}
if (x) *x = tga_w;
if (y) *y = tga_h;
if (comp) *comp = tga_comp;
return 1; // seems to have passed everything
} | O0 | c | stbi__tga_info(stbi__context*, int*, int*, int*):
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x48(%rsp), %rdi
callq 0x11000
movq 0x48(%rsp), %rdi
callq 0x11000
movzbl %al, %eax
movl %eax, 0x10(%rsp)
cmpl $0x1, 0x10(%rsp)
jle 0x1e4d1
movq 0x48(%rsp), %rdi
callq 0x9440
movl $0x0, 0x54(%rsp)
jmp 0x1e71a
movq 0x48(%rsp), %rdi
callq 0x11000
movzbl %al, %eax
movl %eax, 0x20(%rsp)
cmpl $0x1, 0x10(%rsp)
jne 0x1e585
cmpl $0x1, 0x20(%rsp)
je 0x1e512
cmpl $0x9, 0x20(%rsp)
je 0x1e512
movq 0x48(%rsp), %rdi
callq 0x9440
movl $0x0, 0x54(%rsp)
jmp 0x1e71a
movq 0x48(%rsp), %rdi
movl $0x4, %esi
callq 0x11580
movq 0x48(%rsp), %rdi
callq 0x11000
movzbl %al, %eax
movl %eax, 0x14(%rsp)
cmpl $0x8, 0x14(%rsp)
je 0x1e56c
cmpl $0xf, 0x14(%rsp)
je 0x1e56c
cmpl $0x10, 0x14(%rsp)
je 0x1e56c
cmpl $0x18, 0x14(%rsp)
je 0x1e56c
cmpl $0x20, 0x14(%rsp)
je 0x1e56c
movq 0x48(%rsp), %rdi
callq 0x9440
movl $0x0, 0x54(%rsp)
jmp 0x1e71a
movq 0x48(%rsp), %rdi
movl $0x4, %esi
callq 0x11580
movl 0x14(%rsp), %eax
movl %eax, 0x18(%rsp)
jmp 0x1e5cf
cmpl $0x2, 0x20(%rsp)
je 0x1e5b8
cmpl $0x3, 0x20(%rsp)
je 0x1e5b8
cmpl $0xa, 0x20(%rsp)
je 0x1e5b8
cmpl $0xb, 0x20(%rsp)
je 0x1e5b8
movq 0x48(%rsp), %rdi
callq 0x9440
movl $0x0, 0x54(%rsp)
jmp 0x1e71a
movq 0x48(%rsp), %rdi
movl $0x9, %esi
callq 0x11580
movl $0x0, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x19b20
movl %eax, 0x2c(%rsp)
cmpl $0x1, 0x2c(%rsp)
jge 0x1e5fb
movq 0x48(%rsp), %rdi
callq 0x9440
movl $0x0, 0x54(%rsp)
jmp 0x1e71a
movq 0x48(%rsp), %rdi
callq 0x19b20
movl %eax, 0x28(%rsp)
cmpl $0x1, 0x28(%rsp)
jge 0x1e627
movq 0x48(%rsp), %rdi
callq 0x9440
movl $0x0, 0x54(%rsp)
jmp 0x1e71a
movq 0x48(%rsp), %rdi
callq 0x11000
movzbl %al, %eax
movl %eax, 0x1c(%rsp)
movq 0x48(%rsp), %rdi
callq 0x11000
cmpl $0x0, 0x18(%rsp)
je 0x1e683
cmpl $0x8, 0x1c(%rsp)
je 0x1e66e
cmpl $0x10, 0x1c(%rsp)
je 0x1e66e
movq 0x48(%rsp), %rdi
callq 0x9440
movl $0x0, 0x54(%rsp)
jmp 0x1e71a
movl 0x18(%rsp), %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1c500
movl %eax, 0x24(%rsp)
jmp 0x1e6be
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movb $0x1, %al
cmpl $0x3, 0x20(%rsp)
movb %al, 0xf(%rsp)
je 0x1e6a4
cmpl $0xb, 0x20(%rsp)
sete %al
movb %al, 0xf(%rsp)
movl 0x8(%rsp), %edi
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1c500
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x1e6d9
movq 0x48(%rsp), %rdi
callq 0x9440
movl $0x0, 0x54(%rsp)
jmp 0x1e71a
cmpq $0x0, 0x40(%rsp)
je 0x1e6ec
movl 0x2c(%rsp), %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x38(%rsp)
je 0x1e6ff
movl 0x28(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x30(%rsp)
je 0x1e712
movl 0x24(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZL14stbi__tga_infoP13stbi__contextPiS1_S1_:
sub rsp, 58h
mov [rsp+58h+var_10], rdi
mov [rsp+58h+var_18], rsi
mov [rsp+58h+var_20], rdx
mov [rsp+58h+var_28], rcx
mov rdi, [rsp+58h+var_10]
call _ZL10stbi__get8P13stbi__context; stbi__get8(stbi__context *)
mov rdi, [rsp+58h+var_10]
call _ZL10stbi__get8P13stbi__context; stbi__get8(stbi__context *)
movzx eax, al
mov [rsp+58h+var_48], eax
cmp [rsp+58h+var_48], 1
jle short loc_1E4D1
mov rdi, [rsp+58h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov [rsp+58h+var_4], 0
jmp loc_1E71A
loc_1E4D1:
mov rdi, [rsp+58h+var_10]
call _ZL10stbi__get8P13stbi__context; stbi__get8(stbi__context *)
movzx eax, al
mov [rsp+58h+var_38], eax
cmp [rsp+58h+var_48], 1
jnz loc_1E585
cmp [rsp+58h+var_38], 1
jz short loc_1E512
cmp [rsp+58h+var_38], 9
jz short loc_1E512
mov rdi, [rsp+58h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov [rsp+58h+var_4], 0
jmp loc_1E71A
loc_1E512:
mov rdi, [rsp+58h+var_10]
mov esi, 4
call _ZL10stbi__skipP13stbi__contexti; stbi__skip(stbi__context *,int)
mov rdi, [rsp+58h+var_10]
call _ZL10stbi__get8P13stbi__context; stbi__get8(stbi__context *)
movzx eax, al
mov [rsp+58h+var_44], eax
cmp [rsp+58h+var_44], 8
jz short loc_1E56C
cmp [rsp+58h+var_44], 0Fh
jz short loc_1E56C
cmp [rsp+58h+var_44], 10h
jz short loc_1E56C
cmp [rsp+58h+var_44], 18h
jz short loc_1E56C
cmp [rsp+58h+var_44], 20h ; ' '
jz short loc_1E56C
mov rdi, [rsp+58h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov [rsp+58h+var_4], 0
jmp loc_1E71A
loc_1E56C:
mov rdi, [rsp+58h+var_10]
mov esi, 4
call _ZL10stbi__skipP13stbi__contexti; stbi__skip(stbi__context *,int)
mov eax, [rsp+58h+var_44]
mov [rsp+58h+var_40], eax
jmp short loc_1E5CF
loc_1E585:
cmp [rsp+58h+var_38], 2
jz short loc_1E5B8
cmp [rsp+58h+var_38], 3
jz short loc_1E5B8
cmp [rsp+58h+var_38], 0Ah
jz short loc_1E5B8
cmp [rsp+58h+var_38], 0Bh
jz short loc_1E5B8
mov rdi, [rsp+58h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov [rsp+58h+var_4], 0
jmp loc_1E71A
loc_1E5B8:
mov rdi, [rsp+58h+var_10]
mov esi, 9
call _ZL10stbi__skipP13stbi__contexti; stbi__skip(stbi__context *,int)
mov [rsp+58h+var_40], 0
loc_1E5CF:
mov rdi, [rsp+58h+var_10]
call _ZL13stbi__get16leP13stbi__context; stbi__get16le(stbi__context *)
mov [rsp+58h+var_2C], eax
cmp [rsp+58h+var_2C], 1
jge short loc_1E5FB
mov rdi, [rsp+58h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov [rsp+58h+var_4], 0
jmp loc_1E71A
loc_1E5FB:
mov rdi, [rsp+58h+var_10]
call _ZL13stbi__get16leP13stbi__context; stbi__get16le(stbi__context *)
mov [rsp+58h+var_30], eax
cmp [rsp+58h+var_30], 1
jge short loc_1E627
mov rdi, [rsp+58h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov [rsp+58h+var_4], 0
jmp loc_1E71A
loc_1E627:
mov rdi, [rsp+58h+var_10]
call _ZL10stbi__get8P13stbi__context; stbi__get8(stbi__context *)
movzx eax, al
mov [rsp+58h+var_3C], eax
mov rdi, [rsp+58h+var_10]
call _ZL10stbi__get8P13stbi__context; stbi__get8(stbi__context *)
cmp [rsp+58h+var_40], 0
jz short loc_1E683
cmp [rsp+58h+var_3C], 8
jz short loc_1E66E
cmp [rsp+58h+var_3C], 10h
jz short loc_1E66E
mov rdi, [rsp+58h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov [rsp+58h+var_4], 0
jmp loc_1E71A
loc_1E66E:
mov edi, [rsp+58h+var_40]; int
xor esi, esi; int
xor eax, eax
mov edx, eax; int *
call _ZL18stbi__tga_get_compiiPi; stbi__tga_get_comp(int,int,int *)
mov [rsp+58h+var_34], eax
jmp short loc_1E6BE
loc_1E683:
mov eax, [rsp+58h+var_3C]
mov [rsp+58h+var_50], eax
mov al, 1
cmp [rsp+58h+var_38], 3
mov [rsp+58h+var_49], al
jz short loc_1E6A4
cmp [rsp+58h+var_38], 0Bh
setz al
mov [rsp+58h+var_49], al
loc_1E6A4:
mov edi, [rsp+58h+var_50]; int
mov al, [rsp+58h+var_49]
and al, 1
movzx esi, al; int
xor eax, eax
mov edx, eax; int *
call _ZL18stbi__tga_get_compiiPi; stbi__tga_get_comp(int,int,int *)
mov [rsp+58h+var_34], eax
loc_1E6BE:
cmp [rsp+58h+var_34], 0
jnz short loc_1E6D9
mov rdi, [rsp+58h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov [rsp+58h+var_4], 0
jmp short loc_1E71A
loc_1E6D9:
cmp [rsp+58h+var_18], 0
jz short loc_1E6EC
mov ecx, [rsp+58h+var_2C]
mov rax, [rsp+58h+var_18]
mov [rax], ecx
loc_1E6EC:
cmp [rsp+58h+var_20], 0
jz short loc_1E6FF
mov ecx, [rsp+58h+var_30]
mov rax, [rsp+58h+var_20]
mov [rax], ecx
loc_1E6FF:
cmp [rsp+58h+var_28], 0
jz short loc_1E712
mov ecx, [rsp+58h+var_34]
mov rax, [rsp+58h+var_28]
mov [rax], ecx
loc_1E712:
mov [rsp+58h+var_4], 1
loc_1E71A:
mov eax, [rsp+58h+var_4]
add rsp, 58h
retn
| long long stbi__tga_info(_QWORD *a1, int *a2, int *a3, _DWORD *a4)
{
bool v5; // [rsp+Fh] [rbp-49h]
unsigned int v6; // [rsp+10h] [rbp-48h]
int v7; // [rsp+14h] [rbp-44h]
int v8; // [rsp+18h] [rbp-40h]
int v9; // [rsp+1Ch] [rbp-3Ch]
int v10; // [rsp+20h] [rbp-38h]
int comp; // [rsp+24h] [rbp-34h]
int v12; // [rsp+28h] [rbp-30h]
int v13; // [rsp+2Ch] [rbp-2Ch]
stbi__get8((long long)a1);
v6 = (unsigned __int8)stbi__get8((long long)a1);
if ( v6 > 1 )
goto LABEL_29;
v10 = (unsigned __int8)stbi__get8((long long)a1);
if ( v6 == 1 )
{
if ( v10 != 1 && v10 != 9 )
goto LABEL_29;
stbi__skip((long long)a1, 4);
v7 = (unsigned __int8)stbi__get8((long long)a1);
if ( v7 != 8 && v7 != 15 && v7 != 16 && v7 != 24 && v7 != 32 )
goto LABEL_29;
stbi__skip((long long)a1, 4);
v8 = v7;
}
else
{
if ( v10 != 2 && v10 != 3 && v10 != 10 && v10 != 11 )
goto LABEL_29;
stbi__skip((long long)a1, 9);
v8 = 0;
}
v13 = stbi__get16le((long long)a1);
if ( v13 < 1 )
goto LABEL_29;
v12 = stbi__get16le((long long)a1);
if ( v12 < 1 )
goto LABEL_29;
v9 = (unsigned __int8)stbi__get8((long long)a1);
stbi__get8((long long)a1);
if ( v8 )
{
if ( v9 != 8 && v9 != 16 )
goto LABEL_29;
comp = stbi__tga_get_comp(v8, 0, 0LL);
}
else
{
v5 = 1;
if ( v10 != 3 )
v5 = v10 == 11;
comp = stbi__tga_get_comp(v9, v5, 0LL);
}
if ( !comp )
{
LABEL_29:
stbi__rewind(a1);
return 0;
}
if ( a2 )
*a2 = v13;
if ( a3 )
*a3 = v12;
if ( a4 )
*a4 = comp;
return 1;
}
| stbi__tga_info:
SUB RSP,0x58
MOV qword ptr [RSP + 0x48],RDI
MOV qword ptr [RSP + 0x40],RSI
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x30],RCX
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00111000
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00111000
MOVZX EAX,AL
MOV dword ptr [RSP + 0x10],EAX
CMP dword ptr [RSP + 0x10],0x1
JLE 0x0011e4d1
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00109440
MOV dword ptr [RSP + 0x54],0x0
JMP 0x0011e71a
LAB_0011e4d1:
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00111000
MOVZX EAX,AL
MOV dword ptr [RSP + 0x20],EAX
CMP dword ptr [RSP + 0x10],0x1
JNZ 0x0011e585
CMP dword ptr [RSP + 0x20],0x1
JZ 0x0011e512
CMP dword ptr [RSP + 0x20],0x9
JZ 0x0011e512
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00109440
MOV dword ptr [RSP + 0x54],0x0
JMP 0x0011e71a
LAB_0011e512:
MOV RDI,qword ptr [RSP + 0x48]
MOV ESI,0x4
CALL 0x00111580
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00111000
MOVZX EAX,AL
MOV dword ptr [RSP + 0x14],EAX
CMP dword ptr [RSP + 0x14],0x8
JZ 0x0011e56c
CMP dword ptr [RSP + 0x14],0xf
JZ 0x0011e56c
CMP dword ptr [RSP + 0x14],0x10
JZ 0x0011e56c
CMP dword ptr [RSP + 0x14],0x18
JZ 0x0011e56c
CMP dword ptr [RSP + 0x14],0x20
JZ 0x0011e56c
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00109440
MOV dword ptr [RSP + 0x54],0x0
JMP 0x0011e71a
LAB_0011e56c:
MOV RDI,qword ptr [RSP + 0x48]
MOV ESI,0x4
CALL 0x00111580
MOV EAX,dword ptr [RSP + 0x14]
MOV dword ptr [RSP + 0x18],EAX
JMP 0x0011e5cf
LAB_0011e585:
CMP dword ptr [RSP + 0x20],0x2
JZ 0x0011e5b8
CMP dword ptr [RSP + 0x20],0x3
JZ 0x0011e5b8
CMP dword ptr [RSP + 0x20],0xa
JZ 0x0011e5b8
CMP dword ptr [RSP + 0x20],0xb
JZ 0x0011e5b8
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00109440
MOV dword ptr [RSP + 0x54],0x0
JMP 0x0011e71a
LAB_0011e5b8:
MOV RDI,qword ptr [RSP + 0x48]
MOV ESI,0x9
CALL 0x00111580
MOV dword ptr [RSP + 0x18],0x0
LAB_0011e5cf:
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00119b20
MOV dword ptr [RSP + 0x2c],EAX
CMP dword ptr [RSP + 0x2c],0x1
JGE 0x0011e5fb
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00109440
MOV dword ptr [RSP + 0x54],0x0
JMP 0x0011e71a
LAB_0011e5fb:
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00119b20
MOV dword ptr [RSP + 0x28],EAX
CMP dword ptr [RSP + 0x28],0x1
JGE 0x0011e627
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00109440
MOV dword ptr [RSP + 0x54],0x0
JMP 0x0011e71a
LAB_0011e627:
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00111000
MOVZX EAX,AL
MOV dword ptr [RSP + 0x1c],EAX
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00111000
CMP dword ptr [RSP + 0x18],0x0
JZ 0x0011e683
CMP dword ptr [RSP + 0x1c],0x8
JZ 0x0011e66e
CMP dword ptr [RSP + 0x1c],0x10
JZ 0x0011e66e
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00109440
MOV dword ptr [RSP + 0x54],0x0
JMP 0x0011e71a
LAB_0011e66e:
MOV EDI,dword ptr [RSP + 0x18]
XOR ESI,ESI
XOR EAX,EAX
MOV EDX,EAX
CALL 0x0011c500
MOV dword ptr [RSP + 0x24],EAX
JMP 0x0011e6be
LAB_0011e683:
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x8],EAX
MOV AL,0x1
CMP dword ptr [RSP + 0x20],0x3
MOV byte ptr [RSP + 0xf],AL
JZ 0x0011e6a4
CMP dword ptr [RSP + 0x20],0xb
SETZ AL
MOV byte ptr [RSP + 0xf],AL
LAB_0011e6a4:
MOV EDI,dword ptr [RSP + 0x8]
MOV AL,byte ptr [RSP + 0xf]
AND AL,0x1
MOVZX ESI,AL
XOR EAX,EAX
MOV EDX,EAX
CALL 0x0011c500
MOV dword ptr [RSP + 0x24],EAX
LAB_0011e6be:
CMP dword ptr [RSP + 0x24],0x0
JNZ 0x0011e6d9
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00109440
MOV dword ptr [RSP + 0x54],0x0
JMP 0x0011e71a
LAB_0011e6d9:
CMP qword ptr [RSP + 0x40],0x0
JZ 0x0011e6ec
MOV ECX,dword ptr [RSP + 0x2c]
MOV RAX,qword ptr [RSP + 0x40]
MOV dword ptr [RAX],ECX
LAB_0011e6ec:
CMP qword ptr [RSP + 0x38],0x0
JZ 0x0011e6ff
MOV ECX,dword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x38]
MOV dword ptr [RAX],ECX
LAB_0011e6ff:
CMP qword ptr [RSP + 0x30],0x0
JZ 0x0011e712
MOV ECX,dword ptr [RSP + 0x24]
MOV RAX,qword ptr [RSP + 0x30]
MOV dword ptr [RAX],ECX
LAB_0011e712:
MOV dword ptr [RSP + 0x54],0x1
LAB_0011e71a:
MOV EAX,dword ptr [RSP + 0x54]
ADD RSP,0x58
RET
|
/* stbi__tga_info(stbi__context*, int*, int*, int*) */
int4 stbi__tga_info(stbi__context *param_1,int *param_2,int *param_3,int *param_4)
{
byte bVar1;
char cVar2;
int iVar3;
int iVar4;
uint uVar5;
bool local_49;
uint local_40;
int local_34;
int4 local_4;
stbi__get8(param_1);
bVar1 = stbi__get8(param_1);
if (1 < bVar1) {
stbi__rewind(param_1);
return 0;
}
cVar2 = stbi__get8(param_1);
if (bVar1 == 1) {
if ((cVar2 != '\x01') && (cVar2 != '\t')) {
stbi__rewind(param_1);
return 0;
}
stbi__skip(param_1,4);
bVar1 = stbi__get8(param_1);
local_40 = (uint)bVar1;
if (((local_40 != 8) && (local_40 != 0xf)) &&
((local_40 != 0x10 && ((local_40 != 0x18 && (local_40 != 0x20)))))) {
stbi__rewind(param_1);
return 0;
}
stbi__skip(param_1,4);
}
else {
if ((((cVar2 != '\x02') && (cVar2 != '\x03')) && (cVar2 != '\n')) && (cVar2 != '\v')) {
stbi__rewind(param_1);
return 0;
}
stbi__skip(param_1,9);
local_40 = 0;
}
iVar3 = stbi__get16le(param_1);
if (iVar3 < 1) {
stbi__rewind(param_1);
local_4 = 0;
}
else {
iVar4 = stbi__get16le(param_1);
if (iVar4 < 1) {
stbi__rewind(param_1);
local_4 = 0;
}
else {
bVar1 = stbi__get8(param_1);
uVar5 = (uint)bVar1;
stbi__get8(param_1);
if (local_40 == 0) {
local_49 = cVar2 == '\x03' || cVar2 == '\v';
local_34 = stbi__tga_get_comp(uVar5,(uint)local_49,(int *)0x0);
}
else {
if ((uVar5 != 8) && (uVar5 != 0x10)) {
stbi__rewind(param_1);
return 0;
}
local_34 = stbi__tga_get_comp(local_40,0,(int *)0x0);
}
if (local_34 == 0) {
stbi__rewind(param_1);
local_4 = 0;
}
else {
if (param_2 != (int *)0x0) {
*param_2 = iVar3;
}
if (param_3 != (int *)0x0) {
*param_3 = iVar4;
}
if (param_4 != (int *)0x0) {
*param_4 = local_34;
}
local_4 = 1;
}
}
}
return local_4;
}
| |
32,183 | map_find_record | bluesky950520[P]quickjs/quickjs.c | static JSMapRecord *map_find_record(JSContext *ctx, JSMapState *s,
JSValue key)
{
struct list_head *el;
JSMapRecord *mr;
uint32_t h;
h = map_hash_key(ctx, key) & (s->hash_size - 1);
list_for_each(el, &s->hash_table[h]) {
mr = list_entry(el, JSMapRecord, hash_link);
if (js_same_value_zero(ctx, mr->key, key))
return mr;
}
return NULL;
} | O1 | c | map_find_record:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x4750b
movl 0x28(%r15), %ebp
decl %ebp
andl %eax, %ebp
movq 0x20(%r15), %rax
shlq $0x4, %rbp
movq 0x8(%rax,%rbp), %r13
addq %rbp, %rax
cmpq %rax, %r13
je 0x474f0
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rdx
movq %r12, %rdi
movq %r14, %rcx
movq %rbx, %r8
callq 0x3a341
testl %eax, %eax
jne 0x474f5
movq 0x8(%r13), %r13
movq 0x20(%r15), %rax
jmp 0x474c4
xorl %r13d, %r13d
jmp 0x474f9
addq $-0x20, %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| map_find_record:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
mov rdi, rdx
mov rsi, rcx
call map_hash_key
mov ebp, [r15+28h]
dec ebp
and ebp, eax
mov rax, [r15+20h]
shl rbp, 4
mov r13, [rax+rbp+8]
loc_474C4:
add rax, rbp
cmp r13, rax
jz short loc_474F0
mov rsi, [r13+10h]
mov rdx, [r13+18h]
mov rdi, r12
mov rcx, r14
mov r8, rbx
call js_same_value_zero
test eax, eax
jnz short loc_474F5
mov r13, [r13+8]
mov rax, [r15+20h]
jmp short loc_474C4
loc_474F0:
xor r13d, r13d
jmp short loc_474F9
loc_474F5:
add r13, 0FFFFFFFFFFFFFFE0h
loc_474F9:
mov rax, r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long map_find_record(long long a1, long long a2, _DWORD *a3, long long a4, double a5, __m128d a6)
{
long long v8; // rbp
long long v9; // rax
long long v10; // rbp
long long v11; // r13
v8 = (unsigned int)map_hash_key(a3, a4) & (*(_DWORD *)(a2 + 40) - 1);
v9 = *(_QWORD *)(a2 + 32);
v10 = 16 * v8;
v11 = *(_QWORD *)(v9 + v10 + 8);
while ( 1 )
{
if ( v11 == v10 + v9 )
return 0LL;
if ( js_same_value_zero(a1, *(_DWORD **)(v11 + 16), *(_QWORD *)(v11 + 24), a3, a4, a5, a6) )
break;
v11 = *(_QWORD *)(v11 + 8);
v9 = *(_QWORD *)(a2 + 32);
}
return v11 - 32;
}
| |||
32,184 | map_find_record | bluesky950520[P]quickjs/quickjs.c | static JSMapRecord *map_find_record(JSContext *ctx, JSMapState *s,
JSValue key)
{
struct list_head *el;
JSMapRecord *mr;
uint32_t h;
h = map_hash_key(ctx, key) & (s->hash_size - 1);
list_for_each(el, &s->hash_table[h]) {
mr = list_entry(el, JSMapRecord, hash_link);
if (js_same_value_zero(ctx, mr->key, key))
return mr;
}
return NULL;
} | O2 | c | map_find_record:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x3da58
movl 0x28(%r15), %ebp
decl %ebp
andl %eax, %ebp
movq 0x20(%r15), %rax
shlq $0x4, %rbp
leaq (%rax,%rbp), %r13
addq $0x8, %r13
movq (%r13), %r13
addq %rbp, %rax
cmpq %rax, %r13
je 0x3d877
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rdx
movq %r12, %rdi
movq %r14, %rcx
movq %rbx, %r8
callq 0x33456
testl %eax, %eax
jne 0x3d87b
addq $0x8, %r13
movq 0x20(%r15), %rax
jmp 0x3d847
xorl %eax, %eax
jmp 0x3d882
addq $-0x20, %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| map_find_record:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
mov rdi, rdx
mov rsi, rcx
call map_hash_key
mov ebp, [r15+28h]
dec ebp
and ebp, eax
mov rax, [r15+20h]
shl rbp, 4
lea r13, [rax+rbp]
add r13, 8
loc_3D847:
mov r13, [r13+0]
add rax, rbp
cmp r13, rax
jz short loc_3D877
mov rsi, [r13+10h]
mov rdx, [r13+18h]
mov rdi, r12
mov rcx, r14
mov r8, rbx
call js_same_value_zero
test eax, eax
jnz short loc_3D87B
add r13, 8
mov rax, [r15+20h]
jmp short loc_3D847
loc_3D877:
xor eax, eax
jmp short loc_3D882
loc_3D87B:
add r13, 0FFFFFFFFFFFFFFE0h
mov rax, r13
loc_3D882:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long map_find_record(long long a1, long long a2, _DWORD *a3, long long a4, __m128d a5)
{
long long v7; // rbp
long long v8; // rax
long long v9; // rbp
long long *v10; // r13
long long v11; // r13
v7 = (unsigned int)map_hash_key(a3, a4) & (*(_DWORD *)(a2 + 40) - 1);
v8 = *(_QWORD *)(a2 + 32);
v9 = 16 * v7;
v10 = (long long *)(v8 + v9 + 8);
while ( 1 )
{
v11 = *v10;
if ( v11 == v9 + v8 )
return 0LL;
if ( (unsigned int)js_same_value_zero(a1, *(_DWORD **)(v11 + 16), *(_QWORD *)(v11 + 24), a3, a4, a5) )
break;
v10 = (long long *)(v11 + 8);
v8 = *(_QWORD *)(a2 + 32);
}
return v11 - 32;
}
| map_find_record:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
MOV RDI,RDX
MOV RSI,RCX
CALL 0x0013da58
MOV EBP,dword ptr [R15 + 0x28]
DEC EBP
AND EBP,EAX
MOV RAX,qword ptr [R15 + 0x20]
SHL RBP,0x4
LEA R13,[RAX + RBP*0x1]
ADD R13,0x8
LAB_0013d847:
MOV R13,qword ptr [R13]
ADD RAX,RBP
CMP R13,RAX
JZ 0x0013d877
MOV RSI,qword ptr [R13 + 0x10]
MOV RDX,qword ptr [R13 + 0x18]
MOV RDI,R12
MOV RCX,R14
MOV R8,RBX
CALL 0x00133456
TEST EAX,EAX
JNZ 0x0013d87b
ADD R13,0x8
MOV RAX,qword ptr [R15 + 0x20]
JMP 0x0013d847
LAB_0013d877:
XOR EAX,EAX
JMP 0x0013d882
LAB_0013d87b:
ADD R13,-0x20
MOV RAX,R13
LAB_0013d882:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long map_find_record(int8 param_1,long param_2,int8 param_3,int8 param_4)
{
long lVar1;
uint uVar2;
int iVar3;
long lVar4;
long lVar5;
uVar2 = map_hash_key(param_3,param_4);
lVar4 = *(long *)(param_2 + 0x20);
lVar5 = (ulong)(*(int *)(param_2 + 0x28) - 1U & uVar2) * 0x10;
lVar1 = lVar4 + lVar5;
while( true ) {
lVar1 = *(long *)(lVar1 + 8);
if (lVar1 == lVar4 + lVar5) {
return 0;
}
iVar3 = js_same_value_zero(param_1,*(int8 *)(lVar1 + 0x10),*(int8 *)(lVar1 + 0x18),
param_3,param_4);
if (iVar3 != 0) break;
lVar4 = *(long *)(param_2 + 0x20);
}
return lVar1 + -0x20;
}
| |
32,185 | ma_save_pack_length | eloqsql/storage/maria/ma_packrec.c | uint _ma_save_pack_length(uint version, uchar *block_buff, ulong length)
{
if (length < 254)
{
*(uchar*) block_buff= (uchar) length;
return 1;
}
if (length <= 65535)
{
*(uchar*) block_buff=254;
int2store(block_buff+1,(uint) length);
return 3;
}
*(uchar*) block_buff=255;
if (version == 1) /* old format */
{
DBUG_ASSERT(length <= 0xFFFFFF);
int3store(block_buff + 1, (ulong) length);
return 4;
}
else
{
int4store(block_buff + 1, (ulong) length);
return 5;
}
} | O0 | c | ma_save_pack_length:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0xfe, -0x18(%rbp)
jae 0x4bd71
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4be10
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
ja 0x4bda5
movq -0x10(%rbp), %rax
movb $-0x2, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x4be10
movq -0x10(%rbp), %rax
movb $-0x1, (%rax)
cmpl $0x1, -0x8(%rbp)
jne 0x4bdef
jmp 0x4bdb4
jmp 0x4bdb6
jmp 0x4bdb8
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movl $0x4, -0x4(%rbp)
jmp 0x4be10
jmp 0x4bdf1
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_save_pack_length:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
cmp [rbp+var_18], 0FEh
jnb short loc_4BD71
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov [rbp+var_4], 1
jmp loc_4BE10
loc_4BD71:
cmp [rbp+var_18], 0FFFFh
ja short loc_4BDA5
mov rax, [rbp+var_10]
mov byte ptr [rax], 0FEh
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov cx, ax
mov rax, [rbp+var_20]
mov [rax], cx
mov [rbp+var_4], 3
jmp short loc_4BE10
loc_4BDA5:
mov rax, [rbp+var_10]
mov byte ptr [rax], 0FFh
cmp [rbp+var_8], 1
jnz short loc_4BDEF
jmp short $+2
loc_4BDB4:
jmp short $+2
loc_4BDB6:
jmp short $+2
loc_4BDB8:
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+1], cl
mov rax, [rbp+var_18]
shr eax, 8
mov cl, al
mov rax, [rbp+var_10]
mov [rax+2], cl
mov rax, [rbp+var_18]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_10]
mov [rax+3], cl
mov [rbp+var_4], 4
jmp short loc_4BE10
loc_4BDEF:
jmp short $+2
loc_4BDF1:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov ecx, eax
mov rax, [rbp+var_28]
mov [rax], ecx
mov [rbp+var_4], 5
loc_4BE10:
mov eax, [rbp+var_4]
pop rbp
retn
| long long ma_save_pack_length(int a1, long long a2, unsigned long long a3)
{
if ( a3 >= 0xFE )
{
if ( a3 > 0xFFFF )
{
*(_BYTE *)a2 = -1;
if ( a1 == 1 )
{
*(_WORD *)(a2 + 1) = a3;
*(_BYTE *)(a2 + 3) = BYTE2(a3);
return 4;
}
else
{
*(_DWORD *)(a2 + 1) = a3;
return 5;
}
}
else
{
*(_BYTE *)a2 = -2;
*(_WORD *)(a2 + 1) = a3;
return 3;
}
}
else
{
*(_BYTE *)a2 = a3;
return 1;
}
}
| _ma_save_pack_length:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
CMP qword ptr [RBP + -0x18],0xfe
JNC 0x0014bd71
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014be10
LAB_0014bd71:
CMP qword ptr [RBP + -0x18],0xffff
JA 0x0014bda5
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0xfe
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x20]
MOV word ptr [RAX],CX
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0014be10
LAB_0014bda5:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0xff
CMP dword ptr [RBP + -0x8],0x1
JNZ 0x0014bdef
JMP 0x0014bdb4
LAB_0014bdb4:
JMP 0x0014bdb6
LAB_0014bdb6:
JMP 0x0014bdb8
LAB_0014bdb8:
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x3],CL
MOV dword ptr [RBP + -0x4],0x4
JMP 0x0014be10
LAB_0014bdef:
JMP 0x0014bdf1
LAB_0014bdf1:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0x5
LAB_0014be10:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 _ma_save_pack_length(int param_1,int1 *param_2,ulong param_3)
{
int4 local_c;
if (param_3 < 0xfe) {
*param_2 = (char)param_3;
local_c = 1;
}
else if (param_3 < 0x10000) {
*param_2 = 0xfe;
*(short *)(param_2 + 1) = (short)param_3;
local_c = 3;
}
else {
*param_2 = 0xff;
if (param_1 == 1) {
param_2[1] = (char)param_3;
param_2[2] = (char)(param_3 >> 8);
param_2[3] = (char)(param_3 >> 0x10);
local_c = 4;
}
else {
*(int *)(param_2 + 1) = (int)param_3;
local_c = 5;
}
}
return local_c;
}
| |
32,186 | ma_save_pack_length | eloqsql/storage/maria/ma_packrec.c | uint _ma_save_pack_length(uint version, uchar *block_buff, ulong length)
{
if (length < 254)
{
*(uchar*) block_buff= (uchar) length;
return 1;
}
if (length <= 65535)
{
*(uchar*) block_buff=254;
int2store(block_buff+1,(uint) length);
return 3;
}
*(uchar*) block_buff=255;
if (version == 1) /* old format */
{
DBUG_ASSERT(length <= 0xFFFFFF);
int3store(block_buff + 1, (ulong) length);
return 4;
}
else
{
int4store(block_buff + 1, (ulong) length);
return 5;
}
} | O3 | c | ma_save_pack_length:
pushq %rbp
movq %rsp, %rbp
cmpq $0xfd, %rdx
ja 0x45133
movb %dl, (%rsi)
movl $0x1, %eax
jmp 0x4516d
cmpq $0xffff, %rdx # imm = 0xFFFF
ja 0x4514a
movb $-0x2, (%rsi)
movw %dx, 0x1(%rsi)
movl $0x3, %eax
jmp 0x4516d
movb $-0x1, (%rsi)
cmpl $0x1, %edi
jne 0x45165
movb %dl, 0x1(%rsi)
movb %dh, 0x2(%rsi)
shrl $0x10, %edx
movb %dl, 0x3(%rsi)
movl $0x4, %eax
jmp 0x4516d
movl %edx, 0x1(%rsi)
movl $0x5, %eax
popq %rbp
retq
| _ma_save_pack_length:
push rbp
mov rbp, rsp
cmp rdx, 0FDh
ja short loc_45133
mov [rsi], dl
mov eax, 1
jmp short loc_4516D
loc_45133:
cmp rdx, 0FFFFh
ja short loc_4514A
mov byte ptr [rsi], 0FEh
mov [rsi+1], dx
mov eax, 3
jmp short loc_4516D
loc_4514A:
mov byte ptr [rsi], 0FFh
cmp edi, 1
jnz short loc_45165
mov [rsi+1], dl
mov [rsi+2], dh
shr edx, 10h
mov [rsi+3], dl
mov eax, 4
jmp short loc_4516D
loc_45165:
mov [rsi+1], edx
mov eax, 5
loc_4516D:
pop rbp
retn
| long long ma_save_pack_length(int a1, long long a2, unsigned long long a3)
{
if ( a3 > 0xFD )
{
if ( a3 > 0xFFFF )
{
*(_BYTE *)a2 = -1;
if ( a1 == 1 )
{
*(_WORD *)(a2 + 1) = a3;
*(_BYTE *)(a2 + 3) = BYTE2(a3);
return 4LL;
}
else
{
*(_DWORD *)(a2 + 1) = a3;
return 5LL;
}
}
else
{
*(_BYTE *)a2 = -2;
*(_WORD *)(a2 + 1) = a3;
return 3LL;
}
}
else
{
*(_BYTE *)a2 = a3;
return 1LL;
}
}
| _ma_save_pack_length:
PUSH RBP
MOV RBP,RSP
CMP RDX,0xfd
JA 0x00145133
MOV byte ptr [RSI],DL
MOV EAX,0x1
JMP 0x0014516d
LAB_00145133:
CMP RDX,0xffff
JA 0x0014514a
MOV byte ptr [RSI],0xfe
MOV word ptr [RSI + 0x1],DX
MOV EAX,0x3
JMP 0x0014516d
LAB_0014514a:
MOV byte ptr [RSI],0xff
CMP EDI,0x1
JNZ 0x00145165
MOV byte ptr [RSI + 0x1],DL
MOV byte ptr [RSI + 0x2],DH
SHR EDX,0x10
MOV byte ptr [RSI + 0x3],DL
MOV EAX,0x4
JMP 0x0014516d
LAB_00145165:
MOV dword ptr [RSI + 0x1],EDX
MOV EAX,0x5
LAB_0014516d:
POP RBP
RET
|
int8 _ma_save_pack_length(int param_1,int1 *param_2,ulong param_3)
{
int8 uVar1;
if (param_3 < 0xfe) {
*param_2 = (char)param_3;
uVar1 = 1;
}
else if (param_3 < 0x10000) {
*param_2 = 0xfe;
*(short *)(param_2 + 1) = (short)param_3;
uVar1 = 3;
}
else {
*param_2 = 0xff;
if (param_1 == 1) {
param_2[1] = (char)param_3;
param_2[2] = (char)(param_3 >> 8);
param_2[3] = (char)(param_3 >> 0x10);
uVar1 = 4;
}
else {
*(int *)(param_2 + 1) = (int)param_3;
uVar1 = 5;
}
}
return uVar1;
}
| |
32,187 | my_xml_error_lineno | eloqsql/strings/xml.c | uint my_xml_error_lineno(MY_XML_PARSER *p)
{
uint res=0;
const char *s;
for (s=p->beg ; s<p->cur; s++)
{
if (s[0] == '\n')
res++;
}
return res;
} | O0 | c | my_xml_error_lineno:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x130(%rcx), %rax
jae 0x78614
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x78604
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x78606
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x785de
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| my_xml_error_lineno:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], 0
mov rax, [rbp+var_8]
mov rax, [rax+128h]
mov [rbp+var_18], rax
loc_785DE:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
cmp rax, [rcx+130h]
jnb short loc_78614
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
cmp eax, 0Ah
jnz short loc_78604
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
loc_78604:
jmp short $+2
loc_78606:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_785DE
loc_78614:
mov eax, [rbp+var_C]
pop rbp
retn
| long long my_xml_error_lineno(long long a1)
{
_BYTE *i; // [rsp+0h] [rbp-18h]
unsigned int v3; // [rsp+Ch] [rbp-Ch]
v3 = 0;
for ( i = *(_BYTE **)(a1 + 296); (unsigned long long)i < *(_QWORD *)(a1 + 304); ++i )
{
if ( *i == 10 )
++v3;
}
return v3;
}
| my_xml_error_lineno:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x128]
MOV qword ptr [RBP + -0x18],RAX
LAB_001785de:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x130]
JNC 0x00178614
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0xa
JNZ 0x00178604
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
LAB_00178604:
JMP 0x00178606
LAB_00178606:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001785de
LAB_00178614:
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET
|
int my_xml_error_lineno(long param_1)
{
char *local_20;
int local_14;
local_14 = 0;
for (local_20 = *(char **)(param_1 + 0x128); local_20 < *(char **)(param_1 + 0x130);
local_20 = local_20 + 1) {
if (*local_20 == '\n') {
local_14 = local_14 + 1;
}
}
return local_14;
}
| |
32,188 | cxangles::vectors(glm::vec<3, float, (glm::qualifier)0> const&, glm::vec<3, float, (glm::qualifier)0>*, glm::vec<3, float, (glm::qualifier)0>*, glm::vec<3, float, (glm::qualifier)0>*) | untodesu[P]voxelius/core/angles.hh | inline void cxangles::vectors(const glm::fvec3 &angles, glm::fvec3 *forward, glm::fvec3 *right, glm::fvec3 *up)
{
if(!forward && !right && !up) {
// There's no point in figuring out
// direction vectors if nothing is passed
// in the function to store that stuff in
return;
}
const auto pcv = glm::cos(angles);
const auto psv = glm::sin(angles);
const auto ncv = pcv * (-1.0f);
const auto nsv = psv * (-1.0f);
if(forward) {
forward->x = pcv.x * nsv.y;
forward->y = psv.x;
forward->z = pcv.x * ncv.y;
}
if(right) {
right->x = pcv.z * pcv.y;
right->y = psv.z * pcv.y;
right->z = nsv.y;
}
if(up) {
up->x = psv.x * psv.y * pcv.z + ncv.y * psv.z;
up->y = pcv.x * pcv.z;
up->z = nsv.x * ncv.y * pcv.z + psv.y * psv.z;
}
} | O0 | cpp | cxangles::vectors(glm::vec<3, float, (glm::qualifier)0> const&, glm::vec<3, float, (glm::qualifier)0>*, glm::vec<3, float, (glm::qualifier)0>*, glm::vec<3, float, (glm::qualifier)0>*):
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x40165
cmpq $0x0, -0x18(%rbp)
jne 0x40165
cmpq $0x0, -0x20(%rbp)
jne 0x40165
jmp 0x40311
movq -0x8(%rbp), %rdi
callq 0x57420
movss %xmm1, -0x38(%rbp)
movlpd %xmm0, -0x40(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x57480
movss %xmm1, -0x58(%rbp)
movlpd %xmm0, -0x60(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movss 0x32a6b9(%rip), %xmm0 # 0x36a86c
movss %xmm0, -0xb4(%rbp)
callq 0x574e0
movaps %xmm0, %xmm2
movss -0xb4(%rbp), %xmm0
movaps %xmm2, -0xb0(%rbp)
movaps %xmm1, %xmm2
movaps -0xb0(%rbp), %xmm1
movss %xmm2, -0x78(%rbp)
movlpd %xmm1, -0x80(%rbp)
movl -0x78(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x574e0
movss %xmm1, -0x98(%rbp)
movlpd %xmm0, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x8c(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0x84(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x40264
movss -0x30(%rbp), %xmm0
mulss -0x88(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movss -0x50(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x30(%rbp), %xmm0
mulss -0x6c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x402a1
movss -0x28(%rbp), %xmm0
mulss -0x2c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movss -0x48(%rbp), %xmm0
mulss -0x2c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x88(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x40311
movss -0x50(%rbp), %xmm0
mulss -0x4c(%rbp), %xmm0
movss -0x28(%rbp), %xmm2
movss -0x6c(%rbp), %xmm1
mulss -0x48(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movss -0x30(%rbp), %xmm0
mulss -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x8c(%rbp), %xmm0
mulss -0x6c(%rbp), %xmm0
movss -0x28(%rbp), %xmm2
movss -0x4c(%rbp), %xmm1
mulss -0x48(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x8(%rax)
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZN8cxangles7vectorsERKN3glm3vecILi3EfLNS0_9qualifierE0EEEPS3_S6_S6_:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
cmp [rbp+var_10], 0
jnz short loc_40165
cmp [rbp+var_18], 0
jnz short loc_40165
cmp [rbp+var_20], 0
jnz short loc_40165
jmp loc_40311
loc_40165:
mov rdi, [rbp+var_8]
call _ZN3glm3cosILi3EfLNS_9qualifierE0EEENS_3vecIXT_ET0_XT1_EEERKS4_; glm::cos<3,float,(glm::qualifier)0>(glm::vec<3,float,(glm::qualifier)0> const&)
movss [rbp+var_38], xmm1
movlpd [rbp+var_40], xmm0
mov eax, [rbp+var_38]
mov [rbp+var_28], eax
mov rax, [rbp+var_40]
mov [rbp+var_30], rax
mov rdi, [rbp+var_8]
call _ZN3glm3sinILi3EfLNS_9qualifierE0EEENS_3vecIXT_ET0_XT1_EEERKS4_; glm::sin<3,float,(glm::qualifier)0>(glm::vec<3,float,(glm::qualifier)0> const&)
movss [rbp+var_58], xmm1
movlpd [rbp+var_60], xmm0
mov eax, [rbp+var_58]
mov [rbp+var_48], eax
mov rax, [rbp+var_60]
mov [rbp+var_50], rax
lea rdi, [rbp+var_30]
movss xmm0, cs:flt_36A86C
movss [rbp+var_B4], xmm0
call _ZN3glmmlIfLNS_9qualifierE0EEENS_3vecILi3ET_XT0_EEERKS4_S3_; glm::operator*<float,(glm::qualifier)0>(glm::vec<3,float,(glm::qualifier)0> const&,float)
movaps xmm2, xmm0
movss xmm0, [rbp+var_B4]
movaps [rbp+var_B0], xmm2
movaps xmm2, xmm1
movaps xmm1, [rbp+var_B0]
movss [rbp+var_78], xmm2
movlpd [rbp+var_80], xmm1
mov eax, [rbp+var_78]
mov [rbp+var_68], eax
mov rax, [rbp+var_80]
mov [rbp+var_70], rax
lea rdi, [rbp+var_50]
call _ZN3glmmlIfLNS_9qualifierE0EEENS_3vecILi3ET_XT0_EEERKS4_S3_; glm::operator*<float,(glm::qualifier)0>(glm::vec<3,float,(glm::qualifier)0> const&,float)
movss [rbp+var_98], xmm1
movlpd [rbp+var_A0], xmm0
mov rax, [rbp+var_A0]
mov [rbp+var_8C], rax
mov eax, [rbp+var_98]
mov [rbp+var_84], eax
cmp [rbp+var_10], 0
jz short loc_40264
movss xmm0, dword ptr [rbp+var_30]
mulss xmm0, dword ptr [rbp+var_8C+4]
mov rax, [rbp+var_10]
movss dword ptr [rax], xmm0
movss xmm0, dword ptr [rbp+var_50]
mov rax, [rbp+var_10]
movss dword ptr [rax+4], xmm0
movss xmm0, dword ptr [rbp+var_30]
mulss xmm0, dword ptr [rbp+var_70+4]
mov rax, [rbp+var_10]
movss dword ptr [rax+8], xmm0
loc_40264:
cmp [rbp+var_18], 0
jz short loc_402A1
movss xmm0, [rbp+var_28]
mulss xmm0, dword ptr [rbp+var_30+4]
mov rax, [rbp+var_18]
movss dword ptr [rax], xmm0
movss xmm0, [rbp+var_48]
mulss xmm0, dword ptr [rbp+var_30+4]
mov rax, [rbp+var_18]
movss dword ptr [rax+4], xmm0
movss xmm0, dword ptr [rbp+var_8C+4]
mov rax, [rbp+var_18]
movss dword ptr [rax+8], xmm0
loc_402A1:
cmp [rbp+var_20], 0
jz short loc_40311
movss xmm0, dword ptr [rbp+var_50]
mulss xmm0, dword ptr [rbp+var_50+4]
movss xmm2, [rbp+var_28]
movss xmm1, dword ptr [rbp+var_70+4]
mulss xmm1, [rbp+var_48]
mulss xmm0, xmm2
addss xmm0, xmm1
mov rax, [rbp+var_20]
movss dword ptr [rax], xmm0
movss xmm0, dword ptr [rbp+var_30]
mulss xmm0, [rbp+var_28]
mov rax, [rbp+var_20]
movss dword ptr [rax+4], xmm0
movss xmm0, dword ptr [rbp+var_8C]
mulss xmm0, dword ptr [rbp+var_70+4]
movss xmm2, [rbp+var_28]
movss xmm1, dword ptr [rbp+var_50+4]
mulss xmm1, [rbp+var_48]
mulss xmm0, xmm2
addss xmm0, xmm1
mov rax, [rbp+var_20]
movss dword ptr [rax+8], xmm0
loc_40311:
add rsp, 0C0h
pop rbp
retn
| float * cxangles::vectors(long long a1, long long a2, long long a3, float *a4, double a5, float a6)
{
double v6; // xmm2_8
float *result; // rax
double v8; // [rsp+34h] [rbp-8Ch]
double v9; // [rsp+70h] [rbp-50h] BYREF
float v10; // [rsp+78h] [rbp-48h]
double v11; // [rsp+80h] [rbp-40h]
float v12; // [rsp+88h] [rbp-38h]
double v13; // [rsp+90h] [rbp-30h] BYREF
float v14; // [rsp+98h] [rbp-28h]
float *v15; // [rsp+A0h] [rbp-20h]
long long v16; // [rsp+A8h] [rbp-18h]
long long v17; // [rsp+B0h] [rbp-10h]
long long v18; // [rsp+B8h] [rbp-8h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
if ( a2 || v16 || v15 )
{
v12 = a6;
v11 = glm::cos<3,float,(glm::qualifier)0>(v18);
v14 = a6;
v13 = v11;
v10 = a6;
v9 = glm::sin<3,float,(glm::qualifier)0>(v18);
v6 = glm::operator*<float,(glm::qualifier)0>(&v13);
v8 = glm::operator*<float,(glm::qualifier)0>(&v9);
result = (float *)LODWORD(v6);
if ( v17 )
{
*(float *)v17 = *(float *)&v13 * *((float *)&v8 + 1);
*(_DWORD *)(v17 + 4) = LODWORD(v9);
result = (float *)v17;
*(float *)(v17 + 8) = *(float *)&v13 * *((float *)&v6 + 1);
}
if ( v16 )
{
*(float *)v16 = v14 * *((float *)&v13 + 1);
*(float *)(v16 + 4) = v10 * *((float *)&v13 + 1);
result = (float *)v16;
*(_DWORD *)(v16 + 8) = HIDWORD(v8);
}
if ( v15 )
{
*v15 = (float)((float)(*(float *)&v9 * *((float *)&v9 + 1)) * v14) + (float)(*((float *)&v6 + 1) * v10);
v15[1] = *(float *)&v13 * v14;
result = v15;
v15[2] = (float)((float)(*(float *)&v8 * *((float *)&v6 + 1)) * v14) + (float)(*((float *)&v9 + 1) * v10);
}
}
return result;
}
| vectors:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x00140165
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x00140165
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x00140165
JMP 0x00140311
LAB_00140165:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00157420
MOVSS dword ptr [RBP + -0x38],XMM1
MOVLPD qword ptr [RBP + -0x40],XMM0
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00157480
MOVSS dword ptr [RBP + -0x58],XMM1
MOVLPD qword ptr [RBP + -0x60],XMM0
MOV EAX,dword ptr [RBP + -0x58]
MOV dword ptr [RBP + -0x48],EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x50],RAX
LEA RDI,[RBP + -0x30]
MOVSS XMM0,dword ptr [0x0046a86c]
MOVSS dword ptr [RBP + -0xb4],XMM0
CALL 0x001574e0
MOVAPS XMM2,XMM0
MOVSS XMM0,dword ptr [RBP + -0xb4]
MOVAPS xmmword ptr [RBP + -0xb0],XMM2
MOVAPS XMM2,XMM1
MOVAPS XMM1,xmmword ptr [RBP + -0xb0]
MOVSS dword ptr [RBP + -0x78],XMM2
MOVLPD qword ptr [RBP + -0x80],XMM1
MOV EAX,dword ptr [RBP + -0x78]
MOV dword ptr [RBP + -0x68],EAX
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x70],RAX
LEA RDI,[RBP + -0x50]
CALL 0x001574e0
MOVSS dword ptr [RBP + -0x98],XMM1
MOVLPD qword ptr [RBP + -0xa0],XMM0
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x8c],RAX
MOV EAX,dword ptr [RBP + -0x98]
MOV dword ptr [RBP + -0x84],EAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00140264
MOVSS XMM0,dword ptr [RBP + -0x30]
MULSS XMM0,dword ptr [RBP + -0x88]
MOV RAX,qword ptr [RBP + -0x10]
MOVSS dword ptr [RAX],XMM0
MOVSS XMM0,dword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x10]
MOVSS dword ptr [RAX + 0x4],XMM0
MOVSS XMM0,dword ptr [RBP + -0x30]
MULSS XMM0,dword ptr [RBP + -0x6c]
MOV RAX,qword ptr [RBP + -0x10]
MOVSS dword ptr [RAX + 0x8],XMM0
LAB_00140264:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001402a1
MOVSS XMM0,dword ptr [RBP + -0x28]
MULSS XMM0,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS dword ptr [RAX],XMM0
MOVSS XMM0,dword ptr [RBP + -0x48]
MULSS XMM0,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS dword ptr [RAX + 0x4],XMM0
MOVSS XMM0,dword ptr [RBP + -0x88]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS dword ptr [RAX + 0x8],XMM0
LAB_001402a1:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00140311
MOVSS XMM0,dword ptr [RBP + -0x50]
MULSS XMM0,dword ptr [RBP + -0x4c]
MOVSS XMM2,dword ptr [RBP + -0x28]
MOVSS XMM1,dword ptr [RBP + -0x6c]
MULSS XMM1,dword ptr [RBP + -0x48]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOV RAX,qword ptr [RBP + -0x20]
MOVSS dword ptr [RAX],XMM0
MOVSS XMM0,dword ptr [RBP + -0x30]
MULSS XMM0,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOVSS dword ptr [RAX + 0x4],XMM0
MOVSS XMM0,dword ptr [RBP + -0x8c]
MULSS XMM0,dword ptr [RBP + -0x6c]
MOVSS XMM2,dword ptr [RBP + -0x28]
MOVSS XMM1,dword ptr [RBP + -0x4c]
MULSS XMM1,dword ptr [RBP + -0x48]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOV RAX,qword ptr [RBP + -0x20]
MOVSS dword ptr [RAX + 0x8],XMM0
LAB_00140311:
ADD RSP,0xc0
POP RBP
RET
|
/* cxangles::vectors(glm::vec<3, float, (glm::qualifier)0> const&, glm::vec<3, float,
(glm::qualifier)0>*, glm::vec<3, float, (glm::qualifier)0>*, glm::vec<3, float,
(glm::qualifier)0>*) */
void cxangles::vectors(vec *param_1,vec *param_2,vec *param_3,vec *param_4)
{
float extraout_XMM0_Db;
int8 uVar1;
float in_XMM1_Da;
int8 local_58;
float local_50;
int8 local_48;
int8 local_38;
float local_30;
vec *local_28;
vec *local_20;
vec *local_18;
vec *local_10;
float fVar2;
if (((param_2 != (vec *)0x0) || (param_3 != (vec *)0x0)) || (param_4 != (vec *)0x0)) {
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_38 = glm::cos<3,float,(glm::qualifier)0>(param_1);
local_30 = in_XMM1_Da;
local_48 = local_38;
local_58 = glm::sin<3,float,(glm::qualifier)0>(local_10);
fVar2 = DAT_0046a86c;
local_50 = in_XMM1_Da;
glm::operator*((vec *)&local_38,DAT_0046a86c);
uVar1 = glm::operator*((vec *)&local_58,fVar2);
fVar2 = (float)((ulong)uVar1 >> 0x20);
if (local_18 != (vec *)0x0) {
*(float *)local_18 = (float)local_38 * fVar2;
*(float *)(local_18 + 4) = (float)local_58;
*(float *)(local_18 + 8) = (float)local_38 * extraout_XMM0_Db;
}
if (local_20 != (vec *)0x0) {
*(float *)local_20 = local_30 * local_38._4_4_;
*(float *)(local_20 + 4) = local_50 * local_38._4_4_;
*(float *)(local_20 + 8) = fVar2;
}
if (local_28 != (vec *)0x0) {
*(float *)local_28 = (float)local_58 * local_58._4_4_ * local_30 + extraout_XMM0_Db * local_50
;
*(float *)(local_28 + 4) = (float)local_38 * local_30;
*(float *)(local_28 + 8) =
(float)uVar1 * extraout_XMM0_Db * local_30 + local_58._4_4_ * local_50;
}
}
return;
}
| |
32,189 | LefDefParser::lefwEndMacro(char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwEndMacro(const char *macroName)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_MACRO_START &&
lefwState != LEFW_MACRO)
return LEFW_BAD_ORDER;
if (!macroName || macroName == 0 || *macroName == 0)
return LEFW_BAD_DATA;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) "END %s\n\n", macroName);
else
fprintf(lefwFile, "END %s\n\n", macroName);
lefwLines++;
lefwState = LEFW_MACRO_END;
return LEFW_OK;
} | O3 | cpp | LefDefParser::lefwEndMacro(char const*):
pushq %rbx
movq %rdi, %rdx
leaq 0x119d4(%rip), %rax # 0x24e00
movq (%rax), %rdi
testq %rdi, %rdi
je 0x13474
leaq 0x11c15(%rip), %rbx # 0x25050
movl (%rbx), %ecx
cmpl $0x21, %ecx
je 0x1344c
movl $0x2, %eax
cmpl $0x9, %ecx
jne 0x1349a
movl $0x3, %eax
testq %rdx, %rdx
je 0x1349a
cmpb $0x0, (%rdx)
je 0x1349a
cmpb $0x1, 0x11c8a(%rip) # 0x250ec
jne 0x1347b
leaq 0x7f70(%rip), %rsi # 0x1b3db
xorl %eax, %eax
callq 0x18c35
jmp 0x13489
movl $0x1, %eax
jmp 0x1349a
leaq 0x7f59(%rip), %rsi # 0x1b3db
xorl %eax, %eax
callq 0x10f0
leaq 0x11bbc(%rip), %rax # 0x2504c
incl (%rax)
movl $0x57, (%rbx)
xorl %eax, %eax
popq %rbx
retq
| _ZN12LefDefParser12lefwEndMacroEPKc:
push rbx
mov rdx, rdi
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
test rdi, rdi
jz short loc_13474
lea rbx, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov ecx, [rbx]
cmp ecx, 21h ; '!'
jz short loc_1344C
mov eax, 2
cmp ecx, 9
jnz short loc_1349A
loc_1344C:
mov eax, 3
test rdx, rdx
jz short loc_1349A
cmp byte ptr [rdx], 0
jz short loc_1349A
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_1347B
lea rsi, aEndS+3; "END %s\n\n"
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_13489
loc_13474:
mov eax, 1
jmp short loc_1349A
loc_1347B:
lea rsi, aEndS+3; "END %s\n\n"
xor eax, eax
call _fprintf
loc_13489:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
mov dword ptr [rbx], 57h ; 'W'
xor eax, eax
loc_1349A:
pop rbx
retn
| long long LefDefParser::lefwEndMacro(
LefDefParser *this,
const char *a2,
long long a3,
long long a4,
int a5,
int a6)
{
long long result; // rax
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
if ( LefDefParser::lefwState == 33 || (result = 2LL, LefDefParser::lefwState == 9) )
{
result = 3LL;
if ( this )
{
if ( *(_BYTE *)this )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)"END %s\n\n",
(_DWORD)this,
LefDefParser::lefwState,
a5,
a6);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "END %s\n\n", (const char *)this);
++LefDefParser::lefwLines;
LefDefParser::lefwState = 87;
return 0LL;
}
}
}
return result;
}
| lefwEndMacro:
PUSH RBX
MOV RDX,RDI
LEA RAX,[0x124e00]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x00113474
LEA RBX,[0x125050]
MOV ECX,dword ptr [RBX]
CMP ECX,0x21
JZ 0x0011344c
MOV EAX,0x2
CMP ECX,0x9
JNZ 0x0011349a
LAB_0011344c:
MOV EAX,0x3
TEST RDX,RDX
JZ 0x0011349a
CMP byte ptr [RDX],0x0
JZ 0x0011349a
CMP byte ptr [0x001250ec],0x1
JNZ 0x0011347b
LEA RSI,[0x11b3db]
XOR EAX,EAX
CALL 0x00118c35
JMP 0x00113489
LAB_00113474:
MOV EAX,0x1
JMP 0x0011349a
LAB_0011347b:
LEA RSI,[0x11b3db]
XOR EAX,EAX
CALL 0x001010f0
LAB_00113489:
LEA RAX,[0x12504c]
INC dword ptr [RAX]
MOV dword ptr [RBX],0x57
XOR EAX,EAX
LAB_0011349a:
POP RBX
RET
|
/* LefDefParser::lefwEndMacro(char const*) */
int8 LefDefParser::lefwEndMacro(char *param_1)
{
int8 uVar1;
if (lefwFile == (_IO_FILE *)0x0) {
uVar1 = 1;
}
else if ((((lefwState == 0x21) || (uVar1 = 2, lefwState == 9)) &&
(uVar1 = 3, param_1 != (char *)0x0)) && (*param_1 != '\0')) {
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile,"END %s\n\n");
}
else {
fprintf(lefwFile,"END %s\n\n");
}
lefwLines = lefwLines + 1;
lefwState = 0x57;
uVar1 = 0;
}
return uVar1;
}
| |
32,190 | convert_dirname | eloqsql/mysys/mf_dirname.c | char *convert_dirname(char *to, const char *from, const char *from_end)
{
char *to_org=to;
#ifdef BACKSLASH_MBTAIL
CHARSET_INFO *fs= fs_character_set();
#endif
DBUG_ENTER("convert_dirname");
/* We use -2 here, becasue we need place for the last FN_LIBCHAR */
if (!from_end || (from_end - from) > FN_REFLEN-2)
from_end=from+FN_REFLEN -2;
#if FN_LIBCHAR != '/'
{
for (; from != from_end && *from ; from++)
{
if (*from == '/')
*to++= FN_LIBCHAR;
else
{
#ifdef BACKSLASH_MBTAIL
uint l;
if (my_ci_use_mb(fs) && (l= my_ismbchar(fs, from, from + 3)))
{
memmove(to, from, l);
to+= l;
from+= l - 1;
to_org= to; /* Don't look inside mbchar */
}
else
#endif
{
*to++= *from;
}
}
}
*to=0;
}
#else
/* This is ok even if to == from, becasue we need to cut the string */
to= strmake(to, from, (size_t) (from_end-from));
#endif
/* Add FN_LIBCHAR to the end of directory path */
if (to != to_org && (to[-1] != FN_LIBCHAR && to[-1] != FN_DEVCHAR))
{
*to++=FN_LIBCHAR;
*to=0;
}
DBUG_RETURN(to); /* Pointer to end of dir */
} | O3 | c | convert_dirname:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdx, %rax
subq %rsi, %rax
leaq 0x1fe(%rsi), %rcx
cmpq $0x1ff, %rax # imm = 0x1FF
movq %rdx, %rax
cmovgeq %rcx, %rax
testq %rdx, %rdx
cmoveq %rcx, %rax
subq %rsi, %rax
movq %rax, %rdx
callq 0xe1f70
cmpq %rbx, %rax
je 0x9c05a
movzbl -0x1(%rax), %ecx
testl %ecx, %ecx
je 0x9c05a
cmpl $0x2f, %ecx
je 0x9c05a
movw $0x2f, (%rax)
incq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
| convert_dirname:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rax, rdx
sub rax, rsi
lea rcx, [rsi+1FEh]
cmp rax, 1FFh
mov rax, rdx
cmovge rax, rcx
test rdx, rdx
cmovz rax, rcx
sub rax, rsi
mov rdx, rax
call strmake
cmp rax, rbx
jz short loc_9C05A
movzx ecx, byte ptr [rax-1]
test ecx, ecx
jz short loc_9C05A
cmp ecx, 2Fh ; '/'
jz short loc_9C05A
mov word ptr [rax], 2Fh ; '/'
inc rax
loc_9C05A:
add rsp, 8
pop rbx
pop rbp
retn
| _WORD * convert_dirname(_WORD *a1, long long a2, long long a3)
{
long long v3; // rax
_WORD *result; // rax
v3 = a3;
if ( a3 - a2 >= 511 )
v3 = a2 + 510;
if ( !a3 )
v3 = a2 + 510;
result = (_WORD *)strmake(a1, a2, v3 - a2);
if ( result != a1 && *((_BYTE *)result - 1) && *((_BYTE *)result - 1) != 47 )
{
*result = 47;
return (_WORD *)((char *)result + 1);
}
return result;
}
| convert_dirname:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,RDX
SUB RAX,RSI
LEA RCX,[RSI + 0x1fe]
CMP RAX,0x1ff
MOV RAX,RDX
CMOVGE RAX,RCX
TEST RDX,RDX
CMOVZ RAX,RCX
SUB RAX,RSI
MOV RDX,RAX
CALL 0x001e1f70
CMP RAX,RBX
JZ 0x0019c05a
MOVZX ECX,byte ptr [RAX + -0x1]
TEST ECX,ECX
JZ 0x0019c05a
CMP ECX,0x2f
JZ 0x0019c05a
MOV word ptr [RAX],0x2f
INC RAX
LAB_0019c05a:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int2 * convert_dirname(int2 *param_1,long param_2,long param_3)
{
long lVar1;
int2 *puVar2;
lVar1 = param_3;
if (0x1fe < param_3 - param_2) {
lVar1 = param_2 + 0x1fe;
}
if (param_3 == 0) {
lVar1 = param_2 + 0x1fe;
}
puVar2 = (int2 *)strmake(param_1,param_2,lVar1 - param_2);
if (((puVar2 != param_1) && (*(char *)((long)puVar2 + -1) != '\0')) &&
(*(char *)((long)puVar2 + -1) != '/')) {
*puVar2 = 0x2f;
puVar2 = (int2 *)((long)puVar2 + 1);
}
return puVar2;
}
| |
32,191 | ma_pvio_register_callback | eloqsql/libmariadb/libmariadb/ma_pvio.c | int ma_pvio_register_callback(my_bool register_callback,
void (*callback_function)(int mode, MYSQL *mysql, const uchar *buffer, size_t length))
{
LIST *list;
if (!callback_function)
return 1;
/* plugin will unregister in it's deinit function */
if (register_callback)
{
list= (LIST *)malloc(sizeof(LIST));
list->data= (void *)callback_function;
pvio_callback= list_add(pvio_callback, list);
}
else /* unregister callback function */
{
LIST *p= pvio_callback;
while (p)
{
if (p->data == callback_function)
{
list_delete(pvio_callback, p);
break;
}
p= p->next;
}
}
return 0;
} | O3 | c | ma_pvio_register_callback:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x2effe
movq %rsi, %r14
testb %dil, %dil
je 0x2f00a
movl $0x18, %edi
callq 0x14620
movq %r14, 0x10(%rax)
leaq 0x33f1c(%rip), %rbx # 0x62f08
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x2e5a4
movq %rax, (%rbx)
xorl %ebx, %ebx
jmp 0x2f003
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x33ef7(%rip), %rax # 0x62f08
movq (%rax), %rdi
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x2f003
movq %rdi, %rsi
cmpq %r14, 0x10(%rsi)
je 0x2f02f
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
jne 0x2f01e
jmp 0x2f003
callq 0x2e5d8
jmp 0x2f003
nop
| ma_pvio_register_callback:
push rbp
mov rbp, rsp
push r14
push rbx
test rsi, rsi
jz short loc_2EFFE
mov r14, rsi
test dil, dil
jz short loc_2F00A
mov edi, 18h
call _malloc
mov [rax+10h], r14
lea rbx, pvio_callback
mov rdi, [rbx]
mov rsi, rax
call list_add
mov [rbx], rax
xor ebx, ebx
jmp short loc_2F003
loc_2EFFE:
mov ebx, 1
loc_2F003:
mov eax, ebx
pop rbx
pop r14
pop rbp
retn
loc_2F00A:
lea rax, pvio_callback
mov rdi, [rax]
xor ebx, ebx
test rdi, rdi
jz short loc_2F003
mov rsi, rdi
loc_2F01E:
cmp [rsi+10h], r14
jz short loc_2F02F
mov rsi, [rsi+8]
test rsi, rsi
jnz short loc_2F01E
jmp short loc_2F003
loc_2F02F:
call list_delete
jmp short loc_2F003
| long long ma_pvio_register_callback(char a1, long long a2)
{
_QWORD *v3; // rax
unsigned int v4; // ebx
long long *v6; // rsi
if ( a2 )
{
if ( a1 )
{
v3 = (_QWORD *)malloc(24LL);
v3[2] = a2;
pvio_callback = list_add(pvio_callback, v3);
return 0;
}
else
{
v4 = 0;
if ( pvio_callback )
{
v6 = pvio_callback;
while ( v6[2] != a2 )
{
v6 = (long long *)v6[1];
if ( !v6 )
return v4;
}
list_delete(pvio_callback, v6);
}
}
}
else
{
return 1;
}
return v4;
}
| ma_pvio_register_callback:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
TEST RSI,RSI
JZ 0x0012effe
MOV R14,RSI
TEST DIL,DIL
JZ 0x0012f00a
MOV EDI,0x18
CALL 0x00114620
MOV qword ptr [RAX + 0x10],R14
LEA RBX,[0x162f08]
MOV RDI,qword ptr [RBX]
MOV RSI,RAX
CALL 0x0012e5a4
MOV qword ptr [RBX],RAX
XOR EBX,EBX
JMP 0x0012f003
LAB_0012effe:
MOV EBX,0x1
LAB_0012f003:
MOV EAX,EBX
POP RBX
POP R14
POP RBP
RET
LAB_0012f00a:
LEA RAX,[0x162f08]
MOV RDI,qword ptr [RAX]
XOR EBX,EBX
TEST RDI,RDI
JZ 0x0012f003
MOV RSI,RDI
LAB_0012f01e:
CMP qword ptr [RSI + 0x10],R14
JZ 0x0012f02f
MOV RSI,qword ptr [RSI + 0x8]
TEST RSI,RSI
JNZ 0x0012f01e
JMP 0x0012f003
LAB_0012f02f:
CALL 0x0012e5d8
JMP 0x0012f003
|
int8 ma_pvio_register_callback(char param_1,long param_2)
{
long *plVar1;
void *pvVar2;
int8 uVar3;
long lVar4;
if (param_2 == 0) {
uVar3 = 1;
}
else if (param_1 == '\0') {
uVar3 = 0;
lVar4 = pvio_callback;
if (pvio_callback != 0) {
do {
if (*(long *)(lVar4 + 0x10) == param_2) {
list_delete();
return 0;
}
plVar1 = (long *)(lVar4 + 8);
lVar4 = *plVar1;
} while (*plVar1 != 0);
}
}
else {
pvVar2 = malloc(0x18);
*(long *)((long)pvVar2 + 0x10) = param_2;
pvio_callback = list_add(pvio_callback,pvVar2);
uVar3 = 0;
}
return uVar3;
}
| |
32,192 | minja::Context::~Context() | monkey531[P]llama/common/minja.hpp | virtual ~Context() {} | O3 | cpp | minja::Context::~Context():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x950be(%rip), %rax # 0x155120
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0xc0077
callq 0x50ba8
leaq 0x58(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x88dae
movq %r14, %rdi
callq 0x8e068
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xc009b
callq 0x50ba8
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xc00a9
callq 0x50ba8
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xc00b7
callq 0x50ba8
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xc00ec
movq 0x95eb9(%rip), %rax # 0x155f80
cmpb $0x0, (%rax)
je 0xc00d7
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xc00e1
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xc00ec
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xc0128
movq 0x95e84(%rip), %rax # 0x155f80
cmpb $0x0, (%rax)
je 0xc010c
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xc0116
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xc0128
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN5minja7ContextD2Ev:
push r14
push rbx
push rax
mov rbx, rdi
lea rax, _ZTVN5minja7ContextE; `vtable for'minja::Context
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+70h]
test rdi, rdi
jz short loc_C0077
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_C0077:
lea r14, [rbx+58h]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rbx+50h]
test rdi, rdi
jz short loc_C009B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_C009B:
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_C00A9
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_C00A9:
mov rdi, [rbx+30h]
test rdi, rdi
jz short loc_C00B7
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_C00B7:
mov rdi, [rbx+20h]
test rdi, rdi
jz short loc_C00EC
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_C00D7
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_C00E1
loc_C00D7:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_C00E1:
cmp eax, 1
jnz short loc_C00EC
mov rax, [rdi]
call qword ptr [rax+18h]
loc_C00EC:
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_C0128
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_C010C
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_C0116
loc_C010C:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_C0116:
cmp eax, 1
jnz short loc_C0128
mov rax, [rdi]
add rsp, 8
pop rbx
pop r14
jmp qword ptr [rax+18h]
loc_C0128:
add rsp, 8
pop rbx
pop r14
retn
| void minja::Context::~Context(minja::Context *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
volatile signed __int32 *v4; // rdi
volatile signed __int32 *v5; // rdi
volatile signed __int32 *v6; // rdi
signed __int32 v7; // eax
volatile signed __int32 *v8; // rdi
signed __int32 v9; // eax
*(_QWORD *)this = &`vtable for'minja::Context + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 14);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 88);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((char *)this + 88);
v3 = (volatile signed __int32 *)*((_QWORD *)this + 10);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
v4 = (volatile signed __int32 *)*((_QWORD *)this + 8);
if ( v4 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v4);
v5 = (volatile signed __int32 *)*((_QWORD *)this + 6);
if ( v5 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v5);
v6 = (volatile signed __int32 *)*((_QWORD *)this + 4);
if ( v6 )
{
if ( _libc_single_threaded )
{
v7 = *((_DWORD *)v6 + 3);
*((_DWORD *)v6 + 3) = v7 - 1;
}
else
{
v7 = _InterlockedExchangeAdd(v6 + 3, 0xFFFFFFFF);
}
if ( v7 == 1 )
(*(void ( **)(volatile signed __int32 *, _QWORD))(*(_QWORD *)v6 + 24LL))(v6, 0LL);
}
v8 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v8 )
{
if ( _libc_single_threaded )
{
v9 = *((_DWORD *)v8 + 3);
*((_DWORD *)v8 + 3) = v9 - 1;
}
else
{
v9 = _InterlockedExchangeAdd(v8 + 3, 0xFFFFFFFF);
}
if ( v9 == 1 )
(*(void ( **)(volatile signed __int32 *, _QWORD))(*(_QWORD *)v8 + 24LL))(v8, 0LL);
}
}
| ~Context:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x255120]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x70]
TEST RDI,RDI
JZ 0x001c0077
CALL 0x00150ba8
LAB_001c0077:
LEA R14,[RBX + 0x58]
MOV RDI,R14
XOR ESI,ESI
CALL 0x00188dae
MOV RDI,R14
CALL 0x0018e068
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JZ 0x001c009b
CALL 0x00150ba8
LAB_001c009b:
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x001c00a9
CALL 0x00150ba8
LAB_001c00a9:
MOV RDI,qword ptr [RBX + 0x30]
TEST RDI,RDI
JZ 0x001c00b7
CALL 0x00150ba8
LAB_001c00b7:
MOV RDI,qword ptr [RBX + 0x20]
TEST RDI,RDI
JZ 0x001c00ec
MOV RAX,qword ptr [0x00255f80]
CMP byte ptr [RAX],0x0
JZ 0x001c00d7
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001c00e1
LAB_001c00d7:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001c00e1:
CMP EAX,0x1
JNZ 0x001c00ec
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001c00ec:
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x001c0128
MOV RAX,qword ptr [0x00255f80]
CMP byte ptr [RAX],0x0
JZ 0x001c010c
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001c0116
LAB_001c010c:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001c0116:
CMP EAX,0x1
JNZ 0x001c0128
MOV RAX,qword ptr [RDI]
ADD RSP,0x8
POP RBX
POP R14
JMP qword ptr [RAX + 0x18]
LAB_001c0128:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::Context::~Context() */
void __thiscall minja::Context::~Context(Context *this)
{
int *piVar1;
long *plVar2;
int iVar3;
*(int ***)this = &PTR__Context_00255130;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x70) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x70));
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)(this + 0x58),0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)(this + 0x58));
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x50) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x50));
}
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x40) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x40));
}
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x30) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x30));
}
plVar2 = *(long **)(this + 0x20);
if (plVar2 != (long *)0x0) {
if (*PTR___libc_single_threaded_00255f80 == '\0') {
LOCK();
piVar1 = (int *)((long)plVar2 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)plVar2 + 0xc);
*(int *)((long)plVar2 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*plVar2 + 0x18))();
}
}
plVar2 = *(long **)(this + 0x10);
if (plVar2 != (long *)0x0) {
if (*PTR___libc_single_threaded_00255f80 == '\0') {
LOCK();
piVar1 = (int *)((long)plVar2 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)plVar2 + 0xc);
*(int *)((long)plVar2 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
/* WARNING: Could not recover jumptable at 0x001c0125. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(*plVar2 + 0x18))();
return;
}
}
return;
}
| |
32,193 | my_b_append | eloqsql/mysys/mf_iocache.c | int my_b_append(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
size_t rest_length,length;
MEM_CHECK_DEFINED(Buffer, Count);
/*
Assert that we cannot come here with a shared cache. If we do one
day, we might need to add a call to copy_to_read_buffer().
*/
DBUG_ASSERT(!info->share);
DBUG_ASSERT(!(info->myflags & MY_ENCRYPT));
lock_append_buffer(info);
rest_length= (size_t) (info->write_end - info->write_pos);
if (Count <= rest_length)
goto end;
memcpy(info->write_pos, Buffer, rest_length);
Buffer+=rest_length;
Count-=rest_length;
info->write_pos+=rest_length;
if (my_b_flush_io_cache(info,0))
{
unlock_append_buffer(info);
return 1;
}
if (Count >= IO_SIZE)
{ /* Fill first intern buffer */
length= IO_ROUND_DN(Count);
if (mysql_file_write(info->file,Buffer, length, info->myflags | MY_NABP))
{
unlock_append_buffer(info);
return info->error= -1;
}
Count-=length;
Buffer+=length;
info->end_of_file+=length;
}
end:
memcpy(info->write_pos,Buffer,(size_t) Count);
info->write_pos+=Count;
unlock_append_buffer(info);
return 0;
} | O3 | c | my_b_append:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
addq $0x50, %rdi
cmpq $0x0, 0x90(%r14)
movq %rdi, -0x38(%rbp)
jne 0x970d2
callq 0x29220
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rbx
subq %rdi, %rbx
movq %r13, %r12
subq %rbx, %r12
jbe 0x96fdb
movq %r15, %rsi
movq %rbx, %rdx
callq 0x29080
addq %rbx, 0x40(%r14)
movq %r14, %rdi
xorl %esi, %esi
callq 0x9648d
testl %eax, %eax
je 0x9701b
movq 0x90(%r14), %rdi
testq %rdi, %rdi
jne 0x970fd
movq -0x38(%rbp), %rdi
callq 0x291e0
movl $0x1, %eax
jmp 0x9700c
movq %r13, %r12
movq 0x40(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x29080
addq %r12, 0x40(%r14)
movq 0x90(%r14), %rdi
testq %rdi, %rdi
jne 0x970e8
movq -0x38(%rbp), %rdi
callq 0x291e0
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %rbx, %r15
cmpq $0x1000, %r12 # imm = 0x1000
jb 0x96fde
movl %r12d, %ebx
andl $0xfffff000, %ebx # imm = 0xFFFFF000
movl 0xd4(%r14), %esi
movq 0xf8(%r14), %r13
orq $0x4, %r13
leaq 0x2f1077(%rip), %rax # 0x3880c0
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %esi, -0x2c(%rbp)
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
movq %rbx, -0x48(%rbp)
jne 0x97112
movl -0x2c(%rbp), %edi
movq %r15, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x2f004
movq %rax, %rbx
testq %rbx, %rbx
je 0x970b5
movq 0x90(%r14), %rdi
testq %rdi, %rdi
jne 0x97174
movq -0x38(%rbp), %rdi
callq 0x291e0
movl $0xffffffff, 0xe4(%r14) # imm = 0xFFFFFFFF
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x9700c
movabsq $-0xfffff001, %rax # imm = 0xFFFFFFFF00000FFF
andq %rax, %r12
movq -0x48(%rbp), %rax
addq %rax, %r15
addq %rax, 0x8(%r14)
jmp 0x96fde
leaq 0x4653d(%rip), %rsi # 0xdd616
movl $0x62b, %edx # imm = 0x62B
callq 0x2eb8f
jmp 0x96f8b
leaq 0x2f0fd1(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x97001
leaq 0x2f0fbc(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x96fcb
movq %rax, %rcx
leaq 0x2f0fa4(%rip), %rax # 0x3880c0
movq (%rax), %rax
leaq 0x464f0(%rip), %rdx # 0xdd616
movq %rcx, -0x40(%rbp)
movq %rcx, %rdi
movq %rbx, %rsi
movl $0x63b, %ecx # imm = 0x63B
callq *0x210(%rax)
movl -0x2c(%rbp), %edi
movq %r15, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x2f004
movq %rbx, %rcx
movq %rax, %rbx
xorl %esi, %esi
testq %rax, %rax
cmoveq %rcx, %rsi
leaq 0x2f0f5e(%rip), %rax # 0x3880c0
movq (%rax), %rax
movq -0x40(%rbp), %rdi
callq *0x218(%rax)
jmp 0x97082
leaq 0x2f0f45(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x97097
| my_b_append:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r13, rdx
mov r15, rsi
mov r14, rdi
add rdi, 50h ; 'P'
cmp qword ptr [r14+90h], 0
mov [rbp+var_38], rdi
jnz loc_970D2
call _pthread_mutex_lock
loc_96F8B:
mov rdi, [r14+40h]
mov rbx, [r14+48h]
sub rbx, rdi
mov r12, r13
sub r12, rbx
jbe short loc_96FDB
mov rsi, r15
mov rdx, rbx
call _memcpy
add [r14+40h], rbx
mov rdi, r14
xor esi, esi
call my_b_flush_io_cache
test eax, eax
jz short loc_9701B
mov rdi, [r14+90h]
test rdi, rdi
jnz loc_970FD
loc_96FCB:
mov rdi, [rbp+var_38]
call _pthread_mutex_unlock
mov eax, 1
jmp short loc_9700C
loc_96FDB:
mov r12, r13
loc_96FDE:
mov rdi, [r14+40h]
mov rsi, r15
mov rdx, r12
call _memcpy
add [r14+40h], r12
mov rdi, [r14+90h]
test rdi, rdi
jnz loc_970E8
loc_97001:
mov rdi, [rbp+var_38]
call _pthread_mutex_unlock
xor eax, eax
loc_9700C:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9701B:
add r15, rbx
cmp r12, 1000h
jb short loc_96FDE
mov ebx, r12d
and ebx, 0FFFFF000h
mov esi, [r14+0D4h]
mov r13, [r14+0F8h]
or r13, 4
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov [rbp+var_2C], esi
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
mov [rbp+var_48], rbx
jnz loc_97112
mov edi, [rbp+var_2C]
mov rsi, r15
mov rdx, rbx
mov rcx, r13
call my_write
mov rbx, rax
loc_97082:
test rbx, rbx
jz short loc_970B5
mov rdi, [r14+90h]
test rdi, rdi
jnz loc_97174
loc_97097:
mov rdi, [rbp+var_38]
call _pthread_mutex_unlock
mov dword ptr [r14+0E4h], 0FFFFFFFFh
mov eax, 0FFFFFFFFh
jmp loc_9700C
loc_970B5:
mov rax, 0FFFFFFFF00000FFFh
and r12, rax
mov rax, [rbp+var_48]
add r15, rax
add [r14+8], rax
jmp loc_96FDE
loc_970D2:
lea rsi, aWorkspaceLlm4b_21; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 62Bh
call psi_mutex_lock
jmp loc_96F8B
loc_970E8:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_97001
loc_970FD:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_96FCB
loc_97112:
mov rcx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_21; "/workspace/llm4binary/github2025/eloqsq"...
mov [rbp+var_40], rcx
mov rdi, rcx
mov rsi, rbx
mov ecx, 63Bh
call qword ptr [rax+210h]
mov edi, [rbp+var_2C]
mov rsi, r15
mov rdx, rbx
mov rcx, r13
call my_write
mov rcx, rbx
mov rbx, rax
xor esi, esi
test rax, rax
cmovz rsi, rcx
lea rax, PSI_server
mov rax, [rax]
mov rdi, [rbp+var_40]
call qword ptr [rax+218h]
jmp loc_97082
loc_97174:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_97097
| long long my_b_append(long long a1, long long a2, unsigned long long a3)
{
long long v4; // r15
long long v6; // rdi
bool v7; // zf
long long v8; // rdi
unsigned long long v9; // rbx
unsigned long long v10; // r12
long long v12; // r13
long long v13; // rax
long long v14; // rbx
long long v15; // rsi
_BYTE v16[72]; // [rsp+0h] [rbp-90h] BYREF
long long v17; // [rsp+48h] [rbp-48h]
long long v18; // [rsp+50h] [rbp-40h]
long long v19; // [rsp+58h] [rbp-38h]
unsigned int v20; // [rsp+64h] [rbp-2Ch]
v4 = a2;
v6 = a1 + 80;
v7 = *(_QWORD *)(a1 + 144) == 0LL;
v19 = v6;
if ( v7 )
pthread_mutex_lock(v6);
else
psi_mutex_lock(v6, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c", 0x62Bu);
v8 = *(_QWORD *)(a1 + 64);
v9 = *(_QWORD *)(a1 + 72) - v8;
v10 = a3 - v9;
if ( a3 <= v9 )
{
v10 = a3;
}
else
{
memcpy(v8, a2, *(_QWORD *)(a1 + 72) - v8);
*(_QWORD *)(a1 + 64) += v9;
if ( (unsigned int)my_b_flush_io_cache((long long *)a1, 0) )
{
if ( *(_QWORD *)(a1 + 144) )
PSI_server[44]();
pthread_mutex_unlock(v19);
return 1LL;
}
v4 = v9 + a2;
if ( v10 >= 0x1000 )
{
v12 = *(_QWORD *)(a1 + 248) | 4LL;
v20 = *(_DWORD *)(a1 + 212);
v13 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v16, v20, 7LL);
v17 = (unsigned int)v10 & 0xFFFFF000;
if ( v13 )
{
v18 = v13;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v13,
v10 & 0xFFFFF000,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1595LL);
v14 = my_write(v20, v4, (unsigned int)v10 & 0xFFFFF000, v12);
v15 = 0LL;
if ( !v14 )
v15 = (unsigned int)v10 & 0xFFFFF000;
((void ( *)(long long, long long))PSI_server[67])(v18, v15);
}
else
{
v14 = my_write(v20, v4, (unsigned int)v10 & 0xFFFFF000, v12);
}
if ( v14 )
{
if ( *(_QWORD *)(a1 + 144) )
PSI_server[44]();
pthread_mutex_unlock(v19);
*(_DWORD *)(a1 + 228) = -1;
return 0xFFFFFFFFLL;
}
v10 &= 0xFFFFFFFF00000FFFLL;
v4 += v17;
*(_QWORD *)(a1 + 8) += v17;
}
}
memcpy(*(_QWORD *)(a1 + 64), v4, v10);
*(_QWORD *)(a1 + 64) += v10;
if ( *(_QWORD *)(a1 + 144) )
PSI_server[44]();
pthread_mutex_unlock(v19);
return 0LL;
}
| my_b_append:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R13,RDX
MOV R15,RSI
MOV R14,RDI
ADD RDI,0x50
CMP qword ptr [R14 + 0x90],0x0
MOV qword ptr [RBP + -0x38],RDI
JNZ 0x001970d2
CALL 0x00129220
LAB_00196f8b:
MOV RDI,qword ptr [R14 + 0x40]
MOV RBX,qword ptr [R14 + 0x48]
SUB RBX,RDI
MOV R12,R13
SUB R12,RBX
JBE 0x00196fdb
MOV RSI,R15
MOV RDX,RBX
CALL 0x00129080
ADD qword ptr [R14 + 0x40],RBX
MOV RDI,R14
XOR ESI,ESI
CALL 0x0019648d
TEST EAX,EAX
JZ 0x0019701b
MOV RDI,qword ptr [R14 + 0x90]
TEST RDI,RDI
JNZ 0x001970fd
LAB_00196fcb:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001291e0
MOV EAX,0x1
JMP 0x0019700c
LAB_00196fdb:
MOV R12,R13
LAB_00196fde:
MOV RDI,qword ptr [R14 + 0x40]
MOV RSI,R15
MOV RDX,R12
CALL 0x00129080
ADD qword ptr [R14 + 0x40],R12
MOV RDI,qword ptr [R14 + 0x90]
TEST RDI,RDI
JNZ 0x001970e8
LAB_00197001:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001291e0
XOR EAX,EAX
LAB_0019700c:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019701b:
ADD R15,RBX
CMP R12,0x1000
JC 0x00196fde
MOV EBX,R12D
AND EBX,0xfffff000
MOV ESI,dword ptr [R14 + 0xd4]
MOV R13,qword ptr [R14 + 0xf8]
OR R13,0x4
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV dword ptr [RBP + -0x2c],ESI
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
MOV qword ptr [RBP + -0x48],RBX
JNZ 0x00197112
MOV EDI,dword ptr [RBP + -0x2c]
MOV RSI,R15
MOV RDX,RBX
MOV RCX,R13
CALL 0x0012f004
MOV RBX,RAX
LAB_00197082:
TEST RBX,RBX
JZ 0x001970b5
MOV RDI,qword ptr [R14 + 0x90]
TEST RDI,RDI
JNZ 0x00197174
LAB_00197097:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001291e0
MOV dword ptr [R14 + 0xe4],0xffffffff
MOV EAX,0xffffffff
JMP 0x0019700c
LAB_001970b5:
MOV RAX,-0xfffff001
AND R12,RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD R15,RAX
ADD qword ptr [R14 + 0x8],RAX
JMP 0x00196fde
LAB_001970d2:
LEA RSI,[0x1dd616]
MOV EDX,0x62b
CALL 0x0012eb8f
JMP 0x00196f8b
LAB_001970e8:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00197001
LAB_001970fd:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00196fcb
LAB_00197112:
MOV RCX,RAX
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1dd616]
MOV qword ptr [RBP + -0x40],RCX
MOV RDI,RCX
MOV RSI,RBX
MOV ECX,0x63b
CALL qword ptr [RAX + 0x210]
MOV EDI,dword ptr [RBP + -0x2c]
MOV RSI,R15
MOV RDX,RBX
MOV RCX,R13
CALL 0x0012f004
MOV RCX,RBX
MOV RBX,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVZ RSI,RCX
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x40]
CALL qword ptr [RAX + 0x218]
JMP 0x00197082
LAB_00197174:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00197097
|
int8 my_b_append(long param_1,void *param_2,ulong param_3)
{
int iVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
int1 local_98 [72];
ulong local_50;
long local_48;
pthread_mutex_t *local_40;
int4 local_34;
local_40 = (pthread_mutex_t *)(param_1 + 0x50);
if (*(long *)(param_1 + 0x90) == 0) {
pthread_mutex_lock(local_40);
}
else {
psi_mutex_lock(local_40,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x62b);
}
uVar3 = *(long *)(param_1 + 0x48) - (long)*(void **)(param_1 + 0x40);
uVar4 = param_3 - uVar3;
if (uVar3 <= param_3 && uVar4 != 0) {
memcpy(*(void **)(param_1 + 0x40),param_2,uVar3);
*(long *)(param_1 + 0x40) = *(long *)(param_1 + 0x40) + uVar3;
iVar1 = my_b_flush_io_cache(param_1,0);
if (iVar1 != 0) {
if (*(long *)(param_1 + 0x90) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(local_40);
return 1;
}
param_2 = (void *)((long)param_2 + uVar3);
param_3 = uVar4;
if (0xfff < uVar4) {
uVar3 = (ulong)((uint)uVar4 & 0xfffff000);
local_34 = *(int4 *)(param_1 + 0xd4);
uVar5 = *(ulong *)(param_1 + 0xf8) | 4;
lVar2 = (**(code **)(PSI_server + 0x158))(local_98,local_34,7);
local_50 = uVar3;
if (lVar2 == 0) {
lVar2 = my_write(local_34,param_2,uVar3,uVar5);
}
else {
local_48 = lVar2;
(**(code **)(PSI_server + 0x210))
(lVar2,uVar3,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x63b);
lVar2 = my_write(local_34,param_2,uVar3,uVar5);
uVar5 = 0;
if (lVar2 == 0) {
uVar5 = uVar3;
}
(**(code **)(PSI_server + 0x218))(local_48,uVar5);
}
if (lVar2 != 0) {
if (*(long *)(param_1 + 0x90) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(local_40);
*(int4 *)(param_1 + 0xe4) = 0xffffffff;
return 0xffffffff;
}
param_3 = uVar4 & 0xffffffff00000fff;
param_2 = (void *)((long)param_2 + local_50);
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + local_50;
}
}
memcpy(*(void **)(param_1 + 0x40),param_2,param_3);
*(long *)(param_1 + 0x40) = *(long *)(param_1 + 0x40) + param_3;
if (*(long *)(param_1 + 0x90) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(local_40);
return 0;
}
| |
32,194 | fmt::v10::basic_memory_buffer<wchar_t, 500ul, std::allocator<wchar_t>>::grow(unsigned long) | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h | FMT_CONSTEXPR20 void grow(size_t size) override {
detail::abort_fuzzing_if(size > 5000);
const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
size_t old_capacity = this->capacity();
size_t new_capacity = old_capacity + old_capacity / 2;
if (size > new_capacity)
new_capacity = size;
else if (new_capacity > max_size)
new_capacity = size > max_size ? size : max_size;
T* old_data = this->data();
T* new_data =
std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);
// Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481).
detail::assume(this->size() <= new_capacity);
// The following code doesn't throw, so the raw pointer above doesn't leak.
std::uninitialized_copy_n(old_data, this->size(), new_data);
this->set(new_data, new_capacity);
// deallocate must not throw according to the standard, but even if it does,
// the buffer already uses the new storage and will deallocate it in
// destructor.
if (old_data != store_) alloc_.deallocate(old_data, old_capacity);
} | O0 | c | fmt::v10::basic_memory_buffer<wchar_t, 500ul, std::allocator<wchar_t>>::grow(unsigned long):
subq $0x78, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x1388, 0x48(%rsp) # imm = 0x1388
seta %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x29d50
movq 0x18(%rsp), %rdi
callq 0x9d600
movq 0x18(%rsp), %rdi
movq %rax, 0x40(%rsp)
callq 0x9d610
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x38(%rsp), %rcx
shrq %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x30(%rsp), %rax
jbe 0x9d4ea
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x9d524
movq 0x30(%rsp), %rax
cmpq 0x40(%rsp), %rax
jbe 0x9d522
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
jbe 0x9d50e
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x9d518
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x9d524
movq 0x18(%rsp), %rdi
callq 0x9d620
movq 0x18(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rsi
callq 0x9d630
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x9d320
movq 0x18(%rsp), %rdi
cmpq 0x30(%rsp), %rax
setbe %al
andb $0x1, %al
movb %al, 0x5f(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x9d320
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
callq 0x9d670
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x9d440
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
addq $0x20, %rcx
cmpq %rcx, %rax
je 0x9d5de
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %rax, 0x60(%rsp)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x9d9b0
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN3fmt3v1019basic_memory_bufferIiLm500ESaIiEE4growEm:
sub rsp, 78h
mov [rsp+78h+var_28], rdi
mov [rsp+78h+var_30], rsi
mov rax, [rsp+78h+var_28]
mov [rsp+78h+var_60], rax
cmp [rsp+78h+var_30], 1388h
setnbe al
movzx edi, al
and edi, 1; this
call _ZN3fmt3v106detail16abort_fuzzing_ifEb; fmt::v10::detail::abort_fuzzing_if(bool)
mov rdi, [rsp+78h+var_60]
call _ZNSt16allocator_traitsISaIiEE8max_sizeERKS0_; std::allocator_traits<std::allocator<int>>::max_size(std::allocator<int> const&)
mov rdi, [rsp+78h+var_60]
mov [rsp+78h+var_38], rax
call _ZNK3fmt3v106detail6bufferIiE8capacityEv; fmt::v10::detail::buffer<int>::capacity(void)
mov [rsp+78h+var_40], rax
mov rax, [rsp+78h+var_40]
mov rcx, [rsp+78h+var_40]
shr rcx, 1
add rax, rcx
mov [rsp+78h+var_48], rax
mov rax, [rsp+78h+var_30]
cmp rax, [rsp+78h+var_48]
jbe short loc_9D4EA
mov rax, [rsp+78h+var_30]
mov [rsp+78h+var_48], rax
jmp short loc_9D524
loc_9D4EA:
mov rax, [rsp+78h+var_48]
cmp rax, [rsp+78h+var_38]
jbe short loc_9D522
mov rax, [rsp+78h+var_30]
cmp rax, [rsp+78h+var_38]
jbe short loc_9D50E
mov rax, [rsp+78h+var_30]
mov [rsp+78h+var_68], rax
jmp short loc_9D518
loc_9D50E:
mov rax, [rsp+78h+var_38]
mov [rsp+78h+var_68], rax
loc_9D518:
mov rax, [rsp+78h+var_68]
mov [rsp+78h+var_48], rax
loc_9D522:
jmp short $+2
loc_9D524:
mov rdi, [rsp+78h+var_60]
call _ZN3fmt3v106detail6bufferIiE4dataEv; fmt::v10::detail::buffer<int>::data(void)
mov rdi, [rsp+78h+var_60]
mov [rsp+78h+var_50], rax
mov rsi, [rsp+78h+var_48]
call _ZNSt16allocator_traitsISaIiEE8allocateERS0_m; std::allocator_traits<std::allocator<int>>::allocate(std::allocator<int>&,ulong)
mov rdi, [rsp+78h+var_60]
mov [rsp+78h+var_58], rax
call _ZNK3fmt3v106detail6bufferIiE4sizeEv; fmt::v10::detail::buffer<int>::size(void)
mov rdi, [rsp+78h+var_60]
cmp rax, [rsp+78h+var_48]
setbe al
and al, 1
mov [rsp+78h+var_19], al
mov rax, [rsp+78h+var_50]
mov [rsp+78h+var_70], rax
call _ZNK3fmt3v106detail6bufferIiE4sizeEv; fmt::v10::detail::buffer<int>::size(void)
mov rdi, [rsp+78h+var_70]
mov rsi, rax
mov rdx, [rsp+78h+var_58]
call _ZSt20uninitialized_copy_nIPimS0_ET1_T_T0_S1_; std::uninitialized_copy_n<int *,ulong,int *>(int *,ulong,int *)
mov rdi, [rsp+78h+var_60]
mov rsi, [rsp+78h+var_58]
mov rdx, [rsp+78h+var_48]
call _ZN3fmt3v106detail6bufferIiE3setEPim; fmt::v10::detail::buffer<int>::set(int *,ulong)
mov rcx, [rsp+78h+var_60]
mov rax, [rsp+78h+var_50]
add rcx, 20h ; ' '
cmp rax, rcx
jz short loc_9D5DE
mov rdx, [rsp+78h+var_60]
mov rcx, [rsp+78h+var_50]
mov rax, [rsp+78h+var_40]
mov [rsp+78h+var_8], rdx
mov [rsp+78h+var_10], rcx
mov [rsp+78h+var_18], rax
mov rdi, [rsp+78h+var_8]
mov rsi, [rsp+78h+var_10]
mov rdx, [rsp+78h+var_18]
call _ZN9__gnu_cxx13new_allocatorIiE10deallocateEPim; __gnu_cxx::new_allocator<int>::deallocate(int *,ulong)
loc_9D5DE:
add rsp, 78h
retn
| long long fmt::v10::basic_memory_buffer<int,500ul,std::allocator<int>>::grow(long long a1, unsigned long long a2)
{
long long v2; // rax
long long result; // rax
unsigned long long v4; // [rsp+10h] [rbp-68h]
long long v5; // [rsp+20h] [rbp-58h]
long long v6; // [rsp+28h] [rbp-50h]
unsigned long long v7; // [rsp+30h] [rbp-48h]
unsigned long long v8; // [rsp+38h] [rbp-40h]
unsigned long long v9; // [rsp+40h] [rbp-38h]
fmt::v10::detail::abort_fuzzing_if((fmt::v10::detail *)(a2 > 0x1388));
v9 = std::allocator_traits<std::allocator<int>>::max_size(a1);
v8 = fmt::v10::detail::buffer<int>::capacity(a1);
v7 = (v8 >> 1) + v8;
if ( a2 <= v7 )
{
if ( v7 > v9 )
{
if ( a2 <= v9 )
v4 = v9;
else
v4 = a2;
v7 = v4;
}
}
else
{
v7 = a2;
}
v6 = fmt::v10::detail::buffer<int>::data(a1);
v5 = std::allocator_traits<std::allocator<int>>::allocate(a1, v7);
fmt::v10::detail::buffer<int>::size(a1);
v2 = fmt::v10::detail::buffer<int>::size(a1);
std::uninitialized_copy_n<int *,unsigned long,int *>(v6, v2, v5);
fmt::v10::detail::buffer<int>::set(a1, v5, v7);
result = v6;
if ( v6 != a1 + 32 )
return __gnu_cxx::new_allocator<int>::deallocate(a1, v6, v8);
return result;
}
| grow:
SUB RSP,0x78
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x18],RAX
CMP qword ptr [RSP + 0x48],0x1388
SETA AL
MOVZX EDI,AL
AND EDI,0x1
CALL 0x00129d50
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0019d600
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x40],RAX
CALL 0x0019d610
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RSP + 0x38]
SHR RCX,0x1
ADD RAX,RCX
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x48]
CMP RAX,qword ptr [RSP + 0x30]
JBE 0x0019d4ea
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x30],RAX
JMP 0x0019d524
LAB_0019d4ea:
MOV RAX,qword ptr [RSP + 0x30]
CMP RAX,qword ptr [RSP + 0x40]
JBE 0x0019d522
MOV RAX,qword ptr [RSP + 0x48]
CMP RAX,qword ptr [RSP + 0x40]
JBE 0x0019d50e
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0019d518
LAB_0019d50e:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x10],RAX
LAB_0019d518:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RAX
LAB_0019d522:
JMP 0x0019d524
LAB_0019d524:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0019d620
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x28],RAX
MOV RSI,qword ptr [RSP + 0x30]
CALL 0x0019d630
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x20],RAX
CALL 0x0019d320
MOV RDI,qword ptr [RSP + 0x18]
CMP RAX,qword ptr [RSP + 0x30]
SETBE AL
AND AL,0x1
MOV byte ptr [RSP + 0x5f],AL
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0019d320
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x0019d670
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x0019d440
MOV RCX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x28]
ADD RCX,0x20
CMP RAX,RCX
JZ 0x0019d5de
MOV RDX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x70],RDX
MOV qword ptr [RSP + 0x68],RCX
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x60]
CALL 0x0019d9b0
LAB_0019d5de:
ADD RSP,0x78
RET
|
/* fmt::v10::basic_memory_buffer<int, 500ul, std::allocator<int> >::grow(unsigned long) */
void __thiscall
fmt::v10::basic_memory_buffer<int,500ul,std::allocator<int>>::grow
(basic_memory_buffer<int,500ul,std::allocator<int>> *this,ulong param_1)
{
ulong uVar1;
ulong uVar2;
basic_memory_buffer<int,500ul,std::allocator<int>> *pbVar3;
int *piVar4;
ulong local_68;
ulong local_48;
v10::detail::abort_fuzzing_if(5000 < param_1);
local_68 = std::allocator_traits<std::allocator<int>>::max_size((allocator *)this);
uVar1 = v10::detail::buffer<int>::capacity((buffer<int> *)this);
uVar2 = uVar1 + (uVar1 >> 1);
local_48 = param_1;
if ((param_1 <= uVar2) && (local_48 = uVar2, local_68 < uVar2)) {
if (local_68 < param_1) {
local_68 = param_1;
}
local_48 = local_68;
}
pbVar3 = (basic_memory_buffer<int,500ul,std::allocator<int>> *)
v10::detail::buffer<int>::data((buffer<int> *)this);
piVar4 = (int *)std::allocator_traits<std::allocator<int>>::allocate((allocator *)this,local_48);
v10::detail::buffer<int>::size((buffer<int> *)this);
uVar2 = v10::detail::buffer<int>::size((buffer<int> *)this);
std::uninitialized_copy_n<int*,unsigned_long,int*>((int *)pbVar3,uVar2,piVar4);
v10::detail::buffer<int>::set((buffer<int> *)this,piVar4,local_48);
if (pbVar3 != this + 0x20) {
__gnu_cxx::new_allocator<int>::deallocate((new_allocator<int> *)this,(int *)pbVar3,uVar1);
}
return;
}
| |
32,195 | alaya::SequentialStorageTest_UpdateTest_Test::TestBody() | AlayaLite/tests/storage/sequential_storage_test.cpp | TEST_F(SequentialStorageTest, UpdateTest) {
alaya::SequentialStorage<int, uint32_t> storage;
storage.init(sizeof(int), 10, 64);
int data1 = 42;
int data2 = 100;
uint32_t id1 = storage.insert(&data1);
storage.update(id1, &data2);
EXPECT_EQ(*storage[id1], data2);
} | O0 | cpp | alaya::SequentialStorageTest_UpdateTest_Test::TestBody():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf9c0
movq 0x8(%rsp), %rax
leaq 0x8a784(%rip), %rcx # 0x9a838
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x18, %rsp
retq
| _ZN5alaya37SequentialStorageTest_UpdateTest_TestC2Ev:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rdi, [rsp+18h+var_8]; this
mov [rsp+18h+var_10], rdi
call _ZN5alaya21SequentialStorageTestC2Ev; alaya::SequentialStorageTest::SequentialStorageTest(void)
mov rax, [rsp+18h+var_10]
lea rcx, _ZTVN5alaya37SequentialStorageTest_UpdateTest_TestE; `vtable for'alaya::SequentialStorageTest_UpdateTest_Test
add rcx, 10h
mov [rax], rcx
add rsp, 18h
retn
| alaya::SequentialStorageTest_UpdateTest_Test * alaya::SequentialStorageTest_UpdateTest_Test::SequentialStorageTest_UpdateTest_Test(
alaya::SequentialStorageTest_UpdateTest_Test *this)
{
alaya::SequentialStorageTest_UpdateTest_Test *result; // rax
alaya::SequentialStorageTest::SequentialStorageTest(this);
result = this;
*(_QWORD *)this = &`vtable for'alaya::SequentialStorageTest_UpdateTest_Test + 2;
return result;
}
| SequentialStorageTest_UpdateTest_Test:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0010f9c0
MOV RAX,qword ptr [RSP + 0x8]
LEA RCX,[0x19a838]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
ADD RSP,0x18
RET
|
/* alaya::SequentialStorageTest_UpdateTest_Test::SequentialStorageTest_UpdateTest_Test() */
void __thiscall
alaya::SequentialStorageTest_UpdateTest_Test::SequentialStorageTest_UpdateTest_Test
(SequentialStorageTest_UpdateTest_Test *this)
{
SequentialStorageTest::SequentialStorageTest((SequentialStorageTest *)this);
*(int ***)this = &PTR__SequentialStorageTest_UpdateTest_Test_0019a848;
return;
}
| |
32,196 | DirectoryExists | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c | bool DirectoryExists(const char *dirPath)
{
bool result = false;
DIR *dir = opendir(dirPath);
if (dir != NULL)
{
result = true;
closedir(dir);
}
return result;
} | O0 | c | DirectoryExists:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa810
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd1221
movb $0x1, -0x9(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa910
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| DirectoryExists:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_9], 0
mov rdi, [rbp+var_8]
call _opendir
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_D1221
mov [rbp+var_9], 1
mov rdi, [rbp+var_18]
call _closedir
loc_D1221:
mov al, [rbp+var_9]
and al, 1
add rsp, 20h
pop rbp
retn
| char DirectoryExists(long long a1)
{
long long v2; // [rsp+8h] [rbp-18h]
char v3; // [rsp+17h] [rbp-9h]
v3 = 0;
v2 = opendir(a1);
if ( v2 )
{
v3 = 1;
closedir(v2);
}
return v3;
}
| DirectoryExists:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],0x0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0010a810
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001d1221
MOV byte ptr [RBP + -0x9],0x1
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0010a910
LAB_001d1221:
MOV AL,byte ptr [RBP + -0x9]
AND AL,0x1
ADD RSP,0x20
POP RBP
RET
|
bool DirectoryExists(char *param_1)
{
DIR *__dirp;
__dirp = opendir(param_1);
if (__dirp != (DIR *)0x0) {
closedir(__dirp);
}
return __dirp != (DIR *)0x0;
}
| |
32,197 | DirectoryExists | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c | bool DirectoryExists(const char *dirPath)
{
bool result = false;
DIR *dir = opendir(dirPath);
if (dir != NULL)
{
result = true;
closedir(dir);
}
return result;
} | O3 | c | DirectoryExists:
pushq %rbx
callq 0xa810
movq %rax, %rbx
testq %rax, %rax
je 0x75c37
movq %rbx, %rdi
callq 0xa900
testq %rbx, %rbx
setne %al
popq %rbx
retq
| DirectoryExists:
push rbx
call _opendir
mov rbx, rax
test rax, rax
jz short loc_75C37
mov rdi, rbx
call _closedir
loc_75C37:
test rbx, rbx
setnz al
pop rbx
retn
| bool DirectoryExists()
{
long long v0; // rax
long long v1; // rbx
v0 = opendir();
v1 = v0;
if ( v0 )
closedir(v0);
return v1 != 0;
}
| DirectoryExists:
PUSH RBX
CALL 0x0010a810
MOV RBX,RAX
TEST RAX,RAX
JZ 0x00175c37
MOV RDI,RBX
CALL 0x0010a900
LAB_00175c37:
TEST RBX,RBX
SETNZ AL
POP RBX
RET
|
bool DirectoryExists(char *param_1)
{
DIR *__dirp;
__dirp = opendir(param_1);
if (__dirp != (DIR *)0x0) {
closedir(__dirp);
}
return __dirp != (DIR *)0x0;
}
| |
32,198 | get_options | eloqsql/libmariadb/unittest/libmariadb/my_test.h | void get_options(int argc, char **argv)
{
int c= 0;
while ((c=getopt(argc,argv, "h:u:p:d:w:P:S:t:?")) >= 0)
{
switch(c) {
case 'h':
hostname= optarg;
break;
case 'u':
username= optarg;
break;
case 'p':
password= optarg;
break;
case 'd':
schema= optarg;
break;
case 'P':
port= atoi(optarg);
ssl_port=port;
break;
case 'S':
socketname= optarg;
break;
case 't':
force_tls= 1;
break;
case '?':
usage();
exit(0);
break;
default:
usage();
BAIL_OUT("Unknown option %c\n", c);
}
}
} | O3 | c | get_options:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x21397(%rip), %rdx # 0x351eb
callq 0x13110
testl %eax, %eax
js 0x13f38
movl %eax, %r12d
movq 0x35155(%rip), %r13 # 0x48fc0
leaq 0x21379(%rip), %r15 # 0x351eb
cmpl $0x67, %r12d
jle 0x13e9e
cmpl $0x73, %r12d
jg 0x13ec1
cmpl $0x68, %r12d
je 0x13efb
cmpl $0x70, %r12d
jne 0x13f59
movq (%r13), %rax
movq %rax, 0x370c7(%rip) # 0x4af60
jmp 0x13f1f
cmpl $0x52, %r12d
jle 0x13ede
cmpl $0x53, %r12d
je 0x13f14
cmpl $0x64, %r12d
jne 0x13f59
movq (%r13), %rax
movq %rax, 0x370a9(%rip) # 0x4af68
jmp 0x13f1f
cmpl $0x74, %r12d
je 0x13f08
cmpl $0x75, %r12d
jne 0x13f59
movq (%r13), %rax
movq %rax, 0x3707c(%rip) # 0x4af58
jmp 0x13f1f
cmpl $0x50, %r12d
jne 0x13f47
movq (%r13), %rdi
callq 0x136f0
movl %eax, 0x3707d(%rip) # 0x4af70
movl %eax, 0x3707b(%rip) # 0x4af74
jmp 0x13f1f
movq (%r13), %rax
movq %rax, 0x3704a(%rip) # 0x4af50
jmp 0x13f1f
movl $0x1, 0x3706e(%rip) # 0x4af80
jmp 0x13f1f
movq (%r13), %rax
movq %rax, 0x37059(%rip) # 0x4af78
movl %r14d, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x13110
movl %eax, %r12d
testl %eax, %eax
jns 0x13e72
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x3f, %r12d
jne 0x13f59
callq 0x15665
xorl %edi, %edi
callq 0x13580
callq 0x15665
leaq 0x21298(%rip), %rdi # 0x351fd
movl %r12d, %esi
xorl %eax, %eax
callq 0x15718
| get_options:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r14d, edi
lea rdx, aHUPDWPST; "h:u:p:d:w:P:S:t:?"
call _getopt
test eax, eax
js loc_13F38
mov r12d, eax
mov r13, cs:optarg_ptr
lea r15, aHUPDWPST; "h:u:p:d:w:P:S:t:?"
loc_13E72:
cmp r12d, 67h ; 'g'
jle short loc_13E9E
cmp r12d, 73h ; 's'
jg short loc_13EC1
cmp r12d, 68h ; 'h'
jz short loc_13EFB
cmp r12d, 70h ; 'p'
jnz loc_13F59
mov rax, [r13+0]
mov cs:password, rax
jmp loc_13F1F
loc_13E9E:
cmp r12d, 52h ; 'R'
jle short loc_13EDE
cmp r12d, 53h ; 'S'
jz short loc_13F14
cmp r12d, 64h ; 'd'
jnz loc_13F59
mov rax, [r13+0]
mov cs:schema, rax
jmp short loc_13F1F
loc_13EC1:
cmp r12d, 74h ; 't'
jz short loc_13F08
cmp r12d, 75h ; 'u'
jnz loc_13F59
mov rax, [r13+0]
mov cs:username, rax
jmp short loc_13F1F
loc_13EDE:
cmp r12d, 50h ; 'P'
jnz short loc_13F47
mov rdi, [r13+0]
call _atoi
mov cs:port, eax
mov cs:ssl_port, eax
jmp short loc_13F1F
loc_13EFB:
mov rax, [r13+0]
mov cs:hostname, rax
jmp short loc_13F1F
loc_13F08:
mov cs:force_tls, 1
jmp short loc_13F1F
loc_13F14:
mov rax, [r13+0]
mov cs:socketname, rax
loc_13F1F:
mov edi, r14d
mov rsi, rbx
mov rdx, r15
call _getopt
mov r12d, eax
test eax, eax
jns loc_13E72
loc_13F38:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_13F47:
cmp r12d, 3Fh ; '?'
jnz short loc_13F59
call usage
xor edi, edi
call _exit
loc_13F59:
call usage
lea rdi, aUnknownOptionC; "Unknown option %c\n"
mov esi, r12d
xor eax, eax
call BAIL_OUT
| long long get_options(long long a1, long long a2)
{
char v2; // al
long long result; // rax
int v4; // r12d
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
char v9; // [rsp-8h] [rbp-30h]
v9 = v2;
result = getopt(a1, a2, "h:u:p:d:w:P:S:t:?");
if ( (int)result >= 0 )
{
v4 = result;
do
{
if ( v4 <= 103 )
{
if ( v4 <= 82 )
{
if ( v4 != 80 )
{
if ( v4 == 63 )
{
usage();
exit(0LL);
}
LABEL_24:
usage();
BAIL_OUT((unsigned int)"Unknown option %c\n", v4, v5, v6, v7, v8, v9);
}
port = atoi(optarg);
ssl_port = port;
}
else if ( v4 == 83 )
{
socketname = optarg;
}
else
{
if ( v4 != 100 )
goto LABEL_24;
schema = optarg;
}
}
else if ( v4 > 115 )
{
if ( v4 == 116 )
{
force_tls = 1;
}
else
{
if ( v4 != 117 )
goto LABEL_24;
username = optarg;
}
}
else if ( v4 == 104 )
{
hostname = optarg;
}
else
{
if ( v4 != 112 )
goto LABEL_24;
password = optarg;
}
result = getopt((unsigned int)a1, a2, "h:u:p:d:w:P:S:t:?");
v4 = result;
}
while ( (int)result >= 0 );
}
return result;
}
| get_options:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14D,EDI
LEA RDX,[0x1351eb]
CALL 0x00113110
TEST EAX,EAX
JS 0x00113f38
MOV R12D,EAX
MOV R13,qword ptr [0x00148fc0]
LEA R15,[0x1351eb]
LAB_00113e72:
CMP R12D,0x67
JLE 0x00113e9e
CMP R12D,0x73
JG 0x00113ec1
CMP R12D,0x68
JZ 0x00113efb
CMP R12D,0x70
JNZ 0x00113f59
MOV RAX,qword ptr [R13]
MOV qword ptr [0x0014af60],RAX
JMP 0x00113f1f
LAB_00113e9e:
CMP R12D,0x52
JLE 0x00113ede
CMP R12D,0x53
JZ 0x00113f14
CMP R12D,0x64
JNZ 0x00113f59
MOV RAX,qword ptr [R13]
MOV qword ptr [0x0014af68],RAX
JMP 0x00113f1f
LAB_00113ec1:
CMP R12D,0x74
JZ 0x00113f08
CMP R12D,0x75
JNZ 0x00113f59
MOV RAX,qword ptr [R13]
MOV qword ptr [0x0014af58],RAX
JMP 0x00113f1f
LAB_00113ede:
CMP R12D,0x50
JNZ 0x00113f47
MOV RDI,qword ptr [R13]
CALL 0x001136f0
MOV dword ptr [0x0014af70],EAX
MOV dword ptr [0x0014af74],EAX
JMP 0x00113f1f
LAB_00113efb:
MOV RAX,qword ptr [R13]
MOV qword ptr [0x0014af50],RAX
JMP 0x00113f1f
LAB_00113f08:
MOV dword ptr [0x0014af80],0x1
JMP 0x00113f1f
LAB_00113f14:
MOV RAX,qword ptr [R13]
MOV qword ptr [0x0014af78],RAX
LAB_00113f1f:
MOV EDI,R14D
MOV RSI,RBX
MOV RDX,R15
CALL 0x00113110
MOV R12D,EAX
TEST EAX,EAX
JNS 0x00113e72
LAB_00113f38:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00113f47:
CMP R12D,0x3f
JNZ 0x00113f59
CALL 0x00115665
XOR EDI,EDI
CALL 0x00113580
LAB_00113f59:
CALL 0x00115665
LEA RDI,[0x1351fd]
MOV ESI,R12D
XOR EAX,EAX
CALL 0x00115718
|
void get_options(int param_1,char **param_2)
{
int *puVar1;
int iVar2;
iVar2 = getopt(param_1,param_2,"h:u:p:d:w:P:S:t:?");
puVar1 = PTR_optarg_00148fc0;
do {
if (iVar2 < 0) {
return;
}
if (iVar2 < 0x68) {
if (iVar2 < 0x53) {
if (iVar2 != 0x50) {
if (iVar2 == 0x3f) {
usage();
/* WARNING: Subroutine does not return */
exit(0);
}
LAB_00113f59:
usage();
/* WARNING: Subroutine does not return */
BAIL_OUT("Unknown option %c\n",iVar2);
}
port = atoi(*(char **)puVar1);
ssl_port = port;
}
else if (iVar2 == 0x53) {
socketname = *(int8 *)puVar1;
}
else {
if (iVar2 != 100) goto LAB_00113f59;
schema = *(int8 *)puVar1;
}
}
else if (iVar2 < 0x74) {
if (iVar2 == 0x68) {
hostname = *(int8 *)puVar1;
}
else {
if (iVar2 != 0x70) goto LAB_00113f59;
password = *(int8 *)puVar1;
}
}
else if (iVar2 == 0x74) {
force_tls = 1;
}
else {
if (iVar2 != 0x75) goto LAB_00113f59;
username = *(int8 *)puVar1;
}
iVar2 = getopt(param_1,param_2,"h:u:p:d:w:P:S:t:?");
} while( true );
}
| |
32,199 | translog_fill_overhead_table | eloqsql/storage/maria/ma_loghandler.c | void translog_fill_overhead_table()
{
uint i;
for (i= 0; i < TRANSLOG_FLAGS_NUM; i++)
{
page_overhead[i]= 7;
if (i & TRANSLOG_PAGE_CRC)
page_overhead[i]+= CRC_SIZE;
if (i & TRANSLOG_SECTOR_PROTECTION)
page_overhead[i]+= TRANSLOG_PAGE_SIZE /
DISK_DRIVE_SECTOR_SIZE;
}
} | O3 | c | translog_fill_overhead_table:
pushq %rbp
movq %rsp, %rbp
movaps 0xa6971(%rip), %xmm0 # 0xd9080
movaps %xmm0, 0xbcc6ca(%rip) # 0xbfede0
movaps %xmm0, 0xbcc6d3(%rip) # 0xbfedf0
popq %rbp
retq
| translog_fill_overhead_table:
push rbp
mov rbp, rsp
movaps xmm0, cs:xmmword_D9080
movaps cs:page_overhead, xmm0
movaps cs:xmmword_BFEDF0, xmm0
pop rbp
retn
| void translog_fill_overhead_table()
{
page_overhead = xmmword_D9080;
xmmword_BFEDF0 = xmmword_D9080;
}
| translog_fill_overhead_table:
PUSH RBP
MOV RBP,RSP
MOVAPS XMM0,xmmword ptr [0x001d9080]
MOVAPS xmmword ptr [0x00cfede0],XMM0
MOVAPS xmmword ptr [0x00cfedf0],XMM0
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void translog_fill_overhead_table(void)
{
page_overhead._0_8_ = _DAT_001d9080;
page_overhead._8_8_ = _UNK_001d9088;
page_overhead._16_8_ = _DAT_001d9080;
page_overhead._24_8_ = _UNK_001d9088;
return;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.