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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
38,100 | diff | eloqsql/strings/dtoa.c | static Bigint *diff(Bigint *a, Bigint *b, Stack_alloc *alloc)
{
Bigint *c;
int i, wa, wb;
ULong *xa, *xae, *xb, *xbe, *xc;
ULLong borrow, y;
i= cmp(a,b);
if (!i)
{
c= Balloc(0, alloc);
c->wds= 1;
c->p.x[0]= 0;
return c;
}
if (i < 0)
{
c= a;
a= b;
b= c;
i= 1;
}
else
i= 0;
c= Balloc(a->k, alloc);
c->sign= i;
wa= a->wds;
xa= a->p.x;
xae= xa + wa;
wb= b->wds;
xb= b->p.x;
xbe= xb + wb;
xc= c->p.x;
borrow= 0;
do
{
y= (ULLong)*xa++ - *xb++ - borrow;
borrow= y >> 32 & (ULong)1;
*xc++= (ULong) (y & FFFFFFFF);
}
while (xb < xbe);
while (xa < xae)
{
y= *xa++ - borrow;
borrow= y >> 32 & (ULong)1;
*xc++= (ULong) (y & FFFFFFFF);
}
while (!*--xc)
wa--;
c->wds= wa;
return c;
} | O0 | c | diff:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14b180
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x14afbe
movq -0x20(%rbp), %rsi
xorl %edi, %edi
callq 0x14a690
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14b16a
cmpl $0x0, -0x2c(%rbp)
jge 0x14afe5
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0x14afec
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x20(%rbp), %rsi
callq 0x14a690
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %eax
movq -0x50(%rbp), %rcx
movq %rcx, %rdx
addq $0x4, %rdx
movq %rdx, -0x50(%rbp)
movl (%rcx), %ecx
subq %rcx, %rax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
shrq $0x20, %rax
andq $0x1, %rax
movq %rax, -0x68(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x70(%rbp), %rax
movl %eax, %ecx
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x60(%rbp)
movl %ecx, (%rax)
movq -0x50(%rbp), %rax
cmpq -0x58(%rbp), %rax
jb 0x14b06d
jmp 0x14b0d7
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x14b12d
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %eax
subq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
shrq $0x20, %rax
andq $0x1, %rax
movq %rax, -0x68(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x70(%rbp), %rax
movl %eax, %ecx
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x60(%rbp)
movl %ecx, (%rax)
jmp 0x14b0d7
jmp 0x14b12f
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x60(%rbp)
cmpl $0x0, -0x4(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x14b14d
jmp 0x14b158
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x14b12f
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| diff:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call cmp
mov [rbp+var_2C], eax
cmp [rbp+var_2C], 0
jnz short loc_14AFBE
mov rsi, [rbp+var_20]
xor edi, edi
call Balloc
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov dword ptr [rax+14h], 1
mov rax, [rbp+var_28]
mov rax, [rax]
mov dword ptr [rax], 0
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp loc_14B16A
loc_14AFBE:
cmp [rbp+var_2C], 0
jge short loc_14AFE5
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_10], rax
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov [rbp+var_2C], 1
jmp short loc_14AFEC
loc_14AFE5:
mov [rbp+var_2C], 0
loc_14AFEC:
mov rax, [rbp+var_10]
mov edi, [rax+8]
mov rsi, [rbp+var_20]
call Balloc
mov [rbp+var_28], rax
mov ecx, [rbp+var_2C]
mov rax, [rbp+var_28]
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov eax, [rax+14h]
mov [rbp+var_30], eax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
movsxd rcx, [rbp+var_30]
shl rcx, 2
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
mov eax, [rax+14h]
mov [rbp+var_34], eax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
movsxd rcx, [rbp+var_34]
shl rcx, 2
add rax, rcx
mov [rbp+var_58], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_60], rax
mov [rbp+var_68], 0
loc_14B06D:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov eax, [rax]
mov rcx, [rbp+var_50]
mov rdx, rcx
add rdx, 4
mov [rbp+var_50], rdx
mov ecx, [rcx]
sub rax, rcx
sub rax, [rbp+var_68]
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
shr rax, 20h
and rax, 1
mov [rbp+var_68], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_70]
mov ecx, eax
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 4
mov [rbp+var_60], rdx
mov [rax], ecx
mov rax, [rbp+var_50]
cmp rax, [rbp+var_58]
jb short loc_14B06D
jmp short $+2
loc_14B0D7:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_48]
jnb short loc_14B12D
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov eax, [rax]
sub rax, [rbp+var_68]
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
shr rax, 20h
and rax, 1
mov [rbp+var_68], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_70]
mov ecx, eax
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 4
mov [rbp+var_60], rdx
mov [rax], ecx
jmp short loc_14B0D7
loc_14B12D:
jmp short $+2
loc_14B12F:
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_60], rcx
cmp dword ptr [rax-4], 0
setnz al
xor al, 0FFh
test al, 1
jnz short loc_14B14D
jmp short loc_14B158
loc_14B14D:
mov eax, [rbp+var_30]
add eax, 0FFFFFFFFh
mov [rbp+var_30], eax
jmp short loc_14B12F
loc_14B158:
mov ecx, [rbp+var_30]
mov rax, [rbp+var_28]
mov [rax+14h], ecx
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_14B16A:
mov rax, [rbp+var_8]
add rsp, 70h
pop rbp
retn
| long long diff(unsigned int **a1, unsigned int **a2, long long a3)
{
unsigned int *v3; // rax
unsigned int *v4; // rcx
_DWORD *v5; // rax
unsigned int *v6; // rax
_DWORD *v7; // rax
_DWORD *v8; // rax
unsigned long long v10; // [rsp+0h] [rbp-70h]
unsigned long long v11; // [rsp+0h] [rbp-70h]
long long v12; // [rsp+8h] [rbp-68h]
_DWORD *v13; // [rsp+10h] [rbp-60h]
unsigned long long v14; // [rsp+18h] [rbp-58h]
unsigned int *v15; // [rsp+20h] [rbp-50h]
unsigned long long v16; // [rsp+28h] [rbp-48h]
unsigned int *v17; // [rsp+30h] [rbp-40h]
int v18; // [rsp+40h] [rbp-30h]
int v19; // [rsp+44h] [rbp-2Ch]
int v20; // [rsp+44h] [rbp-2Ch]
long long v21; // [rsp+48h] [rbp-28h]
long long v22; // [rsp+48h] [rbp-28h]
unsigned int **v24; // [rsp+58h] [rbp-18h]
unsigned int **v25; // [rsp+60h] [rbp-10h]
v25 = a1;
v24 = a2;
v19 = cmp(a1, a2);
if ( v19 )
{
if ( v19 >= 0 )
{
v20 = 0;
}
else
{
v25 = a2;
v24 = a1;
v20 = 1;
}
v22 = Balloc(*((_DWORD *)v25 + 2), a3);
*(_DWORD *)(v22 + 16) = v20;
v18 = *((_DWORD *)v25 + 5);
v17 = *v25;
v16 = (unsigned long long)&(*v25)[v18];
v15 = *v24;
v14 = (unsigned long long)&(*v24)[*((int *)v24 + 5)];
v13 = *(_DWORD **)v22;
v12 = 0LL;
do
{
v3 = v17++;
v4 = v15++;
v10 = *v3 - (unsigned long long)*v4 - v12;
v12 = HIDWORD(v10) & 1;
v5 = v13++;
*v5 = v10;
}
while ( (unsigned long long)v15 < v14 );
while ( (unsigned long long)v17 < v16 )
{
v6 = v17++;
v11 = *v6 - v12;
v12 = HIDWORD(v11) & 1;
v7 = v13++;
*v7 = v11;
}
while ( 1 )
{
v8 = v13--;
if ( *(v8 - 1) )
break;
--v18;
}
*(_DWORD *)(v22 + 20) = v18;
return v22;
}
else
{
v21 = Balloc(0, a3);
*(_DWORD *)(v21 + 20) = 1;
**(_DWORD **)v21 = 0;
return v21;
}
}
| |||
38,101 | diff | eloqsql/strings/dtoa.c | static Bigint *diff(Bigint *a, Bigint *b, Stack_alloc *alloc)
{
Bigint *c;
int i, wa, wb;
ULong *xa, *xae, *xb, *xbe, *xc;
ULLong borrow, y;
i= cmp(a,b);
if (!i)
{
c= Balloc(0, alloc);
c->wds= 1;
c->p.x[0]= 0;
return c;
}
if (i < 0)
{
c= a;
a= b;
b= c;
i= 1;
}
else
i= 0;
c= Balloc(a->k, alloc);
c->sign= i;
wa= a->wds;
xa= a->p.x;
xae= xa + wa;
wb= b->wds;
xb= b->p.x;
xbe= xb + wb;
xc= c->p.x;
borrow= 0;
do
{
y= (ULLong)*xa++ - *xb++ - borrow;
borrow= y >> 32 & (ULong)1;
*xc++= (ULong) (y & FFFFFFFF);
}
while (xb < xbe);
while (xa < xae)
{
y= *xa++ - borrow;
borrow= y >> 32 & (ULong)1;
*xc++= (ULong) (y & FFFFFFFF);
}
while (!*--xc)
wa--;
c->wds= wa;
return c;
} | O3 | c | diff:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x14(%rdi), %eax
movslq 0x14(%rsi), %rdi
subl %edi, %eax
jne 0xd68db
movq (%rbx), %rax
leaq (%rax,%rdi,4), %rcx
movq (%rsi), %r8
leaq (%r8,%rdi,4), %rdi
addq $-0x4, %rdi
movl -0x4(%rcx), %r8d
movl (%rdi), %r9d
cmpl %r9d, %r8d
jne 0xd68d1
addq $-0x4, %rcx
addq $-0x4, %rdi
cmpq %rax, %rcx
ja 0xd6899
xorl %edi, %edi
movq %rdx, %rsi
callq 0xd6358
movl $0x1, 0x14(%rax)
movq (%rax), %rcx
movl $0x0, (%rcx)
jmp 0xd6977
xorl %eax, %eax
cmpl %r9d, %r8d
sbbl %eax, %eax
orl $0x1, %eax
movl %eax, %r14d
shrl $0x1f, %r14d
testl %eax, %eax
movq %rsi, %r15
cmovsq %rbx, %r15
cmovsq %rsi, %rbx
movl 0x8(%rbx), %edi
movq %rdx, %rsi
callq 0xd6358
movl %r14d, 0x10(%rax)
movslq 0x14(%rbx), %rcx
movq (%rbx), %r8
movslq 0x14(%r15), %rdx
movq (%r15), %r9
leaq (%r9,%rdx,4), %r10
movq (%rax), %rdx
xorl %edi, %edi
movq %r8, %rsi
movl (%r9), %r11d
addq %rdi, %r11
movl (%rsi), %edi
addq $0x4, %rsi
addq $0x4, %r9
subq %r11, %rdi
movl %edi, (%rdx)
shrq $0x20, %rdi
andl $0x1, %edi
addq $0x4, %rdx
cmpq %r10, %r9
jb 0xd6918
leaq (%r8,%rcx,4), %r8
cmpq %r8, %rsi
jae 0xd6963
movl (%rsi), %r9d
addq $0x4, %rsi
subq %rdi, %r9
movq %r9, %rdi
shrq $0x20, %rdi
andl $0x1, %edi
movl %r9d, (%rdx)
addq $0x4, %rdx
jmp 0xd6941
incl %ecx
addq $-0x4, %rdx
decl %ecx
cmpl $0x0, (%rdx)
leaq -0x4(%rdx), %rdx
je 0xd6969
movl %ecx, 0x14(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| diff:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov eax, [rdi+14h]
movsxd rdi, dword ptr [rsi+14h]
sub eax, edi
jnz short loc_D68DB
mov rax, [rbx]
lea rcx, [rax+rdi*4]
mov r8, [rsi]
lea rdi, [r8+rdi*4]
add rdi, 0FFFFFFFFFFFFFFFCh
loc_D6899:
mov r8d, [rcx-4]
mov r9d, [rdi]
cmp r8d, r9d
jnz short loc_D68D1
add rcx, 0FFFFFFFFFFFFFFFCh
add rdi, 0FFFFFFFFFFFFFFFCh
cmp rcx, rax
ja short loc_D6899
xor edi, edi
mov rsi, rdx
call Balloc
mov dword ptr [rax+14h], 1
mov rcx, [rax]
mov dword ptr [rcx], 0
jmp loc_D6977
loc_D68D1:
xor eax, eax
cmp r8d, r9d
sbb eax, eax
or eax, 1
loc_D68DB:
mov r14d, eax
shr r14d, 1Fh
test eax, eax
mov r15, rsi
cmovs r15, rbx
cmovs rbx, rsi
mov edi, [rbx+8]
mov rsi, rdx
call Balloc
mov [rax+10h], r14d
movsxd rcx, dword ptr [rbx+14h]
mov r8, [rbx]
movsxd rdx, dword ptr [r15+14h]
mov r9, [r15]
lea r10, [r9+rdx*4]
mov rdx, [rax]
xor edi, edi
mov rsi, r8
loc_D6918:
mov r11d, [r9]
add r11, rdi
mov edi, [rsi]
add rsi, 4
add r9, 4
sub rdi, r11
mov [rdx], edi
shr rdi, 20h
and edi, 1
add rdx, 4
cmp r9, r10
jb short loc_D6918
lea r8, [r8+rcx*4]
loc_D6941:
cmp rsi, r8
jnb short loc_D6963
mov r9d, [rsi]
add rsi, 4
sub r9, rdi
mov rdi, r9
shr rdi, 20h
and edi, 1
mov [rdx], r9d
add rdx, 4
jmp short loc_D6941
loc_D6963:
inc ecx
add rdx, 0FFFFFFFFFFFFFFFCh
loc_D6969:
dec ecx
cmp dword ptr [rdx], 0
lea rdx, [rdx-4]
jz short loc_D6969
mov [rax+14h], ecx
loc_D6977:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long diff(unsigned int **a1, unsigned int **a2, long long a3)
{
unsigned int **v3; // rbx
int v4; // eax
long long v5; // rdi
int v6; // eax
unsigned long long v7; // rcx
unsigned int *i; // rdi
unsigned int v9; // r8d
long long result; // rax
unsigned int v11; // r14d
unsigned int **v12; // r15
long long v13; // rcx
unsigned int *v14; // r8
unsigned int *v15; // r9
unsigned long long v16; // r10
_DWORD *v17; // rdx
long long v18; // rdi
unsigned int *v19; // rsi
long long v20; // r11
long long v21; // rdi
long long v22; // rdi
unsigned long long v23; // r8
long long v24; // r9
long long v25; // r9
int v26; // ecx
_DWORD *v27; // rdx
v3 = a1;
v4 = *((_DWORD *)a1 + 5);
v5 = *((int *)a2 + 5);
v6 = v4 - v5;
if ( !v6 )
{
v7 = (unsigned long long)&(*v3)[v5];
for ( i = &(*a2)[v5 - 1]; ; --i )
{
v9 = *(_DWORD *)(v7 - 4);
if ( v9 != *i )
break;
v7 -= 4LL;
if ( v7 <= (unsigned long long)*v3 )
{
result = Balloc(0, a3);
*(_DWORD *)(result + 20) = 1;
**(_DWORD **)result = 0;
return result;
}
}
v6 = v9 < *i ? -1 : 1;
}
v11 = (unsigned int)v6 >> 31;
v12 = a2;
if ( v6 < 0 )
{
v12 = v3;
v3 = a2;
}
result = Balloc(*((_DWORD *)v3 + 2), a3);
*(_DWORD *)(result + 16) = v11;
v13 = *((int *)v3 + 5);
v14 = *v3;
v15 = *v12;
v16 = (unsigned long long)&(*v12)[*((int *)v12 + 5)];
v17 = *(_DWORD **)result;
v18 = 0LL;
v19 = *v3;
do
{
v20 = v18 + *v15;
v21 = *v19++;
++v15;
v22 = v21 - v20;
*v17 = v22;
v18 = BYTE4(v22) & 1;
++v17;
}
while ( (unsigned long long)v15 < v16 );
v23 = (unsigned long long)&v14[v13];
while ( (unsigned long long)v19 < v23 )
{
v24 = *v19++;
v25 = v24 - v18;
v18 = BYTE4(v25) & 1;
*v17++ = v25;
}
v26 = v13 + 1;
v27 = v17 - 1;
do
--v26;
while ( *v27-- == 0 );
*(_DWORD *)(result + 20) = v26;
return result;
}
| diff:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0x14]
MOVSXD RDI,dword ptr [RSI + 0x14]
SUB EAX,EDI
JNZ 0x001d68db
MOV RAX,qword ptr [RBX]
LEA RCX,[RAX + RDI*0x4]
MOV R8,qword ptr [RSI]
LEA RDI,[R8 + RDI*0x4]
ADD RDI,-0x4
LAB_001d6899:
MOV R8D,dword ptr [RCX + -0x4]
MOV R9D,dword ptr [RDI]
CMP R8D,R9D
JNZ 0x001d68d1
ADD RCX,-0x4
ADD RDI,-0x4
CMP RCX,RAX
JA 0x001d6899
XOR EDI,EDI
MOV RSI,RDX
CALL 0x001d6358
MOV dword ptr [RAX + 0x14],0x1
MOV RCX,qword ptr [RAX]
MOV dword ptr [RCX],0x0
JMP 0x001d6977
LAB_001d68d1:
XOR EAX,EAX
CMP R8D,R9D
SBB EAX,EAX
OR EAX,0x1
LAB_001d68db:
MOV R14D,EAX
SHR R14D,0x1f
TEST EAX,EAX
MOV R15,RSI
CMOVS R15,RBX
CMOVS RBX,RSI
MOV EDI,dword ptr [RBX + 0x8]
MOV RSI,RDX
CALL 0x001d6358
MOV dword ptr [RAX + 0x10],R14D
MOVSXD RCX,dword ptr [RBX + 0x14]
MOV R8,qword ptr [RBX]
MOVSXD RDX,dword ptr [R15 + 0x14]
MOV R9,qword ptr [R15]
LEA R10,[R9 + RDX*0x4]
MOV RDX,qword ptr [RAX]
XOR EDI,EDI
MOV RSI,R8
LAB_001d6918:
MOV R11D,dword ptr [R9]
ADD R11,RDI
MOV EDI,dword ptr [RSI]
ADD RSI,0x4
ADD R9,0x4
SUB RDI,R11
MOV dword ptr [RDX],EDI
SHR RDI,0x20
AND EDI,0x1
ADD RDX,0x4
CMP R9,R10
JC 0x001d6918
LEA R8,[R8 + RCX*0x4]
LAB_001d6941:
CMP RSI,R8
JNC 0x001d6963
MOV R9D,dword ptr [RSI]
ADD RSI,0x4
SUB R9,RDI
MOV RDI,R9
SHR RDI,0x20
AND EDI,0x1
MOV dword ptr [RDX],R9D
ADD RDX,0x4
JMP 0x001d6941
LAB_001d6963:
INC ECX
ADD RDX,-0x4
LAB_001d6969:
DEC ECX
CMP dword ptr [RDX],0x0
LEA RDX,[RDX + -0x4]
JZ 0x001d6969
MOV dword ptr [RAX + 0x14],ECX
LAB_001d6977:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void diff(ulong *param_1,ulong *param_2,int8 param_3)
{
uint uVar1;
uint *puVar2;
uint uVar3;
int8 *puVar4;
int iVar5;
ulong uVar6;
int *piVar7;
ulong *puVar8;
uint *puVar9;
uint *puVar10;
long lVar11;
uint *puVar12;
iVar5 = *(int *)((long)param_2 + 0x14);
uVar3 = *(int *)((long)param_1 + 0x14) - iVar5;
if (uVar3 == 0) {
uVar6 = *param_1 + (long)iVar5 * 4;
puVar10 = (uint *)(*param_2 + (long)iVar5 * 4);
do {
puVar10 = puVar10 + -1;
if (*(uint *)(uVar6 - 4) != *puVar10) {
uVar3 = -(uint)(*(uint *)(uVar6 - 4) < *puVar10) | 1;
goto LAB_001d68db;
}
uVar6 = uVar6 - 4;
} while (*param_1 < uVar6);
puVar4 = (int8 *)Balloc(0,param_3);
*(int4 *)((long)puVar4 + 0x14) = 1;
*(int4 *)*puVar4 = 0;
}
else {
LAB_001d68db:
puVar8 = param_1;
if ((int)uVar3 < 0) {
puVar8 = param_2;
param_2 = param_1;
}
puVar4 = (int8 *)Balloc((int)puVar8[1],param_3);
*(uint *)(puVar4 + 2) = uVar3 >> 0x1f;
iVar5 = *(int *)((long)puVar8 + 0x14);
puVar2 = (uint *)*puVar8;
puVar12 = (uint *)*param_2;
puVar10 = puVar12 + *(int *)((long)param_2 + 0x14);
piVar7 = (int *)*puVar4;
uVar6 = 0;
puVar9 = puVar2;
do {
uVar3 = *puVar12;
uVar1 = *puVar9;
puVar9 = puVar9 + 1;
puVar12 = puVar12 + 1;
lVar11 = (ulong)uVar1 - (uVar3 + uVar6);
*piVar7 = (int)lVar11;
uVar6 = (ulong)((uint)((ulong)lVar11 >> 0x20) & 1);
piVar7 = piVar7 + 1;
} while (puVar12 < puVar10);
for (; puVar9 < puVar2 + iVar5; puVar9 = puVar9 + 1) {
lVar11 = *puVar9 - uVar6;
uVar6 = (ulong)((uint)((ulong)lVar11 >> 0x20) & 1);
*piVar7 = (int)lVar11;
piVar7 = piVar7 + 1;
}
iVar5 = iVar5 + 1;
do {
piVar7 = piVar7 + -1;
iVar5 = iVar5 + -1;
} while (*piVar7 == 0);
*(int *)((long)puVar4 + 0x14) = iVar5;
}
return;
}
| |
38,102 | my_large_free | eloqsql/mysys/my_largepage.c | void my_large_free(void *ptr, size_t size)
{
DBUG_ENTER("my_large_free");
/*
The following implementations can only fail if ptr was not allocated with
my_large_malloc(), i.e. my_malloc_lock() was used so we should free it
with my_free_lock()
For ASAN, we need to explicitly unpoison this memory region because the OS
may reuse that memory for some TLS or stack variable. It will remain
poisoned if it was explicitly poisioned before release. If this happens,
we'll have hard to debug false positives like in MDEV-21239.
For valgrind, we mark it as UNDEFINED rather than NOACCESS because of the
implict reuse possiblility.
*/
#if defined(HAVE_MMAP) && !defined(_WIN32)
if (munmap(ptr, size))
{
my_error(EE_BADMEMORYRELEASE, MYF(ME_ERROR_LOG_ONLY), ptr, size, errno);
}
# if !__has_feature(memory_sanitizer)
else
{
MEM_MAKE_ADDRESSABLE(ptr, size);
}
# endif
#elif defined(_WIN32)
/*
When RELEASE memory, the size parameter must be 0.
Do not use MEM_RELEASE with MEM_DECOMMIT.
*/
if (ptr && !VirtualFree(ptr, 0, MEM_RELEASE))
{
my_error(EE_BADMEMORYRELEASE, MYF(ME_ERROR_LOG_ONLY), ptr, size,
GetLastError());
}
# if !__has_feature(memory_sanitizer)
else
{
MEM_MAKE_ADDRESSABLE(ptr, size);
}
# endif
#else
my_free_lock(ptr);
#endif
DBUG_VOID_RETURN;
} | O3 | c | my_large_free:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x294d0
testl %eax, %eax
je 0xa803c
callq 0x29790
movl (%rax), %r8d
movl $0x80, %esi
movl $0x24, %edi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x9e11f
popq %rbx
popq %r14
popq %rbp
retq
| my_large_free:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
call _munmap
test eax, eax
jz short loc_A803C
call ___errno_location
mov r8d, [rax]
mov esi, 80h
mov edi, 24h ; '$'
mov rdx, r14
mov rcx, rbx
xor eax, eax
pop rbx
pop r14
pop rbp
jmp my_error
loc_A803C:
pop rbx
pop r14
pop rbp
retn
| unsigned long long my_large_free(long long a1, long long a2)
{
unsigned long long result; // rax
unsigned int *v3; // rax
result = munmap(a1, a2);
if ( (_DWORD)result )
{
v3 = (unsigned int *)__errno_location(a1);
return my_error(0x24u, 128LL, a1, a2, *v3);
}
return result;
}
| my_large_free:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CALL 0x001294d0
TEST EAX,EAX
JZ 0x001a803c
CALL 0x00129790
MOV R8D,dword ptr [RAX]
MOV ESI,0x80
MOV EDI,0x24
MOV RDX,R14
MOV RCX,RBX
XOR EAX,EAX
POP RBX
POP R14
POP RBP
JMP 0x0019e11f
LAB_001a803c:
POP RBX
POP R14
POP RBP
RET
|
void my_large_free(void *param_1,size_t param_2)
{
int iVar1;
int *piVar2;
iVar1 = munmap(param_1,param_2);
if (iVar1 != 0) {
piVar2 = __errno_location();
my_error(0x24,0x80,param_1,param_2,*piVar2);
return;
}
return;
}
| |
38,103 | mi_log | eloqsql/storage/myisam/mi_log.c | int mi_log(int activate_log)
{
int error=0;
char buff[FN_REFLEN];
DBUG_ENTER("mi_log");
log_type=activate_log;
if (activate_log)
{
if (!myisam_pid)
myisam_pid=(ulong) getpid();
if (myisam_log_file < 0)
{
if ((myisam_log_file= mysql_file_create(mi_key_file_log,
fn_format(buff,
myisam_log_filename,
"", ".log", 4),
0,
(O_RDWR | O_BINARY | O_APPEND),
MYF(0))) < 0)
DBUG_RETURN(my_errno);
}
}
else if (myisam_log_file >= 0)
{
error= mysql_file_close(myisam_log_file, MYF(0)) ? my_errno : 0 ;
myisam_log_file= -1;
}
DBUG_RETURN(error);
} | O0 | c | mi_log:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x218(%rbp)
movl $0x0, -0x21c(%rbp)
movl -0x218(%rbp), %eax
movl %eax, 0xbc8de4(%rip) # 0xc7a2c8
cmpl $0x0, -0x218(%rbp)
je 0xb15a2
cmpq $0x0, 0xbc8dc7(%rip) # 0xc7a2c0
jne 0xb1509
callq 0x2a890
cltq
movq %rax, 0xbc8db7(%rip) # 0xc7a2c0
leaq 0x20de20(%rip), %rax # 0x2bf330
cmpl $0x0, (%rax)
jge 0xb15a0
leaq 0xbc8d80(%rip), %rax # 0xc7a2a0
movl (%rax), %eax
movl %eax, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
leaq 0x20ddf2(%rip), %rax # 0x2bf328
movq (%rax), %rsi
leaq 0xa658a(%rip), %rdx # 0x157aca
leaq 0xa203c(%rip), %rcx # 0x153583
movl $0x4, %r8d
callq 0xdf4e0
movl -0x220(%rbp), %edi
movq %rax, %rcx
leaq 0xa23f4(%rip), %rsi # 0x153956
movl $0x35, %edx
xorl %r8d, %r8d
movl $0x402, %r9d # imm = 0x402
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0xb1650
leaq 0x20ddaa(%rip), %rcx # 0x2bf330
movl %eax, (%rcx)
cmpl $0x0, %eax
jge 0xb159e
jmp 0xb158f
callq 0xf6060
movl (%rax), %eax
movl %eax, -0x214(%rbp)
jmp 0xb1613
jmp 0xb15a0
jmp 0xb1605
leaq 0x20dd87(%rip), %rax # 0x2bf330
cmpl $0x0, (%rax)
jl 0xb1603
leaq 0x20dd7b(%rip), %rax # 0x2bf330
movl (%rax), %edx
leaq 0xa2398(%rip), %rdi # 0x153956
movl $0x3b, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0xb1740
cmpl $0x0, %eax
je 0xb15e0
callq 0xf6060
movl (%rax), %eax
movl %eax, -0x224(%rbp)
jmp 0xb15ea
xorl %eax, %eax
movl %eax, -0x224(%rbp)
jmp 0xb15ea
movl -0x224(%rbp), %eax
movl %eax, -0x21c(%rbp)
leaq 0x20dd33(%rip), %rax # 0x2bf330
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
jmp 0xb1605
jmp 0xb1607
movl -0x21c(%rbp), %eax
movl %eax, -0x214(%rbp)
movl -0x214(%rbp), %eax
movl %eax, -0x228(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xb1640
movl -0x228(%rbp), %eax
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
callq 0x2a250
nopw %cs:(%rax,%rax)
| mi_log:
push rbp
mov rbp, rsp
sub rsp, 230h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], edi
mov [rbp+var_21C], 0
mov eax, [rbp+var_218]
mov cs:log_type, eax
cmp [rbp+var_218], 0
jz loc_B15A2
cmp cs:myisam_pid, 0
jnz short loc_B1509
call _getpid
cdqe
mov cs:myisam_pid, rax
loc_B1509:
lea rax, myisam_log_file
cmp dword ptr [rax], 0
jge loc_B15A0
lea rax, mi_key_file_log
mov eax, [rax]
mov [rbp+var_220], eax
lea rdi, [rbp+var_210]
lea rax, myisam_log_filename
mov rsi, [rax]
lea rdx, asc_157AC6+4; ""
lea rcx, aMyisamLog+6; ".log"
mov r8d, 4
call fn_format
mov edi, [rbp+var_220]
mov rcx, rax
lea rsi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 35h ; '5'
xor r8d, r8d
mov r9d, 402h
xor eax, eax
mov [rsp+230h+var_230], 0
call inline_mysql_file_create_1
lea rcx, myisam_log_file
mov [rcx], eax
cmp eax, 0
jge short loc_B159E
jmp short $+2
loc_B158F:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_214], eax
jmp short loc_B1613
loc_B159E:
jmp short $+2
loc_B15A0:
jmp short loc_B1605
loc_B15A2:
lea rax, myisam_log_file
cmp dword ptr [rax], 0
jl short loc_B1603
lea rax, myisam_log_file
mov edx, [rax]
lea rdi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 3Bh ; ';'
xor eax, eax
mov ecx, eax
call inline_mysql_file_close_5
cmp eax, 0
jz short loc_B15E0
call _my_thread_var
mov eax, [rax]
mov [rbp+var_224], eax
jmp short loc_B15EA
loc_B15E0:
xor eax, eax
mov [rbp+var_224], eax
jmp short $+2
loc_B15EA:
mov eax, [rbp+var_224]
mov [rbp+var_21C], eax
lea rax, myisam_log_file
mov dword ptr [rax], 0FFFFFFFFh
loc_B1603:
jmp short $+2
loc_B1605:
jmp short $+2
loc_B1607:
mov eax, [rbp+var_21C]
mov [rbp+var_214], eax
loc_B1613:
mov eax, [rbp+var_214]
mov [rbp+var_228], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_B1640
mov eax, [rbp+var_228]
add rsp, 230h
pop rbp
retn
loc_B1640:
call ___stack_chk_fail
| long long mi_log(int a1)
{
int v1; // eax
unsigned int v3; // [rsp+Ch] [rbp-224h]
unsigned int v4; // [rsp+10h] [rbp-220h]
unsigned int v5; // [rsp+14h] [rbp-21Ch]
_BYTE v7[520]; // [rsp+20h] [rbp-210h] BYREF
unsigned long long v8; // [rsp+228h] [rbp-8h]
v8 = __readfsqword(0x28u);
v5 = 0;
log_type = a1;
if ( !a1 )
{
if ( (myisam_log_file & 0x80000000) == 0 )
{
if ( (unsigned int)inline_mysql_file_close_5(
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",
59LL,
myisam_log_file,
0LL) )
v3 = *(_DWORD *)my_thread_var(
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",
(_BYTE *)&word_3A + 1);
else
v3 = 0;
v5 = v3;
myisam_log_file = -1;
}
return v5;
}
if ( !myisam_pid )
myisam_pid = (int)getpid();
if ( (myisam_log_file & 0x80000000) == 0 )
return v5;
v4 = mi_key_file_log;
v1 = fn_format(v7, myisam_log_filename, "", ".log", 4LL);
myisam_log_file = inline_mysql_file_create_1(
v4,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",
53,
v1,
0,
1026,
0LL);
if ( (myisam_log_file & 0x80000000) == 0 )
return v5;
return *(unsigned int *)my_thread_var(v4, "/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c");
}
| mi_log:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x230
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x218],EDI
MOV dword ptr [RBP + -0x21c],0x0
MOV EAX,dword ptr [RBP + -0x218]
MOV dword ptr [0x00d7a2c8],EAX
CMP dword ptr [RBP + -0x218],0x0
JZ 0x001b15a2
CMP qword ptr [0x00d7a2c0],0x0
JNZ 0x001b1509
CALL 0x0012a890
CDQE
MOV qword ptr [0x00d7a2c0],RAX
LAB_001b1509:
LEA RAX,[0x3bf330]
CMP dword ptr [RAX],0x0
JGE 0x001b15a0
LEA RAX,[0xd7a2a0]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x220],EAX
LEA RDI,[RBP + -0x210]
LEA RAX,[0x3bf328]
MOV RSI,qword ptr [RAX]
LEA RDX,[0x257aca]
LEA RCX,[0x253583]
MOV R8D,0x4
CALL 0x001df4e0
MOV EDI,dword ptr [RBP + -0x220]
MOV RCX,RAX
LEA RSI,[0x253956]
MOV EDX,0x35
XOR R8D,R8D
MOV R9D,0x402
XOR EAX,EAX
MOV qword ptr [RSP],0x0
CALL 0x001b1650
LEA RCX,[0x3bf330]
MOV dword ptr [RCX],EAX
CMP EAX,0x0
JGE 0x001b159e
JMP 0x001b158f
LAB_001b158f:
CALL 0x001f6060
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x214],EAX
JMP 0x001b1613
LAB_001b159e:
JMP 0x001b15a0
LAB_001b15a0:
JMP 0x001b1605
LAB_001b15a2:
LEA RAX,[0x3bf330]
CMP dword ptr [RAX],0x0
JL 0x001b1603
LEA RAX,[0x3bf330]
MOV EDX,dword ptr [RAX]
LEA RDI,[0x253956]
MOV ESI,0x3b
XOR EAX,EAX
MOV ECX,EAX
CALL 0x001b1740
CMP EAX,0x0
JZ 0x001b15e0
CALL 0x001f6060
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x224],EAX
JMP 0x001b15ea
LAB_001b15e0:
XOR EAX,EAX
MOV dword ptr [RBP + -0x224],EAX
JMP 0x001b15ea
LAB_001b15ea:
MOV EAX,dword ptr [RBP + -0x224]
MOV dword ptr [RBP + -0x21c],EAX
LEA RAX,[0x3bf330]
MOV dword ptr [RAX],0xffffffff
LAB_001b1603:
JMP 0x001b1605
LAB_001b1605:
JMP 0x001b1607
LAB_001b1607:
MOV EAX,dword ptr [RBP + -0x21c]
MOV dword ptr [RBP + -0x214],EAX
LAB_001b1613:
MOV EAX,dword ptr [RBP + -0x214]
MOV dword ptr [RBP + -0x228],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001b1640
MOV EAX,dword ptr [RBP + -0x228]
ADD RSP,0x230
POP RBP
RET
LAB_001b1640:
CALL 0x0012a250
|
int4 mi_log(int param_1)
{
int4 uVar1;
__pid_t _Var2;
int iVar3;
int8 uVar4;
int4 *puVar5;
long in_FS_OFFSET;
int4 local_22c;
int4 local_224;
int4 local_21c;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_224 = 0;
log_type = param_1;
if (param_1 == 0) {
if (-1 < myisam_log_file) {
iVar3 = inline_mysql_file_close
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",0x3b,
myisam_log_file,0);
if (iVar3 == 0) {
local_22c = 0;
}
else {
puVar5 = (int4 *)_my_thread_var();
local_22c = *puVar5;
}
local_224 = local_22c;
myisam_log_file = -1;
}
}
else {
if (myisam_pid == 0) {
_Var2 = getpid();
myisam_pid = (long)_Var2;
}
uVar1 = mi_key_file_log;
if (myisam_log_file < 0) {
uVar4 = fn_format(local_218,myisam_log_filename,&DAT_00257aca,".log",4);
myisam_log_file =
inline_mysql_file_create
(uVar1,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",0x35,
uVar4,0,0x402,0);
if (myisam_log_file < 0) {
puVar5 = (int4 *)_my_thread_var();
local_21c = *puVar5;
goto LAB_001b1613;
}
}
}
local_21c = local_224;
LAB_001b1613:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_21c;
}
| |
38,104 | mi_log | eloqsql/storage/myisam/mi_log.c | int mi_log(int activate_log)
{
int error=0;
char buff[FN_REFLEN];
DBUG_ENTER("mi_log");
log_type=activate_log;
if (activate_log)
{
if (!myisam_pid)
myisam_pid=(ulong) getpid();
if (myisam_log_file < 0)
{
if ((myisam_log_file= mysql_file_create(mi_key_file_log,
fn_format(buff,
myisam_log_filename,
"", ".log", 4),
0,
(O_RDWR | O_BINARY | O_APPEND),
MYF(0))) < 0)
DBUG_RETURN(my_errno);
}
}
else if (myisam_log_file >= 0)
{
error= mysql_file_close(myisam_log_file, MYF(0)) ? my_errno : 0 ;
myisam_log_file= -1;
}
DBUG_RETURN(error);
} | O3 | c | mi_log:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x270, %rsp # imm = 0x270
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
movl %edi, 0xb82b3b(%rip) # 0xbff548
testl %edi, %edi
je 0x7cacd
cmpq $0x0, 0xb82b23(%rip) # 0xbff540
jne 0x7ca2d
callq 0x298f0
cltq
movq %rax, 0xb82b13(%rip) # 0xbff540
leaq 0x3088fc(%rip), %r12 # 0x385330
cmpl $0x0, (%r12)
jns 0x7cb14
leaq 0xb82ada(%rip), %rax # 0xbff520
movl (%rax), %r14d
leaq 0x3088d8(%rip), %rax # 0x385328
movq (%rax), %rsi
leaq 0x631ec(%rip), %rdx # 0xdfc46
leaq 0x5ecba(%rip), %rcx # 0xdb71b
leaq -0x230(%rbp), %rdi
movl $0x4, %r8d
callq 0x947d0
movq %rax, %rbx
leaq 0x309593(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x288(%rbp), %rdi
leaq -0x238(%rbp), %r15
movl %r14d, %esi
xorl %edx, %edx
movq %rbx, %rcx
movq %r15, %r8
callq *0x148(%rax)
movq %rax, (%r15)
testq %rax, %rax
jne 0x7cb40
movq %rbx, %rdi
xorl %esi, %esi
movl $0x402, %edx # imm = 0x402
xorl %ecx, %ecx
callq 0x9dcd4
movl %eax, (%r12)
testl %eax, %eax
jns 0x7cb14
callq 0xa1ac2
movl (%rax), %eax
jmp 0x7cb21
leaq 0x30885c(%rip), %r15 # 0x385330
movl (%r15), %ebx
testl %ebx, %ebx
js 0x7cb14
leaq 0x30952e(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x230(%rbp), %rdi
movl %ebx, %esi
movl $0x4, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x7cb64
movl %ebx, %edi
xorl %esi, %esi
callq 0xa0525
testl %eax, %eax
je 0x7cb18
callq 0xa1ac2
movl (%rax), %eax
jmp 0x7cb1a
xorl %eax, %eax
jmp 0x7cb21
xorl %eax, %eax
movl $0xffffffff, (%r15) # imm = 0xFFFFFFFF
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0x7cb7d
addq $0x270, %rsp # imm = 0x270
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x238(%rbp), %rdx
leaq -0x23c(%rbp), %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x2db3e
movl (%r14), %eax
jmp 0x7cabc
leaq -0x288(%rbp), %r14
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x2db99
movl (%r14), %eax
jmp 0x7cb07
callq 0x29250
| mi_log:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 270h
mov rax, fs:28h
mov [rbp+var_28], rax
mov cs:log_type, edi
test edi, edi
jz loc_7CACD
cmp cs:myisam_pid, 0
jnz short loc_7CA2D
call _getpid
cdqe
mov cs:myisam_pid, rax
loc_7CA2D:
lea r12, myisam_log_file
cmp dword ptr [r12], 0
jns loc_7CB14
lea rax, mi_key_file_log
mov r14d, [rax]
lea rax, myisam_log_filename
mov rsi, [rax]
lea rdx, asc_DFC42+4; ""
lea rcx, aMyisamLog+6; ".log"
lea rdi, [rbp+var_230]
mov r8d, 4
call fn_format
mov rbx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_288]
lea r15, [rbp+var_238]
mov esi, r14d
xor edx, edx
mov rcx, rbx
mov r8, r15
call qword ptr [rax+148h]
mov [r15], rax
test rax, rax
jnz loc_7CB40
mov rdi, rbx
xor esi, esi
mov edx, 402h
xor ecx, ecx
call my_create
loc_7CABC:
mov [r12], eax
test eax, eax
jns short loc_7CB14
call _my_thread_var
mov eax, [rax]
jmp short loc_7CB21
loc_7CACD:
lea r15, myisam_log_file
mov ebx, [r15]
test ebx, ebx
js short loc_7CB14
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_230]
mov esi, ebx
mov edx, 4
call qword ptr [rax+158h]
test rax, rax
jnz short loc_7CB64
mov edi, ebx
xor esi, esi
call my_close
loc_7CB07:
test eax, eax
jz short loc_7CB18
call _my_thread_var
mov eax, [rax]
jmp short loc_7CB1A
loc_7CB14:
xor eax, eax
jmp short loc_7CB21
loc_7CB18:
xor eax, eax
loc_7CB1A:
mov dword ptr [r15], 0FFFFFFFFh
loc_7CB21:
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_7CB7D
add rsp, 270h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_7CB40:
lea rdx, [rbp+var_238]
lea r14, [rbp+var_23C]
mov rdi, rax
mov rsi, rbx
mov rcx, r14
call mi_log_cold_1
mov eax, [r14]
jmp loc_7CABC
loc_7CB64:
lea r14, [rbp+var_288]
mov rdi, rax
mov esi, ebx
mov rdx, r14
call mi_log_cold_2
mov eax, [r14]
jmp short loc_7CB07
loc_7CB7D:
call ___stack_chk_fail
| long long mi_log(int a1)
{
unsigned int v1; // r14d
long long v2; // rbx
long long v3; // rax
long long v4; // rdi
int v5; // eax
long long result; // rax
unsigned int v7; // ebx
long long v8; // rax
long long v9; // rdi
unsigned int v10; // eax
unsigned int v11[19]; // [rsp+8h] [rbp-288h] BYREF
int v12; // [rsp+54h] [rbp-23Ch] BYREF
long long v13; // [rsp+58h] [rbp-238h] BYREF
_BYTE v14[520]; // [rsp+60h] [rbp-230h] BYREF
unsigned long long v15; // [rsp+268h] [rbp-28h]
v15 = __readfsqword(0x28u);
log_type = a1;
if ( a1 )
{
if ( !myisam_pid )
myisam_pid = (int)getpid();
if ( (myisam_log_file & 0x80000000) != 0 )
{
v1 = mi_key_file_log;
v2 = fn_format(v14, myisam_log_filename, "", ".log", 4LL);
v3 = ((long long ( *)(unsigned int *, _QWORD, _QWORD, long long, long long *))PSI_server[41])(
v11,
v1,
0LL,
v2,
&v13);
v13 = v3;
if ( v3 )
{
v4 = v3;
mi_log_cold_1(v3, v2, &v13, (unsigned int *)&v12);
v5 = v12;
}
else
{
v4 = v2;
v5 = my_create(v2, 0LL, 1026LL, 0LL);
}
myisam_log_file = v5;
if ( v5 < 0 )
return *(unsigned int *)my_thread_var(v4);
}
return 0LL;
}
v7 = myisam_log_file;
if ( (myisam_log_file & 0x80000000) != 0 )
return 0LL;
v8 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v14, myisam_log_file, 4LL);
if ( v8 )
{
v9 = v8;
mi_log_cold_2(v8, v7, v11);
v10 = v11[0];
}
else
{
v9 = v7;
v10 = my_close(v7, 0LL);
}
if ( v10 )
result = *(unsigned int *)my_thread_var(v9);
else
result = 0LL;
myisam_log_file = -1;
return result;
}
| mi_log:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x270
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV dword ptr [0x00cff548],EDI
TEST EDI,EDI
JZ 0x0017cacd
CMP qword ptr [0x00cff540],0x0
JNZ 0x0017ca2d
CALL 0x001298f0
CDQE
MOV qword ptr [0x00cff540],RAX
LAB_0017ca2d:
LEA R12,[0x485330]
CMP dword ptr [R12],0x0
JNS 0x0017cb14
LEA RAX,[0xcff520]
MOV R14D,dword ptr [RAX]
LEA RAX,[0x485328]
MOV RSI,qword ptr [RAX]
LEA RDX,[0x1dfc46]
LEA RCX,[0x1db71b]
LEA RDI,[RBP + -0x230]
MOV R8D,0x4
CALL 0x001947d0
MOV RBX,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x288]
LEA R15,[RBP + -0x238]
MOV ESI,R14D
XOR EDX,EDX
MOV RCX,RBX
MOV R8,R15
CALL qword ptr [RAX + 0x148]
MOV qword ptr [R15],RAX
TEST RAX,RAX
JNZ 0x0017cb40
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x402
XOR ECX,ECX
CALL 0x0019dcd4
LAB_0017cabc:
MOV dword ptr [R12],EAX
TEST EAX,EAX
JNS 0x0017cb14
CALL 0x001a1ac2
MOV EAX,dword ptr [RAX]
JMP 0x0017cb21
LAB_0017cacd:
LEA R15,[0x485330]
MOV EBX,dword ptr [R15]
TEST EBX,EBX
JS 0x0017cb14
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x230]
MOV ESI,EBX
MOV EDX,0x4
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0017cb64
MOV EDI,EBX
XOR ESI,ESI
CALL 0x001a0525
LAB_0017cb07:
TEST EAX,EAX
JZ 0x0017cb18
CALL 0x001a1ac2
MOV EAX,dword ptr [RAX]
JMP 0x0017cb1a
LAB_0017cb14:
XOR EAX,EAX
JMP 0x0017cb21
LAB_0017cb18:
XOR EAX,EAX
LAB_0017cb1a:
MOV dword ptr [R15],0xffffffff
LAB_0017cb21:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x0017cb7d
ADD RSP,0x270
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0017cb40:
LEA RDX,[RBP + -0x238]
LEA R14,[RBP + -0x23c]
MOV RDI,RAX
MOV RSI,RBX
MOV RCX,R14
CALL 0x0012db3e
MOV EAX,dword ptr [R14]
JMP 0x0017cabc
LAB_0017cb64:
LEA R14,[RBP + -0x288]
MOV RDI,RAX
MOV ESI,EBX
MOV RDX,R14
CALL 0x0012db99
MOV EAX,dword ptr [R14]
JMP 0x0017cb07
LAB_0017cb7d:
CALL 0x00129250
|
int4 mi_log(int param_1)
{
int iVar1;
__pid_t _Var2;
int4 uVar3;
int8 uVar4;
int4 *puVar5;
long lVar6;
long in_FS_OFFSET;
int local_290 [19];
int local_244;
long local_240;
int1 local_238 [520];
long local_30;
iVar1 = myisam_log_file;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
log_type = param_1;
if (param_1 == 0) {
if (-1 < myisam_log_file) {
lVar6 = (**(code **)(PSI_server + 0x158))(local_238,myisam_log_file,4);
if (lVar6 == 0) {
local_290[0] = my_close(iVar1,0);
}
else {
mi_log_cold_2(lVar6,iVar1,local_290);
}
if (local_290[0] == 0) {
uVar3 = 0;
}
else {
puVar5 = (int4 *)_my_thread_var();
uVar3 = *puVar5;
}
myisam_log_file = -1;
goto LAB_0017cb21;
}
}
else {
if (myisam_pid == 0) {
_Var2 = getpid();
myisam_pid = (long)_Var2;
}
uVar3 = mi_key_file_log;
if (myisam_log_file < 0) {
uVar4 = fn_format(local_238,myisam_log_filename,&DAT_001dfc46,".log",4);
local_240 = (**(code **)(PSI_server + 0x148))(local_290,uVar3,0,uVar4,&local_240);
if (local_240 == 0) {
local_244 = my_create(uVar4,0,0x402,0);
}
else {
mi_log_cold_1(local_240,uVar4,&local_240,&local_244);
}
myisam_log_file = local_244;
if (local_244 < 0) {
puVar5 = (int4 *)_my_thread_var();
uVar3 = *puVar5;
goto LAB_0017cb21;
}
}
}
uVar3 = 0;
LAB_0017cb21:
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return uVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
38,105 | ma_net_flush | eloqsql/libmariadb/libmariadb/ma_net.c | int ma_net_flush(NET *net)
{
int error=0;
/* don't flush if pipelined query is in progress */
if (net->extension->multi_status > COM_MULTI_OFF)
return 0;
if (net->buff != net->write_pos)
{
error=ma_net_real_write(net,(char*) net->buff,
(size_t) (net->write_pos - net->buff));
net->write_pos=net->buff;
}
if (net->compress)
net->pkt_nr= net->compress_pkt_nr;
return(error);
} | O0 | c | ma_net_flush:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x2a0(%rax), %rax
cmpl $0x0, (%rax)
jbe 0x6035c
movl $0x0, -0x4(%rbp)
jmp 0x603c6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x603a5
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq %rax, %rdx
callq 0x603d0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x84(%rax)
je 0x603c0
movq -0x10(%rbp), %rax
movl 0x64(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x60(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| ma_net_flush:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], 0
mov rax, [rbp+var_10]
mov rax, [rax+2A0h]
cmp dword ptr [rax], 0
jbe short loc_6035C
mov [rbp+var_4], 0
jmp short loc_603C6
loc_6035C:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rcx, [rbp+var_10]
cmp rax, [rcx+18h]
jz short loc_603A5
mov rdi, [rbp+var_10]
mov rax, [rbp+var_10]
mov rsi, [rax+8]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
mov rax, [rbp+var_10]
mov rax, [rax+8]
sub rdx, rax
call ma_net_real_write
mov [rbp+var_14], eax
mov rax, [rbp+var_10]
mov rcx, [rax+8]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
loc_603A5:
mov rax, [rbp+var_10]
cmp byte ptr [rax+84h], 0
jz short loc_603C0
mov rax, [rbp+var_10]
mov ecx, [rax+64h]
mov rax, [rbp+var_10]
mov [rax+60h], ecx
loc_603C0:
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
loc_603C6:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long ma_net_flush(long long a1)
{
unsigned int v2; // [rsp+Ch] [rbp-14h]
v2 = 0;
if ( **(_DWORD **)(a1 + 672) )
{
return 0;
}
else
{
if ( *(_QWORD *)(a1 + 8) != *(_QWORD *)(a1 + 24) )
{
v2 = ma_net_real_write(a1, *(_QWORD *)(a1 + 8), *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 8));
*(_QWORD *)(a1 + 24) = *(_QWORD *)(a1 + 8);
}
if ( *(_BYTE *)(a1 + 132) )
*(_DWORD *)(a1 + 96) = *(_DWORD *)(a1 + 100);
return v2;
}
}
| ma_net_flush:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2a0]
CMP dword ptr [RAX],0x0
JBE 0x0016035c
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001603c6
LAB_0016035c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x18]
JZ 0x001603a5
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
SUB RDX,RAX
CALL 0x001603d0
MOV dword ptr [RBP + -0x14],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
LAB_001603a5:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x84],0x0
JZ 0x001603c0
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x64]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x60],ECX
LAB_001603c0:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
LAB_001603c6:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 ma_net_flush(long param_1)
{
int4 local_1c;
int4 local_c;
local_1c = 0;
if (**(int **)(param_1 + 0x2a0) == 0) {
if (*(long *)(param_1 + 8) != *(long *)(param_1 + 0x18)) {
local_1c = ma_net_real_write(param_1,*(int8 *)(param_1 + 8),
*(long *)(param_1 + 0x18) - *(long *)(param_1 + 8));
*(int8 *)(param_1 + 0x18) = *(int8 *)(param_1 + 8);
}
if (*(char *)(param_1 + 0x84) != '\0') {
*(int4 *)(param_1 + 0x60) = *(int4 *)(param_1 + 100);
}
local_c = local_1c;
}
else {
local_c = 0;
}
return local_c;
}
| |
38,106 | js_object_list_resize_hash | bluesky950520[P]quickjs/quickjs.c | static int js_object_list_resize_hash(JSContext *ctx, JSObjectList *s,
uint32_t new_hash_size)
{
JSObjectListEntry *e;
uint32_t i, h, *new_hash_table;
new_hash_table = js_malloc(ctx, sizeof(new_hash_table[0]) * new_hash_size);
if (!new_hash_table)
return -1;
js_free(ctx, s->hash_table);
s->hash_table = new_hash_table;
s->hash_size = new_hash_size;
for(i = 0; i < s->hash_size; i++) {
s->hash_table[i] = -1;
}
for(i = 0; i < s->object_count; i++) {
e = &s->object_tab[i];
h = js_object_list_get_hash(e->obj, s->hash_size);
e->hash_next = s->hash_table[h];
s->hash_table[h] = i;
}
return 0;
} | O0 | c | js_object_list_resize_hash:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
shlq $0x2, %rsi
callq 0x21cb0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x79ede
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x79fc9
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x21db0
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x18(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x79f41
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0xc(%rsp), %ecx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x79f12
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x79fc1
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movl 0x18(%rax), %esi
callq 0x79e70
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x8(%rsp), %ecx
movl (%rax,%rcx,4), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0xc(%rsp), %edx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x8(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x79f49
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| js_object_list_resize_hash:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_1C], edx
mov rdi, [rsp+38h+var_10]
mov eax, [rsp+38h+var_1C]
mov esi, eax
shl rsi, 2
call js_malloc
mov [rsp+38h+var_38], rax
cmp [rsp+38h+var_38], 0
jnz short loc_79EDE
mov [rsp+38h+var_4], 0FFFFFFFFh
jmp loc_79FC9
loc_79EDE:
mov rdi, [rsp+38h+var_10]
mov rax, [rsp+38h+var_18]
mov rsi, [rax+10h]
call js_free
mov rcx, [rsp+38h+var_38]
mov rax, [rsp+38h+var_18]
mov [rax+10h], rcx
mov ecx, [rsp+38h+var_1C]
mov rax, [rsp+38h+var_18]
mov [rax+18h], ecx
mov [rsp+38h+var_2C], 0
loc_79F12:
mov eax, [rsp+38h+var_2C]
mov rcx, [rsp+38h+var_18]
cmp eax, [rcx+18h]
jnb short loc_79F41
mov rax, [rsp+38h+var_18]
mov rax, [rax+10h]
mov ecx, [rsp+38h+var_2C]
mov dword ptr [rax+rcx*4], 0FFFFFFFFh
mov eax, [rsp+38h+var_2C]
add eax, 1
mov [rsp+38h+var_2C], eax
jmp short loc_79F12
loc_79F41:
mov [rsp+38h+var_2C], 0
loc_79F49:
mov eax, [rsp+38h+var_2C]
mov rcx, [rsp+38h+var_18]
cmp eax, [rcx+8]
jnb short loc_79FC1
mov rax, [rsp+38h+var_18]
mov rax, [rax]
mov ecx, [rsp+38h+var_2C]
shl rcx, 4
add rax, rcx
mov [rsp+38h+var_28], rax
mov rax, [rsp+38h+var_28]
mov rdi, [rax]
mov rax, [rsp+38h+var_18]
mov esi, [rax+18h]
call js_object_list_get_hash
mov [rsp+38h+var_30], eax
mov rax, [rsp+38h+var_18]
mov rax, [rax+10h]
mov ecx, [rsp+38h+var_30]
mov ecx, [rax+rcx*4]
mov rax, [rsp+38h+var_28]
mov [rax+8], ecx
mov edx, [rsp+38h+var_2C]
mov rax, [rsp+38h+var_18]
mov rax, [rax+10h]
mov ecx, [rsp+38h+var_30]
mov [rax+rcx*4], edx
mov eax, [rsp+38h+var_2C]
add eax, 1
mov [rsp+38h+var_2C], eax
jmp short loc_79F49
loc_79FC1:
mov [rsp+38h+var_4], 0
loc_79FC9:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| long long js_object_list_resize_hash(long long a1, long long a2, unsigned int a3)
{
long long v4; // [rsp+0h] [rbp-38h]
unsigned int hash; // [rsp+8h] [rbp-30h]
unsigned int i; // [rsp+Ch] [rbp-2Ch]
unsigned int j; // [rsp+Ch] [rbp-2Ch]
long long v8; // [rsp+10h] [rbp-28h]
v4 = js_malloc(a1, 4LL * a3);
if ( v4 )
{
js_free(a1, *(_QWORD *)(a2 + 16));
*(_QWORD *)(a2 + 16) = v4;
*(_DWORD *)(a2 + 24) = a3;
for ( i = 0; i < *(_DWORD *)(a2 + 24); ++i )
*(_DWORD *)(*(_QWORD *)(a2 + 16) + 4LL * i) = -1;
for ( j = 0; j < *(_DWORD *)(a2 + 8); ++j )
{
v8 = 16LL * j + *(_QWORD *)a2;
hash = js_object_list_get_hash(*(_QWORD *)v8, *(_DWORD *)(a2 + 24));
*(_DWORD *)(v8 + 8) = *(_DWORD *)(*(_QWORD *)(a2 + 16) + 4LL * hash);
*(_DWORD *)(*(_QWORD *)(a2 + 16) + 4LL * hash) = j;
}
return 0;
}
else
{
return (unsigned int)-1;
}
}
| js_object_list_resize_hash:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV dword ptr [RSP + 0x1c],EDX
MOV RDI,qword ptr [RSP + 0x28]
MOV EAX,dword ptr [RSP + 0x1c]
MOV ESI,EAX
SHL RSI,0x2
CALL 0x00121cb0
MOV qword ptr [RSP],RAX
CMP qword ptr [RSP],0x0
JNZ 0x00179ede
MOV dword ptr [RSP + 0x34],0xffffffff
JMP 0x00179fc9
LAB_00179ede:
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x10]
CALL 0x00121db0
MOV RCX,qword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x10],RCX
MOV ECX,dword ptr [RSP + 0x1c]
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX + 0x18],ECX
MOV dword ptr [RSP + 0xc],0x0
LAB_00179f12:
MOV EAX,dword ptr [RSP + 0xc]
MOV RCX,qword ptr [RSP + 0x20]
CMP EAX,dword ptr [RCX + 0x18]
JNC 0x00179f41
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RSP + 0xc]
MOV dword ptr [RAX + RCX*0x4],0xffffffff
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x00179f12
LAB_00179f41:
MOV dword ptr [RSP + 0xc],0x0
LAB_00179f49:
MOV EAX,dword ptr [RSP + 0xc]
MOV RCX,qword ptr [RSP + 0x20]
CMP EAX,dword ptr [RCX + 0x8]
JNC 0x00179fc1
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RSP + 0xc]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RAX + 0x18]
CALL 0x00179e70
MOV dword ptr [RSP + 0x8],EAX
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RSP + 0x8]
MOV ECX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RAX + 0x8],ECX
MOV EDX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RSP + 0x8]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x00179f49
LAB_00179fc1:
MOV dword ptr [RSP + 0x34],0x0
LAB_00179fc9:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int4 js_object_list_resize_hash(int8 param_1,long *param_2,uint param_3)
{
uint uVar1;
long lVar2;
int8 *puVar3;
uint local_2c;
int4 local_4;
lVar2 = js_malloc(param_1,(ulong)param_3 << 2);
if (lVar2 == 0) {
local_4 = 0xffffffff;
}
else {
js_free(param_1,param_2[2]);
param_2[2] = lVar2;
*(uint *)(param_2 + 3) = param_3;
for (local_2c = 0; local_2c < *(uint *)(param_2 + 3); local_2c = local_2c + 1) {
*(int4 *)(param_2[2] + (ulong)local_2c * 4) = 0xffffffff;
}
for (local_2c = 0; local_2c < *(uint *)(param_2 + 1); local_2c = local_2c + 1) {
puVar3 = (int8 *)(*param_2 + (ulong)local_2c * 0x10);
uVar1 = js_object_list_get_hash(*puVar3,(int)param_2[3]);
*(int4 *)(puVar3 + 1) = *(int4 *)(param_2[2] + (ulong)uVar1 * 4);
*(uint *)(param_2[2] + (ulong)uVar1 * 4) = local_2c;
}
local_4 = 0;
}
return local_4;
}
| |
38,107 | ma_block_start_trans | eloqsql/storage/maria/ma_state.c | my_bool _ma_block_start_trans(void* param)
{
MARIA_HA *info=(MARIA_HA*) param;
DBUG_ENTER("_ma_block_start_trans");
if (info->s->lock_key_trees)
{
/*
Assume for now that this doesn't fail (It can only fail in
out of memory conditions)
TODO: Fix this by having one extra state pre-allocated
*/
DBUG_RETURN(_ma_setup_live_state(info));
}
else
{
/*
We come here in the following cases:
- The table is a temporary table
- It's a table which is crash safe but not yet versioned, for
example a table with fulltext or rtree keys
Set the current state to point to save_state so that the
block_format code don't count the same record twice.
Copy also the current state. This may have been wrong if the
same file was used several times in the last statement
*/
info->state= info->state_start;
*info->state= info->s->state.state;
}
/*
Info->trn is set if this table is already handled and we are
called from maria_versioning()
*/
if (info->s->base.born_transactional && !info->trn)
{
/*
Assume for now that this doesn't fail (It can only fail in
out of memory conditions)
*/
DBUG_RETURN(maria_create_trn_hook(info) != 0);
}
DBUG_RETURN(0);
} | O3 | c | ma_block_start_trans:
movq (%rdi), %rax
cmpb $0x0, 0x7e3(%rax)
jne 0x39174
movq 0x60(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq 0x48(%rax), %rdx
movq %rdx, 0x30(%rcx)
movups 0x18(%rax), %xmm0
movups 0x28(%rax), %xmm1
movups 0x38(%rax), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
movq (%rdi), %rax
cmpb $0x0, 0x44c(%rax)
je 0x39af9
cmpq $0x0, 0x8(%rdi)
je 0x39afc
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x3c5781(%rip), %rax # 0x3ff288
callq *(%rax)
testl %eax, %eax
setne %al
popq %rbp
retq
| _ma_block_start_trans:
mov rax, [rdi]
cmp byte ptr [rax+7E3h], 0
jnz _ma_setup_live_state
mov rcx, [rdi+60h]
mov [rdi+20h], rcx
mov rdx, [rax+48h]
mov [rcx+30h], rdx
movups xmm0, xmmword ptr [rax+18h]
movups xmm1, xmmword ptr [rax+28h]
movups xmm2, xmmword ptr [rax+38h]
movups xmmword ptr [rcx+20h], xmm2
movups xmmword ptr [rcx+10h], xmm1
movups xmmword ptr [rcx], xmm0
mov rax, [rdi]
cmp byte ptr [rax+44Ch], 0
jz short loc_39AF9
cmp qword ptr [rdi+8], 0
jz short loc_39AFC
loc_39AF9:
xor eax, eax
retn
loc_39AFC:
push rbp
mov rbp, rsp
lea rax, maria_create_trn_hook
call qword ptr [rax]
test eax, eax
setnz al
pop rbp
retn
| char ma_block_start_trans(long long *a1)
{
long long v1; // rax
long long v2; // rcx
__int128 v3; // xmm0
__int128 v4; // xmm1
v1 = *a1;
if ( *(_BYTE *)(*a1 + 2019) )
return ma_setup_live_state(a1);
v2 = a1[12];
a1[4] = v2;
*(_QWORD *)(v2 + 48) = *(_QWORD *)(v1 + 72);
v3 = *(_OWORD *)(v1 + 24);
v4 = *(_OWORD *)(v1 + 40);
*(_OWORD *)(v2 + 32) = *(_OWORD *)(v1 + 56);
*(_OWORD *)(v2 + 16) = v4;
*(_OWORD *)v2 = v3;
return *(_BYTE *)(*a1 + 1100) && !a1[1] && (unsigned int)maria_create_trn_hook(a1) != 0;
}
| _ma_block_start_trans:
MOV RAX,qword ptr [RDI]
CMP byte ptr [RAX + 0x7e3],0x0
JNZ 0x00139174
MOV RCX,qword ptr [RDI + 0x60]
MOV qword ptr [RDI + 0x20],RCX
MOV RDX,qword ptr [RAX + 0x48]
MOV qword ptr [RCX + 0x30],RDX
MOVUPS XMM0,xmmword ptr [RAX + 0x18]
MOVUPS XMM1,xmmword ptr [RAX + 0x28]
MOVUPS XMM2,xmmword ptr [RAX + 0x38]
MOVUPS xmmword ptr [RCX + 0x20],XMM2
MOVUPS xmmword ptr [RCX + 0x10],XMM1
MOVUPS xmmword ptr [RCX],XMM0
MOV RAX,qword ptr [RDI]
CMP byte ptr [RAX + 0x44c],0x0
JZ 0x00139af9
CMP qword ptr [RDI + 0x8],0x0
JZ 0x00139afc
LAB_00139af9:
XOR EAX,EAX
RET
LAB_00139afc:
PUSH RBP
MOV RBP,RSP
LEA RAX,[0x4ff288]
CALL qword ptr [RAX]
TEST EAX,EAX
SETNZ AL
POP RBP
RET
|
bool _ma_block_start_trans(long *param_1)
{
pthread_mutex_t *__mutex;
long lVar1;
long lVar2;
int4 *puVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
int4 uVar8;
int4 uVar9;
int4 uVar10;
int4 uVar11;
int4 uVar12;
int4 uVar13;
int4 uVar14;
long lVar15;
long lVar16;
long lVar17;
long lVar18;
int iVar19;
long *plVar20;
long *plVar21;
lVar2 = *param_1;
if (*(char *)(lVar2 + 0x7e3) == '\0') {
puVar3 = (int4 *)param_1[0xc];
param_1[4] = (long)puVar3;
*(int8 *)(puVar3 + 0xc) = *(int8 *)(lVar2 + 0x48);
uVar4 = *(int4 *)(lVar2 + 0x18);
uVar5 = *(int4 *)(lVar2 + 0x1c);
uVar6 = *(int4 *)(lVar2 + 0x20);
uVar7 = *(int4 *)(lVar2 + 0x24);
uVar8 = *(int4 *)(lVar2 + 0x28);
uVar9 = *(int4 *)(lVar2 + 0x2c);
uVar10 = *(int4 *)(lVar2 + 0x30);
uVar11 = *(int4 *)(lVar2 + 0x34);
uVar12 = *(int4 *)(lVar2 + 0x3c);
uVar13 = *(int4 *)(lVar2 + 0x40);
uVar14 = *(int4 *)(lVar2 + 0x44);
puVar3[8] = *(int4 *)(lVar2 + 0x38);
puVar3[9] = uVar12;
puVar3[10] = uVar13;
puVar3[0xb] = uVar14;
puVar3[4] = uVar8;
puVar3[5] = uVar9;
puVar3[6] = uVar10;
puVar3[7] = uVar11;
*puVar3 = uVar4;
puVar3[1] = uVar5;
puVar3[2] = uVar6;
puVar3[3] = uVar7;
if ((*(char *)(*param_1 + 0x44c) != '\0') && (param_1[1] == 0)) {
iVar19 = (*maria_create_trn_hook)();
return iVar19 != 0;
}
return false;
}
lVar2 = *param_1;
iVar19 = (*maria_create_trn_hook)();
if (iVar19 != 0) {
return true;
}
lVar1 = param_1[1];
plVar21 = (long *)(lVar1 + 0x58);
plVar20 = plVar21;
while (plVar20 = (long *)*plVar20, plVar20 != (long *)0x0) {
if (plVar20[1] == lVar2) goto LAB_00139294;
}
plVar20 = (long *)my_malloc(0,0x88,0x30);
if (plVar20 == (long *)0x0) {
return true;
}
*plVar20 = *plVar21;
*plVar21 = (long)plVar20;
plVar20[1] = lVar2;
__mutex = (pthread_mutex_t *)(lVar2 + 0x8f0);
if (*(long *)(lVar2 + 0x930) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c",0x59)
;
}
*(int *)(lVar2 + 0x7ac) = *(int *)(lVar2 + 0x7ac) + 1;
plVar21 = (long *)(lVar2 + 0x450);
do {
plVar21 = (long *)*plVar21;
} while (*(ulong *)(lVar1 + 0x78) <= (ulong)plVar21[1]);
if (*(long *)(lVar2 + 0x930) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
lVar2 = plVar21[3];
lVar1 = plVar21[4];
lVar15 = plVar21[5];
lVar16 = plVar21[6];
lVar17 = plVar21[7];
plVar20[2] = plVar21[2];
plVar20[3] = lVar2;
plVar20[4] = lVar1;
plVar20[5] = lVar15;
plVar20[6] = lVar16;
plVar20[7] = lVar17;
plVar20[8] = plVar21[8];
lVar2 = plVar21[8];
lVar1 = plVar21[2];
lVar15 = plVar21[3];
lVar16 = plVar21[4];
lVar17 = plVar21[5];
lVar18 = plVar21[7];
plVar20[0xd] = plVar21[6];
plVar20[0xe] = lVar18;
plVar20[9] = lVar1;
plVar20[10] = lVar15;
plVar20[0xf] = lVar2;
plVar20[0xb] = lVar16;
plVar20[0xc] = lVar17;
*(byte *)((long)plVar20 + 0x44) = *(byte *)((long)plVar20 + 0x44) & 0xfc;
LAB_00139294:
param_1[0xc] = (long)(plVar20 + 9);
param_1[4] = (long)(plVar20 + 2);
param_1[0xd] = (long)plVar20;
*(int *)(plVar20 + 0x10) = (int)plVar20[0x10] + 1;
*(byte *)((long)plVar20 + 0x44) =
*(byte *)((long)plVar20 + 0x44) | ~*(byte *)(param_1 + 0xc3) * '\x02' & 2;
return false;
}
| |
38,108 | resize_simple_key_cache | eloqsql/mysys/mf_keycache.c | static
int resize_simple_key_cache(SIMPLE_KEY_CACHE_CB *keycache,
uint key_cache_block_size,
size_t use_mem, uint division_limit,
uint age_threshold, uint changed_blocks_hash_size)
{
int blocks= 0;
DBUG_ENTER("resize_simple_key_cache");
DBUG_ASSERT(keycache->key_cache_inited);
/*
Note that the cache_lock mutex and the resize_queue are left untouched.
We do not lose the cache_lock and will release it only at the end of
this function.
*/
if (prepare_resize_simple_key_cache(keycache, 0))
goto finish;
/* The following will work even if use_mem is 0 */
blocks= init_simple_key_cache(keycache, key_cache_block_size, use_mem,
division_limit, age_threshold,
changed_blocks_hash_size);
finish:
finish_resize_simple_key_cache(keycache);
DBUG_RETURN(blocks);
} | O3 | c | resize_simple_key_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, -0x30(%rbp)
movl %r8d, -0x2c(%rbp)
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
xorl %r13d, %r13d
xorl %esi, %esi
callq 0xb62ca
testl %eax, %eax
jne 0xb57b0
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %r12d, %ecx
movl -0x2c(%rbp), %r8d
movl -0x30(%rbp), %r9d
callq 0xb52b5
movl %eax, %r13d
movq %rbx, %rdi
callq 0xb64ae
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| resize_simple_key_cache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rbp+var_30], r9d
mov [rbp+var_2C], r8d
mov r12d, ecx
mov r14, rdx
mov r15d, esi
mov rbx, rdi
xor r13d, r13d
xor esi, esi
call prepare_resize_simple_key_cache
test eax, eax
jnz short loc_B57B0
mov rdi, rbx
mov esi, r15d
mov rdx, r14
mov ecx, r12d
mov r8d, [rbp+var_2C]
mov r9d, [rbp+var_30]
call init_simple_key_cache
mov r13d, eax
loc_B57B0:
mov rdi, rbx
call finish_resize_simple_key_cache
mov eax, r13d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long resize_simple_key_cache(
char *a1,
unsigned int a2,
unsigned long long a3,
unsigned int a4,
unsigned int a5,
unsigned int a6)
{
unsigned int inited; // r13d
inited = 0;
if ( !(unsigned int)prepare_resize_simple_key_cache(a1, 0LL) )
inited = init_simple_key_cache(a1, a2, a3, a4, a5, a6);
finish_resize_simple_key_cache(a1);
return inited;
}
| resize_simple_key_cache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV dword ptr [RBP + -0x30],R9D
MOV dword ptr [RBP + -0x2c],R8D
MOV R12D,ECX
MOV R14,RDX
MOV R15D,ESI
MOV RBX,RDI
XOR R13D,R13D
XOR ESI,ESI
CALL 0x001b62ca
TEST EAX,EAX
JNZ 0x001b57b0
MOV RDI,RBX
MOV ESI,R15D
MOV RDX,R14
MOV ECX,R12D
MOV R8D,dword ptr [RBP + -0x2c]
MOV R9D,dword ptr [RBP + -0x30]
CALL 0x001b52b5
MOV R13D,EAX
LAB_001b57b0:
MOV RDI,RBX
CALL 0x001b64ae
MOV EAX,R13D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4
resize_simple_key_cache
(int8 param_1,int4 param_2,int8 param_3,int4 param_4,
int4 param_5,int4 param_6)
{
int iVar1;
int4 uVar2;
uVar2 = 0;
iVar1 = prepare_resize_simple_key_cache(param_1,0);
if (iVar1 == 0) {
uVar2 = init_simple_key_cache(param_1,param_2,param_3,param_4,param_5,param_6);
}
finish_resize_simple_key_cache(param_1);
return uVar2;
}
| |
38,109 | my_register_filename | eloqsql/mysys/my_open.c | File my_register_filename(File fd, const char *FileName, enum file_type
type_of_file, uint error_message_number, myf MyFlags)
{
DBUG_ENTER("my_register_filename");
if ((int) fd >= MY_FILE_MIN)
{
my_atomic_add32_explicit(&my_file_opened, 1, MY_MEMORY_ORDER_RELAXED);
if ((uint) fd >= my_file_limit || (MyFlags & MY_NO_REGISTER))
DBUG_RETURN(fd);
my_file_info[fd].name = my_strdup(key_memory_my_file_info, FileName, MyFlags);
statistic_increment(my_file_total_opened,&THR_LOCK_open);
my_file_info[fd].type = type_of_file;
DBUG_PRINT("exit",("fd: %d",fd));
DBUG_RETURN(fd);
}
my_errno= errno;
DBUG_PRINT("error",("Got error %d on open", my_errno));
if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
{
if (my_errno == EMFILE)
error_message_number= EE_OUT_OF_FILERESOURCES;
my_error(error_message_number,
MYF(ME_BELL | (MyFlags & (ME_NOTE | ME_ERROR_LOG))),
FileName, my_errno);
}
DBUG_RETURN(-1);
} | O0 | c | my_register_filename:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0xfbf06
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
leaq 0xb92110(%rip), %rcx # 0xc8df74
lock
xaddl %eax, (%rcx)
movl %eax, -0x28(%rbp)
movl -0x8(%rbp), %eax
leaq 0x1cbcbb(%rip), %rcx # 0x2c7b30
cmpl (%rcx), %eax
jae 0xfbe89
movq -0x20(%rbp), %rax
andq $0x2004, %rax # imm = 0x2004
cmpq $0x0, %rax
je 0xfbe96
jmp 0xfbe8b
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfbf7d
leaq 0xb92607(%rip), %rax # 0xc8e4a4
movl (%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xfb810
movq %rax, %rcx
leaq 0x1cbc82(%rip), %rax # 0x2c7b38
movq (%rax), %rax
movslq -0x8(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
leaq 0xb92092(%rip), %rax # 0xc8df60
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0xb92084(%rip), %rax # 0xc8df60
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
leaq 0x1cbc4f(%rip), %rax # 0x2c7b38
movq (%rax), %rax
movslq -0x8(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
jmp 0xfbefc
jmp 0xfbefe
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfbf7d
callq 0x29700
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
callq 0xfdd30
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0xfbf1c
movq -0x20(%rbp), %rax
andq $0x19, %rax
cmpq $0x0, %rax
je 0xfbf74
callq 0xfdd30
cmpl $0x18, (%rax)
jne 0xfbf3b
movl $0x17, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rax
andq $0x440, %rax # imm = 0x440
orq $0x4, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xfdd30
movl -0x44(%rbp), %edi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl (%rax), %ecx
movb $0x0, %al
callq 0xf76a0
jmp 0xfbf76
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_register_filename:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
mov [rbp+var_20], r8
cmp [rbp+var_8], 0
jl loc_FBF06
mov [rbp+var_24], 1
mov eax, [rbp+var_24]
lea rcx, my_file_opened
lock xadd [rcx], eax
mov [rbp+var_28], eax
mov eax, [rbp+var_8]
lea rcx, my_file_limit
cmp eax, [rcx]
jnb short loc_FBE89
mov rax, [rbp+var_20]
and rax, 2004h
cmp rax, 0
jz short loc_FBE96
loc_FBE89:
jmp short $+2
loc_FBE8B:
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
jmp loc_FBF7D
loc_FBE96:
lea rax, key_memory_my_file_info
mov edi, [rax]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_20]
call my_strdup
mov rcx, rax
lea rax, my_file_info
mov rax, [rax]
movsxd rdx, [rbp+var_8]
shl rdx, 4
add rax, rdx
mov [rax], rcx
lea rax, my_file_total_opened
mov rcx, [rax]
add rcx, 1
lea rax, my_file_total_opened
mov [rax], rcx
mov ecx, [rbp+var_14]
lea rax, my_file_info
mov rax, [rax]
movsxd rdx, [rbp+var_8]
shl rdx, 4
add rax, rdx
mov [rax+8], ecx
jmp short $+2
loc_FBEFC:
jmp short $+2
loc_FBEFE:
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
jmp short loc_FBF7D
loc_FBF06:
call ___errno_location
mov eax, [rax]
mov [rbp+var_2C], eax
call _my_thread_var
mov ecx, [rbp+var_2C]
mov [rax], ecx
jmp short $+2
loc_FBF1C:
mov rax, [rbp+var_20]
and rax, 19h
cmp rax, 0
jz short loc_FBF74
call _my_thread_var
cmp dword ptr [rax], 18h
jnz short loc_FBF3B
mov [rbp+var_18], 17h
loc_FBF3B:
mov eax, [rbp+var_18]
mov [rbp+var_44], eax
mov rax, [rbp+var_20]
and rax, 440h
or rax, 4
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
call _my_thread_var
mov edi, [rbp+var_44]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
mov ecx, [rax]
mov al, 0
call my_error
loc_FBF74:
jmp short $+2
loc_FBF76:
mov [rbp+var_4], 0FFFFFFFFh
loc_FBF7D:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long my_register_filename(long long a1, const char *a2, int a3, unsigned int a4, __int16 a5)
{
unsigned int *v5; // rax
int v7; // [rsp+24h] [rbp-2Ch]
if ( (int)a1 < 0 )
{
v7 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a1, a2) = v7;
if ( (a5 & 0x19) != 0 )
{
if ( *(_DWORD *)my_thread_var(a1, a2) == 24 )
a4 = 23;
v5 = (unsigned int *)my_thread_var(a1, a2);
my_error(a4, a5 & 0x440 | 4LL, a2, *v5);
}
return (unsigned int)-1;
}
else
{
_InterlockedExchangeAdd(my_file_opened, 1u);
if ( (unsigned int)a1 >= my_file_limit || (a5 & 0x2004) != 0 )
{
return (unsigned int)a1;
}
else
{
*((_QWORD *)my_file_info + 2 * (int)a1) = my_strdup(key_memory_my_file_info, (long long)a2, a5);
++my_file_total_opened;
*((_DWORD *)my_file_info + 4 * (int)a1 + 2) = a3;
return (unsigned int)a1;
}
}
}
| my_register_filename:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x18],ECX
MOV qword ptr [RBP + -0x20],R8
CMP dword ptr [RBP + -0x8],0x0
JL 0x001fbf06
MOV dword ptr [RBP + -0x24],0x1
MOV EAX,dword ptr [RBP + -0x24]
LEA RCX,[0xd8df74]
XADD.LOCK dword ptr [RCX],EAX
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x8]
LEA RCX,[0x3c7b30]
CMP EAX,dword ptr [RCX]
JNC 0x001fbe89
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x2004
CMP RAX,0x0
JZ 0x001fbe96
LAB_001fbe89:
JMP 0x001fbe8b
LAB_001fbe8b:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001fbf7d
LAB_001fbe96:
LEA RAX,[0xd8e4a4]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001fb810
MOV RCX,RAX
LEA RAX,[0x3c7b38]
MOV RAX,qword ptr [RAX]
MOVSXD RDX,dword ptr [RBP + -0x8]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
LEA RAX,[0xd8df60]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
LEA RAX,[0xd8df60]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x14]
LEA RAX,[0x3c7b38]
MOV RAX,qword ptr [RAX]
MOVSXD RDX,dword ptr [RBP + -0x8]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x8],ECX
JMP 0x001fbefc
LAB_001fbefc:
JMP 0x001fbefe
LAB_001fbefe:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001fbf7d
LAB_001fbf06:
CALL 0x00129700
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
CALL 0x001fdd30
MOV ECX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX],ECX
JMP 0x001fbf1c
LAB_001fbf1c:
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x19
CMP RAX,0x0
JZ 0x001fbf74
CALL 0x001fdd30
CMP dword ptr [RAX],0x18
JNZ 0x001fbf3b
MOV dword ptr [RBP + -0x18],0x17
LAB_001fbf3b:
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x440
OR RAX,0x4
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
CALL 0x001fdd30
MOV EDI,dword ptr [RBP + -0x44]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX]
MOV AL,0x0
CALL 0x001f76a0
LAB_001fbf74:
JMP 0x001fbf76
LAB_001fbf76:
MOV dword ptr [RBP + -0x4],0xffffffff
LAB_001fbf7d:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
uint my_register_filename
(uint param_1,int8 param_2,int4 param_3,int4 param_4,ulong param_5)
{
int iVar1;
int8 uVar2;
int *piVar3;
int4 *puVar4;
int4 local_20;
uint local_c;
if ((int)param_1 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((param_5 & 0x19) != 0) {
piVar3 = (int *)_my_thread_var();
local_20 = param_4;
if (*piVar3 == 0x18) {
local_20 = 0x17;
}
puVar4 = (int4 *)_my_thread_var();
my_error(local_20,param_5 & 0x440 | 4,param_2,*puVar4);
}
local_c = 0xffffffff;
}
else {
LOCK();
my_file_opened = my_file_opened + 1;
UNLOCK();
local_c = param_1;
if ((param_1 < my_file_limit) && ((param_5 & 0x2004) == 0)) {
uVar2 = my_strdup(key_memory_my_file_info,param_2,param_5);
*(int8 *)(my_file_info + (long)(int)param_1 * 0x10) = uVar2;
my_file_total_opened = my_file_total_opened + 1;
*(int4 *)(my_file_info + (long)(int)param_1 * 0x10 + 8) = param_3;
}
}
return local_c;
}
| |
38,110 | fini_one_value | eloqsql/mysys/my_getopt.c | static void fini_one_value(const struct my_option *option, void *variable,
longlong value __attribute__ ((unused)))
{
DBUG_ENTER("fini_one_value");
switch ((option->var_type & GET_TYPE_MASK)) {
case GET_STR_ALLOC:
my_free(*((char**) variable));
*((char**) variable)= NULL;
break;
default: /* dummy default to avoid compiler warnings */
break;
}
DBUG_VOID_RETURN;
} | O3 | c | fini_one_value:
movl 0x30(%rdi), %eax
andl $0x3f, %eax
cmpl $0xa, %eax
jne 0x271b4
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rdi
callq 0x284b6
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| fini_one_value:
mov eax, [rdi+30h]
and eax, 3Fh
cmp eax, 0Ah
jnz short locret_271B4
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rsi
mov rdi, [rsi]
call my_free
mov qword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
locret_271B4:
retn
| long long fini_one_value(long long a1, _QWORD *a2)
{
long long result; // rax
result = *(_DWORD *)(a1 + 48) & 0x3F;
if ( (_DWORD)result == 10 )
{
result = my_free(*a2);
*a2 = 0LL;
}
return result;
}
| fini_one_value:
MOV EAX,dword ptr [RDI + 0x30]
AND EAX,0x3f
CMP EAX,0xa
JNZ 0x001271b4
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV RDI,qword ptr [RSI]
CALL 0x001284b6
MOV qword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
LAB_001271b4:
RET
|
void fini_one_value(long param_1,int8 *param_2)
{
if ((*(uint *)(param_1 + 0x30) & 0x3f) == 10) {
my_free(*param_2);
*param_2 = 0;
}
return;
}
| |
38,111 | 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 0xf3bb5
movq -0x30(%rbp), %rax
andq $0x1a, %rax
cmpq $0x0, %rax
jne 0xf3bd5
leaq 0xb8db8e(%rip), %rax # 0xc81758
movq (%rax), %rax
orq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xf3bd7
callq 0x2a740
movl $0x0, (%rax)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x2a5f0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xf3d87
jmp 0xf3c0a
jmp 0xf3c0c
callq 0x2a740
movl (%rax), %eax
movl %eax, -0x44(%rbp)
callq 0xf55f0
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
callq 0x2a740
cmpl $0x0, (%rax)
je 0xf3c3f
cmpq $-0x1, -0x38(%rbp)
je 0xf3c4a
movq -0x30(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xf3c4a
callq 0xf55f0
movl $0xaf, (%rax)
jmp 0xf3c4c
jmp 0xf3c4e
cmpq $0x0, -0x38(%rbp)
je 0xf3c5c
cmpq $-0x1, -0x38(%rbp)
jne 0xf3c6f
callq 0x2a740
cmpl $0x4, (%rax)
jne 0xf3c6f
jmp 0xf3c68
jmp 0xf3c6a
jmp 0xf3bd7
cmpq $-0x1, -0x38(%rbp)
je 0xf3cc5
cmpq $0x0, -0x38(%rbp)
je 0xf3cc5
movq -0x30(%rbp), %rax
andq $0x200, %rax # imm = 0x200
cmpq $0x0, %rax
je 0xf3cc5
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 0xf3bd7
movq -0x30(%rbp), %rax
andq $0x1a, %rax
cmpq $0x0, %rax
je 0xf3d64
cmpq $-0x1, -0x38(%rbp)
jne 0xf3d19
movq -0x30(%rbp), %rax
andq $0x440, %rax # imm = 0x440
orq $0x4, %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %edi
callq 0x102a40
movq %rax, -0x50(%rbp)
callq 0xf55f0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl (%rax), %ecx
movl $0x2, %edi
movb $0x0, %al
callq 0xef140
jmp 0xf3d62
movq -0x30(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xf3d60
movq -0x30(%rbp), %rax
andq $0x440, %rax # imm = 0x440
orq $0x4, %rax
movq %rax, -0x68(%rbp)
movl -0xc(%rbp), %edi
callq 0x102a40
movq %rax, -0x60(%rbp)
callq 0xf55f0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movl (%rax), %ecx
movl $0x9, %edi
movb $0x0, %al
callq 0xef140
jmp 0xf3d62
jmp 0xf3d64
cmpq $-0x1, -0x38(%rbp)
je 0xf3d79
movq -0x30(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xf3d85
jmp 0xf3d7b
movq $-0x1, -0x8(%rbp)
jmp 0xf3db5
jmp 0xf3d87
movq -0x30(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xf3d9f
movq $0x0, -0x38(%rbp)
jmp 0xf3dab
movq -0x40(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xf3dad
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_F3BB5:
mov rax, [rbp+var_30]
and rax, 1Ah
cmp rax, 0
jnz short loc_F3BD5
lea rax, my_global_flags
mov rax, [rax]
or rax, [rbp+var_30]
mov [rbp+var_30], rax
loc_F3BD5:
jmp short $+2
loc_F3BD7:
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_F3D87
jmp short $+2
loc_F3C0A:
jmp short $+2
loc_F3C0C:
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_F3C3F
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_F3C4A
mov rax, [rbp+var_30]
and rax, 6
cmp rax, 0
jz short loc_F3C4A
loc_F3C3F:
call _my_thread_var
mov dword ptr [rax], 0AFh
loc_F3C4A:
jmp short $+2
loc_F3C4C:
jmp short $+2
loc_F3C4E:
cmp [rbp+var_38], 0
jz short loc_F3C5C
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jnz short loc_F3C6F
loc_F3C5C:
call ___errno_location
cmp dword ptr [rax], 4
jnz short loc_F3C6F
jmp short $+2
loc_F3C68:
jmp short $+2
loc_F3C6A:
jmp loc_F3BD7
loc_F3C6F:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_F3CC5
cmp [rbp+var_38], 0
jz short loc_F3CC5
mov rax, [rbp+var_30]
and rax, 200h
cmp rax, 0
jz short loc_F3CC5
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_F3BD7
loc_F3CC5:
mov rax, [rbp+var_30]
and rax, 1Ah
cmp rax, 0
jz loc_F3D64
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jnz short loc_F3D19
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_F3D62
loc_F3D19:
mov rax, [rbp+var_30]
and rax, 6
cmp rax, 0
jz short loc_F3D60
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_F3D60:
jmp short $+2
loc_F3D62:
jmp short $+2
loc_F3D64:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_F3D79
mov rax, [rbp+var_30]
and rax, 6
cmp rax, 0
jz short loc_F3D85
loc_F3D79:
jmp short $+2
loc_F3D7B:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_F3DB5
loc_F3D85:
jmp short $+2
loc_F3D87:
mov rax, [rbp+var_30]
and rax, 6
cmp rax, 0
jz short loc_F3D9F
mov [rbp+var_38], 0
jmp short loc_F3DAB
loc_F3D9F:
mov rax, [rbp+var_40]
add rax, [rbp+var_38]
mov [rbp+var_38], rax
loc_F3DAB:
jmp short $+2
loc_F3DAD:
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_F3DB5:
mov rax, [rbp+var_8]
add rsp, 70h
pop rbp
retn
| long long my_pread(unsigned int a1, long long a2, long long a3, long long a4, __int16 a5, double a6)
{
unsigned int *v6; // rax
unsigned int *v7; // rax
long long v9; // [rsp+10h] [rbp-60h]
long long v10; // [rsp+20h] [rbp-50h]
int v11; // [rsp+2Ch] [rbp-44h]
long long v12; // [rsp+30h] [rbp-40h]
long long v13; // [rsp+38h] [rbp-38h]
__int16 v15; // [rsp+40h] [rbp-30h]
v15 = a5;
v12 = 0LL;
if ( (a5 & 0x1A) == 0 )
v15 = a5 | my_global_flags;
while ( 1 )
{
*(_DWORD *)__errno_location() = 0;
v13 = pread64(a1, a2, a3, a4);
if ( v13 == a3 )
break;
v11 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a6) = v11;
if ( !*(_DWORD *)__errno_location() || v13 != -1 && (v15 & 6) != 0 )
*(_DWORD *)my_thread_var(a6) = 175;
if ( v13 && v13 != -1 || *(_DWORD *)__errno_location() != 4 )
{
if ( v13 == -1 || !v13 || (v15 & 0x200) == 0 )
{
if ( (v15 & 0x1A) != 0 )
{
if ( v13 == -1 )
{
v10 = my_filename(a1);
v6 = (unsigned int *)my_thread_var(a6);
my_error(2u, v15 & 0x440 | 4LL, v10, *v6);
}
else if ( (v15 & 6) != 0 )
{
v9 = my_filename(a1);
v7 = (unsigned int *)my_thread_var(a6);
my_error(9u, v15 & 0x440 | 4LL, v9, *v7);
}
}
if ( v13 == -1 || (v15 & 6) != 0 )
return -1LL;
break;
}
a2 += v13;
a3 -= v13;
v12 += v13;
a4 += v13;
}
}
if ( (v15 & 6) != 0 )
return 0LL;
else
return v13 + v12;
}
| 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 0x001f3bb5
LAB_001f3bb5:
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x1a
CMP RAX,0x0
JNZ 0x001f3bd5
LEA RAX,[0xd81758]
MOV RAX,qword ptr [RAX]
OR RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RAX
LAB_001f3bd5:
JMP 0x001f3bd7
LAB_001f3bd7:
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 0x0012a5f0
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001f3d87
JMP 0x001f3c0a
LAB_001f3c0a:
JMP 0x001f3c0c
LAB_001f3c0c:
CALL 0x0012a740
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x44],EAX
CALL 0x001f55f0
MOV ECX,dword ptr [RBP + -0x44]
MOV dword ptr [RAX],ECX
CALL 0x0012a740
CMP dword ptr [RAX],0x0
JZ 0x001f3c3f
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001f3c4a
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001f3c4a
LAB_001f3c3f:
CALL 0x001f55f0
MOV dword ptr [RAX],0xaf
LAB_001f3c4a:
JMP 0x001f3c4c
LAB_001f3c4c:
JMP 0x001f3c4e
LAB_001f3c4e:
CMP qword ptr [RBP + -0x38],0x0
JZ 0x001f3c5c
CMP qword ptr [RBP + -0x38],-0x1
JNZ 0x001f3c6f
LAB_001f3c5c:
CALL 0x0012a740
CMP dword ptr [RAX],0x4
JNZ 0x001f3c6f
JMP 0x001f3c68
LAB_001f3c68:
JMP 0x001f3c6a
LAB_001f3c6a:
JMP 0x001f3bd7
LAB_001f3c6f:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001f3cc5
CMP qword ptr [RBP + -0x38],0x0
JZ 0x001f3cc5
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x200
CMP RAX,0x0
JZ 0x001f3cc5
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 0x001f3bd7
LAB_001f3cc5:
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x1a
CMP RAX,0x0
JZ 0x001f3d64
CMP qword ptr [RBP + -0x38],-0x1
JNZ 0x001f3d19
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 0x00202a40
MOV qword ptr [RBP + -0x50],RAX
CALL 0x001f55f0
MOV RSI,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RAX]
MOV EDI,0x2
MOV AL,0x0
CALL 0x001ef140
JMP 0x001f3d62
LAB_001f3d19:
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001f3d60
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 0x00202a40
MOV qword ptr [RBP + -0x60],RAX
CALL 0x001f55f0
MOV RSI,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x60]
MOV ECX,dword ptr [RAX]
MOV EDI,0x9
MOV AL,0x0
CALL 0x001ef140
LAB_001f3d60:
JMP 0x001f3d62
LAB_001f3d62:
JMP 0x001f3d64
LAB_001f3d64:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001f3d79
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001f3d85
LAB_001f3d79:
JMP 0x001f3d7b
LAB_001f3d7b:
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x001f3db5
LAB_001f3d85:
JMP 0x001f3d87
LAB_001f3d87:
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001f3d9f
MOV qword ptr [RBP + -0x38],0x0
JMP 0x001f3dab
LAB_001f3d9f:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
LAB_001f3dab:
JMP 0x001f3dad
LAB_001f3dad:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001f3db5:
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_001f3d87:
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_001f3d87;
}
local_20 = (void *)(sVar3 + (long)local_20);
local_28 = local_28 - sVar3;
local_48 = sVar3 + local_48;
local_30 = sVar3 + local_30;
} while( true );
}
| |
38,112 | ggml_backend_cpu_init | ngxson[P]ggml-easy/ggml/src/ggml-cpu/ggml-cpu.cpp | ggml_backend_t ggml_backend_cpu_init(void) {
// initialize CPU backend now to avoid slowing the first graph computation
ggml_cpu_init();
struct ggml_backend_cpu_context * ctx = new ggml_backend_cpu_context;
if (ctx == NULL) {
return NULL;
}
ctx->n_threads = GGML_DEFAULT_N_THREADS;
ctx->threadpool = NULL;
ctx->work_data = NULL;
ctx->work_size = 0;
ctx->abort_callback = NULL;
ctx->abort_callback_data = NULL;
ggml_backend_t cpu_backend = new ggml_backend {
/* .guid = */ ggml_backend_cpu_guid(),
/* .interface = */ ggml_backend_cpu_i,
/* .device = */ ggml_backend_reg_dev_get(ggml_backend_cpu_reg(), 0),
/* .context = */ ctx,
};
if (cpu_backend == NULL) {
delete ctx;
return NULL;
}
return cpu_backend;
} | O2 | cpp | ggml_backend_cpu_init:
pushq %r14
pushq %rbx
pushq %rax
callq 0xbcd0
pushq $0x30
popq %rdi
callq 0xb970
movq %rax, %rbx
movl $0x4, (%rax)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x8(%rax)
andq $0x0, 0x28(%rax)
movl $0x80, %edi
vzeroupper
callq 0xb970
movq %rax, %r14
leaq 0x47107(%rip), %rax # 0x57a30
movq %rax, (%r14)
vmovups 0x4609c(%rip), %ymm0 # 0x569d0
vmovups %ymm0, 0x8(%r14)
vmovups 0x460ae(%rip), %ymm0 # 0x569f0
vmovups %ymm0, 0x28(%r14)
vmovups 0x460c0(%rip), %ymm0 # 0x56a10
vmovups %ymm0, 0x48(%r14)
movq 0x460d3(%rip), %rax # 0x56a30
movq %rax, 0x68(%r14)
vzeroupper
callq 0xbcd0
leaq 0x47090(%rip), %rdi # 0x57a00
xorl %esi, %esi
callq 0xc080
movq %rax, 0x70(%r14)
movq %rbx, 0x78(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x80, %esi
movq %r14, %rdi
callq 0xb9b0
movq %rbx, %rdi
callq 0xc100
| ggml_backend_cpu_init:
push r14
push rbx
push rax
call _ggml_cpu_init
push 30h ; '0'
pop rdi; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
mov dword ptr [rax], 4
vxorps xmm0, xmm0, xmm0
vmovups ymmword ptr [rax+8], ymm0
and qword ptr [rax+28h], 0
mov edi, 80h; unsigned __int64
vzeroupper
call __Znwm; operator new(ulong)
mov r14, rax
lea rax, _ZZL21ggml_backend_cpu_guidvE4guid; ggml_backend_cpu_guid(void)::guid
mov [r14], rax
vmovups ymm0, ymmword ptr cs:_ZL18ggml_backend_cpu_i; ggml_backend_cpu_i
vmovups ymmword ptr [r14+8], ymm0
vmovups ymm0, ymmword ptr cs:unk_569F0
vmovups ymmword ptr [r14+28h], ymm0
vmovups ymm0, ymmword ptr cs:unk_56A10
vmovups ymmword ptr [r14+48h], ymm0
mov rax, cs:qword_56A30
mov [r14+68h], rax
vzeroupper
call _ggml_cpu_init
lea rdi, _ZZ20ggml_backend_cpu_regE20ggml_backend_cpu_reg; ggml_backend_cpu_reg::ggml_backend_cpu_reg
xor esi, esi
call _ggml_backend_reg_dev_get
mov [r14+70h], rax
mov [r14+78h], rbx
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
mov rbx, rax
mov esi, 80h; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, rbx
call __Unwind_Resume
| _QWORD * ggml_backend_cpu_init(long long a1, __m128 _XMM0)
{
ggml_cpu_init(a1);
_RBX = operator new(0x30uLL);
*(_DWORD *)_RBX = 4;
__asm
{
vxorps xmm0, xmm0, xmm0
vmovups ymmword ptr [rax+8], ymm0
}
*(_QWORD *)(_RBX + 40) = 0LL;
__asm { vzeroupper }
_R14 = (_QWORD *)operator new(0x80uLL);
*_R14 = &ggml_backend_cpu_guid(void)::guid;
__asm
{
vmovups ymm0, ymmword ptr cs:_ZL18ggml_backend_cpu_i; ggml_backend_cpu_i
vmovups ymmword ptr [r14+8], ymm0
vmovups ymm0, ymmword ptr cs:unk_569F0
vmovups ymmword ptr [r14+28h], ymm0
vmovups ymm0, ymmword ptr cs:unk_56A10
vmovups ymmword ptr [r14+48h], ymm0
}
_R14[13] = &dword_0;
__asm { vzeroupper }
ggml_cpu_init(128LL);
_R14[14] = ggml_backend_reg_dev_get(&ggml_backend_cpu_reg::ggml_backend_cpu_reg, 0LL, *(double *)&_XMM0);
_R14[15] = _RBX;
return _R14;
}
| ggml_backend_cpu_init:
PUSH R14
PUSH RBX
PUSH RAX
CALL 0x0010bcd0
PUSH 0x30
POP RDI
CALL 0x0010b970
MOV RBX,RAX
MOV dword ptr [RAX],0x4
VXORPS XMM0,XMM0,XMM0
VMOVUPS ymmword ptr [RAX + 0x8],YMM0
AND qword ptr [RAX + 0x28],0x0
MOV EDI,0x80
VZEROUPPER
CALL 0x0010b970
MOV R14,RAX
LEA RAX,[0x157a30]
MOV qword ptr [R14],RAX
VMOVUPS YMM0,ymmword ptr [0x001569d0]
VMOVUPS ymmword ptr [R14 + 0x8],YMM0
VMOVUPS YMM0,ymmword ptr [0x001569f0]
VMOVUPS ymmword ptr [R14 + 0x28],YMM0
VMOVUPS YMM0,ymmword ptr [0x00156a10]
VMOVUPS ymmword ptr [R14 + 0x48],YMM0
MOV RAX,qword ptr [0x00156a30]
MOV qword ptr [R14 + 0x68],RAX
LAB_00110961:
VZEROUPPER
CALL 0x0010bcd0
LEA RDI,[0x157a00]
XOR ESI,ESI
CALL 0x0010c080
LAB_00110977:
MOV qword ptr [R14 + 0x70],RAX
MOV qword ptr [R14 + 0x78],RBX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
int8 * ggml_backend_cpu_init(void)
{
int8 uVar1;
int8 uVar2;
int4 *puVar3;
int8 *puVar4;
int8 uVar5;
ggml_cpu_init();
puVar3 = (int4 *)operator_new(0x30);
*puVar3 = 4;
*(int8 *)(puVar3 + 2) = 0;
*(int8 *)(puVar3 + 4) = 0;
*(int8 *)(puVar3 + 6) = 0;
*(int8 *)(puVar3 + 8) = 0;
*(int8 *)(puVar3 + 10) = 0;
puVar4 = (int8 *)operator_new(0x80);
*puVar4 = ggml_backend_cpu_guid()::guid;
uVar2 = ggml_backend_cpu_i._24_8_;
uVar1 = ggml_backend_cpu_i._16_8_;
uVar5 = ggml_backend_cpu_i._8_8_;
puVar4[1] = ggml_backend_cpu_i._0_8_;
puVar4[2] = uVar5;
puVar4[3] = uVar1;
puVar4[4] = uVar2;
uVar2 = ggml_backend_cpu_i._56_8_;
uVar1 = ggml_backend_cpu_i._48_8_;
uVar5 = ggml_backend_cpu_i._40_8_;
puVar4[5] = ggml_backend_cpu_i._32_8_;
puVar4[6] = uVar5;
puVar4[7] = uVar1;
puVar4[8] = uVar2;
uVar2 = ggml_backend_cpu_i._88_8_;
uVar1 = ggml_backend_cpu_i._80_8_;
uVar5 = ggml_backend_cpu_i._72_8_;
puVar4[9] = ggml_backend_cpu_i._64_8_;
puVar4[10] = uVar5;
puVar4[0xb] = uVar1;
puVar4[0xc] = uVar2;
puVar4[0xd] = ggml_backend_cpu_i._96_8_;
/* try { // try from 00110961 to 00110976 has its CatchHandler @ 0011098a */
ggml_cpu_init();
uVar5 = ggml_backend_reg_dev_get(ggml_backend_cpu_reg::ggml_backend_cpu_reg,0);
puVar4[0xe] = uVar5;
puVar4[0xf] = puVar3;
return puVar4;
}
| |
38,113 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(unsigned int, unsigned int&) | monkey531[P]llama/common/json.hpp | inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
{
// LCOV_EXCL_START
if (n >= 1000000000)
{
pow10 = 1000000000;
return 10;
}
// LCOV_EXCL_STOP
if (n >= 100000000)
{
pow10 = 100000000;
return 9;
}
if (n >= 10000000)
{
pow10 = 10000000;
return 8;
}
if (n >= 1000000)
{
pow10 = 1000000;
return 7;
}
if (n >= 100000)
{
pow10 = 100000;
return 6;
}
if (n >= 10000)
{
pow10 = 10000;
return 5;
}
if (n >= 1000)
{
pow10 = 1000;
return 4;
}
if (n >= 100)
{
pow10 = 100;
return 3;
}
if (n >= 10)
{
pow10 = 10;
return 2;
}
pow10 = 1;
return 1;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(unsigned int, unsigned int&):
cmpl $0x3b9ac9ff, %edi # imm = 0x3B9AC9FF
jbe 0x88d3d
pushq $0xa
popq %rax
movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00
jmp 0x88dc5
cmpl $0x5f5e0ff, %edi # imm = 0x5F5E0FF
jbe 0x88d4f
pushq $0x9
popq %rax
movl $0x5f5e100, %ecx # imm = 0x5F5E100
jmp 0x88dc5
cmpl $0x98967f, %edi # imm = 0x98967F
jbe 0x88d61
pushq $0x8
popq %rax
movl $0x989680, %ecx # imm = 0x989680
jmp 0x88dc5
cmpl $0xf423f, %edi # imm = 0xF423F
jbe 0x88d73
pushq $0x7
popq %rax
movl $0xf4240, %ecx # imm = 0xF4240
jmp 0x88dc5
cmpl $0x1869f, %edi # imm = 0x1869F
jbe 0x88d85
pushq $0x6
popq %rax
movl $0x186a0, %ecx # imm = 0x186A0
jmp 0x88dc5
cmpl $0x270f, %edi # imm = 0x270F
jbe 0x88d97
pushq $0x5
popq %rax
movl $0x2710, %ecx # imm = 0x2710
jmp 0x88dc5
cmpl $0x3e7, %edi # imm = 0x3E7
jbe 0x88da9
pushq $0x4
popq %rax
movl $0x3e8, %ecx # imm = 0x3E8
jmp 0x88dc5
cmpl $0x63, %edi
jbe 0x88db6
pushq $0x3
popq %rax
pushq $0x64
popq %rcx
jmp 0x88dc5
xorl %eax, %eax
cmpl $0xa, %edi
setae %al
leal (%rax,%rax,8), %ecx
incl %ecx
incl %eax
movl %ecx, (%rsi)
retq
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl18find_largest_pow10EjRj:
cmp edi, 3B9AC9FFh
jbe short loc_88D3D
push 0Ah
pop rax
mov ecx, 3B9ACA00h
jmp loc_88DC5
loc_88D3D:
cmp edi, 5F5E0FFh
jbe short loc_88D4F
push 9
pop rax
mov ecx, 5F5E100h
jmp short loc_88DC5
loc_88D4F:
cmp edi, 98967Fh
jbe short loc_88D61
push 8
pop rax
mov ecx, 989680h
jmp short loc_88DC5
loc_88D61:
cmp edi, offset unk_F423F
jbe short loc_88D73
push 7
pop rax
mov ecx, offset unk_F4240
jmp short loc_88DC5
loc_88D73:
cmp edi, 1869Fh
jbe short loc_88D85
push 6
pop rax
mov ecx, 186A0h
jmp short loc_88DC5
loc_88D85:
cmp edi, 270Fh
jbe short loc_88D97
push 5
pop rax
mov ecx, 2710h
jmp short loc_88DC5
loc_88D97:
cmp edi, 3E7h
jbe short loc_88DA9
push 4
pop rax
mov ecx, 3E8h
jmp short loc_88DC5
loc_88DA9:
cmp edi, 63h ; 'c'
jbe short loc_88DB6
push 3
pop rax
push 64h ; 'd'
pop rcx
jmp short loc_88DC5
loc_88DB6:
xor eax, eax
cmp edi, 0Ah
setnb al
lea ecx, [rax+rax*8]
inc ecx
inc eax
loc_88DC5:
mov [rsi], ecx
retn
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *this,
_DWORD *a2,
unsigned int *a3)
{
long long result; // rax
void *v4; // rcx
BOOL v5; // eax
if ( (unsigned int)this <= 0x3B9AC9FF )
{
if ( (unsigned int)this <= 0x5F5E0FF )
{
if ( (unsigned int)this <= 0x98967F )
{
if ( (unsigned int)this <= (unsigned int)&unk_F423F )
{
if ( (unsigned int)this <= 0x1869F )
{
if ( (unsigned int)this <= 0x270F )
{
if ( (unsigned int)this <= 0x3E7 )
{
if ( (unsigned int)this <= 0x63 )
{
v5 = (unsigned int)this >= 0xA;
LODWORD(v4) = 9 * v5 + 1;
result = (unsigned int)(v5 + 1);
}
else
{
result = 3LL;
LODWORD(v4) = 100;
}
}
else
{
result = 4LL;
LODWORD(v4) = 1000;
}
}
else
{
result = 5LL;
LODWORD(v4) = 10000;
}
}
else
{
result = 6LL;
LODWORD(v4) = 100000;
}
}
else
{
result = 7LL;
v4 = &unk_F4240;
}
}
else
{
result = 8LL;
LODWORD(v4) = 10000000;
}
}
else
{
result = 9LL;
LODWORD(v4) = 100000000;
}
}
else
{
result = 10LL;
LODWORD(v4) = 1000000000;
}
*a2 = (_DWORD)v4;
return result;
}
| find_largest_pow10:
CMP EDI,0x3b9ac9ff
JBE 0x00188d3d
PUSH 0xa
POP RAX
MOV ECX,0x3b9aca00
JMP 0x00188dc5
LAB_00188d3d:
CMP EDI,0x5f5e0ff
JBE 0x00188d4f
PUSH 0x9
POP RAX
MOV ECX,0x5f5e100
JMP 0x00188dc5
LAB_00188d4f:
CMP EDI,0x98967f
JBE 0x00188d61
PUSH 0x8
POP RAX
MOV ECX,0x989680
JMP 0x00188dc5
LAB_00188d61:
CMP EDI,0xf423f
JBE 0x00188d73
PUSH 0x7
POP RAX
MOV ECX,0xf4240
JMP 0x00188dc5
LAB_00188d73:
CMP EDI,0x1869f
JBE 0x00188d85
PUSH 0x6
POP RAX
MOV ECX,0x186a0
JMP 0x00188dc5
LAB_00188d85:
CMP EDI,0x270f
JBE 0x00188d97
PUSH 0x5
POP RAX
MOV ECX,0x2710
JMP 0x00188dc5
LAB_00188d97:
CMP EDI,0x3e7
JBE 0x00188da9
PUSH 0x4
POP RAX
MOV ECX,0x3e8
JMP 0x00188dc5
LAB_00188da9:
CMP EDI,0x63
JBE 0x00188db6
PUSH 0x3
POP RAX
PUSH 0x64
POP RCX
JMP 0x00188dc5
LAB_00188db6:
XOR EAX,EAX
CMP EDI,0xa
SETNC AL
LEA ECX,[RAX + RAX*0x8]
INC ECX
INC EAX
LAB_00188dc5:
MOV dword ptr [RSI],ECX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(unsigned int, unsigned int&) */
char nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(uint param_1,uint *param_2)
{
char cVar1;
uint uVar2;
if (param_1 < 1000000000) {
if (param_1 < 100000000) {
if (param_1 < 10000000) {
if (param_1 < 1000000) {
if (param_1 < 100000) {
if (param_1 < 10000) {
if (param_1 < 1000) {
if (param_1 < 100) {
uVar2 = (uint)(9 < param_1) * 9 + 1;
cVar1 = (9 < param_1) + '\x01';
}
else {
cVar1 = '\x03';
uVar2 = 100;
}
}
else {
cVar1 = '\x04';
uVar2 = 1000;
}
}
else {
cVar1 = '\x05';
uVar2 = 10000;
}
}
else {
cVar1 = '\x06';
uVar2 = 100000;
}
}
else {
cVar1 = '\a';
uVar2 = 1000000;
}
}
else {
cVar1 = '\b';
uVar2 = 10000000;
}
}
else {
cVar1 = '\t';
uVar2 = 100000000;
}
}
else {
cVar1 = '\n';
uVar2 = 1000000000;
}
*param_2 = uVar2;
return cVar1;
}
| |
38,114 | mi_state_info_read_dsk | eloqsql/storage/myisam/mi_open.c | uint mi_state_info_read_dsk(File file, MI_STATE_INFO *state, my_bool pRead)
{
uchar buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
if (!myisam_single_user)
{
if (pRead)
{
if (mysql_file_pread(file, buff, state->state_length, 0L, MYF(MY_NABP)))
return 1;
}
else if (mysql_file_read(file, buff, state->state_length, MYF(MY_NABP)))
return 1;
mi_state_info_read(buff, state);
}
return 0;
} | O0 | c | mi_state_info_read_dsk:
pushq %rbp
movq %rsp, %rbp
subq $0x2360, %rsp # imm = 0x2360
movb %dl, %al
movq %fs:0x28, %rcx
movq %rcx, -0x8(%rbp)
movl %edi, -0x2348(%rbp)
movq %rsi, -0x2350(%rbp)
movb %al, -0x2351(%rbp)
leaq 0xbc2146(%rip), %rax # 0xc7c65a
cmpb $0x0, (%rax)
jne 0xba5d0
cmpb $0x0, -0x2351(%rbp)
je 0xba575
movl -0x2348(%rbp), %edx
leaq -0x2340(%rbp), %rcx
movq -0x2350(%rbp), %rax
movl 0xf8(%rax), %eax
movl %eax, %r8d
leaq 0x9a636(%rip), %rdi # 0x154b80
movl $0x418, %esi # imm = 0x418
xorl %eax, %eax
movl %eax, %r9d
movq $0x4, (%rsp)
callq 0xba610
cmpq $0x0, %rax
je 0xba573
movl $0x1, -0x2344(%rbp)
jmp 0xba5da
jmp 0xba5bd
movl -0x2348(%rbp), %edx
leaq -0x2340(%rbp), %rcx
movq -0x2350(%rbp), %rax
movl 0xf8(%rax), %eax
movl %eax, %r8d
leaq 0x9a5e7(%rip), %rdi # 0x154b80
movl $0x41b, %esi # imm = 0x41B
movl $0x4, %r9d
callq 0xb6520
cmpq $0x0, %rax
je 0xba5bb
movl $0x1, -0x2344(%rbp)
jmp 0xba5da
jmp 0xba5bd
leaq -0x2340(%rbp), %rdi
movq -0x2350(%rbp), %rsi
callq 0xb6780
movl $0x0, -0x2344(%rbp)
movl -0x2344(%rbp), %eax
movl %eax, -0x2358(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xba607
movl -0x2358(%rbp), %eax
addq $0x2360, %rsp # imm = 0x2360
popq %rbp
retq
callq 0x29230
nopl (%rax)
| mi_state_info_read_dsk:
push rbp
mov rbp, rsp
sub rsp, 2360h
mov al, dl
mov rcx, fs:28h
mov [rbp+var_8], rcx
mov [rbp+var_2348], edi
mov [rbp+var_2350], rsi
mov [rbp+var_2351], al
lea rax, myisam_single_user
cmp byte ptr [rax], 0
jnz loc_BA5D0
cmp [rbp+var_2351], 0
jz short loc_BA575
mov edx, [rbp+var_2348]
lea rcx, [rbp+var_2340]
mov rax, [rbp+var_2350]
mov eax, [rax+0F8h]
mov r8d, eax
lea rdi, aWorkspaceLlm4b_31; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 418h
xor eax, eax
mov r9d, eax
mov [rsp+2360h+var_2360], 4
call inline_mysql_file_pread_7
cmp rax, 0
jz short loc_BA573
mov [rbp+var_2344], 1
jmp short loc_BA5DA
loc_BA573:
jmp short loc_BA5BD
loc_BA575:
mov edx, [rbp+var_2348]
lea rcx, [rbp+var_2340]
mov rax, [rbp+var_2350]
mov eax, [rax+0F8h]
mov r8d, eax
lea rdi, aWorkspaceLlm4b_31; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 41Bh
mov r9d, 4
call inline_mysql_file_read_2
cmp rax, 0
jz short loc_BA5BB
mov [rbp+var_2344], 1
jmp short loc_BA5DA
loc_BA5BB:
jmp short $+2
loc_BA5BD:
lea rdi, [rbp+var_2340]
mov rsi, [rbp+var_2350]
call mi_state_info_read
loc_BA5D0:
mov [rbp+var_2344], 0
loc_BA5DA:
mov eax, [rbp+var_2344]
mov [rbp+var_2358], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_BA607
mov eax, [rbp+var_2358]
add rsp, 2360h
pop rbp
retn
loc_BA607:
call ___stack_chk_fail
| long long mi_state_info_read_dsk(unsigned int a1, long long a2, char a3)
{
_BYTE v5[9016]; // [rsp+20h] [rbp-2340h] BYREF
unsigned long long v6; // [rsp+2358h] [rbp-8h]
v6 = __readfsqword(0x28u);
if ( myisam_single_user )
return 0;
if ( !a3 )
{
if ( inline_mysql_file_read_2(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",
0x41Bu,
a1,
(long long)v5,
*(unsigned int *)(a2 + 248),
4LL) )
{
return 1;
}
goto LABEL_8;
}
if ( !inline_mysql_file_pread_7(
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",
1048,
a1,
(unsigned int)v5,
*(_DWORD *)(a2 + 248),
0,
4LL) )
{
LABEL_8:
mi_state_info_read((long long)v5, a2);
return 0;
}
return 1;
}
| mi_state_info_read_dsk:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2360
MOV AL,DL
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RCX
MOV dword ptr [RBP + -0x2348],EDI
MOV qword ptr [RBP + -0x2350],RSI
MOV byte ptr [RBP + -0x2351],AL
LEA RAX,[0xd7c65a]
CMP byte ptr [RAX],0x0
JNZ 0x001ba5d0
CMP byte ptr [RBP + -0x2351],0x0
JZ 0x001ba575
MOV EDX,dword ptr [RBP + -0x2348]
LEA RCX,[RBP + -0x2340]
MOV RAX,qword ptr [RBP + -0x2350]
MOV EAX,dword ptr [RAX + 0xf8]
MOV R8D,EAX
LEA RDI,[0x254b80]
MOV ESI,0x418
XOR EAX,EAX
MOV R9D,EAX
MOV qword ptr [RSP],0x4
CALL 0x001ba610
CMP RAX,0x0
JZ 0x001ba573
MOV dword ptr [RBP + -0x2344],0x1
JMP 0x001ba5da
LAB_001ba573:
JMP 0x001ba5bd
LAB_001ba575:
MOV EDX,dword ptr [RBP + -0x2348]
LEA RCX,[RBP + -0x2340]
MOV RAX,qword ptr [RBP + -0x2350]
MOV EAX,dword ptr [RAX + 0xf8]
MOV R8D,EAX
LEA RDI,[0x254b80]
MOV ESI,0x41b
MOV R9D,0x4
CALL 0x001b6520
CMP RAX,0x0
JZ 0x001ba5bb
MOV dword ptr [RBP + -0x2344],0x1
JMP 0x001ba5da
LAB_001ba5bb:
JMP 0x001ba5bd
LAB_001ba5bd:
LEA RDI,[RBP + -0x2340]
MOV RSI,qword ptr [RBP + -0x2350]
CALL 0x001b6780
LAB_001ba5d0:
MOV dword ptr [RBP + -0x2344],0x0
LAB_001ba5da:
MOV EAX,dword ptr [RBP + -0x2344]
MOV dword ptr [RBP + -0x2358],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001ba607
MOV EAX,dword ptr [RBP + -0x2358]
ADD RSP,0x2360
POP RBP
RET
LAB_001ba607:
CALL 0x00129230
|
int4 mi_state_info_read_dsk(int4 param_1,long param_2,char param_3)
{
long lVar1;
long in_FS_OFFSET;
int4 local_234c;
int1 local_2348 [9016];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (myisam_single_user == '\0') {
if (param_3 == '\0') {
lVar1 = inline_mysql_file_read
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",0x41b,
param_1,local_2348,*(int4 *)(param_2 + 0xf8),4);
if (lVar1 != 0) {
local_234c = 1;
goto LAB_001ba5da;
}
}
else {
lVar1 = inline_mysql_file_pread
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",0x418,
param_1,local_2348,*(int4 *)(param_2 + 0xf8),0,4);
if (lVar1 != 0) {
local_234c = 1;
goto LAB_001ba5da;
}
}
mi_state_info_read(local_2348,param_2);
}
local_234c = 0;
LAB_001ba5da:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_234c;
}
| |
38,115 | minja::IfNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
for (const auto& branch : cascade) {
auto enter_branch = true;
if (branch.first) {
enter_branch = branch.first->evaluate(context).to_bool();
}
if (enter_branch) {
if (!branch.second) throw std::runtime_error("IfNode.cascade.second is null");
branch.second->render(out, context);
return;
}
}
} | O1 | cpp | minja::IfNode::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 %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, (%rsp)
movq 0x20(%rdi), %r13
movq 0x28(%rdi), %r14
cmpq %r14, %r13
je 0xbf13c
movq %rdx, %rbx
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpq $0x0, (%r13)
je 0xbf0e6
movq (%r13), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0xaaef8
movq %r12, %rdi
callq 0xab0fa
movl %eax, %ebp
movq %r15, %rdi
xorl %esi, %esi
callq 0x8974c
movq %r15, %rdi
callq 0x8ed0c
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xbf0a7
callq 0x520bc
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xbf0b6
callq 0x520bc
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xbf0c5
callq 0x520bc
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xbf100
movq 0x99eaa(%rip), %rax # 0x158f80
cmpb $0x0, (%rax)
je 0xbf0eb
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xbf0f5
movb $0x1, %bpl
jmp 0xbf100
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xbf100
movq (%rdi), %rax
callq *0x18(%rax)
testb %bpl, %bpl
je 0xbf12f
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0xbf14b
movq (%rsp), %rsi
movq %rbx, %rdx
callq 0xbf220
addq $0x20, %r13
cmpq %r14, %r13
sete %al
orb %al, %bpl
je 0xbf066
jmp 0xbf13c
addq $0x20, %r13
cmpq %r14, %r13
jne 0xbf066
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1d5b0
movq %rax, %rbx
leaq 0x59f7c(%rip), %rsi # 0x1190db
movq %rax, %rdi
callq 0x1d410
movq 0x99e7a(%rip), %rsi # 0x158fe8
movq 0x99de3(%rip), %rdx # 0x158f58
movq %rbx, %rdi
callq 0x1e5a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d8b0
jmp 0xbf197
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xab1ee
movq %r14, %rdi
callq 0x1e650
nop
| _ZNK5minja6IfNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rsp+88h+var_88], rsi
mov r13, [rdi+20h]
mov r14, [rdi+28h]
cmp r13, r14
jz loc_BF13C
mov rbx, rdx
lea r15, [rsp+88h+var_40]
lea r12, [rsp+88h+var_80]
loc_BF066:
cmp qword ptr [r13+0], 0
jz short loc_BF0E6
mov rsi, [r13+0]
mov rdi, r12
mov rdx, rbx
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov rdi, r12; this
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
mov ebp, eax
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 rdi, r15
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, [rsp+88h+var_48]
test rdi, rdi
jz short loc_BF0A7
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_BF0A7:
mov rdi, [rsp+88h+var_58]
test rdi, rdi
jz short loc_BF0B6
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_BF0B6:
mov rdi, [rsp+88h+var_68]
test rdi, rdi
jz short loc_BF0C5
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_BF0C5:
mov rdi, [rsp+88h+var_78]
test rdi, rdi
jz short loc_BF100
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_BF0EB
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_BF0F5
loc_BF0E6:
mov bpl, 1
jmp short loc_BF100
loc_BF0EB:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_BF0F5:
cmp eax, 1
jnz short loc_BF100
mov rax, [rdi]
call qword ptr [rax+18h]
loc_BF100:
test bpl, bpl
jz short loc_BF12F
mov rdi, [r13+10h]
test rdi, rdi
jz short loc_BF14B
mov rsi, [rsp+88h+var_88]
mov rdx, rbx
call _ZNK5minja12TemplateNode6renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE; minja::TemplateNode::render(std::ostringstream &,std::shared_ptr<minja::Context> const&)
add r13, 20h ; ' '
cmp r13, r14
setz al
or bpl, al
jz loc_BF066
jmp short loc_BF13C
loc_BF12F:
add r13, 20h ; ' '
cmp r13, r14
jnz loc_BF066
loc_BF13C:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_BF14B:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aIfnodeCascadeS; "IfNode.cascade.second is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_BF197
mov r14, rax
lea rdi, [rsp+88h+var_80]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_BF197:
mov rdi, r14
call __Unwind_Resume
| do_render:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RSP],RSI
MOV R13,qword ptr [RDI + 0x20]
MOV R14,qword ptr [RDI + 0x28]
CMP R13,R14
JZ 0x001bf13c
MOV RBX,RDX
LEA R15,[RSP + 0x48]
LEA R12,[RSP + 0x8]
LAB_001bf066:
CMP qword ptr [R13],0x0
JZ 0x001bf0e6
MOV RSI,qword ptr [R13]
MOV RDI,R12
MOV RDX,RBX
CALL 0x001aaef8
LAB_001bf07c:
MOV RDI,R12
CALL 0x001ab0fa
LAB_001bf084:
MOV EBP,EAX
MOV RDI,R15
XOR ESI,ESI
CALL 0x0018974c
MOV RDI,R15
CALL 0x0018ed0c
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x001bf0a7
CALL 0x001520bc
LAB_001bf0a7:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x001bf0b6
CALL 0x001520bc
LAB_001bf0b6:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x001bf0c5
CALL 0x001520bc
LAB_001bf0c5:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x001bf100
MOV RAX,qword ptr [0x00258f80]
CMP byte ptr [RAX],0x0
JZ 0x001bf0eb
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001bf0f5
LAB_001bf0e6:
MOV BPL,0x1
JMP 0x001bf100
LAB_001bf0eb:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001bf0f5:
CMP EAX,0x1
JNZ 0x001bf100
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001bf100:
TEST BPL,BPL
JZ 0x001bf12f
MOV RDI,qword ptr [R13 + 0x10]
TEST RDI,RDI
JZ 0x001bf14b
MOV RSI,qword ptr [RSP]
MOV RDX,RBX
CALL 0x001bf220
ADD R13,0x20
CMP R13,R14
SETZ AL
OR BPL,AL
JZ 0x001bf066
JMP 0x001bf13c
LAB_001bf12f:
ADD R13,0x20
CMP R13,R14
JNZ 0x001bf066
LAB_001bf13c:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001bf14b:
MOV EDI,0x10
CALL 0x0011d5b0
MOV RBX,RAX
LAB_001bf158:
LEA RSI,[0x2190db]
MOV RDI,RAX
CALL 0x0011d410
LAB_001bf167:
MOV RSI,qword ptr [0x00258fe8]
MOV RDX,qword ptr [0x00258f58]
MOV RDI,RBX
CALL 0x0011e5a0
|
/* minja::IfNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context> const&)
const */
void minja::IfNode::do_render(ostringstream *param_1,shared_ptr *param_2)
{
int *piVar1;
long *plVar2;
char cVar3;
int iVar4;
runtime_error *this;
long *plVar5;
Expression local_80 [8];
long *local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
data local_40 [16];
plVar5 = *(long **)(param_1 + 0x20);
plVar2 = *(long **)(param_1 + 0x28);
if (plVar5 != plVar2) {
do {
while( true ) {
if (*plVar5 == 0) {
cVar3 = '\x01';
}
else {
Expression::evaluate(local_80,(shared_ptr *)*plVar5);
/* try { // try from 001bf07c to 001bf083 has its CatchHandler @ 001bf18a */
cVar3 = Value::to_bool((Value *)local_80);
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_40,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_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_00258f80 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar4 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar4 + -1;
}
if (iVar4 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
}
if (cVar3 == '\0') break;
if ((ostringstream *)plVar5[2] == (ostringstream *)0x0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001bf158 to 001bf166 has its CatchHandler @ 001bf17d */
std::runtime_error::runtime_error(this,"IfNode.cascade.second is null");
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00258fe8,PTR__runtime_error_00258f58);
}
TemplateNode::render((ostringstream *)plVar5[2],param_2);
plVar5 = plVar5 + 4;
if (cVar3 != '\0' || plVar5 == plVar2) {
return;
}
}
plVar5 = plVar5 + 4;
} while (plVar5 != plVar2);
}
return;
}
| ||
38,116 | long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const | llama.cpp/common/minja/minja.hpp | T get(const std::string & key, T default_value) const {
if (!contains(key)) return default_value;
return at(key).get<T>();
} | O3 | cpp | long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x6ed8a
testb %al, %al
je 0x78b76
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x602f8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d2d4
movq %rax, %rdi
callq 0x642d8
movl %eax, %ebx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x60b38
movq %r14, %rdi
callq 0x60bd8
leaq 0x38(%rsp), %rdi
callq 0x56124
leaq 0x28(%rsp), %rdi
callq 0x56124
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x56124
movq -0x10(%r14), %rdi
testq %rdi, %rdi
je 0x78b76
movq 0x92437(%rip), %rax # 0x10af88
cmpb $0x0, (%rax)
je 0x78b61
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x78b6b
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x78b76
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a540
movq %rbx, %rdi
callq 0x1d8e0
nop
| _ZNK5minja5Value3getIbEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES2_:
push r15
push r14
push rbx
sub rsp, 50h
mov ebx, edx
mov r15, rsi
mov r14, rdi
call _ZNK5minja5Value8containsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::contains(std::string const&)
test al, al
jz loc_78B76
mov rbx, rsp
mov rdi, rbx
mov rsi, r15
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, r14; this
mov rsi, rbx; minja::Value *
call _ZN5minja5Value2atERKS0_; minja::Value::at(minja::Value const&)
mov rdi, rax
call _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
mov ebx, eax
lea r14, [rsp+68h+var_28]
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+68h+var_30]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+68h+var_40]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea r14, [rsp+68h+var_50]
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_78B76
mov rax, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rax], 0
jz short loc_78B61
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_78B6B
loc_78B61:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_78B6B:
cmp eax, 1
jnz short loc_78B76
mov rax, [rdi]
call qword ptr [rax+18h]
loc_78B76:
mov eax, ebx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
| long long minja::Value::get<bool>(minja::Value *this, __m128d a2, long long a3, unsigned int a4)
{
_QWORD *v5; // rax
unsigned int v6; // eax
long long v7; // rdi
signed __int32 v8; // eax
__int128 v10; // [rsp+0h] [rbp-68h] BYREF
volatile signed __int32 *v11; // [rsp+18h] [rbp-50h] BYREF
volatile signed __int32 *v12; // [rsp+28h] [rbp-40h] BYREF
volatile signed __int32 *v13; // [rsp+38h] [rbp-30h] BYREF
char v14[40]; // [rsp+40h] [rbp-28h] BYREF
if ( minja::Value::contains((long long)this, a2) )
{
minja::Value::Value(&v10);
v5 = (_QWORD *)minja::Value::at(this, (const minja::Value *)&v10);
LOBYTE(v6) = minja::Value::get<bool>(v5);
a4 = v6;
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(v14);
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(v14);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v13);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v12);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v11);
v7 = *((_QWORD *)&v10 + 1);
if ( *((_QWORD *)&v10 + 1) )
{
if ( _libc_single_threaded )
{
v8 = *(_DWORD *)(*((_QWORD *)&v10 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v10 + 1) + 12LL) = v8 - 1;
}
else
{
v8 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v10 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v8 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v7 + 24LL))(v7, 0LL);
}
}
return a4;
}
| get<bool>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV EBX,EDX
MOV R15,RSI
MOV R14,RDI
CALL 0x0016ed8a
TEST AL,AL
JZ 0x00178b76
MOV RBX,RSP
MOV RDI,RBX
MOV RSI,R15
CALL 0x001602f8
LAB_00178af4:
MOV RDI,R14
MOV RSI,RBX
CALL 0x0016d2d4
MOV RDI,RAX
CALL 0x001642d8
LAB_00178b07:
MOV EBX,EAX
LEA R14,[RSP + 0x40]
MOV RDI,R14
XOR ESI,ESI
CALL 0x00160b38
MOV RDI,R14
CALL 0x00160bd8
LEA RDI,[RSP + 0x38]
CALL 0x00156124
LEA RDI,[RSP + 0x28]
CALL 0x00156124
LEA R14,[RSP + 0x18]
MOV RDI,R14
CALL 0x00156124
MOV RDI,qword ptr [R14 + -0x10]
TEST RDI,RDI
JZ 0x00178b76
MOV RAX,qword ptr [0x0020af88]
CMP byte ptr [RAX],0x0
JZ 0x00178b61
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00178b6b
LAB_00178b61:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00178b6b:
CMP EAX,0x1
JNZ 0x00178b76
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00178b76:
MOV EAX,EBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* bool minja::Value::get<bool>(std::__cxx11::string const&, bool) const */
bool __thiscall minja::Value::get<bool>(Value *this,string *param_1,bool param_2)
{
int *piVar1;
char cVar2;
int iVar3;
Value *this_00;
Value aVStack_68 [8];
long *local_60;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_50 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_40 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_30 [8];
data local_28 [16];
cVar2 = contains(this,param_1);
if (cVar2 != '\0') {
Value(aVStack_68,param_1);
/* try { // try from 00178af4 to 00178b06 has its CatchHandler @ 00178b82 */
this_00 = (Value *)at(this,aVStack_68);
param_2 = get<bool>(this_00);
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_28,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_28);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_30);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_50);
if (local_60 != (long *)0x0) {
if (*PTR___libc_single_threaded_0020af88 == '\0') {
LOCK();
piVar1 = (int *)((long)local_60 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_60 + 0xc);
*(int *)((long)local_60 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_60 + 0x18))();
}
}
}
return param_2;
}
| |
38,117 | lex2str | eloqsql/strings/xml.c | static const char *lex2str(int lex)
{
switch(lex)
{
case MY_XML_EOF: return "END-OF-INPUT";
case MY_XML_STRING: return "STRING";
case MY_XML_IDENT: return "IDENT";
case MY_XML_CDATA: return "CDATA";
case MY_XML_EQ: return "'='";
case MY_XML_LT: return "'<'";
case MY_XML_GT: return "'>'";
case MY_XML_SLASH: return "'/'";
case MY_XML_COMMENT: return "COMMENT";
case MY_XML_TEXT: return "TEXT";
case MY_XML_QUESTION: return "'?'";
case MY_XML_EXCLAM: return "'!'";
}
return "unknown token";
} | O0 | c | lex2str:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x21, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x33, %eax
ja 0xd6745
movq -0x18(%rbp), %rax
leaq 0x142641(%rip), %rcx # 0x218cd8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7d3d(%rip), %rax # 0xde3e4
movq %rax, -0x8(%rbp)
jmp 0xd6750
leaq 0x7d54(%rip), %rax # 0xde40b
movq %rax, -0x8(%rbp)
jmp 0xd6750
leaq 0x7d4b(%rip), %rax # 0xde412
movq %rax, -0x8(%rbp)
jmp 0xd6750
leaq 0x7d41(%rip), %rax # 0xde418
movq %rax, -0x8(%rbp)
jmp 0xd6750
leaq 0x7d3a(%rip), %rax # 0xde41e
movq %rax, -0x8(%rbp)
jmp 0xd6750
leaq 0x7d31(%rip), %rax # 0xde422
movq %rax, -0x8(%rbp)
jmp 0xd6750
leaq 0x7d28(%rip), %rax # 0xde426
movq %rax, -0x8(%rbp)
jmp 0xd6750
leaq 0x7d1f(%rip), %rax # 0xde42a
movq %rax, -0x8(%rbp)
jmp 0xd6750
leaq 0x7d16(%rip), %rax # 0xde42e
movq %rax, -0x8(%rbp)
jmp 0xd6750
leaq 0x7d11(%rip), %rax # 0xde436
movq %rax, -0x8(%rbp)
jmp 0xd6750
leaq 0x7d09(%rip), %rax # 0xde43b
movq %rax, -0x8(%rbp)
jmp 0xd6750
leaq 0x7d00(%rip), %rax # 0xde43f
movq %rax, -0x8(%rbp)
jmp 0xd6750
leaq 0x7cf7(%rip), %rax # 0xde443
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| lex2str:
push rbp
mov rbp, rsp
mov [rbp+var_C], edi
mov eax, [rbp+var_C]
add eax, 0FFFFFFDFh; switch 52 cases
mov ecx, eax
mov [rbp+var_18], rcx
sub eax, 33h
ja def_D669E; jumptable 00000000000D669E default case, cases 34-46,48-59,64-66,70-72,74-82
mov rax, [rbp+var_18]
lea rcx, jpt_D669E
movsxd rax, ds:(jpt_D669E - 218CD8h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_D66A0:
lea rax, aUnexpectedEndO+0Bh; jumptable 00000000000D669E case 69
mov [rbp+var_8], rax
jmp loc_D6750
loc_D66B0:
lea rax, aString; jumptable 00000000000D669E case 83
mov [rbp+var_8], rax
jmp loc_D6750
loc_D66C0:
lea rax, aIdent; jumptable 00000000000D669E case 73
mov [rbp+var_8], rax
jmp loc_D6750
loc_D66D0:
lea rax, aCdata_0; jumptable 00000000000D669E case 68
mov [rbp+var_8], rax
jmp short loc_D6750
loc_D66DD:
lea rax, asc_DE41E; jumptable 00000000000D669E case 61
mov [rbp+var_8], rax
jmp short loc_D6750
loc_D66EA:
lea rax, asc_DE422; jumptable 00000000000D669E case 60
mov [rbp+var_8], rax
jmp short loc_D6750
loc_D66F7:
lea rax, asc_DE426; jumptable 00000000000D669E case 62
mov [rbp+var_8], rax
jmp short loc_D6750
loc_D6704:
lea rax, asc_DE42A; jumptable 00000000000D669E case 47
mov [rbp+var_8], rax
jmp short loc_D6750
loc_D6711:
lea rax, aComment; jumptable 00000000000D669E case 67
mov [rbp+var_8], rax
jmp short loc_D6750
loc_D671E:
lea rax, aText; jumptable 00000000000D669E case 84
mov [rbp+var_8], rax
jmp short loc_D6750
loc_D672B:
lea rax, asc_DE43B; jumptable 00000000000D669E case 63
mov [rbp+var_8], rax
jmp short loc_D6750
loc_D6738:
lea rax, asc_DE43F; jumptable 00000000000D669E case 33
mov [rbp+var_8], rax
jmp short loc_D6750
def_D669E:
lea rax, aUnknownToken; jumptable 00000000000D669E default case, cases 34-46,48-59,64-66,70-72,74-82
mov [rbp+var_8], rax
loc_D6750:
mov rax, [rbp+var_8]
pop rbp
retn
| char * lex2str(int a1)
{
char *v2; // [rsp+10h] [rbp-8h]
switch ( a1 )
{
case '!':
v2 = "'!'";
break;
case '/':
v2 = "'/'";
break;
case '<':
v2 = "'<'";
break;
case '=':
v2 = "'='";
break;
case '>':
v2 = "'>'";
break;
case '?':
v2 = "'?'";
break;
case 'C':
v2 = "COMMENT";
break;
case 'D':
v2 = "CDATA";
break;
case 'E':
v2 = "END-OF-INPUT";
break;
case 'I':
v2 = "IDENT";
break;
case 'S':
v2 = "STRING";
break;
case 'T':
v2 = "TEXT";
break;
default:
v2 = "unknown token";
break;
}
return v2;
}
| lex2str:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0xc],EDI
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,-0x21
MOV ECX,EAX
MOV qword ptr [RBP + -0x18],RCX
SUB EAX,0x33
JA 0x001d6745
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x318cd8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_45:
LEA RAX,[0x1de3e4]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001d6750
caseD_53:
LEA RAX,[0x1de40b]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001d6750
caseD_49:
LEA RAX,[0x1de412]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001d6750
caseD_44:
LEA RAX,[0x1de418]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001d6750
caseD_3d:
LEA RAX,[0x1de41e]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001d6750
caseD_3c:
LEA RAX,[0x1de422]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001d6750
caseD_3e:
LEA RAX,[0x1de426]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001d6750
caseD_2f:
LEA RAX,[0x1de42a]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001d6750
caseD_43:
LEA RAX,[0x1de42e]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001d6750
caseD_54:
LEA RAX,[0x1de436]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001d6750
caseD_3f:
LEA RAX,[0x1de43b]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001d6750
caseD_21:
LEA RAX,[0x1de43f]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001d6750
caseD_22:
LEA RAX,[0x1de443]
MOV qword ptr [RBP + -0x8],RAX
LAB_001d6750:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
char * lex2str(int4 param_1)
{
char *local_10;
switch(param_1) {
case 0x21:
local_10 = "\'!\'";
break;
default:
local_10 = "unknown token";
break;
case 0x2f:
local_10 = "\'/\'";
break;
case 0x3c:
local_10 = "\'<\'";
break;
case 0x3d:
local_10 = "\'=\'";
break;
case 0x3e:
local_10 = "\'>\'";
break;
case 0x3f:
local_10 = "\'?\'";
break;
case 0x43:
local_10 = "COMMENT";
break;
case 0x44:
local_10 = "CDATA";
break;
case 0x45:
local_10 = "END-OF-INPUT";
break;
case 0x49:
local_10 = "IDENT";
break;
case 0x53:
local_10 = "STRING";
break;
case 0x54:
local_10 = "TEXT";
}
return local_10;
}
| |
38,118 | ma_memmap_file | eloqsql/storage/maria/ma_packrec.c | my_bool _ma_memmap_file(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_memmap_file");
if (!info->s->file_map)
{
if (mysql_file_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0)) <
share->state.state.data_file_length+MEMMAP_EXTRA_MARGIN)
{
DBUG_PRINT("warning",("File isn't extended for memmap"));
DBUG_RETURN(0);
}
if (_ma_dynmap_file(info, share->state.state.data_file_length))
DBUG_RETURN(0);
}
info->opt_flag|= MEMMAP_USED;
info->read_record= share->read_record= _ma_read_mempack_record;
share->scan= _ma_read_rnd_mempack_record;
DBUG_RETURN(1);
} | O3 | c | ma_memmap_file:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq (%rdi), %r12
cmpq $0x0, 0x5f0(%r12)
je 0x3655f
orb $0x20, 0x61c(%rbx)
leaq 0x9f(%rip), %rax # 0x365dc
movq %rax, 0x648(%r12)
movq %rax, 0x3d8(%rbx)
leaq 0x136(%rip), %rax # 0x36689
movq %rax, 0x658(%r12)
movb $0x1, %al
jmp 0x365b8
movl 0x480(%rbx), %r14d
leaq 0x34eaa3(%rip), %rax # 0x385010
movq (%rax), %rax
leaq -0x70(%rbp), %rdi
movl %r14d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x365c5
movl %r14d, %edi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0xa0464
movq 0x40(%r12), %rsi
leaq 0x7(%rsi), %rcx
cmpq %rcx, %rax
jb 0x365b6
movq %rbx, %rdi
callq 0x38180
testb %al, %al
je 0x3652f
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x28(%rbp), %r15
movq %rax, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x29e40
movq (%r15), %rax
jmp 0x36598
| _ma_memmap_file:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 50h
mov rbx, rdi
mov r12, [rdi]
cmp qword ptr [r12+5F0h], 0
jz short loc_3655F
loc_3652F:
or byte ptr [rbx+61Ch], 20h
lea rax, _ma_read_mempack_record
mov [r12+648h], rax
mov [rbx+3D8h], rax
lea rax, _ma_read_rnd_mempack_record
mov [r12+658h], rax
mov al, 1
jmp short loc_365B8
loc_3655F:
mov r14d, [rbx+480h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_70]
mov esi, r14d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz short loc_365C5
mov edi, r14d
xor esi, esi
mov edx, 2
xor ecx, ecx
call my_seek
loc_36598:
mov rsi, [r12+40h]
lea rcx, [rsi+7]
cmp rax, rcx
jb short loc_365B6
mov rdi, rbx
call _ma_dynmap_file
test al, al
jz loc_3652F
loc_365B6:
xor eax, eax
loc_365B8:
add rsp, 50h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_365C5:
lea r15, [rbp+var_28]
mov rdi, rax
mov esi, r14d
mov rdx, r15
call _ma_memmap_file_cold_1
mov rax, [r15]
jmp short loc_36598
| char ma_memmap_file(long long a1)
{
_QWORD *v1; // r12
unsigned int v3; // r14d
long long v4; // rax
unsigned long long v5; // rax
long long v6; // rsi
_BYTE v7[72]; // [rsp+0h] [rbp-70h] BYREF
unsigned long long v8[5]; // [rsp+48h] [rbp-28h] BYREF
v1 = *(_QWORD **)a1;
if ( !*(_QWORD *)(*(_QWORD *)a1 + 1520LL) )
{
v3 = *(_DWORD *)(a1 + 1152);
v4 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v7, v3, 8LL);
if ( v4 )
{
ma_memmap_file_cold_1(v4, v3, v8);
v5 = v8[0];
}
else
{
v5 = my_seek(v3, 0LL, 2LL, 0LL);
}
v6 = v1[8];
if ( v5 < v6 + 7 || (unsigned __int8)ma_dynmap_file(a1, v6) )
return 0;
}
*(_BYTE *)(a1 + 1564) |= 0x20u;
v1[201] = ma_read_mempack_record;
*(_QWORD *)(a1 + 984) = ma_read_mempack_record;
v1[203] = ma_read_rnd_mempack_record;
return 1;
}
| _ma_memmap_file:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV RBX,RDI
MOV R12,qword ptr [RDI]
CMP qword ptr [R12 + 0x5f0],0x0
JZ 0x0013655f
LAB_0013652f:
OR byte ptr [RBX + 0x61c],0x20
LEA RAX,[0x1365dc]
MOV qword ptr [R12 + 0x648],RAX
MOV qword ptr [RBX + 0x3d8],RAX
LEA RAX,[0x136689]
MOV qword ptr [R12 + 0x658],RAX
MOV AL,0x1
JMP 0x001365b8
LAB_0013655f:
MOV R14D,dword ptr [RBX + 0x480]
LEA RAX,[0x485010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x70]
MOV ESI,R14D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001365c5
MOV EDI,R14D
XOR ESI,ESI
MOV EDX,0x2
XOR ECX,ECX
CALL 0x001a0464
LAB_00136598:
MOV RSI,qword ptr [R12 + 0x40]
LEA RCX,[RSI + 0x7]
CMP RAX,RCX
JC 0x001365b6
MOV RDI,RBX
CALL 0x00138180
TEST AL,AL
JZ 0x0013652f
LAB_001365b6:
XOR EAX,EAX
LAB_001365b8:
ADD RSP,0x50
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001365c5:
LEA R15,[RBP + -0x28]
MOV RDI,RAX
MOV ESI,R14D
MOV RDX,R15
CALL 0x00129e40
MOV RAX,qword ptr [R15]
JMP 0x00136598
|
int8 _ma_memmap_file(long *param_1)
{
int4 uVar1;
long lVar2;
char cVar3;
int8 uVar4;
long lVar5;
int1 local_78 [72];
ulong local_30;
lVar2 = *param_1;
if (*(long *)(lVar2 + 0x5f0) == 0) {
uVar1 = (int4)param_1[0x90];
lVar5 = (**(code **)(PSI_server + 0x158))(local_78,uVar1,8);
if (lVar5 == 0) {
local_30 = my_seek(uVar1,0,2,0);
}
else {
_ma_memmap_file_cold_1(lVar5,uVar1,&local_30);
}
if (*(long *)(lVar2 + 0x40) + 7U <= local_30) {
cVar3 = _ma_dynmap_file(param_1);
if (cVar3 == '\0') goto LAB_0013652f;
}
uVar4 = 0;
}
else {
LAB_0013652f:
*(byte *)((long)param_1 + 0x61c) = *(byte *)((long)param_1 + 0x61c) | 0x20;
*(code **)(lVar2 + 0x648) = _ma_read_mempack_record;
param_1[0x7b] = (long)_ma_read_mempack_record;
*(code **)(lVar2 + 0x658) = _ma_read_rnd_mempack_record;
uVar4 = 0x136601;
}
return uVar4;
}
| |
38,119 | my_mb_wc_eucjpms | eloqsql/strings/ctype-eucjpms.c | static int
my_mb_wc_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII code set: [00..7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
if (hi >= 0xA1 && hi <= 0xFE) /* JIS X 0208 code set: [A1..FE][A1..FE] */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
return (*pwc= jisx0208_eucjpms_to_unicode[(hi << 8) + s[1]]) ? 2 :
(s[1] < 0xA1 || s[1] > 0xFE) ? MY_CS_ILSEQ : -2;
}
/* JIS-X-0201 HALF WIDTH KATAKANA: [8E][A1..DF] -> [U+FF61..U+FF9F] */
if (hi == 0x8E)
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if (s[1] < 0xA1 || s[1] > 0xDF)
return MY_CS_ILSEQ;
*pwc= 0xFEC0 + s[1]; /* 0xFFC0 = 0xFF61 - 0xA1 */
return 2;
}
if (hi == 0x8F) /* JIS X 0212 code set: [8F][A1..FE][A1..FE] */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
return (*pwc= jisx0212_eucjpms_to_unicode[(((int) s[1]) << 8) + s[2]]) ?
3 :
(s[1] < 0xA1 || s[1] > 0xFE || s[2] < 0xA1 || s[2] > 0xFE) ?
MY_CS_ILSEQ : -3;
}
return MY_CS_ILSEQ;
} | O3 | c | my_mb_wc_eucjpms:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x6ab82
movzbl (%rdx), %edi
testb %dil, %dil
js 0x6ab84
movq %rdi, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leal 0x5f(%rdi), %eax
cmpb $0x5d, %al
ja 0x6abd0
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x6ab82
movzbl 0x1(%rdx), %eax
shll $0x9, %edi
leal (%rdi,%rax,2), %eax
leaq 0xab376(%rip), %rcx # 0x115f20
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0x6ab82
movb 0x1(%rdx), %al
incb %al
xorl %ecx, %ecx
cmpb $-0x5e, %al
setb %cl
leal -0x2(,%rcx,2), %eax
jmp 0x6ab82
cmpq $0x8f, %rdi
je 0x6ac14
cmpl $0x8e, %edi
jne 0x6ac56
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x6ab82
movzbl 0x1(%rdx), %ecx
leal 0x20(%rcx), %edx
movl $0x0, %eax
cmpb $-0x3f, %dl
jb 0x6ab82
addq $0xfec0, %rcx # imm = 0xFEC0
movq %rcx, (%rsi)
movl $0x2, %eax
jmp 0x6ab82
leaq 0x3(%rdx), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rdi
ja 0x6ab82
movzwl 0x1(%rdx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
leaq 0xcb2e8(%rip), %rcx # 0x135f20
movzwl (%rcx,%rax,2), %ecx
movq %rcx, (%rsi)
movl $0x3, %eax
testq %rcx, %rcx
jne 0x6ab82
movb 0x1(%rdx), %al
incb %al
cmpb $-0x5e, %al
jae 0x6ac5d
xorl %eax, %eax
jmp 0x6ab82
movb 0x2(%rdx), %cl
movl $0x0, %eax
cmpb $-0x5f, %cl
jb 0x6ab82
xorl %eax, %eax
cmpb $-0x1, %cl
sete %al
leal (%rax,%rax,2), %eax
addl $-0x3, %eax
jmp 0x6ab82
| my_mb_wc_eucjpms:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_6AB82
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_6AB84
mov [rsi], rdi
mov eax, 1
loc_6AB82:
pop rbp
retn
loc_6AB84:
lea eax, [rdi+5Fh]
cmp al, 5Dh ; ']'
ja short loc_6ABD0
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_6AB82
movzx eax, byte ptr [rdx+1]
shl edi, 9
lea eax, [rdi+rax*2]
lea rcx, jisx0208_eucjpms_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_6AB82
mov al, [rdx+1]
inc al
xor ecx, ecx
cmp al, 0A2h
setb cl
lea eax, ds:0FFFFFFFFFFFFFFFEh[rcx*2]
jmp short loc_6AB82
loc_6ABD0:
cmp rdi, 8Fh
jz short loc_6AC14
cmp edi, 8Eh
jnz short loc_6AC56
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_6AB82
movzx ecx, byte ptr [rdx+1]
lea edx, [rcx+20h]
mov eax, 0
cmp dl, 0C1h
jb short loc_6AB82
add rcx, 0FEC0h
mov [rsi], rcx
mov eax, 2
jmp loc_6AB82
loc_6AC14:
lea rdi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rdi, rcx
ja loc_6AB82
movzx eax, word ptr [rdx+1]
rol ax, 8
movzx eax, ax
lea rcx, jisx0212_eucjpms_to_unicode
movzx ecx, word ptr [rcx+rax*2]
mov [rsi], rcx
mov eax, 3
test rcx, rcx
jnz loc_6AB82
mov al, [rdx+1]
inc al
cmp al, 0A2h
jnb short loc_6AC5D
loc_6AC56:
xor eax, eax
jmp loc_6AB82
loc_6AC5D:
mov cl, [rdx+2]
mov eax, 0
cmp cl, 0A1h
jb loc_6AB82
xor eax, eax
cmp cl, 0FFh
setz al
lea eax, [rax+rax*2]
add eax, 0FFFFFFFDh
jmp loc_6AB82
| long long my_mb_wc_eucjpms(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
long long v7; // rcx
long long v8; // rcx
unsigned __int8 v9; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x5Du )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = jisx0208_eucjpms_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
return 2 * (unsigned int)((unsigned __int8)(a3[1] + 1) < 0xA2u) - 2;
}
return result;
}
if ( v5 != 143 )
{
if ( (_DWORD)v5 == 142 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v7 = a3[1];
result = 0LL;
if ( (unsigned __int8)(v7 + 32) >= 0xC1u )
{
*a2 = v7 + 65216;
return 2LL;
}
}
return result;
}
return 0LL;
}
result = 4294967193LL;
if ( (unsigned long long)(a3 + 3) > a4 )
return result;
v8 = jisx0212_eucjpms_to_unicode[(unsigned __int16)__ROL2__(*(_WORD *)(a3 + 1), 8)];
*a2 = v8;
result = 3LL;
if ( v8 )
return result;
if ( (unsigned __int8)(a3[1] + 1) < 0xA2u )
return 0LL;
v9 = a3[2];
result = 0LL;
if ( v9 >= 0xA1u )
return 3 * (unsigned int)(v9 == 0xFF) - 3;
return result;
}
| my_mb_wc_eucjpms:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0016ab82
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x0016ab84
MOV qword ptr [RSI],RDI
MOV EAX,0x1
LAB_0016ab82:
POP RBP
RET
LAB_0016ab84:
LEA EAX,[RDI + 0x5f]
CMP AL,0x5d
JA 0x0016abd0
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x0016ab82
MOVZX EAX,byte ptr [RDX + 0x1]
SHL EDI,0x9
LEA EAX,[RDI + RAX*0x2]
LEA RCX,[0x215f20]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x0016ab82
MOV AL,byte ptr [RDX + 0x1]
INC AL
XOR ECX,ECX
CMP AL,0xa2
SETC CL
LEA EAX,[-0x2 + RCX*0x2]
JMP 0x0016ab82
LAB_0016abd0:
CMP RDI,0x8f
JZ 0x0016ac14
CMP EDI,0x8e
JNZ 0x0016ac56
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x0016ab82
MOVZX ECX,byte ptr [RDX + 0x1]
LEA EDX,[RCX + 0x20]
MOV EAX,0x0
CMP DL,0xc1
JC 0x0016ab82
ADD RCX,0xfec0
MOV qword ptr [RSI],RCX
MOV EAX,0x2
JMP 0x0016ab82
LAB_0016ac14:
LEA RDI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RDI,RCX
JA 0x0016ab82
MOVZX EAX,word ptr [RDX + 0x1]
ROL AX,0x8
MOVZX EAX,AX
LEA RCX,[0x235f20]
MOVZX ECX,word ptr [RCX + RAX*0x2]
MOV qword ptr [RSI],RCX
MOV EAX,0x3
TEST RCX,RCX
JNZ 0x0016ab82
MOV AL,byte ptr [RDX + 0x1]
INC AL
CMP AL,0xa2
JNC 0x0016ac5d
LAB_0016ac56:
XOR EAX,EAX
JMP 0x0016ab82
LAB_0016ac5d:
MOV CL,byte ptr [RDX + 0x2]
MOV EAX,0x0
CMP CL,0xa1
JC 0x0016ab82
XOR EAX,EAX
CMP CL,0xff
SETZ AL
LEA EAX,[RAX + RAX*0x2]
ADD EAX,-0x3
JMP 0x0016ab82
|
int my_mb_wc_eucjpms(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if ((byte)(bVar1 + 0x5f) < 0x5e) {
iVar3 = -0x66;
if (param_3 + 2 <= param_4) {
uVar2 = *(ushort *)
(jisx0208_eucjpms_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
iVar3 = 2;
if ((ulong)uVar2 == 0) {
iVar3 = (uint)((byte)(param_3[1] + 1) < 0xa2) * 2 + -2;
}
}
}
else {
if ((ulong)bVar1 == 0x8f) {
if (param_4 < param_3 + 3) {
return -0x67;
}
uVar2 = *(ushort *)
(&jisx0212_eucjpms_to_unicode +
(ulong)(ushort)(*(ushort *)(param_3 + 1) << 8 | *(ushort *)(param_3 + 1) >> 8) *
2);
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 3;
}
if (0xa1 < (byte)(param_3[1] + 1)) {
if (param_3[2] < 0xa1) {
return 0;
}
return (uint)(param_3[2] == 0xff) * 3 + -3;
}
}
else if (bVar1 == 0x8e) {
if (param_4 < param_3 + 2) {
return -0x66;
}
if ((byte)(param_3[1] + 0x20) < 0xc1) {
return 0;
}
*param_2 = (ulong)param_3[1] + 0xfec0;
return 2;
}
iVar3 = 0;
}
}
else {
*param_2 = (ulong)bVar1;
iVar3 = 1;
}
}
return iVar3;
}
| |
38,120 | HKDF_Extract | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/keygen.c | static void HKDF_Extract(unsigned char PRK[32],
const void *salt, size_t salt_len,
const void *IKM, size_t IKM_len,
#ifndef __BLST_HKDF_TESTMODE__
int IKM_fixup,
#endif
HMAC_SHA256_CTX *ctx)
{
unsigned char zero[1] = { 0 };
HMAC_init(ctx, salt != NULL ? salt : zero, salt_len);
HMAC_update(ctx, IKM, IKM_len);
#ifndef __BLST_HKDF_TESTMODE__
if (IKM_fixup) {
/* Section 2.3 KeyGen in BLS-signature draft */
HMAC_update(ctx, zero, 1);
}
#endif
HMAC_final(PRK, ctx);
} | O0 | c | HKDF_Extract:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
leaq -0x2d(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x5110
movq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3286d
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x32875
leaq -0x2d(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x32a80
movq 0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x32c60
cmpl $0x0, -0x2c(%rbp)
je 0x328af
movq 0x10(%rbp), %rdi
leaq -0x2d(%rbp), %rsi
movl $0x1, %edx
callq 0x32c60
movq -0x8(%rbp), %rdi
movq 0x10(%rbp), %rsi
callq 0x32c90
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| HKDF_Extract:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, [rbp+arg_0]
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 [rbp+var_2C], r9d
lea rdi, [rbp+var_2D]
xor esi, esi
mov edx, 1
call _memset
mov rax, [rbp+arg_0]
mov [rbp+var_38], rax
cmp [rbp+var_10], 0
jz short loc_3286D
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
jmp short loc_32875
loc_3286D:
lea rax, [rbp+var_2D]
mov [rbp+var_40], rax
loc_32875:
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_18]
call HMAC_init
mov rdi, [rbp+arg_0]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call HMAC_update
cmp [rbp+var_2C], 0
jz short loc_328AF
mov rdi, [rbp+arg_0]
lea rsi, [rbp+var_2D]
mov edx, 1
call HMAC_update
loc_328AF:
mov rdi, [rbp+var_8]
mov rsi, [rbp+arg_0]
call HMAC_final
add rsp, 40h
pop rbp
retn
| long long HKDF_Extract(long long a1, long long a2, long long a3, long long a4, long long a5, int a6, long long a7)
{
char v8; // [rsp+13h] [rbp-2Dh] BYREF
int v9; // [rsp+14h] [rbp-2Ch]
long long v10; // [rsp+18h] [rbp-28h]
long long v11; // [rsp+20h] [rbp-20h]
long long v12; // [rsp+28h] [rbp-18h]
long long v13; // [rsp+30h] [rbp-10h]
long long v14; // [rsp+38h] [rbp-8h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = a4;
v10 = a5;
v9 = a6;
memset(&v8, 0LL, sizeof(v8));
if ( v13 )
HMAC_init(a7, v13, v12);
else
HMAC_init(a7, &v8, v12);
HMAC_update(a7, v11, v10);
if ( v9 )
HMAC_update(a7, &v8, 1LL);
return HMAC_final(v14, a7);
}
| HKDF_Extract:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr [RBP + 0x10]
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 dword ptr [RBP + -0x2c],R9D
LEA RDI,[RBP + -0x2d]
XOR ESI,ESI
MOV EDX,0x1
CALL 0x00105110
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0013286d
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00132875
LAB_0013286d:
LEA RAX,[RBP + -0x2d]
MOV qword ptr [RBP + -0x40],RAX
LAB_00132875:
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00132a80
MOV RDI,qword ptr [RBP + 0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x00132c60
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x001328af
MOV RDI,qword ptr [RBP + 0x10]
LEA RSI,[RBP + -0x2d]
MOV EDX,0x1
CALL 0x00132c60
LAB_001328af:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + 0x10]
CALL 0x00132c90
ADD RSP,0x40
POP RBP
RET
|
void HKDF_Extract(int8 param_1,int1 *param_2,int8 param_3,int8 param_4,
int8 param_5,int param_6,int8 param_7)
{
int1 *local_48;
int1 local_35;
int local_34;
int8 local_30;
int8 local_28;
int8 local_20;
int1 *local_18;
int8 local_10;
local_34 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
memset(&local_35,0,1);
if (local_18 == (int1 *)0x0) {
local_48 = &local_35;
}
else {
local_48 = local_18;
}
HMAC_init(param_7,local_48,local_20);
HMAC_update(param_7,local_28,local_30);
if (local_34 != 0) {
HMAC_update(param_7,&local_35,1);
}
HMAC_final(local_10,param_7);
return;
}
| |
38,121 | my_copy_8bit | eloqsql/strings/ctype-simple.c | size_t
my_copy_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
set_if_smaller(src_length, dst_length);
set_if_smaller(src_length, nchars);
if (src_length)
memmove(dst, src, src_length);
status->m_source_end_pos= src + src_length;
status->m_well_formed_error_pos= NULL;
return src_length;
} | O0 | c | my_copy_8bit:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x1484d6
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x1484d8
jmp 0x1484da
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x1484ec
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x1484ee
cmpq $0x0, -0x28(%rbp)
je 0x148506
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2a160
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_copy_8bit:
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, [rbp+arg_0]
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 [rbp+var_30], r9
mov rax, [rbp+var_28]
cmp rax, [rbp+var_18]
jbe short loc_1484D6
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
loc_1484D6:
jmp short $+2
loc_1484D8:
jmp short $+2
loc_1484DA:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jbe short loc_1484EC
mov rax, [rbp+var_30]
mov [rbp+var_28], rax
loc_1484EC:
jmp short $+2
loc_1484EE:
cmp [rbp+var_28], 0
jz short loc_148506
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call _memmove
loc_148506:
mov rcx, [rbp+var_20]
add rcx, [rbp+var_28]
mov rax, [rbp+arg_0]
mov [rax], rcx
mov rax, [rbp+arg_0]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
| unsigned long long my_copy_8bit(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
unsigned long long a6,
_QWORD *a7)
{
unsigned long long v8; // [rsp+8h] [rbp-28h]
v8 = a5;
if ( a5 > a3 )
v8 = a3;
if ( v8 > a6 )
v8 = a6;
if ( v8 )
memmove(a2, a4, v8);
*a7 = v8 + a4;
a7[1] = 0LL;
return v8;
}
| |||
38,122 | my_copy_8bit | eloqsql/strings/ctype-simple.c | size_t
my_copy_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
set_if_smaller(src_length, dst_length);
set_if_smaller(src_length, nchars);
if (src_length)
memmove(dst, src, src_length);
status->m_source_end_pos= src + src_length;
status->m_well_formed_error_pos= NULL;
return src_length;
} | O3 | c | my_copy_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq 0x10(%rbp), %r15
cmpq %rdx, %r8
cmovbq %r8, %rbx
cmpq %r9, %rbx
cmovaeq %r9, %rbx
testq %rbx, %rbx
je 0xd5b85
movq %rsi, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2a150
addq %rbx, %r14
movq %r14, (%r15)
movq $0x0, 0x8(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| my_copy_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rcx
mov rbx, rdx
mov r15, [rbp+arg_0]
cmp r8, rdx
cmovb rbx, r8
cmp rbx, r9
cmovnb rbx, r9
test rbx, rbx
jz short loc_D5B85
mov rdi, rsi
mov rsi, r14
mov rdx, rbx
call _memmove
loc_D5B85:
add r14, rbx
mov [r15], r14
mov qword ptr [r15+8], 0
mov rax, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| unsigned long long my_copy_8bit(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
unsigned long long a6,
_QWORD *a7)
{
unsigned long long v8; // rbx
v8 = a3;
if ( a5 < a3 )
v8 = a5;
if ( v8 >= a6 )
v8 = a6;
if ( v8 )
memmove(a2, a4, v8);
*a7 = v8 + a4;
a7[1] = 0LL;
return v8;
}
| my_copy_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV RBX,RDX
MOV R15,qword ptr [RBP + 0x10]
CMP R8,RDX
CMOVC RBX,R8
CMP RBX,R9
CMOVNC RBX,R9
TEST RBX,RBX
JZ 0x001d5b85
MOV RDI,RSI
MOV RSI,R14
MOV RDX,RBX
CALL 0x0012a150
LAB_001d5b85:
ADD R14,RBX
MOV qword ptr [R15],R14
MOV qword ptr [R15 + 0x8],0x0
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
size_t my_copy_8bit(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
ulong param_6,long *param_7)
{
if (param_5 < param_3) {
param_3 = param_5;
}
if (param_6 <= param_3) {
param_3 = param_6;
}
if (param_3 != 0) {
memmove(param_2,param_4,param_3);
}
*param_7 = (long)param_4 + param_3;
param_7[1] = 0;
return param_3;
}
| |
38,123 | ma_hashtbl_search | eloqsql/libmariadb/libmariadb/ma_hashtbl.c | void* ma_hashtbl_search(MA_HASHTBL *hash,const uchar *key,uint length)
{
MA_HASHTBL_LINK *pos;
uint flag,idx;
flag=1;
if (hash->records)
{
idx=hash_mask((*hash->calc_hashnr)(key,length ? length :
hash->key_length),
hash->blength,hash->records);
do
{
pos= dynamic_element(&hash->array,idx,MA_HASHTBL_LINK*);
if (!hashcmp(hash,pos,key,length))
{
hash->current_record= idx;
return (pos->data);
}
if (flag)
{
flag=0; /* Reset flag */
if (hash_rec_mask(hash,pos,hash->blength,hash->records) != idx)
break; /* Wrong link */
}
}
while ((idx=pos->next) != NO_RECORD);
}
hash->current_record= NO_RECORD;
return(0);
} | O3 | c | ma_hashtbl_search:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x5433c
movl %edx, %r14d
movq 0x40(%rbx), %rax
movl %edx, %esi
testl %edx, %edx
jne 0x542c7
movl 0x4(%rbx), %esi
movq -0x30(%rbp), %rdi
callq *%rax
movl 0xc(%rbx), %r12d
leal -0x1(%r12), %ecx
andl %eax, %ecx
shrl %r12d
decl %r12d
andl %eax, %r12d
cmpl 0x8(%rbx), %ecx
cmovbl %ecx, %r12d
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movl %r12d, %ecx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r13
movq 0x8(%rax,%rcx), %rsi
movq %rbx, %rdi
movq -0x30(%rbp), %rdx
movl %r14d, %ecx
callq 0x5435e
testl %eax, %eax
je 0x54347
testb $0x1, %r15b
jne 0x5432f
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %edx
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0x543d4
cmpl %r12d, %eax
jne 0x5433c
movl (%r13), %r12d
movb $0x1, %r15b
cmpl $-0x1, %r12d
jne 0x542eb
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
xorl %eax, %eax
jmp 0x5434f
movl %r12d, 0x10(%rbx)
movq 0x8(%r13), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_hashtbl_search:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rbp+var_30], rsi
mov rbx, rdi
cmp dword ptr [rdi+8], 0
jz loc_5433C
mov r14d, edx
mov rax, [rbx+40h]
mov esi, edx
test edx, edx
jnz short loc_542C7
mov esi, [rbx+4]
loc_542C7:
mov rdi, [rbp+var_30]
call rax
mov r12d, [rbx+0Ch]
lea ecx, [r12-1]
and ecx, eax
shr r12d, 1
dec r12d
and r12d, eax
cmp ecx, [rbx+8]
cmovb r12d, ecx
xor r15d, r15d
loc_542EB:
mov rax, [rbx+18h]
mov ecx, r12d
shl rcx, 4
lea r13, [rax+rcx]
mov rsi, [rax+rcx+8]
mov rdi, rbx
mov rdx, [rbp+var_30]
mov ecx, r14d
call hashcmp
test eax, eax
jz short loc_54347
test r15b, 1
jnz short loc_5432F
mov ecx, [rbx+8]
mov edx, [rbx+0Ch]
mov rsi, [r13+8]
mov rdi, rbx
call hash_rec_mask
cmp eax, r12d
jnz short loc_5433C
loc_5432F:
mov r12d, [r13+0]
mov r15b, 1
cmp r12d, 0FFFFFFFFh
jnz short loc_542EB
loc_5433C:
mov dword ptr [rbx+10h], 0FFFFFFFFh
xor eax, eax
jmp short loc_5434F
loc_54347:
mov [rbx+10h], r12d
mov rax, [r13+8]
loc_5434F:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_hashtbl_search(long long a1, long long a2, unsigned int a3)
{
long long v4; // rsi
int v5; // eax
unsigned int v6; // r12d
unsigned int v7; // ecx
unsigned int v8; // r12d
char v9; // r15
long long v10; // r13
if ( *(_DWORD *)(a1 + 8) )
{
v4 = a3;
if ( !a3 )
v4 = *(unsigned int *)(a1 + 4);
v5 = (*(long long ( **)(long long, long long))(a1 + 64))(a2, v4);
v6 = *(_DWORD *)(a1 + 12);
v7 = v5 & (v6 - 1);
v8 = v5 & ((v6 >> 1) - 1);
if ( v7 < *(_DWORD *)(a1 + 8) )
v8 = v7;
v9 = 0;
while ( 1 )
{
v10 = *(_QWORD *)(a1 + 24) + 16LL * v8;
if ( !(unsigned int)hashcmp(a1, *(_QWORD *)(v10 + 8), a2, a3) )
break;
if ( (v9 & 1) != 0
|| (unsigned int)hash_rec_mask(a1, *(_QWORD *)(v10 + 8), *(unsigned int *)(a1 + 12), *(unsigned int *)(a1 + 8)) == v8 )
{
v8 = *(_DWORD *)v10;
v9 = 1;
if ( *(_DWORD *)v10 != -1 )
continue;
}
goto LABEL_11;
}
*(_DWORD *)(a1 + 16) = v8;
return *(_QWORD *)(v10 + 8);
}
else
{
LABEL_11:
*(_DWORD *)(a1 + 16) = -1;
return 0LL;
}
}
| ma_hashtbl_search:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RBP + -0x30],RSI
MOV RBX,RDI
CMP dword ptr [RDI + 0x8],0x0
JZ 0x0015433c
MOV R14D,EDX
MOV RAX,qword ptr [RBX + 0x40]
MOV ESI,EDX
TEST EDX,EDX
JNZ 0x001542c7
MOV ESI,dword ptr [RBX + 0x4]
LAB_001542c7:
MOV RDI,qword ptr [RBP + -0x30]
CALL RAX
MOV R12D,dword ptr [RBX + 0xc]
LEA ECX,[R12 + -0x1]
AND ECX,EAX
SHR R12D,0x1
DEC R12D
AND R12D,EAX
CMP ECX,dword ptr [RBX + 0x8]
CMOVC R12D,ECX
XOR R15D,R15D
LAB_001542eb:
MOV RAX,qword ptr [RBX + 0x18]
MOV ECX,R12D
SHL RCX,0x4
LEA R13,[RAX + RCX*0x1]
MOV RSI,qword ptr [RAX + RCX*0x1 + 0x8]
MOV RDI,RBX
MOV RDX,qword ptr [RBP + -0x30]
MOV ECX,R14D
CALL 0x0015435e
TEST EAX,EAX
JZ 0x00154347
TEST R15B,0x1
JNZ 0x0015432f
MOV ECX,dword ptr [RBX + 0x8]
MOV EDX,dword ptr [RBX + 0xc]
MOV RSI,qword ptr [R13 + 0x8]
MOV RDI,RBX
CALL 0x001543d4
CMP EAX,R12D
JNZ 0x0015433c
LAB_0015432f:
MOV R12D,dword ptr [R13]
MOV R15B,0x1
CMP R12D,-0x1
JNZ 0x001542eb
LAB_0015433c:
MOV dword ptr [RBX + 0x10],0xffffffff
XOR EAX,EAX
JMP 0x0015434f
LAB_00154347:
MOV dword ptr [RBX + 0x10],R12D
MOV RAX,qword ptr [R13 + 0x8]
LAB_0015434f:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 ma_hashtbl_search(long param_1,int8 param_2,int param_3)
{
uint *puVar1;
uint uVar2;
int iVar3;
uint uVar4;
bool bVar5;
if (*(int *)(param_1 + 8) != 0) {
iVar3 = param_3;
if (param_3 == 0) {
iVar3 = *(int *)(param_1 + 4);
}
uVar2 = (**(code **)(param_1 + 0x40))(param_2,iVar3);
uVar4 = *(uint *)(param_1 + 0xc) - 1 & uVar2;
uVar2 = (*(uint *)(param_1 + 0xc) >> 1) - 1 & uVar2;
if (uVar4 < *(uint *)(param_1 + 8)) {
uVar2 = uVar4;
}
bVar5 = false;
do {
puVar1 = (uint *)(*(long *)(param_1 + 0x18) + (ulong)uVar2 * 0x10);
iVar3 = hashcmp(param_1,*(int8 *)(*(long *)(param_1 + 0x18) + 8 + (ulong)uVar2 * 0x10),
param_2,param_3);
if (iVar3 == 0) {
*(uint *)(param_1 + 0x10) = uVar2;
return *(int8 *)(puVar1 + 2);
}
if ((!bVar5) &&
(uVar4 = hash_rec_mask(param_1,*(int8 *)(puVar1 + 2),*(int4 *)(param_1 + 0xc),
*(int4 *)(param_1 + 8)), uVar4 != uVar2)) break;
uVar2 = *puVar1;
bVar5 = true;
} while (uVar2 != 0xffffffff);
}
*(int4 *)(param_1 + 0x10) = 0xffffffff;
return 0;
}
| |
38,124 | unlock_io_cache | eloqsql/mysys/mf_iocache.c | static void unlock_io_cache(IO_CACHE *cache)
{
IO_CACHE_SHARE *cshare= cache->share;
DBUG_ENTER("unlock_io_cache");
DBUG_PRINT("io_cache_share", ("%s: %p pos: %lu running: %u",
(cache == cshare->source_cache) ?
"writer" : "reader",
cache, (ulong) cshare->pos_in_file,
cshare->total_threads));
cshare->running_threads= cshare->total_threads;
mysql_cond_broadcast(&cshare->cond);
mysql_mutex_unlock(&cshare->mutex);
DBUG_VOID_RETURN;
} | O0 | c | unlock_io_cache:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xe4fcd
movq -0x10(%rbp), %rax
movl 0xdc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xd8(%rax)
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0xe3800
movq -0x10(%rbp), %rdi
callq 0xe3860
jmp 0xe4ff9
addq $0x10, %rsp
popq %rbp
retq
nop
| unlock_io_cache:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+98h]
mov [rbp+var_10], rax
jmp short $+2
loc_E4FCD:
mov rax, [rbp+var_10]
mov ecx, [rax+0DCh]
mov rax, [rbp+var_10]
mov [rax+0D8h], ecx
mov rdi, [rbp+var_10]
add rdi, 48h ; 'H'
call inline_mysql_cond_broadcast_2
mov rdi, [rbp+var_10]
call inline_mysql_mutex_unlock_24
jmp short $+2
loc_E4FF9:
add rsp, 10h
pop rbp
retn
| long long unlock_io_cache(long long a1)
{
long long v2; // [rsp+0h] [rbp-10h]
v2 = *(_QWORD *)(a1 + 152);
*(_DWORD *)(v2 + 216) = *(_DWORD *)(v2 + 220);
inline_mysql_cond_broadcast_2(v2 + 72);
return inline_mysql_mutex_unlock_24(v2);
}
| unlock_io_cache:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001e4fcd
LAB_001e4fcd:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0xdc]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xd8],ECX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x48
CALL 0x001e3800
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e3860
JMP 0x001e4ff9
LAB_001e4ff9:
ADD RSP,0x10
POP RBP
RET
|
void unlock_io_cache(long param_1)
{
long lVar1;
lVar1 = *(long *)(param_1 + 0x98);
*(int4 *)(lVar1 + 0xd8) = *(int4 *)(lVar1 + 0xdc);
inline_mysql_cond_broadcast(lVar1 + 0x48);
inline_mysql_mutex_unlock(lVar1);
return;
}
| |
38,125 | Settings::getCount(int) const | 666mxvbee[P]BattleShip/lib/Settings/Settings.cpp | uint64_t Settings::getCount(int typeShip) const {
std::lock_guard<std::mutex> lock(settings_mutex);
auto it = shipCounts.find(typeShip);
if (it != shipCounts.end()) {
return it->second;
}
return 0;
} | O0 | cpp | Settings::getCount(int) const:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xb200
movq -0x58(%rbp), %rdi
addq $0x60, %rdi
leaq -0x14(%rbp), %rsi
callq 0xb600
movq %rax, -0x50(%rbp)
jmp 0x9ef7
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x60, %rdi
callq 0xb660
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xb630
xorb $-0x1, %al
testb $0x1, %al
jne 0x9f25
jmp 0x9f56
leaq -0x28(%rbp), %rdi
callq 0xb690
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x9f65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xb290
jmp 0x9f78
movq $0x0, -0x8(%rbp)
movl $0x1, -0x44(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xb290
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
| _ZNK8Settings8getCountEi:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov rsi, [rbp+var_10]
mov [rbp+var_58], rsi
lea rdi, [rbp+var_20]
call _ZNSt10lock_guardISt5mutexEC2ERS0_; std::lock_guard<std::mutex>::lock_guard(std::mutex&)
mov rdi, [rbp+var_58]
add rdi, 60h ; '`'
lea rsi, [rbp+var_14]
call _ZNKSt3mapIimSt4lessIiESaISt4pairIKimEEE4findERS3_; std::map<int,ulong>::find(int const&)
mov [rbp+var_50], rax
jmp short $+2
loc_9EF7:
mov rdi, [rbp+var_58]
mov rax, [rbp+var_50]
mov [rbp+var_28], rax
add rdi, 60h ; '`'
call _ZNKSt3mapIimSt4lessIiESaISt4pairIKimEEE3endEv; std::map<int,ulong>::end(void)
mov [rbp+var_40], rax
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_40]
call _ZSteqRKSt23_Rb_tree_const_iteratorISt4pairIKimEES5_; std::operator==(std::_Rb_tree_const_iterator<std::pair<int const,ulong>> const&,std::_Rb_tree_const_iterator<std::pair<int const,ulong>> const&)
xor al, 0FFh
test al, 1
jnz short loc_9F25
jmp short loc_9F56
loc_9F25:
lea rdi, [rbp+var_28]
call _ZNKSt23_Rb_tree_const_iteratorISt4pairIKimEEptEv; std::_Rb_tree_const_iterator<std::pair<int const,ulong>>::operator->(void)
mov rax, [rax+8]
mov [rbp+var_8], rax
mov [rbp+var_44], 1
jmp short loc_9F65
mov rcx, rax
mov eax, edx
mov [rbp+var_30], rcx
mov [rbp+var_34], eax
lea rdi, [rbp+var_20]
call _ZNSt10lock_guardISt5mutexED2Ev; std::lock_guard<std::mutex>::~lock_guard()
jmp short loc_9F78
loc_9F56:
mov [rbp+var_8], 0
mov [rbp+var_44], 1
loc_9F65:
lea rdi, [rbp+var_20]
call _ZNSt10lock_guardISt5mutexED2Ev; std::lock_guard<std::mutex>::~lock_guard()
mov rax, [rbp+var_8]
add rsp, 60h
pop rbp
retn
loc_9F78:
mov rdi, [rbp+var_30]
call __Unwind_Resume
| long long Settings::getCount(Settings *this, int a2)
{
long long v3; // [rsp+20h] [rbp-40h] BYREF
long long v4; // [rsp+38h] [rbp-28h] BYREF
_BYTE v5[12]; // [rsp+40h] [rbp-20h] BYREF
int v6; // [rsp+4Ch] [rbp-14h] BYREF
Settings *v7; // [rsp+50h] [rbp-10h]
long long v8; // [rsp+58h] [rbp-8h]
v7 = this;
v6 = a2;
std::lock_guard<std::mutex>::lock_guard(v5);
v4 = std::map<int,unsigned long>::find((char *)this + 96, &v6);
v3 = std::map<int,unsigned long>::end((char *)this + 96);
if ( (std::operator==(&v4, &v3) & 1) != 0 )
v8 = 0LL;
else
v8 = *(_QWORD *)(std::_Rb_tree_const_iterator<std::pair<int const,unsigned long>>::operator->(&v4) + 8);
std::lock_guard<std::mutex>::~lock_guard(v5);
return v8;
}
| getCount:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV RSI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x58],RSI
LEA RDI,[RBP + -0x20]
CALL 0x0010b200
MOV RDI,qword ptr [RBP + -0x58]
ADD RDI,0x60
LAB_00109ee8:
LEA RSI,[RBP + -0x14]
CALL 0x0010b600
LAB_00109ef1:
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00109ef7
LAB_00109ef7:
MOV RDI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x28],RAX
ADD RDI,0x60
CALL 0x0010b660
MOV qword ptr [RBP + -0x40],RAX
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x40]
CALL 0x0010b630
XOR AL,0xff
TEST AL,0x1
JNZ 0x00109f25
JMP 0x00109f56
LAB_00109f25:
LEA RDI,[RBP + -0x28]
CALL 0x0010b690
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x44],0x1
JMP 0x00109f65
LAB_00109f56:
MOV qword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x44],0x1
LAB_00109f65:
LEA RDI,[RBP + -0x20]
CALL 0x0010b290
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x60
POP RBP
RET
|
/* Settings::getCount(int) const */
int8 __thiscall Settings::getCount(Settings *this,int param_1)
{
byte bVar1;
long lVar2;
int8 local_48 [3];
int8 local_30;
lock_guard<std::mutex> local_28 [12];
int local_1c;
Settings *local_18;
int8 local_10;
local_1c = param_1;
local_18 = this;
std::lock_guard<std::mutex>::lock_guard(local_28,(mutex *)this);
/* try { // try from 00109ee8 to 00109ef0 has its CatchHandler @ 00109f3f */
local_30 = std::
map<int,unsigned_long,std::less<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::find((map<int,unsigned_long,std::less<int>,std::allocator<std::pair<int_const,unsigned_long>>>
*)(this + 0x60),&local_1c);
local_48[0] = std::
map<int,unsigned_long,std::less<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::end((map<int,unsigned_long,std::less<int>,std::allocator<std::pair<int_const,unsigned_long>>>
*)(this + 0x60));
bVar1 = std::operator==((_Rb_tree_const_iterator *)&local_30,(_Rb_tree_const_iterator *)local_48);
if (((bVar1 ^ 0xff) & 1) == 0) {
local_10 = 0;
}
else {
lVar2 = std::_Rb_tree_const_iterator<std::pair<int_const,unsigned_long>>::operator->
((_Rb_tree_const_iterator<std::pair<int_const,unsigned_long>> *)&local_30);
local_10 = *(int8 *)(lVar2 + 8);
}
std::lock_guard<std::mutex>::~lock_guard(local_28);
return local_10;
}
| |
38,126 | Settings::getCount(int) const | 666mxvbee[P]BattleShip/lib/Settings/Settings.cpp | uint64_t Settings::getCount(int typeShip) const {
std::lock_guard<std::mutex> lock(settings_mutex);
auto it = shipCounts.find(typeShip);
if (it != shipCounts.end()) {
return it->second;
}
return 0;
} | O2 | cpp | Settings::getCount(int) const:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl %esi, (%r14)
callq 0x6d3c
leaq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x12d7e
leaq 0x68(%rbx), %rcx
cmpq %rcx, %rax
je 0x623f
movq 0x28(%rax), %r14
jmp 0x6242
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x52e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x52e0
movq %r14, %rdi
callq 0x55b0
| _ZNK8Settings8getCountEi:
push r14
push rbx
push rax
mov rbx, rdi
lea r14, [rsp+18h+var_14]
mov [r14], esi
call _ZNSt5mutex4lockEv; std::mutex::lock(void)
lea rdi, [rbx+60h]
mov rsi, r14
call _ZNKSt8_Rb_treeIiSt4pairIKimESt10_Select1stIS2_ESt4lessIiESaIS2_EE4findERS1_; std::_Rb_tree<int,std::pair<int const,ulong>,std::_Select1st<std::pair<int const,ulong>>,std::less<int>,std::allocator<std::pair<int const,ulong>>>::find(int const&)
lea rcx, [rbx+68h]
cmp rax, rcx
jz short loc_623F
mov r14, [rax+28h]
jmp short loc_6242
loc_623F:
xor r14d, r14d
loc_6242:
mov rdi, rbx
call _pthread_mutex_unlock
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
mov r14, rax
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, r14
call __Unwind_Resume
| long long Settings::getCount(Settings *this, int a2)
{
_QWORD *v2; // rax
long long v3; // r14
_DWORD v5[5]; // [rsp+0h] [rbp-14h] BYREF
v5[0] = a2;
std::mutex::lock(this);
v2 = (_QWORD *)std::_Rb_tree<int,std::pair<int const,unsigned long>,std::_Select1st<std::pair<int const,unsigned long>>,std::less<int>,std::allocator<std::pair<int const,unsigned long>>>::find(
(char *)this + 96,
v5);
if ( v2 == (_QWORD *)((char *)this + 104) )
v3 = 0LL;
else
v3 = v2[5];
pthread_mutex_unlock(this);
return v3;
}
| getCount:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA R14,[RSP + 0x4]
MOV dword ptr [R14],ESI
CALL 0x00106d3c
LEA RDI,[RBX + 0x60]
LAB_00106228:
MOV RSI,R14
CALL 0x00112d7e
LAB_00106230:
LEA RCX,[RBX + 0x68]
CMP RAX,RCX
JZ 0x0010623f
MOV R14,qword ptr [RAX + 0x28]
JMP 0x00106242
LAB_0010623f:
XOR R14D,R14D
LAB_00106242:
MOV RDI,RBX
CALL 0x001052e0
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* Settings::getCount(int) const */
int8 Settings::getCount(int param_1)
{
long lVar1;
int4 in_register_0000003c;
pthread_mutex_t *__mutex;
int8 uVar2;
int local_14;
__mutex = (pthread_mutex_t *)CONCAT44(in_register_0000003c,param_1);
std::mutex::lock();
/* try { // try from 00106228 to 0010622f has its CatchHandler @ 00106255 */
lVar1 = std::
_Rb_tree<int,std::pair<int_const,unsigned_long>,std::_Select1st<std::pair<int_const,unsigned_long>>,std::less<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::find((_Rb_tree<int,std::pair<int_const,unsigned_long>,std::_Select1st<std::pair<int_const,unsigned_long>>,std::less<int>,std::allocator<std::pair<int_const,unsigned_long>>>
*)((long)__mutex + 0x60),&local_14);
if (lVar1 == (long)__mutex + 0x68) {
uVar2 = 0;
}
else {
uVar2 = *(int8 *)(lVar1 + 0x28);
}
pthread_mutex_unlock(__mutex);
return uVar2;
}
| |
38,127 | Settings::getCount(int) const | 666mxvbee[P]BattleShip/lib/Settings/Settings.cpp | uint64_t Settings::getCount(int typeShip) const {
std::lock_guard<std::mutex> lock(settings_mutex);
auto it = shipCounts.find(typeShip);
if (it != shipCounts.end()) {
return it->second;
}
return 0;
} | O3 | cpp | Settings::getCount(int) const:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x5520
testl %eax, %eax
jne 0x67fc
movq 0x70(%rbx), %rcx
testq %rcx, %rcx
je 0x67e3
leaq 0x68(%rbx), %rdx
movq %rdx, %rax
xorl %esi, %esi
cmpl %ebp, 0x20(%rcx)
setl %sil
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x67c2
cmpq %rdx, %rax
je 0x67e3
cmpl %ebp, 0x20(%rax)
jle 0x67f6
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x52f0
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x28(%rax), %r14
jmp 0x67e6
movl %eax, %edi
callq 0x5260
nop
| _ZNK8Settings8getCountEi:
push rbp
push r14
push rbx
mov ebp, esi
mov rbx, rdi
call _pthread_mutex_lock
test eax, eax
jnz short loc_67FC
mov rcx, [rbx+70h]
test rcx, rcx
jz short loc_67E3
lea rdx, [rbx+68h]
mov rax, rdx
loc_67C2:
xor esi, esi
cmp [rcx+20h], ebp
setl sil
cmovge rax, rcx
mov rcx, [rcx+rsi*8+10h]
test rcx, rcx
jnz short loc_67C2
cmp rax, rdx
jz short loc_67E3
cmp [rax+20h], ebp
jle short loc_67F6
loc_67E3:
xor r14d, r14d
loc_67E6:
mov rdi, rbx
call _pthread_mutex_unlock
mov rax, r14
pop rbx
pop r14
pop rbp
retn
loc_67F6:
mov r14, [rax+28h]
jmp short loc_67E6
loc_67FC:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
| long long Settings::getCount(Settings *this, int a2)
{
int v2; // eax
char *v3; // rcx
char *v4; // rax
long long v5; // r14
v2 = pthread_mutex_lock(this);
if ( v2 )
std::__throw_system_error(v2);
v3 = (char *)*((_QWORD *)this + 14);
if ( !v3 )
goto LABEL_9;
v4 = (char *)this + 104;
do
{
if ( *((_DWORD *)v3 + 8) >= a2 )
v4 = v3;
v3 = *(char **)&v3[8 * (*((_DWORD *)v3 + 8) < a2) + 16];
}
while ( v3 );
if ( v4 != (char *)this + 104 && *((_DWORD *)v4 + 8) <= a2 )
v5 = *((_QWORD *)v4 + 5);
else
LABEL_9:
v5 = 0LL;
pthread_mutex_unlock(this);
return v5;
}
| getCount:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBP,ESI
MOV RBX,RDI
CALL 0x00105520
TEST EAX,EAX
JNZ 0x001067fc
MOV RCX,qword ptr [RBX + 0x70]
TEST RCX,RCX
JZ 0x001067e3
LEA RDX,[RBX + 0x68]
MOV RAX,RDX
LAB_001067c2:
XOR ESI,ESI
CMP dword ptr [RCX + 0x20],EBP
SETL SIL
CMOVGE RAX,RCX
MOV RCX,qword ptr [RCX + RSI*0x8 + 0x10]
TEST RCX,RCX
JNZ 0x001067c2
CMP RAX,RDX
JZ 0x001067e3
CMP dword ptr [RAX + 0x20],EBP
JLE 0x001067f6
LAB_001067e3:
XOR R14D,R14D
LAB_001067e6:
MOV RDI,RBX
CALL 0x001052f0
MOV RAX,R14
POP RBX
POP R14
POP RBP
RET
LAB_001067f6:
MOV R14,qword ptr [RAX + 0x28]
JMP 0x001067e6
LAB_001067fc:
MOV EDI,EAX
CALL 0x00105260
|
/* Settings::getCount(int) const */
int8 __thiscall Settings::getCount(Settings *this,int param_1)
{
int iVar1;
Settings *pSVar2;
Settings *pSVar3;
int8 uVar4;
iVar1 = pthread_mutex_lock((pthread_mutex_t *)this);
if (iVar1 != 0) {
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar1);
}
pSVar3 = *(Settings **)(this + 0x70);
if (pSVar3 != (Settings *)0x0) {
pSVar2 = this + 0x68;
do {
if (param_1 <= *(int *)(pSVar3 + 0x20)) {
pSVar2 = pSVar3;
}
pSVar3 = *(Settings **)(pSVar3 + (ulong)(*(int *)(pSVar3 + 0x20) < param_1) * 8 + 0x10);
} while (pSVar3 != (Settings *)0x0);
if ((pSVar2 != this + 0x68) && (*(int *)(pSVar2 + 0x20) <= param_1)) {
uVar4 = *(int8 *)(pSVar2 + 0x28);
goto LAB_001067e6;
}
}
uVar4 = 0;
LAB_001067e6:
pthread_mutex_unlock((pthread_mutex_t *)this);
return uVar4;
}
| |
38,128 | js_callsite_getfield | bluesky950520[P]quickjs/quickjs.c | static JSValue js_callsite_getfield(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic)
{
JSCallSiteData *csd = JS_GetOpaque2(ctx, this_val, JS_CLASS_CALL_SITE);
if (!csd)
return JS_EXCEPTION;
JSValue *field = (void *)((char *)csd + magic);
return js_dup(*field);
} | O1 | c | js_callsite_getfield:
pushq %rbx
subq $0x10, %rsp
movl %r9d, %ebx
movl $0x3c, %ecx
callq 0x275b5
testq %rax, %rax
je 0x848f4
movq %rax, %rcx
movslq %ebx, %rdx
movq (%rax,%rdx), %rax
movq 0x8(%rcx,%rdx), %rdx
movq %rax, 0x8(%rsp)
cmpl $-0x9, %edx
jb 0x848fb
movq 0x8(%rsp), %rcx
incl (%rcx)
jmp 0x848fb
movl $0x6, %edx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
| js_callsite_getfield:
push rbx
sub rsp, 10h
mov ebx, r9d
mov ecx, 3Ch ; '<'
call JS_GetOpaque2
test rax, rax
jz short loc_848F4
mov rcx, rax
movsxd rdx, ebx
mov rax, [rax+rdx]
mov rdx, [rcx+rdx+8]
mov [rsp+18h+var_10], rax
cmp edx, 0FFFFFFF7h
jb short loc_848FB
mov rcx, [rsp+18h+var_10]
inc dword ptr [rcx]
jmp short loc_848FB
loc_848F4:
mov edx, 6
xor eax, eax
loc_848FB:
add rsp, 10h
pop rbx
retn
| _DWORD * js_callsite_getfield(long long a1, long long a2, int a3, long long a4, long long a5, int a6)
{
long long Opaque2; // rax
long long v8; // rcx
_DWORD *result; // rax
Opaque2 = JS_GetOpaque2(a1, a2, a3, 0x3Cu);
if ( !Opaque2 )
return 0LL;
v8 = Opaque2;
result = *(_DWORD **)(Opaque2 + a6);
if ( (unsigned int)*(_QWORD *)(v8 + a6 + 8) >= 0xFFFFFFF7 )
++*result;
return result;
}
| |||
38,129 | js_callsite_getfield | bluesky950520[P]quickjs/quickjs.c | static JSValue js_callsite_getfield(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic)
{
JSCallSiteData *csd = JS_GetOpaque2(ctx, this_val, JS_CLASS_CALL_SITE);
if (!csd)
return JS_EXCEPTION;
JSValue *field = (void *)((char *)csd + magic);
return js_dup(*field);
} | O2 | c | js_callsite_getfield:
pushq %rbx
movl %r9d, %ebx
pushq $0x3c
popq %rcx
callq 0x21207
testq %rax, %rax
je 0x6f3ec
movq %rax, %rcx
movslq %ebx, %rdx
movq (%rax,%rdx), %rax
movq 0x8(%rcx,%rdx), %rdx
cmpl $-0x9, %edx
jb 0x6f3f1
incl (%rax)
jmp 0x6f3f1
pushq $0x6
popq %rdx
xorl %eax, %eax
popq %rbx
retq
| js_callsite_getfield:
push rbx
mov ebx, r9d
push 3Ch ; '<'
pop rcx
call JS_GetOpaque2
test rax, rax
jz short loc_6F3EC
mov rcx, rax
movsxd rdx, ebx
mov rax, [rax+rdx]
mov rdx, [rcx+rdx+8]
cmp edx, 0FFFFFFF7h
jb short loc_6F3F1
inc dword ptr [rax]
jmp short loc_6F3F1
loc_6F3EC:
push 6
pop rdx
xor eax, eax
loc_6F3F1:
pop rbx
retn
| _DWORD * js_callsite_getfield(long long a1, long long a2, int a3, long long a4, long long a5, int a6)
{
long long Opaque2; // rax
long long v8; // rcx
_DWORD *result; // rax
Opaque2 = JS_GetOpaque2(a1, a2, a3, 0x3Cu);
if ( !Opaque2 )
return 0LL;
v8 = Opaque2;
result = *(_DWORD **)(Opaque2 + a6);
if ( (unsigned int)*(_QWORD *)(v8 + a6 + 8) >= 0xFFFFFFF7 )
++*result;
return result;
}
| js_callsite_getfield:
PUSH RBX
MOV EBX,R9D
PUSH 0x3c
POP RCX
CALL 0x00121207
TEST RAX,RAX
JZ 0x0016f3ec
MOV RCX,RAX
MOVSXD RDX,EBX
MOV RAX,qword ptr [RAX + RDX*0x1]
MOV RDX,qword ptr [RCX + RDX*0x1 + 0x8]
CMP EDX,-0x9
JC 0x0016f3f1
INC dword ptr [RAX]
JMP 0x0016f3f1
LAB_0016f3ec:
PUSH 0x6
POP RDX
XOR EAX,EAX
LAB_0016f3f1:
POP RBX
RET
|
int1 [16] js_callsite_getfield(void)
{
long lVar1;
int *piVar2;
int8 uVar3;
int in_R9D;
int1 auVar4 [16];
lVar1 = JS_GetOpaque2();
if (lVar1 == 0) {
uVar3 = 6;
piVar2 = (int *)0x0;
}
else {
piVar2 = *(int **)(lVar1 + in_R9D);
uVar3 = *(int8 *)(lVar1 + 8 + (long)in_R9D);
if (0xfffffff6 < (uint)uVar3) {
*piVar2 = *piVar2 + 1;
}
}
auVar4._8_8_ = uVar3;
auVar4._0_8_ = piVar2;
return auVar4;
}
| |
38,130 | my_getwd | eloqsql/mysys/my_getwd.c | int my_getwd(char * buf, size_t size, myf MyFlags)
{
char * pos;
DBUG_ENTER("my_getwd");
DBUG_PRINT("my",("buf:%p size: %u MyFlags %lu",
buf, (uint) size, MyFlags));
if (size < 1)
DBUG_RETURN(-1);
if (curr_dir[0]) /* Current pos is saved here */
(void) strmake(buf,&curr_dir[0],size-1);
else
{
#if defined(HAVE_GETCWD)
if (size < 2)
DBUG_RETURN(-1);
if (!getcwd(buf,(uint) (size-2)) && MyFlags & MY_WME)
{
my_errno=errno;
my_error(EE_GETWD,MYF(ME_BELL),errno);
DBUG_RETURN(-1);
}
#elif defined(HAVE_GETWD)
{
char pathname[MAXPATHLEN];
getwd(pathname);
strmake(buf,pathname,size-1);
}
#else
#error "No way to get current directory"
#endif
if (*((pos=strend(buf))-1) != FN_LIBCHAR) /* End with FN_LIBCHAR */
{
pos[0]= FN_LIBCHAR;
pos[1]=0;
}
(void) strmake(&curr_dir[0],buf, (size_t) (FN_REFLEN-1));
}
DBUG_RETURN(0);
} | O3 | c | my_getwd:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x4ff39
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x319d98(%rip), %rax # 0x369c70
cmpb $0x0, (%rax)
je 0x4fef3
decq %rdx
leaq 0x319d89(%rip), %rsi # 0x369c70
movq %r14, %rdi
callq 0x4a204
xorl %ebx, %ebx
jmp 0x4ff39
cmpq $0x1, %rdx
je 0x4ff39
addl $-0x2, %edx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x25160
testb $0x10, %r15b
je 0x4ff46
testq %rax, %rax
jne 0x4ff46
callq 0x25060
movq %rax, %r14
movl (%rax), %r15d
callq 0x4b596
movl %r15d, (%rax)
movl (%r14), %edx
movl $0x4, %esi
movl $0x10, %edi
xorl %eax, %eax
callq 0x4c22b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x5db98
cmpb $0x2f, -0x1(%rax)
je 0x4ff59
movw $0x2f, (%rax)
leaq 0x319d10(%rip), %rdi # 0x369c70
movl $0x1ff, %edx # imm = 0x1FF
movq %r14, %rsi
jmp 0x4feea
| my_getwd:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov ebx, 0FFFFFFFFh
test rsi, rsi
jz short loc_4FF39
mov r15, rdx
mov rdx, rsi
mov r14, rdi
lea rax, curr_dir
cmp byte ptr [rax], 0
jz short loc_4FEF3
dec rdx
lea rsi, curr_dir
mov rdi, r14
loc_4FEEA:
call strmake
xor ebx, ebx
jmp short loc_4FF39
loc_4FEF3:
cmp rdx, 1
jz short loc_4FF39
add edx, 0FFFFFFFEh
mov rdi, r14
mov rsi, rdx
call _getcwd
test r15b, 10h
jz short loc_4FF46
test rax, rax
jnz short loc_4FF46
call ___errno_location
mov r14, rax
mov r15d, [rax]
call _my_thread_var
mov [rax], r15d
mov edx, [r14]
mov esi, 4
mov edi, 10h
xor eax, eax
call my_error
loc_4FF39:
mov eax, ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_4FF46:
mov rdi, r14
call strend
cmp byte ptr [rax-1], 2Fh ; '/'
jz short loc_4FF59
mov word ptr [rax], 2Fh ; '/'
loc_4FF59:
lea rdi, curr_dir
mov edx, 1FFh
mov rsi, r14
jmp short loc_4FEEA
| long long my_getwd(_BYTE *a1, long long a2, char a3)
{
unsigned int v3; // ebx
_BYTE *v5; // r14
long long v6; // rdx
_BYTE *v7; // rsi
long long v8; // rax
unsigned int *v9; // r14
unsigned int v10; // r15d
_WORD *v12; // rax
v3 = -1;
if ( a2 )
{
v5 = a1;
if ( curr_dir[0] )
{
v6 = a2 - 1;
v7 = curr_dir;
}
else
{
if ( a2 == 1 )
return v3;
v8 = getcwd(a1, (unsigned int)(a2 - 2));
if ( (a3 & 0x10) != 0 && !v8 )
{
v9 = (unsigned int *)__errno_location(a1);
v10 = *v9;
*(_DWORD *)my_thread_var() = v10;
my_error(0x10u, 4LL, *v9);
return v3;
}
v12 = (_WORD *)strend(a1);
if ( *((_BYTE *)v12 - 1) != 47 )
*v12 = 47;
a1 = curr_dir;
v6 = 511LL;
v7 = v5;
}
strmake((long long)a1, (long long)v7, v6);
return 0;
}
return v3;
}
| my_getwd:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,0xffffffff
TEST RSI,RSI
JZ 0x0014ff39
MOV R15,RDX
MOV RDX,RSI
MOV R14,RDI
LEA RAX,[0x469c70]
CMP byte ptr [RAX],0x0
JZ 0x0014fef3
DEC RDX
LEA RSI,[0x469c70]
MOV RDI,R14
LAB_0014feea:
CALL 0x0014a204
XOR EBX,EBX
JMP 0x0014ff39
LAB_0014fef3:
CMP RDX,0x1
JZ 0x0014ff39
ADD EDX,-0x2
MOV RDI,R14
MOV RSI,RDX
CALL 0x00125160
TEST R15B,0x10
JZ 0x0014ff46
TEST RAX,RAX
JNZ 0x0014ff46
CALL 0x00125060
MOV R14,RAX
MOV R15D,dword ptr [RAX]
CALL 0x0014b596
MOV dword ptr [RAX],R15D
MOV EDX,dword ptr [R14]
MOV ESI,0x4
MOV EDI,0x10
XOR EAX,EAX
CALL 0x0014c22b
LAB_0014ff39:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0014ff46:
MOV RDI,R14
CALL 0x0015db98
CMP byte ptr [RAX + -0x1],0x2f
JZ 0x0014ff59
MOV word ptr [RAX],0x2f
LAB_0014ff59:
LEA RDI,[0x469c70]
MOV EDX,0x1ff
MOV RSI,R14
JMP 0x0014feea
|
int8 my_getwd(char *param_1,long param_2,ulong param_3)
{
int iVar1;
char *pcVar2;
int *piVar3;
int *piVar4;
int2 *puVar5;
char *pcVar6;
if (param_2 == 0) {
return 0xffffffff;
}
if (curr_dir == '\0') {
if (param_2 == 1) {
return 0xffffffff;
}
pcVar2 = getcwd(param_1,(ulong)((int)param_2 - 2));
if (((param_3 & 0x10) != 0) && (pcVar2 == (char *)0x0)) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
my_error(0x10,4,*piVar3);
return 0xffffffff;
}
puVar5 = (int2 *)strend(param_1);
if (*(char *)((long)puVar5 + -1) != '/') {
*puVar5 = 0x2f;
}
pcVar6 = &curr_dir;
param_2 = 0x1ff;
pcVar2 = param_1;
}
else {
param_2 = param_2 + -1;
pcVar2 = &curr_dir;
pcVar6 = param_1;
}
strmake(pcVar6,pcVar2,param_2);
return 0;
}
| |
38,131 | free_node | 7CodeWizard[P]stablediffusion/ggml/src/ggml-alloc.c | static void free_node(ggml_gallocr_t galloc, struct ggml_tensor * node) {
ggml_tallocr_t alloc = node_tallocr(galloc, node);
ggml_tallocr_free_tensor(alloc, node);
} | O1 | c | free_node:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r14
testq %r14, %r14
jne 0xb3be3
movq 0x28(%rdi), %r14
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x96070
movq (%r14,%rax,8), %r14
movq (%r14), %rdi
cmpq %rdi, 0x8(%rbx)
je 0xb3bf6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x108(%rbx), %rax
testq %rax, %rax
je 0xb3c08
cmpq %rdi, 0x8(%rax)
jne 0xb3bec
movq 0x118(%rbx), %r15
movq %rbx, %rsi
callq 0xb3e89
movq %rax, %rcx
movq 0x18(%r14), %rsi
xorl %edx, %edx
divq %rsi
movq %rsi, %rax
subq %rdx, %rax
xorl %edx, %edx
divq %rsi
addq %rcx, %rdx
movslq 0x20(%r14), %rax
movl %eax, %esi
testq %rax, %rax
jle 0xb3c7e
leaq 0x28(%r14), %r9
leaq (%r15,%rdx), %r11
leaq 0x48(%r14), %rcx
leal -0x1(%rsi), %r8d
movq %rsi, %rbx
negq %rbx
xorl %edi, %edi
movq -0x20(%rcx), %r12
movq -0x18(%rcx), %r10
leaq (%r12,%r10), %r13
cmpq %r15, %r13
je 0xb3cee
cmpq %r12, %r11
je 0xb3d48
addq $0x10, %rcx
decq %rdi
cmpq %rdi, %rbx
jne 0xb3c54
cmpl $0xff, %esi
jg 0xb3db6
leaq 0x28(%r14), %rcx
xorl %edi, %edi
testl %esi, %esi
jle 0xb3caa
movq %rcx, %r8
cmpq %r15, (%r8)
jae 0xb3caa
incq %rdi
addq $0x10, %r8
cmpq %rdi, %rsi
jne 0xb3c97
movl %esi, %edi
cmpl %edi, %eax
jle 0xb3cd6
movslq %edi, %rsi
movq %rax, %r8
shlq $0x4, %r8
addq %r14, %r8
addq $0x28, %r8
decq %rax
vmovups -0x10(%r8), %xmm0
vmovups %xmm0, (%r8)
addq $-0x10, %r8
cmpq %rsi, %rax
jg 0xb3cbf
movl %edi, %eax
shlq $0x4, %rax
movq %r15, (%rcx,%rax)
movq %rdx, 0x8(%rcx,%rax)
incl 0x20(%r14)
jmp 0xb3bec
movl %edi, %esi
negl %esi
addq %rdx, %r10
movq %r10, -0x18(%rcx)
decl %eax
cmpl %esi, %eax
jle 0xb3bec
addq %r10, %r12
cmpq -0x10(%rcx), %r12
jne 0xb3bec
movl $0x1, %edx
addq -0x8(%rcx), %r10
subq %rdi, %rdx
movq %r10, -0x18(%rcx)
movl %eax, 0x20(%r14)
cmpl %eax, %edx
jge 0xb3bec
movl %eax, %eax
vmovups (%rcx), %xmm0
vmovups %xmm0, -0x10(%rcx)
decq %rax
addq $0x10, %rcx
cmpq %rax, %rdx
jne 0xb3d2e
jmp 0xb3bec
movq %r15, -0x20(%rcx)
addq %rdx, %r10
movq %r10, -0x18(%rcx)
testq %rdi, %rdi
je 0xb3bec
movl %edi, %eax
notl %eax
shlq $0x4, %rax
movq 0x8(%r9,%rax), %rdx
movq (%r9,%rax), %r11
addq %rdx, %r11
cmpq %r15, %r11
jne 0xb3bec
movq %rdi, %r11
negq %r11
addq %rax, %r9
addq %r10, %rdx
movq %rdx, 0x8(%r9)
decl %esi
movl %esi, 0x20(%r14)
cmpl %r11d, %esi
jle 0xb3bec
addq $-0x10, %rcx
addq %rdi, %r8
vmovups (%rcx), %xmm0
vmovups %xmm0, -0x10(%rcx)
addq $0x10, %rcx
decq %r8
jne 0xb3d9f
jmp 0xb3bec
callq 0x18074
nop
| free_node:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rsi
mov r14, [rdi]
test r14, r14
jnz short loc_B3BE3
mov r14, [rdi+28h]
mov rax, [rdi+8]
mov rsi, [rdi+10h]
mov rdi, rax
mov rdx, rbx
call ggml_hash_find_or_insert
mov r14, [r14+rax*8]
loc_B3BE3:
mov rdi, [r14]
cmp [rbx+8], rdi
jz short loc_B3BF6
loc_B3BEC:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_B3BF6:
mov rax, [rbx+108h]
test rax, rax
jz short loc_B3C08
cmp [rax+8], rdi
jnz short loc_B3BEC
loc_B3C08:
mov r15, [rbx+118h]
mov rsi, rbx
call ggml_backend_buffer_get_alloc_size
mov rcx, rax
mov rsi, [r14+18h]
xor edx, edx
div rsi
mov rax, rsi
sub rax, rdx
xor edx, edx
div rsi
add rdx, rcx
movsxd rax, dword ptr [r14+20h]
mov esi, eax
test rax, rax
jle short loc_B3C7E
lea r9, [r14+28h]
lea r11, [r15+rdx]
lea rcx, [r14+48h]
lea r8d, [rsi-1]
mov rbx, rsi
neg rbx
xor edi, edi
loc_B3C54:
mov r12, [rcx-20h]
mov r10, [rcx-18h]
lea r13, [r12+r10]
cmp r13, r15
jz loc_B3CEE
cmp r11, r12
jz loc_B3D48
add rcx, 10h
dec rdi
cmp rbx, rdi
jnz short loc_B3C54
loc_B3C7E:
cmp esi, 0FFh
jg loc_B3DB6
lea rcx, [r14+28h]
xor edi, edi
test esi, esi
jle short loc_B3CAA
mov r8, rcx
loc_B3C97:
cmp [r8], r15
jnb short loc_B3CAA
inc rdi
add r8, 10h
cmp rsi, rdi
jnz short loc_B3C97
mov edi, esi
loc_B3CAA:
cmp eax, edi
jle short loc_B3CD6
movsxd rsi, edi
mov r8, rax
shl r8, 4
add r8, r14
add r8, 28h ; '('
loc_B3CBF:
dec rax
vmovups xmm0, xmmword ptr [r8-10h]
vmovups xmmword ptr [r8], xmm0
add r8, 0FFFFFFFFFFFFFFF0h
cmp rax, rsi
jg short loc_B3CBF
loc_B3CD6:
mov eax, edi
shl rax, 4
mov [rcx+rax], r15
mov [rcx+rax+8], rdx
inc dword ptr [r14+20h]
jmp loc_B3BEC
loc_B3CEE:
mov esi, edi
neg esi
add r10, rdx
mov [rcx-18h], r10
dec eax
cmp eax, esi
jle loc_B3BEC
add r12, r10
cmp r12, [rcx-10h]
jnz loc_B3BEC
mov edx, 1
add r10, [rcx-8]
sub rdx, rdi
mov [rcx-18h], r10
mov [r14+20h], eax
cmp edx, eax
jge loc_B3BEC
mov eax, eax
loc_B3D2E:
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [rcx-10h], xmm0
dec rax
add rcx, 10h
cmp rdx, rax
jnz short loc_B3D2E
jmp loc_B3BEC
loc_B3D48:
mov [rcx-20h], r15
add r10, rdx
mov [rcx-18h], r10
test rdi, rdi
jz loc_B3BEC
mov eax, edi
not eax
shl rax, 4
mov rdx, [r9+rax+8]
mov r11, [r9+rax]
add r11, rdx
cmp r11, r15
jnz loc_B3BEC
mov r11, rdi
neg r11
add r9, rax
add rdx, r10
mov [r9+8], rdx
dec esi
mov [r14+20h], esi
cmp esi, r11d
jle loc_B3BEC
add rcx, 0FFFFFFFFFFFFFFF0h
add r8, rdi
loc_B3D9F:
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [rcx-10h], xmm0
add rcx, 10h
dec r8
jnz short loc_B3D9F
jmp loc_B3BEC
loc_B3DB6:
call free_node_cold_1
| void free_node(long long **a1, _QWORD *a2)
{
long long *v2; // r14
long long *v3; // r14
long long v4; // rdi
long long v5; // rax
unsigned long long v6; // r15
unsigned long long alloc_size; // rcx
unsigned long long v8; // rdx
long long v9; // rax
long long v10; // rsi
long long *v11; // r9
long long v13; // r8
long long v14; // r12
long long v15; // r10
long long *v16; // rcx
long long v17; // rdi
unsigned long long *v18; // r8
long long v21; // rax
long long v22; // r10
long long v24; // r10
long long v25; // rax
long long v26; // rdx
int v27; // esi
long long v29; // r8
v2 = *a1;
if ( !*a1 )
{
v3 = a1[5];
v2 = (long long *)v3[ggml_hash_find_or_insert((unsigned long long)a1[1], (long long)a1[2], (unsigned long long)a2)];
}
v4 = *v2;
if ( a2[1] == *v2 )
{
v5 = a2[33];
if ( !v5 || *(_QWORD *)(v5 + 8) == v4 )
{
v6 = a2[35];
alloc_size = ggml_backend_buffer_get_alloc_size(v4, a2);
v8 = alloc_size + (v2[3] - alloc_size % v2[3]) % v2[3];
v9 = *((int *)v2 + 8);
v10 = *((unsigned int *)v2 + 8);
if ( v9 <= 0 )
{
LABEL_12:
if ( (int)v10 > 255 )
free_node_cold_1(v4, v10, v8);
v16 = v2 + 5;
v17 = 0LL;
if ( (int)v10 > 0 )
{
v18 = (unsigned long long *)(v2 + 5);
while ( *v18 < v6 )
{
++v17;
v18 += 2;
if ( v10 == v17 )
{
LODWORD(v17) = *((_DWORD *)v2 + 8);
break;
}
}
}
if ( (int)v9 > (int)v17 )
{
_R8 = (long long)&v2[2 * v9 + 5];
do
{
--v9;
__asm
{
vmovups xmm0, xmmword ptr [r8-10h]
vmovups xmmword ptr [r8], xmm0
}
_R8 -= 16LL;
}
while ( v9 > (int)v17 );
}
v21 = 2LL * (unsigned int)v17;
v16[v21] = v6;
v16[v21 + 1] = v8;
++*((_DWORD *)v2 + 8);
}
else
{
v11 = v2 + 5;
_RCX = v2 + 9;
v13 = (unsigned int)(v10 - 1);
v4 = 0LL;
while ( 1 )
{
v14 = *(_RCX - 4);
v15 = *(_RCX - 3);
if ( v14 + v15 == v6 )
break;
if ( v6 + v8 == v14 )
{
*(_RCX - 4) = v6;
v24 = v8 + v15;
*(_RCX - 3) = v24;
if ( v4 )
{
v25 = 2LL * (unsigned int)~(_DWORD)v4;
v26 = v11[v25 + 1];
if ( v26 + v11[v25] == v6 )
{
v11[v25 + 1] = v24 + v26;
v27 = v10 - 1;
*((_DWORD *)v2 + 8) = v27;
if ( v27 > -(int)v4 )
{
_RCX = _RCX - 2;
v29 = v4 + v13;
do
{
__asm
{
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [rcx-10h], xmm0
}
_RCX += 2;
--v29;
}
while ( v29 );
}
}
}
return;
}
_RCX += 2;
if ( -v10 == --v4 )
goto LABEL_12;
}
v22 = v8 + v15;
*(_RCX - 3) = v22;
LODWORD(v9) = v9 - 1;
if ( (int)v9 > -(int)v4 && v22 + v14 == *(_RCX - 2) )
{
*(_RCX - 3) = *(_RCX - 1) + v22;
*((_DWORD *)v2 + 8) = v9;
if ( 1 - (int)v4 < (int)v9 )
{
v9 = (unsigned int)v9;
do
{
__asm
{
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [rcx-10h], xmm0
}
--v9;
_RCX += 2;
}
while ( 1 - v4 != v9 );
}
}
}
}
}
}
| |||
38,132 | free_node | 7CodeWizard[P]stablediffusion/ggml/src/ggml-alloc.c | static void free_node(ggml_gallocr_t galloc, struct ggml_tensor * node) {
ggml_tallocr_t alloc = node_tallocr(galloc, node);
ggml_tallocr_free_tensor(alloc, node);
} | O2 | c | free_node:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
callq 0x8fb36
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x8fb5d
testb %al, %al
je 0x8faec
movq 0x118(%r14), %r15
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x8fcc5
movq %rax, %rcx
movq 0x18(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
divq %rdi
movq %rdi, %rax
subq %rdx, %rax
xorl %edx, %edx
divq %rdi
addq %rcx, %rdx
movslq 0x20(%rbx), %rax
leaq 0x28(%rbx), %rdi
leaq (%r15,%rdx), %r10
testl %eax, %eax
movl $0x0, %r8d
cmovgl %eax, %r8d
leaq 0x48(%rbx), %rcx
cmpq %rsi, %r8
je 0x8f9e6
movq -0x20(%rcx), %r11
movq -0x18(%rcx), %r9
leaq (%r11,%r9), %r14
cmpq %r15, %r14
je 0x8fa11
cmpq %r11, %r10
je 0x8fa56
incq %rsi
addq $0x10, %rcx
jmp 0x8f9c2
cmpl $0xff, %eax
jg 0x8faf2
xorl %ecx, %ecx
movq %rdi, %rsi
cmpq %rcx, %r8
je 0x8fab4
cmpq %r15, (%rsi)
jae 0x8fab1
incq %rcx
addq $0x10, %rsi
jmp 0x8f9f6
addq %rdx, %r9
movq %r9, -0x18(%rcx)
decl %eax
cmpl %esi, %eax
jle 0x8faec
addq %r9, %r11
cmpq -0x10(%rcx), %r11
jne 0x8faec
incq %rsi
addq -0x8(%rcx), %r9
movq %r9, -0x18(%rcx)
movl %eax, 0x20(%rbx)
cmpl %esi, %eax
jle 0x8faec
vmovups (%rcx), %xmm0
vmovups %xmm0, -0x10(%rcx)
addq $0x10, %rcx
incl %esi
jmp 0x8fa3d
movq %r15, -0x20(%rcx)
addq %rdx, %r9
movq %r9, -0x18(%rcx)
testq %rsi, %rsi
je 0x8faec
leal -0x1(%rsi), %edx
shlq $0x4, %rdx
movq 0x8(%rdi,%rdx), %r8
movq (%rdi,%rdx), %r10
addq %r8, %r10
cmpq %r15, %r10
jne 0x8faec
addq $-0x10, %rcx
addq %rdx, %rdi
addq %r9, %r8
movq %r8, 0x8(%rdi)
decl %eax
movl %eax, 0x20(%rbx)
cmpl %eax, %esi
cmovgl %esi, %eax
cmpq %rax, %rsi
je 0x8faec
vmovups (%rcx), %xmm0
vmovups %xmm0, -0x10(%rcx)
addq $0x10, %rcx
decq %rax
jmp 0x8fa9a
movl %ecx, %r8d
movslq %r8d, %rcx
movq %rax, %rsi
shlq $0x4, %rsi
addq %rbx, %rsi
addq $0x28, %rsi
cmpq %rcx, %rax
jle 0x8fadc
decq %rax
vmovups -0x10(%rsi), %xmm0
vmovups %xmm0, (%rsi)
addq $-0x10, %rsi
jmp 0x8fac5
shlq $0x4, %rcx
movq %r15, (%rdi,%rcx)
movq %rdx, 0x8(%rdi,%rcx)
incl 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x4644f(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x464a0(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0xa70c(%rip), %rsi # 0x9a21e
leaq 0x14a41(%rip), %rdx # 0xa455a
leaq 0x14bd1(%rip), %r8 # 0xa46f1
movl $0xcf, %ecx
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
| free_node:
push r15
push r14
push rbx
mov r14, rsi
call node_tallocr
mov rbx, rax
mov rdi, rax
mov rsi, r14
call ggml_tallocr_is_own
test al, al
jz loc_8FAEC
mov r15, [r14+118h]
mov rdi, [rbx]
mov rsi, r14
call ggml_backend_buffer_get_alloc_size
mov rcx, rax
mov rdi, [rbx+18h]
xor esi, esi
xor edx, edx
div rdi
mov rax, rdi
sub rax, rdx
xor edx, edx
div rdi
add rdx, rcx
movsxd rax, dword ptr [rbx+20h]
lea rdi, [rbx+28h]
lea r10, [r15+rdx]
test eax, eax
mov r8d, 0
cmovg r8d, eax
lea rcx, [rbx+48h]
loc_8F9C2:
cmp r8, rsi
jz short loc_8F9E6
mov r11, [rcx-20h]
mov r9, [rcx-18h]
lea r14, [r11+r9]
cmp r14, r15
jz short loc_8FA11
cmp r10, r11
jz short loc_8FA56
inc rsi
add rcx, 10h
jmp short loc_8F9C2
loc_8F9E6:
cmp eax, 0FFh
jg loc_8FAF2
xor ecx, ecx
mov rsi, rdi
loc_8F9F6:
cmp r8, rcx
jz loc_8FAB4
cmp [rsi], r15
jnb loc_8FAB1
inc rcx
add rsi, 10h
jmp short loc_8F9F6
loc_8FA11:
add r9, rdx
mov [rcx-18h], r9
dec eax
cmp eax, esi
jle loc_8FAEC
add r11, r9
cmp r11, [rcx-10h]
jnz loc_8FAEC
inc rsi
add r9, [rcx-8]
mov [rcx-18h], r9
mov [rbx+20h], eax
loc_8FA3D:
cmp eax, esi
jle loc_8FAEC
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [rcx-10h], xmm0
add rcx, 10h
inc esi
jmp short loc_8FA3D
loc_8FA56:
mov [rcx-20h], r15
add r9, rdx
mov [rcx-18h], r9
test rsi, rsi
jz loc_8FAEC
lea edx, [rsi-1]
shl rdx, 4
mov r8, [rdi+rdx+8]
mov r10, [rdi+rdx]
add r10, r8
cmp r10, r15
jnz short loc_8FAEC
add rcx, 0FFFFFFFFFFFFFFF0h
add rdi, rdx
add r8, r9
mov [rdi+8], r8
dec eax
mov [rbx+20h], eax
cmp esi, eax
cmovg eax, esi
loc_8FA9A:
cmp rsi, rax
jz short loc_8FAEC
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [rcx-10h], xmm0
add rcx, 10h
dec rax
jmp short loc_8FA9A
loc_8FAB1:
mov r8d, ecx
loc_8FAB4:
movsxd rcx, r8d
mov rsi, rax
shl rsi, 4
add rsi, rbx
add rsi, 28h ; '('
loc_8FAC5:
cmp rax, rcx
jle short loc_8FADC
dec rax
vmovups xmm0, xmmword ptr [rsi-10h]
vmovups xmmword ptr [rsi], xmm0
add rsi, 0FFFFFFFFFFFFFFF0h
jmp short loc_8FAC5
loc_8FADC:
shl rcx, 4
mov [rdi+rcx], r15
mov [rdi+rcx+8], rdx
inc dword ptr [rbx+20h]
loc_8FAEC:
pop rbx
pop r14
pop r15
retn
loc_8FAF2:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_8; "/workspace/llm4binary/github/2025_star3"...
lea r8, aAllocNFreeBloc; "alloc->n_free_blocks < MAX_FREE_BLOCKS "...
mov ecx, 0CFh
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
| long long free_node(long long a1, long long a2)
{
long long v2; // rbx
long long result; // rax
unsigned long long v4; // r15
unsigned long long alloc_size; // rax
long long v6; // rsi
unsigned long long v7; // rdx
long long v8; // rdi
long long v9; // r8
long long v11; // r11
long long v12; // r9
long long v13; // rcx
unsigned long long *v14; // rsi
long long v15; // r9
int v16; // esi
long long v18; // r9
long long v19; // rdx
long long v20; // r8
long long v25; // rcx
long long v26; // rdi
v2 = node_tallocr(a1);
result = ggml_tallocr_is_own(v2, a2);
if ( (_BYTE)result )
{
v4 = *(_QWORD *)(a2 + 280);
alloc_size = ggml_backend_buffer_get_alloc_size(*(_QWORD *)v2, a2);
v6 = 0LL;
v7 = alloc_size + (*(_QWORD *)(v2 + 24) - alloc_size % *(_QWORD *)(v2 + 24)) % *(_QWORD *)(v2 + 24);
result = *(int *)(v2 + 32);
v8 = v2 + 40;
v9 = 0LL;
if ( (int)result > 0 )
v9 = (unsigned int)result;
_RCX = v2 + 72;
while ( v9 != v6 )
{
v11 = *(_QWORD *)(_RCX - 32);
v12 = *(_QWORD *)(_RCX - 24);
if ( v11 + v12 == v4 )
{
v15 = v7 + v12;
*(_QWORD *)(_RCX - 24) = v15;
result = (unsigned int)(result - 1);
if ( (int)result > (int)v6 && v15 + v11 == *(_QWORD *)(_RCX - 16) )
{
v16 = v6 + 1;
*(_QWORD *)(_RCX - 24) = *(_QWORD *)(_RCX - 8) + v15;
*(_DWORD *)(v2 + 32) = result;
while ( (int)result > v16 )
{
__asm
{
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [rcx-10h], xmm0
}
_RCX += 16LL;
++v16;
}
}
return result;
}
if ( v4 + v7 == v11 )
{
*(_QWORD *)(_RCX - 32) = v4;
v18 = v7 + v12;
*(_QWORD *)(_RCX - 24) = v18;
if ( v6 )
{
v19 = 16LL * (unsigned int)(v6 - 1);
v20 = *(_QWORD *)(v8 + v19 + 8);
if ( v20 + *(_QWORD *)(v8 + v19) == v4 )
{
_RCX = _RCX - 16;
*(_QWORD *)(v19 + v8 + 8) = v18 + v20;
result = (unsigned int)(result - 1);
*(_DWORD *)(v2 + 32) = result;
if ( (int)v6 > (int)result )
result = (unsigned int)v6;
while ( v6 != result )
{
__asm
{
vmovups xmm0, xmmword ptr [rcx]
vmovups xmmword ptr [rcx-10h], xmm0
}
_RCX += 16LL;
--result;
}
}
}
return result;
}
++v6;
_RCX += 16LL;
}
if ( (int)result > 255 )
{
fflush(stdout);
v26 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml-alloc.c",
207,
"alloc->n_free_blocks < MAX_FREE_BLOCKS && \"out of free blocks\"");
ggml_print_backtrace();
abort(v26);
}
v13 = 0LL;
v14 = (unsigned long long *)(v2 + 40);
while ( v9 != v13 )
{
if ( *v14 >= v4 )
{
LODWORD(v9) = v13;
break;
}
++v13;
v14 += 2;
}
_RSI = v2 + 16 * result + 40;
while ( result > (int)v9 )
{
--result;
__asm
{
vmovups xmm0, xmmword ptr [rsi-10h]
vmovups xmmword ptr [rsi], xmm0
}
_RSI -= 16LL;
}
v25 = 16LL * (int)v9;
*(_QWORD *)(v8 + v25) = v4;
*(_QWORD *)(v8 + v25 + 8) = v7;
++*(_DWORD *)(v2 + 32);
}
return result;
}
| free_node:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
CALL 0x0018fb36
MOV RBX,RAX
MOV RDI,RAX
MOV RSI,R14
CALL 0x0018fb5d
TEST AL,AL
JZ 0x0018faec
MOV R15,qword ptr [R14 + 0x118]
MOV RDI,qword ptr [RBX]
MOV RSI,R14
CALL 0x0018fcc5
MOV RCX,RAX
MOV RDI,qword ptr [RBX + 0x18]
XOR ESI,ESI
XOR EDX,EDX
DIV RDI
MOV RAX,RDI
SUB RAX,RDX
XOR EDX,EDX
DIV RDI
ADD RDX,RCX
MOVSXD RAX,dword ptr [RBX + 0x20]
LEA RDI,[RBX + 0x28]
LEA R10,[R15 + RDX*0x1]
TEST EAX,EAX
MOV R8D,0x0
CMOVG R8D,EAX
LEA RCX,[RBX + 0x48]
LAB_0018f9c2:
CMP R8,RSI
JZ 0x0018f9e6
MOV R11,qword ptr [RCX + -0x20]
MOV R9,qword ptr [RCX + -0x18]
LEA R14,[R11 + R9*0x1]
CMP R14,R15
JZ 0x0018fa11
CMP R10,R11
JZ 0x0018fa56
INC RSI
ADD RCX,0x10
JMP 0x0018f9c2
LAB_0018f9e6:
CMP EAX,0xff
JG 0x0018faf2
XOR ECX,ECX
MOV RSI,RDI
LAB_0018f9f6:
CMP R8,RCX
JZ 0x0018fab4
CMP qword ptr [RSI],R15
JNC 0x0018fab1
INC RCX
ADD RSI,0x10
JMP 0x0018f9f6
LAB_0018fa11:
ADD R9,RDX
MOV qword ptr [RCX + -0x18],R9
DEC EAX
CMP EAX,ESI
JLE 0x0018faec
ADD R11,R9
CMP R11,qword ptr [RCX + -0x10]
JNZ 0x0018faec
INC RSI
ADD R9,qword ptr [RCX + -0x8]
MOV qword ptr [RCX + -0x18],R9
MOV dword ptr [RBX + 0x20],EAX
LAB_0018fa3d:
CMP EAX,ESI
JLE 0x0018faec
VMOVUPS XMM0,xmmword ptr [RCX]
VMOVUPS xmmword ptr [RCX + -0x10],XMM0
ADD RCX,0x10
INC ESI
JMP 0x0018fa3d
LAB_0018fa56:
MOV qword ptr [RCX + -0x20],R15
ADD R9,RDX
MOV qword ptr [RCX + -0x18],R9
TEST RSI,RSI
JZ 0x0018faec
LEA EDX,[RSI + -0x1]
SHL RDX,0x4
MOV R8,qword ptr [RDI + RDX*0x1 + 0x8]
MOV R10,qword ptr [RDI + RDX*0x1]
ADD R10,R8
CMP R10,R15
JNZ 0x0018faec
ADD RCX,-0x10
ADD RDI,RDX
ADD R8,R9
MOV qword ptr [RDI + 0x8],R8
DEC EAX
MOV dword ptr [RBX + 0x20],EAX
CMP ESI,EAX
CMOVG EAX,ESI
LAB_0018fa9a:
CMP RSI,RAX
JZ 0x0018faec
VMOVUPS XMM0,xmmword ptr [RCX]
VMOVUPS xmmword ptr [RCX + -0x10],XMM0
ADD RCX,0x10
DEC RAX
JMP 0x0018fa9a
LAB_0018fab1:
MOV R8D,ECX
LAB_0018fab4:
MOVSXD RCX,R8D
MOV RSI,RAX
SHL RSI,0x4
ADD RSI,RBX
ADD RSI,0x28
LAB_0018fac5:
CMP RAX,RCX
JLE 0x0018fadc
DEC RAX
VMOVUPS XMM0,xmmword ptr [RSI + -0x10]
VMOVUPS xmmword ptr [RSI],XMM0
ADD RSI,-0x10
JMP 0x0018fac5
LAB_0018fadc:
SHL RCX,0x4
MOV qword ptr [RDI + RCX*0x1],R15
MOV qword ptr [RDI + RCX*0x1 + 0x8],RDX
INC dword ptr [RBX + 0x20]
LAB_0018faec:
POP RBX
POP R14
POP R15
RET
LAB_0018faf2:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a455a]
LEA R8,[0x1a46f1]
MOV ECX,0xcf
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
void free_node(int8 param_1,long param_2)
{
ulong *puVar1;
char cVar2;
int iVar3;
uint uVar4;
int8 *puVar5;
ulong uVar6;
long lVar7;
ulong uVar8;
int8 *puVar9;
long lVar10;
long lVar11;
int iVar12;
ulong uVar13;
ulong *puVar14;
ulong uVar15;
long lVar16;
puVar5 = (int8 *)node_tallocr();
cVar2 = ggml_tallocr_is_own(puVar5,param_2);
if (cVar2 != '\0') {
uVar8 = *(ulong *)(param_2 + 0x118);
uVar6 = ggml_backend_buffer_get_alloc_size(*puVar5);
uVar15 = puVar5[3];
uVar13 = 0;
lVar11 = (uVar15 - uVar6 % uVar15) % uVar15 + uVar6;
uVar4 = *(uint *)(puVar5 + 4);
lVar7 = (long)(int)uVar4;
puVar1 = puVar5 + 5;
uVar15 = 0;
if (0 < (int)uVar4) {
uVar15 = (ulong)uVar4;
}
puVar9 = puVar5 + 9;
for (; uVar15 != uVar13; uVar13 = uVar13 + 1) {
lVar10 = puVar9[-4];
lVar16 = puVar9[-3];
iVar12 = (int)uVar13;
if (lVar10 + lVar16 == uVar8) {
lVar16 = lVar16 + lVar11;
puVar9[-3] = lVar16;
iVar3 = uVar4 - 1;
if (iVar3 <= iVar12) {
return;
}
if (lVar10 + lVar16 != puVar9[-2]) {
return;
}
puVar9[-3] = lVar16 + puVar9[-1];
*(int *)(puVar5 + 4) = iVar3;
for (uVar13 = uVar13 + 1; (int)uVar13 < iVar3; uVar13 = (ulong)((int)uVar13 + 1)) {
puVar9[-2] = *puVar9;
puVar9[-1] = puVar9[1];
puVar9 = puVar9 + 2;
}
return;
}
if (uVar8 + lVar11 == lVar10) {
puVar9[-4] = uVar8;
puVar9[-3] = lVar16 + lVar11;
if (uVar13 == 0) {
return;
}
uVar15 = (ulong)(iVar12 - 1);
if (puVar1[uVar15 * 2] + puVar5[uVar15 * 2 + 6] != uVar8) {
return;
}
puVar9 = puVar9 + -2;
puVar1[uVar15 * 2 + 1] = puVar5[uVar15 * 2 + 6] + lVar16 + lVar11;
uVar4 = uVar4 - 1;
*(uint *)(puVar5 + 4) = uVar4;
uVar8 = (ulong)uVar4;
if ((int)uVar4 < iVar12) {
uVar8 = uVar13 & 0xffffffff;
}
for (; uVar13 != uVar8; uVar8 = uVar8 - 1) {
puVar9[-2] = *puVar9;
puVar9[-1] = puVar9[1];
puVar9 = puVar9 + 2;
}
return;
}
puVar9 = puVar9 + 2;
}
if (0xff < (int)uVar4) {
fflush(*(FILE **)PTR_stdout_001d5f48);
fprintf(*(FILE **)PTR_stderr_001d5fa8,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml-alloc.c"
,0xcf,"alloc->n_free_blocks < MAX_FREE_BLOCKS && \"out of free blocks\"");
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
puVar14 = puVar1;
for (uVar6 = 0; uVar15 != uVar6; uVar6 = uVar6 + 1) {
if (uVar8 <= *puVar14) {
uVar15 = uVar6 & 0xffffffff;
break;
}
puVar14 = puVar14 + 2;
}
lVar10 = (long)(int)uVar15;
puVar9 = puVar5 + lVar7 * 2 + 5;
for (; lVar10 < lVar7; lVar7 = lVar7 + -1) {
*puVar9 = puVar9[-2];
puVar9[1] = puVar9[-1];
puVar9 = puVar9 + -2;
}
puVar1[lVar10 * 2] = uVar8;
puVar5[lVar10 * 2 + 6] = lVar11;
*(int *)(puVar5 + 4) = *(int *)(puVar5 + 4) + 1;
}
return;
}
| |
38,133 | ma_store_blob_length | eloqsql/storage/maria/ma_dynrec.c | void _ma_store_blob_length(uchar *pos,uint pack_length,uint length)
{
switch (pack_length) {
case 1:
*pos= (uchar) length;
break;
case 2:
int2store(pos,length);
break;
case 3:
int3store(pos,length);
break;
case 4:
int4store(pos,length);
default:
break;
}
return;
} | O3 | c | ma_store_blob_length:
pushq %rbp
movq %rsp, %rbp
decl %esi
cmpl $0x3, %esi
ja 0x3e321
leaq 0xa2dac(%rip), %rax # 0xe10ac
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb %dl, (%rdi)
jmp 0x3e321
movb %dl, (%rdi)
movb %dh, 0x1(%rdi)
shrl $0x10, %edx
movb %dl, 0x2(%rdi)
jmp 0x3e321
movl %edx, (%rdi)
jmp 0x3e321
movw %dx, (%rdi)
popq %rbp
retq
| _ma_store_blob_length:
push rbp
mov rbp, rsp
dec esi; switch 4 cases
cmp esi, 3
ja short def_3E307; jumptable 000000000003E307 default case
lea rax, jpt_3E307
movsxd rcx, ds:(jpt_3E307 - 0E10ACh)[rax+rsi*4]
add rcx, rax
jmp rcx; switch jump
loc_3E309:
mov [rdi], dl; jumptable 000000000003E307 case 1
jmp short def_3E307; jumptable 000000000003E307 default case
loc_3E30D:
mov [rdi], dl; jumptable 000000000003E307 case 3
mov [rdi+1], dh
shr edx, 10h
mov [rdi+2], dl
jmp short def_3E307; jumptable 000000000003E307 default case
loc_3E31A:
mov [rdi], edx; jumptable 000000000003E307 case 4
jmp short def_3E307; jumptable 000000000003E307 default case
loc_3E31E:
mov [rdi], dx; jumptable 000000000003E307 case 2
def_3E307:
pop rbp; jumptable 000000000003E307 default case
retn
| void ma_store_blob_length(_BYTE *a1, int a2, int a3)
{
switch ( a2 )
{
case 1:
*a1 = a3;
break;
case 2:
*(_WORD *)a1 = a3;
break;
case 3:
*(_WORD *)a1 = a3;
a1[2] = BYTE2(a3);
break;
case 4:
*(_DWORD *)a1 = a3;
break;
default:
return;
}
}
| _ma_store_blob_length:
PUSH RBP
MOV RBP,RSP
DEC ESI
CMP ESI,0x3
JA 0x0013e321
LEA RAX,[0x1e10ac]
MOVSXD RCX,dword ptr [RAX + RSI*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_1:
MOV byte ptr [RDI],DL
JMP 0x0013e321
caseD_3:
MOV byte ptr [RDI],DL
MOV byte ptr [RDI + 0x1],DH
SHR EDX,0x10
MOV byte ptr [RDI + 0x2],DL
JMP 0x0013e321
caseD_4:
MOV dword ptr [RDI],EDX
JMP 0x0013e321
caseD_2:
MOV word ptr [RDI],DX
default:
POP RBP
RET
|
void _ma_store_blob_length(int4 *param_1,int4 param_2,int4 param_3)
{
switch(param_2) {
case 1:
*(char *)param_1 = (char)param_3;
break;
case 2:
*(short *)param_1 = (short)param_3;
break;
case 3:
*(char *)param_1 = (char)param_3;
*(char *)((long)param_1 + 1) = (char)((uint)param_3 >> 8);
*(char *)((long)param_1 + 2) = (char)((uint)param_3 >> 0x10);
break;
case 4:
*param_1 = param_3;
}
return;
}
| |
38,134 | translog_mark_file_finished | eloqsql/storage/maria/ma_loghandler.c | static void translog_mark_file_finished(uint32 file)
{
int i;
struct st_file_counter *UNINIT_VAR(fc_ptr);
DBUG_ENTER("translog_mark_file_finished");
DBUG_PRINT("enter", ("file: %lu", (ulong) file));
mysql_mutex_lock(&log_descriptor.unfinished_files_lock);
DBUG_ASSERT(log_descriptor.unfinished_files.elements > 0);
for (i= 0;
i < (int) log_descriptor.unfinished_files.elements;
i++)
{
fc_ptr= dynamic_element(&log_descriptor.unfinished_files,
i, struct st_file_counter *);
if (fc_ptr->file == file)
{
break;
}
}
DBUG_ASSERT(i < (int) log_descriptor.unfinished_files.elements);
if (! --fc_ptr->counter)
delete_dynamic_element(&log_descriptor.unfinished_files, i);
mysql_mutex_unlock(&log_descriptor.unfinished_files_lock);
DBUG_VOID_RETURN;
} | O3 | c | translog_mark_file_finished:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpq $0x0, 0xbaf5b2(%rip) # 0xbff608
jne 0x500ba
leaq 0xbaf569(%rip), %rdi # 0xbff5c8
callq 0x29220
movl 0xbaf5ae(%rip), %esi # 0xbff618
movq 0xbaf59f(%rip), %rax # 0xbff610
leal -0x1(%rsi), %edx
xorl %ecx, %ecx
cmpl %ebx, (%rax,%rcx,8)
je 0x50088
incq %rcx
cmpq %rcx, %rsi
jne 0x50076
movq %rdx, %rcx
jmp 0x5008a
movl %ecx, %esi
decl 0x4(%rax,%rcx,8)
jne 0x5009c
leaq 0xbaf579(%rip), %rdi # 0xbff610
callq 0x91e21
movq 0xbaf565(%rip), %rdi # 0xbff608
testq %rdi, %rdi
jne 0x500c1
leaq 0xbaf519(%rip), %rdi # 0xbff5c8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x291e0
callq 0x2cece
jmp 0x50064
leaq 0x335f48(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x500a8
| translog_mark_file_finished:
push rbp
mov rbp, rsp
push rbx
push rax
mov ebx, edi
cmp cs:qword_BFF608, 0
jnz short loc_500BA
lea rdi, unk_BFF5C8
call _pthread_mutex_lock
loc_50064:
mov esi, cs:dword_BFF618
mov rax, cs:qword_BFF610
lea edx, [rsi-1]
xor ecx, ecx
loc_50076:
cmp [rax+rcx*8], ebx
jz short loc_50088
inc rcx
cmp rsi, rcx
jnz short loc_50076
mov rcx, rdx
jmp short loc_5008A
loc_50088:
mov esi, ecx
loc_5008A:
dec dword ptr [rax+rcx*8+4]
jnz short loc_5009C
lea rdi, qword_BFF610
call delete_dynamic_element
loc_5009C:
mov rdi, cs:qword_BFF608
test rdi, rdi
jnz short loc_500C1
loc_500A8:
lea rdi, unk_BFF5C8
add rsp, 8
pop rbx
pop rbp
jmp _pthread_mutex_unlock
loc_500BA:
call translog_mark_file_finished_cold_1
jmp short loc_50064
loc_500C1:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_500A8
| long long translog_mark_file_finished(long long a1)
{
long long v1; // rsi
long long v2; // rdx
long long v3; // rcx
if ( qword_BFF608 )
translog_mark_file_finished_cold_1(a1);
else
pthread_mutex_lock(&unk_BFF5C8);
v1 = (unsigned int)dword_BFF618;
v2 = (unsigned int)(dword_BFF618 - 1);
v3 = 0LL;
while ( *(_DWORD *)(qword_BFF610 + 8 * v3) != (_DWORD)a1 )
{
if ( dword_BFF618 == ++v3 )
{
v3 = (unsigned int)(dword_BFF618 - 1);
goto LABEL_8;
}
}
v1 = (unsigned int)v3;
LABEL_8:
if ( (*(_DWORD *)(qword_BFF610 + 8 * v3 + 4))-- == 1 )
delete_dynamic_element(&qword_BFF610, v1, v2);
if ( qword_BFF608 )
((void ( *)(long long, long long, long long))PSI_server[44])(qword_BFF608, v1, v2);
return pthread_mutex_unlock(&unk_BFF5C8);
}
| translog_mark_file_finished:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV EBX,EDI
CMP qword ptr [0x00cff608],0x0
JNZ 0x001500ba
LEA RDI,[0xcff5c8]
CALL 0x00129220
LAB_00150064:
MOV ESI,dword ptr [0x00cff618]
MOV RAX,qword ptr [0x00cff610]
LEA EDX,[RSI + -0x1]
XOR ECX,ECX
LAB_00150076:
CMP dword ptr [RAX + RCX*0x8],EBX
JZ 0x00150088
INC RCX
CMP RSI,RCX
JNZ 0x00150076
MOV RCX,RDX
JMP 0x0015008a
LAB_00150088:
MOV ESI,ECX
LAB_0015008a:
DEC dword ptr [RAX + RCX*0x8 + 0x4]
JNZ 0x0015009c
LEA RDI,[0xcff610]
CALL 0x00191e21
LAB_0015009c:
MOV RDI,qword ptr [0x00cff608]
TEST RDI,RDI
JNZ 0x001500c1
LAB_001500a8:
LEA RDI,[0xcff5c8]
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001291e0
LAB_001500ba:
CALL 0x0012cece
JMP 0x00150064
LAB_001500c1:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001500a8
|
void translog_mark_file_finished(int param_1)
{
int *piVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
if (DAT_00cff608 == 0) {
pthread_mutex_lock((pthread_mutex_t *)&DAT_00cff5c8);
}
else {
translog_mark_file_finished_cold_1();
}
uVar4 = (ulong)DAT_00cff618;
uVar3 = (ulong)(DAT_00cff618 - 1);
uVar2 = 0;
do {
if (*(int *)(DAT_00cff610 + uVar2 * 8) == param_1) {
uVar4 = uVar2 & 0xffffffff;
uVar3 = uVar2;
break;
}
uVar2 = uVar2 + 1;
} while (uVar4 != uVar2);
piVar1 = (int *)(DAT_00cff610 + 4 + uVar3 * 8);
*piVar1 = *piVar1 + -1;
if (*piVar1 == 0) {
delete_dynamic_element(&DAT_00cff610,uVar4);
}
if (DAT_00cff608 != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)&DAT_00cff5c8);
return;
}
| |
38,135 | evmone::instr::core::keccak256(evmone::StackTop, long, evmone::ExecutionState&) | corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/lib/evmone/instructions.hpp | inline Result keccak256(StackTop stack, int64_t gas_left, ExecutionState& state) noexcept
{
const auto& index = stack.pop();
auto& size = stack.top();
if (!check_memory(gas_left, state.memory, index, size))
return {EVMC_OUT_OF_GAS, gas_left};
const auto i = static_cast<size_t>(index);
const auto s = static_cast<size_t>(size);
const auto w = num_words(s);
const auto cost = w * 6;
if ((gas_left -= cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
auto data = s != 0 ? &state.memory[i] : nullptr;
size = intx::be::load<uint256>(ethash::keccak256(data, s));
return {EVMC_SUCCESS, gas_left};
} | O0 | cpp | evmone::instr::core::keccak256(evmone::StackTop, long, evmone::ExecutionState&):
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5fb60
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5fb80
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq -0x20(%rbp), %rdi
callq 0x66e10
testb $0x1, %al
jne 0x66d12
movl $0x3, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x66df8
movq -0x30(%rbp), %rdi
callq 0x66f00
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x66f00
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x66f20
movq %rax, -0x50(%rbp)
imulq $0x6, -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jge 0x66d6b
movl $0x3, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x66df8
cmpq $0x0, -0x48(%rbp)
je 0x66d8c
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x40(%rbp), %rsi
callq 0x5ead0
movq %rax, -0xa8(%rbp)
jmp 0x66d97
xorl %eax, %eax
movq %rax, -0xa8(%rbp)
jmp 0x66d97
movq -0xa8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
callq 0x66f70
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x66f40
movq -0x38(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, (%rax)
movq -0x78(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN6evmone5instr4core9keccak256ENS_8StackTopElRNS_14ExecutionStateE:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
lea rdi, [rbp+var_18]; this
call _ZN6evmone8StackTop3popEv; evmone::StackTop::pop(void)
mov [rbp+var_30], rax
lea rdi, [rbp+var_18]; this
call _ZN6evmone8StackTop3topEv; evmone::StackTop::top(void)
mov [rbp+var_38], rax
mov rsi, [rbp+var_28]
add rsi, 8; unsigned __int64
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_38]
lea rdi, [rbp+var_20]
call _ZN6evmone12check_memoryERlRNS_6MemoryERKN4intx4uintILj256EEES7_; evmone::check_memory(long &,evmone::Memory &,intx::uint<256u> const&,intx::uint<256u> const&)
test al, 1
jnz short loc_66D12
mov [rbp+var_10], 3
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp loc_66DF8
loc_66D12:
mov rdi, [rbp+var_30]
call _ZNK4intx4uintILj256EEcvT_ImvEEv; intx::uint<256u>::operator ulong<ulong,void>(void)
mov [rbp+var_40], rax
mov rdi, [rbp+var_38]
call _ZNK4intx4uintILj256EEcvT_ImvEEv; intx::uint<256u>::operator ulong<ulong,void>(void)
mov [rbp+var_48], rax
mov rdi, [rbp+var_48]; this
call _ZN6evmone9num_wordsEm; evmone::num_words(ulong)
mov [rbp+var_50], rax
imul rax, [rbp+var_50], 6
mov [rbp+var_58], rax
mov rcx, [rbp+var_58]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
cmp rax, 0
jge short loc_66D6B
mov [rbp+var_10], 3
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp loc_66DF8
loc_66D6B:
cmp [rbp+var_48], 0
jz short loc_66D8C
mov rdi, [rbp+var_28]
add rdi, 8
mov rsi, [rbp+var_40]
call _ZN6evmone6MemoryixEm; evmone::Memory::operator[](ulong)
mov [rbp+var_A8], rax
jmp short loc_66D97
loc_66D8C:
xor eax, eax
mov [rbp+var_A8], rax
jmp short $+2
loc_66D97:
mov rax, [rbp+var_A8]
mov [rbp+var_60], rax
mov rsi, [rbp+var_60]; unsigned __int8 *
mov rdx, [rbp+var_48]; unsigned __int64
lea rdi, [rbp+var_A0]; this
call _ZN6ethash9keccak256EPKhm; ethash::keccak256(uchar const*,ulong)
lea rdi, [rbp+var_80]
lea rsi, [rbp+var_A0]
call _ZN4intx2be4loadINS_4uintILj256EEE14ethash_hash256EET_RKT0_; intx::be::load<intx::uint<256u>,ethash_hash256>(ethash_hash256 const&)
mov rax, [rbp+var_38]
mov rcx, [rbp+var_80]
mov [rax], rcx
mov rcx, [rbp+var_78]
mov [rax+8], rcx
mov rcx, [rbp+var_70]
mov [rax+10h], rcx
mov rcx, [rbp+var_68]
mov [rax+18h], rcx
mov [rbp+var_10], 0
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_66DF8:
mov eax, [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 0B0h
pop rbp
retn
| long long evmone::instr::core::keccak256(long long a1, long long a2, long long a3)
{
_QWORD *v3; // rax
const unsigned __int8 *v5; // [rsp+8h] [rbp-A8h]
_BYTE v6[32]; // [rsp+10h] [rbp-A0h] BYREF
_QWORD v7[6]; // [rsp+30h] [rbp-80h] BYREF
long long v8; // [rsp+60h] [rbp-50h]
evmone *v9; // [rsp+68h] [rbp-48h]
long long v10; // [rsp+70h] [rbp-40h]
_QWORD *v11; // [rsp+78h] [rbp-38h]
long long v12; // [rsp+80h] [rbp-30h]
long long v13; // [rsp+88h] [rbp-28h]
long long v14; // [rsp+90h] [rbp-20h] BYREF
long long v15; // [rsp+98h] [rbp-18h] BYREF
unsigned int v16; // [rsp+A0h] [rbp-10h]
long long v17; // [rsp+A8h] [rbp-8h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = evmone::StackTop::pop((evmone::StackTop *)&v15);
v11 = (_QWORD *)evmone::StackTop::top((evmone::StackTop *)&v15);
if ( (evmone::check_memory(&v14, v13 + 8, v12, v11) & 1) != 0 )
{
v10 = intx::uint<256u>::operator unsigned long<unsigned long,void>(v12);
v9 = (evmone *)intx::uint<256u>::operator unsigned long<unsigned long,void>(v11);
v8 = evmone::num_words(v9, v13 + 8);
v7[5] = 6 * v8;
v14 -= 6 * v8;
if ( v14 >= 0 )
{
if ( v9 )
v5 = (const unsigned __int8 *)evmone::Memory::operator[](v13 + 8, v10);
else
v5 = 0LL;
v7[4] = v5;
ethash::keccak256((ethash *)v6, v5, (unsigned long long)v9);
intx::be::load<intx::uint<256u>,ethash_hash256>(v7, v6);
v3 = v11;
*v11 = v7[0];
v3[1] = v7[1];
v3[2] = v7[2];
v3[3] = v7[3];
v16 = 0;
v17 = v14;
}
else
{
v16 = 3;
v17 = v14;
}
}
else
{
v16 = 3;
v17 = v14;
}
return v16;
}
| keccak256:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
LEA RDI,[RBP + -0x18]
CALL 0x0015fb60
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[RBP + -0x18]
CALL 0x0015fb80
MOV qword ptr [RBP + -0x38],RAX
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x8
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
LEA RDI,[RBP + -0x20]
CALL 0x00166e10
TEST AL,0x1
JNZ 0x00166d12
MOV dword ptr [RBP + -0x10],0x3
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00166df8
LAB_00166d12:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00166f00
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00166f00
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x00166f20
MOV qword ptr [RBP + -0x50],RAX
IMUL RAX,qword ptr [RBP + -0x50],0x6
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JGE 0x00166d6b
MOV dword ptr [RBP + -0x10],0x3
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00166df8
LAB_00166d6b:
CMP qword ptr [RBP + -0x48],0x0
JZ 0x00166d8c
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x40]
CALL 0x0015ead0
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x00166d97
LAB_00166d8c:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x00166d97
LAB_00166d97:
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0x60],RAX
MOV RSI,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RBP + -0x48]
LEA RDI,[RBP + -0xa0]
CALL 0x00166f70
LEA RDI,[RBP + -0x80]
LEA RSI,[RBP + -0xa0]
CALL 0x00166f40
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x80]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x78]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX + 0x18],RCX
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_00166df8:
MOV EAX,dword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0xb0
POP RBP
RET
|
/* evmone::instr::core::keccak256(evmone::StackTop, long, evmone::ExecutionState&) */
int1 [16] evmone::instr::core::keccak256(int8 param_1,long param_2,long param_3)
{
ulong uVar1;
int1 auVar2 [16];
uchar *local_b0;
ethash local_a8 [32];
int8 local_88;
int8 local_80;
int8 local_78;
int8 local_70;
uchar *local_68;
long local_60;
long local_58;
ulong local_50;
ulong local_48;
uint *local_40;
uint *local_38;
long local_30;
long local_28;
int8 local_20;
uint local_18;
long local_10;
local_30 = param_3;
local_28 = param_2;
local_20 = param_1;
local_38 = (uint *)StackTop::pop((StackTop *)&local_20);
local_40 = (uint *)StackTop::top((StackTop *)&local_20);
uVar1 = check_memory(&local_28,(Memory *)(local_30 + 8),local_38,local_40);
if ((uVar1 & 1) == 0) {
local_18 = 3;
local_10 = local_28;
}
else {
local_48 = intx::uint::operator_cast_to_unsigned_long(local_38);
local_50 = intx::uint::operator_cast_to_unsigned_long(local_40);
local_58 = num_words(local_50);
local_60 = local_58 * 6;
local_28 = local_28 + local_58 * -6;
if (local_28 < 0) {
local_18 = 3;
local_10 = local_28;
}
else {
if (local_50 == 0) {
local_b0 = (uchar *)0x0;
}
else {
local_b0 = (uchar *)Memory::operator[]((Memory *)(local_30 + 8),local_48);
}
local_68 = local_b0;
ethash::keccak256(local_a8,local_b0,local_50);
intx::be::load<intx::uint<256u>,ethash_hash256>((be *)&local_88,(ethash_hash256 *)local_a8);
*(int8 *)local_40 = local_88;
*(int8 *)(local_40 + 8) = local_80;
*(int8 *)(local_40 + 0x10) = local_78;
*(int8 *)(local_40 + 0x18) = local_70;
local_18 = 0;
local_10 = local_28;
}
}
auVar2._4_4_ = 0;
auVar2._0_4_ = local_18;
auVar2._8_8_ = local_10;
return auVar2;
}
| |
38,136 | my_strnxfrm_simple_internal | eloqsql/strings/ctype-simple.c | size_t my_strnxfrm_simple_internal(CHARSET_INFO * cs,
uchar *dst, size_t dstlen, uint *nweights,
const uchar *src, size_t srclen)
{
const uchar *map= cs->sort_order;
uchar *d0= dst;
uint frmlen;
if ((frmlen= (uint)MY_MIN(dstlen, *nweights)) > srclen)
frmlen= (uint)srclen;
if (dst != src)
{
const uchar *end;
for (end= src + frmlen; src < end;)
*dst++= map[*src++];
}
else
{
const uchar *end;
for (end= dst + frmlen; dst < end; dst++)
*dst= map[(uchar) *dst];
}
*nweights-= frmlen;
return dst - d0;
} | O3 | c | my_strnxfrm_simple_internal:
pushq %rbp
movq %rsp, %rbp
movq 0x58(%rdi), %rdi
movl (%rcx), %eax
cmpq %rdx, %rax
cmovbel %eax, %edx
cmpq %r9, %rdx
cmovbel %edx, %r9d
movq %rsi, %rax
cmpq %r8, %rsi
je 0x36d61
testq %r9, %r9
je 0x36d80
leaq (%r8,%r9), %rdx
movq %rsi, %rax
movzbl (%r8), %r10d
incq %r8
movb (%rdi,%r10), %r10b
movb %r10b, (%rax)
incq %rax
cmpq %rdx, %r8
jb 0x36d49
jmp 0x36d80
testq %r9, %r9
je 0x36d80
leaq (%rsi,%r9), %rdx
movq %rsi, %rax
movzbl (%rax), %r8d
movb (%rdi,%r8), %r8b
movb %r8b, (%rax)
incq %rax
cmpq %rdx, %rax
jb 0x36d6d
subl %r9d, (%rcx)
subq %rsi, %rax
popq %rbp
retq
| my_strnxfrm_simple_internal:
push rbp
mov rbp, rsp
mov rdi, [rdi+58h]
mov eax, [rcx]
cmp rax, rdx
cmovbe edx, eax
cmp rdx, r9
cmovbe r9d, edx
mov rax, rsi
cmp rsi, r8
jz short loc_36D61
test r9, r9
jz short loc_36D80
lea rdx, [r8+r9]
mov rax, rsi
loc_36D49:
movzx r10d, byte ptr [r8]
inc r8
mov r10b, [rdi+r10]
mov [rax], r10b
inc rax
cmp r8, rdx
jb short loc_36D49
jmp short loc_36D80
loc_36D61:
test r9, r9
jz short loc_36D80
lea rdx, [rsi+r9]
mov rax, rsi
loc_36D6D:
movzx r8d, byte ptr [rax]
mov r8b, [rdi+r8]
mov [rax], r8b
inc rax
cmp rax, rdx
jb short loc_36D6D
loc_36D80:
sub [rcx], r9d
sub rax, rsi
pop rbp
retn
| _BYTE * my_strnxfrm_simple_internal(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
_DWORD *a4,
unsigned __int8 *a5,
unsigned long long a6)
{
long long v6; // rdi
unsigned long long v7; // rax
unsigned __int8 *v8; // rax
unsigned __int8 *v9; // rdx
long long v10; // r10
v6 = *(_QWORD *)(a1 + 88);
v7 = (unsigned int)*a4;
if ( v7 <= a3 )
a3 = (unsigned int)v7;
if ( a3 <= a6 )
a6 = (unsigned int)a3;
v8 = a2;
if ( a2 == a5 )
{
if ( a6 )
{
v8 = a2;
do
{
*v8 = *(_BYTE *)(v6 + *v8);
++v8;
}
while ( v8 < &a2[a6] );
}
}
else if ( a6 )
{
v9 = &a5[a6];
v8 = a2;
do
{
v10 = *a5++;
*v8++ = *(_BYTE *)(v6 + v10);
}
while ( a5 < v9 );
}
*a4 -= a6;
return (_BYTE *)(v8 - a2);
}
| my_strnxfrm_simple_internal:
PUSH RBP
MOV RBP,RSP
MOV RDI,qword ptr [RDI + 0x58]
MOV EAX,dword ptr [RCX]
CMP RAX,RDX
CMOVBE EDX,EAX
CMP RDX,R9
CMOVBE R9D,EDX
MOV RAX,RSI
CMP RSI,R8
JZ 0x00136d61
TEST R9,R9
JZ 0x00136d80
LEA RDX,[R8 + R9*0x1]
MOV RAX,RSI
LAB_00136d49:
MOVZX R10D,byte ptr [R8]
INC R8
MOV R10B,byte ptr [RDI + R10*0x1]
MOV byte ptr [RAX],R10B
INC RAX
CMP R8,RDX
JC 0x00136d49
JMP 0x00136d80
LAB_00136d61:
TEST R9,R9
JZ 0x00136d80
LEA RDX,[RSI + R9*0x1]
MOV RAX,RSI
LAB_00136d6d:
MOVZX R8D,byte ptr [RAX]
MOV R8B,byte ptr [RDI + R8*0x1]
MOV byte ptr [RAX],R8B
INC RAX
CMP RAX,RDX
JC 0x00136d6d
LAB_00136d80:
SUB dword ptr [RCX],R9D
SUB RAX,RSI
POP RBP
RET
|
long my_strnxfrm_simple_internal
(long param_1,byte *param_2,ulong param_3,uint *param_4,byte *param_5,ulong param_6)
{
byte *pbVar1;
byte bVar2;
long lVar3;
byte *pbVar4;
ulong uVar5;
ulong uVar6;
lVar3 = *(long *)(param_1 + 0x58);
uVar5 = param_3 & 0xffffffff;
if (*param_4 <= param_3) {
uVar5 = (ulong)*param_4;
}
uVar6 = param_6 & 0xffffffff;
if (uVar5 <= param_6) {
uVar6 = uVar5;
}
pbVar4 = param_2;
if (param_2 == param_5) {
if (uVar6 != 0) {
do {
*pbVar4 = *(byte *)(lVar3 + (ulong)*pbVar4);
pbVar4 = pbVar4 + 1;
} while (pbVar4 < param_2 + uVar6);
}
}
else if (uVar6 != 0) {
pbVar1 = param_5 + uVar6;
do {
bVar2 = *param_5;
param_5 = param_5 + 1;
*pbVar4 = *(byte *)(lVar3 + (ulong)bVar2);
pbVar4 = pbVar4 + 1;
} while (param_5 < pbVar1);
}
*param_4 = *param_4 - (int)uVar6;
return (long)pbVar4 - (long)param_2;
}
| |
38,137 | my_numcells_sjis | eloqsql/strings/ctype-sjis.c | static
size_t my_numcells_sjis(CHARSET_INFO *cs __attribute__((unused)),
const char *str, const char *str_end)
{
size_t clen;
const uchar *b= (const uchar *) str;
const uchar *e= (const uchar *) str_end;
for (clen= 0; b < e; )
{
if (*b >= 0xA1 && *b <= 0xDF)
{
clen++;
b++;
}
else if (*b > 0x7F)
{
clen+= 2;
b+= 2;
}
else
{
clen++;
b++;
}
}
return clen;
} | O3 | c | my_numcells_sjis:
cmpq %rdx, %rsi
jae 0x4c7db
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl $0x1, %ecx
movb (%rsi), %dil
leal 0x5f(%rdi), %r8d
shrb $0x7, %dil
movzbl %dil, %edi
incq %rdi
cmpb $0x3f, %r8b
cmovbq %rcx, %rdi
addq %rdi, %rax
addq %rdi, %rsi
cmpq %rdx, %rsi
jb 0x4c7b4
popq %rbp
retq
xorl %eax, %eax
retq
| my_numcells_sjis:
cmp rsi, rdx
jnb short loc_4C7DB
push rbp
mov rbp, rsp
xor eax, eax
mov ecx, 1
loc_4C7B4:
mov dil, [rsi]
lea r8d, [rdi+5Fh]
shr dil, 7
movzx edi, dil
inc rdi
cmp r8b, 3Fh ; '?'
cmovb rdi, rcx
add rax, rdi
add rsi, rdi
cmp rsi, rdx
jb short loc_4C7B4
pop rbp
retn
loc_4C7DB:
xor eax, eax
retn
| long long my_numcells_sjis(long long a1, _BYTE *a2, unsigned long long a3)
{
long long result; // rax
long long v4; // rdi
if ( (unsigned long long)a2 >= a3 )
return 0LL;
result = 0LL;
do
{
v4 = (*a2 >> 7) + 1LL;
if ( (unsigned __int8)(*a2 + 95) < 0x3Fu )
v4 = 1LL;
result += v4;
a2 += v4;
}
while ( (unsigned long long)a2 < a3 );
return result;
}
| my_numcells_sjis:
CMP RSI,RDX
JNC 0x0014c7db
PUSH RBP
MOV RBP,RSP
XOR EAX,EAX
MOV ECX,0x1
LAB_0014c7b4:
MOV DIL,byte ptr [RSI]
LEA R8D,[RDI + 0x5f]
SHR DIL,0x7
MOVZX EDI,DIL
INC RDI
CMP R8B,0x3f
CMOVC RDI,RCX
ADD RAX,RDI
ADD RSI,RDI
CMP RSI,RDX
JC 0x0014c7b4
POP RBP
RET
LAB_0014c7db:
XOR EAX,EAX
RET
|
long my_numcells_sjis(int8 param_1,byte *param_2,byte *param_3)
{
long lVar1;
long lVar2;
if (param_2 < param_3) {
lVar1 = 0;
do {
lVar2 = (ulong)(*param_2 >> 7) + 1;
if ((byte)(*param_2 + 0x5f) < 0x3f) {
lVar2 = 1;
}
lVar1 = lVar1 + lVar2;
param_2 = param_2 + lVar2;
} while (param_2 < param_3);
return lVar1;
}
return 0;
}
| |
38,138 | set_segment_footer | seiftnesse[P]memoryallocator/src/custom_alloc_util.c | void set_segment_footer(segment_t *s) {
if (!s || integrity_check_level < 2) return;
uint32_t *footer = get_segment_footer(s);
if (footer) {
*footer = FOOTER_GUARD_VALUE;
HEAP_LOG("Set footer guard at %p for segment %p\n", footer, s);
}
} | O1 | c | set_segment_footer:
testq %rdi, %rdi
je 0x11a04
cmpl $0x2, 0x48ba9(%rip) # 0x5a56c
jl 0x11a04
movl 0x4(%rdi), %ecx
leal -0x4001(%rcx), %eax
cmpl $0xffffc000, %eax # imm = 0xFFFFC000
jae 0x119d9
xorl %eax, %eax
jmp 0x119f9
shlq $0xc, %rcx
leaq (%rcx,%rdi), %rax
addq $-0x4, %rax
addq %rdi, %rcx
xorl %edx, %edx
cmpq %rdi, %rax
cmovbeq %rdx, %rax
cmpq $0x4, %rcx
cmovbq %rdx, %rax
testq %rax, %rax
je 0x11a04
movl $0xdeadc0de, (%rax) # imm = 0xDEADC0DE
retq
| set_segment_footer:
test rdi, rdi
jz short locret_11A04
cmp cs:integrity_check_level, 2
jl short locret_11A04
mov ecx, [rdi+4]
lea eax, [rcx-4001h]
cmp eax, 0FFFFC000h
jnb short loc_119D9
xor eax, eax
jmp short loc_119F9
loc_119D9:
shl rcx, 0Ch
lea rax, [rcx+rdi]
add rax, 0FFFFFFFFFFFFFFFCh
add rcx, rdi
xor edx, edx
cmp rax, rdi
cmovbe rax, rdx
cmp rcx, 4
cmovb rax, rdx
loc_119F9:
test rax, rax
jz short locret_11A04
mov dword ptr [rax], 0DEADC0DEh
locret_11A04:
retn
| void set_segment_footer(unsigned long long a1)
{
long long v1; // rcx
_DWORD *v2; // rax
long long v3; // rcx
unsigned long long v4; // rcx
if ( a1 && integrity_check_level >= 2 )
{
v1 = *(unsigned int *)(a1 + 4);
if ( (unsigned int)(v1 - 16385) >= 0xFFFFC000 )
{
v3 = v1 << 12;
v2 = (_DWORD *)(v3 + a1 - 4);
v4 = a1 + v3;
if ( (unsigned long long)v2 <= a1 )
v2 = 0LL;
if ( v4 < 4 )
v2 = 0LL;
}
else
{
v2 = 0LL;
}
if ( v2 )
*v2 = -559038242;
}
}
| set_segment_footer:
TEST RDI,RDI
JZ 0x00111a04
CMP dword ptr [0x0015a56c],0x2
JL 0x00111a04
MOV ECX,dword ptr [RDI + 0x4]
LEA EAX,[RCX + -0x4001]
CMP EAX,0xffffc000
JNC 0x001119d9
XOR EAX,EAX
JMP 0x001119f9
LAB_001119d9:
SHL RCX,0xc
LEA RAX,[RCX + RDI*0x1]
ADD RAX,-0x4
ADD RCX,RDI
XOR EDX,EDX
CMP RAX,RDI
CMOVBE RAX,RDX
CMP RCX,0x4
CMOVC RAX,RDX
LAB_001119f9:
TEST RAX,RAX
JZ 0x00111a04
MOV dword ptr [RAX],0xdeadc0de
LAB_00111a04:
RET
|
void set_segment_footer(int4 *param_1)
{
uint uVar1;
int4 *puVar2;
if ((param_1 != (int4 *)0x0) && (1 < integrity_check_level)) {
uVar1 = param_1[1];
if (uVar1 - 0x4001 < 0xffffc000) {
puVar2 = (int4 *)0x0;
}
else {
puVar2 = param_1 + (ulong)uVar1 * 0x400 + -1;
if (param_1 + (ulong)uVar1 * 0x400 + -1 <= param_1) {
puVar2 = (int4 *)0x0;
}
if (param_1 + (ulong)uVar1 * 0x400 < (int4 *)0x4) {
puVar2 = (int4 *)0x0;
}
}
if (puVar2 != (int4 *)0x0) {
*puVar2 = 0xdeadc0de;
}
}
return;
}
| |
38,139 | inline_mysql_cond_init | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_cond_init(
#ifdef HAVE_PSI_COND_INTERFACE
PSI_cond_key key,
#endif
mysql_cond_t *that,
const pthread_condattr_t *attr)
{
#ifdef HAVE_PSI_COND_INTERFACE
that->m_psi= PSI_COND_CALL(init_cond)(key, &that->m_cond);
#else
that->m_psi= NULL;
#endif
return pthread_cond_init(&that->m_cond, attr);
} | O0 | c | inline_mysql_cond_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x26d136(%rip), %rax # 0x2cb450
movq (%rax), %rax
movq 0x60(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a360
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| inline_mysql_cond_init_0:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+60h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+30h], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_cond_init
add rsp, 20h
pop rbp
retn
| long long inline_mysql_cond_init_0(unsigned int a1, long long a2, long long a3)
{
*(_QWORD *)(a2 + 48) = ((long long ( *)(_QWORD, long long))PSI_server[12])(a1, a2);
return pthread_cond_init(a2, a3);
}
| inline_mysql_cond_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RAX,[0x3cb450]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x60]
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012a360
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_cond_init(int4 param_1,pthread_cond_t *param_2,pthread_condattr_t *param_3)
{
longlong lVar1;
lVar1 = (**(code **)(PSI_server + 0x60))(param_1,param_2);
param_2[1].__align = lVar1;
pthread_cond_init(param_2,param_3);
return;
}
| |
38,140 | insert_at | eloqsql/mysys/queues.c | static void insert_at(QUEUE *queue, uchar *element, uint idx)
{
uint next_index, offset_to_key= queue->offset_to_key;
uint offset_to_queue_pos= queue->offset_to_queue_pos;
/* max_at_top swaps the comparison if we want to order by desc */
while ((next_index= idx >> 1) > 0 &&
queue->compare(queue->first_cmp_arg,
element + offset_to_key,
queue->root[next_index] + offset_to_key) *
queue->max_at_top < 0)
{
queue->root[idx]= queue->root[next_index];
if (offset_to_queue_pos)
(*(uint*) (queue->root[idx] + offset_to_queue_pos-1))= idx;
idx= next_index;
}
queue->root[idx]= element;
if (offset_to_queue_pos)
(*(uint*) (element + offset_to_queue_pos-1))= idx;
} | O0 | c | insert_at:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
shrl %ecx
movl %ecx, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jbe 0xf727a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %ecx
addq %rcx, %rsi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl -0x18(%rbp), %edx
movq (%rcx,%rdx,8), %rdx
movl -0x1c(%rbp), %ecx
addq %rcx, %rdx
callq *%rax
movq -0x8(%rbp), %rcx
imull 0x24(%rcx), %eax
cmpl $0x0, %eax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xf7283
jmp 0xf72c8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, -0x20(%rbp)
je 0xf72bd
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x20(%rbp), %ecx
movl %edx, -0x1(%rax,%rcx)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xf7227
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, -0x20(%rbp)
je 0xf72ee
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %edx, -0x1(%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| insert_at:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov eax, [rax+18h]
mov [rbp+var_1C], eax
mov rax, [rbp+var_8]
mov eax, [rax+1Ch]
mov [rbp+var_20], eax
loc_F7227:
mov ecx, [rbp+var_14]
shr ecx, 1
mov [rbp+var_18], ecx
xor eax, eax
cmp ecx, 0
mov [rbp+var_21], al
jbe short loc_F727A
mov rax, [rbp+var_8]
mov rax, [rax+28h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+8]
mov rsi, [rbp+var_10]
mov ecx, [rbp+var_1C]
add rsi, rcx
mov rcx, [rbp+var_8]
mov rcx, [rcx]
mov edx, [rbp+var_18]
mov rdx, [rcx+rdx*8]
mov ecx, [rbp+var_1C]
add rdx, rcx
call rax
mov rcx, [rbp+var_8]
imul eax, [rcx+24h]
cmp eax, 0
setl al
mov [rbp+var_21], al
loc_F727A:
mov al, [rbp+var_21]
test al, 1
jnz short loc_F7283
jmp short loc_F72C8
loc_F7283:
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_18]
mov rdx, [rax+rcx*8]
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_14]
mov [rax+rcx*8], rdx
cmp [rbp+var_20], 0
jz short loc_F72BD
mov edx, [rbp+var_14]
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8]
mov ecx, [rbp+var_20]
mov [rax+rcx-1], edx
loc_F72BD:
mov eax, [rbp+var_18]
mov [rbp+var_14], eax
jmp loc_F7227
loc_F72C8:
mov rdx, [rbp+var_10]
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_14]
mov [rax+rcx*8], rdx
cmp [rbp+var_20], 0
jz short loc_F72EE
mov edx, [rbp+var_14]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
mov [rax+rcx-1], edx
loc_F72EE:
add rsp, 30h
pop rbp
retn
| long long insert_at(long long *a1, long long a2, unsigned int a3)
{
long long result; // rax
bool v4; // [rsp+Fh] [rbp-21h]
unsigned int v5; // [rsp+10h] [rbp-20h]
unsigned int v6; // [rsp+14h] [rbp-1Ch]
unsigned int v7; // [rsp+18h] [rbp-18h]
v6 = *((_DWORD *)a1 + 6);
v5 = *((_DWORD *)a1 + 7);
while ( 1 )
{
v7 = a3 >> 1;
v4 = 0;
if ( a3 >> 1 )
v4 = (int)(*((_DWORD *)a1 + 9)
* ((long long ( *)(long long, long long, _QWORD))a1[5])(
a1[1],
v6 + a2,
v6 + *(_QWORD *)(*a1 + 8LL * v7))) < 0;
if ( !v4 )
break;
*(_QWORD *)(*a1 + 8LL * a3) = *(_QWORD *)(*a1 + 8LL * v7);
if ( v5 )
*(_DWORD *)(*(_QWORD *)(*a1 + 8LL * a3) + v5 - 1LL) = a3;
a3 >>= 1;
}
result = *a1;
*(_QWORD *)(*a1 + 8LL * a3) = a2;
if ( v5 )
{
result = a2;
*(_DWORD *)(a2 + v5 - 1) = a3;
}
return result;
}
| insert_at:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x18]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBP + -0x20],EAX
LAB_001f7227:
MOV ECX,dword ptr [RBP + -0x14]
SHR ECX,0x1
MOV dword ptr [RBP + -0x18],ECX
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x21],AL
JBE 0x001f727a
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x1c]
ADD RSI,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
MOV EDX,dword ptr [RBP + -0x18]
MOV RDX,qword ptr [RCX + RDX*0x8]
MOV ECX,dword ptr [RBP + -0x1c]
ADD RDX,RCX
CALL RAX
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x24]
CMP EAX,0x0
SETL AL
MOV byte ptr [RBP + -0x21],AL
LAB_001f727a:
MOV AL,byte ptr [RBP + -0x21]
TEST AL,0x1
JNZ 0x001f7283
JMP 0x001f72c8
LAB_001f7283:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x14]
MOV qword ptr [RAX + RCX*0x8],RDX
CMP dword ptr [RBP + -0x20],0x0
JZ 0x001f72bd
MOV EDX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV ECX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX + RCX*0x1 + -0x1],EDX
LAB_001f72bd:
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001f7227
LAB_001f72c8:
MOV RDX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x14]
MOV qword ptr [RAX + RCX*0x8],RDX
CMP dword ptr [RBP + -0x20],0x0
JZ 0x001f72ee
MOV EDX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX + RCX*0x1 + -0x1],EDX
LAB_001f72ee:
ADD RSP,0x30
POP RBP
RET
|
void insert_at(long *param_1,long param_2,uint param_3)
{
uint uVar1;
uint uVar2;
int iVar3;
uint uVar4;
bool bVar5;
uint local_1c;
uVar1 = *(uint *)(param_1 + 3);
uVar2 = *(uint *)((long)param_1 + 0x1c);
uVar4 = param_3;
while( true ) {
local_1c = uVar4;
uVar4 = local_1c >> 1;
bVar5 = false;
if (uVar4 != 0) {
iVar3 = (*(code *)param_1[5])
(param_1[1],param_2 + (ulong)uVar1,
*(long *)(*param_1 + (ulong)uVar4 * 8) + (ulong)uVar1);
bVar5 = iVar3 * *(int *)((long)param_1 + 0x24) < 0;
}
if (!bVar5) break;
*(int8 *)(*param_1 + (ulong)local_1c * 8) = *(int8 *)(*param_1 + (ulong)uVar4 * 8);
if (uVar2 != 0) {
*(uint *)(*(long *)(*param_1 + (ulong)local_1c * 8) + -1 + (ulong)uVar2) = local_1c;
}
}
*(long *)(*param_1 + (ulong)local_1c * 8) = param_2;
if (uVar2 != 0) {
*(uint *)(param_2 + -1 + (ulong)uVar2) = local_1c;
}
return;
}
| |
38,141 | ftxui::ConstStringRef::ConstStringRef(char const*) | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/include/ftxui/util/ref.hpp | ConstStringRef(const char* ref) : ConstStringRef(std::string(ref)) {} | O3 | cpp | ftxui::ConstStringRef::ConstStringRef(char const*):
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x104a6
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rcx
leaq 0x18(%rsp), %rdx
cmpq %rdx, %rcx
je 0x36682
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x36688
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movb $0x0, 0x20(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN5ftxui14ConstStringRefC2EPKc:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
lea r14, [rsp+38h+var_30]
lea rdx, [rsp+38h+var_31]
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rax, [rbx+10h]
mov [rbx], rax
mov rcx, [r14]
lea rdx, [rsp+38h+var_20]
cmp rcx, rdx
jz short loc_36682
mov [rbx], rcx
mov rax, [rsp+38h+var_20]
mov [rbx+10h], rax
jmp short loc_36688
loc_36682:
movups xmm0, xmmword ptr [rdx]
movups xmmword ptr [rax], xmm0
loc_36688:
mov rax, [rsp+38h+var_28]
mov [rbx+8], rax
mov byte ptr [rbx+20h], 0
add rsp, 28h
pop rbx
pop r14
retn
| long long ftxui::ConstStringRef::ConstStringRef(ftxui::ConstStringRef *this, const char *a2)
{
long long result; // rax
__int128 *v3; // [rsp+8h] [rbp-30h] BYREF
long long v4; // [rsp+10h] [rbp-28h]
__int128 v5; // [rsp+18h] [rbp-20h] BYREF
std::string::basic_string<std::allocator<char>>(&v3, (long long)a2);
*(_QWORD *)this = (char *)this + 16;
if ( v3 == &v5 )
{
*((_OWORD *)this + 1) = v5;
}
else
{
*(_QWORD *)this = v3;
*((_QWORD *)this + 2) = v5;
}
result = v4;
*((_QWORD *)this + 1) = v4;
*((_BYTE *)this + 32) = 0;
return result;
}
| ConstStringRef:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RDI,R14
CALL 0x001104a6
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RCX,qword ptr [R14]
LEA RDX,[RSP + 0x18]
CMP RCX,RDX
JZ 0x00136682
MOV qword ptr [RBX],RCX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RBX + 0x10],RAX
JMP 0x00136688
LAB_00136682:
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS xmmword ptr [RAX],XMM0
LAB_00136688:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RBX + 0x8],RAX
MOV byte ptr [RBX + 0x20],0x0
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* ftxui::ConstStringRef::ConstStringRef(char const*) */
void __thiscall ftxui::ConstStringRef::ConstStringRef(ConstStringRef *this,char *param_1)
{
allocator local_31;
int8 *local_30;
int8 local_28;
int8 local_20;
int8 uStack_18;
std::__cxx11::string::string<std::allocator<char>>((string *)&local_30,param_1,&local_31);
*(ConstStringRef **)this = this + 0x10;
if (local_30 == &local_20) {
*(int8 *)(this + 0x10) = local_20;
*(int8 *)(this + 0x18) = uStack_18;
}
else {
*(int8 **)this = local_30;
*(int8 *)(this + 0x10) = local_20;
}
*(int8 *)(this + 8) = local_28;
this[0x20] = (ConstStringRef)0x0;
return;
}
| |
38,142 | reinit_queue | eloqsql/mysys/queues.c | int reinit_queue(QUEUE *queue, uint max_elements, uint offset_to_key,
my_bool max_at_top, int (*compare) (void *, uchar *, uchar *),
void *first_cmp_arg, uint offset_to_queue_pos,
uint auto_extent)
{
DBUG_ENTER("reinit_queue");
queue->elements= 0;
queue->compare= compare;
queue->first_cmp_arg= first_cmp_arg;
queue->offset_to_key= offset_to_key;
queue->offset_to_queue_pos= offset_to_queue_pos;
queue->auto_extent= auto_extent;
queue_set_max_at_top(queue, max_at_top);
DBUG_RETURN(resize_queue(queue, max_elements));
} | O3 | c | reinit_queue:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %r10d
movl $0x0, 0x10(%rdi)
movq %r8, 0x28(%rdi)
movq %r9, 0x8(%rdi)
movl %edx, 0x18(%rdi)
movl %r10d, 0x1c(%rdi)
movl %eax, 0x20(%rdi)
xorl %eax, %eax
negb %cl
sbbl %eax, %eax
orl $0x1, %eax
movl %eax, 0x24(%rdi)
popq %rbp
jmp 0xa2119
| reinit_queue:
push rbp
mov rbp, rsp
mov eax, [rbp+arg_8]
mov r10d, [rbp+arg_0]
mov dword ptr [rdi+10h], 0
mov [rdi+28h], r8
mov [rdi+8], r9
mov [rdi+18h], edx
mov [rdi+1Ch], r10d
mov [rdi+20h], eax
xor eax, eax
neg cl
sbb eax, eax
or eax, 1
mov [rdi+24h], eax
pop rbp
jmp $+5
| long long reinit_queue(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6, int a7, int a8)
{
*(_DWORD *)(a1 + 16) = 0;
*(_QWORD *)(a1 + 40) = a5;
*(_QWORD *)(a1 + 8) = a6;
*(_DWORD *)(a1 + 24) = a3;
*(_DWORD *)(a1 + 28) = a7;
*(_DWORD *)(a1 + 32) = a8;
LOBYTE(a4) = -(char)a4;
*(_DWORD *)(a1 + 36) = (_BYTE)a4 != 0 ? -1 : 1;
return resize_queue(a1, a2, a3, a4);
}
| reinit_queue:
PUSH RBP
MOV RBP,RSP
MOV EAX,dword ptr [RBP + 0x18]
MOV R10D,dword ptr [RBP + 0x10]
MOV dword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x28],R8
MOV qword ptr [RDI + 0x8],R9
MOV dword ptr [RDI + 0x18],EDX
MOV dword ptr [RDI + 0x1c],R10D
MOV dword ptr [RDI + 0x20],EAX
XOR EAX,EAX
NEG CL
SBB EAX,EAX
OR EAX,0x1
MOV dword ptr [RDI + 0x24],EAX
POP RBP
JMP 0x001a2119
|
void reinit_queue(long param_1,int8 param_2,int4 param_3,char param_4,int8 param_5
,int8 param_6,int4 param_7,int4 param_8)
{
*(int4 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x28) = param_5;
*(int8 *)(param_1 + 8) = param_6;
*(int4 *)(param_1 + 0x18) = param_3;
*(int4 *)(param_1 + 0x1c) = param_7;
*(int4 *)(param_1 + 0x20) = param_8;
*(uint *)(param_1 + 0x24) = -(uint)(param_4 != '\0') | 1;
resize_queue();
return;
}
| |
38,143 | test_concurrently | eloqsql/unittest/mysys/thr_template.c | void test_concurrently(const char *test, pthread_handler handler, int n, int m)
{
pthread_t *threads= malloc(n * sizeof(pthread_t));
int i;
ulonglong now= my_interval_timer();
assert(threads);
bad= 0;
diag("Testing %s with %d threads, %d iterations... ", test, n, m);
for (i= 0; i < n; i++)
{
if (pthread_create(&threads[i], 0, handler, &m) != 0)
{
diag("Could not create thread");
abort();
}
}
for (i= 0; i < n; i++)
pthread_join(threads[i], 0);
now= my_interval_timer() - now;
free(threads);
ok(!bad, "tested %s in %g secs (%d)", test, ((double)now)/1e9, bad);
} | O0 | c | test_concurrently:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
callq 0x243d0
movq %rax, -0x20(%rbp)
callq 0x25b80
movq %rax, -0x30(%rbp)
movl $0x0, 0x3630de(%rip) # 0x3877d8
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x569f5(%rip), %rdi # 0x7b100
movb $0x0, %al
callq 0x24f80
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x24766
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x18(%rbp), %rcx
callq 0x24570
cmpl $0x0, %eax
je 0x24759
leaq 0x569e1(%rip), %rdi # 0x7b12e
movb $0x0, %al
callq 0x24f80
callq 0x241a0
jmp 0x2475b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x24719
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x24795
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x24260
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2476d
callq 0x25b80
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x24360
movl 0x363024(%rip), %eax # 0x3877d8
testl %eax, %eax
sete %al
movzbl %al, %edi
movq -0x8(%rbp), %rdx
movaps 0x56919(%rip), %xmm1 # 0x7b0e0
movq -0x30(%rbp), %xmm0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x56918(%rip), %xmm1 # 0x7b0f0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x56819(%rip), %xmm1 # 0x7b008
divsd %xmm1, %xmm0
movl 0x362fdf(%rip), %ecx # 0x3877d8
leaq 0x56946(%rip), %rsi # 0x7b146
movb $0x1, %al
callq 0x25240
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| test_concurrently:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
movsxd rdi, [rbp+var_14]
shl rdi, 3
call _malloc
mov [rbp+var_20], rax
call my_interval_timer
mov [rbp+var_30], rax
mov cs:bad, 0
mov rsi, [rbp+var_8]
mov edx, [rbp+var_14]
mov ecx, [rbp+var_18]
lea rdi, aTestingSWithDT; "Testing %s with %d threads, %d iteratio"...
mov al, 0
call diag
mov [rbp+var_24], 0
loc_24719:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_14]
jge short loc_24766
mov rdi, [rbp+var_20]
movsxd rax, [rbp+var_24]
shl rax, 3
add rdi, rax
mov rdx, [rbp+var_10]
xor eax, eax
mov esi, eax
lea rcx, [rbp+var_18]
call _pthread_create
cmp eax, 0
jz short loc_24759
lea rdi, aCouldNotCreate; "Could not create thread"
mov al, 0
call diag
call _abort
loc_24759:
jmp short $+2
loc_2475B:
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_24719
loc_24766:
mov [rbp+var_24], 0
loc_2476D:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_14]
jge short loc_24795
mov rax, [rbp+var_20]
movsxd rcx, [rbp+var_24]
mov rdi, [rax+rcx*8]
xor eax, eax
mov esi, eax
call _pthread_join
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_2476D
loc_24795:
call my_interval_timer
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_30], rax
mov rdi, [rbp+var_20]
call _free
mov eax, cs:bad
test eax, eax
setz al
movzx edi, al
mov rdx, [rbp+var_8]
movaps xmm1, cs:xmmword_7B0E0
movq xmm0, [rbp+var_30]
punpckldq xmm0, xmm1
movapd xmm1, cs:xmmword_7B0F0
subpd xmm0, xmm1
movaps xmm1, xmm0
unpckhpd xmm0, xmm0
addsd xmm0, xmm1
movsd xmm1, cs:qword_7B008
divsd xmm0, xmm1
mov ecx, cs:bad
lea rsi, aTestedSInGSecs; "tested %s in %g secs (%d)"
mov al, 1
call ok
add rsp, 30h
pop rbp
retn
| long long test_concurrently(long long a1, long long a2, int a3, int a4)
{
char v4; // al
int v5; // r8d
int v6; // r9d
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
int v11; // r8d
int v12; // r9d
long long v14; // [rsp+0h] [rbp-30h]
long long v15; // [rsp+0h] [rbp-30h]
int i; // [rsp+Ch] [rbp-24h]
int j; // [rsp+Ch] [rbp-24h]
long long v18; // [rsp+10h] [rbp-20h]
int v19; // [rsp+18h] [rbp-18h] BYREF
int v20; // [rsp+1Ch] [rbp-14h]
long long v21; // [rsp+20h] [rbp-10h]
long long v22; // [rsp+28h] [rbp-8h]
v22 = a1;
v21 = a2;
v20 = a3;
v19 = a4;
v18 = malloc(8LL * a3);
v4 = my_interval_timer();
bad = 0;
diag((unsigned int)"Testing %s with %d threads, %d iterations... ", a1, v20, v19, v5, v6, v4);
for ( i = 0; i < v20; ++i )
{
if ( (unsigned int)pthread_create(8LL * i + v18, 0LL, v21, &v19) )
{
diag((unsigned int)"Could not create thread", 0, v7, v8, v9, v10, v14);
abort();
}
}
for ( j = 0; j < v20; ++j )
pthread_join(*(_QWORD *)(v18 + 8LL * j), 0LL);
v15 = my_interval_timer() - v14;
free(v18);
return ok(bad == 0, (unsigned int)"tested %s in %g secs (%d)", v22, bad, v11, v12, v15);
}
| test_concurrently:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x18],ECX
MOVSXD RDI,dword ptr [RBP + -0x14]
SHL RDI,0x3
CALL 0x001243d0
MOV qword ptr [RBP + -0x20],RAX
CALL 0x00125b80
MOV qword ptr [RBP + -0x30],RAX
MOV dword ptr [0x004877d8],0x0
MOV RSI,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RBP + -0x14]
MOV ECX,dword ptr [RBP + -0x18]
LEA RDI,[0x17b100]
MOV AL,0x0
CALL 0x00124f80
MOV dword ptr [RBP + -0x24],0x0
LAB_00124719:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x14]
JGE 0x00124766
MOV RDI,qword ptr [RBP + -0x20]
MOVSXD RAX,dword ptr [RBP + -0x24]
SHL RAX,0x3
ADD RDI,RAX
MOV RDX,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV ESI,EAX
LEA RCX,[RBP + -0x18]
CALL 0x00124570
CMP EAX,0x0
JZ 0x00124759
LEA RDI,[0x17b12e]
MOV AL,0x0
CALL 0x00124f80
CALL 0x001241a0
LAB_00124759:
JMP 0x0012475b
LAB_0012475b:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00124719
LAB_00124766:
MOV dword ptr [RBP + -0x24],0x0
LAB_0012476d:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x14]
JGE 0x00124795
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV RDI,qword ptr [RAX + RCX*0x8]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00124260
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0012476d
LAB_00124795:
CALL 0x00125b80
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00124360
MOV EAX,dword ptr [0x004877d8]
TEST EAX,EAX
SETZ AL
MOVZX EDI,AL
MOV RDX,qword ptr [RBP + -0x8]
MOVAPS XMM1,xmmword ptr [0x0017b0e0]
MOVQ XMM0,qword ptr [RBP + -0x30]
PUNPCKLDQ XMM0,XMM1
MOVAPD XMM1,xmmword ptr [0x0017b0f0]
SUBPD XMM0,XMM1
MOVAPS XMM1,XMM0
UNPCKHPD XMM0,XMM0
ADDSD XMM0,XMM1
MOVSD XMM1,qword ptr [0x0017b008]
DIVSD XMM0,XMM1
MOV ECX,dword ptr [0x004877d8]
LEA RSI,[0x17b146]
MOV AL,0x1
CALL 0x00125240
ADD RSP,0x30
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void test_concurrently(int8 param_1,__start_routine *param_2,int param_3,int4 param_4)
{
int iVar1;
void *__ptr;
long lVar2;
long lVar3;
int1 auVar4 [16];
int local_2c;
int4 local_20;
int local_1c;
__start_routine *local_18;
int8 local_10;
local_20 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
__ptr = malloc((long)param_3 << 3);
lVar2 = my_interval_timer();
bad = 0;
diag("Testing %s with %d threads, %d iterations... ",local_10,local_1c,local_20);
local_2c = 0;
while( true ) {
if (local_1c <= local_2c) {
for (local_2c = 0; local_2c < local_1c; local_2c = local_2c + 1) {
pthread_join(*(pthread_t *)((long)__ptr + (long)local_2c * 8),(void **)0x0);
}
lVar3 = my_interval_timer();
lVar3 = lVar3 - lVar2;
free(__ptr);
auVar4._8_4_ = (int)((ulong)lVar3 >> 0x20);
auVar4._0_8_ = lVar3;
auVar4._12_4_ = _UNK_0017b0e4;
ok(((auVar4._8_8_ - _UNK_0017b0f8) +
((double)CONCAT44(_DAT_0017b0e0,(int)lVar3) - _DAT_0017b0f0)) / DAT_0017b008,bad == 0,
"tested %s in %g secs (%d)",local_10,bad);
return;
}
iVar1 = pthread_create((pthread_t *)((long)__ptr + (long)local_2c * 8),(pthread_attr_t *)0x0,
local_18,&local_20);
if (iVar1 != 0) break;
local_2c = local_2c + 1;
}
diag("Could not create thread");
/* WARNING: Subroutine does not return */
abort();
}
| |
38,144 | my_caseup_str_utf8mb3 | eloqsql/strings/ctype-utf8.c | static size_t my_caseup_str_utf8mb3(CHARSET_INFO *cs, char *src)
{
my_wc_t wc;
int srcres, dstres;
char *dst= src, *dst0= src;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(cs->caseup_multiply == 1);
while (*src &&
(srcres= my_utf8mb3_uni_no_range(cs, &wc, (uchar *) src)) > 0)
{
my_toupper_utf8mb3(uni_plane, &wc);
if ((dstres= my_uni_utf8mb3_no_range(cs, wc, (uchar*) dst)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
*dst= '\0';
return (size_t) (dst - dst0);
} | O3 | c | my_caseup_str_utf8mb3:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi)
movq %rsi, %r14
je 0x706eb
movq 0x78(%rdi), %r13
leaq -0x30(%rbp), %r15
movq %rbx, %r12
movq %rbx, %r14
movq %r15, %rdi
movq %r12, %rsi
callq 0x70fc4
testl %eax, %eax
je 0x706eb
movq 0x8(%r13), %rdx
movq -0x30(%rbp), %rcx
movzbl %ch, %esi
movq (%rdx,%rsi,8), %rdx
testq %rdx, %rdx
je 0x7067a
movzbl %cl, %ecx
leaq (%rcx,%rcx,2), %rcx
movl (%rdx,%rcx,4), %ecx
movq %rcx, -0x30(%rbp)
movl $0x1, %edx
cmpq $0x80, %rcx
jb 0x706d4
movl $0x2, %edx
cmpq $0x800, %rcx # imm = 0x800
jb 0x706bb
cmpq $0xffff, %rcx # imm = 0xFFFF
ja 0x706eb
movl %ecx, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x2(%r14)
shrq $0x6, %rcx
orq $0x800, %rcx # imm = 0x800
movl $0x3, %edx
movl %ecx, %esi
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x1(%r14)
shrq $0x6, %rcx
orq $0xc0, %rcx
movb %cl, (%r14)
movl %eax, %eax
addq %rdx, %r14
cmpb $0x0, (%r12,%rax)
leaq (%r12,%rax), %r12
jne 0x70645
movb $0x0, (%r14)
subq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_caseup_str_utf8mb3:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
cmp byte ptr [rsi], 0
mov r14, rsi
jz loc_706EB
mov r13, [rdi+78h]
lea r15, [rbp+var_30]
mov r12, rbx
mov r14, rbx
loc_70645:
mov rdi, r15
mov rsi, r12
call my_utf8mb3_uni_no_range
test eax, eax
jz loc_706EB
mov rdx, [r13+8]
mov rcx, [rbp+var_30]
movzx esi, ch
mov rdx, [rdx+rsi*8]
test rdx, rdx
jz short loc_7067A
movzx ecx, cl
lea rcx, [rcx+rcx*2]
mov ecx, [rdx+rcx*4]
mov [rbp+var_30], rcx
loc_7067A:
mov edx, 1
cmp rcx, 80h
jb short loc_706D4
mov edx, 2
cmp rcx, 800h
jb short loc_706BB
cmp rcx, 0FFFFh
ja short loc_706EB
mov edx, ecx
and dl, 3Fh
or dl, 80h
mov [r14+2], dl
shr rcx, 6
or rcx, 800h
mov edx, 3
loc_706BB:
mov esi, ecx
and sil, 3Fh
or sil, 80h
mov [r14+1], sil
shr rcx, 6
or rcx, 0C0h
loc_706D4:
mov [r14], cl
mov eax, eax
add r14, rdx
cmp byte ptr [r12+rax], 0
lea r12, [r12+rax]
jnz loc_70645
loc_706EB:
mov byte ptr [r14], 0
sub r14, rbx
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_caseup_str_utf8mb3(long long a1, _BYTE *a2)
{
unsigned long long v2; // rax
_BYTE *v3; // r14
long long v4; // r13
_BYTE *v5; // r12
unsigned int v6; // eax
unsigned long long v7; // rcx
long long v8; // rdx
long long v9; // rdx
bool v10; // zf
unsigned long long v12; // [rsp+0h] [rbp-30h] BYREF
v12 = v2;
v3 = a2;
if ( *a2 )
{
v4 = *(_QWORD *)(a1 + 120);
v5 = a2;
v3 = a2;
do
{
v6 = my_utf8mb3_uni_no_range(&v12, v5);
if ( !v6 )
break;
v7 = v12;
v8 = *(_QWORD *)(*(_QWORD *)(v4 + 8) + 8LL * BYTE1(v12));
if ( v8 )
{
v7 = *(unsigned int *)(v8 + 12LL * (unsigned __int8)v12);
v12 = v7;
}
v9 = 1LL;
if ( v7 >= 0x80 )
{
v9 = 2LL;
if ( v7 >= 0x800 )
{
if ( v7 > 0xFFFF )
break;
v3[2] = v7 & 0x3F | 0x80;
v7 = (v7 >> 6) | 0x800;
v9 = 3LL;
}
v3[1] = v7 & 0x3F | 0x80;
v7 = (v7 >> 6) | 0xC0;
}
*v3 = v7;
v3 += v9;
v10 = v5[v6] == 0;
v5 += v6;
}
while ( !v10 );
}
*v3 = 0;
return v3 - a2;
}
| my_caseup_str_utf8mb3:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
CMP byte ptr [RSI],0x0
MOV R14,RSI
JZ 0x001706eb
MOV R13,qword ptr [RDI + 0x78]
LEA R15,[RBP + -0x30]
MOV R12,RBX
MOV R14,RBX
LAB_00170645:
MOV RDI,R15
MOV RSI,R12
CALL 0x00170fc4
TEST EAX,EAX
JZ 0x001706eb
MOV RDX,qword ptr [R13 + 0x8]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ESI,CH
MOV RDX,qword ptr [RDX + RSI*0x8]
TEST RDX,RDX
JZ 0x0017067a
MOVZX ECX,CL
LEA RCX,[RCX + RCX*0x2]
MOV ECX,dword ptr [RDX + RCX*0x4]
MOV qword ptr [RBP + -0x30],RCX
LAB_0017067a:
MOV EDX,0x1
CMP RCX,0x80
JC 0x001706d4
MOV EDX,0x2
CMP RCX,0x800
JC 0x001706bb
CMP RCX,0xffff
JA 0x001706eb
MOV EDX,ECX
AND DL,0x3f
OR DL,0x80
MOV byte ptr [R14 + 0x2],DL
SHR RCX,0x6
OR RCX,0x800
MOV EDX,0x3
LAB_001706bb:
MOV ESI,ECX
AND SIL,0x3f
OR SIL,0x80
MOV byte ptr [R14 + 0x1],SIL
SHR RCX,0x6
OR RCX,0xc0
LAB_001706d4:
MOV byte ptr [R14],CL
MOV EAX,EAX
ADD R14,RDX
CMP byte ptr [R12 + RAX*0x1],0x0
LEA R12,[R12 + RAX*0x1]
JNZ 0x00170645
LAB_001706eb:
MOV byte ptr [R14],0x0
SUB R14,RBX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_caseup_str_utf8mb3(long param_1,char *param_2)
{
char *pcVar1;
long lVar2;
uint uVar3;
ulong in_RAX;
ulong uVar4;
long lVar5;
char *pcVar6;
char *pcVar7;
ulong local_38;
pcVar7 = param_2;
if (*param_2 != '\0') {
lVar2 = *(long *)(param_1 + 0x78);
pcVar6 = param_2;
local_38 = in_RAX;
do {
uVar3 = my_utf8mb3_uni_no_range(&local_38,pcVar6);
if (uVar3 == 0) break;
lVar5 = *(long *)(*(long *)(lVar2 + 8) + (local_38 >> 8 & 0xff) * 8);
if (lVar5 != 0) {
local_38 = (ulong)*(uint *)(lVar5 + (local_38 & 0xff) * 0xc);
}
lVar5 = 1;
uVar4 = local_38;
if (0x7f < local_38) {
lVar5 = 2;
if (0x7ff < local_38) {
if (0xffff < local_38) break;
pcVar7[2] = (byte)local_38 & 0x3f | 0x80;
uVar4 = local_38 >> 6 | 0x800;
lVar5 = 3;
}
pcVar7[1] = (byte)uVar4 & 0x3f | 0x80;
uVar4 = uVar4 >> 6 | 0xc0;
}
*pcVar7 = (char)uVar4;
pcVar7 = pcVar7 + lVar5;
pcVar1 = pcVar6 + uVar3;
pcVar6 = pcVar6 + uVar3;
} while (*pcVar1 != '\0');
}
*pcVar7 = '\0';
return (long)pcVar7 - (long)param_2;
}
| |
38,145 | ma_hashtbl_update | eloqsql/libmariadb/libmariadb/ma_hashtbl.c | my_bool ma_hashtbl_update(MA_HASHTBL *hash,uchar *record,uchar *old_key,uint old_key_length)
{
uint idx,new_index,new_pos_index,blength,records,empty;
MA_HASHTBL_LINK org_link,*data,*previous,*pos;
data=dynamic_element(&hash->array,0,MA_HASHTBL_LINK*);
blength=hash->blength; records=hash->records;
/* Search after record with key */
idx=hash_mask((*hash->calc_hashnr)(old_key,(old_key_length ?
old_key_length :
hash->key_length)),
blength,records);
new_index=hash_mask(rec_hashnr(hash,record),blength,records);
if (idx == new_index)
return(0); /* Nothing to do (No record check) */
previous=0;
for (;;)
{
if ((pos= data+idx)->data == record)
break;
previous=pos;
if ((idx=pos->next) == NO_RECORD)
return(1); /* Not found in links */
}
hash->current_record= NO_RECORD;
org_link= *pos;
empty=idx;
/* Relink record from current chain */
if (!previous)
{
if (pos->next != NO_RECORD)
{
empty=pos->next;
*pos= data[pos->next];
}
}
else
previous->next=pos->next; /* unlink pos */
/* Move data to correct position */
pos=data+new_index;
new_pos_index=hash_rec_mask(hash,pos,blength,records);
if (new_index != new_pos_index)
{ /* Other record in wrong position */
data[empty] = *pos;
movelink(data,new_index,new_pos_index,empty);
org_link.next=NO_RECORD;
data[new_index]= org_link;
}
else
{ /* Link in chain at right position */
org_link.next=data[new_index].next;
data[empty]=org_link;
data[new_index].next=empty;
}
return(0);
} | O0 | c | ma_hashtbl_update:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x5fe2c
movl -0x24(%rbp), %eax
movl %eax, -0x7c(%rbp)
jmp 0x5fe36
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x7c(%rbp)
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rdi
movl -0x7c(%rbp), %esi
callq *%rax
movl %eax, %edi
movl -0x34(%rbp), %esi
movl -0x38(%rbp), %edx
callq 0x5f3c0
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f9a0
movl %eax, %edi
movl -0x34(%rbp), %esi
movl -0x38(%rbp), %edx
callq 0x5f3c0
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0x5fe81
movb $0x0, -0x1(%rbp)
jmp 0x60005
movq $0x0, -0x60(%rbp)
movq -0x58(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x5fea7
jmp 0x5fec8
movq -0x68(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $-0x1, %eax
jne 0x5fec6
movb $0x1, -0x1(%rbp)
jmp 0x60005
jmp 0x5fe89
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x68(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpq $0x0, -0x60(%rbp)
jne 0x5ff2a
movq -0x68(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x5ff28
movq -0x68(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x68(%rbp), %rax
movq -0x58(%rbp), %rcx
movq -0x68(%rbp), %rdx
movl (%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x5ff36
movq -0x68(%rbp), %rax
movl (%rax), %ecx
movq -0x60(%rbp), %rax
movl %ecx, (%rax)
movq -0x58(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %ecx
callq 0x5f490
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
je 0x5ffbe
movq -0x58(%rbp), %rax
movl -0x3c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x68(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x58(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
movl -0x3c(%rbp), %ecx
callq 0x5f9e0
movl $0xffffffff, -0x50(%rbp) # imm = 0xFFFFFFFF
movq -0x58(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x60001
movq -0x58(%rbp), %rax
movl -0x2c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movl -0x3c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x3c(%rbp), %ecx
movq -0x58(%rbp), %rax
movl -0x2c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_hashtbl_update:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov [rbp+var_58], rax
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
mov [rbp+var_34], eax
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov [rbp+var_38], eax
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov [rbp+var_78], rax
mov rax, [rbp+var_20]
mov [rbp+var_70], rax
cmp [rbp+var_24], 0
jz short loc_5FE2C
mov eax, [rbp+var_24]
mov [rbp+var_7C], eax
jmp short loc_5FE36
loc_5FE2C:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov [rbp+var_7C], eax
loc_5FE36:
mov rax, [rbp+var_78]
mov rdi, [rbp+var_70]
mov esi, [rbp+var_7C]
call rax
mov edi, eax
mov esi, [rbp+var_34]
mov edx, [rbp+var_38]
call hash_mask
mov [rbp+var_28], eax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call rec_hashnr
mov edi, eax
mov esi, [rbp+var_34]
mov edx, [rbp+var_38]
call hash_mask
mov [rbp+var_2C], eax
mov eax, [rbp+var_28]
cmp eax, [rbp+var_2C]
jnz short loc_5FE81
mov [rbp+var_1], 0
jmp loc_60005
loc_5FE81:
mov [rbp+var_60], 0
loc_5FE89:
mov rax, [rbp+var_58]
mov ecx, [rbp+var_28]
shl rcx, 4
add rax, rcx
mov [rbp+var_68], rax
mov rax, [rax+8]
cmp rax, [rbp+var_18]
jnz short loc_5FEA7
jmp short loc_5FEC8
loc_5FEA7:
mov rax, [rbp+var_68]
mov [rbp+var_60], rax
mov rax, [rbp+var_68]
mov eax, [rax]
mov [rbp+var_28], eax
cmp eax, 0FFFFFFFFh
jnz short loc_5FEC6
mov [rbp+var_1], 1
jmp loc_60005
loc_5FEC6:
jmp short loc_5FE89
loc_5FEC8:
mov rax, [rbp+var_10]
mov dword ptr [rax+10h], 0FFFFFFFFh
mov rax, [rbp+var_68]
mov rcx, [rax]
mov [rbp+var_50], rcx
mov rax, [rax+8]
mov [rbp+var_48], rax
mov eax, [rbp+var_28]
mov [rbp+var_3C], eax
cmp [rbp+var_60], 0
jnz short loc_5FF2A
mov rax, [rbp+var_68]
cmp dword ptr [rax], 0FFFFFFFFh
jz short loc_5FF28
mov rax, [rbp+var_68]
mov eax, [rax]
mov [rbp+var_3C], eax
mov rax, [rbp+var_68]
mov rcx, [rbp+var_58]
mov rdx, [rbp+var_68]
mov edx, [rdx]
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
loc_5FF28:
jmp short loc_5FF36
loc_5FF2A:
mov rax, [rbp+var_68]
mov ecx, [rax]
mov rax, [rbp+var_60]
mov [rax], ecx
loc_5FF36:
mov rax, [rbp+var_58]
mov ecx, [rbp+var_2C]
shl rcx, 4
add rax, rcx
mov [rbp+var_68], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_68]
mov edx, [rbp+var_34]
mov ecx, [rbp+var_38]
call hash_rec_mask
mov [rbp+var_30], eax
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_30]
jz short loc_5FFBE
mov rax, [rbp+var_58]
mov ecx, [rbp+var_3C]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+var_68]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rdi, [rbp+var_58]
mov esi, [rbp+var_2C]
mov edx, [rbp+var_30]
mov ecx, [rbp+var_3C]
call movelink
mov dword ptr [rbp+var_50], 0FFFFFFFFh
mov rax, [rbp+var_58]
mov ecx, [rbp+var_2C]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+var_50]
mov [rax], rcx
mov rcx, [rbp+var_48]
mov [rax+8], rcx
jmp short loc_60001
loc_5FFBE:
mov rax, [rbp+var_58]
mov ecx, [rbp+var_2C]
shl rcx, 4
add rax, rcx
mov eax, [rax]
mov dword ptr [rbp+var_50], eax
mov rax, [rbp+var_58]
mov ecx, [rbp+var_3C]
shl rcx, 4
add rax, rcx
mov rcx, [rbp+var_50]
mov [rax], rcx
mov rcx, [rbp+var_48]
mov [rax+8], rcx
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_58]
mov edx, [rbp+var_2C]
shl rdx, 4
add rax, rdx
mov [rax], ecx
loc_60001:
mov [rbp+var_1], 0
loc_60005:
mov al, [rbp+var_1]
add rsp, 80h
pop rbp
retn
| char ma_hashtbl_update(long long a1, long long a2, long long a3, unsigned int a4)
{
unsigned int v4; // eax
unsigned int v5; // eax
long long v6; // rdx
_QWORD *v7; // rax
_QWORD *v8; // rax
_QWORD *v9; // rax
unsigned int v11; // [rsp+4h] [rbp-7Ch]
unsigned int *v12; // [rsp+18h] [rbp-68h]
_QWORD *v13; // [rsp+18h] [rbp-68h]
_DWORD *v14; // [rsp+20h] [rbp-60h]
long long v15; // [rsp+28h] [rbp-58h]
long long v16; // [rsp+30h] [rbp-50h]
long long v17; // [rsp+38h] [rbp-48h]
unsigned int v18; // [rsp+44h] [rbp-3Ch]
unsigned int v19; // [rsp+48h] [rbp-38h]
unsigned int v20; // [rsp+4Ch] [rbp-34h]
unsigned int v21; // [rsp+50h] [rbp-30h]
unsigned int v22; // [rsp+54h] [rbp-2Ch]
unsigned int v23; // [rsp+58h] [rbp-28h]
v15 = *(_QWORD *)(a1 + 24);
v20 = *(_DWORD *)(a1 + 12);
v19 = *(_DWORD *)(a1 + 8);
if ( a4 )
v11 = a4;
else
v11 = *(_DWORD *)(a1 + 4);
v4 = (*(long long ( **)(long long, _QWORD))(a1 + 64))(a3, v11);
v23 = hash_mask(v4, v20, v19);
v5 = rec_hashnr(a1, a2);
v22 = hash_mask(v5, v20, v19);
if ( v23 == v22 )
return 0;
v14 = 0LL;
while ( 1 )
{
v12 = (unsigned int *)(16LL * v23 + v15);
if ( *((_QWORD *)v12 + 1) == a2 )
break;
v14 = (_DWORD *)(16LL * v23 + v15);
v23 = *v12;
if ( *v12 == -1 )
return 1;
}
*(_DWORD *)(a1 + 16) = -1;
v16 = *(_QWORD *)v12;
v17 = *((_QWORD *)v12 + 1);
v18 = v23;
if ( v14 )
{
*v14 = *v12;
}
else if ( *v12 != -1 )
{
v18 = *v12;
v6 = 16LL * *v12;
*(_QWORD *)v12 = *(_QWORD *)(v6 + v15);
*((_QWORD *)v12 + 1) = *(_QWORD *)(v6 + v15 + 8);
}
v13 = (_QWORD *)(16LL * v22 + v15);
v21 = hash_rec_mask(a1, (long long)v13, v20, v19);
if ( v22 == v21 )
{
LODWORD(v16) = *(_DWORD *)(16LL * v22 + v15);
v9 = (_QWORD *)(16LL * v18 + v15);
*v9 = v16;
v9[1] = v17;
*(_DWORD *)(16LL * v22 + v15) = v18;
}
else
{
v7 = (_QWORD *)(16LL * v18 + v15);
*v7 = *v13;
v7[1] = v13[1];
movelink(v15, v22, v21, v18);
LODWORD(v16) = -1;
v8 = (_QWORD *)(16LL * v22 + v15);
*v8 = v16;
v8[1] = v17;
}
return 0;
}
| ma_hashtbl_update:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x70],RAX
CMP dword ptr [RBP + -0x24],0x0
JZ 0x0015fe2c
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x7c],EAX
JMP 0x0015fe36
LAB_0015fe2c:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x7c],EAX
LAB_0015fe36:
MOV RAX,qword ptr [RBP + -0x78]
MOV RDI,qword ptr [RBP + -0x70]
MOV ESI,dword ptr [RBP + -0x7c]
CALL RAX
MOV EDI,EAX
MOV ESI,dword ptr [RBP + -0x34]
MOV EDX,dword ptr [RBP + -0x38]
CALL 0x0015f3c0
MOV dword ptr [RBP + -0x28],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0015f9a0
MOV EDI,EAX
MOV ESI,dword ptr [RBP + -0x34]
MOV EDX,dword ptr [RBP + -0x38]
CALL 0x0015f3c0
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x2c]
JNZ 0x0015fe81
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00160005
LAB_0015fe81:
MOV qword ptr [RBP + -0x60],0x0
LAB_0015fe89:
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x28]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x0015fea7
JMP 0x0015fec8
LAB_0015fea7:
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x28],EAX
CMP EAX,-0x1
JNZ 0x0015fec6
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00160005
LAB_0015fec6:
JMP 0x0015fe89
LAB_0015fec8:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x10],0xffffffff
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x3c],EAX
CMP qword ptr [RBP + -0x60],0x0
JNZ 0x0015ff2a
MOV RAX,qword ptr [RBP + -0x68]
CMP dword ptr [RAX],-0x1
JZ 0x0015ff28
MOV RAX,qword ptr [RBP + -0x68]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x68]
MOV EDX,dword ptr [RDX]
SHL RDX,0x4
ADD RCX,RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
LAB_0015ff28:
JMP 0x0015ff36
LAB_0015ff2a:
MOV RAX,qword ptr [RBP + -0x68]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX],ECX
LAB_0015ff36:
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x2c]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x68]
MOV EDX,dword ptr [RBP + -0x34]
MOV ECX,dword ptr [RBP + -0x38]
CALL 0x0015f490
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x30]
JZ 0x0015ffbe
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x3c]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x58]
MOV ESI,dword ptr [RBP + -0x2c]
MOV EDX,dword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x3c]
CALL 0x0015f9e0
MOV dword ptr [RBP + -0x50],0xffffffff
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x2c]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x00160001
LAB_0015ffbe:
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x2c]
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x50],EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RBP + -0x3c]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x58]
MOV EDX,dword ptr [RBP + -0x2c]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX],ECX
LAB_00160001:
MOV byte ptr [RBP + -0x1],0x0
LAB_00160005:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x80
POP RBP
RET
|
int8 ma_hashtbl_update(long param_1,long param_2,int8 param_3,int param_4)
{
int4 uVar1;
int4 uVar2;
long lVar3;
int8 uVar4;
int8 uVar5;
int4 uVar6;
uint uVar7;
uint uVar8;
uint *puVar9;
int8 *puVar10;
uint *puVar11;
int8 *puVar12;
int local_84;
uint *local_68;
int8 local_58;
uint local_44;
uint local_30;
int1 local_9;
lVar3 = *(long *)(param_1 + 0x18);
uVar1 = *(int4 *)(param_1 + 0xc);
uVar2 = *(int4 *)(param_1 + 8);
local_84 = param_4;
if (param_4 == 0) {
local_84 = *(int *)(param_1 + 4);
}
uVar6 = (**(code **)(param_1 + 0x40))(param_3,local_84);
local_30 = hash_mask(uVar6,uVar1,uVar2);
uVar6 = rec_hashnr(param_1,param_2);
uVar7 = hash_mask(uVar6,uVar1,uVar2);
puVar11 = (uint *)(ulong)local_30;
if (local_30 == uVar7) {
local_9 = 0;
}
else {
local_68 = (uint *)0x0;
do {
puVar9 = (uint *)(lVar3 + (ulong)local_30 * 0x10);
if (*(long *)(puVar9 + 2) == param_2) {
*(int4 *)(param_1 + 0x10) = 0xffffffff;
uVar4 = *(int8 *)puVar9;
uVar5 = *(int8 *)(puVar9 + 2);
local_44 = local_30;
if (local_68 == (uint *)0x0) {
if (*puVar9 != 0xffffffff) {
local_44 = *puVar9;
puVar12 = (int8 *)(lVar3 + (ulong)*puVar9 * 0x10);
*(int8 *)puVar9 = *puVar12;
*(int8 *)(puVar9 + 2) = puVar12[1];
}
}
else {
*local_68 = *puVar9;
}
puVar12 = (int8 *)(lVar3 + (ulong)uVar7 * 0x10);
uVar8 = hash_rec_mask(param_1,puVar12,uVar1,uVar2);
local_58._4_4_ = (int4)((ulong)uVar4 >> 0x20);
if (uVar7 == uVar8) {
local_58 = CONCAT44(local_58._4_4_,*(int4 *)(lVar3 + (ulong)uVar7 * 0x10));
puVar12 = (int8 *)(lVar3 + (ulong)local_44 * 0x10);
*puVar12 = local_58;
puVar12[1] = uVar5;
puVar11 = (uint *)(lVar3 + (ulong)uVar7 * 0x10);
*puVar11 = local_44;
}
else {
puVar10 = (int8 *)(lVar3 + (ulong)local_44 * 0x10);
*puVar10 = *puVar12;
puVar10[1] = puVar12[1];
movelink(lVar3,uVar7,uVar8,local_44);
local_58 = CONCAT44(local_58._4_4_,0xffffffff);
puVar11 = (uint *)(lVar3 + (ulong)uVar7 * 0x10);
*(int8 *)puVar11 = local_58;
*(int8 *)(puVar11 + 2) = uVar5;
}
local_9 = 0;
goto LAB_00160005;
}
local_30 = *puVar9;
puVar11 = (uint *)(ulong)local_30;
local_68 = puVar9;
} while (local_30 != 0xffffffff);
local_9 = 1;
}
LAB_00160005:
return CONCAT71((int7)((ulong)puVar11 >> 8),local_9);
}
| |
38,146 | Note::Note() | 11AgReS1SoR11[P]Graph/Common/Figures/Note.cpp | Note::Note()
{
id = "note_" + std::to_string(nextId++);
} | O0 | cpp | Note::Note():
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x99d0
movq -0x78(%rbp), %rax
movq 0x4531(%rip), %rcx # 0x12fc8
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x1, 0x5c(%rax)
movl $0x1, 0x60(%rax)
addq $0x68, %rax
movq %rax, -0x70(%rbp)
leaq -0x9(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x9ac0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x6e7(%rip), %rsi # 0xf1b7
callq 0x9a80
jmp 0xead7
leaq -0x9(%rbp), %rdi
callq 0x9670
movq 0x4b29(%rip), %rsi # 0x13610
movq %rsi, %rax
incq %rax
movq %rax, 0x4b1c(%rip) # 0x13610
leaq -0x60(%rbp), %rdi
callq 0x9200
jmp 0xeaff
leaq 0x9b0(%rip), %rsi # 0xf4b6
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x9a60
jmp 0xeb15
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
callq 0x9740
leaq -0x40(%rbp), %rdi
callq 0x93d0
leaq -0x60(%rbp), %rdi
callq 0x93d0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x9670
jmp 0xeb84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xeb7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x93d0
movq -0x70(%rbp), %rdi
callq 0x93d0
movq -0x78(%rbp), %rdi
callq 0x90a0
movq -0x18(%rbp), %rdi
callq 0x9ab0
nopw %cs:(%rax,%rax)
| _ZN4NoteC2Ev:
push rbp; Alternative name is 'Note::Note(void)'
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
mov [rbp+var_78], rdi
call __ZN5ShapeC2Ev; Shape::Shape(void)
mov rax, [rbp+var_78]
mov rcx, cs:_ZTV4Note_ptr
add rcx, 10h
mov [rax], rcx
mov dword ptr [rax+5Ch], 1
mov dword ptr [rax+60h], 1
add rax, 68h ; 'h'
mov [rbp+var_70], rax
lea rdi, [rbp+var_9]
mov [rbp+var_68], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rbp+var_70]
mov rdx, [rbp+var_68]
lea rsi, asc_F1B5+2; ""
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_EAD7:
lea rdi, [rbp+var_9]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov rsi, cs:_ZL6nextId_0; unsigned __int64
mov rax, rsi
inc rax
mov cs:_ZL6nextId_0, rax; nextId
lea rdi, [rbp+var_60]; this
call __ZNSt7__cxx119to_stringEm; std::to_string(ulong)
jmp short $+2
loc_EAFF:
lea rsi, aNote; "note_"
lea rdi, [rbp+var_40]
lea rdx, [rbp+var_60]
call __ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_EB15:
mov rdi, [rbp+var_78]
add rdi, 8
lea rsi, [rbp+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
lea rdi, [rbp+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_60]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
add rsp, 80h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_18], rcx
mov [rbp+var_1C], eax
lea rdi, [rbp+var_9]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_EB84
mov rcx, rax
mov eax, edx
mov [rbp+var_18], rcx
mov [rbp+var_1C], eax
jmp short loc_EB7B
mov rcx, rax
mov eax, edx
mov [rbp+var_18], rcx
mov [rbp+var_1C], eax
lea rdi, [rbp+var_60]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_EB7B:
mov rdi, [rbp+var_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_EB84:
mov rdi, [rbp+var_78]; this
call __ZN5ShapeD2Ev; Shape::~Shape()
mov rdi, [rbp+var_18]
call __Unwind_Resume
| void Note::Note(Note *this)
{
unsigned long long v1; // rsi
_BYTE v2[32]; // [rsp+20h] [rbp-60h] BYREF
_BYTE v3[36]; // [rsp+40h] [rbp-40h] BYREF
char v4; // [rsp+77h] [rbp-9h] BYREF
Shape *v5; // [rsp+78h] [rbp-8h]
v5 = this;
Shape::Shape(this);
*(_QWORD *)this = &`vtable for'Note + 2;
*((_DWORD *)this + 23) = 1;
*((_DWORD *)this + 24) = 1;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((char *)this + 104, "", &v4);
std::allocator<char>::~allocator(&v4);
v1 = nextId++;
std::to_string((std::__cxx11 *)v2, v1);
std::operator+<char>(v3, "note_", v2);
std::string::operator=((char *)this + 8, v3);
std::string::~string(v3);
std::string::~string(v2);
}
| Note:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x78],RDI
CALL 0x001099d0
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [0x00112fc8]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
MOV dword ptr [RAX + 0x5c],0x1
MOV dword ptr [RAX + 0x60],0x1
ADD RAX,0x68
MOV qword ptr [RBP + -0x70],RAX
LEA RDI,[RBP + -0x9]
MOV qword ptr [RBP + -0x68],RDI
CALL 0x00109ac0
MOV RDI,qword ptr [RBP + -0x70]
MOV RDX,qword ptr [RBP + -0x68]
LAB_0010eac9:
LEA RSI,[0x10f1b7]
CALL 0x00109a80
JMP 0x0010ead7
LAB_0010ead7:
LEA RDI,[RBP + -0x9]
CALL 0x00109670
MOV RSI,qword ptr [0x00113610]
MOV RAX,RSI
INC RAX
MOV qword ptr [0x00113610],RAX
LAB_0010eaf4:
LEA RDI,[RBP + -0x60]
CALL 0x00109200
JMP 0x0010eaff
LAB_0010eaff:
LEA RSI,[0x10f4b6]
LEA RDI,[RBP + -0x40]
LEA RDX,[RBP + -0x60]
CALL 0x00109a60
LAB_0010eb13:
JMP 0x0010eb15
LAB_0010eb15:
MOV RDI,qword ptr [RBP + -0x78]
ADD RDI,0x8
LEA RSI,[RBP + -0x40]
CALL 0x00109740
LEA RDI,[RBP + -0x40]
CALL 0x001093d0
LEA RDI,[RBP + -0x60]
CALL 0x001093d0
ADD RSP,0x80
POP RBP
RET
|
/* Note::Note() */
void __thiscall Note::Note(Note *this)
{
ulong uVar1;
__cxx11 local_68 [32];
string local_48 [55];
allocator local_11;
Note *local_10;
local_10 = this;
Shape::Shape((Shape *)this);
*(int **)this = PTR_vtable_00112fc8 + 0x10;
*(int4 *)(this + 0x5c) = 1;
*(int4 *)(this + 0x60) = 1;
std::allocator<char>::allocator();
/* try { // try from 0010eac9 to 0010ead4 has its CatchHandler @ 0010eb41 */
std::__cxx11::string::string<std::allocator<char>>((string *)(this + 0x68),"",&local_11);
std::allocator<char>::~allocator((allocator<char> *)&local_11);
uVar1 = nextId;
nextId = nextId + 1;
/* try { // try from 0010eaf4 to 0010eafc has its CatchHandler @ 0010eb58 */
std::__cxx11::to_string(local_68,uVar1);
/* try { // try from 0010eaff to 0010eb12 has its CatchHandler @ 0010eb66 */
std::operator+((char *)local_48,(string *)"note_");
std::__cxx11::string::operator=((string *)(this + 8),local_48);
std::__cxx11::string::~string(local_48);
std::__cxx11::string::~string((string *)local_68);
return;
}
| |
38,147 | Note::Note() | 11AgReS1SoR11[P]Graph/Common/Figures/Note.cpp | Note::Note()
{
id = "note_" + std::to_string(nextId++);
} | O1 | cpp | Note::Note():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movw $0x0, 0x48(%rdi)
movsd 0xcc9(%rip), %xmm0 # 0x8210
movups %xmm0, 0x4c(%rdi)
movq 0x3a76(%rip), %rax # 0xafc8
addq $0x10, %rax
movq %rax, (%rdi)
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x5c(%rdi)
leaq 0x68(%rdi), %r14
leaq 0x78(%rdi), %r13
movq %r13, 0x68(%rdi)
leaq 0xc3d(%rip), %rdx # 0x81b7
movq %r14, %rdi
movq %rdx, %rsi
callq 0x30e0
movq 0x3c1c(%rip), %r15 # 0xb1a8
leaq 0x1(%r15), %rax
movq %rax, 0x3c11(%rip) # 0xb1a8
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x75f1
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x75ea
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0x75ef
cmpq $0x2710, %rcx # imm = 0x2710
jb 0x75f1
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0x75b4
addl $-0x3, %esi
jmp 0x75f1
addl $-0x2, %esi
jmp 0x75f1
decl %esi
movl %esi, %esi
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x3230
leaq 0x8(%rsp), %r12
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x31d0
leaq 0xe95(%rip), %rcx # 0x84ba
movl $0x5, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3210
addq $0x8, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x7662
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x7669
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3240
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x76a5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31f0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x76bc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31f0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x76ea
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31f0
jmp 0x76ea
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x7703
movq (%r13), %rsi
incq %rsi
callq 0x31f0
jmp 0x7703
movq %rax, %r15
movq %rbx, %rdi
callq 0x3040
movq %r15, %rdi
callq 0x32e0
nop
| _ZN4NoteC2Ev:
push rbp; Alternative name is 'Note::Note(void)'
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rdi
lea rax, [rdi+18h]
mov [rdi+8], rax
xor eax, eax
mov [rdi+10h], rax
mov [rdi+18h], al
lea rcx, [rdi+38h]
mov [rdi+28h], rcx
mov [rdi+30h], rax
mov [rdi+38h], al
mov word ptr [rdi+48h], 0
movsd xmm0, cs:qword_8210
movups xmmword ptr [rdi+4Ch], xmm0
mov rax, cs:_ZTV4Note_ptr
add rax, 10h
mov [rdi], rax
mov rax, 100000001h
mov [rdi+5Ch], rax
lea r14, [rdi+68h]
lea r13, [rdi+78h]
mov [rdi+68h], r13
lea rdx, asc_81B5+2; ""
mov rdi, r14
mov rsi, rdx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov r15, cs:_ZL6nextId_0; nextId
lea rax, [r15+1]
mov cs:_ZL6nextId_0, rax; nextId
mov esi, 1
cmp r15, 0Ah
jb short loc_75F1
mov esi, 4
mov rdi, 346DC5D63886594Bh
mov rcx, r15
loc_75B4:
cmp rcx, 63h ; 'c'
jbe short loc_75EA
cmp rcx, 3E7h
jbe short loc_75EF
cmp rcx, 2710h
jb short loc_75F1
mov rax, rcx
mul rdi
shr rdx, 0Bh
add esi, 4
cmp rcx, 1869Fh
mov rcx, rdx
ja short loc_75B4
add esi, 0FFFFFFFDh
jmp short loc_75F1
loc_75EA:
add esi, 0FFFFFFFEh
jmp short loc_75F1
loc_75EF:
dec esi
loc_75F1:
mov esi, esi
lea rbp, [rsp+78h+var_60]
mov [rbp-10h], rbp
lea rdi, [rsp+78h+var_70]
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
lea r12, [rsp+78h+var_70]
mov rdi, [r12]
mov esi, [r12+8]
mov rdx, r15
call __ZNSt8__detail18__to_chars_10_implImEEvPcjT_; std::__detail::__to_chars_10_impl<ulong>(char *,uint,ulong)
lea rcx, aNote; "note_"
mov r8d, 5
mov rdi, r12
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
add rbx, 8
lea r15, [rsp+78h+var_40]
mov [r15-10h], r15
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_7662
mov [rsp+78h+var_50], rdx
mov rdx, [rcx]
mov [rsp+78h+var_40], rdx
jmp short loc_7669
loc_7662:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r15], xmm0
loc_7669:
mov rdx, [rax+8]
lea r14, [rsp+78h+var_50]
mov [r14+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r14]; void *
cmp rdi, r15
jz short loc_76A5
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_76A5:
mov rdi, [rsp+78h+var_70]; void *
cmp rdi, rbp
jz short loc_76BC
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_76BC:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r15, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, rbp
jz short loc_76EA
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_76EA
mov r15, rax
loc_76EA:
mov rdi, [r14]; void *
cmp rdi, r13
jz short loc_7703
mov rsi, [r13+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7703
mov r15, rax
loc_7703:
mov rdi, rbx; this
call __ZN5ShapeD2Ev; Shape::~Shape()
mov rdi, r15
call __Unwind_Resume
| void Note::Note(Note *this)
{
unsigned long long v1; // r15
unsigned int v2; // esi
unsigned long long v3; // rcx
bool v4; // cc
long long v5; // rax
_OWORD *v6; // rcx
void *v7; // [rsp+8h] [rbp-70h] BYREF
unsigned int v8; // [rsp+10h] [rbp-68h]
_QWORD v9[2]; // [rsp+18h] [rbp-60h] BYREF
void *v10[2]; // [rsp+28h] [rbp-50h] BYREF
_OWORD v11[4]; // [rsp+38h] [rbp-40h] BYREF
*((_QWORD *)this + 1) = (char *)this + 24;
*((_QWORD *)this + 2) = 0LL;
*((_BYTE *)this + 24) = 0;
*((_QWORD *)this + 5) = (char *)this + 56;
*((_QWORD *)this + 6) = 0LL;
*((_BYTE *)this + 56) = 0;
*((_WORD *)this + 36) = 0;
*(_OWORD *)((char *)this + 76) = 0xA00000001uLL;
*(_QWORD *)this = &`vtable for'Note + 2;
*(_QWORD *)((char *)this + 92) = 0x100000001LL;
*((_QWORD *)this + 13) = (char *)this + 120;
std::string::_M_construct<char const*>((char *)this + 104, "", "");
v1 = nextId++;
v2 = 1;
if ( v1 >= 0xA )
{
v2 = 4;
v3 = v1;
while ( 1 )
{
if ( v3 <= 0x63 )
{
v2 -= 2;
goto LABEL_10;
}
if ( v3 <= 0x3E7 )
break;
if ( v3 < 0x2710 )
goto LABEL_10;
v2 += 4;
v4 = v3 <= 0x1869F;
v3 /= 0x2710uLL;
if ( v4 )
{
v2 -= 3;
goto LABEL_10;
}
}
--v2;
}
LABEL_10:
v7 = v9;
std::string::_M_construct(&v7, v2, 0LL);
std::__detail::__to_chars_10_impl<unsigned long>(v7, v8, v1);
v5 = std::string::replace(&v7, 0LL, 0LL, "note_", 5LL);
v10[0] = v11;
v6 = (_OWORD *)(v5 + 16);
if ( *(_QWORD *)v5 == v5 + 16 )
{
v11[0] = *v6;
}
else
{
v10[0] = *(void **)v5;
*(_QWORD *)&v11[0] = *(_QWORD *)v6;
}
v10[1] = *(void **)(v5 + 8);
*(_QWORD *)v5 = v6;
*(_QWORD *)(v5 + 8) = 0LL;
*(_BYTE *)(v5 + 16) = 0;
std::string::operator=((char *)this + 8, v10);
if ( v10[0] != v11 )
operator delete(v10[0], *(_QWORD *)&v11[0] + 1LL);
if ( v7 != v9 )
operator delete(v7, v9[0] + 1LL);
}
| Note:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RDI
LEA RAX,[RDI + 0x18]
MOV qword ptr [RDI + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],RAX
MOV byte ptr [RDI + 0x18],AL
LEA RCX,[RDI + 0x38]
MOV qword ptr [RDI + 0x28],RCX
MOV qword ptr [RDI + 0x30],RAX
MOV byte ptr [RDI + 0x38],AL
MOV word ptr [RDI + 0x48],0x0
MOVSD XMM0,qword ptr [0x00108210]
MOVUPS xmmword ptr [RDI + 0x4c],XMM0
MOV RAX,qword ptr [0x0010afc8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RAX,0x100000001
MOV qword ptr [RDI + 0x5c],RAX
LEA R14,[RDI + 0x68]
LEA R13,[RDI + 0x78]
MOV qword ptr [RDI + 0x68],R13
LAB_00107573:
LEA RDX,[0x1081b7]
MOV RDI,R14
MOV RSI,RDX
CALL 0x001030e0
MOV R15,qword ptr [0x0010b1a8]
LEA RAX,[R15 + 0x1]
MOV qword ptr [0x0010b1a8],RAX
MOV ESI,0x1
CMP R15,0xa
JC 0x001075f1
MOV ESI,0x4
MOV RDI,0x346dc5d63886594b
MOV RCX,R15
LAB_001075b4:
CMP RCX,0x63
JBE 0x001075ea
CMP RCX,0x3e7
JBE 0x001075ef
CMP RCX,0x2710
JC 0x001075f1
MOV RAX,RCX
MUL RDI
SHR RDX,0xb
ADD ESI,0x4
CMP RCX,0x1869f
MOV RCX,RDX
JA 0x001075b4
ADD ESI,-0x3
JMP 0x001075f1
LAB_001075ea:
ADD ESI,-0x2
JMP 0x001075f1
LAB_001075ef:
DEC ESI
LAB_001075f1:
MOV ESI,ESI
LEA RBP,[RSP + 0x18]
MOV qword ptr [RBP + -0x10],RBP
LAB_001075fc:
LEA RDI,[RSP + 0x8]
XOR EDX,EDX
CALL 0x00103230
LEA R12,[RSP + 0x8]
MOV RDI,qword ptr [R12]
MOV ESI,dword ptr [R12 + 0x8]
MOV RDX,R15
CALL 0x001031d0
LAB_0010761e:
LEA RCX,[0x1084ba]
MOV R8D,0x5
MOV RDI,R12
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00103210
LAB_00107637:
ADD RBX,0x8
LEA R15,[RSP + 0x38]
MOV qword ptr [R15 + -0x10],R15
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00107662
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x38],RDX
JMP 0x00107669
LAB_00107662:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R15],XMM0
LAB_00107669:
MOV RDX,qword ptr [RAX + 0x8]
LEA R14,[RSP + 0x28]
MOV qword ptr [R14 + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,RBX
MOV RSI,R14
CALL 0x00103240
MOV RDI,qword ptr [R14]
CMP RDI,R15
JZ 0x001076a5
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001031f0
LAB_001076a5:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,RBP
JZ 0x001076bc
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001031f0
LAB_001076bc:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Note::Note() */
void __thiscall Note::Note(Note *this)
{
bool bVar1;
ulong uVar2;
char cVar3;
long *plVar4;
ulong uVar5;
long *plVar6;
char cVar7;
long *local_70;
uint local_68;
long local_60 [2];
long *local_50;
long local_48;
long local_40;
long lStack_38;
*(Note **)(this + 8) = this + 0x18;
*(int8 *)(this + 0x10) = 0;
this[0x18] = (Note)0x0;
*(Note **)(this + 0x28) = this + 0x38;
*(int8 *)(this + 0x30) = 0;
this[0x38] = (Note)0x0;
*(int2 *)(this + 0x48) = 0;
*(int8 *)(this + 0x4c) = DAT_00108210;
*(int8 *)(this + 0x54) = 0;
*(int **)this = PTR_vtable_0010afc8 + 0x10;
*(int8 *)(this + 0x5c) = 0x100000001;
*(Note **)(this + 0x68) = this + 0x78;
/* try { // try from 00107573 to 00107584 has its CatchHandler @ 00107700 */
std::__cxx11::string::_M_construct<char_const*>(this + 0x68,&DAT_001081b7);
uVar2 = nextId;
cVar7 = '\x01';
if (9 < nextId) {
uVar5 = nextId;
cVar3 = '\x04';
do {
cVar7 = cVar3;
if (uVar5 < 100) {
cVar7 = cVar7 + -2;
goto LAB_001075f1;
}
if (uVar5 < 1000) {
cVar7 = cVar7 + -1;
goto LAB_001075f1;
}
if (uVar5 < 10000) goto LAB_001075f1;
bVar1 = 99999 < uVar5;
uVar5 = uVar5 / 10000;
cVar3 = cVar7 + '\x04';
} while (bVar1);
cVar7 = cVar7 + '\x01';
}
LAB_001075f1:
/* try { // try from 001075fc to 00107607 has its CatchHandler @ 001076e7 */
nextId = nextId + 1;
local_70 = local_60;
std::__cxx11::string::_M_construct((ulong)&local_70,cVar7);
std::__detail::__to_chars_10_impl<unsigned_long>((char *)local_70,local_68,uVar2);
/* try { // try from 0010761e to 00107636 has its CatchHandler @ 001076cb */
plVar4 = (long *)std::__cxx11::string::replace((ulong)&local_70,0,(char *)0x0,0x1084ba);
plVar6 = plVar4 + 2;
if ((long *)*plVar4 == plVar6) {
local_40 = *plVar6;
lStack_38 = plVar4[3];
local_50 = &local_40;
}
else {
local_40 = *plVar6;
local_50 = (long *)*plVar4;
}
local_48 = plVar4[1];
*plVar4 = (long)plVar6;
plVar4[1] = 0;
*(int1 *)(plVar4 + 2) = 0;
std::__cxx11::string::operator=((string *)(this + 8),(string *)&local_50);
if (local_50 != &local_40) {
operator_delete(local_50,local_40 + 1);
}
if (local_70 != local_60) {
operator_delete(local_70,local_60[0] + 1);
}
return;
}
| |
38,148 | Note::Note() | 11AgReS1SoR11[P]Graph/Common/Figures/Note.cpp | Note::Note()
{
id = "note_" + std::to_string(nextId++);
} | O2 | cpp | Note::Note():
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x43e0
movq 0x3ac4(%rip), %rax # 0x9fc8
addq $0x10, %rax
movq %rax, (%rbx)
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x5c(%rbx)
leaq 0x68(%rbx), %r14
leaq 0xc93(%rip), %rsi # 0x71b7
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
callq 0x4450
movq 0x3d50(%rip), %rsi # 0xa288
leaq 0x1(%rsi), %rax
movq %rax, 0x3d45(%rip) # 0xa288
movq %rsp, %rdi
callq 0x4120
leaq 0xf68(%rip), %rsi # 0x74ba
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x4440
addq $0x8, %rbx
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4300
movq %r14, %rdi
callq 0x4180
movq %rsp, %rdi
callq 0x4180
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %rsp, %rdi
callq 0x4180
jmp 0x659d
movq %rax, %r15
movq %r14, %rdi
callq 0x4180
jmp 0x65aa
movq %rax, %r15
movq %rbx, %rdi
callq 0x4040
movq %r15, %rdi
callq 0x4460
| _ZN4NoteC2Ev:
push r15; Alternative name is 'Note::Note(void)'
push r14
push rbx
sub rsp, 40h
mov rbx, rdi
call __ZN5ShapeC2Ev; Shape::Shape(void)
mov rax, cs:_ZTV4Note_ptr
add rax, 10h
mov [rbx], rax
mov rax, 100000001h
mov [rbx+5Ch], rax
lea r14, [rbx+68h]
lea rsi, asc_71B5+2; ""
lea rdx, [rsp+58h+var_38]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rsi, cs:_ZL6nextId_0; unsigned __int64
lea rax, [rsi+1]
mov cs:_ZL6nextId_0, rax; nextId
mov rdi, rsp; this
call __ZNSt7__cxx119to_stringEm; std::to_string(ulong)
lea rsi, aNote; "note_"
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&&)
add rbx, 8
lea r14, [rsp+58h+var_38]
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add rsp, 40h
pop rbx
pop r14
pop r15
retn
mov r15, rax
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_659D
mov r15, rax
loc_659D:
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_65AA
mov r15, rax
loc_65AA:
mov rdi, rbx; this
call __ZN5ShapeD2Ev; Shape::~Shape()
mov rdi, r15
call __Unwind_Resume
| void Note::Note(Note *this)
{
unsigned long long v1; // rsi
_BYTE v2[32]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v3[56]; // [rsp+20h] [rbp-38h] BYREF
Shape::Shape(this);
*(_QWORD *)this = &`vtable for'Note + 2;
*(_QWORD *)((char *)this + 92) = 0x100000001LL;
std::string::basic_string<std::allocator<char>>((char *)this + 104, "", v3);
v1 = nextId++;
std::to_string((std::__cxx11 *)v2, v1);
std::operator+<char>(v3, "note_", v2);
std::string::operator=((char *)this + 8, v3);
std::string::~string(v3);
std::string::~string(v2);
}
| Note:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
CALL 0x001043e0
MOV RAX,qword ptr [0x00109fc8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RAX,0x100000001
MOV qword ptr [RBX + 0x5c],RAX
LEA R14,[RBX + 0x68]
LAB_0010651d:
LEA RSI,[0x1071b7]
LEA RDX,[RSP + 0x20]
MOV RDI,R14
CALL 0x00104450
MOV RSI,qword ptr [0x0010a288]
LEA RAX,[RSI + 0x1]
MOV qword ptr [0x0010a288],RAX
LAB_00106543:
MOV RDI,RSP
CALL 0x00104120
LAB_0010654b:
LEA RSI,[0x1074ba]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00104440
LAB_0010655f:
ADD RBX,0x8
LEA R14,[RSP + 0x20]
MOV RDI,RBX
MOV RSI,R14
CALL 0x00104300
MOV RDI,R14
CALL 0x00104180
MOV RDI,RSP
CALL 0x00104180
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
|
/* Note::Note() */
void __thiscall Note::Note(Note *this)
{
ulong uVar1;
__cxx11 a_Stack_58 [32];
allocator local_38 [32];
Shape::Shape((Shape *)this);
*(int **)this = PTR_vtable_00109fc8 + 0x10;
*(int8 *)(this + 0x5c) = 0x100000001;
/* try { // try from 0010651d to 00106530 has its CatchHandler @ 001065a7 */
std::__cxx11::string::string<std::allocator<char>>((string *)(this + 0x68),"",local_38);
uVar1 = nextId;
nextId = nextId + 1;
/* try { // try from 00106543 to 0010654a has its CatchHandler @ 0010659a */
std::__cxx11::to_string(a_Stack_58,uVar1);
/* try { // try from 0010654b to 0010655e has its CatchHandler @ 0010658d */
std::operator+((char *)local_38,(string *)"note_");
std::__cxx11::string::operator=((string *)(this + 8),(string *)local_38);
std::__cxx11::string::~string((string *)local_38);
std::__cxx11::string::~string((string *)a_Stack_58);
return;
}
| |
38,149 | pvio_socket_wait_io_or_timeout | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | int pvio_socket_wait_io_or_timeout(MARIADB_PVIO *pvio, my_bool is_read, int timeout)
{
int rc;
struct st_pvio_socket *csock= NULL;
#ifndef _WIN32
struct pollfd p_fd;
#else
struct timeval tv= {0,0};
fd_set fds, exc_fds;
#endif
if (!pvio || !pvio->data)
return 0;
if (pvio->mysql->options.extension &&
pvio->mysql->options.extension->io_wait != NULL) {
my_socket handle;
if (pvio_socket_get_handle(pvio, &handle))
return 0;
return pvio->mysql->options.extension->io_wait(handle, is_read, timeout);
}
csock= (struct st_pvio_socket *)pvio->data;
{
#ifndef _WIN32
memset(&p_fd, 0, sizeof(p_fd));
p_fd.fd= csock->socket;
p_fd.events= (is_read) ? POLLIN : POLLOUT;
if (!timeout)
timeout= -1;
do {
rc= poll(&p_fd, 1, timeout);
} while (rc == -1 && errno == EINTR);
if (rc == 0)
errno= ETIMEDOUT;
#else
FD_ZERO(&fds);
FD_ZERO(&exc_fds);
FD_SET(csock->socket, &fds);
FD_SET(csock->socket, &exc_fds);
if (timeout >= 0)
{
tv.tv_sec= timeout / 1000;
tv.tv_usec= (timeout % 1000) * 1000;
}
rc= select(0, (is_read) ? &fds : NULL,
(is_read) ? NULL : &fds,
&exc_fds,
(timeout >= 0) ? &tv : NULL);
if (rc == SOCKET_ERROR)
{
errno= WSAGetLastError();
}
else if (rc == 0)
{
rc= SOCKET_ERROR;
WSASetLastError(WSAETIMEDOUT);
errno= ETIMEDOUT;
}
else if (FD_ISSET(csock->socket, &exc_fds))
{
int err;
int len = sizeof(int);
if (getsockopt(csock->socket, SOL_SOCKET, SO_ERROR, (char *)&err, &len) != SOCKET_ERROR)
{
WSASetLastError(err);
errno= err;
}
rc= SOCKET_ERROR;
}
#endif
}
return rc;
} | O0 | c | pvio_socket_wait_io_or_timeout:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3e51e
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3e52a
movl $0x0, -0x4(%rbp)
jmp 0x3e634
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x480(%rax)
je 0x3e59e
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x140(%rax)
je 0x3e59e
movq -0x10(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x3f520
cmpb $0x0, %al
je 0x3e572
movl $0x0, -0x4(%rbp)
jmp 0x3e634
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x140(%rax), %rax
movl -0x34(%rbp), %edi
movb -0x11(%rbp), %cl
movl -0x18(%rbp), %edx
movsbl %cl, %esi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x3e634
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x12230
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movsbl -0x11(%rbp), %edx
movl $0x4, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movw %ax, -0x2c(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x3e5e7
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
jmp 0x3e5e9
movl -0x18(%rbp), %edx
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x12660
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x1c(%rbp)
movb %al, -0x35(%rbp)
jne 0x3e616
callq 0x12040
cmpl $0x4, (%rax)
sete %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x3e5e9
cmpl $0x0, -0x1c(%rbp)
jne 0x3e62e
callq 0x12040
movl $0x6e, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| pvio_socket_wait_io_or_timeout:
push rbp
mov rbp, rsp
sub rsp, 40h
mov al, sil
mov [rbp+var_10], rdi
mov [rbp+var_11], al
mov [rbp+var_18], edx
mov [rbp+var_28], 0
cmp [rbp+var_10], 0
jz short loc_3E51E
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_3E52A
loc_3E51E:
mov [rbp+var_4], 0
jmp loc_3E634
loc_3E52A:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
cmp qword ptr [rax+480h], 0
jz short loc_3E59E
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
cmp qword ptr [rax+140h], 0
jz short loc_3E59E
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_34]
call pvio_socket_get_handle
cmp al, 0
jz short loc_3E572
mov [rbp+var_4], 0
jmp loc_3E634
loc_3E572:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rax, [rax+140h]
mov edi, [rbp+var_34]
mov cl, [rbp+var_11]
mov edx, [rbp+var_18]
movsx esi, cl
call rax
mov [rbp+var_4], eax
jmp loc_3E634
loc_3E59E:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
lea rdi, [rbp+var_30]
xor esi, esi
mov edx, 8
call _memset
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_30], eax
movsx edx, [rbp+var_11]
mov eax, 4
mov ecx, 1
cmp edx, 0
cmovnz eax, ecx
mov [rbp+var_2C], ax
cmp [rbp+var_18], 0
jnz short loc_3E5E7
mov [rbp+var_18], 0FFFFFFFFh
loc_3E5E7:
jmp short $+2
loc_3E5E9:
mov edx, [rbp+var_18]
lea rdi, [rbp+var_30]
mov esi, 1
call _poll
mov [rbp+var_1C], eax
xor eax, eax
cmp [rbp+var_1C], 0FFFFFFFFh
mov [rbp+var_35], al
jnz short loc_3E616
call ___errno_location
cmp dword ptr [rax], 4
setz al
mov [rbp+var_35], al
loc_3E616:
mov al, [rbp+var_35]
test al, 1
jnz short loc_3E5E9
cmp [rbp+var_1C], 0
jnz short loc_3E62E
call ___errno_location
mov dword ptr [rax], 6Eh ; 'n'
loc_3E62E:
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
loc_3E634:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long pvio_socket_wait_io_or_timeout(int **a1, char a2, unsigned int a3)
{
__int16 v3; // ax
bool v5; // [rsp+Bh] [rbp-35h]
unsigned int v6; // [rsp+Ch] [rbp-34h] BYREF
int v7; // [rsp+10h] [rbp-30h] BYREF
__int16 v8; // [rsp+14h] [rbp-2Ch]
int *v9; // [rsp+18h] [rbp-28h]
unsigned int v10; // [rsp+24h] [rbp-1Ch]
unsigned int v11; // [rsp+28h] [rbp-18h]
char v12; // [rsp+2Fh] [rbp-11h]
int **v13; // [rsp+30h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v9 = 0LL;
if ( a1 && *v13 )
{
if ( *((_QWORD *)v13[8] + 144) && *(_QWORD *)(*((_QWORD *)v13[8] + 144) + 320LL) )
{
if ( (unsigned __int8)pvio_socket_get_handle(v13, &v6) )
return 0;
else
return (unsigned int)(*(long long ( **)(_QWORD, _QWORD, _QWORD))(*((_QWORD *)v13[8] + 144) + 320LL))(
v6,
(unsigned int)v12,
v11);
}
else
{
v9 = *v13;
memset(&v7, 0LL, 8LL);
v7 = *v9;
v3 = 4;
if ( v12 )
v3 = 1;
v8 = v3;
if ( !v11 )
v11 = -1;
do
{
v10 = poll(&v7, 1LL, v11);
v5 = 0;
if ( v10 == -1 )
v5 = *(_DWORD *)__errno_location(&v7) == 4;
}
while ( v5 );
if ( !v10 )
*(_DWORD *)__errno_location(&v7) = 110;
return v10;
}
}
else
{
return 0;
}
}
| pvio_socket_wait_io_or_timeout:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV AL,SIL
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],AL
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x28],0x0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0013e51e
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x0013e52a
LAB_0013e51e:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013e634
LAB_0013e52a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x0013e59e
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x140],0x0
JZ 0x0013e59e
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x34]
CALL 0x0013f520
CMP AL,0x0
JZ 0x0013e572
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013e634
LAB_0013e572:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x140]
MOV EDI,dword ptr [RBP + -0x34]
MOV CL,byte ptr [RBP + -0x11]
MOV EDX,dword ptr [RBP + -0x18]
MOVSX ESI,CL
CALL RAX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013e634
LAB_0013e59e:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
LEA RDI,[RBP + -0x30]
XOR ESI,ESI
MOV EDX,0x8
CALL 0x00112230
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x30],EAX
MOVSX EDX,byte ptr [RBP + -0x11]
MOV EAX,0x4
MOV ECX,0x1
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV word ptr [RBP + -0x2c],AX
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x0013e5e7
MOV dword ptr [RBP + -0x18],0xffffffff
LAB_0013e5e7:
JMP 0x0013e5e9
LAB_0013e5e9:
MOV EDX,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x30]
MOV ESI,0x1
CALL 0x00112660
MOV dword ptr [RBP + -0x1c],EAX
XOR EAX,EAX
CMP dword ptr [RBP + -0x1c],-0x1
MOV byte ptr [RBP + -0x35],AL
JNZ 0x0013e616
CALL 0x00112040
CMP dword ptr [RAX],0x4
SETZ AL
MOV byte ptr [RBP + -0x35],AL
LAB_0013e616:
MOV AL,byte ptr [RBP + -0x35]
TEST AL,0x1
JNZ 0x0013e5e9
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x0013e62e
CALL 0x00112040
MOV dword ptr [RAX],0x6e
LAB_0013e62e:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
LAB_0013e634:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int pvio_socket_wait_io_or_timeout(long *param_1,char param_2,int param_3)
{
char cVar1;
int *piVar2;
bool bVar3;
int4 local_3c;
pollfd local_38;
int *local_30;
int local_24;
int local_20;
char local_19;
long *local_18;
int local_c;
local_30 = (int *)0x0;
if ((param_1 == (long *)0x0) || (*param_1 == 0)) {
local_c = 0;
}
else {
local_20 = param_3;
local_19 = param_2;
local_18 = param_1;
if ((*(long *)(param_1[8] + 0x480) == 0) ||
(*(long *)(*(long *)(param_1[8] + 0x480) + 0x140) == 0)) {
local_30 = (int *)*param_1;
memset(&local_38,0,8);
local_38.fd = *local_30;
local_38.events = 4;
if (local_19 != '\0') {
local_38.events = 1;
}
if (local_20 == 0) {
local_20 = -1;
}
do {
local_24 = poll(&local_38,1,local_20);
bVar3 = false;
if (local_24 == -1) {
piVar2 = __errno_location();
bVar3 = *piVar2 == 4;
}
} while (bVar3);
if (local_24 == 0) {
piVar2 = __errno_location();
*piVar2 = 0x6e;
}
local_c = local_24;
}
else {
cVar1 = pvio_socket_get_handle(param_1,&local_3c);
if (cVar1 == '\0') {
local_c = (**(code **)(*(long *)(local_18[8] + 0x480) + 0x140))
(local_3c,(int)local_19,local_20,local_19);
}
else {
local_c = 0;
}
}
}
return local_c;
}
| |
38,150 | gguf_kv::gguf_kv(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&) | monkey531[P]llama/ggml/src/gguf.cpp | gguf_kv(const std::string & key, const std::string & value)
: key(key), is_array(false), type(GGUF_TYPE_STRING) {
GGML_ASSERT(!key.empty());
data_string.push_back(value);
} | O1 | cpp | gguf_kv::gguf_kv(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
pushq %rax
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
callq 0x16630
movb $0x0, 0x20(%r14)
movl $0x8, 0x24(%r14)
leaq 0x28(%r14), %rbp
leaq 0x40(%r14), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
cmpq $0x0, 0x8(%r13)
je 0x464ac
movq %r15, %rdi
movq %r12, %rsi
callq 0x16850
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13862(%rip), %rdi # 0x59d15
leaq 0x419f(%rip), %rdx # 0x4a659
leaq 0x14003(%rip), %rcx # 0x5a4c4
movl $0x96, %esi
xorl %eax, %eax
callq 0x17c70
movq %rax, %r12
movq %r15, %rdi
callq 0x16c50
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x464ed
movq 0x38(%r14), %rsi
subq %rdi, %rsi
callq 0x17080
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18a4c
movq %r12, %rdi
callq 0x17e30
| _ZN7gguf_kvC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rdx
mov r13, rsi
mov r14, rdi
lea rbx, [rdi+10h]
mov [rdi], rbx
mov rsi, [rsi]
mov rdx, [r13+8]
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 byte ptr [r14+20h], 0
mov dword ptr [r14+24h], 8
lea rbp, [r14+28h]
lea r15, [r14+40h]
xorps xmm0, xmm0
movups xmmword ptr [r14+28h], xmm0
movups xmmword ptr [r14+38h], xmm0
movups xmmword ptr [r14+48h], xmm0
cmp qword ptr [r13+8], 0
jz short loc_464AC
mov rdi, r15
mov rsi, r12
call __ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_464AC:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyEmpty; "!key.empty()"
mov esi, 96h
xor eax, eax
call _ggml_abort
mov r12, rax
mov rdi, r15
call __ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rbp+0]; void *
test rdi, rdi
jz short loc_464ED
mov rsi, [r14+38h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_464ED:
mov rdi, r14
mov rsi, rbx
call _ZN7gguf_kvC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7__cold_1; gguf_kv::gguf_kv(std::string const&,std::string const&) [clone]
mov rdi, r12
call __Unwind_Resume
| long long gguf_kv::gguf_kv(long long a1, _QWORD *a2, long long a3)
{
int v4; // r8d
int v5; // r9d
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char *>(a1, *a2, *a2 + a2[1]);
*(_BYTE *)(a1 + 32) = 0;
*(_DWORD *)(a1 + 36) = 8;
*(_OWORD *)(a1 + 40) = 0LL;
*(_OWORD *)(a1 + 56) = 0LL;
*(_OWORD *)(a1 + 72) = 0LL;
if ( !a2[1] )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",
150,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"!key.empty()",
v4,
v5);
return std::vector<std::string>::push_back(a1 + 64, a3);
}
| gguf_kv:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RDX
MOV R13,RSI
MOV R14,RDI
LEA RBX,[RDI + 0x10]
MOV qword ptr [RDI],RBX
MOV RSI,qword ptr [RSI]
MOV RDX,qword ptr [R13 + 0x8]
ADD RDX,RSI
CALL 0x00116630
MOV byte ptr [R14 + 0x20],0x0
MOV dword ptr [R14 + 0x24],0x8
LEA RBP,[R14 + 0x28]
LEA R15,[R14 + 0x40]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOVUPS xmmword ptr [R14 + 0x38],XMM0
MOVUPS xmmword ptr [R14 + 0x48],XMM0
CMP qword ptr [R13 + 0x8],0x0
JZ 0x001464ac
LAB_00146492:
MOV RDI,R15
MOV RSI,R12
CALL 0x00116850
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001464ac:
LEA RDI,[0x159d15]
LEA RDX,[0x14a659]
LEA RCX,[0x15a4c4]
MOV ESI,0x96
XOR EAX,EAX
CALL 0x00117c70
|
/* gguf_kv::gguf_kv(std::__cxx11::string const&, std::__cxx11::string const&) */
void __thiscall gguf_kv::gguf_kv(gguf_kv *this,string *param_1,string *param_2)
{
*(gguf_kv **)this = this + 0x10;
std::__cxx11::string::_M_construct<char*>
(this,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
this[0x20] = (gguf_kv)0x0;
*(int4 *)(this + 0x24) = 8;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
if (*(long *)(param_1 + 8) != 0) {
/* try { // try from 00146492 to 001464cc has its CatchHandler @ 001464cd */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)(this + 0x40),
param_2);
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",0x96,
"GGML_ASSERT(%s) failed","!key.empty()");
}
| |
38,151 | my_fprintf | eloqsql/strings/my_vsnprintf.c | int my_fprintf(FILE *stream, const char* format, ...)
{
int result;
va_list args;
va_start(args, format);
result= my_vfprintf(stream, format, args);
va_end(args);
return result;
} | O3 | c | my_fprintf:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq -0xd0(%rbp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x5eb2c
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
leaq -0x20(%rbp), %rdx
movq %r10, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rdx)
callq 0x5e9f0
addq $0xd0, %rsp
popq %rbp
retq
nop
| my_fprintf:
push rbp
mov rbp, rsp
sub rsp, 0D0h
lea r10, [rbp+var_D0]
mov [r10+10h], rdx
mov [r10+18h], rcx
mov [r10+20h], r8
mov [r10+28h], r9
test al, al
jz short loc_5EB2C
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_5EB2C:
lea rdx, [rbp+var_20]
mov [rdx+10h], r10
lea rax, [rbp+arg_0]
mov [rdx+8], rax
mov rax, 3000000010h
mov [rdx], rax
call my_vfprintf
add rsp, 0D0h
pop rbp
retn
| long long my_fprintf(
long long a1,
unsigned __int8 *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,
char a15)
{
char v16; // [rsp+0h] [rbp-D0h] BYREF
long long v17; // [rsp+10h] [rbp-C0h]
long long v18; // [rsp+18h] [rbp-B8h]
long long v19; // [rsp+20h] [rbp-B0h]
long long v20; // [rsp+28h] [rbp-A8h]
__m128 v21; // [rsp+30h] [rbp-A0h]
__m128 v22; // [rsp+40h] [rbp-90h]
__m128 v23; // [rsp+50h] [rbp-80h]
__m128 v24; // [rsp+60h] [rbp-70h]
__m128 v25; // [rsp+70h] [rbp-60h]
__m128 v26; // [rsp+80h] [rbp-50h]
__m128 v27; // [rsp+90h] [rbp-40h]
__m128 v28; // [rsp+A0h] [rbp-30h]
_QWORD v29[4]; // [rsp+B0h] [rbp-20h] BYREF
v21 = a7;
v22 = a8;
v23 = a9;
v24 = a10;
v25 = a11;
v26 = a12;
v27 = a13;
v28 = a14;
v17 = a3;
v18 = a4;
v19 = a5;
v20 = a6;
v29[2] = &v16;
v29[1] = &a15;
v29[0] = 0x3000000010LL;
return my_vfprintf(a1, a2, (unsigned int *)v29);
}
| my_fprintf:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
LEA R10,[RBP + -0xd0]
MOV qword ptr [R10 + 0x10],RDX
MOV qword ptr [R10 + 0x18],RCX
MOV qword ptr [R10 + 0x20],R8
MOV qword ptr [R10 + 0x28],R9
TEST AL,AL
JZ 0x0015eb2c
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_0015eb2c:
LEA RDX,[RBP + -0x20]
MOV qword ptr [RDX + 0x10],R10
LEA RAX,[RBP + 0x10]
MOV qword ptr [RDX + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [RDX],RAX
CALL 0x0015e9f0
ADD RSP,0xd0
POP RBP
RET
|
void my_fprintf(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
int1 local_d8 [16];
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int8 local_28;
int1 *local_20;
int1 *local_18;
local_18 = local_d8;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
local_20 = &stack0x00000008;
local_28 = 0x3000000010;
local_c8 = param_11;
local_c0 = param_12;
local_b8 = param_13;
local_b0 = param_14;
my_vfprintf();
return;
}
| |
38,152 | ma_hashtbl_delete | eloqsql/libmariadb/libmariadb/ma_hashtbl.c | my_bool ma_hashtbl_delete(MA_HASHTBL *hash,uchar *record)
{
uint blength,pos2,pos_hashnr,lastpos_hashnr,idx,empty_index;
MA_HASHTBL_LINK *data,*lastpos,*gpos,*pos,*pos3,*empty;
if (!hash->records)
return(1);
blength=hash->blength;
data=dynamic_element(&hash->array,0,MA_HASHTBL_LINK*);
/* Search after record with key */
pos=data+ hash_mask(rec_hashnr(hash,record),blength,hash->records);
gpos = 0;
while (pos->data != record)
{
gpos=pos;
if (pos->next == NO_RECORD)
return(1); /* Key not found */
pos=data+pos->next;
}
if ( --(hash->records) < hash->blength >> 1) hash->blength>>=1;
hash->current_record= NO_RECORD;
lastpos=data+hash->records;
/* Remove link to record */
empty=pos; empty_index=(uint) (empty-data);
if (gpos)
gpos->next=pos->next; /* unlink current ptr */
else if (pos->next != NO_RECORD)
{
empty=data+(empty_index=pos->next);
pos->data=empty->data;
pos->next=empty->next;
}
if (empty == lastpos) /* last key at wrong pos or no next link */
goto exit;
/* Move the last key (lastpos) */
lastpos_hashnr=rec_hashnr(hash,lastpos->data);
/* pos is where lastpos should be */
pos=data+hash_mask(lastpos_hashnr,hash->blength,hash->records);
if (pos == empty) /* Move to empty position. */
{
empty[0]=lastpos[0];
goto exit;
}
pos_hashnr=rec_hashnr(hash,pos->data);
/* pos3 is where the pos should be */
pos3= data+hash_mask(pos_hashnr,hash->blength,hash->records);
if (pos != pos3)
{ /* pos is on wrong posit */
empty[0]=pos[0]; /* Save it here */
pos[0]=lastpos[0]; /* This should be here */
movelink(data,(uint) (pos-data),(uint) (pos3-data),empty_index);
goto exit;
}
pos2= hash_mask(lastpos_hashnr,blength,hash->records+1);
if (pos2 == hash_mask(pos_hashnr,blength,hash->records+1))
{ /* Identical key-positions */
if (pos2 != hash->records)
{
empty[0]=lastpos[0];
movelink(data,(uint) (lastpos-data),(uint) (pos-data),empty_index);
goto exit;
}
idx= (uint) (pos-data); /* Link pos->next after lastpos */
}
else idx= NO_RECORD; /* Different positions merge */
empty[0]=lastpos[0];
movelink(data,idx,empty_index,pos->next);
pos->next=empty_index;
exit:
ma_pop_dynamic(&hash->array);
if (hash->free)
(*hash->free)((uchar*) record);
return(0);
} | O3 | c | ma_hashtbl_delete:
movb $0x1, %al
cmpl $0x0, 0x8(%rdi)
je 0x1b044
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0xc(%rdi), %r12d
movq 0x18(%rdi), %r13
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x1add8
leaq -0x58(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rdi
movl (%r15), %esi
jmp 0x1ade5
movl 0x4(%r14), %esi
movl %esi, -0x58(%rbp)
movl (%r14), %edi
addq %rbx, %rdi
callq *0x40(%r14)
movl %eax, %r15d
movl 0x8(%r14), %esi
leal -0x1(%r12), %r8d
andl %r8d, %eax
shrl %r12d
decl %r12d
movq %r12, -0x70(%rbp)
andl %r12d, %r15d
cmpl %esi, %eax
cmovbl %eax, %r15d
movq %r15, %rax
shlq $0x4, %rax
leaq (%rax,%r13), %r12
cmpq %rbx, 0x8(%r13,%rax)
je 0x1ae42
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movl (%r12), %r15d
cmpq %rcx, %r15
je 0x1ae77
movq %r12, %rax
movq %r15, %rdx
shlq $0x4, %rdx
leaq (%rdx,%r13), %r12
cmpq %rbx, 0x8(%r13,%rdx)
jne 0x1ae22
jmp 0x1ae44
xorl %eax, %eax
decl %esi
movl %esi, 0x8(%r14)
movl 0xc(%r14), %ecx
shrl %ecx
cmpl %ecx, %esi
jae 0x1ae58
movl %ecx, 0xc(%r14)
movl $0xffffffff, 0x10(%r14) # imm = 0xFFFFFFFF
movl %esi, %r9d
shlq $0x4, %r9
addq %r13, %r9
movl (%r12), %ecx
testq %rax, %rax
je 0x1ae7e
movl %ecx, (%rax)
jmp 0x1aea4
movb $0x1, %al
jmp 0x1b036
cmpl $-0x1, %ecx
je 0x1aea4
movq %rcx, %rax
shlq $0x4, %rax
movq 0x8(%r13,%rax), %rdx
movq %rdx, 0x8(%r12)
movl (%r13,%rax), %edx
movl %edx, (%r12)
leaq (%rax,%r13), %r12
movl %ecx, %r15d
leaq 0x18(%r14), %rdi
cmpq %r9, %r12
je 0x1b021
movq %rdi, -0x38(%rbp)
movl %r8d, -0x54(%rbp)
movl %esi, -0x50(%rbp)
movq %r9, -0x48(%rbp)
movq 0x8(%r9), %rdi
movq 0x30(%r14), %rax
testq %rax, %rax
movq %rbx, -0x40(%rbp)
je 0x1aee3
leaq -0x5c(%rbp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rdi
movl (%rbx), %esi
jmp 0x1aef0
movl 0x4(%r14), %esi
movl %esi, -0x5c(%rbp)
movl (%r14), %eax
addq %rax, %rdi
callq *0x40(%r14)
movl 0xc(%r14), %ebx
leal -0x1(%rbx), %ecx
andl %eax, %ecx
shrl %ebx
decl %ebx
andl %eax, %ebx
cmpl 0x8(%r14), %ecx
cmovbl %ecx, %ebx
movq %rbx, %rcx
shlq $0x4, %rcx
addq %r13, %rcx
cmpq %r12, %rcx
je 0x1af40
movl %eax, -0x4c(%rbp)
movq %rcx, -0x68(%rbp)
movq 0x8(%rcx), %rdi
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x1af51
leaq -0x2c(%rbp), %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rdi
leaq -0x2c(%rbp), %rax
movl (%rax), %esi
jmp 0x1af5e
movq -0x48(%rbp), %rax
movups (%rax), %xmm0
movups %xmm0, (%r12)
jmp 0x1b019
movl 0x4(%r14), %esi
movl %esi, -0x2c(%rbp)
movl (%r14), %eax
addq %rax, %rdi
callq *0x40(%r14)
movl 0x8(%r14), %ecx
movl 0xc(%r14), %edx
leal -0x1(%rdx), %esi
andl %eax, %esi
shrl %edx
decl %edx
andl %eax, %edx
cmpl %ecx, %esi
cmovbl %esi, %edx
cmpl %edx, %ebx
jne 0x1afed
leal 0x1(%rcx), %edx
movl -0x4c(%rbp), %r9d
movl %r9d, %esi
movl -0x54(%rbp), %r8d
andl %r8d, %esi
movq -0x70(%rbp), %rdi
andl %edi, %r9d
cmpl %edx, %esi
cmovbl %esi, %r9d
andl %eax, %r8d
andl %edi, %eax
cmpl %edx, %r8d
cmovbl %r8d, %eax
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpl %eax, %r9d
movq -0x48(%rbp), %rax
movq -0x68(%rbp), %rdi
jne 0x1afc5
cmpl %ecx, %r9d
jne 0x1b045
movl %ebx, %edx
movups (%rax), %xmm0
movups %xmm0, (%r12)
movl (%rdi), %eax
movl %r15d, %esi
movl %esi, %ecx
shlq $0x4, %rcx
movl (%r13,%rcx), %esi
cmpl %edx, %esi
jne 0x1afd2
addq %rcx, %r13
movl %eax, (%r13)
movl %r15d, (%rdi)
jmp 0x1b019
movq -0x68(%rbp), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq -0x48(%rbp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movl %edx, %eax
shlq $0x4, %rax
movl (%r13,%rax), %edx
cmpl %ebx, %edx
jne 0x1b003
addq %rax, %r13
movl %r15d, (%r13)
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %rdi
callq 0x19b41
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x1b034
movq %rbx, %rdi
callq *%rax
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movups (%rax), %xmm0
movups %xmm0, (%r12)
movl -0x50(%rbp), %ecx
movl %ebx, %eax
shlq $0x4, %rax
movl (%r13,%rax), %ebx
cmpl %ecx, %ebx
jne 0x1b050
jmp 0x1b012
| ma_hashtbl_delete:
mov al, 1
cmp dword ptr [rdi+8], 0
jz locret_1B044
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rsi
mov r14, rdi
mov r12d, [rdi+0Ch]
mov r13, [rdi+18h]
mov rax, [rdi+30h]
test rax, rax
jz short loc_1ADD8
lea r15, [rbp-58h]
mov rdi, rbx
mov rsi, r15
xor edx, edx
call rax
mov rdi, rax
mov esi, [r15]
jmp short loc_1ADE5
loc_1ADD8:
mov esi, [r14+4]
mov [rbp-58h], esi
mov edi, [r14]
add rdi, rbx
loc_1ADE5:
call qword ptr [r14+40h]
mov r15d, eax
mov esi, [r14+8]
lea r8d, [r12-1]
and eax, r8d
shr r12d, 1
dec r12d
mov [rbp-70h], r12
and r15d, r12d
cmp eax, esi
cmovb r15d, eax
mov rax, r15
shl rax, 4
lea r12, [rax+r13]
cmp [r13+rax+8], rbx
jz short loc_1AE42
mov ecx, 0FFFFFFFFh
loc_1AE22:
mov r15d, [r12]
cmp r15, rcx
jz short loc_1AE77
mov rax, r12
mov rdx, r15
shl rdx, 4
lea r12, [rdx+r13]
cmp [r13+rdx+8], rbx
jnz short loc_1AE22
jmp short loc_1AE44
loc_1AE42:
xor eax, eax
loc_1AE44:
dec esi
mov [r14+8], esi
mov ecx, [r14+0Ch]
shr ecx, 1
cmp esi, ecx
jnb short loc_1AE58
mov [r14+0Ch], ecx
loc_1AE58:
mov dword ptr [r14+10h], 0FFFFFFFFh
mov r9d, esi
shl r9, 4
add r9, r13
mov ecx, [r12]
test rax, rax
jz short loc_1AE7E
mov [rax], ecx
jmp short loc_1AEA4
loc_1AE77:
mov al, 1
jmp loc_1B036
loc_1AE7E:
cmp ecx, 0FFFFFFFFh
jz short loc_1AEA4
mov rax, rcx
shl rax, 4
mov rdx, [r13+rax+8]
mov [r12+8], rdx
mov edx, [r13+rax+0]
mov [r12], edx
lea r12, [rax+r13]
mov r15d, ecx
loc_1AEA4:
lea rdi, [r14+18h]
cmp r12, r9
jz loc_1B021
mov [rbp-38h], rdi
mov [rbp-54h], r8d
mov [rbp-50h], esi
mov [rbp-48h], r9
mov rdi, [r9+8]
mov rax, [r14+30h]
test rax, rax
mov [rbp-40h], rbx
jz short loc_1AEE3
lea rbx, [rbp-5Ch]
mov rsi, rbx
xor edx, edx
call rax
mov rdi, rax
mov esi, [rbx]
jmp short loc_1AEF0
loc_1AEE3:
mov esi, [r14+4]
mov [rbp-5Ch], esi
mov eax, [r14]
add rdi, rax
loc_1AEF0:
call qword ptr [r14+40h]
mov ebx, [r14+0Ch]
lea ecx, [rbx-1]
and ecx, eax
shr ebx, 1
dec ebx
and ebx, eax
cmp ecx, [r14+8]
cmovb ebx, ecx
mov rcx, rbx
shl rcx, 4
add rcx, r13
cmp rcx, r12
jz short loc_1AF40
mov [rbp-4Ch], eax
mov [rbp-68h], rcx
mov rdi, [rcx+8]
mov rax, [r14+30h]
test rax, rax
jz short loc_1AF51
lea rsi, [rbp-2Ch]
xor edx, edx
call rax
mov rdi, rax
lea rax, [rbp-2Ch]
mov esi, [rax]
jmp short loc_1AF5E
loc_1AF40:
mov rax, [rbp-48h]
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [r12], xmm0
jmp loc_1B019
loc_1AF51:
mov esi, [r14+4]
mov [rbp-2Ch], esi
mov eax, [r14]
add rdi, rax
loc_1AF5E:
call qword ptr [r14+40h]
mov ecx, [r14+8]
mov edx, [r14+0Ch]
lea esi, [rdx-1]
and esi, eax
shr edx, 1
dec edx
and edx, eax
cmp esi, ecx
cmovb edx, esi
cmp ebx, edx
jnz short loc_1AFED
lea edx, [rcx+1]
mov r9d, [rbp-4Ch]
mov esi, r9d
mov r8d, [rbp-54h]
and esi, r8d
mov rdi, [rbp-70h]
and r9d, edi
cmp esi, edx
cmovb r9d, esi
and r8d, eax
and eax, edi
cmp r8d, edx
cmovb eax, r8d
mov edx, 0FFFFFFFFh
cmp r9d, eax
mov rax, [rbp-48h]
mov rdi, [rbp-68h]
jnz short loc_1AFC5
cmp r9d, ecx
jnz loc_1B045
mov edx, ebx
loc_1AFC5:
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [r12], xmm0
mov eax, [rdi]
mov esi, r15d
loc_1AFD2:
mov ecx, esi
shl rcx, 4
mov esi, [r13+rcx+0]
cmp esi, edx
jnz short loc_1AFD2
add r13, rcx
mov [r13+0], eax
mov [rdi], r15d
jmp short loc_1B019
loc_1AFED:
mov rcx, [rbp-68h]
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
mov rax, [rbp-48h]
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [rcx], xmm0
loc_1B003:
mov eax, edx
shl rax, 4
mov edx, [r13+rax+0]
cmp edx, ebx
jnz short loc_1B003
loc_1B012:
add r13, rax
mov [r13+0], r15d
loc_1B019:
mov rbx, [rbp-40h]
mov rdi, [rbp-38h]
loc_1B021:
call ma_pop_dynamic
mov rax, [r14+38h]
test rax, rax
jz short loc_1B034
mov rdi, rbx
call rax
loc_1B034:
xor eax, eax
loc_1B036:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_1B044:
retn
loc_1B045:
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [r12], xmm0
mov ecx, [rbp-50h]
loc_1B050:
mov eax, ebx
shl rax, 4
mov ebx, [r13+rax+0]
cmp ebx, ecx
jnz short loc_1B050
jmp short loc_1B012
| char ma_hashtbl_delete(unsigned int *a1, long long a2)
{
char result; // al
long long v3; // rbx
unsigned int v5; // r12d
long long v6; // r13
long long ( *v7)(long long, unsigned int *, _QWORD); // rax
long long v8; // rdi
long long v9; // rsi
unsigned int v10; // r15d
unsigned int v11; // esi
unsigned int v12; // r8d
unsigned int v13; // eax
long long v14; // r15
unsigned int *v15; // r12
unsigned int *v16; // rax
unsigned int v17; // esi
unsigned int v18; // ecx
long long v19; // r9
long long v20; // rcx
long long v21; // rdi
long long v22; // rdi
long long ( *v23)(long long, unsigned int *, _QWORD); // rax
long long v24; // rdi
long long v25; // rsi
unsigned int v26; // eax
unsigned int v27; // ebx
unsigned int v28; // ecx
long long v29; // rbx
long long v30; // rcx
long long v31; // rdi
long long ( *v32)(long long, unsigned int *, _QWORD); // rax
long long v33; // rdi
long long v34; // rsi
int v35; // eax
unsigned int v36; // ecx
unsigned int v37; // edx
unsigned int v38; // esi
unsigned int v39; // edx
int v40; // r9d
unsigned int v41; // r8d
int v42; // eax
int v43; // edx
unsigned int v44; // esi
long long v45; // rcx
long long v46; // rax
void ( *v47)(long long); // rax
int v48; // [rsp-78h] [rbp-78h]
_DWORD *v49; // [rsp-70h] [rbp-70h]
unsigned int v50; // [rsp-64h] [rbp-64h] BYREF
unsigned int v51; // [rsp-60h] [rbp-60h] BYREF
unsigned int v52; // [rsp-5Ch] [rbp-5Ch]
unsigned int v53; // [rsp-58h] [rbp-58h]
unsigned int v54; // [rsp-54h] [rbp-54h]
_OWORD *v55; // [rsp-50h] [rbp-50h]
long long v56; // [rsp-48h] [rbp-48h]
unsigned int *v57; // [rsp-40h] [rbp-40h]
unsigned int v58; // [rsp-34h] [rbp-34h] BYREF
result = 1;
if ( !a1[2] )
return result;
v3 = a2;
v5 = a1[3];
v6 = *((_QWORD *)a1 + 3);
v7 = (long long ( *)(long long, unsigned int *, _QWORD))*((_QWORD *)a1 + 6);
if ( v7 )
{
v8 = v7(a2, &v51, 0LL);
v9 = v51;
}
else
{
v9 = a1[1];
v51 = a1[1];
v8 = v3 + *a1;
}
v10 = (*((long long ( **)(long long, long long))a1 + 8))(v8, v9);
v11 = a1[2];
v12 = v5 - 1;
v13 = (v5 - 1) & v10;
v48 = (v5 >> 1) - 1;
v14 = v48 & v10;
if ( v13 < v11 )
v14 = v13;
v15 = (unsigned int *)(16 * v14 + v6);
if ( *((_QWORD *)v15 + 1) == v3 )
{
v16 = 0LL;
LABEL_12:
v17 = v11 - 1;
a1[2] = v17;
v18 = a1[3] >> 1;
if ( v17 < v18 )
a1[3] = v18;
a1[4] = -1;
v19 = v6 + 16LL * v17;
v20 = *v15;
if ( v16 )
{
*v16 = v20;
}
else if ( (_DWORD)v20 != -1 )
{
*((_QWORD *)v15 + 1) = *(_QWORD *)(v6 + 16 * v20 + 8);
*v15 = *(_DWORD *)(v6 + 16 * v20);
v15 = (unsigned int *)(16 * v20 + v6);
LODWORD(v14) = v20;
}
v21 = (long long)(a1 + 6);
if ( v15 == (unsigned int *)v19 )
goto LABEL_47;
v57 = a1 + 6;
v52 = v12;
v53 = v17;
v55 = (_OWORD *)(v6 + 16LL * v17);
v22 = *(_QWORD *)(v19 + 8);
v23 = (long long ( *)(long long, unsigned int *, _QWORD))*((_QWORD *)a1 + 6);
v56 = v3;
if ( v23 )
{
v24 = v23(v22, &v50, 0LL);
v25 = v50;
}
else
{
v25 = a1[1];
v50 = a1[1];
v24 = *a1 + v22;
}
v26 = (*((long long ( **)(long long, long long))a1 + 8))(v24, v25);
v27 = a1[3];
v28 = v26 & (v27 - 1);
v29 = v26 & ((v27 >> 1) - 1);
if ( v28 < a1[2] )
v29 = v28;
v30 = v6 + 16 * v29;
if ( (unsigned int *)v30 == v15 )
{
*(_OWORD *)v15 = *v55;
}
else
{
v54 = v26;
v49 = (_DWORD *)(v6 + 16 * v29);
v31 = *(_QWORD *)(v30 + 8);
v32 = (long long ( *)(long long, unsigned int *, _QWORD))*((_QWORD *)a1 + 6);
if ( v32 )
{
v33 = v32(v31, &v58, 0LL);
v34 = v58;
}
else
{
v34 = a1[1];
v58 = a1[1];
v33 = *a1 + v31;
}
v35 = (*((long long ( **)(long long, long long))a1 + 8))(v33, v34);
v36 = a1[2];
v37 = a1[3];
v38 = v35 & (v37 - 1);
v39 = v35 & ((v37 >> 1) - 1);
if ( v38 < v36 )
v39 = v38;
if ( (_DWORD)v29 == v39 )
{
v40 = v48 & v54;
if ( (v52 & v54) < v36 + 1 )
v40 = v52 & v54;
v41 = v35 & v52;
v42 = v48 & v35;
if ( v41 < v36 + 1 )
v42 = v41;
v43 = -1;
if ( v40 != v42 )
goto LABEL_40;
if ( v40 == v36 )
{
v43 = v29;
LABEL_40:
*(_OWORD *)v15 = *v55;
v44 = v14;
do
{
v45 = 16LL * v44;
v44 = *(_DWORD *)(v6 + v45);
}
while ( v44 != v43 );
*(_DWORD *)(v45 + v6) = *v49;
*v49 = v14;
goto LABEL_46;
}
*(_OWORD *)v15 = *v55;
do
{
v46 = 16LL * (unsigned int)v29;
LODWORD(v29) = *(_DWORD *)(v6 + v46);
}
while ( (_DWORD)v29 != v53 );
}
else
{
*(_OWORD *)v15 = *(_OWORD *)v49;
*(_OWORD *)v49 = *v55;
do
{
v46 = 16LL * v39;
v39 = *(_DWORD *)(v6 + v46);
}
while ( v39 != (_DWORD)v29 );
}
*(_DWORD *)(v46 + v6) = v14;
}
LABEL_46:
v3 = v56;
v21 = (long long)v57;
LABEL_47:
ma_pop_dynamic(v21);
v47 = (void ( *)(long long))*((_QWORD *)a1 + 7);
if ( v47 )
v47(v3);
return 0;
}
while ( 1 )
{
v14 = *v15;
if ( v14 == 0xFFFFFFFFLL )
return 1;
v16 = v15;
v15 = (unsigned int *)(16 * v14 + v6);
if ( *((_QWORD *)v15 + 1) == v3 )
goto LABEL_12;
}
}
| ma_hashtbl_delete:
MOV AL,0x1
CMP dword ptr [RDI + 0x8],0x0
JZ 0x0011b044
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RSI
MOV R14,RDI
MOV R12D,dword ptr [RDI + 0xc]
MOV R13,qword ptr [RDI + 0x18]
MOV RAX,qword ptr [RDI + 0x30]
TEST RAX,RAX
JZ 0x0011add8
LEA R15,[RBP + -0x58]
MOV RDI,RBX
MOV RSI,R15
XOR EDX,EDX
CALL RAX
MOV RDI,RAX
MOV ESI,dword ptr [R15]
JMP 0x0011ade5
LAB_0011add8:
MOV ESI,dword ptr [R14 + 0x4]
MOV dword ptr [RBP + -0x58],ESI
MOV EDI,dword ptr [R14]
ADD RDI,RBX
LAB_0011ade5:
CALL qword ptr [R14 + 0x40]
MOV R15D,EAX
MOV ESI,dword ptr [R14 + 0x8]
LEA R8D,[R12 + -0x1]
AND EAX,R8D
SHR R12D,0x1
DEC R12D
MOV qword ptr [RBP + -0x70],R12
AND R15D,R12D
CMP EAX,ESI
CMOVC R15D,EAX
MOV RAX,R15
SHL RAX,0x4
LEA R12,[RAX + R13*0x1]
CMP qword ptr [R13 + RAX*0x1 + 0x8],RBX
JZ 0x0011ae42
MOV ECX,0xffffffff
LAB_0011ae22:
MOV R15D,dword ptr [R12]
CMP R15,RCX
JZ 0x0011ae77
MOV RAX,R12
MOV RDX,R15
SHL RDX,0x4
LEA R12,[RDX + R13*0x1]
CMP qword ptr [R13 + RDX*0x1 + 0x8],RBX
JNZ 0x0011ae22
JMP 0x0011ae44
LAB_0011ae42:
XOR EAX,EAX
LAB_0011ae44:
DEC ESI
MOV dword ptr [R14 + 0x8],ESI
MOV ECX,dword ptr [R14 + 0xc]
SHR ECX,0x1
CMP ESI,ECX
JNC 0x0011ae58
MOV dword ptr [R14 + 0xc],ECX
LAB_0011ae58:
MOV dword ptr [R14 + 0x10],0xffffffff
MOV R9D,ESI
SHL R9,0x4
ADD R9,R13
MOV ECX,dword ptr [R12]
TEST RAX,RAX
JZ 0x0011ae7e
MOV dword ptr [RAX],ECX
JMP 0x0011aea4
LAB_0011ae77:
MOV AL,0x1
JMP 0x0011b036
LAB_0011ae7e:
CMP ECX,-0x1
JZ 0x0011aea4
MOV RAX,RCX
SHL RAX,0x4
MOV RDX,qword ptr [R13 + RAX*0x1 + 0x8]
MOV qword ptr [R12 + 0x8],RDX
MOV EDX,dword ptr [R13 + RAX*0x1]
MOV dword ptr [R12],EDX
LEA R12,[RAX + R13*0x1]
MOV R15D,ECX
LAB_0011aea4:
LEA RDI,[R14 + 0x18]
CMP R12,R9
JZ 0x0011b021
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x54],R8D
MOV dword ptr [RBP + -0x50],ESI
MOV qword ptr [RBP + -0x48],R9
MOV RDI,qword ptr [R9 + 0x8]
MOV RAX,qword ptr [R14 + 0x30]
TEST RAX,RAX
MOV qword ptr [RBP + -0x40],RBX
JZ 0x0011aee3
LEA RBX,[RBP + -0x5c]
MOV RSI,RBX
XOR EDX,EDX
CALL RAX
MOV RDI,RAX
MOV ESI,dword ptr [RBX]
JMP 0x0011aef0
LAB_0011aee3:
MOV ESI,dword ptr [R14 + 0x4]
MOV dword ptr [RBP + -0x5c],ESI
MOV EAX,dword ptr [R14]
ADD RDI,RAX
LAB_0011aef0:
CALL qword ptr [R14 + 0x40]
MOV EBX,dword ptr [R14 + 0xc]
LEA ECX,[RBX + -0x1]
AND ECX,EAX
SHR EBX,0x1
DEC EBX
AND EBX,EAX
CMP ECX,dword ptr [R14 + 0x8]
CMOVC EBX,ECX
MOV RCX,RBX
SHL RCX,0x4
ADD RCX,R13
CMP RCX,R12
JZ 0x0011af40
MOV dword ptr [RBP + -0x4c],EAX
MOV qword ptr [RBP + -0x68],RCX
MOV RDI,qword ptr [RCX + 0x8]
MOV RAX,qword ptr [R14 + 0x30]
TEST RAX,RAX
JZ 0x0011af51
LEA RSI,[RBP + -0x2c]
XOR EDX,EDX
CALL RAX
MOV RDI,RAX
LEA RAX,[RBP + -0x2c]
MOV ESI,dword ptr [RAX]
JMP 0x0011af5e
LAB_0011af40:
MOV RAX,qword ptr [RBP + -0x48]
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [R12],XMM0
JMP 0x0011b019
LAB_0011af51:
MOV ESI,dword ptr [R14 + 0x4]
MOV dword ptr [RBP + -0x2c],ESI
MOV EAX,dword ptr [R14]
ADD RDI,RAX
LAB_0011af5e:
CALL qword ptr [R14 + 0x40]
MOV ECX,dword ptr [R14 + 0x8]
MOV EDX,dword ptr [R14 + 0xc]
LEA ESI,[RDX + -0x1]
AND ESI,EAX
SHR EDX,0x1
DEC EDX
AND EDX,EAX
CMP ESI,ECX
CMOVC EDX,ESI
CMP EBX,EDX
JNZ 0x0011afed
LEA EDX,[RCX + 0x1]
MOV R9D,dword ptr [RBP + -0x4c]
MOV ESI,R9D
MOV R8D,dword ptr [RBP + -0x54]
AND ESI,R8D
MOV RDI,qword ptr [RBP + -0x70]
AND R9D,EDI
CMP ESI,EDX
CMOVC R9D,ESI
AND R8D,EAX
AND EAX,EDI
CMP R8D,EDX
CMOVC EAX,R8D
MOV EDX,0xffffffff
CMP R9D,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [RBP + -0x68]
JNZ 0x0011afc5
CMP R9D,ECX
JNZ 0x0011b045
MOV EDX,EBX
LAB_0011afc5:
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [R12],XMM0
MOV EAX,dword ptr [RDI]
MOV ESI,R15D
LAB_0011afd2:
MOV ECX,ESI
SHL RCX,0x4
MOV ESI,dword ptr [R13 + RCX*0x1]
CMP ESI,EDX
JNZ 0x0011afd2
ADD R13,RCX
MOV dword ptr [R13],EAX
MOV dword ptr [RDI],R15D
JMP 0x0011b019
LAB_0011afed:
MOV RCX,qword ptr [RBP + -0x68]
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
MOV RAX,qword ptr [RBP + -0x48]
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RCX],XMM0
LAB_0011b003:
MOV EAX,EDX
SHL RAX,0x4
MOV EDX,dword ptr [R13 + RAX*0x1]
CMP EDX,EBX
JNZ 0x0011b003
LAB_0011b012:
ADD R13,RAX
MOV dword ptr [R13],R15D
LAB_0011b019:
MOV RBX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x38]
LAB_0011b021:
CALL 0x00119b41
MOV RAX,qword ptr [R14 + 0x38]
TEST RAX,RAX
JZ 0x0011b034
MOV RDI,RBX
CALL RAX
LAB_0011b034:
XOR EAX,EAX
LAB_0011b036:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_0011b044:
RET
LAB_0011b045:
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [R12],XMM0
MOV ECX,dword ptr [RBP + -0x50]
LAB_0011b050:
MOV EAX,EBX
SHL RAX,0x4
MOV EBX,dword ptr [R13 + RAX*0x1]
CMP EBX,ECX
JNZ 0x0011b050
JMP 0x0011b012
|
int8 ma_hashtbl_delete(uint *param_1,long param_2)
{
long lVar1;
int8 uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
long lVar6;
uint *puVar7;
ulong uVar8;
uint uVar9;
uint uVar10;
uint *puVar11;
uint uVar12;
uint *puVar13;
ulong uVar14;
uint local_64;
uint local_60;
uint local_5c;
uint local_58;
uint local_54;
uint *local_50;
long local_48;
uint *local_40;
uint local_34;
if (param_1[2] == 0) {
return 1;
}
uVar9 = param_1[3];
lVar1 = *(long *)(param_1 + 6);
if (*(code **)(param_1 + 0xc) == (code *)0x0) {
local_60 = param_1[1];
lVar6 = (ulong)*param_1 + param_2;
}
else {
lVar6 = (**(code **)(param_1 + 0xc))(param_2,&local_60,0);
}
uVar3 = (**(code **)(param_1 + 0x10))(lVar6,local_60);
uVar4 = uVar9 - 1;
uVar12 = (uVar9 >> 1) - 1;
uVar9 = uVar3 & uVar12;
if ((uVar3 & uVar4) < param_1[2]) {
uVar9 = uVar3 & uVar4;
}
uVar14 = (ulong)uVar9;
puVar13 = (uint *)(uVar14 * 0x10 + lVar1);
if (*(long *)(lVar1 + 8 + uVar14 * 0x10) == param_2) {
puVar7 = (uint *)0x0;
}
else {
do {
puVar7 = puVar13;
uVar14 = (ulong)*puVar7;
if (uVar14 == 0xffffffff) {
return 1;
}
puVar13 = (uint *)(uVar14 * 0x10 + lVar1);
} while (*(long *)(lVar1 + 8 + uVar14 * 0x10) != param_2);
}
uVar9 = param_1[2] - 1;
param_1[2] = uVar9;
if (uVar9 < param_1[3] >> 1) {
param_1[3] = param_1[3] >> 1;
}
param_1[4] = 0xffffffff;
puVar11 = (uint *)((ulong)uVar9 * 0x10 + lVar1);
uVar3 = *puVar13;
if (puVar7 == (uint *)0x0) {
if (uVar3 != 0xffffffff) {
lVar6 = (ulong)uVar3 * 0x10;
*(int8 *)(puVar13 + 2) = *(int8 *)(lVar1 + 8 + lVar6);
*puVar13 = *(uint *)(lVar1 + lVar6);
puVar13 = (uint *)(lVar6 + lVar1);
uVar14 = (ulong)uVar3;
}
}
else {
*puVar7 = uVar3;
}
puVar7 = param_1 + 6;
if (puVar13 != puVar11) {
local_5c = uVar4;
local_58 = uVar9;
local_50 = puVar11;
local_48 = param_2;
local_40 = puVar7;
if (*(code **)(param_1 + 0xc) == (code *)0x0) {
local_64 = param_1[1];
lVar6 = *(long *)(puVar11 + 2) + (ulong)*param_1;
}
else {
lVar6 = (**(code **)(param_1 + 0xc))(*(long *)(puVar11 + 2),&local_64,0);
}
uVar4 = (**(code **)(param_1 + 0x10))(lVar6,local_64);
uVar3 = param_1[3] - 1 & uVar4;
uVar9 = (param_1[3] >> 1) - 1 & uVar4;
if (uVar3 < param_1[2]) {
uVar9 = uVar3;
}
uVar8 = (ulong)uVar9;
puVar11 = (uint *)(uVar8 * 0x10 + lVar1);
if (puVar11 == puVar13) {
uVar9 = local_50[1];
uVar4 = local_50[2];
uVar3 = local_50[3];
*puVar13 = *local_50;
puVar13[1] = uVar9;
puVar13[2] = uVar4;
puVar13[3] = uVar3;
param_2 = local_48;
puVar7 = local_40;
}
else {
local_54 = uVar4;
if (*(code **)(param_1 + 0xc) == (code *)0x0) {
local_34 = param_1[1];
lVar6 = *(long *)(puVar11 + 2) + (ulong)*param_1;
}
else {
lVar6 = (**(code **)(param_1 + 0xc))(*(long *)(puVar11 + 2),&local_34,0);
}
uVar5 = (**(code **)(param_1 + 0x10))(lVar6,local_34);
uVar4 = param_1[2];
uVar10 = param_1[3] - 1 & uVar5;
uVar3 = (param_1[3] >> 1) - 1 & uVar5;
if (uVar10 < uVar4) {
uVar3 = uVar10;
}
uVar10 = (uint)uVar14;
param_2 = local_48;
puVar7 = local_40;
if (uVar9 == uVar3) {
uVar3 = local_54 & uVar12;
if ((local_54 & local_5c) < uVar4 + 1) {
uVar3 = local_54 & local_5c;
}
uVar12 = uVar5 & uVar12;
if ((local_5c & uVar5) < uVar4 + 1) {
uVar12 = local_5c & uVar5;
}
uVar5 = 0xffffffff;
if ((uVar3 != uVar12) || (uVar5 = uVar9, uVar3 == uVar4)) {
uVar9 = local_50[1];
uVar4 = local_50[2];
uVar3 = local_50[3];
*puVar13 = *local_50;
puVar13[1] = uVar9;
puVar13[2] = uVar4;
puVar13[3] = uVar3;
do {
lVar6 = uVar14 * 0x10;
uVar9 = *(uint *)(lVar1 + lVar6);
uVar14 = (ulong)uVar9;
} while (uVar9 != uVar5);
*(uint *)(lVar1 + lVar6) = *puVar11;
*puVar11 = uVar10;
goto LAB_0011b021;
}
uVar9 = local_50[1];
uVar4 = local_50[2];
uVar3 = local_50[3];
*puVar13 = *local_50;
puVar13[1] = uVar9;
puVar13[2] = uVar4;
puVar13[3] = uVar3;
do {
lVar6 = uVar8 * 0x10;
uVar8 = (ulong)*(uint *)(lVar1 + lVar6);
} while (*(uint *)(lVar1 + lVar6) != local_58);
}
else {
uVar2 = *(int8 *)(puVar11 + 2);
*(int8 *)puVar13 = *(int8 *)puVar11;
*(int8 *)(puVar13 + 2) = uVar2;
uVar4 = local_50[1];
uVar12 = local_50[2];
uVar5 = local_50[3];
*puVar11 = *local_50;
puVar11[1] = uVar4;
puVar11[2] = uVar12;
puVar11[3] = uVar5;
do {
lVar6 = (ulong)uVar3 * 0x10;
uVar3 = *(uint *)(lVar1 + lVar6);
} while (uVar3 != uVar9);
}
*(uint *)(lVar1 + lVar6) = uVar10;
}
}
LAB_0011b021:
ma_pop_dynamic(puVar7);
if (*(code **)(param_1 + 0xe) != (code *)0x0) {
(**(code **)(param_1 + 0xe))(param_2);
}
return 0;
}
| |
38,153 | ggml_backend_buft_get_alloc_size | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | size_t ggml_backend_buft_get_alloc_size(ggml_backend_buffer_type_t buft, struct ggml_tensor * tensor) {
// get_alloc_size is optional, defaults to ggml_nbytes
if (buft->iface.get_alloc_size) {
size_t size = buft->iface.get_alloc_size(buft, tensor);
assert(size >= ggml_nbytes(tensor));
return size;
}
return ggml_nbytes(tensor);
} | O0 | cpp | ggml_backend_buft_get_alloc_size:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x5da99
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x42650
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jb 0x5da70
jmp 0x5da8f
leaq 0x57184(%rip), %rdi # 0xb4bfb
leaq 0x57199(%rip), %rsi # 0xb4c17
movl $0x3e, %edx
leaq 0x571e9(%rip), %rcx # 0xb4c73
callq 0x44810
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5daa6
movq -0x18(%rbp), %rdi
callq 0x42650
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
| ggml_backend_buft_get_alloc_size:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
cmp qword ptr [rax+20h], 0
jz short loc_5DA99
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call rax
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
mov rdi, [rbp+var_18]
call _ggml_nbytes
mov rcx, rax
mov rax, [rbp+var_28]
cmp rax, rcx
jb short loc_5DA70
jmp short loc_5DA8F
loc_5DA70:
lea rdi, aSizeGgmlNbytes; "size >= ggml_nbytes(tensor)"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov edx, 3Eh ; '>'
lea rcx, aSizeTGgmlBacke; "size_t ggml_backend_buft_get_alloc_size"...
call ___assert_fail
loc_5DA8F:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp short loc_5DAA6
loc_5DA99:
mov rdi, [rbp+var_18]
call _ggml_nbytes
mov [rbp+var_8], rax
loc_5DAA6:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long ggml_backend_buft_get_alloc_size(long long a1, unsigned int *a2)
{
unsigned long long v3; // [rsp+10h] [rbp-20h]
if ( !*(_QWORD *)(a1 + 32) )
return ggml_nbytes(a2);
v3 = (*(long long ( **)(long long, unsigned int *))(a1 + 32))(a1, a2);
if ( v3 < ggml_nbytes(a2) )
__assert_fail(
"size >= ggml_nbytes(tensor)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
62LL,
"size_t ggml_backend_buft_get_alloc_size(ggml_backend_buffer_type_t, struct ggml_tensor *)");
return v3;
}
| ggml_backend_buft_get_alloc_size:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x0015da99
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL RAX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00142650
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,RCX
JC 0x0015da70
JMP 0x0015da8f
LAB_0015da70:
LEA RDI,[0x1b4bfb]
LEA RSI,[0x1b4c17]
MOV EDX,0x3e
LEA RCX,[0x1b4c73]
CALL 0x00144810
LAB_0015da8f:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0015daa6
LAB_0015da99:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00142650
MOV qword ptr [RBP + -0x8],RAX
LAB_0015daa6:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
ulong ggml_backend_buft_get_alloc_size(long param_1,int8 param_2)
{
ulong uVar1;
ulong local_10;
if (*(long *)(param_1 + 0x20) == 0) {
local_10 = ggml_nbytes(param_2);
}
else {
local_10 = (**(code **)(param_1 + 0x20))(param_1,param_2);
uVar1 = ggml_nbytes(param_2);
if (local_10 < uVar1) {
/* WARNING: Subroutine does not return */
__assert_fail("size >= ggml_nbytes(tensor)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,0x3e,
"size_t ggml_backend_buft_get_alloc_size(ggml_backend_buffer_type_t, struct ggml_tensor *)"
);
}
}
return local_10;
}
| |
38,154 | ggml_backend_buft_get_alloc_size | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | size_t ggml_backend_buft_get_alloc_size(ggml_backend_buffer_type_t buft, struct ggml_tensor * tensor) {
// get_alloc_size is optional, defaults to ggml_nbytes
if (buft->iface.get_alloc_size) {
size_t size = buft->iface.get_alloc_size(buft, tensor);
assert(size >= ggml_nbytes(tensor));
return size;
}
return ggml_nbytes(tensor);
} | O2 | cpp | ggml_backend_buft_get_alloc_size:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x2b346
movq %rbx, %rsi
callq *%rax
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d300
cmpq %rax, %r14
jb 0x2b355
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1d300
leaq 0x2640c(%rip), %rdi # 0x51768
leaq 0x26421(%rip), %rsi # 0x51784
leaq 0x26476(%rip), %rcx # 0x517e0
pushq $0x3e
popq %rdx
callq 0x1dfb0
| ggml_backend_buft_get_alloc_size:
push r14
push rbx
push rax
mov rbx, rsi
mov rax, [rdi+20h]
test rax, rax
jz short loc_2B346
mov rsi, rbx
call rax
mov r14, rax
mov rdi, rbx
call _ggml_nbytes
cmp r14, rax
jb short loc_2B355
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
loc_2B346:
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
jmp _ggml_nbytes
loc_2B355:
lea rdi, aSizeGgmlNbytes; "size >= ggml_nbytes(tensor)"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aSizeTGgmlBacke; "size_t ggml_backend_buft_get_alloc_size"...
push 3Eh ; '>'
pop rdx
call ___assert_fail
| unsigned long long ggml_backend_buft_get_alloc_size(long long a1, unsigned int *a2)
{
long long ( *v2)(long long, unsigned int *); // rax
unsigned long long v3; // r14
v2 = *(long long ( **)(long long, unsigned int *))(a1 + 32);
if ( !v2 )
return ggml_nbytes(a2);
v3 = v2(a1, a2);
if ( v3 < ggml_nbytes(a2) )
__assert_fail(
"size >= ggml_nbytes(tensor)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
62LL,
"size_t ggml_backend_buft_get_alloc_size(ggml_backend_buffer_type_t, struct ggml_tensor *)");
return v3;
}
| ggml_backend_buft_get_alloc_size:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV RAX,qword ptr [RDI + 0x20]
TEST RAX,RAX
JZ 0x0012b346
MOV RSI,RBX
CALL RAX
MOV R14,RAX
MOV RDI,RBX
CALL 0x0011d300
CMP R14,RAX
JC 0x0012b355
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0012b346:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0011d300
LAB_0012b355:
LEA RDI,[0x151768]
LEA RSI,[0x151784]
LEA RCX,[0x1517e0]
PUSH 0x3e
POP RDX
CALL 0x0011dfb0
|
ulong ggml_backend_buft_get_alloc_size(long param_1,int8 param_2)
{
ulong uVar1;
ulong uVar2;
if (*(code **)(param_1 + 0x20) == (code *)0x0) {
uVar1 = ggml_nbytes(param_2);
return uVar1;
}
uVar1 = (**(code **)(param_1 + 0x20))(param_1,param_2);
uVar2 = ggml_nbytes(param_2);
if (uVar2 <= uVar1) {
return uVar1;
}
/* WARNING: Subroutine does not return */
__assert_fail("size >= ggml_nbytes(tensor)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,0x3e,
"size_t ggml_backend_buft_get_alloc_size(ggml_backend_buffer_type_t, struct ggml_tensor *)"
);
}
| |
38,155 | translog_purge | eloqsql/storage/maria/ma_loghandler.c | my_bool translog_purge(TRANSLOG_ADDRESS low)
{
uint32 last_need_file= LSN_FILE_NO(low);
uint32 min_unsync;
int soft;
TRANSLOG_ADDRESS horizon= translog_get_horizon();
int rc= 0;
DBUG_ENTER("translog_purge");
DBUG_PRINT("enter", ("low: " LSN_FMT, LSN_IN_PARTS(low)));
DBUG_ASSERT(translog_status == TRANSLOG_OK ||
translog_status == TRANSLOG_READONLY);
soft= soft_sync;
min_unsync= soft_sync_min;
DBUG_PRINT("info", ("min_unsync: %lu", (ulong) min_unsync));
if (soft && min_unsync < last_need_file)
{
last_need_file= min_unsync;
DBUG_PRINT("info", ("last_need_file set to %lu", (ulong)last_need_file));
}
mysql_mutex_lock(&log_descriptor.purger_lock);
DBUG_PRINT("info", ("last_lsn_checked file: %lu:",
(ulong) log_descriptor.last_lsn_checked));
if (LSN_FILE_NO(log_descriptor.last_lsn_checked) < last_need_file)
{
uint32 i;
uint32 min_file= translog_first_file(horizon, 1);
DBUG_ASSERT(min_file != 0); /* log is already started */
DBUG_PRINT("info", ("min_file: %lu:",(ulong) min_file));
for(i= min_file; i < last_need_file && rc == 0; i++)
{
LSN lsn= translog_get_file_max_lsn_stored(i);
if (lsn == LSN_IMPOSSIBLE)
break; /* files are still in writing */
if (lsn == LSN_ERROR)
{
rc= 1;
break;
}
if (cmp_translog_addr(lsn, low) >= 0)
break;
DBUG_PRINT("info", ("purge file %lu", (ulong) i));
/* remove file descriptor from the cache */
/*
log_descriptor.min_file can be changed only here during execution
and the function is serialized, so we can access it without problems
*/
if (i >= log_descriptor.min_file)
{
TRANSLOG_FILE *file;
mysql_rwlock_wrlock(&log_descriptor.open_files_lock);
DBUG_ASSERT(log_descriptor.max_file - log_descriptor.min_file + 1 ==
log_descriptor.open_files.elements);
DBUG_ASSERT(log_descriptor.min_file == i);
file= *((TRANSLOG_FILE **)pop_dynamic(&log_descriptor.open_files));
DBUG_PRINT("info", ("Files : %d", log_descriptor.open_files.elements));
DBUG_ASSERT(i == file->number);
log_descriptor.min_file++;
DBUG_ASSERT(log_descriptor.max_file - log_descriptor.min_file + 1 ==
log_descriptor.open_files.elements);
mysql_rwlock_unlock(&log_descriptor.open_files_lock);
translog_close_log_file(file);
}
if (log_purge_type == TRANSLOG_PURGE_IMMIDIATE && ! log_purge_disabled)
{
char path[FN_REFLEN], *file_name;
file_name= translog_filename_by_fileno(i, path);
rc= MY_TEST(mysql_file_delete(key_file_translog,
file_name, MYF(MY_WME)));
}
}
if (unlikely(rc == 1))
log_descriptor.min_need_file= 0; /* impossible value */
else
log_descriptor.min_need_file= i;
}
mysql_mutex_unlock(&log_descriptor.purger_lock);
DBUG_RETURN(rc);
} | O3 | c | translog_purge:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq %rdi, %r15
shrq $0x20, %r15
callq 0x4bf54
movq %rax, %r14
movl 0xbb1b22(%rip), %r12d # 0xbff6ec
cmpl %r15d, %r12d
cmovael %r15d, %r12d
cmpb $0x0, 0xbb1b10(%rip) # 0xbff6e8
cmovel %r15d, %r12d
cmpq $0x0, 0xbb1a9c(%rip) # 0xbff680
jne 0x4ddc5
leaq 0xbb1a4f(%rip), %rdi # 0xbff640
callq 0x29220
cmpl 0xbb1a8f(%rip), %r12d # 0xbff68c
jbe 0x4dd69
movq %r14, %rdi
movl $0x1, %esi
callq 0x4a3dc
movl %eax, %r14d
cmpl %r12d, %eax
jae 0x4dd6d
leaq -0x230(%rbp), %r15
movl %r14d, %edi
callq 0x48ca4
testq %rax, %rax
je 0x4dd6d
cmpq $0x1, %rax
je 0x4ddb1
cmpq %rbx, %rax
jge 0x4dd6d
cmpl 0x3b0dc6(%rip), %r14d # 0x3fea14
jb 0x4dca3
cmpq $0x0, 0x3b0e50(%rip) # 0x3feaa8
jne 0x4dd29
leaq 0x3b0db3(%rip), %rdi # 0x3fea18
callq 0xa441d
leaq 0x3b0d77(%rip), %rdi # 0x3fe9e8
callq 0x91c93
movq (%rax), %r13
incl 0x3b0d95(%rip) # 0x3fea14
movq 0x3b0e22(%rip), %rdi # 0x3feaa8
testq %rdi, %rdi
jne 0x4dd33
leaq 0x3b0d82(%rip), %rdi # 0x3fea18
callq 0xa44be
movq %r13, %rdi
callq 0x4bce0
cmpq $0x0, 0x3af8ed(%rip) # 0x3fd598
movb $0x1, %al
jne 0x4dd10
cmpl $0x0, 0x3af8da(%rip) # 0x3fd590
jne 0x4dd10
movl %r14d, %edi
movq %r15, %rsi
callq 0x48abd
leaq 0x3af44a(%rip), %rax # 0x3fd114
movl (%rax), %esi
leaq 0x33833d(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x288(%rbp), %rdi
movl $0xe, %edx
movq %r15, %rcx
leaq -0x240(%rbp), %r8
callq *0x148(%rax)
movq %rax, -0x240(%rbp)
testq %rax, %rax
jne 0x4dd48
movl $0x10, %esi
movq %r15, %rdi
callq 0x9df38
testl %eax, %eax
sete %al
incl %r14d
cmpl %r12d, %r14d
jae 0x4ddb8
testb %al, %al
jne 0x4dc23
jmp 0x4ddb8
callq 0x2cbe4
jmp 0x4dc6a
leaq 0x3382d6(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x168(%rax)
jmp 0x4dc8f
movq %rax, %rdi
movq %r15, %rsi
leaq -0x240(%rbp), %rdx
leaq -0x234(%rbp), %rcx
callq 0x2cc02
movl -0x234(%rbp), %eax
jmp 0x4dd0b
xorl %ebx, %ebx
jmp 0x4dd76
xorl %ebx, %ebx
movl %r14d, 0xbb18c2(%rip) # 0xbff638
movq 0xbb1903(%rip), %rdi # 0xbff680
testq %rdi, %rdi
jne 0x4ddcf
leaq 0xbb18b7(%rip), %rdi # 0xbff640
callq 0x291e0
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x4dde1
movl %ebx, %eax
addq $0x268, %rsp # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
movb $0x1, %bl
jmp 0x4dd6f
xorl %ebx, %ebx
testb %al, %al
jne 0x4dd6f
movb $0x1, %bl
xorl %r14d, %r14d
jmp 0x4dd6f
callq 0x2cbc7
jmp 0x4dbf6
leaq 0x33823a(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x4dd82
callq 0x29270
| translog_purge:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 268h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r15, rdi
shr r15, 20h
call translog_get_horizon
mov r14, rax
mov r12d, cs:soft_sync_min
cmp r12d, r15d
cmovnb r12d, r15d
cmp cs:soft_sync, 0
cmovz r12d, r15d
cmp cs:qword_BFF680, 0
jnz loc_4DDC5
lea rdi, unk_BFF640
call _pthread_mutex_lock
loc_4DBF6:
cmp r12d, dword ptr cs:qword_BFF688+4
jbe loc_4DD69
mov rdi, r14
mov esi, 1
call translog_first_file
mov r14d, eax
cmp eax, r12d
jnb loc_4DD6D
lea r15, [rbp+var_230]
loc_4DC23:
mov edi, r14d
call translog_get_file_max_lsn_stored
test rax, rax
jz loc_4DD6D
cmp rax, 1
jz loc_4DDB1
cmp rax, rbx
jge loc_4DD6D
cmp r14d, dword ptr cs:qword_3FEA10+4
jb short loc_4DCA3
cmp cs:qword_3FEAA8, 0
jnz loc_4DD29
lea rdi, unk_3FEA18
call my_rw_wrlock
loc_4DC6A:
lea rdi, qword_3FE9E8
call pop_dynamic
mov r13, [rax]
inc dword ptr cs:qword_3FEA10+4
mov rdi, cs:qword_3FEAA8
test rdi, rdi
jnz loc_4DD33
loc_4DC8F:
lea rdi, unk_3FEA18
call my_rw_unlock
mov rdi, r13
call translog_close_log_file
loc_4DCA3:
cmp cs:log_purge_type, 0
mov al, 1
jnz short loc_4DD10
cmp cs:log_purge_disabled, 0
jnz short loc_4DD10
mov edi, r14d
mov rsi, r15
call translog_filename_by_fileno
lea rax, key_file_translog
mov esi, [rax]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_288]
mov edx, 0Eh
mov rcx, r15
lea r8, [rbp+var_240]
call qword ptr [rax+148h]
mov [rbp+var_240], rax
test rax, rax
jnz short loc_4DD48
mov esi, 10h
mov rdi, r15
call my_delete
loc_4DD0B:
test eax, eax
setz al
loc_4DD10:
inc r14d
cmp r14d, r12d
jnb loc_4DDB8
test al, al
jnz loc_4DC23
jmp loc_4DDB8
loc_4DD29:
call translog_purge_cold_2
jmp loc_4DC6A
loc_4DD33:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+168h]
jmp loc_4DC8F
loc_4DD48:
mov rdi, rax
mov rsi, r15
lea rdx, [rbp+var_240]
lea rcx, [rbp+var_234]
call translog_purge_cold_3
mov eax, [rbp+var_234]
jmp short loc_4DD0B
loc_4DD69:
xor ebx, ebx
jmp short loc_4DD76
loc_4DD6D:
xor ebx, ebx
loc_4DD6F:
mov dword ptr cs:qword_BFF638, r14d
loc_4DD76:
mov rdi, cs:qword_BFF680
test rdi, rdi
jnz short loc_4DDCF
loc_4DD82:
lea rdi, unk_BFF640
call _pthread_mutex_unlock
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_4DDE1
mov eax, ebx
add rsp, 268h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4DDB1:
xor r14d, r14d
mov bl, 1
jmp short loc_4DD6F
loc_4DDB8:
xor ebx, ebx
test al, al
jnz short loc_4DD6F
mov bl, 1
xor r14d, r14d
jmp short loc_4DD6F
loc_4DDC5:
call translog_purge_cold_1
jmp loc_4DBF6
loc_4DDCF:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_4DD82
loc_4DDE1:
call ___stack_chk_fail
| long long translog_purge(signed long long a1)
{
unsigned int v1; // ebx
unsigned long long horizon; // r14
unsigned int v3; // r12d
unsigned int file; // r14d
signed long long file_max_lsn_stored; // rax
long long v6; // rdx
long long v7; // rcx
int v8; // r8d
int v9; // r9d
long long v10; // r13
bool v11; // al
long long v12; // rax
unsigned int v13; // eax
_BYTE v15[72]; // [rsp+8h] [rbp-288h] BYREF
long long v16; // [rsp+50h] [rbp-240h] BYREF
unsigned int v17; // [rsp+5Ch] [rbp-234h] BYREF
_BYTE v18[512]; // [rsp+60h] [rbp-230h] BYREF
unsigned long long v19; // [rsp+260h] [rbp-30h]
v1 = a1;
v19 = __readfsqword(0x28u);
horizon = translog_get_horizon();
v3 = soft_sync_min;
if ( (unsigned int)soft_sync_min >= HIDWORD(a1) )
v3 = HIDWORD(a1);
if ( !soft_sync )
v3 = HIDWORD(a1);
if ( qword_BFF680 )
translog_purge_cold_1();
else
pthread_mutex_lock(&unk_BFF640);
if ( v3 <= HIDWORD(qword_BFF688) )
{
v1 = 0;
}
else
{
file = translog_first_file(horizon, 1);
if ( file < v3 )
{
while ( 1 )
{
file_max_lsn_stored = translog_get_file_max_lsn_stored(file);
if ( !file_max_lsn_stored )
break;
if ( file_max_lsn_stored == 1 )
{
file = 0;
LOBYTE(v1) = 1;
goto LABEL_30;
}
if ( file_max_lsn_stored >= a1 )
break;
if ( file >= HIDWORD(qword_3FEA10) )
{
if ( qword_3FEAA8 )
translog_purge_cold_2();
else
my_rw_wrlock(&unk_3FEA18);
v10 = *(_QWORD *)pop_dynamic(&qword_3FE9E8);
++HIDWORD(qword_3FEA10);
if ( qword_3FEAA8 )
PSI_server[45]();
my_rw_unlock(&unk_3FEA18);
translog_close_log_file(v10);
}
v11 = 1;
if ( !log_purge_type && !log_purge_disabled )
{
translog_filename_by_fileno(file, (long long)v18, v6, v7, v8, v9);
v12 = ((long long ( *)(_BYTE *, _QWORD, long long, _BYTE *, long long *))PSI_server[41])(
v15,
key_file_translog,
14LL,
v18,
&v16);
v16 = v12;
if ( v12 )
{
translog_purge_cold_3(v12, (long long)v18, &v16, &v17);
v13 = v17;
}
else
{
v13 = my_delete(v18, 16LL);
}
v11 = v13 == 0;
}
if ( ++file >= v3 || !v11 )
{
v1 = 0;
if ( !v11 )
{
LOBYTE(v1) = 1;
file = 0;
}
goto LABEL_30;
}
}
}
v1 = 0;
LABEL_30:
LODWORD(qword_BFF638) = file;
}
if ( qword_BFF680 )
PSI_server[44]();
pthread_mutex_unlock(&unk_BFF640);
return v1;
}
| translog_purge:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x268
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R15,RDI
SHR R15,0x20
CALL 0x0014bf54
MOV R14,RAX
MOV R12D,dword ptr [0x00cff6ec]
CMP R12D,R15D
CMOVNC R12D,R15D
CMP byte ptr [0x00cff6e8],0x0
CMOVZ R12D,R15D
CMP qword ptr [0x00cff680],0x0
JNZ 0x0014ddc5
LEA RDI,[0xcff640]
CALL 0x00129220
LAB_0014dbf6:
CMP R12D,dword ptr [0x00cff68c]
JBE 0x0014dd69
MOV RDI,R14
MOV ESI,0x1
CALL 0x0014a3dc
MOV R14D,EAX
CMP EAX,R12D
JNC 0x0014dd6d
LEA R15,[RBP + -0x230]
LAB_0014dc23:
MOV EDI,R14D
CALL 0x00148ca4
TEST RAX,RAX
JZ 0x0014dd6d
CMP RAX,0x1
JZ 0x0014ddb1
CMP RAX,RBX
JGE 0x0014dd6d
CMP R14D,dword ptr [0x004fea14]
JC 0x0014dca3
CMP qword ptr [0x004feaa8],0x0
JNZ 0x0014dd29
LEA RDI,[0x4fea18]
CALL 0x001a441d
LAB_0014dc6a:
LEA RDI,[0x4fe9e8]
CALL 0x00191c93
MOV R13,qword ptr [RAX]
INC dword ptr [0x004fea14]
MOV RDI,qword ptr [0x004feaa8]
TEST RDI,RDI
JNZ 0x0014dd33
LAB_0014dc8f:
LEA RDI,[0x4fea18]
CALL 0x001a44be
MOV RDI,R13
CALL 0x0014bce0
LAB_0014dca3:
CMP qword ptr [0x004fd598],0x0
MOV AL,0x1
JNZ 0x0014dd10
CMP dword ptr [0x004fd590],0x0
JNZ 0x0014dd10
MOV EDI,R14D
MOV RSI,R15
CALL 0x00148abd
LEA RAX,[0x4fd114]
MOV ESI,dword ptr [RAX]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x288]
MOV EDX,0xe
MOV RCX,R15
LEA R8,[RBP + -0x240]
CALL qword ptr [RAX + 0x148]
MOV qword ptr [RBP + -0x240],RAX
TEST RAX,RAX
JNZ 0x0014dd48
MOV ESI,0x10
MOV RDI,R15
CALL 0x0019df38
LAB_0014dd0b:
TEST EAX,EAX
SETZ AL
LAB_0014dd10:
INC R14D
CMP R14D,R12D
JNC 0x0014ddb8
TEST AL,AL
JNZ 0x0014dc23
JMP 0x0014ddb8
LAB_0014dd29:
CALL 0x0012cbe4
JMP 0x0014dc6a
LAB_0014dd33:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x0014dc8f
LAB_0014dd48:
MOV RDI,RAX
MOV RSI,R15
LEA RDX,[RBP + -0x240]
LEA RCX,[RBP + -0x234]
CALL 0x0012cc02
MOV EAX,dword ptr [RBP + -0x234]
JMP 0x0014dd0b
LAB_0014dd69:
XOR EBX,EBX
JMP 0x0014dd76
LAB_0014dd6d:
XOR EBX,EBX
LAB_0014dd6f:
MOV dword ptr [0x00cff638],R14D
LAB_0014dd76:
MOV RDI,qword ptr [0x00cff680]
TEST RDI,RDI
JNZ 0x0014ddcf
LAB_0014dd82:
LEA RDI,[0xcff640]
CALL 0x001291e0
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0014dde1
MOV EAX,EBX
ADD RSP,0x268
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014ddb1:
XOR R14D,R14D
MOV BL,0x1
JMP 0x0014dd6f
LAB_0014ddb8:
XOR EBX,EBX
TEST AL,AL
JNZ 0x0014dd6f
MOV BL,0x1
XOR R14D,R14D
JMP 0x0014dd6f
LAB_0014ddc5:
CALL 0x0012cbc7
JMP 0x0014dbf6
LAB_0014ddcf:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0014dd82
LAB_0014dde1:
CALL 0x00129270
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong translog_purge(long param_1)
{
uint uVar1;
int iVar2;
int8 uVar3;
long lVar4;
int8 *puVar5;
ulong uVar6;
uint uVar7;
long in_FS_OFFSET;
bool bVar8;
int1 local_290 [72];
long local_248;
int local_23c;
int1 local_238 [512];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = translog_get_horizon();
uVar1 = (uint)((ulong)param_1 >> 0x20);
uVar7 = soft_sync_min;
if (uVar1 <= soft_sync_min) {
uVar7 = uVar1;
}
if (soft_sync == '\0') {
uVar7 = uVar1;
}
if (DAT_00cff680 == 0) {
pthread_mutex_lock((pthread_mutex_t *)&DAT_00cff640);
}
else {
translog_purge_cold_1();
}
if (_DAT_00cff68c < uVar7) {
uVar1 = translog_first_file(uVar3,1);
if (uVar1 < uVar7) {
do {
lVar4 = translog_get_file_max_lsn_stored(uVar1);
if (lVar4 == 0) goto LAB_0014dd6d;
if (lVar4 == 1) {
DAT_00cff638 = 0;
uVar6 = CONCAT71((int7)((ulong)param_1 >> 8),1);
goto LAB_0014dd76;
}
if (param_1 <= lVar4) goto LAB_0014dd6d;
if (DAT_004fea14 <= uVar1) {
if (DAT_004feaa8 == 0) {
my_rw_wrlock(&DAT_004fea18);
}
else {
translog_purge_cold_2();
}
puVar5 = (int8 *)pop_dynamic(&DAT_004fe9e8);
uVar3 = *puVar5;
DAT_004fea14 = DAT_004fea14 + 1;
if (DAT_004feaa8 != 0) {
(**(code **)(PSI_server + 0x168))();
}
my_rw_unlock(&DAT_004fea18);
translog_close_log_file(uVar3);
}
bVar8 = true;
if ((log_purge_type == 0) && (log_purge_disabled == 0)) {
translog_filename_by_fileno(uVar1,local_238);
local_248 = (**(code **)(PSI_server + 0x148))
(local_290,key_file_translog,0xe,local_238,&local_248);
if (local_248 == 0) {
iVar2 = my_delete(local_238,0x10);
}
else {
translog_purge_cold_3(local_248,local_238,&local_248,&local_23c);
iVar2 = local_23c;
}
bVar8 = iVar2 == 0;
}
uVar1 = uVar1 + 1;
} while ((uVar1 < uVar7) && (bVar8));
uVar6 = 0;
DAT_00cff638 = uVar1;
if (!bVar8) {
uVar6 = 1;
DAT_00cff638 = 0;
}
}
else {
LAB_0014dd6d:
uVar6 = 0;
DAT_00cff638 = uVar1;
}
}
else {
uVar6 = 0;
}
LAB_0014dd76:
if (DAT_00cff680 != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)&DAT_00cff640);
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar6 & 0xffffffff;
}
| |
38,156 | 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>::operator[](unsigned long) | monkey531[P]llama/common/json.hpp | reference operator[](size_type idx)
{
// implicitly convert null value to an empty array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value.array = create<array_t>();
assert_invariant();
}
// operator[] only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
// fill up array with null values if given idx is outside range
if (idx >= m_data.m_value.array->size())
{
#if JSON_DIAGNOSTICS
// remember array size & capacity before resizing
const auto old_size = m_data.m_value.array->size();
const auto old_capacity = m_data.m_value.array->capacity();
#endif
m_data.m_value.array->resize(idx + 1);
#if JSON_DIAGNOSTICS
if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
{
// capacity has changed: update all parents
set_parents();
}
else
{
// set parent for values added above
set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
}
#endif
assert_invariant();
}
return m_data.m_value.array->operator[](idx);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
} | O1 | cpp | 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>::operator[](unsigned long):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0x6eae8
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x18690
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x3da52
cmpb $0x2, (%r14)
jne 0x6eb2f
movq 0x8(%r14), %rdi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x4, %rax
cmpq %rbx, %rax
ja 0x6eb18
leaq 0x1(%rbx), %rsi
callq 0x6ed92
movq %r14, %rdi
movl $0x1, %esi
callq 0x3da52
movq 0x8(%r14), %rax
shlq $0x4, %rbx
addq (%rax), %rbx
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x18350
movq %rax, %rbx
movq %r14, %rdi
callq 0x3e11c
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x3eff7(%rip), %rsi # 0xadb4a
leaq 0x10(%rsp), %rdi
callq 0x656d0
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x4a102
xorl %ebp, %ebp
leaq 0x6d74a(%rip), %rsi # 0xdc2c8
leaq -0x22401(%rip), %rdx # 0x4c784
movq %rbx, %rdi
callq 0x18b30
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ebb3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x6ebb3
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6ebc0
movq %rbx, %rdi
callq 0x184f0
movq %r14, %rdi
callq 0x18ba0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixEm:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
cmp byte ptr [rdi], 0
jnz short loc_6EAE8
mov byte ptr [r14], 2
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
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)
loc_6EAE8:
cmp byte ptr [r14], 2
jnz short loc_6EB2F
mov rdi, [r14+8]
mov rax, [rdi+8]
sub rax, [rdi]
sar rax, 4
cmp rax, rbx
ja short loc_6EB18
lea rsi, [rbx+1]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE6resizeEm; 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>>::resize(ulong)
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)
loc_6EB18:
mov rax, [r14+8]
shl rbx, 4
add rbx, [rax]
mov rax, rbx
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_6EB2F:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; 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>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseOpera; "cannot use operator[] with a numeric ar"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA52_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(char const(&)[52],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_6EBB3
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_6EBB3
mov r14, rax
mov bpl, 1
loc_6EBB3:
test bpl, bpl
jz short loc_6EBC0
mov rdi, rbx; void *
call ___cxa_free_exception
loc_6EBC0:
mov rdi, r14
call __Unwind_Resume
| long long 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[](
long long a1,
unsigned long long a2)
{
long long v3; // rax
_QWORD *v4; // rdi
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v7; // [rsp+8h] [rbp-40h] BYREF
_QWORD v8[2]; // [rsp+10h] [rbp-38h] BYREF
if ( !*(_BYTE *)a1 )
{
*(_BYTE *)a1 = 2;
v3 = operator new(0x18uLL);
*(_OWORD *)v3 = 0LL;
*(_QWORD *)(v3 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v3;
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 *)a1);
}
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
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>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(
(long long)v8,
(long long)"cannot use operator[] with a numeric argument with ",
&v7);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
305,
v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v4 = *(_QWORD **)(a1 + 8);
if ( (long long)(v4[1] - *v4) >> 4 <= a2 )
{
std::vector<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>>::resize(
v4,
a2 + 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((char *)a1);
}
return **(_QWORD **)(a1 + 8) + 16 * a2;
}
| operator[]:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
CMP byte ptr [RDI],0x0
JNZ 0x0016eae8
MOV byte ptr [R14],0x2
MOV EDI,0x18
CALL 0x00118690
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013da52
LAB_0016eae8:
CMP byte ptr [R14],0x2
JNZ 0x0016eb2f
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,qword ptr [RDI]
SAR RAX,0x4
CMP RAX,RBX
JA 0x0016eb18
LEA RSI,[RBX + 0x1]
CALL 0x0016ed92
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013da52
LAB_0016eb18:
MOV RAX,qword ptr [R14 + 0x8]
SHL RBX,0x4
ADD RBX,qword ptr [RAX]
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0016eb2f:
MOV EDI,0x20
CALL 0x00118350
MOV RBX,RAX
MOV RDI,R14
CALL 0x0013e11c
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0016eb4c:
LEA RSI,[0x1adb4a]
LEA RDI,[RSP + 0x10]
CALL 0x001656d0
MOV BPL,0x1
LAB_0016eb60:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x131
MOV RCX,R14
CALL 0x0014a102
XOR EBP,EBP
LEA RSI,[0x1dc2c8]
LEA RDX,[0x14c784]
MOV RDI,RBX
CALL 0x00118b30
|
/* 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[](unsigned long) */
long __thiscall
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[](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)
{
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_00;
int8 *puVar1;
int8 uVar2;
char *local_40;
detail local_38 [32];
if (*this == (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>
)0x0) {
*this = (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>
)0x2;
puVar1 = (int8 *)operator_new(0x18);
*puVar1 = 0;
puVar1[1] = 0;
puVar1[2] = 0;
*(int8 **)(this + 8) = puVar1;
assert_invariant(SUB81(this,0));
}
if (*this == (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>
)0x2) {
this_00 = *(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);
if ((ulong)(*(long *)(this_00 + 8) - *(long *)this_00 >> 4) <= param_1) {
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>>>
::resize(this_00,param_1 + 1);
assert_invariant(SUB81(this,0));
}
return param_1 * 0x10 + **(long **)(this + 8);
}
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 0016eb4c to 0016eb5c has its CatchHandler @ 0016ebad */
detail::concat<std::__cxx11::string,char_const(&)[52],char_const*>
(local_38,"cannot use operator[] with a numeric argument with ",&local_40);
/* try { // try from 0016eb60 to 0016eb8c has its CatchHandler @ 0016eb8d */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x131,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
38,157 | IOS::HLE::ESCore::GetInstalledTitles() const | Dolphin-anty/Source/Core/Core/IOS/ES/NandUtils.cpp | std::vector<u64> ESCore::GetInstalledTitles() const
{
return GetTitlesInTitleOrImport(m_ios.GetFS().get(), "/title");
} | O3 | cpp | IOS::HLE::ESCore::GetInstalledTitles() const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x25162a
movq (%r14), %r14
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x838741(%rip), %rsi # 0xa75d83
leaq 0x838740(%rip), %rdx # 0xa75d89
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x176f78
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x23d697
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x23d679
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x10fa70
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23d688
callq 0x1859c6
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZNK3IOS3HLE6ESCore18GetInstalledTitlesEv:
push r15
push r14
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
mov rsi, [rsi]
lea r14, [rsp+58h+var_50]
mov rdi, r14; this
call _ZN3IOS3HLE6Kernel5GetFSEv; IOS::HLE::Kernel::GetFS(void)
mov r14, [r14]
lea r12, [rsp+58h+var_30]
mov [r12-10h], r12
lea rsi, aShared2Title+8; "/title"
lea rdx, aShared2Title+0Eh; ""
lea r15, [rsp+58h+var_40]
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call _ZN3IOS3HLEL24GetTitlesInTitleOrImportEPNS0_2FS10FileSystemERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; IOS::HLE::GetTitlesInTitleOrImport(IOS::HLE::FS::FileSystem *,std::string const&)
mov rdi, [r15]; void *
cmp rdi, r12
jz short loc_23D679
mov rsi, [rsp+58h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_23D679:
mov rdi, [rsp+58h+var_48]
test rdi, rdi
jz short loc_23D688
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_23D688:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r14
pop r15
retn
| IOS::HLE::ESCore * IOS::HLE::ESCore::GetInstalledTitles(IOS::HLE::ESCore *this)
{
long long v1; // r14
long long v3; // [rsp+8h] [rbp-50h] BYREF
volatile signed __int32 *v4; // [rsp+10h] [rbp-48h]
void *v5[2]; // [rsp+18h] [rbp-40h] BYREF
_QWORD v6[6]; // [rsp+28h] [rbp-30h] BYREF
IOS::HLE::Kernel::GetFS((IOS::HLE::Kernel *)&v3);
v1 = v3;
v5[0] = v6;
std::string::_M_construct<char const*>(v5, "/title", (long long)"");
IOS::HLE::GetTitlesInTitleOrImport(this, v1, v5);
if ( v5[0] != v6 )
operator delete(v5[0], v6[0] + 1LL);
if ( v4 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v4);
return this;
}
| allocate:
PUSH RAX
SHR RDI,0x3d
JZ 0x0023d61c
CALL 0x0020f0a0
LAB_0023d61c:
CALL 0x00210680
|
/* __gnu_cxx::new_allocator<spv::Instruction*>::allocate(unsigned long, void const*) [clone .cold.1]
*/
void __gnu_cxx::new_allocator<spv::Instruction*>::allocate(ulong param_1,void *param_2)
{
if (param_1 >> 0x3d != 0) {
std::__throw_bad_array_new_length();
}
/* WARNING: Subroutine does not return */
std::__throw_bad_alloc();
}
| |
38,158 | my_casedn_utf16 | eloqsql/strings/ctype-ucs2.c | static size_t
my_casedn_utf16(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= cs->cset->wc_mb;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= mb_wc(cs, &wc, (uchar *) src, (uchar *) srcend)) > 0)
{
my_tolower_utf16(uni_plane, &wc);
if (res != wc_mb(cs, wc, (uchar *) dst, (uchar *) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
} | O3 | c | my_casedn_utf16:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
testq %rdx, %rdx
jle 0x46ce7
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x78(%rdi), %rax
movq %rax, -0x50(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
leaq (%rsi,%rax), %r14
addq %r15, -0x38(%rbp)
movq %r13, %rdi
leaq -0x40(%rbp), %rsi
movq %r12, %rdx
movq %r14, %rcx
callq *-0x58(%rbp)
testl %eax, %eax
jle 0x46ce7
movl %eax, %ebx
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rax
cmpq (%rax), %rsi
ja 0x46cc9
movq 0x8(%rax), %rax
movq %rsi, %rcx
shrq $0x8, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x46cc9
movzbl %sil, %ecx
leaq (%rcx,%rcx,2), %rcx
movl 0x4(%rax,%rcx,4), %esi
movq %rsi, -0x40(%rbp)
movq %r13, %rdi
movq %r15, %rdx
movq -0x38(%rbp), %rcx
callq *-0x48(%rbp)
cmpl %eax, %ebx
jne 0x46ce7
movl %ebx, %eax
addq %rax, %r12
addq %rax, %r15
cmpq %r14, %r12
jb 0x46c82
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_casedn_utf16:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rbp+var_38], r8
mov [rbp+var_30], rdx
test rdx, rdx
jle loc_46CE7
mov r15, rcx
mov r12, rsi
mov r13, rdi
mov rax, [rdi+78h]
mov [rbp+var_50], rax
mov rax, [rdi+0B8h]
mov rcx, [rax+28h]
mov [rbp+var_58], rcx
mov rax, [rax+30h]
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
lea r14, [rsi+rax]
add [rbp+var_38], r15
loc_46C82:
mov rdi, r13
lea rsi, [rbp+var_40]
mov rdx, r12
mov rcx, r14
call [rbp+var_58]
test eax, eax
jle short loc_46CE7
mov ebx, eax
mov rsi, [rbp+var_40]
mov rax, [rbp+var_50]
cmp rsi, [rax]
ja short loc_46CC9
mov rax, [rax+8]
mov rcx, rsi
shr rcx, 8
mov rax, [rax+rcx*8]
test rax, rax
jz short loc_46CC9
movzx ecx, sil
lea rcx, [rcx+rcx*2]
mov esi, [rax+rcx*4+4]
mov [rbp+var_40], rsi
loc_46CC9:
mov rdi, r13
mov rdx, r15
mov rcx, [rbp+var_38]
call [rbp+var_48]
cmp ebx, eax
jnz short loc_46CE7
mov eax, ebx
add r12, rax
add r15, rax
cmp r12, r14
jb short loc_46C82
loc_46CE7:
mov rax, [rbp+var_30]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_casedn_utf16(long long a1, unsigned long long a2, long long a3, long long a4, long long a5)
{
long long v5; // r15
unsigned long long v6; // r12
long long v7; // rax
unsigned long long v8; // r14
int v9; // eax
unsigned int v10; // ebx
unsigned long long v11; // rsi
long long v12; // rax
long long ( *v14)(long long, unsigned long long *, unsigned long long, unsigned long long); // [rsp+8h] [rbp-58h]
unsigned long long *v15; // [rsp+10h] [rbp-50h]
unsigned int ( *v16)(long long, unsigned long long, long long, long long); // [rsp+18h] [rbp-48h]
unsigned long long v17; // [rsp+20h] [rbp-40h] BYREF
long long v18; // [rsp+28h] [rbp-38h]
long long v19; // [rsp+30h] [rbp-30h]
v18 = a5;
v19 = a3;
if ( a3 > 0 )
{
v5 = a4;
v6 = a2;
v15 = *(unsigned long long **)(a1 + 120);
v7 = *(_QWORD *)(a1 + 184);
v14 = *(long long ( **)(long long, unsigned long long *, unsigned long long, unsigned long long))(v7 + 40);
v16 = *(unsigned int ( **)(long long, unsigned long long, long long, long long))(v7 + 48);
v8 = a2 + v19;
v18 += a4;
do
{
v9 = v14(a1, &v17, v6, v8);
if ( v9 <= 0 )
break;
v10 = v9;
v11 = v17;
if ( v17 <= *v15 )
{
v12 = *(_QWORD *)(v15[1] + 8 * (v17 >> 8));
if ( v12 )
{
v11 = *(unsigned int *)(v12 + 12LL * (unsigned __int8)v17 + 4);
v17 = v11;
}
}
if ( v10 != v16(a1, v11, v5, v18) )
break;
v6 += v10;
v5 += v10;
}
while ( v6 < v8 );
}
return v19;
}
| my_casedn_utf16:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],R8
MOV qword ptr [RBP + -0x30],RDX
TEST RDX,RDX
JLE 0x00146ce7
MOV R15,RCX
MOV R12,RSI
MOV R13,RDI
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV RCX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x58],RCX
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
LEA R14,[RSI + RAX*0x1]
ADD qword ptr [RBP + -0x38],R15
LAB_00146c82:
MOV RDI,R13
LEA RSI,[RBP + -0x40]
MOV RDX,R12
MOV RCX,R14
CALL qword ptr [RBP + -0x58]
TEST EAX,EAX
JLE 0x00146ce7
MOV EBX,EAX
MOV RSI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x50]
CMP RSI,qword ptr [RAX]
JA 0x00146cc9
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,RSI
SHR RCX,0x8
MOV RAX,qword ptr [RAX + RCX*0x8]
TEST RAX,RAX
JZ 0x00146cc9
MOVZX ECX,SIL
LEA RCX,[RCX + RCX*0x2]
MOV ESI,dword ptr [RAX + RCX*0x4 + 0x4]
MOV qword ptr [RBP + -0x40],RSI
LAB_00146cc9:
MOV RDI,R13
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x38]
CALL qword ptr [RBP + -0x48]
CMP EBX,EAX
JNZ 0x00146ce7
MOV EAX,EBX
ADD R12,RAX
ADD R15,RAX
CMP R12,R14
JC 0x00146c82
LAB_00146ce7:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_casedn_utf16(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
ulong uVar1;
ulong *puVar2;
code *pcVar3;
code *pcVar4;
long lVar5;
uint uVar6;
uint uVar7;
ulong local_48;
long local_40;
long local_38;
local_38 = param_3;
if (0 < param_3) {
puVar2 = *(ulong **)(param_1 + 0x78);
pcVar3 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
pcVar4 = *(code **)(*(long *)(param_1 + 0xb8) + 0x30);
uVar1 = param_2 + param_3;
local_40 = param_5 + param_4;
do {
uVar6 = (*pcVar3)(param_1,&local_48,param_2,uVar1);
if ((int)uVar6 < 1) {
return local_38;
}
if ((local_48 <= *puVar2) && (lVar5 = *(long *)(puVar2[1] + (local_48 >> 8) * 8), lVar5 != 0))
{
local_48 = (ulong)*(uint *)(lVar5 + 4 + (local_48 & 0xff) * 0xc);
}
uVar7 = (*pcVar4)(param_1,local_48,param_4,local_40);
if (uVar6 != uVar7) {
return local_38;
}
param_2 = param_2 + uVar6;
param_4 = param_4 + (ulong)uVar6;
} while (param_2 < uVar1);
}
return local_38;
}
| |
38,159 | js_proxy_get | bluesky950520[P]quickjs/quickjs.c | static JSValue js_proxy_get(JSContext *ctx, JSValue obj, JSAtom atom,
JSValue receiver)
{
JSProxyData *s;
JSValue method, ret, atom_val;
int res;
JSValue args[3];
JSPropertyDescriptor desc;
s = get_proxy_method(ctx, &method, obj, JS_ATOM_get);
if (!s)
return JS_EXCEPTION;
/* Note: recursion is possible thru the prototype of s->target */
if (JS_IsUndefined(method))
return JS_GetPropertyInternal(ctx, s->target, atom, receiver, FALSE);
atom_val = JS_AtomToValue(ctx, atom);
if (JS_IsException(atom_val)) {
JS_FreeValue(ctx, method);
return JS_EXCEPTION;
}
args[0] = s->target;
args[1] = atom_val;
args[2] = receiver;
ret = JS_CallFree(ctx, method, s->handler, 3, args);
JS_FreeValue(ctx, atom_val);
if (JS_IsException(ret))
return JS_EXCEPTION;
res = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(s->target), atom);
if (res < 0) {
JS_FreeValue(ctx, ret);
return JS_EXCEPTION;
}
if (res) {
if ((desc.flags & (JS_PROP_GETSET | JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE)) == 0) {
if (!js_same_value(ctx, desc.value, ret)) {
goto fail;
}
} else if ((desc.flags & (JS_PROP_GETSET | JS_PROP_CONFIGURABLE)) == JS_PROP_GETSET) {
if (JS_IsUndefined(desc.getter) && !JS_IsUndefined(ret)) {
fail:
js_free_desc(ctx, &desc);
JS_FreeValue(ctx, ret);
return JS_ThrowTypeError(ctx, "proxy: inconsistent get");
}
}
js_free_desc(ctx, &desc);
}
return ret;
} | O1 | c | js_proxy_get:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r15
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
movl $0x42, %r8d
callq 0x4143c
movl $0x6, %edx
testq %rax, %rax
je 0x5311b
movq %rax, %r13
movq 0x10(%rsp), %rbx
cmpl $0x3, %ebx
jne 0x53125
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
movl %ebp, %ecx
movq %r12, %r8
movq %r15, %r9
pushq $0x0
pushq $0x0
callq 0x26fff
addq $0x10, %rsp
movq %rax, %r15
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
jmp 0x531c1
xorl %r15d, %r15d
xorl %ecx, %ecx
jmp 0x531c1
movq %r14, %rdi
movl %ebp, 0x4(%rsp)
movl %ebp, %esi
xorl %edx, %edx
callq 0x247b6
movq %rdx, %rbp
cmpl $0x6, %ebp
jne 0x53150
movq 0x8(%rsp), %rsi
movq 0x18(%r14), %rdi
movq %rbx, %rdx
callq 0x21922
jmp 0x531b7
movups (%r13), %xmm0
leaq 0x50(%rsp), %r10
movaps %xmm0, (%r10)
movq %rax, 0x10(%r10)
movq %rbp, 0x18(%r10)
movq %r12, 0x20(%r10)
movq %r15, 0x28(%r10)
movq %rax, %r12
movq 0x8(%rsp), %rsi
movq 0x10(%r13), %rcx
movq 0x18(%r13), %r8
subq $0x8, %rsp
movq %r14, %rdi
movq %rbx, %rdx
movl $0x3, %r9d
pushq %r10
callq 0x26cf9
addq $0x10, %rsp
movq %rax, %r15
movq 0x18(%r14), %rdi
movq %r12, %rsi
movq %rdx, %r12
movq %rbp, %rdx
callq 0x21922
movl %r12d, %ebx
cmpq $0x6, %rbx
jne 0x531d9
xorl %r15d, %r15d
xorl %ecx, %ecx
movl $0x6, %edx
movl %r15d, %eax
orq %rcx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r13), %rdx
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
movl 0x4(%rsp), %ecx
callq 0x27c35
testl %eax, %eax
js 0x5324b
je 0x53283
movl 0x18(%rsp), %eax
testb $0x13, %al
je 0x5325a
andl $0x11, %eax
cmpl $0x10, %eax
jne 0x53276
cmpl $0x3, %ebx
je 0x53276
movl 0x38(%rsp), %eax
cmpl $0x3, %eax
jne 0x53276
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x4191f
movq 0x18(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x21922
leaq 0x51166(%rip), %rsi # 0xa439f
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x265c3
jmp 0x531ba
movq 0x18(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
jmp 0x53149
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rcx
movq %r12, %r8
callq 0x2a4bd
testl %eax, %eax
je 0x53216
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x4191f
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r15, %rcx
andq %rax, %rcx
movq %r12, %rdx
jmp 0x531c1
| js_proxy_get:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov r15, r9
mov r12, r8
mov ebp, ecx
mov rcx, rdx
mov rdx, rsi
mov r14, rdi
lea rsi, [rsp+0B8h+var_B0]
mov r8d, 42h ; 'B'
call get_proxy_method
mov edx, 6
test rax, rax
jz short loc_5311B
mov r13, rax
mov rbx, [rsp+0B8h+var_A8]
cmp ebx, 3
jnz short loc_53125
mov rsi, [r13+0]
mov rdx, [r13+8]
mov rdi, r14
mov ecx, ebp
mov r8, r12
mov r9, r15
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov r15, rax
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
jmp loc_531C1
loc_5311B:
xor r15d, r15d
xor ecx, ecx
jmp loc_531C1
loc_53125:
mov rdi, r14
mov [rsp+0B8h+var_B4], ebp
mov esi, ebp
xor edx, edx
call __JS_AtomToValue
mov rbp, rdx
cmp ebp, 6
jnz short loc_53150
mov rsi, [rsp+0B8h+var_B0]
mov rdi, [r14+18h]
mov rdx, rbx
loc_53149:
call JS_FreeValueRT
jmp short loc_531B7
loc_53150:
movups xmm0, xmmword ptr [r13+0]
lea r10, [rsp+0B8h+var_68]
movaps xmmword ptr [r10], xmm0
mov [r10+10h], rax
mov [r10+18h], rbp
mov [r10+20h], r12
mov [r10+28h], r15
mov r12, rax
mov rsi, [rsp+0B8h+var_B0]
mov rcx, [r13+10h]
mov r8, [r13+18h]
sub rsp, 8
mov rdi, r14
mov rdx, rbx
mov r9d, 3
push r10
call JS_CallFree
add rsp, 10h
mov r15, rax
mov rdi, [r14+18h]
mov rsi, r12
mov r12, rdx
mov rdx, rbp
call JS_FreeValueRT
mov ebx, r12d
cmp rbx, 6
jnz short loc_531D9
loc_531B7:
xor r15d, r15d
loc_531BA:
xor ecx, ecx
mov edx, 6
loc_531C1:
mov eax, r15d
or rax, rcx
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_531D9:
mov rdx, [r13+0]
lea rsi, [rsp+0B8h+var_A0]
mov rdi, r14
mov ecx, [rsp+0B8h+var_B4]
call JS_GetOwnPropertyInternal
test eax, eax
js short loc_5324B
jz loc_53283
mov eax, [rsp+0B8h+var_A0]
test al, 13h
jz short loc_5325A
and eax, 11h
cmp eax, 10h
jnz short loc_53276
cmp ebx, 3
jz short loc_53276
mov eax, [rsp+0B8h+var_80]
cmp eax, 3
jnz short loc_53276
loc_53216:
lea rsi, [rsp+0B8h+var_A0]
mov rdi, r14
call js_free_desc
mov rdi, [r14+18h]
mov rsi, r15
mov rdx, r12
call JS_FreeValueRT
lea rsi, aProxyInconsist_6; "proxy: inconsistent get"
xor r15d, r15d
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
jmp loc_531BA
loc_5324B:
mov rdi, [r14+18h]
mov rsi, r15
mov rdx, r12
jmp loc_53149
loc_5325A:
mov rsi, [rsp+0B8h+var_98]
mov rdx, [rsp+0B8h+var_90]
mov rdi, r14
mov rcx, r15
mov r8, r12
call js_same_value
test eax, eax
jz short loc_53216
loc_53276:
lea rsi, [rsp+0B8h+var_A0]
mov rdi, r14
call js_free_desc
loc_53283:
mov rax, 0FFFFFFFF00000000h
mov rcx, r15
and rcx, rax
mov rdx, r12
jmp loc_531C1
| unsigned long long js_proxy_get(
long long a1,
long long a2,
long long a3,
unsigned int 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; // r15
long long *proxy_method; // rax
long long *v18; // r13
long long v19; // rbx
unsigned long long PropertyInternal2; // rax
unsigned long long v21; // rcx
long long v22; // rax
long long v23; // rdx
long long v24; // rbp
_DWORD *v25; // rsi
long long v26; // rdi
long long v27; // rdx
__m128 v28; // xmm0
_DWORD *v29; // r12
_DWORD *v30; // rsi
long long v31; // rdx
long long v32; // r12
int OwnPropertyInternal; // eax
long long v35; // rdx
long long v36; // rcx
long long v37; // r8
long long v38; // r9
__m128 v39; // xmm4
__m128 v40; // xmm5
char v41; // [rsp+0h] [rbp-B8h]
int v42; // [rsp+4h] [rbp-B4h]
_DWORD *v43; // [rsp+8h] [rbp-B0h] BYREF
long long v44; // [rsp+10h] [rbp-A8h]
int v45; // [rsp+18h] [rbp-A0h] BYREF
_DWORD *v46; // [rsp+20h] [rbp-98h]
long long v47; // [rsp+28h] [rbp-90h]
int v48; // [rsp+38h] [rbp-80h]
__m128 v49; // [rsp+50h] [rbp-68h] BYREF
long long v50; // [rsp+60h] [rbp-58h]
long long v51; // [rsp+68h] [rbp-50h]
long long v52; // [rsp+70h] [rbp-48h]
long long v53; // [rsp+78h] [rbp-40h]
v14 = a6;
proxy_method = (long long *)get_proxy_method(
a1,
(unsigned long long *)&v43,
a2,
a3,
66LL,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14);
if ( !proxy_method )
{
LODWORD(v14) = 0;
v21 = 0LL;
return v21 | (unsigned int)v14;
}
v18 = proxy_method;
v19 = v44;
if ( (_DWORD)v44 != 3 )
{
v42 = a4;
v22 = _JS_AtomToValue(a1, a4, 0);
v24 = v23;
if ( (_DWORD)v23 == 6 )
{
v25 = v43;
v26 = *(_QWORD *)(a1 + 24);
v27 = v19;
LABEL_7:
JS_FreeValueRT(v26, v25, v27);
LABEL_9:
LODWORD(v14) = 0;
LABEL_10:
v21 = 0LL;
return v21 | (unsigned int)v14;
}
v28 = *(__m128 *)v18;
v49 = *(__m128 *)v18;
v50 = v22;
v51 = v23;
v52 = a5;
v53 = v14;
v29 = (_DWORD *)v22;
v14 = JS_CallFree(a1, v43, v19, v18[2], v18[3], 3, (long long)&v49);
v30 = v29;
v32 = v31;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v30, v24);
if ( (unsigned int)v32 == 6LL )
goto LABEL_9;
OwnPropertyInternal = JS_GetOwnPropertyInternal(a1, (long long)&v45, *v18, v42);
if ( OwnPropertyInternal < 0 )
{
v26 = *(_QWORD *)(a1 + 24);
v25 = (_DWORD *)v14;
v27 = v32;
goto LABEL_7;
}
if ( OwnPropertyInternal )
{
if ( (v45 & 0x13) != 0 )
{
if ( (v45 & 0x11) == 0x10 && (_DWORD)v32 != 3 && v48 == 3 )
goto LABEL_18;
}
else if ( !(unsigned int)js_same_value(a1, v46, v47, (_DWORD *)v14, v32) )
{
LABEL_18:
js_free_desc(a1, (long long)&v45);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v14, v32);
LODWORD(v14) = 0;
JS_ThrowTypeError(
a1,
(long long)"proxy: inconsistent get",
v35,
v36,
v37,
v38,
v28,
a8,
a9,
a10,
v39,
v40,
a13,
a14,
v41);
goto LABEL_10;
}
js_free_desc(a1, (long long)&v45);
}
v21 = v14 & 0xFFFFFFFF00000000LL;
return v21 | (unsigned int)v14;
}
PropertyInternal2 = JS_GetPropertyInternal2(a1, *proxy_method, proxy_method[1], a4, a5, v14, 0LL, 0);
LODWORD(v14) = PropertyInternal2;
v21 = PropertyInternal2 & 0xFFFFFFFF00000000LL;
return v21 | (unsigned int)v14;
}
| js_proxy_get:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R15,R9
MOV R12,R8
MOV EBP,ECX
MOV RCX,RDX
MOV RDX,RSI
MOV R14,RDI
LEA RSI,[RSP + 0x8]
MOV R8D,0x42
CALL 0x0014143c
MOV EDX,0x6
TEST RAX,RAX
JZ 0x0015311b
MOV R13,RAX
MOV RBX,qword ptr [RSP + 0x10]
CMP EBX,0x3
JNZ 0x00153125
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOV RDI,R14
MOV ECX,EBP
MOV R8,R12
MOV R9,R15
PUSH 0x0
PUSH 0x0
CALL 0x00126fff
ADD RSP,0x10
MOV R15,RAX
MOV RCX,-0x100000000
AND RCX,RAX
JMP 0x001531c1
LAB_0015311b:
XOR R15D,R15D
XOR ECX,ECX
JMP 0x001531c1
LAB_00153125:
MOV RDI,R14
MOV dword ptr [RSP + 0x4],EBP
MOV ESI,EBP
XOR EDX,EDX
CALL 0x001247b6
MOV RBP,RDX
CMP EBP,0x6
JNZ 0x00153150
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [R14 + 0x18]
MOV RDX,RBX
LAB_00153149:
CALL 0x00121922
JMP 0x001531b7
LAB_00153150:
MOVUPS XMM0,xmmword ptr [R13]
LEA R10,[RSP + 0x50]
MOVAPS xmmword ptr [R10],XMM0
MOV qword ptr [R10 + 0x10],RAX
MOV qword ptr [R10 + 0x18],RBP
MOV qword ptr [R10 + 0x20],R12
MOV qword ptr [R10 + 0x28],R15
MOV R12,RAX
MOV RSI,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [R13 + 0x10]
MOV R8,qword ptr [R13 + 0x18]
SUB RSP,0x8
MOV RDI,R14
MOV RDX,RBX
MOV R9D,0x3
PUSH R10
CALL 0x00126cf9
ADD RSP,0x10
MOV R15,RAX
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,R12
MOV R12,RDX
MOV RDX,RBP
CALL 0x00121922
MOV EBX,R12D
CMP RBX,0x6
JNZ 0x001531d9
LAB_001531b7:
XOR R15D,R15D
LAB_001531ba:
XOR ECX,ECX
MOV EDX,0x6
LAB_001531c1:
MOV EAX,R15D
OR RAX,RCX
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001531d9:
MOV RDX,qword ptr [R13]
LEA RSI,[RSP + 0x18]
MOV RDI,R14
MOV ECX,dword ptr [RSP + 0x4]
CALL 0x00127c35
TEST EAX,EAX
JS 0x0015324b
JZ 0x00153283
MOV EAX,dword ptr [RSP + 0x18]
TEST AL,0x13
JZ 0x0015325a
AND EAX,0x11
CMP EAX,0x10
JNZ 0x00153276
CMP EBX,0x3
JZ 0x00153276
MOV EAX,dword ptr [RSP + 0x38]
CMP EAX,0x3
JNZ 0x00153276
LAB_00153216:
LEA RSI,[RSP + 0x18]
MOV RDI,R14
CALL 0x0014191f
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,R15
MOV RDX,R12
CALL 0x00121922
LEA RSI,[0x1a439f]
XOR R15D,R15D
MOV RDI,R14
XOR EAX,EAX
CALL 0x001265c3
JMP 0x001531ba
LAB_0015324b:
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,R15
MOV RDX,R12
JMP 0x00153149
LAB_0015325a:
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV RDI,R14
MOV RCX,R15
MOV R8,R12
CALL 0x0012a4bd
TEST EAX,EAX
JZ 0x00153216
LAB_00153276:
LEA RSI,[RSP + 0x18]
MOV RDI,R14
CALL 0x0014191f
LAB_00153283:
MOV RAX,-0x100000000
MOV RCX,R15
AND RCX,RAX
MOV RDX,R12
JMP 0x001531c1
|
ulong js_proxy_get(long param_1,int8 param_2,int8 param_3,int4 param_4,
int8 param_5,int8 param_6)
{
int iVar1;
int8 *puVar2;
ulong uVar3;
ulong uVar4;
int8 uVar5;
int1 auVar6 [16];
int1 auVar7 [16];
ulong local_b0;
int8 local_a8;
uint local_a0 [2];
int8 local_98;
int8 local_90;
int local_80;
int4 local_68;
int4 uStack_64;
int4 uStack_60;
int4 uStack_5c;
int1 local_58 [16];
int8 local_48;
int8 local_40;
puVar2 = (int8 *)get_proxy_method(param_1,&local_b0,param_2,param_3,0x42);
if (puVar2 == (int8 *)0x0) {
uVar3 = 0;
uVar4 = 0;
goto LAB_001531c1;
}
if ((int)local_a8 == 3) {
uVar3 = JS_GetPropertyInternal2(param_1,*puVar2,puVar2[1],param_4,param_5,param_6,0,0);
uVar4 = uVar3 & 0xffffffff00000000;
goto LAB_001531c1;
}
auVar6 = __JS_AtomToValue(param_1,param_4,0);
auVar7._8_8_ = local_a8;
auVar7._0_8_ = local_b0;
if (auVar6._8_4_ == 6) {
uVar5 = *(int8 *)(param_1 + 0x18);
LAB_00153149:
JS_FreeValueRT(uVar5,auVar7._0_8_,auVar7._8_8_);
}
else {
local_68 = *(int4 *)puVar2;
uStack_64 = *(int4 *)((long)puVar2 + 4);
uStack_60 = *(int4 *)(puVar2 + 1);
uStack_5c = *(int4 *)((long)puVar2 + 0xc);
local_48 = param_5;
local_40 = param_6;
local_58 = auVar6;
auVar7 = JS_CallFree(param_1,local_b0,local_a8,puVar2[2],puVar2[3],3,&local_68);
uVar4 = auVar7._8_8_;
uVar3 = auVar7._0_8_;
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar6._0_8_,auVar6._8_8_);
if ((uVar4 & 0xffffffff) != 6) {
iVar1 = JS_GetOwnPropertyInternal(param_1,local_a0,*puVar2,param_4);
if (iVar1 < 0) {
uVar5 = *(int8 *)(param_1 + 0x18);
goto LAB_00153149;
}
if (iVar1 == 0) {
LAB_00153283:
uVar4 = uVar3 & 0xffffffff00000000;
goto LAB_001531c1;
}
if ((local_a0[0] & 0x13) == 0) {
iVar1 = js_same_value(param_1,local_98,local_90,uVar3,uVar4);
if (iVar1 != 0) goto LAB_00153276;
}
else if ((((local_a0[0] & 0x11) != 0x10) || (auVar7._8_4_ == 3)) || (local_80 != 3)) {
LAB_00153276:
js_free_desc(param_1,local_a0);
goto LAB_00153283;
}
js_free_desc(param_1,local_a0);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar3,uVar4);
JS_ThrowTypeError(param_1,"proxy: inconsistent get");
}
}
uVar3 = 0;
uVar4 = 0;
LAB_001531c1:
return uVar3 & 0xffffffff | uVar4;
}
| |
38,160 | 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 0x15370
cmpq $-0x1, %rax
je 0x1c1e0
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 0x15a50
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2deb4
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1c1bf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x15100
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r12, %rbp
addq %rcx, %rbp
movq %r14, %rdi
movq %rbp, %rdx
callq 0x15370
movq %rax, %r12
cmpq $-0x1, %rax
jne 0x1c184
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq $-0x1, %rcx
callq 0x15a50
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2deb4
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c21f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x15100
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 0x1c253
jmp 0x1c241
movq %rax, %r14
jmp 0x1c265
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1c265
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x15100
movq %rbx, %rdi
callq 0x1956e
movq %r14, %rdi
callq 0x15680
| _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_1C1E0
mov r12, rax
xor ebp, ebp
lea r13, [rsp+58h+var_50]
loc_1C184:
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_1C1BF
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1C1BF:
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_1C184
loc_1C1E0:
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_1C21F
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1C21F:
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_1C253
jmp short $+2
loc_1C241:
mov r14, rax
jmp short loc_1C265
mov r14, rax
mov rdi, [rsp+arg_0]; void *
lea rax, [rsp+arg_10]
loc_1C253:
cmp rdi, rax
jz short loc_1C265
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1C265:
mov rdi, rbx
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 0x00115370
CMP RAX,-0x1
JZ 0x0011c1e0
MOV R12,RAX
XOR EBP,EBP
LEA R13,[RSP + 0x8]
LAB_0011c184:
MOV RCX,R12
SUB RCX,RBP
LAB_0011c18a:
MOV RDI,R13
MOV RSI,R14
MOV RDX,RBP
CALL 0x00115a50
LAB_0011c198:
MOV RDI,RBX
MOV RSI,R13
CALL 0x0012deb4
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x0011c1bf
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00115100
LAB_0011c1bf:
MOV RSI,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV RBP,R12
ADD RBP,RCX
MOV RDI,R14
MOV RDX,RBP
CALL 0x00115370
MOV R12,RAX
CMP RAX,-0x1
JNZ 0x0011c184
LAB_0011c1e0:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV RDX,RBP
MOV RCX,-0x1
CALL 0x00115a50
LAB_0011c1f7:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0012deb4
LAB_0011c204:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0011c21f
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00115100
LAB_0011c21f:
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 0011c18a to 0011c197 has its CatchHandler @ 0011c241 */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_2);
/* try { // try from 0011c198 to 0011c1a2 has its CatchHandler @ 0011c246 */
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 0011c1e0 to 0011c1f6 has its CatchHandler @ 0011c23f */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_2);
/* try { // try from 0011c1f7 to 0011c203 has its CatchHandler @ 0011c231 */
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;
}
| |
38,161 | JS_GetPrototypeFree | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_GetPrototypeFree(JSContext *ctx, JSValue obj)
{
JSValue obj1;
obj1 = JS_GetPrototype(ctx, obj);
JS_FreeValue(ctx, obj);
return obj1;
} | O3 | c | JS_GetPrototypeFree:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
callq 0x2246a
movq %rax, %r15
movq %rdx, %r12
cmpl $-0x9, %ebx
jb 0x3de8f
movq 0x18(%r13), %rdi
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x1, %eax
jg 0x3de8f
movq %r14, %rsi
movq %rbx, %rdx
callq 0x20d90
movq %r15, %rax
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| JS_GetPrototypeFree:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rdx
mov r14, rsi
mov r13, rdi
call JS_GetPrototype
mov r15, rax
mov r12, rdx
cmp ebx, 0FFFFFFF7h
jb short loc_3DE8F
mov rdi, [r13+18h]
mov eax, [r14]
lea ecx, [rax-1]
mov [r14], ecx
cmp eax, 1
jg short loc_3DE8F
mov rsi, r14
mov rdx, rbx
call js_free_value_rt
loc_3DE8F:
mov rax, r15
mov rdx, r12
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| unsigned long long JS_GetPrototypeFree(long long a1, _QWORD *a2, long long a3)
{
long long v4; // r8
long long v5; // r9
unsigned long long Prototype; // r15
long long v7; // rdi
int v8; // eax
long long v9; // rcx
Prototype = JS_GetPrototype(a1, (long long)a2, a3);
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
{
v7 = *(_QWORD *)(a1 + 24);
v8 = *(_DWORD *)a2;
v9 = (unsigned int)(*(_DWORD *)a2 - 1);
*(_DWORD *)a2 = v9;
if ( v8 <= 1 )
js_free_value_rt(v7, a2, a3, v9, v4, v5);
}
return Prototype;
}
| JS_GetPrototypeFree:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R13,RDI
CALL 0x0012246a
MOV R15,RAX
MOV R12,RDX
CMP EBX,-0x9
JC 0x0013de8f
MOV RDI,qword ptr [R13 + 0x18]
MOV EAX,dword ptr [R14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14],ECX
CMP EAX,0x1
JG 0x0013de8f
MOV RSI,R14
MOV RDX,RBX
CALL 0x00120d90
LAB_0013de8f:
MOV RAX,R15
MOV RDX,R12
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int1 [16] JS_GetPrototypeFree(long param_1,int *param_2,int8 param_3)
{
int iVar1;
int8 uVar2;
int1 auVar3 [16];
auVar3 = JS_GetPrototype();
if (0xfffffff6 < (uint)param_3) {
uVar2 = *(int8 *)(param_1 + 0x18);
iVar1 = *param_2;
*param_2 = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar2,param_2,param_3);
}
}
return auVar3;
}
| |
38,162 | search_default_file | eloqsql/mysys/my_default.c | static int search_default_file(struct handle_option_ctx *ctx, const char *dir,
const char *config_file)
{
char **ext;
const char *empty_list[]= { "", 0 };
my_bool have_ext= fn_ext(config_file)[0] != 0;
const char **exts_to_use= have_ext ? empty_list : f_extensions;
for (ext= (char**) exts_to_use; *ext; ext++)
{
int error;
if ((error= search_default_file_with_ext(ctx, dir, *ext, config_file, 0)) < 0)
return error;
}
return 0;
} | O0 | c | search_default_file:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq 0x1cf465(%rip), %rax # 0x2a6af0
movq %rax, -0x40(%rbp)
movq 0x1cf462(%rip), %rax # 0x2a6af8
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd9700
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x41(%rbp)
movsbl -0x41(%rbp), %eax
cmpl $0x0, %eax
je 0xd76c7
leaq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0xd76d4
leaq 0x1db652(%rip), %rax # 0x2b2d20
movq %rax, -0x60(%rbp)
jmp 0xd76d4
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd7729
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
xorl %r8d, %r8d
callq 0xd6960
movl %eax, -0x54(%rbp)
cmpl $0x0, %eax
jge 0xd7719
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd7730
jmp 0xd771b
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0xd76e4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| search_default_file:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, cs:off_2A6AF0; ""
mov [rbp+var_40], rax
mov rax, cs:qword_2A6AF8
mov [rbp+var_38], rax
mov rdi, [rbp+var_20]
call fn_ext
movsx eax, byte ptr [rax]
cmp eax, 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_41], al
movsx eax, [rbp+var_41]
cmp eax, 0
jz short loc_D76C7
lea rax, [rbp+var_40]
mov [rbp+var_60], rax
jmp short loc_D76D4
loc_D76C7:
lea rax, f_extensions
mov [rbp+var_60], rax
jmp short $+2
loc_D76D4:
mov rax, [rbp+var_60]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov [rbp+var_28], rax
loc_D76E4:
mov rax, [rbp+var_28]
cmp qword ptr [rax], 0
jz short loc_D7729
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rax, [rbp+var_28]
mov rdx, [rax]
mov rcx, [rbp+var_20]
xor r8d, r8d
call search_default_file_with_ext
mov [rbp+var_54], eax
cmp eax, 0
jge short loc_D7719
mov eax, [rbp+var_54]
mov [rbp+var_4], eax
jmp short loc_D7730
loc_D7719:
jmp short $+2
loc_D771B:
mov rax, [rbp+var_28]
add rax, 8
mov [rbp+var_28], rax
jmp short loc_D76E4
loc_D7729:
mov [rbp+var_4], 0
loc_D7730:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long search_default_file(long long a1, _BYTE *a2, long long a3)
{
char **v4; // [rsp+0h] [rbp-60h]
int v5; // [rsp+Ch] [rbp-54h]
_QWORD v6[3]; // [rsp+20h] [rbp-40h] BYREF
long long *i; // [rsp+38h] [rbp-28h]
long long v8; // [rsp+40h] [rbp-20h]
_BYTE *v9; // [rsp+48h] [rbp-18h]
long long v10; // [rsp+50h] [rbp-10h]
v10 = a1;
v9 = a2;
v8 = a3;
v6[0] = "";
v6[1] = &dword_0;
if ( *(_BYTE *)fn_ext(a3) )
v4 = (char **)v6;
else
v4 = &f_extensions;
for ( i = (long long *)v4; *i; ++i )
{
v5 = search_default_file_with_ext(v10, v9, *i, v8, 0);
if ( v5 < 0 )
return (unsigned int)v5;
}
return 0;
}
| search_default_file:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [0x003a6af0]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [0x003a6af8]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001d9700
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x41],AL
MOVSX EAX,byte ptr [RBP + -0x41]
CMP EAX,0x0
JZ 0x001d76c7
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001d76d4
LAB_001d76c7:
LEA RAX,[0x3b2d20]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001d76d4
LAB_001d76d4:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x28],RAX
LAB_001d76e4:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX],0x0
JZ 0x001d7729
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
XOR R8D,R8D
CALL 0x001d6960
MOV dword ptr [RBP + -0x54],EAX
CMP EAX,0x0
JGE 0x001d7719
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001d7730
LAB_001d7719:
JMP 0x001d771b
LAB_001d771b:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x8
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001d76e4
LAB_001d7729:
MOV dword ptr [RBP + -0x4],0x0
LAB_001d7730:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int search_default_file(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
char *pcVar2;
int **local_68;
int *local_48;
int8 local_40;
int **local_30;
int8 local_28;
int8 local_20;
int8 local_18;
local_48 = PTR_DAT_003a6af0;
local_40 = DAT_003a6af8;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
pcVar2 = (char *)fn_ext(param_3);
if (*pcVar2 == '\0') {
local_68 = &f_extensions;
}
else {
local_68 = &local_48;
}
local_30 = local_68;
while( true ) {
if (*local_30 == (int *)0x0) {
return 0;
}
iVar1 = search_default_file_with_ext(local_18,local_20,*local_30,local_28,0);
if (iVar1 < 0) break;
local_30 = local_30 + 1;
}
return iVar1;
}
| |
38,163 | mariadb_uncompress | eloqsql/libmariadb/libmariadb/ma_compress.c | my_bool _mariadb_uncompress (NET *net, unsigned char *packet, size_t *len, size_t *complen)
{
if (*complen) /* If compressed */
{
unsigned char *compbuf = (unsigned char *) malloc (*complen);
if (!compbuf)
return 1; /* Not enough memory */
if (compression_plugin(net)->decompress(compression_ctx(net), compbuf, complen, packet, len))
{ /* Probably wrong packet */
free(compbuf);
return 1;
}
*len = *complen;
memcpy(packet,compbuf,*len);
free(compbuf);
}
else *complen= *len;
return 0;
} | O0 | c | mariadb_uncompress:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2a03a
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x135b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x29fc6
movb $0x1, -0x1(%rbp)
jmp 0x2a04c
movq -0x10(%rbp), %rax
movq 0x2a0(%rax), %rax
movq 0x10(%rax), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x2a0(%rcx), %rcx
movq 0x8(%rcx), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq *%rax
cmpb $0x0, %al
je 0x2a00d
movq -0x30(%rbp), %rdi
callq 0x13520
movb $0x1, -0x1(%rbp)
jmp 0x2a04c
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x13360
movq -0x30(%rbp), %rdi
callq 0x13520
jmp 0x2a048
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| _mariadb_uncompress:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_28]
cmp qword ptr [rax], 0
jz loc_2A03A
mov rax, [rbp+var_28]
mov rdi, [rax]
call _malloc
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jnz short loc_29FC6
mov [rbp+var_1], 1
jmp loc_2A04C
loc_29FC6:
mov rax, [rbp+var_10]
mov rax, [rax+2A0h]
mov rax, [rax+10h]
mov rax, [rax+70h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+2A0h]
mov rdi, [rcx+8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_20]
call rax
cmp al, 0
jz short loc_2A00D
mov rdi, [rbp+var_30]
call _free
mov [rbp+var_1], 1
jmp short loc_2A04C
loc_2A00D:
mov rax, [rbp+var_28]
mov rcx, [rax]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_30]
mov rax, [rbp+var_20]
mov rdx, [rax]
call _memcpy
mov rdi, [rbp+var_30]
call _free
jmp short loc_2A048
loc_2A03A:
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rbp+var_28]
mov [rax], rcx
loc_2A048:
mov [rbp+var_1], 0
loc_2A04C:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char mariadb_uncompress(long long a1, long long a2, _QWORD *a3, _QWORD *a4)
{
long long v5; // [rsp+0h] [rbp-30h]
if ( !*a4 )
{
*a4 = *a3;
return 0;
}
v5 = malloc(*a4);
if ( v5 )
{
if ( (*(unsigned __int8 ( **)(_QWORD, long long, _QWORD *, long long, _QWORD *))(*(_QWORD *)(*(_QWORD *)(a1 + 672) + 16LL)
+ 112LL))(
*(_QWORD *)(*(_QWORD *)(a1 + 672) + 8LL),
v5,
a4,
a2,
a3) )
{
free(v5);
return 1;
}
*a3 = *a4;
memcpy(a2, v5, *a3);
free(v5);
return 0;
}
return 1;
}
| _mariadb_uncompress:
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 qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX],0x0
JZ 0x0012a03a
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX]
CALL 0x001135b0
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00129fc6
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012a04c
LAB_00129fc6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x70]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x2a0]
MOV RDI,qword ptr [RCX + 0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x20]
CALL RAX
CMP AL,0x0
JZ 0x0012a00d
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00113520
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012a04c
LAB_0012a00d:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RAX]
CALL 0x00113360
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00113520
JMP 0x0012a048
LAB_0012a03a:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
LAB_0012a048:
MOV byte ptr [RBP + -0x1],0x0
LAB_0012a04c:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 _mariadb_uncompress(long param_1,void *param_2,size_t *param_3,size_t *param_4)
{
char cVar1;
void *__src;
if (*param_4 == 0) {
*param_4 = *param_3;
}
else {
__src = malloc(*param_4);
if (__src == (void *)0x0) {
return 1;
}
cVar1 = (**(code **)(*(long *)(*(long *)(param_1 + 0x2a0) + 0x10) + 0x70))
(*(int8 *)(*(long *)(param_1 + 0x2a0) + 8),__src,param_4,param_2,param_3
);
if (cVar1 != '\0') {
free(__src);
return 1;
}
*param_3 = *param_4;
memcpy(param_2,__src,*param_3);
free(__src);
}
return 0;
}
| |
38,164 | SchemaConverter::_generate_union_rule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<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::allocator<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-schema-to-grammar.cpp | std::string _generate_union_rule(const std::string & name, const std::vector<json> & alt_schemas) {
std::vector<std::string> rules;
for (size_t i = 0; i < alt_schemas.size(); i++) {
rules.push_back(visit(alt_schemas[i], name + (name.empty() ? "alternative-" : "-") + std::to_string(i)));
}
return string_join(rules, " | ");
} | O3 | cpp | SchemaConverter::_generate_union_rule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<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::allocator<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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdi, 0x98(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movq $0x0, 0x90(%rsp)
movq (%rcx), %r12
movq %rcx, 0xa0(%rsp)
cmpq %r12, 0x8(%rcx)
je 0xc423c
leaq 0x70(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x40(%rsp), %r14
movq %rbp, %rbx
movq 0xb0(%rsp), %rcx
movq 0x8(%rcx), %rbp
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rcx), %rsi
leaq (%rsi,%rbp), %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x22484
testq %rbp, %rbp
leaq 0x3271c(%rip), %rsi # 0xf6762
leaq 0x327be(%rip), %rax # 0xf680b
cmoveq %rax, %rsi
movq %r15, %rdi
callq 0x1c0f0
movl $0x1, %esi
cmpq $0xa, %r13
movq %rbx, %rbp
jb 0xc40b6
movl $0x4, %esi
movq %r13, %rcx
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
cmpq $0x63, %rcx
jbe 0xc40af
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0xc40b4
cmpq $0x2710, %rcx # imm = 0x2710
jb 0xc40b6
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0xc4079
addl $-0x3, %esi
jmp 0xc40b6
addl $-0x2, %esi
jmp 0xc40b6
decl %esi
movl %esi, %esi
movq %rbp, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
xorl %edx, %edx
callq 0x1ba00
movq 0x60(%rsp), %rdi
movl 0x68(%rsp), %esi
movq %r13, %rdx
callq 0x5e055
movq (%rsp), %rcx
movl $0xf, %edi
leaq 0x10(%rsp), %rax
cmpq %rax, %rcx
je 0xc40f2
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %r8
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rdi, %rax
jbe 0xc411e
movl $0xf, %edi
cmpq %rbp, %rsi
je 0xc4119
movq 0x70(%rsp), %rdi
cmpq %rdi, %rax
jbe 0xc4128
movq %rsp, %rdi
callq 0x1b260
jmp 0xc4136
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1b9b0
leaq 0x30(%rsp), %rsi
movq %rsi, 0x20(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0xc415b
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0xc4161
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x28(%rsp)
movq %rcx, (%rax)
movq %r13, %rax
shlq $0x4, %rax
addq %rax, %r12
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq %r14, %rdi
movq 0xa8(%rsp), %rsi
movq %r12, %rdx
leaq 0x20(%rsp), %rcx
callq 0xc1202
leaq 0x80(%rsp), %rdi
movq %r14, %rsi
leaq 0x30(%rsp), %r12
callq 0x56246
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xc41d1
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1b8c0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xc41e8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b8c0
movq 0x60(%rsp), %rdi
cmpq %rbp, %rdi
je 0xc41ff
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1b8c0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xc421a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8c0
incq %r13
movq 0xa0(%rsp), %rax
movq (%rax), %r12
movq 0x8(%rax), %rax
subq %r12, %rax
sarq $0x4, %rax
cmpq %rax, %r13
jb 0xc4012
leaq 0x50(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x32776(%rip), %rsi # 0xf69c2
leaq 0x32772(%rip), %rdx # 0xf69c5
leaq 0x40(%rsp), %rdi
callq 0x225b4
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq 0x98(%rsp), %r14
movq %r14, %rdi
callq 0x72ae1
movq 0x40(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc4291
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1b8c0
leaq 0x80(%rsp), %rdi
callq 0x21ff8
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc4350
movq 0x50(%rsp), %rsi
jmp 0xc4348
jmp 0xc42cd
movq %rax, %r14
jmp 0xc4350
jmp 0xc42d4
movq %rax, %r14
jmp 0xc4335
movq %rax, %r14
jmp 0xc431e
movq %rax, %r14
jmp 0xc4302
movq %rax, %r14
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xc4302
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1b8c0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xc431e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b8c0
movq 0x60(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc4335
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1b8c0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xc4350
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8c0
leaq 0x80(%rsp), %rdi
callq 0x21ff8
movq %r14, %rdi
callq 0x1bf90
nop
| _ZN15SchemaConverter20_generate_union_ruleERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapES8_S5_blmdSaNSA_14adl_serializerES8_IhSaIhEEvEESaISG_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov [rsp+0E8h+var_38], rdx
mov [rsp+0E8h+var_40], rsi
mov [rsp+0E8h+var_50], rdi
xorps xmm0, xmm0
movaps [rsp+0E8h+var_68], xmm0
mov [rsp+0E8h+var_58], 0
mov r12, [rcx]
mov [rsp+0E8h+var_48], rcx
cmp [rcx+8], r12
jz loc_C423C
lea rbp, [rsp+0E8h+var_78]
xor r13d, r13d
lea r14, [rsp+0E8h+var_A8]
loc_C4012:
mov rbx, rbp
mov rcx, [rsp+0E8h+var_38]
mov rbp, [rcx+8]
lea rax, [rsp+0E8h+var_D8]
mov [rsp+0E8h+var_E8], rax
mov rsi, [rcx]
lea rdx, [rsi+rbp]
mov r15, rsp
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
test rbp, rbp
lea rsi, aTuple+5; "-"
lea rax, aAlternative; "alternative-"
cmovz rsi, rax
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov esi, 1
cmp r13, 0Ah
mov rbp, rbx
jb short loc_C40B6
mov esi, 4
mov rcx, r13
mov rdi, 346DC5D63886594Bh
loc_C4079:
cmp rcx, 63h ; 'c'
jbe short loc_C40AF
cmp rcx, 3E7h
jbe short loc_C40B4
cmp rcx, 2710h
jb short loc_C40B6
mov rax, rcx
mul rdi
shr rdx, 0Bh
add esi, 4
cmp rcx, 1869Fh
mov rcx, rdx
ja short loc_C4079
add esi, 0FFFFFFFDh
jmp short loc_C40B6
loc_C40AF:
add esi, 0FFFFFFFEh
jmp short loc_C40B6
loc_C40B4:
dec esi
loc_C40B6:
mov esi, esi
mov [rsp+0E8h+var_88], rbp
lea rdi, [rsp+0E8h+var_88]
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov rdi, [rsp+0E8h+var_88]
mov esi, dword ptr [rsp+0E8h+var_80]
mov rdx, r13
call _ZNSt8__detail18__to_chars_10_implImEEvPcjT_; std::__detail::__to_chars_10_impl<ulong>(char *,uint,ulong)
mov rcx, [rsp+0E8h+var_E8]
mov edi, 0Fh
lea rax, [rsp+0E8h+var_D8]
cmp rcx, rax
jz short loc_C40F2
mov rdi, [rsp+0E8h+var_D8]
loc_C40F2:
mov r8, [rsp+0E8h+var_E0]
mov rsi, [rsp+0E8h+var_88]
mov rdx, [rsp+0E8h+var_80]
lea rax, [rdx+r8]
cmp rax, rdi
jbe short loc_C411E
mov edi, 0Fh
cmp rsi, rbp
jz short loc_C4119
mov rdi, [rsp+0E8h+var_78]
loc_C4119:
cmp rax, rdi
jbe short loc_C4128
loc_C411E:
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
jmp short loc_C4136
loc_C4128:
lea rdi, [rsp+0E8h+var_88]
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
loc_C4136:
lea rsi, [rsp+0E8h+var_B8]
mov [rsp+0E8h+var_C8], rsi
mov rdx, [rax]
lea rcx, [rax+10h]
cmp rdx, rcx
jz short loc_C415B
mov [rsp+0E8h+var_C8], rdx
mov rdx, [rcx]
mov [rsp+0E8h+var_B8], rdx
jmp short loc_C4161
loc_C415B:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rsi], xmm0
loc_C4161:
mov rdx, rax
add rdx, 8
mov rsi, [rax+8]
mov [rsp+0E8h+var_C0], rsi
mov [rax], rcx
mov rax, r13
shl rax, 4
add r12, rax
mov qword ptr [rdx], 0
mov byte ptr [rcx], 0
mov rdi, r14
mov rsi, [rsp+0E8h+var_40]
mov rdx, r12
lea rcx, [rsp+0E8h+var_C8]
call _ZN15SchemaConverter5visitERKN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_; SchemaConverter::visit(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&,std::string const&)
lea rdi, [rsp+0E8h+var_68]
mov rsi, r14
lea r12, [rsp+0E8h+var_B8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+0E8h+var_A8]; void *
lea rax, [rsp+0E8h+var_98]
cmp rdi, rax
jz short loc_C41D1
mov rsi, [rsp+0E8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C41D1:
mov rdi, [rsp+0E8h+var_C8]; void *
cmp rdi, r12
jz short loc_C41E8
mov rsi, [rsp+0E8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C41E8:
mov rdi, [rsp+0E8h+var_88]; void *
cmp rdi, rbp
jz short loc_C41FF
mov rsi, [rsp+0E8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C41FF:
mov rdi, [rsp+0E8h+var_E8]; void *
lea rax, [rsp+0E8h+var_D8]
cmp rdi, rax
jz short loc_C421A
mov rsi, [rsp+0E8h+var_D8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C421A:
inc r13
mov rax, [rsp+0E8h+var_48]
mov r12, [rax]
mov rax, [rax+8]
sub rax, r12
sar rax, 4
cmp r13, rax
jb loc_C4012
loc_C423C:
lea rbx, [rsp+0E8h+var_98]
mov [rbx-10h], rbx
lea rsi, asc_F69C1+1; " | "
lea rdx, asc_F69C1+4; ""
lea rdi, [rsp+0E8h+var_A8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, [rsp+0E8h+var_68]
lea rdx, [rsp+0E8h+var_A8]
mov r14, [rsp+0E8h+var_50]
mov rdi, r14
call _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_; string_join(std::vector<std::string> const&,std::string const&)
mov rdi, [rsp+0E8h+var_A8]; void *
cmp rdi, rbx
jz short loc_C4291
mov rsi, [rsp+0E8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C4291:
lea rdi, [rsp+0E8h+var_68]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, r14
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [rsp+arg_38]
cmp rdi, rbx
jz loc_C4350
mov rsi, [rsp+arg_48]
jmp short loc_C4348
jmp short $+2
loc_C42CD:
mov r14, rax
jmp short loc_C4350
jmp short $+2
loc_C42D4:
mov r14, rax
jmp short loc_C4335
mov r14, rax
jmp short loc_C431E
mov r14, rax
jmp short loc_C4302
mov r14, rax
mov rdi, [rsp+arg_38]; void *
lea rax, [rsp+arg_48]
cmp rdi, rax
jz short loc_C4302
mov rsi, [rsp+arg_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C4302:
mov rdi, [rsp+arg_18]; void *
lea rax, [rsp+arg_28]
cmp rdi, rax
jz short loc_C431E
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C431E:
mov rdi, [rsp+arg_58]; void *
cmp rdi, rbx
jz short loc_C4335
mov rsi, [rsp+arg_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C4335:
mov rdi, [rsp+0]; void *
lea rax, [rsp+arg_8]
cmp rdi, rax
jz short loc_C4350
mov rsi, [rsp+arg_8]
loc_C4348:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C4350:
lea rdi, [rsp+arg_78]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __Unwind_Resume
| long long SchemaConverter::_generate_union_rule(long long a1, long long a2, long long a3, long long *a4)
{
__m128d v4; // xmm0
long long v5; // r12
unsigned long long *v6; // rbp
unsigned long long v7; // r13
unsigned long long *v8; // rbx
long long v9; // rbp
char *v10; // rsi
unsigned int v11; // esi
unsigned long long v12; // rcx
bool v13; // cc
unsigned long long v14; // rdi
unsigned long long v15; // rdi
void **v16; // rax
__m128d *v17; // rcx
long long v18; // r14
void *v20; // [rsp+0h] [rbp-E8h] BYREF
long long v21; // [rsp+8h] [rbp-E0h]
_QWORD v22[2]; // [rsp+10h] [rbp-D8h] BYREF
void *v23[2]; // [rsp+20h] [rbp-C8h] BYREF
__m128d v24; // [rsp+30h] [rbp-B8h] BYREF
void *v25[2]; // [rsp+40h] [rbp-A8h] BYREF
_QWORD v26[2]; // [rsp+50h] [rbp-98h] BYREF
void *v27; // [rsp+60h] [rbp-88h] BYREF
long long v28; // [rsp+68h] [rbp-80h]
unsigned long long v29; // [rsp+70h] [rbp-78h] BYREF
__int128 v30; // [rsp+80h] [rbp-68h] BYREF
long long v31; // [rsp+90h] [rbp-58h]
long long v32; // [rsp+98h] [rbp-50h]
long long *v33; // [rsp+A0h] [rbp-48h]
long long v34; // [rsp+A8h] [rbp-40h]
long long v35; // [rsp+B0h] [rbp-38h]
v35 = a3;
v34 = a2;
v32 = a1;
v4 = 0LL;
v30 = 0LL;
v31 = 0LL;
v5 = *a4;
v33 = a4;
if ( a4[1] != v5 )
{
v6 = &v29;
v7 = 0LL;
do
{
v8 = v6;
v9 = *(_QWORD *)(v35 + 8);
v20 = v22;
std::string::_M_construct<char *>((long long)&v20, *(_BYTE **)v35, *(_QWORD *)v35 + v9);
v10 = "-";
if ( !v9 )
v10 = "alternative-";
std::string::append(&v20, v10);
v11 = 1;
v6 = v8;
if ( v7 >= 0xA )
{
v11 = 4;
v12 = v7;
while ( 1 )
{
if ( v12 <= 0x63 )
{
v11 -= 2;
goto LABEL_14;
}
if ( v12 <= 0x3E7 )
break;
if ( v12 < 0x2710 )
goto LABEL_14;
v11 += 4;
v13 = v12 <= 0x1869F;
v12 /= 0x2710uLL;
if ( v13 )
{
v11 -= 3;
goto LABEL_14;
}
}
--v11;
}
LABEL_14:
v27 = v8;
std::string::_M_construct(&v27, v11, 0LL);
std::__detail::__to_chars_10_impl<unsigned long>((char *)v27, v28, v7);
v14 = 15LL;
if ( v20 != v22 )
v14 = v22[0];
if ( v28 + v21 <= v14 )
goto LABEL_20;
v15 = 15LL;
if ( v27 != v8 )
v15 = v29;
if ( v28 + v21 <= v15 )
v16 = (void **)std::string::replace(&v27, 0LL, 0LL, v20, v21);
else
LABEL_20:
v16 = (void **)std::string::_M_append(&v20, v27, v28);
v23[0] = &v24;
v17 = (__m128d *)(v16 + 2);
if ( *v16 == v16 + 2 )
{
v4 = *v17;
v24 = *v17;
}
else
{
v23[0] = *v16;
v24.m128d_f64[0] = v17->m128d_f64[0];
}
v23[1] = v16[1];
*v16 = v17;
v16[1] = 0LL;
LOBYTE(v17->m128d_f64[0]) = 0;
SchemaConverter::visit(v25, v34, 16 * v7 + v5, (long long)v23, v4);
std::vector<std::string>::emplace_back<std::string>((long long)&v30, (long long)v25);
if ( v25[0] != v26 )
operator delete(v25[0], v26[0] + 1LL);
if ( v23[0] != &v24 )
operator delete(v23[0], *(_QWORD *)&v24.m128d_f64[0] + 1LL);
if ( v27 != v8 )
operator delete(v27, v29 + 1);
if ( v20 != v22 )
operator delete(v20, v22[0] + 1LL);
++v7;
v5 = *v33;
}
while ( v7 < (v33[1] - *v33) >> 4 );
}
v25[0] = v26;
std::string::_M_construct<char const*>((long long)v25, " | ", (long long)"");
v18 = v32;
string_join(v32, (long long *)&v30, v25);
if ( v25[0] != v26 )
operator delete(v25[0], v26[0] + 1LL);
std::vector<std::string>::~vector((long long)&v30);
return v18;
}
| _generate_union_rule:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV qword ptr [RSP + 0xb0],RDX
MOV qword ptr [RSP + 0xa8],RSI
MOV qword ptr [RSP + 0x98],RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOV qword ptr [RSP + 0x90],0x0
MOV R12,qword ptr [RCX]
MOV qword ptr [RSP + 0xa0],RCX
CMP qword ptr [RCX + 0x8],R12
JZ 0x001c423c
LEA RBP,[RSP + 0x70]
XOR R13D,R13D
LEA R14,[RSP + 0x40]
LAB_001c4012:
MOV RBX,RBP
MOV RCX,qword ptr [RSP + 0xb0]
MOV RBP,qword ptr [RCX + 0x8]
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV RSI,qword ptr [RCX]
LEA RDX,[RSI + RBP*0x1]
LAB_001c4031:
MOV R15,RSP
MOV RDI,R15
CALL 0x00122484
TEST RBP,RBP
LEA RSI,[0x1f6762]
LEA RAX,[0x1f680b]
CMOVZ RSI,RAX
LAB_001c4051:
MOV RDI,R15
CALL 0x0011c0f0
MOV ESI,0x1
CMP R13,0xa
MOV RBP,RBX
JC 0x001c40b6
MOV ESI,0x4
MOV RCX,R13
MOV RDI,0x346dc5d63886594b
LAB_001c4079:
CMP RCX,0x63
JBE 0x001c40af
CMP RCX,0x3e7
JBE 0x001c40b4
CMP RCX,0x2710
JC 0x001c40b6
MOV RAX,RCX
MUL RDI
SHR RDX,0xb
ADD ESI,0x4
CMP RCX,0x1869f
MOV RCX,RDX
JA 0x001c4079
ADD ESI,-0x3
JMP 0x001c40b6
LAB_001c40af:
ADD ESI,-0x2
JMP 0x001c40b6
LAB_001c40b4:
DEC ESI
LAB_001c40b6:
MOV ESI,ESI
MOV qword ptr [RSP + 0x60],RBP
LAB_001c40bd:
LEA RDI,[RSP + 0x60]
XOR EDX,EDX
CALL 0x0011ba00
MOV RDI,qword ptr [RSP + 0x60]
MOV ESI,dword ptr [RSP + 0x68]
MOV RDX,R13
CALL 0x0015e055
MOV RCX,qword ptr [RSP]
MOV EDI,0xf
LEA RAX,[RSP + 0x10]
CMP RCX,RAX
JZ 0x001c40f2
MOV RDI,qword ptr [RSP + 0x10]
LAB_001c40f2:
MOV R8,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
LEA RAX,[RDX + R8*0x1]
CMP RAX,RDI
JBE 0x001c411e
MOV EDI,0xf
CMP RSI,RBP
JZ 0x001c4119
MOV RDI,qword ptr [RSP + 0x70]
LAB_001c4119:
CMP RAX,RDI
JBE 0x001c4128
LAB_001c411e:
MOV RDI,RSP
CALL 0x0011b260
JMP 0x001c4136
LAB_001c4128:
LEA RDI,[RSP + 0x60]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011b9b0
LAB_001c4136:
LEA RSI,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RSI
MOV RDX,qword ptr [RAX]
LEA RCX,[RAX + 0x10]
CMP RDX,RCX
JZ 0x001c415b
MOV qword ptr [RSP + 0x20],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x30],RDX
JMP 0x001c4161
LAB_001c415b:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSI],XMM0
LAB_001c4161:
MOV RDX,RAX
ADD RDX,0x8
MOV RSI,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RAX],RCX
MOV RAX,R13
SHL RAX,0x4
ADD R12,RAX
MOV qword ptr [RDX],0x0
MOV byte ptr [RCX],0x0
LAB_001c4188:
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDX,R12
LEA RCX,[RSP + 0x20]
CALL 0x001c1202
LAB_001c41a0:
LEA RDI,[RSP + 0x80]
MOV RSI,R14
LEA R12,[RSP + 0x30]
CALL 0x00156246
MOV RDI,qword ptr [RSP + 0x40]
LEA RAX,[RSP + 0x50]
CMP RDI,RAX
JZ 0x001c41d1
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x0011b8c0
LAB_001c41d1:
MOV RDI,qword ptr [RSP + 0x20]
CMP RDI,R12
JZ 0x001c41e8
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0011b8c0
LAB_001c41e8:
MOV RDI,qword ptr [RSP + 0x60]
CMP RDI,RBP
JZ 0x001c41ff
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x0011b8c0
LAB_001c41ff:
MOV RDI,qword ptr [RSP]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x001c421a
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011b8c0
LAB_001c421a:
INC R13
MOV RAX,qword ptr [RSP + 0xa0]
MOV R12,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
SUB RAX,R12
SAR RAX,0x4
CMP R13,RAX
JC 0x001c4012
LAB_001c423c:
LEA RBX,[RSP + 0x50]
MOV qword ptr [RBX + -0x10],RBX
LAB_001c4245:
LEA RSI,[0x1f69c2]
LEA RDX,[0x1f69c5]
LEA RDI,[RSP + 0x40]
CALL 0x001225b4
LAB_001c425d:
LEA RSI,[RSP + 0x80]
LEA RDX,[RSP + 0x40]
MOV R14,qword ptr [RSP + 0x98]
MOV RDI,R14
CALL 0x00172ae1
LAB_001c427a:
MOV RDI,qword ptr [RSP + 0x40]
CMP RDI,RBX
JZ 0x001c4291
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x0011b8c0
LAB_001c4291:
LEA RDI,[RSP + 0x80]
CALL 0x00121ff8
MOV RAX,R14
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* SchemaConverter::_generate_union_rule(std::__cxx11::string const&,
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> > > const&) */
vector * SchemaConverter::_generate_union_rule(string *param_1,vector *param_2)
{
long *plVar1;
ulong uVar2;
bool bVar3;
string *psVar4;
char cVar5;
int8 *puVar6;
long *in_RCX;
ulong uVar7;
long *in_RDX;
char cVar8;
ulong uVar9;
ulong *local_e8;
long local_e0;
ulong local_d8 [2];
long *local_c8;
int8 local_c0;
long local_b8;
int8 uStack_b0;
long *local_a8 [2];
long local_98 [2];
ulong *local_88;
uint local_80;
int4 uStack_7c;
ulong local_78 [2];
int8 local_68;
int8 uStack_60;
int8 local_58;
string *local_50;
long *local_48;
vector *local_40;
long *local_38;
local_68 = 0;
uStack_60 = 0;
local_58 = 0;
local_50 = param_1;
local_40 = param_2;
if (in_RCX[1] != *in_RCX) {
uVar9 = 0;
local_48 = in_RCX;
local_38 = in_RDX;
do {
local_e8 = local_d8;
/* try { // try from 001c4031 to 001c403b has its CatchHandler @ 001c42cd */
std::__cxx11::string::_M_construct<char*>(&local_e8,*local_38,*local_38 + local_38[1]);
/* try { // try from 001c4051 to 001c4058 has its CatchHandler @ 001c42d2 */
std::__cxx11::string::append((char *)&local_e8);
cVar8 = '\x01';
if (9 < uVar9) {
uVar7 = uVar9;
cVar5 = '\x04';
do {
cVar8 = cVar5;
if (uVar7 < 100) {
cVar8 = cVar8 + -2;
goto LAB_001c40b6;
}
if (uVar7 < 1000) {
cVar8 = cVar8 + -1;
goto LAB_001c40b6;
}
if (uVar7 < 10000) goto LAB_001c40b6;
bVar3 = 99999 < uVar7;
uVar7 = uVar7 / 10000;
cVar5 = cVar8 + '\x04';
} while (bVar3);
cVar8 = cVar8 + '\x01';
}
LAB_001c40b6:
/* try { // try from 001c40bd to 001c40c8 has its CatchHandler @ 001c42d4 */
local_88 = local_78;
std::__cxx11::string::_M_construct((ulong)&local_88,cVar8);
std::__detail::__to_chars_10_impl<unsigned_long>((char *)local_88,local_80,uVar9);
uVar7 = 0xf;
if (local_e8 != local_d8) {
uVar7 = local_d8[0];
}
uVar2 = CONCAT44(uStack_7c,local_80) + local_e0;
if (uVar7 < uVar2) {
uVar7 = 0xf;
if (local_88 != local_78) {
uVar7 = local_78[0];
}
if (uVar7 < uVar2) goto LAB_001c411e;
puVar6 = (int8 *)
std::__cxx11::string::replace((ulong)&local_88,0,(char *)0x0,(ulong)local_e8);
}
else {
LAB_001c411e:
/* try { // try from 001c411e to 001c4135 has its CatchHandler @ 001c42d9 */
puVar6 = (int8 *)std::__cxx11::string::_M_append((char *)&local_e8,(ulong)local_88);
}
local_c8 = &local_b8;
plVar1 = puVar6 + 2;
if ((long *)*puVar6 == plVar1) {
local_b8 = *plVar1;
uStack_b0 = puVar6[3];
}
else {
local_b8 = *plVar1;
local_c8 = (long *)*puVar6;
}
local_c0 = puVar6[1];
*puVar6 = plVar1;
puVar6[1] = 0;
*(int1 *)plVar1 = 0;
/* try { // try from 001c4188 to 001c419f has its CatchHandler @ 001c42de */
visit((basic_json *)local_a8,(string *)local_40);
/* try { // try from 001c41a0 to 001c41b4 has its CatchHandler @ 001c42e3 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_68,
(string *)local_a8);
if (local_a8[0] != local_98) {
operator_delete(local_a8[0],local_98[0] + 1);
}
if (local_c8 != &local_b8) {
operator_delete(local_c8,local_b8 + 1);
}
if (local_88 != local_78) {
operator_delete(local_88,local_78[0] + 1);
}
if (local_e8 != local_d8) {
operator_delete(local_e8,local_d8[0] + 1);
}
uVar9 = uVar9 + 1;
} while (uVar9 < (ulong)(local_48[1] - *local_48 >> 4));
}
/* try { // try from 001c4245 to 001c425c has its CatchHandler @ 001c42cb */
local_a8[0] = local_98;
std::__cxx11::string::_M_construct<char_const*>(local_a8,&DAT_001f69c2,&DAT_001f69c5);
psVar4 = local_50;
/* try { // try from 001c425d to 001c4279 has its CatchHandler @ 001c42b3 */
string_join((vector *)local_50,(string *)&local_68);
if (local_a8[0] != local_98) {
operator_delete(local_a8[0],local_98[0] + 1);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_68);
return (vector *)psVar4;
}
| |
38,165 | my_coll_parser_scan_shift_sequence | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_shift_sequence(MY_COLL_RULE_PARSER *p)
{
MY_COLL_RULE before_extend;
memset(&p->rule.curr, 0, sizeof(p->rule.curr));
/* Scan single shift character or contraction */
if (!my_coll_parser_scan_character_list(p, p->rule.curr,
MY_UCA_MAX_CONTRACTION,
"Contraction"))
return 0;
before_extend= p->rule; /* Remember the part before "/" */
/* Append the part after "/" as expansion */
if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_EXTEND)
{
my_coll_parser_scan(p);
if (!my_coll_parser_scan_character_list(p, p->rule.base,
MY_UCA_MAX_EXPANSION,
"Expansion"))
return 0;
}
else if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_CONTEXT)
{
/*
We support 2-character long context sequences only:
one character is the previous context, plus the current character.
It's OK as Unicode's CLDR does not have longer examples.
*/
my_coll_parser_scan(p);
p->rule.with_context= TRUE;
if (!my_coll_parser_scan_character_list(p, p->rule.curr + 1, 1, "context"))
return 0;
}
/* Add rule to the rule list */
if (my_coll_rules_add(p->rules, &p->rule))
return 0;
p->rule= before_extend; /* Restore to the state before "/" */
return 1;
} | O0 | c | my_coll_parser_scan_shift_sequence:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
addq $0x50, %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x362e0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
addq $0x50, %rsi
movl $0x6, %edx
leaq 0x3012c(%rip), %rcx # 0xcf09f
callq 0x9f560
cmpl $0x0, %eax
jne 0x9ef89
movl $0x0, -0x4(%rbp)
jmp 0x9f088
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
leaq -0xb0(%rbp), %rdi
movl $0xa0, %edx
callq 0x360b0
movq -0x10(%rbp), %rdi
callq 0x9e5a0
cmpl $0x8, (%rax)
jne 0x9efe9
movq -0x10(%rbp), %rdi
callq 0x9ed80
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
movl $0xa, %edx
leaq 0x2fef3(%rip), %rcx # 0xceec4
callq 0x9f560
cmpl $0x0, %eax
jne 0x9efe7
movl $0x0, -0x4(%rbp)
jmp 0x9f088
jmp 0x9f042
movq -0x10(%rbp), %rdi
callq 0x9e5a0
cmpl $0x9, (%rax)
jne 0x9f040
movq -0x10(%rbp), %rdi
callq 0x9ed80
movq -0x10(%rbp), %rax
movb $0x1, 0xe8(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
addq $0x50, %rsi
addq $0x8, %rsi
movl $0x1, %edx
leaq 0x309b5(%rip), %rcx # 0xcf9e0
callq 0x9f560
cmpl $0x0, %eax
jne 0x9f03e
movl $0x0, -0x4(%rbp)
jmp 0x9f088
jmp 0x9f040
jmp 0x9f042
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
callq 0x9f8b0
cmpl $0x0, %eax
je 0x9f068
movl $0x0, -0x4(%rbp)
jmp 0x9f088
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
leaq -0xb0(%rbp), %rsi
movl $0xa0, %edx
callq 0x360b0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_coll_parser_scan_shift_sequence:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
add rdi, 50h ; 'P'
xor esi, esi
mov edx, 30h ; '0'
call _memset
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
add rsi, 50h ; 'P'
mov edx, 6
lea rcx, aContraction; "Contraction"
call my_coll_parser_scan_character_list
cmp eax, 0
jnz short loc_9EF89
mov [rbp+var_4], 0
jmp loc_9F088
loc_9EF89:
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
lea rdi, [rbp+var_B0]
mov edx, 0A0h
call _memcpy
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 8
jnz short loc_9EFE9
mov rdi, [rbp+var_10]
call my_coll_parser_scan
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
mov edx, 0Ah
lea rcx, aExpansion; "Expansion"
call my_coll_parser_scan_character_list
cmp eax, 0
jnz short loc_9EFE7
mov [rbp+var_4], 0
jmp loc_9F088
loc_9EFE7:
jmp short loc_9F042
loc_9EFE9:
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 9
jnz short loc_9F040
mov rdi, [rbp+var_10]
call my_coll_parser_scan
mov rax, [rbp+var_10]
mov byte ptr [rax+0E8h], 1
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
add rsi, 50h ; 'P'
add rsi, 8
mov edx, 1
lea rcx, aCharsetsCharse_52+23h; "context"
call my_coll_parser_scan_character_list
cmp eax, 0
jnz short loc_9F03E
mov [rbp+var_4], 0
jmp short loc_9F088
loc_9F03E:
jmp short $+2
loc_9F040:
jmp short $+2
loc_9F042:
mov rax, [rbp+var_10]
mov rdi, [rax+0F0h]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
call my_coll_rules_add
cmp eax, 0
jz short loc_9F068
mov [rbp+var_4], 0
jmp short loc_9F088
loc_9F068:
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
lea rsi, [rbp+var_B0]
mov edx, 0A0h
call _memcpy
mov [rbp+var_4], 1
loc_9F088:
mov eax, [rbp+var_4]
add rsp, 0B0h
pop rbp
retn
| long long my_coll_parser_scan_shift_sequence(long long a1)
{
_BYTE v2[160]; // [rsp+0h] [rbp-B0h] BYREF
long long v3; // [rsp+A0h] [rbp-10h]
v3 = a1;
memset(a1 + 160, 0LL, 48LL);
if ( (unsigned int)my_coll_parser_scan_character_list(v3, v3 + 160, 6LL, "Contraction") )
{
memcpy(v2, v3 + 80, sizeof(v2));
if ( *(_DWORD *)my_coll_parser_curr(v3) == 8 )
{
my_coll_parser_scan(v3);
if ( !(unsigned int)my_coll_parser_scan_character_list(v3, v3 + 80, 10LL, "Expansion") )
return 0;
}
else if ( *(_DWORD *)my_coll_parser_curr(v3) == 9 )
{
my_coll_parser_scan(v3);
*(_BYTE *)(v3 + 232) = 1;
if ( !(unsigned int)my_coll_parser_scan_character_list(v3, v3 + 168, 1LL, "context") )
return 0;
}
if ( (unsigned int)my_coll_rules_add(*(_QWORD *)(v3 + 240), v3 + 80) )
{
return 0;
}
else
{
memcpy(v3 + 80, v2, 160LL);
return 1;
}
}
else
{
return 0;
}
}
| my_coll_parser_scan_shift_sequence:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
ADD RDI,0x50
XOR ESI,ESI
MOV EDX,0x30
CALL 0x001362e0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
ADD RSI,0x50
MOV EDX,0x6
LEA RCX,[0x1cf09f]
CALL 0x0019f560
CMP EAX,0x0
JNZ 0x0019ef89
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0019f088
LAB_0019ef89:
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
LEA RDI,[RBP + -0xb0]
MOV EDX,0xa0
CALL 0x001360b0
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019e5a0
CMP dword ptr [RAX],0x8
JNZ 0x0019efe9
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019ed80
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
MOV EDX,0xa
LEA RCX,[0x1ceec4]
CALL 0x0019f560
CMP EAX,0x0
JNZ 0x0019efe7
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0019f088
LAB_0019efe7:
JMP 0x0019f042
LAB_0019efe9:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019e5a0
CMP dword ptr [RAX],0x9
JNZ 0x0019f040
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019ed80
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xe8],0x1
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
ADD RSI,0x50
ADD RSI,0x8
MOV EDX,0x1
LEA RCX,[0x1cf9e0]
CALL 0x0019f560
CMP EAX,0x0
JNZ 0x0019f03e
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0019f088
LAB_0019f03e:
JMP 0x0019f040
LAB_0019f040:
JMP 0x0019f042
LAB_0019f042:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0xf0]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
CALL 0x0019f8b0
CMP EAX,0x0
JZ 0x0019f068
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0019f088
LAB_0019f068:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
LEA RSI,[RBP + -0xb0]
MOV EDX,0xa0
CALL 0x001360b0
MOV dword ptr [RBP + -0x4],0x1
LAB_0019f088:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0xb0
POP RBP
RET
|
int4 my_coll_parser_scan_shift_sequence(long param_1)
{
int iVar1;
int *piVar2;
int1 local_b8 [160];
long local_18;
int4 local_c;
local_18 = param_1;
memset((void *)(param_1 + 0xa0),0,0x30);
iVar1 = my_coll_parser_scan_character_list(local_18,local_18 + 0xa0,6,"Contraction");
if (iVar1 == 0) {
local_c = 0;
}
else {
memcpy(local_b8,(void *)(local_18 + 0x50),0xa0);
piVar2 = (int *)my_coll_parser_curr(local_18);
if (*piVar2 == 8) {
my_coll_parser_scan(local_18);
iVar1 = my_coll_parser_scan_character_list(local_18,local_18 + 0x50,10,"Expansion");
if (iVar1 == 0) {
return 0;
}
}
else {
piVar2 = (int *)my_coll_parser_curr(local_18);
if (*piVar2 == 9) {
my_coll_parser_scan(local_18);
*(int1 *)(local_18 + 0xe8) = 1;
iVar1 = my_coll_parser_scan_character_list(local_18,local_18 + 0xa8,1,"context");
if (iVar1 == 0) {
return 0;
}
}
}
iVar1 = my_coll_rules_add(*(int8 *)(local_18 + 0xf0),local_18 + 0x50);
if (iVar1 == 0) {
memcpy((void *)(local_18 + 0x50),local_b8,0xa0);
local_c = 1;
}
else {
local_c = 0;
}
}
return local_c;
}
| |
38,166 | my_reverse_bits(unsigned int) | eloqsql/include/my_bit.h | static inline uint32 my_reverse_bits(uint32 key)
{
return
((uint32)_my_bits_reverse_table[ key & 255] << 24) |
((uint32)_my_bits_reverse_table[(key>> 8) & 255] << 16) |
((uint32)_my_bits_reverse_table[(key>>16) & 255] << 8) |
(uint32)_my_bits_reverse_table[(key>>24) ];
} | O0 | c | my_reverse_bits(unsigned int):
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x57496(%rip), %rax # 0xb4040
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movl -0x4(%rbp), %ecx
shrl $0x8, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x57478(%rip), %rcx # 0xb4040
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shrl $0x10, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x57458(%rip), %rcx # 0xb4040
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shrl $0x18, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x5743e(%rip), %rcx # 0xb4040
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
popq %rbp
retq
nopw (%rax,%rax)
| _ZL15my_reverse_bitsj:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
and eax, 0FFh
mov eax, eax
mov ecx, eax
lea rax, _my_bits_reverse_table
movzx eax, byte ptr [rax+rcx]
shl eax, 18h
mov ecx, [rbp+var_4]
shr ecx, 8
and ecx, 0FFh
mov ecx, ecx
mov edx, ecx
lea rcx, _my_bits_reverse_table
movzx ecx, byte ptr [rcx+rdx]
shl ecx, 10h
or eax, ecx
mov ecx, [rbp+var_4]
shr ecx, 10h
and ecx, 0FFh
mov ecx, ecx
mov edx, ecx
lea rcx, _my_bits_reverse_table
movzx ecx, byte ptr [rcx+rdx]
shl ecx, 8
or eax, ecx
mov ecx, [rbp+var_4]
shr ecx, 18h
mov ecx, ecx
mov edx, ecx
lea rcx, _my_bits_reverse_table
movzx ecx, byte ptr [rcx+rdx]
or eax, ecx
pop rbp
retn
| long long my_reverse_bits(unsigned int a1)
{
return my_bits_reverse_table[HIBYTE(a1)] | (my_bits_reverse_table[BYTE2(a1)] << 8) | (my_bits_reverse_table[BYTE1(a1)] << 16) | (my_bits_reverse_table[(unsigned __int8)a1] << 24);
}
| my_reverse_bits:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0xff
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x1b4040]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
SHL EAX,0x18
MOV ECX,dword ptr [RBP + -0x4]
SHR ECX,0x8
AND ECX,0xff
MOV ECX,ECX
MOV EDX,ECX
LEA RCX,[0x1b4040]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
SHL ECX,0x10
OR EAX,ECX
MOV ECX,dword ptr [RBP + -0x4]
SHR ECX,0x10
AND ECX,0xff
MOV ECX,ECX
MOV EDX,ECX
LEA RCX,[0x1b4040]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
SHL ECX,0x8
OR EAX,ECX
MOV ECX,dword ptr [RBP + -0x4]
SHR ECX,0x18
MOV ECX,ECX
MOV EDX,ECX
LEA RCX,[0x1b4040]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
OR EAX,ECX
POP RBP
RET
|
/* my_reverse_bits(unsigned int) */
uint my_reverse_bits(uint param_1)
{
return (uint)(byte)_my_bits_reverse_table[param_1 & 0xff] << 0x18 |
(uint)(byte)_my_bits_reverse_table[param_1 >> 8 & 0xff] << 0x10 |
(uint)(byte)_my_bits_reverse_table[param_1 >> 0x10 & 0xff] << 8 |
(uint)(byte)_my_bits_reverse_table[param_1 >> 0x18];
}
| |
38,167 | ma_readinfo | eloqsql/storage/maria/ma_locking.c | int _ma_readinfo(register MARIA_HA *info __attribute__ ((unused)),
int lock_type __attribute__ ((unused)),
int check_keybuffer __attribute__ ((unused)))
{
#ifdef MARIA_EXTERNAL_LOCKING
DBUG_ENTER("_ma_readinfo");
if (info->lock_type == F_UNLCK)
{
MARIA_SHARE *share= info->s;
if (!share->tot_locks)
{
/* should not be done for transactional tables */
if (_ma_state_info_read_dsk(share->kfile.file, &share->state))
{
if (!my_errno)
my_errno= HA_ERR_FILE_TOO_SHORT;
DBUG_RETURN(1);
}
}
if (check_keybuffer)
VOID(_ma_test_if_changed(info));
info->invalidator=share->invalidator;
}
else if (lock_type == F_WRLCK && info->lock_type == F_RDLCK)
{
my_errno=EACCES; /* Not allowed to change */
DBUG_RETURN(-1); /* when have read_lock() */
}
DBUG_RETURN(0);
#else
return 0;
#endif /* defined(MARIA_EXTERNAL_LOCKING) */
} | O0 | c | ma_readinfo:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_readinfo:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
xor eax, eax
pop rbp
retn
| long long ma_readinfo()
{
return 0LL;
}
| _ma_readinfo:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
XOR EAX,EAX
POP RBP
RET
|
int8 _ma_readinfo(void)
{
return 0;
}
| |
38,168 | translog_sync_files | eloqsql/storage/maria/ma_loghandler.c | static my_bool translog_sync_files(uint32 min, uint32 max,
my_bool sync_dir)
{
uint fn;
my_bool rc= 0;
ulonglong flush_interval;
DBUG_ENTER("translog_sync_files");
DBUG_PRINT("info", ("min: %lu max: %lu sync dir: %d",
(ulong) min, (ulong) max, (int) sync_dir));
DBUG_ASSERT(min <= max);
flush_interval= group_commit_wait;
if (flush_interval)
flush_start= microsecond_interval_timer();
for (fn= min; fn <= max; fn++)
{
TRANSLOG_FILE *file= get_logfile_by_number(fn);
DBUG_ASSERT(file != NULL);
if (!file->is_sync)
{
if (mysql_file_sync(file->handler.file, MYF(MY_WME)))
{
rc= 1;
translog_stop_writing();
DBUG_RETURN(rc);
}
translog_syncs++;
file->is_sync= 1;
}
}
if (sync_dir)
{
if (!(rc= sync_dir(log_descriptor.directory_fd,
MYF(MY_WME | MY_IGNORE_BADFD))))
translog_syncs++;
}
DBUG_RETURN(rc);
} | O0 | c | translog_sync_files:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movb $0x0, -0x15(%rbp)
jmp 0x56d39
jmp 0x56d3b
jmp 0x56d3d
movl 0xc235a1(%rip), %eax # 0xc7a2e4
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x56d64
callq 0xf0070
movl $0x3e8, %ecx # imm = 0x3E8
xorl %edx, %edx
divq %rcx
movq %rax, 0xc2356c(%rip) # 0xc7a2d0
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
ja 0x56de4
movl -0x14(%rbp), %edi
callq 0x58990
movq %rax, -0x28(%rbp)
jmp 0x56d80
movq -0x28(%rbp), %rax
cmpb $0x0, 0x51(%rax)
jne 0x56dd7
movq -0x28(%rbp), %rax
movl 0x18(%rax), %edx
leaq 0xfaf36(%rip), %rdi # 0x151cce
movl $0x1ed2, %esi # imm = 0x1ED2
movl $0x10, %ecx
callq 0x59160
cmpl $0x0, %eax
je 0x56dbd
movb $0x1, -0x15(%rbp)
callq 0x4f7b0
movb -0x15(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x56e29
movq 0x4213f4(%rip), %rax # 0x4781b8
addq $0x1, %rax
movq %rax, 0x4213e9(%rip) # 0x4781b8
movq -0x28(%rbp), %rax
movb $0x1, 0x51(%rax)
jmp 0x56dd9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x56d6a
cmpb $0x0, -0xd(%rbp)
je 0x56e21
movl 0x4228c0(%rip), %edx # 0x4796b0
leaq 0xfaed7(%rip), %rdi # 0x151cce
movl $0x1ee0, %esi # imm = 0x1EE0
movl $0x30, %ecx
callq 0x59160
movb %al, -0x15(%rbp)
cmpb $0x0, %al
jne 0x56e1f
movq 0x4213a4(%rip), %rax # 0x4781b8
addq $0x1, %rax
movq %rax, 0x421399(%rip) # 0x4781b8
jmp 0x56e21
jmp 0x56e23
movb -0x15(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| translog_sync_files:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, dl
mov [rbp+var_8], edi
mov [rbp+var_C], esi
mov [rbp+var_D], al
mov [rbp+var_15], 0
jmp short $+2
loc_56D39:
jmp short $+2
loc_56D3B:
jmp short $+2
loc_56D3D:
mov eax, cs:group_commit_wait
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_56D64
call my_interval_timer
mov ecx, 3E8h
xor edx, edx
div rcx
mov cs:flush_start, rax
loc_56D64:
mov eax, [rbp+var_8]
mov [rbp+var_14], eax
loc_56D6A:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_C]
ja short loc_56DE4
mov edi, [rbp+var_14]
call get_logfile_by_number
mov [rbp+var_28], rax
jmp short $+2
loc_56D80:
mov rax, [rbp+var_28]
cmp byte ptr [rax+51h], 0
jnz short loc_56DD7
mov rax, [rbp+var_28]
mov edx, [rax+18h]
lea rdi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 1ED2h
mov ecx, 10h
call inline_mysql_file_sync_3
cmp eax, 0
jz short loc_56DBD
mov [rbp+var_15], 1
call translog_stop_writing
mov al, [rbp+var_15]
mov [rbp+var_1], al
jmp short loc_56E29
loc_56DBD:
mov rax, cs:translog_syncs
add rax, 1
mov cs:translog_syncs, rax
mov rax, [rbp+var_28]
mov byte ptr [rax+51h], 1
loc_56DD7:
jmp short $+2
loc_56DD9:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_56D6A
loc_56DE4:
cmp [rbp+var_D], 0
jz short loc_56E21
mov edx, cs:dword_4796B0
lea rdi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 1EE0h
mov ecx, 30h ; '0'
call inline_mysql_file_sync_3
mov [rbp+var_15], al
cmp al, 0
jnz short loc_56E1F
mov rax, cs:translog_syncs
add rax, 1
mov cs:translog_syncs, rax
loc_56E1F:
jmp short $+2
loc_56E21:
jmp short $+2
loc_56E23:
mov al, [rbp+var_15]
mov [rbp+var_1], al
loc_56E29:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char translog_sync_files(unsigned int a1, unsigned int a2, char a3)
{
long long logfile_by_number; // [rsp+8h] [rbp-28h]
char v5; // [rsp+1Bh] [rbp-15h]
v5 = 0;
if ( group_commit_wait )
flush_start = my_interval_timer() / 0x3E8uLL;
while ( a1 <= a2 )
{
logfile_by_number = get_logfile_by_number(a1);
if ( !*(_BYTE *)(logfile_by_number + 81) )
{
if ( (unsigned int)inline_mysql_file_sync_3(
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
7890LL,
*(unsigned int *)(logfile_by_number + 24),
16LL) )
{
translog_stop_writing();
return 1;
}
++translog_syncs;
*(_BYTE *)(logfile_by_number + 81) = 1;
}
++a1;
}
if ( a3 )
{
v5 = inline_mysql_file_sync_3(
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
7904LL,
(unsigned int)dword_4796B0,
48LL);
if ( !v5 )
++translog_syncs;
}
return v5;
}
| translog_sync_files:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,DL
MOV dword ptr [RBP + -0x8],EDI
MOV dword ptr [RBP + -0xc],ESI
MOV byte ptr [RBP + -0xd],AL
MOV byte ptr [RBP + -0x15],0x0
JMP 0x00156d39
LAB_00156d39:
JMP 0x00156d3b
LAB_00156d3b:
JMP 0x00156d3d
LAB_00156d3d:
MOV EAX,dword ptr [0x00d7a2e4]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00156d64
CALL 0x001f0070
MOV ECX,0x3e8
XOR EDX,EDX
DIV RCX
MOV qword ptr [0x00d7a2d0],RAX
LAB_00156d64:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x14],EAX
LAB_00156d6a:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0xc]
JA 0x00156de4
MOV EDI,dword ptr [RBP + -0x14]
CALL 0x00158990
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00156d80
LAB_00156d80:
MOV RAX,qword ptr [RBP + -0x28]
CMP byte ptr [RAX + 0x51],0x0
JNZ 0x00156dd7
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RAX + 0x18]
LEA RDI,[0x251cce]
MOV ESI,0x1ed2
MOV ECX,0x10
CALL 0x00159160
CMP EAX,0x0
JZ 0x00156dbd
MOV byte ptr [RBP + -0x15],0x1
CALL 0x0014f7b0
MOV AL,byte ptr [RBP + -0x15]
MOV byte ptr [RBP + -0x1],AL
JMP 0x00156e29
LAB_00156dbd:
MOV RAX,qword ptr [0x005781b8]
ADD RAX,0x1
MOV qword ptr [0x005781b8],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x51],0x1
LAB_00156dd7:
JMP 0x00156dd9
LAB_00156dd9:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00156d6a
LAB_00156de4:
CMP byte ptr [RBP + -0xd],0x0
JZ 0x00156e21
MOV EDX,dword ptr [0x005796b0]
LEA RDI,[0x251cce]
MOV ESI,0x1ee0
MOV ECX,0x30
CALL 0x00159160
MOV byte ptr [RBP + -0x15],AL
CMP AL,0x0
JNZ 0x00156e1f
MOV RAX,qword ptr [0x005781b8]
ADD RAX,0x1
MOV qword ptr [0x005781b8],RAX
LAB_00156e1f:
JMP 0x00156e21
LAB_00156e21:
JMP 0x00156e23
LAB_00156e23:
MOV AL,byte ptr [RBP + -0x15]
MOV byte ptr [RBP + -0x1],AL
LAB_00156e29:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int8 translog_sync_files(uint param_1,uint param_2,char param_3)
{
int iVar1;
ulong uVar2;
long lVar3;
int8 uVar4;
int7 uVar5;
char local_1d;
uint local_1c;
char local_9;
local_1d = '\0';
local_1c = param_1;
if (group_commit_wait != 0) {
uVar2 = my_interval_timer();
flush_start = uVar2 / 1000;
}
do {
uVar2 = (ulong)local_1c;
if (param_2 < local_1c) {
if (param_3 != '\0') {
uVar2 = inline_mysql_file_sync
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x1ee0,DAT_005796b0,0x30);
local_1d = (char)uVar2;
if (local_1d == '\0') {
uVar2 = translog_syncs + 1;
translog_syncs = uVar2;
}
}
uVar5 = (int7)(uVar2 >> 8);
local_9 = local_1d;
LAB_00156e29:
return CONCAT71(uVar5,local_9);
}
lVar3 = get_logfile_by_number(local_1c);
if (*(char *)(lVar3 + 0x51) == '\0') {
iVar1 = inline_mysql_file_sync
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x1ed2,*(int4 *)(lVar3 + 0x18),0x10);
if (iVar1 != 0) {
uVar4 = translog_stop_writing();
uVar5 = (int7)((ulong)uVar4 >> 8);
local_9 = '\x01';
goto LAB_00156e29;
}
translog_syncs = translog_syncs + 1;
*(int1 *)(lVar3 + 0x51) = 1;
}
local_1c = local_1c + 1;
} while( true );
}
| |
38,169 | sapphire_plugins::gravy::getDescriptor() | sapphire-plugins/src/gravy/processor.cpp | const clap_plugin_descriptor *getDescriptor()
{
static const char *features[] = {CLAP_PLUGIN_FEATURE_AUDIO_EFFECT, CLAP_PLUGIN_FEATURE_FILTER,
nullptr};
static clap_plugin_descriptor desc = {
CLAP_VERSION,
pluginId,
"Gravy",
"Sapphire",
"",
"",
"",
sst::plugininfra::VersionInformation::project_version_and_hash,
"A Fun Filter",
&features[0]};
return &desc;
} | O3 | cpp | sapphire_plugins::gravy::getDescriptor():
movb 0x502756(%rip), %al # 0x5f7b00
testb %al, %al
je 0xf53b6
leaq 0x5026f3(%rip), %rax # 0x5f7aa8
retq
pushq %rax
callq 0x8885a
addq $0x8, %rsp
jmp 0xf53ae
| _ZN16sapphire_plugins5gravy13getDescriptorEv:
mov al, cs:_ZGVZN16sapphire_plugins5gravy13getDescriptorEvE4desc; `guard variable for'sapphire_plugins::gravy::getDescriptor(void)::desc
test al, al
jz short loc_F53B6
loc_F53AE:
lea rax, _ZZN16sapphire_plugins5gravy13getDescriptorEvE4desc; sapphire_plugins::gravy::getDescriptor(void)::desc
retn
loc_F53B6:
push rax
call _ZN16sapphire_plugins5gravy13getDescriptorEv_cold_1; sapphire_plugins::gravy::getDescriptor(void) [clone]
add rsp, 8
jmp short loc_F53AE
| long long * sapphire_plugins::gravy::getDescriptor(sapphire_plugins::gravy *this)
{
if ( !(_BYTE)`guard variable for'sapphire_plugins::gravy::getDescriptor(void)::desc )
sapphire_plugins::gravy::getDescriptor();
return &sapphire_plugins::gravy::getDescriptor(void)::desc;
}
| getDescriptor:
MOV AL,byte ptr [0x006f7b00]
TEST AL,AL
JZ 0x001f53b6
LAB_001f53ae:
LEA RAX,[0x6f7aa8]
RET
LAB_001f53b6:
PUSH RAX
CALL 0x0018885a
ADD RSP,0x8
JMP 0x001f53ae
|
/* sapphire_plugins::gravy::getDescriptor() */
int1 * sapphire_plugins::gravy::getDescriptor(void)
{
if (getDescriptor()::desc == '\0') {
getDescriptor();
}
return getDescriptor()::desc;
}
| |
38,170 | ma_ft_parse | eloqsql/storage/maria/ma_ft_update.c | uint _ma_ft_parse(TREE *parsed, MARIA_HA *info, uint keynr, const uchar *record,
MYSQL_FTPARSER_PARAM *param, MEM_ROOT *mem_root)
{
FT_SEG_ITERATOR ftsi;
struct st_mysql_ftparser *parser;
DBUG_ENTER("_ma_ft_parse");
_ma_ft_segiterator_init(info, keynr, record, &ftsi);
maria_ft_parse_init(parsed, info->s->keyinfo[keynr].seg->charset);
parser= info->s->keyinfo[keynr].parser;
while (_ma_ft_segiterator(&ftsi))
{
/** @todo this casts ftsi.pos (const) to non-const */
if (ftsi.pos)
if (maria_ft_parse(parsed, (uchar *)ftsi.pos, ftsi.len, parser, param,
mem_root))
DBUG_RETURN(1);
}
DBUG_RETURN(0);
} | O0 | c | ma_ft_parse:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
leaq -0x58(%rbp), %rcx
callq 0x75be0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movq 0xc0(%rax), %rax
movq (%rax), %rsi
callq 0x75610
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movq 0xd0(%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x75cb0
cmpl $0x0, %eax
je 0x75f3c
cmpq $0x0, -0x40(%rbp)
je 0x75f3a
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x54(%rbp), %edx
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x756c0
cmpl $0x0, %eax
je 0x75f38
jmp 0x75f2f
movl $0x1, -0x4(%rbp)
jmp 0x75f45
jmp 0x75f3a
jmp 0x75ef7
jmp 0x75f3e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
| _ma_ft_parse:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rdi, [rbp+var_18]
mov esi, [rbp+var_1C]
mov rdx, [rbp+var_28]
lea rcx, [rbp+var_58]
call _ma_ft_segiterator_init
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+570h]
mov ecx, [rbp+var_1C]
imul rcx, 118h
add rax, rcx
mov rax, [rax+0C0h]
mov rsi, [rax]
call maria_ft_parse_init
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+570h]
mov ecx, [rbp+var_1C]
imul rcx, 118h
add rax, rcx
mov rax, [rax+0D0h]
mov [rbp+var_60], rax
loc_75EF7:
lea rdi, [rbp+var_58]
call _ma_ft_segiterator
cmp eax, 0
jz short loc_75F3C
cmp [rbp+var_40], 0
jz short loc_75F3A
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_40]
mov edx, [rbp+var_54]
mov rcx, [rbp+var_60]
mov r8, [rbp+var_30]
mov r9, [rbp+var_38]
call maria_ft_parse
cmp eax, 0
jz short loc_75F38
jmp short $+2
loc_75F2F:
mov [rbp+var_4], 1
jmp short loc_75F45
loc_75F38:
jmp short $+2
loc_75F3A:
jmp short loc_75EF7
loc_75F3C:
jmp short $+2
loc_75F3E:
mov [rbp+var_4], 0
loc_75F45:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long ma_ft_parse(_QWORD *a1, long long a2, unsigned int a3, long long a4, _QWORD *a5, long long a6)
{
long long v7; // [rsp+0h] [rbp-60h]
_BYTE v8[4]; // [rsp+8h] [rbp-58h] BYREF
int v9; // [rsp+Ch] [rbp-54h]
long long v10; // [rsp+20h] [rbp-40h]
long long v11; // [rsp+28h] [rbp-38h]
_QWORD *v12; // [rsp+30h] [rbp-30h]
long long v13; // [rsp+38h] [rbp-28h]
unsigned int v14; // [rsp+44h] [rbp-1Ch]
long long v15; // [rsp+48h] [rbp-18h]
_QWORD *v16; // [rsp+50h] [rbp-10h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12 = a5;
v11 = a6;
ma_ft_segiterator_init(a2, a3, a4, (long long)v8);
maria_ft_parse_init(v16, **(_QWORD **)(280LL * v14 + *(_QWORD *)(*(_QWORD *)v15 + 1392LL) + 192));
v7 = *(_QWORD *)(280LL * v14 + *(_QWORD *)(*(_QWORD *)v15 + 1392LL) + 208);
while ( (unsigned int)ma_ft_segiterator((long long)v8) )
{
if ( v10 && (unsigned int)maria_ft_parse((long long)v16, v10, v9, v7, v12, v11) )
return 1;
}
return 0;
}
| _ma_ft_parse:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x1c]
MOV RDX,qword ptr [RBP + -0x28]
LEA RCX,[RBP + -0x58]
CALL 0x00175be0
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0xc0]
MOV RSI,qword ptr [RAX]
CALL 0x00175610
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0xd0]
MOV qword ptr [RBP + -0x60],RAX
LAB_00175ef7:
LEA RDI,[RBP + -0x58]
CALL 0x00175cb0
CMP EAX,0x0
JZ 0x00175f3c
CMP qword ptr [RBP + -0x40],0x0
JZ 0x00175f3a
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x54]
MOV RCX,qword ptr [RBP + -0x60]
MOV R8,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x38]
CALL 0x001756c0
CMP EAX,0x0
JZ 0x00175f38
JMP 0x00175f2f
LAB_00175f2f:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00175f45
LAB_00175f38:
JMP 0x00175f3a
LAB_00175f3a:
JMP 0x00175ef7
LAB_00175f3c:
JMP 0x00175f3e
LAB_00175f3e:
MOV dword ptr [RBP + -0x4],0x0
LAB_00175f45:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int4
_ma_ft_parse(int8 param_1,long *param_2,uint param_3,int8 param_4,int8 param_5,
int8 param_6)
{
int8 uVar1;
int iVar2;
int1 local_60 [4];
int4 local_5c;
long local_48;
int8 local_40;
int8 local_38;
int8 local_30;
uint local_24;
long *local_20;
int8 local_18;
local_40 = param_6;
local_38 = param_5;
local_30 = param_4;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
_ma_ft_segiterator_init(param_2,param_3,param_4,local_60);
maria_ft_parse_init(local_18,**(int8 **)
(*(long *)(*local_20 + 0x570) + (ulong)local_24 * 0x118 + 0xc0));
uVar1 = *(int8 *)(*(long *)(*local_20 + 0x570) + (ulong)local_24 * 0x118 + 0xd0);
do {
iVar2 = _ma_ft_segiterator(local_60);
if (iVar2 == 0) {
return 0;
}
} while ((local_48 == 0) ||
(iVar2 = maria_ft_parse(local_18,local_48,local_5c,uVar1,local_38,local_40), iVar2 == 0));
return 1;
}
| |
38,171 | ma_pvio_wait_io_or_timeout | eloqsql/libmariadb/libmariadb/ma_pvio.c | int ma_pvio_wait_io_or_timeout(MARIADB_PVIO *pvio, my_bool is_read, int timeout)
{
if (pvio)
{
if (IS_PVIO_ASYNC_ACTIVE(pvio))
return ma_pvio_wait_async(pvio->mysql->options.extension->async_context,
(is_read) ? VIO_IO_EVENT_READ : VIO_IO_EVENT_WRITE,
timeout);
if (pvio && pvio->methods->wait_io_or_timeout)
return pvio->methods->wait_io_or_timeout(pvio, is_read, timeout);
}
return 1;
} | O0 | c | ma_pvio_wait_io_or_timeout:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x288eb
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x288b3
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x480(%rax)
je 0x288b3
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x288b3
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movsbl 0x14(%rax), %eax
cmpl $0x0, %eax
je 0x288b3
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rdi
movsbl -0x11(%rbp), %ecx
movl $0x1, %esi
xorl %eax, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
movl -0x18(%rbp), %edx
callq 0x28900
movsbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x288f2
cmpq $0x0, -0x10(%rbp)
je 0x288e9
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0x288e9
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %cl
movl -0x18(%rbp), %edx
movsbl %cl, %esi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x288f2
jmp 0x288eb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| ma_pvio_wait_io_or_timeout:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, sil
mov [rbp+var_10], rdi
mov [rbp+var_11], al
mov [rbp+var_18], edx
cmp [rbp+var_10], 0
jz loc_288EB
mov rax, [rbp+var_10]
cmp qword ptr [rax+40h], 0
jz short loc_288B3
mov rax, [rbp+var_10]
mov rax, [rax+40h]
cmp qword ptr [rax+480h], 0
jz short loc_288B3
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
cmp qword ptr [rax+28h], 0
jz short loc_288B3
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rax, [rax+28h]
movsx eax, byte ptr [rax+14h]
cmp eax, 0
jz short loc_288B3
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rdi, [rax+28h]
movsx ecx, [rbp+var_11]
mov esi, 1
xor eax, eax
cmp ecx, 0
cmovnz esi, eax
mov edx, [rbp+var_18]
call ma_pvio_wait_async
movsx eax, al
mov [rbp+var_4], eax
jmp short loc_288F2
loc_288B3:
cmp [rbp+var_10], 0
jz short loc_288E9
mov rax, [rbp+var_10]
mov rax, [rax+48h]
cmp qword ptr [rax+30h], 0
jz short loc_288E9
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov rax, [rax+30h]
mov rdi, [rbp+var_10]
mov cl, [rbp+var_11]
mov edx, [rbp+var_18]
movsx esi, cl
call rax
mov [rbp+var_4], eax
jmp short loc_288F2
loc_288E9:
jmp short $+2
loc_288EB:
mov [rbp+var_4], 1
loc_288F2:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long ma_pvio_wait_io_or_timeout(long long a1, char a2, unsigned int a3)
{
if ( !a1 )
return 1;
if ( !*(_QWORD *)(a1 + 64)
|| !*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL)
|| !*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 40LL)
|| !*(_BYTE *)(*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 40LL) + 20LL) )
{
if ( *(_QWORD *)(*(_QWORD *)(a1 + 72) + 48LL) )
return (unsigned int)(*(long long ( **)(long long, _QWORD, _QWORD))(*(_QWORD *)(a1 + 72) + 48LL))(
a1,
(unsigned int)a2,
a3);
return 1;
}
return (unsigned int)(char)ma_pvio_wait_async(
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 40LL),
a2 == 0,
a3);
}
| ma_pvio_wait_io_or_timeout:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,SIL
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],AL
MOV dword ptr [RBP + -0x18],EDX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001288eb
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x40],0x0
JZ 0x001288b3
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x001288b3
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x28],0x0
JZ 0x001288b3
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOVSX EAX,byte ptr [RAX + 0x14]
CMP EAX,0x0
JZ 0x001288b3
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RDI,qword ptr [RAX + 0x28]
MOVSX ECX,byte ptr [RBP + -0x11]
MOV ESI,0x1
XOR EAX,EAX
CMP ECX,0x0
CMOVNZ ESI,EAX
MOV EDX,dword ptr [RBP + -0x18]
CALL 0x00128900
MOVSX EAX,AL
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001288f2
LAB_001288b3:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001288e9
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
CMP qword ptr [RAX + 0x30],0x0
JZ 0x001288e9
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RBP + -0x11]
MOV EDX,dword ptr [RBP + -0x18]
MOVSX ESI,CL
CALL RAX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001288f2
LAB_001288e9:
JMP 0x001288eb
LAB_001288eb:
MOV dword ptr [RBP + -0x4],0x1
LAB_001288f2:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int ma_pvio_wait_io_or_timeout(long param_1,char param_2,int4 param_3)
{
char cVar1;
int iVar2;
if (param_1 != 0) {
if ((((*(long *)(param_1 + 0x40) != 0) && (*(long *)(*(long *)(param_1 + 0x40) + 0x480) != 0))
&& (*(long *)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x28) != 0)) &&
(*(char *)(*(long *)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x28) + 0x14) != '\0')) {
cVar1 = ma_pvio_wait_async(*(int8 *)
(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x28),
param_2 == '\0',param_3);
return (int)cVar1;
}
if ((param_1 != 0) && (*(long *)(*(long *)(param_1 + 0x48) + 0x30) != 0)) {
iVar2 = (**(code **)(*(long *)(param_1 + 0x48) + 0x30))(param_1,(int)param_2,param_3,param_2);
return iVar2;
}
}
return 1;
}
| |
38,172 | dual_vector_from_variable | tsotchke[P]eshkol/src/core/utils/autodiff.c | DualVector* dual_vector_from_variable(Arena* arena, VectorF* value) {
assert(arena != NULL);
assert(value != NULL);
// Create an identity derivative vector
VectorF* derivative = vector_f_create(arena, value->dim);
if (!derivative) return NULL;
// Initialize to identity
for (size_t i = 0; i < value->dim; i++) {
derivative->data[i] = 1.0f;
}
return dual_vector_create(arena, value, derivative);
} | O0 | c | dual_vector_from_variable:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8be9
jmp 0x8c08
leaq 0x388a(%rip), %rdi # 0xc47a
leaq 0x54e5(%rip), %rsi # 0xe0dc
movl $0xae, %edx
leaq 0x55c3(%rip), %rcx # 0xe1c6
callq 0x10b0
cmpq $0x0, -0x18(%rbp)
je 0x8c11
jmp 0x8c30
leaq 0x3899(%rip), %rdi # 0xc4b1
leaq 0x54bd(%rip), %rsi # 0xe0dc
movl $0xaf, %edx
leaq 0x559b(%rip), %rcx # 0xe1c6
callq 0x10b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3ea0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8c56
movq $0x0, -0x8(%rbp)
jmp 0x8ca4
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x8c8f
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movss 0x3394(%rip), %xmm0 # 0xc010
movss %xmm0, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x8c5e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x89e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
| dual_vector_from_variable:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
cmp [rbp+var_10], 0
jz short loc_8BE9
jmp short loc_8C08
loc_8BE9:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0AEh
lea rcx, aDualvectorDual_1; "DualVector *dual_vector_from_variable(A"...
call ___assert_fail
loc_8C08:
cmp [rbp+var_18], 0
jz short loc_8C11
jmp short loc_8C30
loc_8C11:
lea rdi, aAValueNull+2; "value != NULL"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0AFh
lea rcx, aDualvectorDual_1; "DualVector *dual_vector_from_variable(A"...
call ___assert_fail
loc_8C30:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rsi, [rax+10h]
call vector_f_create
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jnz short loc_8C56
mov [rbp+var_8], 0
jmp short loc_8CA4
loc_8C56:
mov [rbp+var_28], 0
loc_8C5E:
mov rax, [rbp+var_28]
mov rcx, [rbp+var_18]
cmp rax, [rcx+10h]
jnb short loc_8C8F
mov rax, [rbp+var_20]
mov rcx, [rbp+var_28]
movss xmm0, cs:dword_C010
movss dword ptr [rax+rcx*4], xmm0
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_8C5E
loc_8C8F:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call dual_vector_create
mov [rbp+var_8], rax
loc_8CA4:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| _QWORD * dual_vector_from_variable(_QWORD *a1, long long a2)
{
unsigned long long i; // [rsp+8h] [rbp-28h]
long long v4; // [rsp+10h] [rbp-20h]
if ( !a1 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/utils/autodiff.c",
174LL,
"DualVector *dual_vector_from_variable(Arena *, VectorF *)");
if ( !a2 )
__assert_fail(
"value != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/utils/autodiff.c",
175LL,
"DualVector *dual_vector_from_variable(Arena *, VectorF *)");
v4 = vector_f_create(a1, *(_QWORD *)(a2 + 16));
if ( !v4 )
return 0LL;
for ( i = 0LL; i < *(_QWORD *)(a2 + 16); ++i )
*(_DWORD *)(v4 + 4 * i) = 1065353216;
return dual_vector_create((long long)a1, a2, v4);
}
| dual_vector_from_variable:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00108be9
JMP 0x00108c08
LAB_00108be9:
LEA RDI,[0x10c468]
LEA RSI,[0x10e0ac]
MOV EDX,0xae
LEA RCX,[0x10e184]
CALL 0x001010b0
LAB_00108c08:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00108c11
JMP 0x00108c30
LAB_00108c11:
LEA RDI,[0x10c49f]
LEA RSI,[0x10e0ac]
MOV EDX,0xaf
LEA RCX,[0x10e184]
CALL 0x001010b0
LAB_00108c30:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x10]
CALL 0x00103ea0
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x00108c56
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00108ca4
LAB_00108c56:
MOV qword ptr [RBP + -0x28],0x0
LAB_00108c5e:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RCX + 0x10]
JNC 0x00108c8f
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOVSS XMM0,dword ptr [0x0010c010]
MOVSS dword ptr [RAX + RCX*0x4],XMM0
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00108c5e
LAB_00108c8f:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001089e0
MOV qword ptr [RBP + -0x8],RAX
LAB_00108ca4:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
int8 dual_vector_from_variable(long param_1,long param_2)
{
long lVar1;
ulong local_30;
int8 local_10;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/utils/autodiff.c",0xae,
"DualVector *dual_vector_from_variable(Arena *, VectorF *)");
}
if (param_2 != 0) {
lVar1 = vector_f_create(param_1,*(int8 *)(param_2 + 0x10));
if (lVar1 == 0) {
local_10 = 0;
}
else {
for (local_30 = 0; local_30 < *(ulong *)(param_2 + 0x10); local_30 = local_30 + 1) {
*(int4 *)(lVar1 + local_30 * 4) = DAT_0010c010;
}
local_10 = dual_vector_create(param_1,param_2,lVar1);
}
return local_10;
}
/* WARNING: Subroutine does not return */
__assert_fail("value != NULL","/workspace/llm4binary/github2025/eshkol/src/core/utils/autodiff.c",
0xaf,"DualVector *dual_vector_from_variable(Arena *, VectorF *)");
}
| |
38,173 | dual_vector_from_variable | tsotchke[P]eshkol/src/core/utils/autodiff.c | DualVector* dual_vector_from_variable(Arena* arena, VectorF* value) {
assert(arena != NULL);
assert(value != NULL);
// Create an identity derivative vector
VectorF* derivative = vector_f_create(arena, value->dim);
if (!derivative) return NULL;
// Initialize to identity
for (size_t i = 0; i < value->dim; i++) {
derivative->data[i] = 1.0f;
}
return dual_vector_create(arena, value, derivative);
} | O3 | c | dual_vector_from_variable:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6273
movq %rsi, %rbx
testq %rsi, %rsi
je 0x6292
movq %rdi, %r14
movq 0x10(%rbx), %rsi
callq 0x31fc
testq %rax, %rax
je 0x6269
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x6254
leaq 0x3(%rdx), %rcx
andq $-0x4, %rcx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
movdqa 0x5079(%rip), %xmm1 # 0xb1f0
movdqa 0x40a1(%rip), %xmm2 # 0xa220
xorl %edx, %edx
movdqa 0x2f67(%rip), %xmm3 # 0x90f0
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x5067(%rip), %xmm5 # 0xb200
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x61d5
movl $0x3f800000, (%rax,%rdx,4) # imm = 0x3F800000
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x61ec
movl $0x3f800000, 0x4(%rax,%rdx,4) # imm = 0x3F800000
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %esi
testb $0x1, %sil
je 0x622c
movl $0x3f800000, 0x8(%rax,%rdx,4) # imm = 0x3F800000
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x623f
movl $0x3f800000, 0xc(%rax,%rdx,4) # imm = 0x3F800000
addq $0x4, %rdx
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
cmpq %rdx, %rcx
jne 0x6199
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5fcc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x31ed(%rip), %rdi # 0x9467
leaq 0x4fcb(%rip), %rsi # 0xb24c
leaq 0x50ae(%rip), %rcx # 0xb336
movl $0xae, %edx
callq 0x10b0
leaq 0x3205(%rip), %rdi # 0x949e
leaq 0x4fac(%rip), %rsi # 0xb24c
leaq 0x508f(%rip), %rcx # 0xb336
movl $0xaf, %edx
callq 0x10b0
| dual_vector_from_variable:
push r14
push rbx
push rax
test rdi, rdi
jz loc_6273
mov rbx, rsi
test rsi, rsi
jz loc_6292
mov r14, rdi
mov rsi, [rbx+10h]
call vector_f_create
test rax, rax
jz loc_6269
mov rdx, [rbx+10h]
test rdx, rdx
jz loc_6254
lea rcx, [rdx+3]
and rcx, 0FFFFFFFFFFFFFFFCh
dec rdx
movq xmm0, rdx
pshufd xmm0, xmm0, 44h ; 'D'
movdqa xmm1, cs:xmmword_B1F0
movdqa xmm2, cs:xmmword_A220
xor edx, edx
movdqa xmm3, cs:xmmword_90F0
pxor xmm0, xmm3
pcmpeqd xmm4, xmm4
movdqa xmm5, cs:xmmword_B200
loc_6199:
movdqa xmm6, xmm2
pxor xmm6, xmm3
movdqa xmm7, xmm6
pcmpgtd xmm7, xmm0
pcmpeqd xmm6, xmm0
pshufd xmm8, xmm6, 0F5h
pand xmm8, xmm7
pshufd xmm6, xmm7, 0F5h
por xmm6, xmm8
movd esi, xmm6
not esi
test sil, 1
jz short loc_61D5
mov dword ptr [rax+rdx*4], 3F800000h
loc_61D5:
pxor xmm6, xmm4
pextrw esi, xmm6, 4
test sil, 1
jz short loc_61EC
mov dword ptr [rax+rdx*4+4], 3F800000h
loc_61EC:
movdqa xmm6, xmm1
pxor xmm6, xmm3
movdqa xmm7, xmm6
pcmpgtd xmm7, xmm0
pcmpeqd xmm6, xmm0
pshufd xmm8, xmm6, 0F5h
pand xmm8, xmm7
pshufd xmm6, xmm7, 0F5h
por xmm6, xmm8
pxor xmm6, xmm4
pextrw esi, xmm6, 0
test sil, 1
jz short loc_622C
mov dword ptr [rax+rdx*4+8], 3F800000h
loc_622C:
pextrw esi, xmm6, 4
test sil, 1
jz short loc_623F
mov dword ptr [rax+rdx*4+0Ch], 3F800000h
loc_623F:
add rdx, 4
paddq xmm2, xmm5
paddq xmm1, xmm5
cmp rcx, rdx
jnz loc_6199
loc_6254:
mov rdi, r14
mov rsi, rbx
mov rdx, rax
add rsp, 8
pop rbx
pop r14
jmp dual_vector_create
loc_6269:
xor eax, eax
add rsp, 8
pop rbx
pop r14
retn
loc_6273:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aDualvectorDual_1; "DualVector *dual_vector_from_variable(A"...
mov edx, 0AEh
call ___assert_fail
loc_6292:
lea rdi, aAValueNull+2; "value != NULL"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aDualvectorDual_1; "DualVector *dual_vector_from_variable(A"...
mov edx, 0AFh
call ___assert_fail
| _QWORD * dual_vector_from_variable(_QWORD *a1, long long a2)
{
long long v2; // rax
long long v3; // rdx
unsigned long long v4; // rcx
__m128i v5; // xmm0
__m128i si128; // xmm1
__m128i v7; // xmm2
long long v8; // rdx
__m128i v9; // xmm3
__m128i v10; // xmm0
__m128i v11; // xmm5
__m128i v12; // xmm6
__m128i v13; // xmm7
__m128i v14; // xmm6
__m128i v15; // xmm6
__m128i v16; // xmm7
__m128i v17; // xmm6
if ( !a1 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/utils/autodiff.c",
174LL,
"DualVector *dual_vector_from_variable(Arena *, VectorF *)");
if ( !a2 )
__assert_fail(
"value != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/utils/autodiff.c",
175LL,
"DualVector *dual_vector_from_variable(Arena *, VectorF *)");
v2 = vector_f_create(a1, *(_QWORD *)(a2 + 16));
if ( !v2 )
return 0LL;
v3 = *(_QWORD *)(a2 + 16);
if ( v3 )
{
v4 = (v3 + 3) & 0xFFFFFFFFFFFFFFFCLL;
v5 = _mm_shuffle_epi32((__m128i)(unsigned long long)(v3 - 1), 68);
si128 = _mm_load_si128((const __m128i *)&xmmword_B1F0);
v7 = _mm_load_si128((const __m128i *)&xmmword_A220);
v8 = 0LL;
v9 = _mm_load_si128((const __m128i *)&xmmword_90F0);
v10 = _mm_xor_si128(v5, v9);
v11 = _mm_load_si128((const __m128i *)&xmmword_B200);
do
{
v12 = _mm_xor_si128(v7, v9);
v13 = _mm_cmpgt_epi32(v12, v10);
v14 = _mm_or_si128(
_mm_shuffle_epi32(v13, 245),
_mm_and_si128(_mm_shuffle_epi32(_mm_cmpeq_epi32(v12, v10), 245), v13));
if ( (~_mm_cvtsi128_si32(v14) & 1) != 0 )
*(_DWORD *)(v2 + 4 * v8) = 1065353216;
if ( (_mm_extract_epi16(_mm_xor_si128(v14, (__m128i)-1LL), 4) & 1) != 0 )
*(_DWORD *)(v2 + 4 * v8 + 4) = 1065353216;
v15 = _mm_xor_si128(si128, v9);
v16 = _mm_cmpgt_epi32(v15, v10);
v17 = _mm_xor_si128(
_mm_or_si128(
_mm_shuffle_epi32(v16, 245),
_mm_and_si128(_mm_shuffle_epi32(_mm_cmpeq_epi32(v15, v10), 245), v16)),
(__m128i)-1LL);
if ( (_mm_extract_epi16(v17, 0) & 1) != 0 )
*(_DWORD *)(v2 + 4 * v8 + 8) = 1065353216;
if ( (_mm_extract_epi16(v17, 4) & 1) != 0 )
*(_DWORD *)(v2 + 4 * v8 + 12) = 1065353216;
v8 += 4LL;
v7 = _mm_add_epi64(v7, v11);
si128 = _mm_add_epi64(si128, v11);
}
while ( v4 != v8 );
}
return dual_vector_create((long long)a1, a2, v2);
}
| |||
38,174 | GL_MeshingTask::vis_test(unsigned short, VoxelInfo const*, glm::vec<3, short, (glm::qualifier)0> const&) const | untodesu[P]voxelius/game/client/chunk_mesher.cc | bool GL_MeshingTask::vis_test(voxel_id voxel, const VoxelInfo *info, const local_pos &lpos) const
{
const auto pvpos = coord::to_voxel(m_cpos, lpos);
const auto pcpos = coord::to_chunk(pvpos);
const auto plpos = coord::to_local(pvpos);
const auto index = coord::to_index(plpos);
const auto cached_cpos = get_cached_cpos(m_cpos, pcpos);
const auto &voxels = m_cache.at(cached_cpos);
const auto neighbour = voxels[index];
if(neighbour == NULL_VOXEL_ID)
return true;
if(neighbour == voxel)
return false;
if(const VoxelInfo *neighbour_info = voxel_registry::find(neighbour)) {
if(neighbour_info->blending != info->blending) {
// Voxel types that use blending are semi-transparent;
// this means they're rendered using a different setup
// and they must have visible faces with opaque voxels
return neighbour_info->blending;
}
}
return false;
} | O0 | cpp | GL_MeshingTask::vis_test(unsigned short, VoxelInfo const*, glm::vec<3, short, (glm::qualifier)0> const&) const:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x98(%rbp)
addq $0xe054, %rsi # imm = 0xE054
movq -0x28(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x637b0
movq -0xa0(%rbp), %rdi
callq 0x63ba0
movq -0xa0(%rbp), %rdi
movl %edx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x63c00
movl %eax, %ecx
movl %ecx, -0x66(%rbp)
shrq $0x20, %rax
movw %ax, -0x62(%rbp)
leaq -0x66(%rbp), %rdi
callq 0x63c90
movq -0x98(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0xe054, %rdi # imm = 0xE054
leaq -0x50(%rbp), %rsi
callq 0x61970
movq -0x98(%rbp), %rdi
movw %ax, -0x72(%rbp)
addq $0x20, %rdi
movzwl -0x72(%rbp), %eax
movl %eax, %esi
callq 0x63cc0
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x636c0
movw (%rax), %ax
movw %ax, -0x82(%rbp)
movzwl -0x82(%rbp), %eax
cmpl $0x0, %eax
jne 0x61359
movb $0x1, -0x1(%rbp)
jmp 0x613c2
movzwl -0x82(%rbp), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6136e
movb $0x0, -0x1(%rbp)
jmp 0x613c2
movzwl -0x82(%rbp), %edi
callq 0x17c620
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x90(%rbp)
je 0x613be
movq -0x90(%rbp), %rax
movb 0x23(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movb 0x23(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x613bc
movq -0x90(%rbp), %rax
movb 0x23(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x613c2
jmp 0x613be
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
| _ZNK14GL_MeshingTask8vis_testEtPK9VoxelInfoRKN3glm3vecILi3EsLNS3_9qualifierE0EEE:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov ax, si
mov [rbp+var_10], rdi
mov [rbp+var_12], ax
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rsi, [rbp+var_10]
mov [rbp+var_98], rsi
add rsi, 0E054h
mov rdx, [rbp+var_28]
lea rdi, [rbp+var_40]
mov [rbp+var_A0], rdi
call _ZN5coord8to_voxelERKN3glm3vecILi3EiLNS0_9qualifierE0EEERKNS1_ILi3EsLS2_0EEE; coord::to_voxel(glm::vec<3,int,(glm::qualifier)0> const&,glm::vec<3,short,(glm::qualifier)0> const&)
mov rdi, [rbp+var_A0]
call _ZN5coord8to_chunkERKN3glm3vecILi3ElLNS0_9qualifierE0EEE; coord::to_chunk(glm::vec<3,long,(glm::qualifier)0> const&)
mov rdi, [rbp+var_A0]
mov [rbp+var_58], edx
mov [rbp+var_60], rax
mov eax, [rbp+var_58]
mov [rbp+var_48], eax
mov rax, [rbp+var_60]
mov [rbp+var_50], rax
call _ZN5coord8to_localERKN3glm3vecILi3ElLNS0_9qualifierE0EEE; coord::to_local(glm::vec<3,long,(glm::qualifier)0> const&)
mov ecx, eax
mov [rbp+var_66], ecx
shr rax, 20h
mov [rbp+var_62], ax
lea rdi, [rbp+var_66]
call _ZN5coord8to_indexERKN3glm3vecILi3EsLNS0_9qualifierE0EEE; coord::to_index(glm::vec<3,short,(glm::qualifier)0> const&)
mov rdi, [rbp+var_98]
mov qword ptr [rbp+var_70], rax
add rdi, 0E054h
lea rsi, [rbp+var_50]
call _ZL15get_cached_cposRKN3glm3vecILi3EiLNS_9qualifierE0EEES4_; get_cached_cpos(glm::vec<3,int,(glm::qualifier)0> const&,glm::vec<3,int,(glm::qualifier)0> const&)
mov rdi, [rbp+var_98]
mov [rbp+var_72], ax
add rdi, 20h ; ' '
movzx eax, [rbp+var_72]
mov esi, eax
call _ZNKSt5arrayI12VoxelStorageLm7EE2atEm; std::array<VoxelStorage,7ul>::at(ulong)
mov [rbp+var_80], rax
mov rdi, [rbp+var_80]
mov rsi, qword ptr [rbp+var_70]; unsigned __int16
call _ZNKSt5arrayItLm4096EEixEm; std::array<ushort,4096ul>::operator[](ulong)
mov ax, [rax]
mov [rbp+var_82], ax
movzx eax, [rbp+var_82]
cmp eax, 0
jnz short loc_61359
mov [rbp+var_1], 1
jmp short loc_613C2
loc_61359:
movzx eax, [rbp+var_82]
movzx ecx, [rbp+var_12]
cmp eax, ecx
jnz short loc_6136E
mov [rbp+var_1], 0
jmp short loc_613C2
loc_6136E:
movzx edi, [rbp+var_82]; this
call _ZN14voxel_registry4findEt; voxel_registry::find(ushort)
mov [rbp+var_90], rax
cmp [rbp+var_90], 0
jz short loc_613BE
mov rax, [rbp+var_90]
mov al, [rax+23h]
and al, 1
movzx eax, al
mov rcx, [rbp+var_20]
mov cl, [rcx+23h]
and cl, 1
movzx ecx, cl
cmp eax, ecx
jz short loc_613BC
mov rax, [rbp+var_90]
mov al, [rax+23h]
and al, 1
mov [rbp+var_1], al
jmp short loc_613C2
loc_613BC:
jmp short $+2
loc_613BE:
mov [rbp+var_1], 0
loc_613C2:
mov al, [rbp+var_1]
and al, 1
add rsp, 0A0h
pop rbp
retn
| char GL_MeshingTask::vis_test(long long a1, unsigned __int16 a2, long long a3, long long a4)
{
long long v4; // rax
int v5; // edx
long long v6; // rax
long long v8; // [rsp+10h] [rbp-90h]
unsigned __int16 v9; // [rsp+1Eh] [rbp-82h]
long long v10; // [rsp+20h] [rbp-80h]
unsigned __int16 cached_cpos; // [rsp+2Eh] [rbp-72h]
unsigned __int16 v12[4]; // [rsp+30h] [rbp-70h]
int v13; // [rsp+3Ah] [rbp-66h] BYREF
__int16 v14; // [rsp+3Eh] [rbp-62h]
long long v15; // [rsp+40h] [rbp-60h]
int v16; // [rsp+48h] [rbp-58h]
long long v17; // [rsp+50h] [rbp-50h] BYREF
int v18; // [rsp+58h] [rbp-48h]
_BYTE v19[24]; // [rsp+60h] [rbp-40h] BYREF
long long v20; // [rsp+78h] [rbp-28h]
long long v21; // [rsp+80h] [rbp-20h]
unsigned __int16 v22; // [rsp+8Eh] [rbp-12h]
long long v23; // [rsp+90h] [rbp-10h]
v23 = a1;
v22 = a2;
v21 = a3;
v20 = a4;
coord::to_voxel(v19, a1 + 57428, a4);
v4 = coord::to_chunk(v19);
v16 = v5;
v15 = v4;
v18 = v5;
v17 = v4;
v6 = coord::to_local(v19);
v13 = v6;
v14 = WORD2(v6);
*(_QWORD *)v12 = coord::to_index(&v13);
cached_cpos = get_cached_cpos(a1 + 57428, &v17);
v10 = std::array<VoxelStorage,7ul>::at(a1 + 32, cached_cpos);
v9 = *(_WORD *)std::array<unsigned short,4096ul>::operator[](v10, *(_QWORD *)v12);
if ( !v9 )
return 1;
if ( v9 == v22 )
return 0;
v8 = voxel_registry::find((voxel_registry *)v9, v12[0]);
if ( !v8 || (*(_BYTE *)(v8 + 35) & 1) == (*(_BYTE *)(v21 + 35) & 1) )
return 0;
else
return *(_BYTE *)(v8 + 35) & 1;
}
| vis_test:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV AX,SI
MOV qword ptr [RBP + -0x10],RDI
MOV word ptr [RBP + -0x12],AX
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RSI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x98],RSI
ADD RSI,0xe054
MOV RDX,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x40]
MOV qword ptr [RBP + -0xa0],RDI
CALL 0x001637b0
MOV RDI,qword ptr [RBP + -0xa0]
CALL 0x00163ba0
MOV RDI,qword ptr [RBP + -0xa0]
MOV dword ptr [RBP + -0x58],EDX
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,dword ptr [RBP + -0x58]
MOV dword ptr [RBP + -0x48],EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x50],RAX
CALL 0x00163c00
MOV ECX,EAX
MOV dword ptr [RBP + -0x66],ECX
SHR RAX,0x20
MOV word ptr [RBP + -0x62],AX
LEA RDI,[RBP + -0x66]
CALL 0x00163c90
MOV RDI,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x70],RAX
ADD RDI,0xe054
LEA RSI,[RBP + -0x50]
CALL 0x00161970
MOV RDI,qword ptr [RBP + -0x98]
MOV word ptr [RBP + -0x72],AX
ADD RDI,0x20
MOVZX EAX,word ptr [RBP + -0x72]
MOV ESI,EAX
CALL 0x00163cc0
MOV qword ptr [RBP + -0x80],RAX
MOV RDI,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x70]
CALL 0x001636c0
MOV AX,word ptr [RAX]
MOV word ptr [RBP + -0x82],AX
MOVZX EAX,word ptr [RBP + -0x82]
CMP EAX,0x0
JNZ 0x00161359
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001613c2
LAB_00161359:
MOVZX EAX,word ptr [RBP + -0x82]
MOVZX ECX,word ptr [RBP + -0x12]
CMP EAX,ECX
JNZ 0x0016136e
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001613c2
LAB_0016136e:
MOVZX EDI,word ptr [RBP + -0x82]
CALL 0x0027c620
MOV qword ptr [RBP + -0x90],RAX
CMP qword ptr [RBP + -0x90],0x0
JZ 0x001613be
MOV RAX,qword ptr [RBP + -0x90]
MOV AL,byte ptr [RAX + 0x23]
AND AL,0x1
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x20]
MOV CL,byte ptr [RCX + 0x23]
AND CL,0x1
MOVZX ECX,CL
CMP EAX,ECX
JZ 0x001613bc
MOV RAX,qword ptr [RBP + -0x90]
MOV AL,byte ptr [RAX + 0x23]
AND AL,0x1
MOV byte ptr [RBP + -0x1],AL
JMP 0x001613c2
LAB_001613bc:
JMP 0x001613be
LAB_001613be:
MOV byte ptr [RBP + -0x1],0x0
LAB_001613c2:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0xa0
POP RBP
RET
|
/* GL_MeshingTask::vis_test(unsigned short, VoxelInfo const*, glm::vec<3, short, (glm::qualifier)0>
const&) const */
byte __thiscall
GL_MeshingTask::vis_test(GL_MeshingTask *this,ushort param_1,VoxelInfo *param_2,vec *param_3)
{
ushort uVar1;
int8 uVar2;
ulong uVar3;
array<unsigned_short,4096ul> *this_00;
ushort *puVar4;
long lVar5;
int4 local_6e;
int2 local_6a;
int1 local_68 [12];
vec local_58 [16];
coord local_48 [24];
vec *local_30;
VoxelInfo *local_28;
ushort local_1a;
GL_MeshingTask *local_18;
byte local_9;
local_30 = param_3;
local_28 = param_2;
local_1a = param_1;
local_18 = this;
coord::to_voxel(local_48,(vec *)(this + 0xe054),param_3);
local_68 = coord::to_chunk((vec *)local_48);
local_58._0_12_ = local_68;
uVar2 = coord::to_local((vec *)local_48);
local_6e = (int4)uVar2;
local_6a = (int2)((ulong)uVar2 >> 0x20);
uVar3 = coord::to_index((vec *)&local_6e);
uVar1 = get_cached_cpos((vec *)(this + 0xe054),local_58);
this_00 = (array<unsigned_short,4096ul> *)
std::array<VoxelStorage,7ul>::at((array<VoxelStorage,7ul> *)(this + 0x20),(ulong)uVar1);
puVar4 = (ushort *)std::array<unsigned_short,4096ul>::operator[](this_00,uVar3);
uVar1 = *puVar4;
if (uVar1 == 0) {
local_9 = 1;
}
else if (uVar1 == local_1a) {
local_9 = 0;
}
else {
lVar5 = voxel_registry::find(uVar1);
if ((lVar5 == 0) || ((*(byte *)(lVar5 + 0x23) & 1) == ((byte)local_28[0x23] & 1))) {
local_9 = 0;
}
else {
local_9 = *(byte *)(lVar5 + 0x23) & 1;
}
}
return local_9;
}
| |
38,175 | DrawSplineSegmentBezierQuadratic | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rshapes.c | void DrawSplineSegmentBezierQuadratic(Vector2 p1, Vector2 c2, Vector2 p3, float thick, Color color)
{
const float step = 1.0f/SPLINE_SEGMENT_DIVISIONS;
Vector2 previous = p1;
Vector2 current = { 0 };
float t = 0.0f;
Vector2 points[2*SPLINE_SEGMENT_DIVISIONS + 2] = { 0 };
for (int i = 1; i <= SPLINE_SEGMENT_DIVISIONS; i++)
{
t = step*(float)i;
float a = powf(1.0f - t, 2);
float b = 2.0f*(1.0f - t)*t;
float c = powf(t, 2);
// NOTE: The easing functions aren't suitable here because they don't take a control point
current.y = a*p1.y + b*c2.y + c*p3.y;
current.x = a*p1.x + b*c2.x + c*p3.x;
float dy = current.y - previous.y;
float dx = current.x - previous.x;
float size = 0.5f*thick/sqrtf(dx*dx+dy*dy);
if (i == 1)
{
points[0].x = previous.x + dy*size;
points[0].y = previous.y - dx*size;
points[1].x = previous.x - dy*size;
points[1].y = previous.y + dx*size;
}
points[2*i + 1].x = current.x - dy*size;
points[2*i + 1].y = current.y + dx*size;
points[2*i].x = current.x + dy*size;
points[2*i].y = current.y - dx*size;
previous = current;
}
DrawTriangleStrip(points, 2*SPLINE_SEGMENT_DIVISIONS + 2, color);
} | O0 | c | DrawSplineSegmentBezierQuadratic:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movlpd %xmm0, -0x8(%rbp)
movlpd %xmm1, -0x10(%rbp)
movlpd %xmm2, -0x18(%rbp)
movl %edi, -0x1c(%rbp)
movss %xmm3, -0x20(%rbp)
movss 0xdedca(%rip), %xmm0 # 0x1bcbb4
movss %xmm0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2c(%rbp)
leaq -0x34(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0xa2d0
xorps %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
leaq -0x1d0(%rbp), %rdi
xorl %esi, %esi
movl $0x190, %edx # imm = 0x190
callq 0xa2d0
movl $0x1, -0x1d4(%rbp)
cmpl $0x18, -0x1d4(%rbp)
jg 0xde160
cvtsi2ssl -0x1d4(%rbp), %xmm1
movss 0xded6b(%rip), %xmm0 # 0x1bcbb4
mulss %xmm1, %xmm0
movss %xmm0, -0x38(%rbp)
movss 0xc629a(%rip), %xmm0 # 0x1a40f4
subss -0x38(%rbp), %xmm0
movss 0xca1b5(%rip), %xmm1 # 0x1a801c
callq 0xa8a0
movss %xmm0, -0x1d8(%rbp)
movss 0xc6278(%rip), %xmm1 # 0x1a40f4
subss -0x38(%rbp), %xmm1
movss 0xca193(%rip), %xmm0 # 0x1a801c
mulss %xmm1, %xmm0
mulss -0x38(%rbp), %xmm0
movss %xmm0, -0x1dc(%rbp)
movss -0x38(%rbp), %xmm0
movss 0xca175(%rip), %xmm1 # 0x1a801c
callq 0xa8a0
movss %xmm0, -0x1e0(%rbp)
movss -0x1d8(%rbp), %xmm1
movss -0x4(%rbp), %xmm2
movss -0x1dc(%rbp), %xmm0
mulss -0xc(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x1e0(%rbp), %xmm0
movss -0x14(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x1d8(%rbp), %xmm1
movss -0x8(%rbp), %xmm2
movss -0x1dc(%rbp), %xmm0
mulss -0x10(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x1e0(%rbp), %xmm0
movss -0x18(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x30(%rbp), %xmm0
subss -0x28(%rbp), %xmm0
movss %xmm0, -0x1e4(%rbp)
movss -0x34(%rbp), %xmm0
subss -0x2c(%rbp), %xmm0
movss %xmm0, -0x1e8(%rbp)
movss 0xc6198(%rip), %xmm0 # 0x1a40f0
mulss -0x20(%rbp), %xmm0
movss %xmm0, -0x1f0(%rbp)
movss -0x1e8(%rbp), %xmm0
movss -0x1e8(%rbp), %xmm2
movss -0x1e4(%rbp), %xmm1
mulss -0x1e4(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0xaa30
movaps %xmm0, %xmm1
movss -0x1f0(%rbp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0x1ec(%rbp)
cmpl $0x1, -0x1d4(%rbp)
jne 0xde064
movss -0x2c(%rbp), %xmm1
movss -0x1e4(%rbp), %xmm0
movss -0x1ec(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1d0(%rbp)
movss -0x28(%rbp), %xmm1
movss -0x1e8(%rbp), %xmm0
movss -0x1ec(%rbp), %xmm2
movd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1cc(%rbp)
movss -0x2c(%rbp), %xmm1
movss -0x1e4(%rbp), %xmm0
movss -0x1ec(%rbp), %xmm2
movd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1c8(%rbp)
movss -0x28(%rbp), %xmm1
movss -0x1e8(%rbp), %xmm0
movss -0x1ec(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1c4(%rbp)
movss -0x34(%rbp), %xmm1
movss -0x1e4(%rbp), %xmm0
movss -0x1ec(%rbp), %xmm2
movd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movl -0x1d4(%rbp), %eax
shll %eax
addl $0x1, %eax
cltq
movss %xmm0, -0x1d0(%rbp,%rax,8)
movss -0x30(%rbp), %xmm1
movss -0x1e8(%rbp), %xmm0
movss -0x1ec(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movl -0x1d4(%rbp), %eax
shll %eax
addl $0x1, %eax
cltq
movss %xmm0, -0x1cc(%rbp,%rax,8)
movss -0x34(%rbp), %xmm1
movss -0x1e4(%rbp), %xmm0
movss -0x1ec(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movl -0x1d4(%rbp), %eax
shll %eax
cltq
movss %xmm0, -0x1d0(%rbp,%rax,8)
movss -0x30(%rbp), %xmm1
movss -0x1e8(%rbp), %xmm0
movss -0x1ec(%rbp), %xmm2
movd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movl -0x1d4(%rbp), %eax
shll %eax
cltq
movss %xmm0, -0x1cc(%rbp,%rax,8)
movq -0x34(%rbp), %rax
movq %rax, -0x2c(%rbp)
movl -0x1d4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d4(%rbp)
jmp 0xdde2c
leaq -0x1d0(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl $0x32, %esi
callq 0xd7610
addq $0x1f0, %rsp # imm = 0x1F0
popq %rbp
retq
nopl (%rax)
| DrawSplineSegmentBezierQuadratic:
push rbp
mov rbp, rsp
sub rsp, 1F0h
movlpd [rbp+var_8], xmm0
movlpd [rbp+var_10], xmm1
movlpd [rbp+var_18], xmm2
mov [rbp+var_1C], edi
movss [rbp+var_20], xmm3
movss xmm0, cs:dword_1BCBB4
movss [rbp+var_24], xmm0
mov rax, [rbp+var_8]
mov [rbp+var_2C], rax
lea rdi, [rbp+var_34]
xor esi, esi
mov edx, 8
call _memset
xorps xmm0, xmm0
movss [rbp+var_38], xmm0
lea rdi, [rbp+var_1D0]
xor esi, esi
mov edx, 190h
call _memset
mov [rbp+var_1D4], 1
loc_DDE2C:
cmp [rbp+var_1D4], 18h
jg loc_DE160
cvtsi2ss xmm1, [rbp+var_1D4]
movss xmm0, cs:dword_1BCBB4
mulss xmm0, xmm1
movss [rbp+var_38], xmm0
movss xmm0, cs:dword_1A40F4
subss xmm0, [rbp+var_38]
movss xmm1, cs:dword_1A801C
call _powf
movss [rbp+var_1D8], xmm0
movss xmm1, cs:dword_1A40F4
subss xmm1, [rbp+var_38]
movss xmm0, cs:dword_1A801C
mulss xmm0, xmm1
mulss xmm0, [rbp+var_38]
movss [rbp+var_1DC], xmm0
movss xmm0, [rbp+var_38]
movss xmm1, cs:dword_1A801C
call _powf
movss [rbp+var_1E0], xmm0
movss xmm1, [rbp+var_1D8]
movss xmm2, dword ptr [rbp+var_8+4]
movss xmm0, [rbp+var_1DC]
mulss xmm0, dword ptr [rbp+var_10+4]
mulss xmm1, xmm2
addss xmm1, xmm0
movss xmm0, [rbp+var_1E0]
movss xmm2, dword ptr [rbp+var_18+4]
mulss xmm0, xmm2
addss xmm0, xmm1
movss dword ptr [rbp+var_34+4], xmm0
movss xmm1, [rbp+var_1D8]
movss xmm2, dword ptr [rbp+var_8]
movss xmm0, [rbp+var_1DC]
mulss xmm0, dword ptr [rbp+var_10]
mulss xmm1, xmm2
addss xmm1, xmm0
movss xmm0, [rbp+var_1E0]
movss xmm2, dword ptr [rbp+var_18]
mulss xmm0, xmm2
addss xmm0, xmm1
movss dword ptr [rbp+var_34], xmm0
movss xmm0, dword ptr [rbp+var_34+4]
subss xmm0, dword ptr [rbp+var_2C+4]
movss [rbp+var_1E4], xmm0
movss xmm0, dword ptr [rbp+var_34]
subss xmm0, dword ptr [rbp+var_2C]
movss [rbp+var_1E8], xmm0
movss xmm0, cs:dword_1A40F0
mulss xmm0, [rbp+var_20]
movss [rbp+var_1F0], xmm0
movss xmm0, [rbp+var_1E8]
movss xmm2, [rbp+var_1E8]
movss xmm1, [rbp+var_1E4]
mulss xmm1, [rbp+var_1E4]
mulss xmm0, xmm2
addss xmm0, xmm1
call _sqrtf
movaps xmm1, xmm0
movss xmm0, [rbp+var_1F0]
divss xmm0, xmm1
movss [rbp+var_1EC], xmm0
cmp [rbp+var_1D4], 1
jnz loc_DE064
movss xmm1, dword ptr [rbp+var_2C]
movss xmm0, [rbp+var_1E4]
movss xmm2, [rbp+var_1EC]
mulss xmm0, xmm2
addss xmm0, xmm1
movss [rbp+var_1D0], xmm0
movss xmm1, dword ptr [rbp+var_2C+4]
movss xmm0, [rbp+var_1E8]
movss xmm2, [rbp+var_1EC]
movd eax, xmm0
xor eax, 80000000h
movd xmm0, eax
mulss xmm0, xmm2
addss xmm0, xmm1
movss [rbp+var_1CC], xmm0
movss xmm1, dword ptr [rbp+var_2C]
movss xmm0, [rbp+var_1E4]
movss xmm2, [rbp+var_1EC]
movd eax, xmm0
xor eax, 80000000h
movd xmm0, eax
mulss xmm0, xmm2
addss xmm0, xmm1
movss [rbp+var_1C8], xmm0
movss xmm1, dword ptr [rbp+var_2C+4]
movss xmm0, [rbp+var_1E8]
movss xmm2, [rbp+var_1EC]
mulss xmm0, xmm2
addss xmm0, xmm1
movss [rbp+var_1C4], xmm0
loc_DE064:
movss xmm1, dword ptr [rbp+var_34]
movss xmm0, [rbp+var_1E4]
movss xmm2, [rbp+var_1EC]
movd eax, xmm0
xor eax, 80000000h
movd xmm0, eax
mulss xmm0, xmm2
addss xmm0, xmm1
mov eax, [rbp+var_1D4]
shl eax, 1
add eax, 1
cdqe
movss [rbp+rax*8+var_1D0], xmm0
movss xmm1, dword ptr [rbp+var_34+4]
movss xmm0, [rbp+var_1E8]
movss xmm2, [rbp+var_1EC]
mulss xmm0, xmm2
addss xmm0, xmm1
mov eax, [rbp+var_1D4]
shl eax, 1
add eax, 1
cdqe
movss [rbp+rax*8+var_1CC], xmm0
movss xmm1, dword ptr [rbp+var_34]
movss xmm0, [rbp+var_1E4]
movss xmm2, [rbp+var_1EC]
mulss xmm0, xmm2
addss xmm0, xmm1
mov eax, [rbp+var_1D4]
shl eax, 1
cdqe
movss [rbp+rax*8+var_1D0], xmm0
movss xmm1, dword ptr [rbp+var_34+4]
movss xmm0, [rbp+var_1E8]
movss xmm2, [rbp+var_1EC]
movd eax, xmm0
xor eax, 80000000h
movd xmm0, eax
mulss xmm0, xmm2
addss xmm0, xmm1
mov eax, [rbp+var_1D4]
shl eax, 1
cdqe
movss [rbp+rax*8+var_1CC], xmm0
mov rax, [rbp+var_34]
mov [rbp+var_2C], rax
mov eax, [rbp+var_1D4]
add eax, 1
mov [rbp+var_1D4], eax
jmp loc_DDE2C
loc_DE160:
lea rdi, [rbp+var_1D0]
mov edx, [rbp+var_1C]
mov esi, 32h ; '2'
call DrawTriangleStrip
add rsp, 1F0h
pop rbp
retn
| long long DrawSplineSegmentBezierQuadratic(int a1, double a2, double a3, double a4, float a5)
{
double v5; // xmm0_8
double v6; // xmm0_8
double v7; // xmm0_8
float v9; // [rsp+0h] [rbp-1F0h]
float v10; // [rsp+4h] [rbp-1ECh]
float v11; // [rsp+8h] [rbp-1E8h]
float v12; // [rsp+Ch] [rbp-1E4h]
float v13; // [rsp+14h] [rbp-1DCh]
float v14; // [rsp+18h] [rbp-1D8h]
int i; // [rsp+1Ch] [rbp-1D4h]
float v16; // [rsp+20h] [rbp-1D0h] BYREF
float v17[101]; // [rsp+24h] [rbp-1CCh]
float v18; // [rsp+1B8h] [rbp-38h]
double v19; // [rsp+1BCh] [rbp-34h] BYREF
double v20; // [rsp+1C4h] [rbp-2Ch]
int v21; // [rsp+1CCh] [rbp-24h]
float v22; // [rsp+1D0h] [rbp-20h]
int v23; // [rsp+1D4h] [rbp-1Ch]
double v24; // [rsp+1D8h] [rbp-18h]
double v25; // [rsp+1E0h] [rbp-10h]
double v26; // [rsp+1E8h] [rbp-8h]
v26 = a2;
v25 = a3;
v24 = a4;
v23 = a1;
v22 = a5;
v21 = 1026206379;
v20 = a2;
memset(&v19, 0LL, sizeof(v19));
v18 = 0.0;
memset(&v16, 0LL, 400LL);
for ( i = 1; i <= 24; ++i )
{
v18 = 0.041666668 * (float)i;
v5 = powf(1.0 - v18, 2.0);
v14 = *(float *)&v5;
v13 = (float)(2.0 * (float)(1.0 - v18)) * v18;
v6 = powf(v18, 2.0);
*((float *)&v19 + 1) = (float)(*(float *)&v6 * *((float *)&v24 + 1))
+ (float)((float)(v14 * *((float *)&v26 + 1)) + (float)(v13 * *((float *)&v25 + 1)));
*(float *)&v19 = (float)(*(float *)&v6 * *(float *)&v24)
+ (float)((float)(v14 * *(float *)&v26) + (float)(v13 * *(float *)&v25));
v12 = *((float *)&v19 + 1) - *((float *)&v20 + 1);
v11 = *(float *)&v19 - *(float *)&v20;
v9 = 0.5 * v22;
v7 = sqrtf((float)(v11 * v11) + (float)(v12 * v12));
v10 = v9 / *(float *)&v7;
if ( i == 1 )
{
v16 = (float)(v12 * v10) + *(float *)&v20;
v17[0] = (float)(COERCE_FLOAT(_mm_cvtsi128_si32((__m128i)LODWORD(v11)) ^ 0x80000000) * v10) + *((float *)&v20 + 1);
v17[1] = (float)(COERCE_FLOAT(_mm_cvtsi128_si32((__m128i)LODWORD(v12)) ^ 0x80000000) * v10) + *(float *)&v20;
v17[2] = (float)(v11 * v10) + *((float *)&v20 + 1);
}
v17[4 * i + 1] = (float)(COERCE_FLOAT(_mm_cvtsi128_si32((__m128i)LODWORD(v12)) ^ 0x80000000) * v10) + *(float *)&v19;
v17[4 * i + 2] = (float)(v11 * v10) + *((float *)&v19 + 1);
v17[4 * i - 1] = (float)(v12 * v10) + *(float *)&v19;
v17[4 * i] = (float)(COERCE_FLOAT(_mm_cvtsi128_si32((__m128i)LODWORD(v11)) ^ 0x80000000) * v10)
+ *((float *)&v19 + 1);
v20 = v19;
}
return DrawTriangleStrip((long long)&v16, 50, v23);
}
| DrawSplineSegmentBezierQuadratic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1f0
MOVLPD qword ptr [RBP + -0x8],XMM0
MOVLPD qword ptr [RBP + -0x10],XMM1
MOVLPD qword ptr [RBP + -0x18],XMM2
MOV dword ptr [RBP + -0x1c],EDI
MOVSS dword ptr [RBP + -0x20],XMM3
MOVSS XMM0,dword ptr [0x002bcbb4]
MOVSS dword ptr [RBP + -0x24],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x2c],RAX
LEA RDI,[RBP + -0x34]
XOR ESI,ESI
MOV EDX,0x8
CALL 0x0010a2d0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x38],XMM0
LEA RDI,[RBP + -0x1d0]
XOR ESI,ESI
MOV EDX,0x190
CALL 0x0010a2d0
MOV dword ptr [RBP + -0x1d4],0x1
LAB_001dde2c:
CMP dword ptr [RBP + -0x1d4],0x18
JG 0x001de160
CVTSI2SS XMM1,dword ptr [RBP + -0x1d4]
MOVSS XMM0,dword ptr [0x002bcbb4]
MULSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x38],XMM0
MOVSS XMM0,dword ptr [0x002a40f4]
SUBSS XMM0,dword ptr [RBP + -0x38]
MOVSS XMM1,dword ptr [0x002a801c]
CALL 0x0010a8a0
MOVSS dword ptr [RBP + -0x1d8],XMM0
MOVSS XMM1,dword ptr [0x002a40f4]
SUBSS XMM1,dword ptr [RBP + -0x38]
MOVSS XMM0,dword ptr [0x002a801c]
MULSS XMM0,XMM1
MULSS XMM0,dword ptr [RBP + -0x38]
MOVSS dword ptr [RBP + -0x1dc],XMM0
MOVSS XMM0,dword ptr [RBP + -0x38]
MOVSS XMM1,dword ptr [0x002a801c]
CALL 0x0010a8a0
MOVSS dword ptr [RBP + -0x1e0],XMM0
MOVSS XMM1,dword ptr [RBP + -0x1d8]
MOVSS XMM2,dword ptr [RBP + -0x4]
MOVSS XMM0,dword ptr [RBP + -0x1dc]
MULSS XMM0,dword ptr [RBP + -0xc]
MULSS XMM1,XMM2
ADDSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x1e0]
MOVSS XMM2,dword ptr [RBP + -0x14]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x30],XMM0
MOVSS XMM1,dword ptr [RBP + -0x1d8]
MOVSS XMM2,dword ptr [RBP + -0x8]
MOVSS XMM0,dword ptr [RBP + -0x1dc]
MULSS XMM0,dword ptr [RBP + -0x10]
MULSS XMM1,XMM2
ADDSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x1e0]
MOVSS XMM2,dword ptr [RBP + -0x18]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x34],XMM0
MOVSS XMM0,dword ptr [RBP + -0x30]
SUBSS XMM0,dword ptr [RBP + -0x28]
MOVSS dword ptr [RBP + -0x1e4],XMM0
MOVSS XMM0,dword ptr [RBP + -0x34]
SUBSS XMM0,dword ptr [RBP + -0x2c]
MOVSS dword ptr [RBP + -0x1e8],XMM0
MOVSS XMM0,dword ptr [0x002a40f0]
MULSS XMM0,dword ptr [RBP + -0x20]
MOVSS dword ptr [RBP + -0x1f0],XMM0
MOVSS XMM0,dword ptr [RBP + -0x1e8]
MOVSS XMM2,dword ptr [RBP + -0x1e8]
MOVSS XMM1,dword ptr [RBP + -0x1e4]
MULSS XMM1,dword ptr [RBP + -0x1e4]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
CALL 0x0010aa30
MOVAPS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x1f0]
DIVSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x1ec],XMM0
CMP dword ptr [RBP + -0x1d4],0x1
JNZ 0x001de064
MOVSS XMM1,dword ptr [RBP + -0x2c]
MOVSS XMM0,dword ptr [RBP + -0x1e4]
MOVSS XMM2,dword ptr [RBP + -0x1ec]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x1d0],XMM0
MOVSS XMM1,dword ptr [RBP + -0x28]
MOVSS XMM0,dword ptr [RBP + -0x1e8]
MOVSS XMM2,dword ptr [RBP + -0x1ec]
MOVD EAX,XMM0
XOR EAX,0x80000000
MOVD XMM0,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x1cc],XMM0
MOVSS XMM1,dword ptr [RBP + -0x2c]
MOVSS XMM0,dword ptr [RBP + -0x1e4]
MOVSS XMM2,dword ptr [RBP + -0x1ec]
MOVD EAX,XMM0
XOR EAX,0x80000000
MOVD XMM0,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x1c8],XMM0
MOVSS XMM1,dword ptr [RBP + -0x28]
MOVSS XMM0,dword ptr [RBP + -0x1e8]
MOVSS XMM2,dword ptr [RBP + -0x1ec]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x1c4],XMM0
LAB_001de064:
MOVSS XMM1,dword ptr [RBP + -0x34]
MOVSS XMM0,dword ptr [RBP + -0x1e4]
MOVSS XMM2,dword ptr [RBP + -0x1ec]
MOVD EAX,XMM0
XOR EAX,0x80000000
MOVD XMM0,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOV EAX,dword ptr [RBP + -0x1d4]
SHL EAX,0x1
ADD EAX,0x1
CDQE
MOVSS dword ptr [RBP + RAX*0x8 + -0x1d0],XMM0
MOVSS XMM1,dword ptr [RBP + -0x30]
MOVSS XMM0,dword ptr [RBP + -0x1e8]
MOVSS XMM2,dword ptr [RBP + -0x1ec]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOV EAX,dword ptr [RBP + -0x1d4]
SHL EAX,0x1
ADD EAX,0x1
CDQE
MOVSS dword ptr [RBP + RAX*0x8 + -0x1cc],XMM0
MOVSS XMM1,dword ptr [RBP + -0x34]
MOVSS XMM0,dword ptr [RBP + -0x1e4]
MOVSS XMM2,dword ptr [RBP + -0x1ec]
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOV EAX,dword ptr [RBP + -0x1d4]
SHL EAX,0x1
CDQE
MOVSS dword ptr [RBP + RAX*0x8 + -0x1d0],XMM0
MOVSS XMM1,dword ptr [RBP + -0x30]
MOVSS XMM0,dword ptr [RBP + -0x1e8]
MOVSS XMM2,dword ptr [RBP + -0x1ec]
MOVD EAX,XMM0
XOR EAX,0x80000000
MOVD XMM0,EAX
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
MOV EAX,dword ptr [RBP + -0x1d4]
SHL EAX,0x1
CDQE
MOVSS dword ptr [RBP + RAX*0x8 + -0x1cc],XMM0
MOV RAX,qword ptr [RBP + -0x34]
MOV qword ptr [RBP + -0x2c],RAX
MOV EAX,dword ptr [RBP + -0x1d4]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1d4],EAX
JMP 0x001dde2c
LAB_001de160:
LEA RDI,[RBP + -0x1d0]
MOV EDX,dword ptr [RBP + -0x1c]
MOV ESI,0x32
CALL 0x001d7610
ADD RSP,0x1f0
POP RBP
RET
|
void DrawSplineSegmentBezierQuadratic
(int8 param_1,int8 param_2,int8 param_3,float param_4,
int4 param_5)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
int local_1dc;
float local_1d8 [102];
float local_40;
float local_3c;
float fStack_38;
int8 local_34;
float local_2c;
float local_28;
int4 local_24;
int8 local_20;
int8 local_18;
int8 local_10;
local_2c = DAT_002bcbb4;
local_34 = param_1;
local_28 = param_4;
local_24 = param_5;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
memset(&local_3c,0,8);
local_40 = 0.0;
memset(local_1d8,0,400);
for (local_1dc = 1; local_1dc < 0x19; local_1dc = local_1dc + 1) {
local_40 = DAT_002bcbb4 * (float)local_1dc;
fVar1 = powf(DAT_002a40f4 - local_40,DAT_002a801c);
fVar2 = DAT_002a801c * (DAT_002a40f4 - local_40) * local_40;
fVar3 = powf(local_40,DAT_002a801c);
fStack_38 = fVar3 * local_20._4_4_ + fVar1 * local_10._4_4_ + fVar2 * local_18._4_4_;
local_3c = fVar3 * (float)local_20 + fVar1 * (float)local_10 + fVar2 * (float)local_18;
fVar1 = fStack_38 - local_34._4_4_;
fVar2 = local_3c - (float)local_34;
fVar4 = DAT_002a40f0 * local_28;
fVar3 = sqrtf(fVar2 * fVar2 + fVar1 * fVar1);
fVar4 = fVar4 / fVar3;
if (local_1dc == 1) {
local_1d8[0] = fVar1 * fVar4 + (float)local_34;
local_1d8[1] = -fVar2 * fVar4 + local_34._4_4_;
local_1d8[2] = -fVar1 * fVar4 + (float)local_34;
local_1d8[3] = fVar2 * fVar4 + local_34._4_4_;
}
local_1d8[(long)(local_1dc * 2 + 1) * 2] = -fVar1 * fVar4 + local_3c;
local_1d8[(long)(local_1dc * 2 + 1) * 2 + 1] = fVar2 * fVar4 + fStack_38;
local_1d8[(long)(local_1dc << 1) * 2] = fVar1 * fVar4 + local_3c;
local_1d8[(long)(local_1dc << 1) * 2 + 1] = -fVar2 * fVar4 + fStack_38;
local_34 = CONCAT44(fStack_38,local_3c);
}
DrawTriangleStrip(local_1d8,0x32,local_24);
return;
}
| |
38,176 | DrawSplineSegmentBezierQuadratic | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rshapes.c | void DrawSplineSegmentBezierQuadratic(Vector2 p1, Vector2 c2, Vector2 p3, float thick, Color color)
{
const float step = 1.0f/SPLINE_SEGMENT_DIVISIONS;
Vector2 previous = p1;
Vector2 current = { 0 };
float t = 0.0f;
Vector2 points[2*SPLINE_SEGMENT_DIVISIONS + 2] = { 0 };
for (int i = 1; i <= SPLINE_SEGMENT_DIVISIONS; i++)
{
t = step*(float)i;
float a = powf(1.0f - t, 2);
float b = 2.0f*(1.0f - t)*t;
float c = powf(t, 2);
// NOTE: The easing functions aren't suitable here because they don't take a control point
current.y = a*p1.y + b*c2.y + c*p3.y;
current.x = a*p1.x + b*c2.x + c*p3.x;
float dy = current.y - previous.y;
float dx = current.x - previous.x;
float size = 0.5f*thick/sqrtf(dx*dx+dy*dy);
if (i == 1)
{
points[0].x = previous.x + dy*size;
points[0].y = previous.y - dx*size;
points[1].x = previous.x - dy*size;
points[1].y = previous.y + dx*size;
}
points[2*i + 1].x = current.x - dy*size;
points[2*i + 1].y = current.y + dx*size;
points[2*i].x = current.x + dy*size;
points[2*i].y = current.y - dx*size;
previous = current;
}
DrawTriangleStrip(points, 2*SPLINE_SEGMENT_DIVISIONS + 2, color);
} | O2 | c | DrawSplineSegmentBezierQuadratic:
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movl %edi, %ebx
movss %xmm3, 0xc(%rsp)
movaps %xmm2, 0x30(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0x50(%rsp), %rdi
movl $0x180, %edx # imm = 0x180
xorl %esi, %esi
callq 0x92c0
movaps 0x10(%rsp), %xmm14
movss 0xc(%rsp), %xmm13
mulss 0x4e9bd(%rip), %xmm13 # 0xb96d8
xorps %xmm3, %xmm3
pushq $0x10
popq %rax
pushq $0x1
popq %rcx
movss 0x625e4(%rip), %xmm0 # 0xcd310
movss 0x4e968(%rip), %xmm1 # 0xb969c
movaps 0x4a405(%rip), %xmm2 # 0xb5140
movaps %xmm14, %xmm5
cmpq $0x190, %rax # imm = 0x190
je 0x6ae44
cvtsi2ss %ecx, %xmm4
mulss %xmm0, %xmm4
movaps %xmm1, %xmm6
subss %xmm4, %xmm6
movaps %xmm6, %xmm7
mulss %xmm6, %xmm7
addss %xmm6, %xmm6
mulss %xmm4, %xmm6
mulss %xmm4, %xmm4
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
mulps 0x20(%rsp), %xmm6
shufps $0x0, %xmm7, %xmm7 # xmm7 = xmm7[0,0,0,0]
mulps %xmm14, %xmm7
addps %xmm6, %xmm7
shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
mulps 0x30(%rsp), %xmm4
addps %xmm7, %xmm4
movaps %xmm4, %xmm6
shufps $0x55, %xmm4, %xmm6 # xmm6 = xmm6[1,1],xmm4[1,1]
movaps %xmm5, %xmm7
shufps $0x55, %xmm5, %xmm7 # xmm7 = xmm7[1,1],xmm5[1,1]
subss %xmm7, %xmm6
movaps %xmm4, %xmm8
subss %xmm5, %xmm8
movaps %xmm6, %xmm7
mulss %xmm6, %xmm7
movaps %xmm8, %xmm9
mulss %xmm8, %xmm9
addss %xmm7, %xmm9
sqrtss %xmm9, %xmm9
movaps %xmm13, %xmm7
divss %xmm9, %xmm7
movaps %xmm8, %xmm9
xorps %xmm2, %xmm9
cmpq $0x10, %rax
jne 0x6ae0d
movlhps %xmm5, %xmm5 # xmm5 = xmm5[0,0]
movaps %xmm6, %xmm10
xorps %xmm2, %xmm10
movaps %xmm7, %xmm11
unpcklps %xmm8, %xmm11 # xmm11 = xmm11[0],xmm8[0],xmm11[1],xmm8[1]
shufps $0x40, %xmm11, %xmm11 # xmm11 = xmm11[0,0,0,1]
movaps %xmm6, %xmm3
unpcklps %xmm9, %xmm3 # xmm3 = xmm3[0],xmm9[0],xmm3[1],xmm9[1]
movaps %xmm10, %xmm12
unpcklps %xmm7, %xmm12 # xmm12 = xmm12[0],xmm7[0],xmm12[1],xmm7[1]
movlhps %xmm12, %xmm3 # xmm3 = xmm3[0],xmm12[0]
mulps %xmm11, %xmm3
addps %xmm5, %xmm3
jmp 0x6ae15
movaps %xmm6, %xmm10
xorps %xmm2, %xmm10
movaps %xmm4, %xmm5
movlhps %xmm4, %xmm5 # xmm5 = xmm5[0],xmm4[0]
unpcklps %xmm8, %xmm10 # xmm10 = xmm10[0],xmm8[0],xmm10[1],xmm8[1]
unpcklps %xmm9, %xmm6 # xmm6 = xmm6[0],xmm9[0],xmm6[1],xmm9[1]
movlhps %xmm10, %xmm6 # xmm6 = xmm6[0],xmm10[0]
shufps $0x0, %xmm7, %xmm7 # xmm7 = xmm7[0,0,0,0]
mulps %xmm6, %xmm7
addps %xmm5, %xmm7
movaps %xmm7, 0x40(%rsp,%rax)
addq $0x10, %rax
incl %ecx
movaps %xmm4, %xmm5
jmp 0x6ad3f
leaq 0x40(%rsp), %rdi
movaps %xmm3, (%rdi)
pushq $0x32
popq %rsi
movl %ebx, %edx
callq 0x66453
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbx
retq
| DrawSplineSegmentBezierQuadratic:
push rbx
sub rsp, 1D0h
mov ebx, edi
movss [rsp+1D8h+var_1CC], xmm3
movaps [rsp+1D8h+var_1A8], xmm2
movaps [rsp+1D8h+var_1B8], xmm1
movaps [rsp+1D8h+var_1C8], xmm0
lea rdi, [rsp+1D8h+var_188]
mov edx, 180h
xor esi, esi
call _memset
movaps xmm14, [rsp+1D8h+var_1C8]
movss xmm13, [rsp+1D8h+var_1CC]
mulss xmm13, cs:dword_B96D8
xorps xmm3, xmm3
push 10h
pop rax
push 1
pop rcx
movss xmm0, cs:dword_CD310
movss xmm1, cs:dword_B969C
movaps xmm2, cs:xmmword_B5140
movaps xmm5, xmm14
loc_6AD3F:
cmp rax, 190h
jz loc_6AE44
cvtsi2ss xmm4, ecx
mulss xmm4, xmm0
movaps xmm6, xmm1
subss xmm6, xmm4
movaps xmm7, xmm6
mulss xmm7, xmm6
addss xmm6, xmm6
mulss xmm6, xmm4
mulss xmm4, xmm4
shufps xmm6, xmm6, 0
mulps xmm6, [rsp+1D8h+var_1B8]
shufps xmm7, xmm7, 0
mulps xmm7, xmm14
addps xmm7, xmm6
shufps xmm4, xmm4, 0
mulps xmm4, [rsp+1D8h+var_1A8]
addps xmm4, xmm7
movaps xmm6, xmm4
shufps xmm6, xmm4, 55h ; 'U'
movaps xmm7, xmm5
shufps xmm7, xmm5, 55h ; 'U'
subss xmm6, xmm7
movaps xmm8, xmm4
subss xmm8, xmm5
movaps xmm7, xmm6
mulss xmm7, xmm6
movaps xmm9, xmm8
mulss xmm9, xmm8
addss xmm9, xmm7
sqrtss xmm9, xmm9
movaps xmm7, xmm13
divss xmm7, xmm9
movaps xmm9, xmm8
xorps xmm9, xmm2
cmp rax, 10h
jnz short loc_6AE0D
movlhps xmm5, xmm5
movaps xmm10, xmm6
xorps xmm10, xmm2
movaps xmm11, xmm7
unpcklps xmm11, xmm8
shufps xmm11, xmm11, 40h ; '@'
movaps xmm3, xmm6
unpcklps xmm3, xmm9
movaps xmm12, xmm10
unpcklps xmm12, xmm7
movlhps xmm3, xmm12
mulps xmm3, xmm11
addps xmm3, xmm5
jmp short loc_6AE15
loc_6AE0D:
movaps xmm10, xmm6
xorps xmm10, xmm2
loc_6AE15:
movaps xmm5, xmm4
movlhps xmm5, xmm4
unpcklps xmm10, xmm8
unpcklps xmm6, xmm9
movlhps xmm6, xmm10
shufps xmm7, xmm7, 0
mulps xmm7, xmm6
addps xmm7, xmm5
movaps [rsp+rax+1D8h+var_198], xmm7
add rax, 10h
inc ecx
movaps xmm5, xmm4
jmp loc_6AD3F
loc_6AE44:
lea rdi, [rsp+1D8h+var_198]
movaps xmmword ptr [rdi], xmm3
push 32h ; '2'
pop rsi
mov edx, ebx
call DrawTriangleStrip
add rsp, 1D0h
pop rbx
retn
| long long DrawSplineSegmentBezierQuadratic(unsigned int a1, __m128 a2, __m128 a3, __m128 a4, float a5)
{
__m128 v5; // xmm4
__m128 v6; // xmm13
__m128 v7; // xmm3
long long v8; // rax
int v9; // ecx
__m128 v10; // xmm5
__m128 v11; // xmm6
__m128 v12; // xmm7
__m128 v13; // xmm6
__m128 v14; // xmm8
__m128 v15; // xmm7
__m128 v16; // xmm9
__m128 v17; // xmm10
__m128 v18; // xmm11
__m128 v20; // [rsp+40h] [rbp-198h] BYREF
_BYTE v21[392]; // [rsp+50h] [rbp-188h] BYREF
memset(v21, 0LL, 384LL);
v6 = (__m128)LODWORD(a5);
v6.m128_f32[0] = a5 * 0.5;
v7 = 0LL;
v8 = 16LL;
v9 = 1;
v10 = a2;
while ( v8 != 400 )
{
v5.m128_f32[0] = (float)v9 * 0.041666668;
v11 = (__m128)0x3F800000u;
v11.m128_f32[0] = 1.0 - v5.m128_f32[0];
v12 = v11;
v12.m128_f32[0] = v11.m128_f32[0] * v11.m128_f32[0];
v11.m128_f32[0] = (float)(v11.m128_f32[0] + v11.m128_f32[0]) * v5.m128_f32[0];
v5.m128_f32[0] = v5.m128_f32[0] * v5.m128_f32[0];
v5 = _mm_add_ps(
_mm_mul_ps(_mm_shuffle_ps(v5, v5, 0), a4),
_mm_add_ps(_mm_mul_ps(_mm_shuffle_ps(v12, v12, 0), a2), _mm_mul_ps(_mm_shuffle_ps(v11, v11, 0), a3)));
v13 = _mm_shuffle_ps(v5, v5, 85);
v13.m128_f32[0] = v13.m128_f32[0] - _mm_shuffle_ps(v10, v10, 85).m128_f32[0];
v14 = v5;
v14.m128_f32[0] = v5.m128_f32[0] - v10.m128_f32[0];
v15 = v6;
v15.m128_f32[0] = v6.m128_f32[0]
/ fsqrt((float)(v14.m128_f32[0] * v14.m128_f32[0]) + (float)(v13.m128_f32[0] * v13.m128_f32[0]));
v16 = _mm_xor_ps(v14, (__m128)xmmword_B5140);
v17 = _mm_xor_ps(v13, (__m128)xmmword_B5140);
if ( v8 == 16 )
{
v18 = _mm_unpacklo_ps(v15, v14);
v7 = _mm_add_ps(
_mm_mul_ps(
_mm_movelh_ps(_mm_unpacklo_ps(v13, v16), _mm_unpacklo_ps(v17, v15)),
_mm_shuffle_ps(v18, v18, 64)),
_mm_movelh_ps(v10, v10));
}
*(__m128 *)((char *)&v20 + v8) = _mm_add_ps(
_mm_mul_ps(
_mm_shuffle_ps(v15, v15, 0),
_mm_movelh_ps(_mm_unpacklo_ps(v13, v16), _mm_unpacklo_ps(v17, v14))),
_mm_movelh_ps(v5, v5));
v8 += 16LL;
++v9;
v10 = v5;
}
v20 = v7;
return DrawTriangleStrip((long long)&v20, 50, a1);
}
| DrawSplineSegmentBezierQuadratic:
PUSH RBX
SUB RSP,0x1d0
MOV EBX,EDI
MOVSS dword ptr [RSP + 0xc],XMM3
MOVAPS xmmword ptr [RSP + 0x30],XMM2
MOVAPS xmmword ptr [RSP + 0x20],XMM1
MOVAPS xmmword ptr [RSP + 0x10],XMM0
LEA RDI,[RSP + 0x50]
MOV EDX,0x180
XOR ESI,ESI
CALL 0x001092c0
MOVAPS XMM14,xmmword ptr [RSP + 0x10]
MOVSS XMM13,dword ptr [RSP + 0xc]
MULSS XMM13,dword ptr [0x001b96d8]
XORPS XMM3,XMM3
PUSH 0x10
POP RAX
PUSH 0x1
POP RCX
MOVSS XMM0,dword ptr [0x001cd310]
MOVSS XMM1,dword ptr [0x001b969c]
MOVAPS XMM2,xmmword ptr [0x001b5140]
MOVAPS XMM5,XMM14
LAB_0016ad3f:
CMP RAX,0x190
JZ 0x0016ae44
CVTSI2SS XMM4,ECX
MULSS XMM4,XMM0
MOVAPS XMM6,XMM1
SUBSS XMM6,XMM4
MOVAPS XMM7,XMM6
MULSS XMM7,XMM6
ADDSS XMM6,XMM6
MULSS XMM6,XMM4
MULSS XMM4,XMM4
SHUFPS XMM6,XMM6,0x0
MULPS XMM6,xmmword ptr [RSP + 0x20]
SHUFPS XMM7,XMM7,0x0
MULPS XMM7,XMM14
ADDPS XMM7,XMM6
SHUFPS XMM4,XMM4,0x0
MULPS XMM4,xmmword ptr [RSP + 0x30]
ADDPS XMM4,XMM7
MOVAPS XMM6,XMM4
SHUFPS XMM6,XMM4,0x55
MOVAPS XMM7,XMM5
SHUFPS XMM7,XMM5,0x55
SUBSS XMM6,XMM7
MOVAPS XMM8,XMM4
SUBSS XMM8,XMM5
MOVAPS XMM7,XMM6
MULSS XMM7,XMM6
MOVAPS XMM9,XMM8
MULSS XMM9,XMM8
ADDSS XMM9,XMM7
SQRTSS XMM9,XMM9
MOVAPS XMM7,XMM13
DIVSS XMM7,XMM9
MOVAPS XMM9,XMM8
XORPS XMM9,XMM2
CMP RAX,0x10
JNZ 0x0016ae0d
MOVLHPS XMM5,XMM5
MOVAPS XMM10,XMM6
XORPS XMM10,XMM2
MOVAPS XMM11,XMM7
UNPCKLPS XMM11,XMM8
SHUFPS XMM11,XMM11,0x40
MOVAPS XMM3,XMM6
UNPCKLPS XMM3,XMM9
MOVAPS XMM12,XMM10
UNPCKLPS XMM12,XMM7
MOVLHPS XMM3,XMM12
MULPS XMM3,XMM11
ADDPS XMM3,XMM5
JMP 0x0016ae15
LAB_0016ae0d:
MOVAPS XMM10,XMM6
XORPS XMM10,XMM2
LAB_0016ae15:
MOVAPS XMM5,XMM4
MOVLHPS XMM5,XMM4
UNPCKLPS XMM10,XMM8
UNPCKLPS XMM6,XMM9
MOVLHPS XMM6,XMM10
SHUFPS XMM7,XMM7,0x0
MULPS XMM7,XMM6
ADDPS XMM7,XMM5
MOVAPS xmmword ptr [RSP + RAX*0x1 + 0x40],XMM7
ADD RAX,0x10
INC ECX
MOVAPS XMM5,XMM4
JMP 0x0016ad3f
LAB_0016ae44:
LEA RDI,[RSP + 0x40]
MOVAPS xmmword ptr [RDI],XMM3
PUSH 0x32
POP RSI
MOV EDX,EBX
CALL 0x00166453
ADD RSP,0x1d0
POP RBX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void DrawSplineSegmentBezierQuadratic
(int8 param_1,int8 param_2,int8 param_3,float param_4,
int4 param_5)
{
long lVar1;
int iVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
float fVar8;
float fVar9;
float fVar10;
float local_198 [100];
fVar3 = (float)((ulong)param_1 >> 0x20);
memset(local_198 + 4,0,0x180);
local_198[0] = 0.0;
local_198[1] = 0.0;
local_198[2] = 0.0;
local_198[3] = 0.0;
iVar2 = 1;
fVar6 = (float)param_1;
fVar7 = fVar3;
for (lVar1 = 0x10; lVar1 != 400; lVar1 = lVar1 + 0x10) {
fVar4 = (float)iVar2 * DAT_001cd310;
fVar8 = DAT_001b969c - fVar4;
fVar9 = (fVar8 + fVar8) * fVar4;
fVar5 = fVar4 * fVar4 * (float)param_3 + fVar8 * fVar8 * (float)param_1 + fVar9 * (float)param_2
;
fVar4 = fVar4 * fVar4 * (float)((ulong)param_3 >> 0x20) +
fVar8 * fVar8 * fVar3 + fVar9 * (float)((ulong)param_2 >> 0x20);
fVar8 = fVar4 - fVar7;
fVar10 = fVar5 - fVar6;
fVar9 = (param_4 * DAT_001b96d8) / SQRT(fVar10 * fVar10 + fVar8 * fVar8);
if (lVar1 == 0x10) {
local_198[0] = fVar8 * fVar9 + fVar6;
local_198[1] = (float)((uint)fVar10 ^ _DAT_001b5140) * fVar9 + fVar7;
local_198[2] = (float)((uint)fVar8 ^ _DAT_001b5140) * fVar9 + fVar6;
local_198[3] = fVar9 * fVar10 + fVar7;
}
*(float *)((long)local_198 + lVar1) = fVar9 * fVar8 + fVar5;
*(float *)((long)local_198 + lVar1 + 4) = fVar9 * (float)((uint)fVar10 ^ _DAT_001b5140) + fVar4;
*(float *)((long)local_198 + lVar1 + 8) = fVar9 * (float)((uint)fVar8 ^ _DAT_001b5140) + fVar5;
*(float *)((long)local_198 + lVar1 + 0xc) = fVar9 * fVar10 + fVar4;
iVar2 = iVar2 + 1;
fVar6 = fVar5;
fVar7 = fVar4;
}
DrawTriangleStrip(local_198,0x32,param_5);
return;
}
| |
38,177 | my_strnxfrm_tis620_nopad | eloqsql/strings/ctype-tis620.c | static size_t
my_strnxfrm_tis620_nopad(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
size_t len, dstlen0= dstlen;
len= MY_MIN(dstlen, srclen);
memcpy(dst, src, len);
len= thai2sortable(dst, len);
set_if_smaller(dstlen, nweights);
set_if_smaller(len, dstlen);
len= my_strxfrm_pad_desc_and_reverse_nopad(cs, dst, dst + len, dst + dstlen,
(uint)(dstlen - len), flags, 0);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len < dstlen0)
{
size_t fill_length= dstlen0 - len;
memset(dst + len, 0x00, fill_length);
len= dstlen0;
}
return len;
} | O3 | c | my_strnxfrm_tis620_nopad:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
cmpq %r9, %rdx
cmovbq %rdx, %r12
movq %rsi, %rdi
movq %r8, %rsi
movq %r12, %rdx
callq 0x24240
movq %r14, %rdi
movq %r12, %rsi
callq 0x58bfb
movl %r15d, %r8d
cmpq %rbx, %r8
cmovaeq %rbx, %r8
cmpq %r8, %r12
cmovaeq %r8, %r12
leaq (%r14,%r12), %rdx
leaq (%r14,%r8), %rcx
subl %r12d, %r8d
movl $0x0, (%rsp)
movq %r13, %rdi
movq %r14, %rsi
movl 0x10(%rbp), %r15d
movl %r15d, %r9d
callq 0x2792e
testb %r15b, %r15b
jns 0x58d93
movq %rbx, %rdx
subq %rax, %rdx
jbe 0x58d93
addq %rax, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x24180
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| my_strnxfrm_tis620_nopad:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, r9
mov r15d, ecx
mov rbx, rdx
mov r14, rsi
mov r13, rdi
cmp rdx, r9
cmovb r12, rdx
mov rdi, rsi
mov rsi, r8
mov rdx, r12
call _memcpy
mov rdi, r14
mov rsi, r12
call thai2sortable
mov r8d, r15d
cmp r8, rbx
cmovnb r8, rbx
cmp r12, r8
cmovnb r12, r8
lea rdx, [r14+r12]
lea rcx, [r14+r8]
sub r8d, r12d
mov [rsp+30h+var_30], 0
mov rdi, r13
mov rsi, r14
mov r15d, [rbp+arg_0]
mov r9d, r15d
call my_strxfrm_pad_desc_and_reverse_nopad
test r15b, r15b
jns short loc_58D93
mov rdx, rbx
sub rdx, rax
jbe short loc_58D93
add r14, rax
mov rdi, r14
xor esi, esi
call _memset
mov rax, rbx
loc_58D93:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long my_strnxfrm_tis620_nopad(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
unsigned int a7)
{
unsigned long long v7; // r12
unsigned long long v10; // r8
unsigned long long result; // rax
v7 = a6;
if ( a3 < a6 )
v7 = a3;
memcpy(a2, a5, v7);
thai2sortable(a2, v7);
v10 = a4;
if ( a4 >= a3 )
v10 = a3;
if ( v7 >= v10 )
v7 = v10;
result = my_strxfrm_pad_desc_and_reverse_nopad(
a1,
(long long)a2,
(unsigned long long)&a2[v7],
(unsigned long long)&a2[v10],
(int)v10 - (int)v7,
a7,
0);
if ( (a7 & 0x80u) != 0 && a3 > result )
{
memset(&a2[result], 0LL, a3 - result);
return a3;
}
return result;
}
| my_strnxfrm_tis620_nopad:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,R9
MOV R15D,ECX
MOV RBX,RDX
MOV R14,RSI
MOV R13,RDI
CMP RDX,R9
CMOVC R12,RDX
MOV RDI,RSI
MOV RSI,R8
MOV RDX,R12
CALL 0x00124240
MOV RDI,R14
MOV RSI,R12
CALL 0x00158bfb
MOV R8D,R15D
CMP R8,RBX
CMOVNC R8,RBX
CMP R12,R8
CMOVNC R12,R8
LEA RDX,[R14 + R12*0x1]
LEA RCX,[R14 + R8*0x1]
SUB R8D,R12D
MOV dword ptr [RSP],0x0
MOV RDI,R13
MOV RSI,R14
MOV R15D,dword ptr [RBP + 0x10]
MOV R9D,R15D
CALL 0x0012792e
TEST R15B,R15B
JNS 0x00158d93
MOV RDX,RBX
SUB RDX,RAX
JBE 0x00158d93
ADD R14,RAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x00124180
MOV RAX,RBX
LAB_00158d93:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strnxfrm_tis620_nopad
(int8 param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,int4 param_7)
{
int8 in_RAX;
ulong uVar1;
uint uVar2;
uVar2 = (uint)((ulong)in_RAX >> 0x20);
if (param_3 < param_6) {
param_6 = param_3;
}
memcpy(param_2,param_5,param_6);
thai2sortable(param_2,param_6);
uVar1 = (ulong)param_4;
if (param_3 <= param_4) {
uVar1 = param_3;
}
if (uVar1 <= param_6) {
param_6 = uVar1;
}
uVar1 = my_strxfrm_pad_desc_and_reverse_nopad
(param_1,param_2,(long)param_2 + param_6,(long)param_2 + uVar1,
(int)uVar1 - (int)param_6,param_7,(ulong)uVar2 << 0x20);
if (((char)param_7 < '\0') && (uVar1 <= param_3 && param_3 - uVar1 != 0)) {
memset((void *)((long)param_2 + uVar1),0,param_3 - uVar1);
uVar1 = param_3;
}
return uVar1;
}
| |
38,178 | ggml_gallocr_free_node | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c | static void ggml_gallocr_free_node(ggml_gallocr_t galloc, struct ggml_tensor * node) {
// graph outputs are never freed
if (node->flags & GGML_TENSOR_FLAG_OUTPUT) {
AT_PRINTF("not freeing output %s\n", node->name);
return;
}
struct hash_node * hn = ggml_gallocr_hash_get(galloc, node);
size_t offset = hn->offset;
int buffer_id = hn->buffer_id;
struct ggml_dyn_tallocr * alloc = galloc->buf_tallocs[buffer_id];
ggml_backend_buffer_type_t buft = galloc->bufts[buffer_id];
size_t size = ggml_backend_buft_get_alloc_size(buft, node);
ggml_dyn_tallocr_free_tensor(alloc, offset, size, node);
hn->allocated = false;
} | O1 | c | ggml_gallocr_free_node:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testb $0x2, 0x94(%rsi)
jne 0x269b2
movq %rsi, %r14
movq %rdi, %r15
callq 0x25acb
movq %rax, %rbx
movq 0x10(%rax), %r12
movslq 0x8(%rax), %rax
movq (%r15), %rcx
movq 0x10(%r15), %rdx
movq (%rdx,%rax,8), %r15
movq (%rcx,%rax,8), %rdi
movq %r14, %rsi
callq 0x17680
movq %rax, %rcx
movq (%r15), %rsi
leaq -0x1(%rsi), %rax
movq %rsi, %rdx
xorq %rax, %rdx
cmpq %rax, %rdx
jbe 0x269bc
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq %rsi, %rax
subq %rdx, %rax
xorl %edx, %edx
divq %rsi
addq %rcx, %rdx
movslq 0x8(%r15), %rdi
testq %rdi, %rdi
jle 0x2693a
leaq 0x10(%r15), %r9
leaq (%rdx,%r12), %r11
leal -0x1(%rdi), %r8d
leaq 0x20(%r15), %rax
movb $0x1, %cl
xorl %esi, %esi
movq -0x10(%rax), %r14
movq -0x8(%rax), %r10
leaq (%r10,%r14), %r13
cmpq %r12, %r13
je 0x2689e
cmpq %r14, %r11
je 0x268e5
incq %rsi
cmpq %rdi, %rsi
setb %cl
addq $0x10, %rax
cmpq %rsi, %rdi
jne 0x26871
jmp 0x2693a
addq %rdx, %r10
movq %r10, -0x8(%rax)
decl %edi
cmpl %esi, %edi
jle 0x26935
addq %r10, %r14
cmpq (%rax), %r14
jne 0x26935
addq 0x8(%rax), %r10
incq %rsi
movq %r10, -0x8(%rax)
movl %edi, 0x8(%r15)
cmpl %edi, %esi
jge 0x26935
addq $0x10, %rax
movl %edi, %edi
movups (%rax), %xmm0
movups %xmm0, -0x10(%rax)
decq %rdi
addq $0x10, %rax
cmpq %rdi, %rsi
jne 0x268d0
jmp 0x26935
movq %r12, -0x10(%rax)
addq %rdx, %r10
movq %r10, -0x8(%rax)
testq %rsi, %rsi
je 0x26935
leal -0x1(%rsi), %r11d
shlq $0x4, %r11
movq 0x8(%r9,%r11), %r14
movq (%r9,%r11), %r13
addq %r14, %r13
cmpq %r12, %r13
jne 0x26935
addq %r11, %r9
addq %r10, %r14
movq %r14, 0x8(%r9)
decl %edi
movl %edi, 0x8(%r15)
cmpl %esi, %edi
jle 0x26935
subq %rsi, %r8
movups (%rax), %xmm0
movups %xmm0, -0x10(%rax)
addq $0x10, %rax
decq %r8
jne 0x26925
testb $0x1, %cl
jne 0x269ae
movslq 0x8(%r15), %rcx
cmpq $0xff, %rcx
jg 0x269db
leaq 0x10(%r15), %rax
testl %ecx, %ecx
jle 0x2696f
movl %ecx, %edi
xorl %esi, %esi
movq %rax, %r8
cmpq %r12, (%r8)
jae 0x26971
incq %rsi
addq $0x10, %r8
cmpq %rsi, %rdi
jne 0x2695a
movl %edi, %esi
jmp 0x26971
xorl %esi, %esi
cmpl %esi, %ecx
jle 0x2699b
movslq %esi, %rdi
movq %rcx, %r8
shlq $0x4, %r8
addq %r15, %r8
addq $0x10, %r8
decq %rcx
movups -0x10(%r8), %xmm0
movups %xmm0, (%r8)
addq $-0x10, %r8
cmpq %rdi, %rcx
jg 0x26986
movl %esi, %ecx
shlq $0x4, %rcx
movq %r12, (%rax,%rcx)
movq %rdx, 0x8(%rax,%rcx)
incl 0x8(%r15)
movb $0x0, 0x18(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x28a07(%rip), %rdi # 0x4f3ca
leaq 0x2859e(%rip), %rsi # 0x4ef68
leaq 0x28a25(%rip), %rcx # 0x4f3f6
movl $0x41, %edx
callq 0x17b00
leaq 0x28586(%rip), %rdi # 0x4ef68
leaq 0x25bd8(%rip), %rdx # 0x4c5c1
leaq 0x28b2d(%rip), %rcx # 0x4f51d
movl $0x112, %esi # imm = 0x112
xorl %eax, %eax
callq 0x18ce0
| ggml_gallocr_free_node:
push r15
push r14
push r13
push r12
push rbx
test byte ptr [rsi+94h], 2
jnz loc_269B2
mov r14, rsi
mov r15, rdi
call ggml_gallocr_hash_get
mov rbx, rax
mov r12, [rax+10h]
movsxd rax, dword ptr [rax+8]
mov rcx, [r15]
mov rdx, [r15+10h]
mov r15, [rdx+rax*8]
mov rdi, [rcx+rax*8]
mov rsi, r14
call _ggml_backend_buft_get_alloc_size
mov rcx, rax
mov rsi, [r15]
lea rax, [rsi-1]
mov rdx, rsi
xor rdx, rax
cmp rdx, rax
jbe loc_269BC
mov rax, rcx
xor edx, edx
div rsi
mov rax, rsi
sub rax, rdx
xor edx, edx
div rsi
add rdx, rcx
movsxd rdi, dword ptr [r15+8]
test rdi, rdi
jle loc_2693A
lea r9, [r15+10h]
lea r11, [rdx+r12]
lea r8d, [rdi-1]
lea rax, [r15+20h]
mov cl, 1
xor esi, esi
loc_26871:
mov r14, [rax-10h]
mov r10, [rax-8]
lea r13, [r10+r14]
cmp r13, r12
jz short loc_2689E
cmp r11, r14
jz short loc_268E5
inc rsi
cmp rsi, rdi
setb cl
add rax, 10h
cmp rdi, rsi
jnz short loc_26871
jmp loc_2693A
loc_2689E:
add r10, rdx
mov [rax-8], r10
dec edi
cmp edi, esi
jle loc_26935
add r14, r10
cmp r14, [rax]
jnz short loc_26935
add r10, [rax+8]
inc rsi
mov [rax-8], r10
mov [r15+8], edi
cmp esi, edi
jge short loc_26935
add rax, 10h
mov edi, edi
loc_268D0:
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [rax-10h], xmm0
dec rdi
add rax, 10h
cmp rsi, rdi
jnz short loc_268D0
jmp short loc_26935
loc_268E5:
mov [rax-10h], r12
add r10, rdx
mov [rax-8], r10
test rsi, rsi
jz short loc_26935
lea r11d, [rsi-1]
shl r11, 4
mov r14, [r9+r11+8]
mov r13, [r9+r11]
add r13, r14
cmp r13, r12
jnz short loc_26935
add r9, r11
add r14, r10
mov [r9+8], r14
dec edi
mov [r15+8], edi
cmp edi, esi
jle short loc_26935
sub r8, rsi
loc_26925:
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [rax-10h], xmm0
add rax, 10h
dec r8
jnz short loc_26925
loc_26935:
test cl, 1
jnz short loc_269AE
loc_2693A:
movsxd rcx, dword ptr [r15+8]
cmp rcx, 0FFh
jg loc_269DB
lea rax, [r15+10h]
test ecx, ecx
jle short loc_2696F
mov edi, ecx
xor esi, esi
mov r8, rax
loc_2695A:
cmp [r8], r12
jnb short loc_26971
inc rsi
add r8, 10h
cmp rdi, rsi
jnz short loc_2695A
mov esi, edi
jmp short loc_26971
loc_2696F:
xor esi, esi
loc_26971:
cmp ecx, esi
jle short loc_2699B
movsxd rdi, esi
mov r8, rcx
shl r8, 4
add r8, r15
add r8, 10h
loc_26986:
dec rcx
movups xmm0, xmmword ptr [r8-10h]
movups xmmword ptr [r8], xmm0
add r8, 0FFFFFFFFFFFFFFF0h
cmp rcx, rdi
jg short loc_26986
loc_2699B:
mov ecx, esi
shl rcx, 4
mov [rax+rcx], r12
mov [rax+rcx+8], rdx
inc dword ptr [r15+8]
loc_269AE:
mov byte ptr [rbx+18h], 0
loc_269B2:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_269BC:
lea rdi, aAlignmentAlign; "alignment && !(alignment & (alignment -"...
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aSizeTAlignedOf; "size_t aligned_offset(const void *, siz"...
mov edx, 41h ; 'A'
call ___assert_fail
loc_269DB:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAllocNFreeBloc; "alloc->n_free_blocks < MAX_FREE_BLOCKS "...
mov esi, 112h
xor eax, eax
call _ggml_abort
| void ggml_gallocr_free_node(_QWORD *a1, unsigned long long a2)
{
long long v2; // rbx
unsigned long long v3; // r12
long long v4; // rax
long long v5; // r15
unsigned long long alloc_size; // rcx
long long v7; // r8
long long v8; // r9
unsigned long long v9; // rdx
long long v10; // rdi
long long v11; // rax
bool v12; // cl
long long v13; // rsi
long long v14; // r14
long long v15; // r10
long long v16; // r10
long long v17; // rsi
_OWORD *v18; // rax
long long v19; // r10
long long v20; // r11
long long v21; // r14
int v22; // edi
long long v23; // rcx
long long v24; // rax
long long v25; // rsi
unsigned long long *v26; // r8
_OWORD *v27; // r8
long long v28; // rcx
if ( (*(_BYTE *)(a2 + 148) & 2) == 0 )
{
v2 = ggml_gallocr_hash_get(a1, a2);
v3 = *(_QWORD *)(v2 + 16);
v4 = *(int *)(v2 + 8);
v5 = *(_QWORD *)(a1[2] + 8 * v4);
alloc_size = ggml_backend_buft_get_alloc_size(*(_QWORD *)(*a1 + 8 * v4), a2);
if ( ((unsigned long long)(*(_QWORD *)v5 - 1LL) ^ *(_QWORD *)v5) <= *(_QWORD *)v5 - 1LL )
__assert_fail(
"alignment && !(alignment & (alignment - 1))",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c",
65LL,
"size_t aligned_offset(const void *, size_t, size_t)");
v9 = alloc_size + (*(_QWORD *)v5 - alloc_size % *(_QWORD *)v5) % *(_QWORD *)v5;
v10 = *(int *)(v5 + 8);
if ( v10 <= 0 )
goto LABEL_21;
v8 = v5 + 16;
v7 = (unsigned int)(v10 - 1);
v11 = v5 + 32;
v12 = 1;
v13 = 0LL;
while ( 1 )
{
v14 = *(_QWORD *)(v11 - 16);
v15 = *(_QWORD *)(v11 - 8);
if ( v15 + v14 == v3 )
break;
if ( v9 + v3 == v14 )
{
*(_QWORD *)(v11 - 16) = v3;
v19 = v9 + v15;
*(_QWORD *)(v11 - 8) = v19;
if ( v13 )
{
v20 = 16LL * (unsigned int)(v13 - 1);
v21 = *(_QWORD *)(v8 + v20 + 8);
if ( v21 + *(_QWORD *)(v8 + v20) == v3 )
{
v8 += v20;
*(_QWORD *)(v8 + 8) = v19 + v21;
v22 = v10 - 1;
*(_DWORD *)(v5 + 8) = v22;
if ( v22 > (int)v13 )
{
v7 -= v13;
do
{
*(_OWORD *)(v11 - 16) = *(_OWORD *)v11;
v11 += 16LL;
--v7;
}
while ( v7 );
}
}
}
goto LABEL_20;
}
v12 = ++v13 < (unsigned long long)v10;
v11 += 16LL;
if ( v10 == v13 )
goto LABEL_21;
}
v16 = v9 + v15;
*(_QWORD *)(v11 - 8) = v16;
LODWORD(v10) = v10 - 1;
if ( (int)v10 > (int)v13 && v16 + v14 == *(_QWORD *)v11 )
{
v17 = v13 + 1;
*(_QWORD *)(v11 - 8) = *(_QWORD *)(v11 + 8) + v16;
*(_DWORD *)(v5 + 8) = v10;
if ( (int)v17 < (int)v10 )
{
v18 = (_OWORD *)(v11 + 16);
v10 = (unsigned int)v10;
do
{
*(v18 - 1) = *v18;
--v10;
++v18;
}
while ( v17 != v10 );
}
}
LABEL_20:
if ( !v12 )
{
LABEL_21:
v23 = *(int *)(v5 + 8);
if ( v23 > 255 )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c",
274,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"alloc->n_free_blocks < MAX_FREE_BLOCKS && \"out of free blocks\"",
v7,
v8);
v24 = v5 + 16;
if ( (int)v23 <= 0 )
{
LODWORD(v25) = 0;
}
else
{
v25 = 0LL;
v26 = (unsigned long long *)(v5 + 16);
while ( *v26 < v3 )
{
++v25;
v26 += 2;
if ( (unsigned int)v23 == v25 )
{
LODWORD(v25) = *(_DWORD *)(v5 + 8);
break;
}
}
}
if ( (int)v23 > (int)v25 )
{
v27 = (_OWORD *)(v5 + 16 * v23 + 16);
do
{
--v23;
*v27 = *(v27 - 1);
--v27;
}
while ( v23 > (int)v25 );
}
v28 = 16LL * (unsigned int)v25;
*(_QWORD *)(v24 + v28) = v3;
*(_QWORD *)(v24 + v28 + 8) = v9;
++*(_DWORD *)(v5 + 8);
}
*(_BYTE *)(v2 + 24) = 0;
}
}
| ggml_gallocr_free_node:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
TEST byte ptr [RSI + 0x94],0x2
JNZ 0x001269b2
MOV R14,RSI
MOV R15,RDI
CALL 0x00125acb
MOV RBX,RAX
MOV R12,qword ptr [RAX + 0x10]
MOVSXD RAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x10]
MOV R15,qword ptr [RDX + RAX*0x8]
MOV RDI,qword ptr [RCX + RAX*0x8]
MOV RSI,R14
CALL 0x00117680
MOV RCX,RAX
MOV RSI,qword ptr [R15]
LEA RAX,[RSI + -0x1]
MOV RDX,RSI
XOR RDX,RAX
CMP RDX,RAX
JBE 0x001269bc
MOV RAX,RCX
XOR EDX,EDX
DIV RSI
MOV RAX,RSI
SUB RAX,RDX
XOR EDX,EDX
DIV RSI
ADD RDX,RCX
MOVSXD RDI,dword ptr [R15 + 0x8]
TEST RDI,RDI
JLE 0x0012693a
LEA R9,[R15 + 0x10]
LEA R11,[RDX + R12*0x1]
LEA R8D,[RDI + -0x1]
LEA RAX,[R15 + 0x20]
MOV CL,0x1
XOR ESI,ESI
LAB_00126871:
MOV R14,qword ptr [RAX + -0x10]
MOV R10,qword ptr [RAX + -0x8]
LEA R13,[R10 + R14*0x1]
CMP R13,R12
JZ 0x0012689e
CMP R11,R14
JZ 0x001268e5
INC RSI
CMP RSI,RDI
SETC CL
ADD RAX,0x10
CMP RDI,RSI
JNZ 0x00126871
JMP 0x0012693a
LAB_0012689e:
ADD R10,RDX
MOV qword ptr [RAX + -0x8],R10
DEC EDI
CMP EDI,ESI
JLE 0x00126935
ADD R14,R10
CMP R14,qword ptr [RAX]
JNZ 0x00126935
ADD R10,qword ptr [RAX + 0x8]
INC RSI
MOV qword ptr [RAX + -0x8],R10
MOV dword ptr [R15 + 0x8],EDI
CMP ESI,EDI
JGE 0x00126935
ADD RAX,0x10
MOV EDI,EDI
LAB_001268d0:
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RAX + -0x10],XMM0
DEC RDI
ADD RAX,0x10
CMP RSI,RDI
JNZ 0x001268d0
JMP 0x00126935
LAB_001268e5:
MOV qword ptr [RAX + -0x10],R12
ADD R10,RDX
MOV qword ptr [RAX + -0x8],R10
TEST RSI,RSI
JZ 0x00126935
LEA R11D,[RSI + -0x1]
SHL R11,0x4
MOV R14,qword ptr [R9 + R11*0x1 + 0x8]
MOV R13,qword ptr [R9 + R11*0x1]
ADD R13,R14
CMP R13,R12
JNZ 0x00126935
ADD R9,R11
ADD R14,R10
MOV qword ptr [R9 + 0x8],R14
DEC EDI
MOV dword ptr [R15 + 0x8],EDI
CMP EDI,ESI
JLE 0x00126935
SUB R8,RSI
LAB_00126925:
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RAX + -0x10],XMM0
ADD RAX,0x10
DEC R8
JNZ 0x00126925
LAB_00126935:
TEST CL,0x1
JNZ 0x001269ae
LAB_0012693a:
MOVSXD RCX,dword ptr [R15 + 0x8]
CMP RCX,0xff
JG 0x001269db
LEA RAX,[R15 + 0x10]
TEST ECX,ECX
JLE 0x0012696f
MOV EDI,ECX
XOR ESI,ESI
MOV R8,RAX
LAB_0012695a:
CMP qword ptr [R8],R12
JNC 0x00126971
INC RSI
ADD R8,0x10
CMP RDI,RSI
JNZ 0x0012695a
MOV ESI,EDI
JMP 0x00126971
LAB_0012696f:
XOR ESI,ESI
LAB_00126971:
CMP ECX,ESI
JLE 0x0012699b
MOVSXD RDI,ESI
MOV R8,RCX
SHL R8,0x4
ADD R8,R15
ADD R8,0x10
LAB_00126986:
DEC RCX
MOVUPS XMM0,xmmword ptr [R8 + -0x10]
MOVUPS xmmword ptr [R8],XMM0
ADD R8,-0x10
CMP RCX,RDI
JG 0x00126986
LAB_0012699b:
MOV ECX,ESI
SHL RCX,0x4
MOV qword ptr [RAX + RCX*0x1],R12
MOV qword ptr [RAX + RCX*0x1 + 0x8],RDX
INC dword ptr [R15 + 0x8]
LAB_001269ae:
MOV byte ptr [RBX + 0x18],0x0
LAB_001269b2:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_001269bc:
LEA RDI,[0x14f3ca]
LEA RSI,[0x14ef68]
LEA RCX,[0x14f3f6]
MOV EDX,0x41
CALL 0x00117b00
LAB_001269db:
LEA RDI,[0x14ef68]
LEA RDX,[0x14c5c1]
LEA RCX,[0x14f51d]
MOV ESI,0x112
XOR EAX,EAX
CALL 0x00118ce0
|
void ggml_gallocr_free_node(long *param_1,long param_2)
{
int iVar1;
ulong uVar2;
ulong *puVar3;
ulong uVar4;
long lVar5;
ulong uVar6;
ulong *puVar7;
long lVar8;
int iVar9;
ulong uVar10;
uint uVar11;
ulong uVar12;
ulong uVar13;
bool bVar14;
if ((*(byte *)(param_2 + 0x94) & 2) != 0) {
return;
}
lVar5 = ggml_gallocr_hash_get();
uVar2 = *(ulong *)(lVar5 + 0x10);
puVar3 = *(ulong **)(param_1[2] + (long)*(int *)(lVar5 + 8) * 8);
uVar6 = ggml_backend_buft_get_alloc_size
(*(int8 *)(*param_1 + (long)*(int *)(lVar5 + 8) * 8),param_2);
uVar12 = *puVar3;
if ((uVar12 ^ uVar12 - 1) <= uVar12 - 1) {
/* WARNING: Subroutine does not return */
__assert_fail("alignment && !(alignment & (alignment - 1))",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c"
,0x41,"size_t aligned_offset(const void *, size_t, size_t)");
}
uVar6 = (uVar12 - uVar6 % uVar12) % uVar12 + uVar6;
iVar1 = (int)puVar3[1];
uVar12 = (ulong)iVar1;
if (0 < (long)uVar12) {
puVar7 = puVar3 + 4;
bVar14 = true;
uVar10 = 0;
do {
uVar4 = puVar7[-2];
uVar13 = puVar7[-1];
iVar9 = (int)uVar10;
if (uVar13 + uVar4 == uVar2) {
uVar13 = uVar13 + uVar6;
puVar7[-1] = uVar13;
uVar11 = iVar1 - 1;
if ((iVar9 < (int)uVar11) && (uVar4 + uVar13 == *puVar7)) {
puVar7[-1] = uVar13 + puVar7[1];
*(uint *)(puVar3 + 1) = uVar11;
if ((int)(uVar10 + 1) < (int)uVar11) {
uVar12 = (ulong)uVar11;
do {
*(int *)puVar7 = (int)puVar7[2];
*(int4 *)((long)puVar7 + 4) = *(int4 *)((long)puVar7 + 0x14);
*(int *)(puVar7 + 1) = (int)puVar7[3];
*(int4 *)((long)puVar7 + 0xc) = *(int4 *)((long)puVar7 + 0x1c);
uVar12 = uVar12 - 1;
puVar7 = puVar7 + 2;
} while (uVar10 + 1 != uVar12);
}
}
goto LAB_00126935;
}
if (uVar6 + uVar2 == uVar4) goto LAB_001268e5;
uVar10 = uVar10 + 1;
bVar14 = uVar10 < uVar12;
puVar7 = puVar7 + 2;
} while (uVar12 != uVar10);
}
LAB_0012693a:
uVar11 = (uint)puVar3[1];
lVar8 = (long)(int)uVar11;
if (0xff < lVar8) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c"
,0x112,"GGML_ASSERT(%s) failed",
"alloc->n_free_blocks < MAX_FREE_BLOCKS && \"out of free blocks\"");
}
if ((int)uVar11 < 1) {
uVar12 = 0;
}
else {
uVar10 = 0;
puVar7 = puVar3 + 2;
do {
uVar12 = uVar10;
if (uVar2 <= *puVar7) break;
uVar10 = uVar10 + 1;
puVar7 = puVar7 + 2;
uVar12 = (ulong)uVar11;
} while (uVar11 != uVar10);
}
if ((int)uVar12 < (int)uVar11) {
puVar7 = puVar3 + lVar8 * 2 + 2;
do {
lVar8 = lVar8 + -1;
*puVar7 = puVar7[-2];
puVar7[1] = puVar7[-1];
puVar7 = puVar7 + -2;
} while ((int)uVar12 < lVar8);
}
(puVar3 + 2)[(uVar12 & 0xffffffff) * 2] = uVar2;
puVar3[(uVar12 & 0xffffffff) * 2 + 3] = uVar6;
*(int *)(puVar3 + 1) = (int)puVar3[1] + 1;
LAB_001269ae:
*(int1 *)(lVar5 + 0x18) = 0;
return;
LAB_001268e5:
puVar7[-2] = uVar2;
puVar7[-1] = uVar13 + uVar6;
if (uVar10 != 0) {
uVar12 = (ulong)(iVar9 - 1);
if (puVar3[uVar12 * 2 + 2] + puVar3[uVar12 * 2 + 3] == uVar2) {
puVar3[uVar12 * 2 + 3] = puVar3[uVar12 * 2 + 3] + uVar13 + uVar6;
*(int *)(puVar3 + 1) = iVar1 + -1;
if (iVar9 < iVar1 + -1) {
lVar8 = (iVar1 - 1) - uVar10;
do {
*(int *)(puVar7 + -2) = (int)*puVar7;
*(int4 *)((long)puVar7 + -0xc) = *(int4 *)((long)puVar7 + 4);
*(int *)(puVar7 + -1) = (int)puVar7[1];
*(int4 *)((long)puVar7 + -4) = *(int4 *)((long)puVar7 + 0xc);
puVar7 = puVar7 + 2;
lVar8 = lVar8 + -1;
} while (lVar8 != 0);
}
}
}
LAB_00126935:
if (bVar14) goto LAB_001269ae;
goto LAB_0012693a;
}
| |
38,179 | evmone::advanced::(anonymous namespace)::op_sstore(evmone::advanced::Instruction const*, evmone::advanced::AdvancedExecutionState&) | corpus-core[P]colibri-stateless/build_O1/_deps/evmone_external-src/lib/evmone/advanced_instructions.cpp | const Instruction* op_sstore(const Instruction* instr, AdvancedExecutionState& state) noexcept
{
const auto gas_left_correction = state.current_block_cost - instr->arg.number;
state.gas_left += gas_left_correction;
const auto status = instr::impl<OP_SSTORE>(state);
if (status != EVMC_SUCCESS)
return state.exit(status);
if ((state.gas_left -= gas_left_correction) < 0)
return state.exit(EVMC_OUT_OF_GAS);
return ++instr;
} | O1 | cpp | evmone::advanced::(anonymous namespace)::op_sstore(evmone::advanced::Instruction const*, evmone::advanced::AdvancedExecutionState&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x230(%rsi), %r15d
subq 0x8(%rdi), %r15
movq 0x220(%rsi), %rsi
addq %r15, %rsi
movq %rsi, 0x220(%r14)
movq 0x228(%r14), %rdi
movq %r14, %rdx
callq 0x4f450
movq %rdx, 0x220(%r14)
addq $-0x40, 0x228(%r14)
testl %eax, %eax
je 0x5314e
movl %eax, 0x78(%r14)
xorl %ebx, %ebx
jmp 0x5315e
subq %r15, %rdx
movq %rdx, 0x220(%r14)
js 0x53167
addq $0x10, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x3, 0x78(%r14)
jmp 0x5314a
| _ZN6evmone8advanced12_GLOBAL__N_19op_sstoreEPKNS0_11InstructionERNS0_22AdvancedExecutionStateE:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov r15d, [rsi+230h]
sub r15, [rdi+8]
mov rsi, [rsi+220h]
add rsi, r15
mov [r14+220h], rsi
mov rdi, [r14+228h]
mov rdx, r14
call _ZN6evmone5instr4core6sstoreENS_8StackTopElRNS_14ExecutionStateE; evmone::instr::core::sstore(evmone::StackTop,long,evmone::ExecutionState &)
mov [r14+220h], rdx
add qword ptr [r14+228h], 0FFFFFFFFFFFFFFC0h
test eax, eax
jz short loc_5314E
mov [r14+78h], eax
loc_5314A:
xor ebx, ebx
jmp short loc_5315E
loc_5314E:
sub rdx, r15
mov [r14+220h], rdx
js short loc_53167
add rbx, 10h
loc_5315E:
mov rax, rbx
pop rbx
pop r14
pop r15
retn
loc_53167:
mov dword ptr [r14+78h], 3
jmp short loc_5314A
| long long evmone::advanced::`anonymous namespace'::op_sstore(long long a1, long long a2)
{
long long v3; // r15
long long v4; // rsi
int v5; // eax
long long v6; // rdx
long long v8; // rdx
v3 = *(unsigned int *)(a2 + 560) - *(_QWORD *)(a1 + 8);
v4 = v3 + *(_QWORD *)(a2 + 544);
*(_QWORD *)(a2 + 544) = v4;
v5 = evmone::instr::core::sstore(*(unsigned long long **)(a2 + 552), v4, a2);
*(_QWORD *)(a2 + 544) = v6;
*(_QWORD *)(a2 + 552) -= 64LL;
if ( v5 )
{
*(_DWORD *)(a2 + 120) = v5;
}
else
{
v8 = v6 - v3;
*(_QWORD *)(a2 + 544) = v8;
if ( v8 >= 0 )
return a1 + 16;
*(_DWORD *)(a2 + 120) = 3;
}
return 0LL;
}
| op_sstore:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV R15D,dword ptr [RSI + 0x230]
SUB R15,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RSI + 0x220]
ADD RSI,R15
MOV qword ptr [R14 + 0x220],RSI
MOV RDI,qword ptr [R14 + 0x228]
MOV RDX,R14
CALL 0x0014f450
MOV qword ptr [R14 + 0x220],RDX
ADD qword ptr [R14 + 0x228],-0x40
TEST EAX,EAX
JZ 0x0015314e
MOV dword ptr [R14 + 0x78],EAX
LAB_0015314a:
XOR EBX,EBX
JMP 0x0015315e
LAB_0015314e:
SUB RDX,R15
MOV qword ptr [R14 + 0x220],RDX
JS 0x00153167
ADD RBX,0x10
LAB_0015315e:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
LAB_00153167:
MOV dword ptr [R14 + 0x78],0x3
JMP 0x0015314a
|
/* evmone::advanced::(anonymous namespace)::op_sstore(evmone::advanced::Instruction const*,
evmone::advanced::AdvancedExecutionState&) */
Instruction *
evmone::advanced::(anonymous_namespace)::op_sstore
(Instruction *param_1,AdvancedExecutionState *param_2)
{
uint uVar1;
int iVar2;
long extraout_RDX;
long lVar3;
long lVar4;
uVar1 = *(uint *)(param_2 + 0x230);
lVar3 = *(long *)(param_1 + 8);
lVar4 = *(long *)(param_2 + 0x220) + ((ulong)uVar1 - lVar3);
*(long *)(param_2 + 0x220) = lVar4;
iVar2 = instr::core::sstore(*(int8 *)(param_2 + 0x228),lVar4,param_2);
*(long *)(param_2 + 0x220) = extraout_RDX;
*(long *)(param_2 + 0x228) = *(long *)(param_2 + 0x228) + -0x40;
if (iVar2 == 0) {
lVar3 = extraout_RDX - ((ulong)uVar1 - lVar3);
*(long *)(param_2 + 0x220) = lVar3;
if (-1 < lVar3) {
return param_1 + 0x10;
}
*(int4 *)(param_2 + 0x78) = 3;
}
else {
*(int *)(param_2 + 0x78) = iVar2;
}
return (Instruction *)0x0;
}
| |
38,180 | find_type_with_warning | eloqsql/mysys/typelib.c | int find_type_with_warning(const char *x, TYPELIB *typelib, const char *option)
{
int res;
const char **ptr;
if ((res= find_type((char *) x, typelib, FIND_TYPE_BASIC)) <= 0)
{
ptr= typelib->type_names;
if (!*x)
fprintf(stderr, "No option given to %s\n", option);
else
fprintf(stderr, "Unknown option to %s: %s\n", option, x);
fprintf(stderr, "Alternatives are: '%s'", *ptr);
while (*++ptr)
fprintf(stderr, ",'%s'", *ptr);
fprintf(stderr, "\n");
}
return res;
} | O3 | c | find_type_with_warning:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq -0x30(%rbp), %rbx
movq %rdi, (%rbx)
callq 0x28150
leaq (%rax,%r15), %rcx
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x62841
movl %eax, %ebx
testl %eax, %eax
jg 0x627ec
movq 0x10(%r12), %r12
cmpb $0x0, (%r15)
movq 0x2d187a(%rip), %r13 # 0x333fc8
movq (%r13), %rdi
je 0x6276f
leaq 0x351a4(%rip), %rdx # 0x978ff
movl $0x1, %esi
movq %r14, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x286e0
jmp 0x62785
leaq 0x35172(%rip), %rdx # 0x978e8
movl $0x1, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0x286e0
movq (%r13), %rdi
movq (%r12), %rcx
leaq 0x35185(%rip), %rdx # 0x97919
movl $0x1, %esi
xorl %eax, %eax
callq 0x286e0
movq 0x8(%r12), %rcx
testq %rcx, %rcx
je 0x627d5
addq $0x10, %r12
leaq 0x3517b(%rip), %r14 # 0x97930
movq (%r13), %rdi
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x286e0
movq (%r12), %rcx
addq $0x8, %r12
testq %rcx, %rcx
jne 0x627b5
movq (%r13), %rdi
leaq 0x32e1f(%rip), %rdx # 0x955ff
movl $0x1, %esi
xorl %eax, %eax
callq 0x286e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| find_type_with_warning:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov r12, rsi
mov r15, rdi
lea rbx, [rbp+var_30]
mov [rbx], rdi
call _strlen
lea rcx, [rax+r15]
mov rdi, rbx
mov rsi, r12
xor edx, edx
call find_type_eol
mov ebx, eax
test eax, eax
jg loc_627EC
mov r12, [r12+10h]
cmp byte ptr [r15], 0
mov r13, cs:stderr_ptr
mov rdi, [r13+0]
jz short loc_6276F
lea rdx, aUnknownOptionT; "Unknown option to %s: %s\n"
mov esi, 1
mov rcx, r14
mov r8, r15
xor eax, eax
call ___fprintf_chk
jmp short loc_62785
loc_6276F:
lea rdx, aNoOptionGivenT; "No option given to %s\n"
mov esi, 1
mov rcx, r14
xor eax, eax
call ___fprintf_chk
loc_62785:
mov rdi, [r13+0]
mov rcx, [r12]
lea rdx, aAlternativesAr; "Alternatives are: '%s'"
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rcx, [r12+8]
test rcx, rcx
jz short loc_627D5
add r12, 10h
lea r14, aS_0; ",'%s'"
loc_627B5:
mov rdi, [r13+0]
mov esi, 1
mov rdx, r14
xor eax, eax
call ___fprintf_chk
mov rcx, [r12]
add r12, 8
test rcx, rcx
jnz short loc_627B5
loc_627D5:
mov rdi, [r13+0]
lea rdx, aUsageSOptions+14h; "\n"
mov esi, 1
xor eax, eax
call ___fprintf_chk
loc_627EC:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long find_type_with_warning(const char *a1, long long a2, const char *a3)
{
long long v4; // rax
int type_eol; // ebx
const char **v6; // r12
const char *v7; // rcx
const char **v8; // r12
const char *v10; // [rsp+0h] [rbp-30h] BYREF
v10 = a1;
v4 = strlen(a1);
type_eol = find_type_eol(&v10, a2, 0LL, &a1[v4]);
if ( type_eol <= 0 )
{
v6 = *(const char ***)(a2 + 16);
if ( *a1 )
__fprintf_chk(stderr, 1LL, "Unknown option to %s: %s\n", a3, a1);
else
__fprintf_chk(stderr, 1LL, "No option given to %s\n", a3);
__fprintf_chk(stderr, 1LL, "Alternatives are: '%s'", *v6);
v7 = v6[1];
if ( v7 )
{
v8 = v6 + 2;
do
{
__fprintf_chk(stderr, 1LL, ",'%s'", v7);
v7 = *v8++;
}
while ( v7 );
}
__fprintf_chk(stderr, 1LL, "\n");
}
return (unsigned int)type_eol;
}
| find_type_with_warning:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R12,RSI
MOV R15,RDI
LEA RBX,[RBP + -0x30]
MOV qword ptr [RBX],RDI
CALL 0x00128150
LEA RCX,[RAX + R15*0x1]
MOV RDI,RBX
MOV RSI,R12
XOR EDX,EDX
CALL 0x00162841
MOV EBX,EAX
TEST EAX,EAX
JG 0x001627ec
MOV R12,qword ptr [R12 + 0x10]
CMP byte ptr [R15],0x0
MOV R13,qword ptr [0x00433fc8]
MOV RDI,qword ptr [R13]
JZ 0x0016276f
LEA RDX,[0x1978ff]
MOV ESI,0x1
MOV RCX,R14
MOV R8,R15
XOR EAX,EAX
CALL 0x001286e0
JMP 0x00162785
LAB_0016276f:
LEA RDX,[0x1978e8]
MOV ESI,0x1
MOV RCX,R14
XOR EAX,EAX
CALL 0x001286e0
LAB_00162785:
MOV RDI,qword ptr [R13]
MOV RCX,qword ptr [R12]
LEA RDX,[0x197919]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x001286e0
MOV RCX,qword ptr [R12 + 0x8]
TEST RCX,RCX
JZ 0x001627d5
ADD R12,0x10
LEA R14,[0x197930]
LAB_001627b5:
MOV RDI,qword ptr [R13]
MOV ESI,0x1
MOV RDX,R14
XOR EAX,EAX
CALL 0x001286e0
MOV RCX,qword ptr [R12]
ADD R12,0x8
TEST RCX,RCX
JNZ 0x001627b5
LAB_001627d5:
MOV RDI,qword ptr [R13]
LEA RDX,[0x1955ff]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x001286e0
LAB_001627ec:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int find_type_with_warning(char *param_1,long param_2,int8 param_3)
{
int8 *puVar1;
long lVar2;
int *puVar3;
int iVar4;
size_t sVar5;
long *plVar6;
char *local_38;
local_38 = param_1;
sVar5 = strlen(param_1);
iVar4 = find_type_eol(&local_38,param_2,0,param_1 + sVar5);
puVar3 = PTR_stderr_00433fc8;
if (iVar4 < 1) {
puVar1 = *(int8 **)(param_2 + 0x10);
if (*param_1 == '\0') {
__fprintf_chk(*(int8 *)PTR_stderr_00433fc8,1,"No option given to %s\n",param_3);
}
else {
__fprintf_chk(*(int8 *)PTR_stderr_00433fc8,1,"Unknown option to %s: %s\n",param_3,
param_1);
}
__fprintf_chk(*(int8 *)puVar3,1,"Alternatives are: \'%s\'",*puVar1);
if (puVar1[1] != 0) {
plVar6 = puVar1 + 2;
do {
__fprintf_chk(*(int8 *)puVar3,1,",\'%s\'");
lVar2 = *plVar6;
plVar6 = plVar6 + 1;
} while (lVar2 != 0);
}
__fprintf_chk(*(int8 *)puVar3,1,"\n");
}
return iVar4;
}
| |
38,181 | js_promise_then_finally_func | bluesky950520[P]quickjs/quickjs.c | static JSValue js_promise_then_finally_func(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv,
int magic, JSValue *func_data)
{
JSValue ctor = func_data[0];
JSValue onFinally = func_data[1];
JSValue res, promise, ret, then_func;
res = JS_Call(ctx, onFinally, JS_UNDEFINED, 0, NULL);
if (JS_IsException(res))
return res;
promise = js_promise_resolve(ctx, ctor, 1, &res, 0);
JS_FreeValue(ctx, res);
if (JS_IsException(promise))
return promise;
if (magic == 0) {
then_func = JS_NewCFunctionData(ctx, js_promise_finally_value_thunk, 0,
0, 1, argv);
} else {
then_func = JS_NewCFunctionData(ctx, js_promise_finally_thrower, 0,
0, 1, argv);
}
if (JS_IsException(then_func)) {
JS_FreeValue(ctx, promise);
return then_func;
}
ret = JS_InvokeFree(ctx, promise, JS_ATOM_then, 1, &then_func);
JS_FreeValue(ctx, then_func);
return ret;
} | O2 | c | js_promise_then_finally_func:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, %rbp
movq %rdi, %rbx
movq 0x70(%rsp), %rax
movq (%rax), %r13
movq 0x8(%rax), %r12
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
andq $0x0, (%rsp)
pushq $0x3
popq %r8
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x21eb6
movq %rdx, %r15
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
cmpl $0x6, %r15d
jne 0x47a5b
movq %rax, %r14
jmp 0x47b27
movq %rbp, 0x10(%rsp)
leaq 0x28(%rsp), %rbp
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %rbp, %r8
xorl %r9d, %r9d
callq 0x476a1
movq %rax, %r14
movq %rdx, %r15
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq %rbx, %rdi
callq 0x1801e
cmpl $0x6, %r15d
je 0x47b27
cmpl $0x0, 0xc(%rsp)
leaq 0x97(%rip), %rax # 0x47b3c
leaq 0xa4(%rip), %rsi # 0x47b50
cmoveq %rax, %rsi
pushq $0x1
popq %r8
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq 0x10(%rsp), %r9
callq 0x1b3ba
movq %rdx, %r13
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
cmpl $0x6, %r13d
jne 0x47af1
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1801e
movq %r12, %r14
movq %r13, %r15
jmp 0x47b27
pushq $0x1
popq %r8
leaq 0x18(%rsp), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x80, %ecx
movq %r12, %r9
callq 0x47b70
movq %rax, %r14
movq %rdx, %r15
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x1801e
movq %r14, %rax
movq %r15, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_promise_then_finally_func:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rsp+68h+var_5C], r9d
mov rbp, r8
mov rbx, rdi
mov rax, [rsp+68h+arg_0]
mov r13, [rax]
mov r12, [rax+8]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
and [rsp+68h+var_68], 0
push 3
pop r8
xor ecx, ecx
xor r9d, r9d
call JS_Call
mov r15, rdx
mov [rsp+68h+var_40], rax
mov [rsp+68h+var_38], rdx
cmp r15d, 6
jnz short loc_47A5B
mov r14, rax
jmp loc_47B27
loc_47A5B:
mov [rsp+68h+var_58], rbp
lea rbp, [rsp+68h+var_40]
mov rdi, rbx
mov rsi, r13
mov rdx, r12
mov r8, rbp
xor r9d, r9d
call js_promise_resolve
mov r14, rax
mov r15, rdx
mov rsi, [rbp+0]
mov rdx, [rbp+8]
mov rdi, rbx
call JS_FreeValue
cmp r15d, 6
jz loc_47B27
cmp [rsp+68h+var_5C], 0
lea rax, js_promise_finally_value_thunk
lea rsi, js_promise_finally_thrower
cmovz rsi, rax
push 1
pop r8
mov rdi, rbx
xor edx, edx
xor ecx, ecx
mov r9, [rsp+68h+var_58]
call JS_NewCFunctionData
mov r13, rdx
mov [rsp+68h+var_50], rax
mov [rsp+68h+var_48], rdx
cmp r13d, 6
jnz short loc_47AF1
mov r12, rax
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call JS_FreeValue
mov r14, r12
mov r15, r13
jmp short loc_47B27
loc_47AF1:
push 1
pop r8
lea r12, [rsp+68h+var_50]
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov ecx, 80h
mov r9, r12
call JS_InvokeFree
mov r14, rax
mov r15, rdx
mov rsi, [r12]
mov rdx, [r12+8]
mov rdi, rbx
call JS_FreeValue
loc_47B27:
mov rax, r14
mov rdx, r15
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _DWORD * js_promise_then_finally_func(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13,
int a14,
long long a15)
{
_DWORD *v16; // r13
unsigned long long v17; // r12
long long v18; // rax
long long v19; // rcx
__m128 v20; // xmm4
__m128 v21; // xmm5
long long v22; // rdx
_DWORD *v23; // r14
long long v24; // rdx
long long v25; // r15
long long ( *v26)(int, int, int, int, int, int, long long); // rsi
unsigned long long v27; // rax
long long v28; // rdx
unsigned long long v29; // r12
unsigned long long v32; // [rsp+18h] [rbp-50h] BYREF
long long v33; // [rsp+20h] [rbp-48h]
long long v34; // [rsp+28h] [rbp-40h] BYREF
long long v35; // [rsp+30h] [rbp-38h]
v16 = *(_DWORD **)a15;
v17 = *(_QWORD *)(a15 + 8);
v18 = JS_Call(a1, *(_QWORD *)(a15 + 16), *(_QWORD *)(a15 + 24), 0, 3, 0, 0LL);
v34 = v18;
v35 = v22;
if ( (_DWORD)v22 == 6 )
return (_DWORD *)v18;
v23 = js_promise_resolve(a1, v16, v17, v19, &v34, 0LL, a2, a3, a4, a5, v20, v21, a8, a9);
v25 = v24;
JS_FreeValue(a1, v34, v35);
if ( (_DWORD)v25 != 6 )
{
v26 = js_promise_finally_thrower;
if ( !a14 )
v26 = js_promise_finally_value_thunk;
v27 = JS_NewCFunctionData(a1, (long long)v26, 0, 0, 1u, a13);
v32 = v27;
v33 = v28;
if ( (_DWORD)v28 == 6 )
{
v29 = v27;
JS_FreeValue(a1, (long long)v23, v25);
return (_DWORD *)v29;
}
else
{
v23 = (_DWORD *)JS_InvokeFree(a1, v23, v25, 128LL, 1LL, &v32);
JS_FreeValue(a1, v32, v33);
}
}
return v23;
}
| js_promise_then_finally_func:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RSP + 0xc],R9D
MOV RBP,R8
MOV RBX,RDI
MOV RAX,qword ptr [RSP + 0x70]
MOV R13,qword ptr [RAX]
MOV R12,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
AND qword ptr [RSP],0x0
PUSH 0x3
POP R8
XOR ECX,ECX
XOR R9D,R9D
CALL 0x00121eb6
MOV R15,RDX
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
CMP R15D,0x6
JNZ 0x00147a5b
MOV R14,RAX
JMP 0x00147b27
LAB_00147a5b:
MOV qword ptr [RSP + 0x10],RBP
LEA RBP,[RSP + 0x28]
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R12
MOV R8,RBP
XOR R9D,R9D
CALL 0x001476a1
MOV R14,RAX
MOV R15,RDX
MOV RSI,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
MOV RDI,RBX
CALL 0x0011801e
CMP R15D,0x6
JZ 0x00147b27
CMP dword ptr [RSP + 0xc],0x0
LEA RAX,[0x147b3c]
LEA RSI,[0x147b50]
CMOVZ RSI,RAX
PUSH 0x1
POP R8
MOV RDI,RBX
XOR EDX,EDX
XOR ECX,ECX
MOV R9,qword ptr [RSP + 0x10]
CALL 0x0011b3ba
MOV R13,RDX
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
CMP R13D,0x6
JNZ 0x00147af1
MOV R12,RAX
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x0011801e
MOV R14,R12
MOV R15,R13
JMP 0x00147b27
LAB_00147af1:
PUSH 0x1
POP R8
LEA R12,[RSP + 0x18]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV ECX,0x80
MOV R9,R12
CALL 0x00147b70
MOV R14,RAX
MOV R15,RDX
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
MOV RDI,RBX
CALL 0x0011801e
LAB_00147b27:
MOV RAX,R14
MOV RDX,R15
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16] js_promise_then_finally_func(int8 param_1)
{
int8 uVar1;
int8 uVar2;
code *pcVar3;
int8 in_R8;
int in_R9D;
int1 auVar4 [16];
int1 auVar5 [16];
int8 *in_stack_00000008;
int1 local_50 [16];
int1 local_40 [16];
uVar1 = *in_stack_00000008;
uVar2 = in_stack_00000008[1];
local_40 = JS_Call(param_1,in_stack_00000008[2],in_stack_00000008[3],0,3,0,0);
auVar4 = local_40;
if (local_40._8_4_ != 6) {
auVar4 = js_promise_resolve(param_1,uVar1,uVar2);
JS_FreeValue(param_1,local_40._0_8_,local_40._8_8_);
if (auVar4._8_4_ != 6) {
pcVar3 = js_promise_finally_thrower;
if (in_R9D == 0) {
pcVar3 = js_promise_finally_value_thunk;
}
auVar5 = JS_NewCFunctionData(param_1,pcVar3,0,0,1,in_R8);
local_50 = auVar5;
if (auVar5._8_4_ == 6) {
JS_FreeValue(param_1,auVar4._0_8_,auVar4._8_8_);
auVar4 = auVar5;
}
else {
auVar4 = JS_InvokeFree(param_1,auVar4._0_8_,auVar4._8_8_,0x80,1,local_50);
JS_FreeValue(param_1,local_50._0_8_,local_50._8_8_);
}
}
}
return auVar4;
}
| |
38,182 | my_hash_sort_simple | eloqsql/strings/ctype-simple.c | void my_hash_sort_simple(CHARSET_INFO *cs,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
register const uchar *sort_order=cs->sort_order;
const uchar *end;
uint16 space_weight= sort_order[' '];
/*
Remove all trailing characters that are equal to space.
We have to do this to be able to compare 'A ' and 'A' as identical.
If the key is long enough, cut the trailing spaces (0x20) using an
optimized function implemented in skip_trailing_spaces().
"len > 16" is just some heuristic here.
Calling skip_triling_space() for short values is not desirable,
because its initialization block may be more expensive than the
performance gained.
*/
end= len > 16 ? skip_trailing_space(key, len) : key + len;
/*
We removed all trailing characters that are binary equal to space 0x20.
Now remove all trailing characters that have weights equal to space.
Some 8bit simple collations may have such characters:
- cp1250_general_ci 0xA0 NO-BREAK SPACE == 0x20 SPACE
- cp1251_ukrainian_ci 0x60 GRAVE ACCENT == 0x20 SPACE
- koi8u_general_ci 0x60 GRAVE ACCENT == 0x20 SPACE
*/
for ( ; key < end ; )
{
if (sort_order[*--end] != space_weight)
{
end++;
break;
}
}
my_hash_sort_simple_nopad(cs, key, end - key, nr1, nr2);
} | O0 | c | my_hash_sort_simple:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
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 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzbl 0x20(%rax), %eax
movw %ax, -0x3a(%rbp)
cmpq $0x10, -0x18(%rbp)
jbe 0xad7ce
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xad850
movq %rax, -0x48(%rbp)
jmp 0xad7da
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xad81f
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x38(%rbp)
movzbl -0x1(%rcx), %ecx
movzbl (%rax,%rcx), %eax
movzwl -0x3a(%rbp), %ecx
cmpl %ecx, %eax
je 0xad81d
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xad81f
jmp 0xad7e2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0xad6c0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_hash_sort_simple:
push rbp
mov rbp, rsp
sub rsp, 50h
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 rax, [rax+58h]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+20h]
mov [rbp+var_3A], ax
cmp [rbp+var_18], 10h
jbe short loc_AD7CE
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call skip_trailing_space_2
mov [rbp+var_48], rax
jmp short loc_AD7DA
loc_AD7CE:
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_48], rax
loc_AD7DA:
mov rax, [rbp+var_48]
mov [rbp+var_38], rax
loc_AD7E2:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_38]
jnb short loc_AD81F
mov rax, [rbp+var_30]
mov rcx, [rbp+var_38]
mov rdx, rcx
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_38], rdx
movzx ecx, byte ptr [rcx-1]
movzx eax, byte ptr [rax+rcx]
movzx ecx, [rbp+var_3A]
cmp eax, ecx
jz short loc_AD81D
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
jmp short loc_AD81F
loc_AD81D:
jmp short loc_AD7E2
loc_AD81F:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_38]
mov rax, [rbp+var_10]
sub rdx, rax
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
call my_hash_sort_simple_nopad
add rsp, 50h
pop rbp
retn
| _QWORD * my_hash_sort_simple(long long a1, unsigned __int8 *a2, unsigned long long a3, long long *a4, _QWORD *a5)
{
unsigned long long v5; // rcx
long long v7; // [rsp+8h] [rbp-48h]
__int16 v8; // [rsp+16h] [rbp-3Ah]
unsigned long long v9; // [rsp+18h] [rbp-38h]
long long v10; // [rsp+20h] [rbp-30h]
v10 = *(_QWORD *)(a1 + 88);
v8 = *(unsigned __int8 *)(v10 + 32);
if ( a3 <= 0x10 )
v7 = (long long)&a2[a3];
else
v7 = skip_trailing_space_2(a2, a3);
v9 = v7;
while ( (unsigned long long)a2 < v9 )
{
v5 = v9--;
if ( *(unsigned __int8 *)(v10 + *(unsigned __int8 *)(v5 - 1)) != v8 )
return my_hash_sort_simple_nopad(a1, a2, ++v9 - (_QWORD)a2, a4, a5);
}
return my_hash_sort_simple_nopad(a1, a2, v9 - (_QWORD)a2, a4, a5);
}
| my_hash_sort_simple:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
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 RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x20]
MOV word ptr [RBP + -0x3a],AX
CMP qword ptr [RBP + -0x18],0x10
JBE 0x001ad7ce
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001ad850
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001ad7da
LAB_001ad7ce:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
LAB_001ad7da:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x38],RAX
LAB_001ad7e2:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x001ad81f
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
MOV RDX,RCX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x38],RDX
MOVZX ECX,byte ptr [RCX + -0x1]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOVZX ECX,word ptr [RBP + -0x3a]
CMP EAX,ECX
JZ 0x001ad81d
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001ad81f
LAB_001ad81d:
JMP 0x001ad7e2
LAB_001ad81f:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
SUB RDX,RAX
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
CALL 0x001ad6c0
ADD RSP,0x50
POP RBP
RET
|
void my_hash_sort_simple(long param_1,ulong param_2,ulong param_3,int8 param_4,
int8 param_5)
{
char cVar1;
long lVar2;
ulong uVar3;
ulong local_50;
ulong local_40;
lVar2 = *(long *)(param_1 + 0x58);
cVar1 = *(char *)(lVar2 + 0x20);
if (param_3 < 0x11) {
local_50 = param_2 + param_3;
}
else {
local_50 = skip_trailing_space(param_2,param_3);
}
local_40 = local_50;
uVar3 = local_40;
do {
local_40 = uVar3;
if (local_40 <= param_2) break;
uVar3 = local_40 - 1;
} while (*(char *)(lVar2 + (ulong)*(byte *)(local_40 - 1)) == cVar1);
my_hash_sort_simple_nopad(param_1,param_2,local_40 - param_2,param_4,param_5);
return;
}
| |
38,183 | do_show_slave_status | eloqsql/client/mysqldump.c | static int do_show_slave_status(MYSQL *mysql_con, int use_gtid,
int have_mariadb_gtid)
{
MYSQL_RES *UNINIT_VAR(slave);
MYSQL_ROW row;
const char *comment_prefix=
(opt_slave_data == MYSQL_OPT_SLAVE_DATA_COMMENTED_SQL) ? "-- " : "";
const char *gtid_comment_prefix= (use_gtid ? comment_prefix : "-- ");
const char *nogtid_comment_prefix= (!use_gtid ? comment_prefix : "-- ");
int set_gtid_done= 0;
if (mysql_query_with_error_report(mysql_con, &slave,
multi_source ?
"SHOW ALL SLAVES STATUS" :
"SHOW SLAVE STATUS"))
{
if (!ignore_errors)
{
/* SHOW SLAVE STATUS reports nothing and --force is not enabled */
fprintf(stderr, "%s: Error: Slave not set up\n", my_progname_short);
}
mysql_free_result(slave);
return 1;
}
while ((row= mysql_fetch_row(slave)))
{
if (multi_source && !set_gtid_done)
{
char gtid_pos[MAX_GTID_LENGTH];
if (have_mariadb_gtid && get_gtid_pos(gtid_pos, 0))
return 1;
if (opt_comments)
fprintf(md_result_file, "\n--\n-- Gtid position to start replication "
"from\n--\n\n");
fprintf(md_result_file, "%sSET GLOBAL gtid_slave_pos='%s';\n",
gtid_comment_prefix, gtid_pos);
set_gtid_done= 1;
}
if (row[9 + multi_source] && row[21 + multi_source])
{
if (use_gtid)
{
if (multi_source)
fprintf(md_result_file, "%sCHANGE MASTER '%.80s' TO "
"MASTER_USE_GTID=slave_pos;\n", gtid_comment_prefix, row[0]);
else
fprintf(md_result_file, "%sCHANGE MASTER TO "
"MASTER_USE_GTID=slave_pos;\n", gtid_comment_prefix);
}
/* SHOW MASTER STATUS reports file and position */
if (opt_comments)
fprintf(md_result_file,
"\n--\n-- Position to start replication or point-in-time "
"recovery from (the master of this slave)\n--\n\n");
if (multi_source)
fprintf(md_result_file, "%sCHANGE MASTER '%.80s' TO ",
nogtid_comment_prefix, row[0]);
else
fprintf(md_result_file, "%sCHANGE MASTER TO ", nogtid_comment_prefix);
if (opt_include_master_host_port)
{
if (row[1 + multi_source])
fprintf(md_result_file, "MASTER_HOST='%s', ", row[1 + multi_source]);
if (row[3])
fprintf(md_result_file, "MASTER_PORT=%s, ", row[3 + multi_source]);
}
fprintf(md_result_file,
"MASTER_LOG_FILE='%s', MASTER_LOG_POS=%s;\n",
row[9 + multi_source], row[21 + multi_source]);
check_io(md_result_file);
}
}
mysql_free_result(slave);
return 0;
} | O0 | c | do_show_slave_status:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp # imm = 0x470
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x420(%rbp)
movl %esi, -0x424(%rbp)
movl %edx, -0x428(%rbp)
movq -0x430(%rbp), %rax
movq %rax, -0x430(%rbp)
movl 0x3c5fa5(%rip), %edx # 0x401624
leaq 0xa14c6(%rip), %rax # 0xdcb4c
leaq 0xa0192(%rip), %rcx # 0xdb81f
cmpl $0x2, %edx
cmoveq %rcx, %rax
movq %rax, -0x440(%rbp)
cmpl $0x0, -0x424(%rbp)
je 0x3b6b4
movq -0x440(%rbp), %rax
movq %rax, -0x460(%rbp)
jmp 0x3b6c4
leaq 0xa0164(%rip), %rax # 0xdb81f
movq %rax, -0x460(%rbp)
jmp 0x3b6c4
movq -0x460(%rbp), %rax
movq %rax, -0x448(%rbp)
cmpl $0x0, -0x424(%rbp)
jne 0x3b6eb
movq -0x440(%rbp), %rax
movq %rax, -0x468(%rbp)
jmp 0x3b6fb
leaq 0xa012d(%rip), %rax # 0xdb81f
movq %rax, -0x468(%rbp)
jmp 0x3b6fb
movq -0x468(%rbp), %rax
movq %rax, -0x450(%rbp)
movl $0x0, -0x454(%rbp)
movq -0x420(%rbp), %rdi
movl 0x3c5f00(%rip), %ecx # 0x401620
leaq 0xa011d(%rip), %rdx # 0xdb844
leaq 0xa00ff(%rip), %rax # 0xdb82d
cmpl $0x0, %ecx
cmovneq %rax, %rdx
leaq -0x430(%rbp), %rsi
callq 0x39350
cmpl $0x0, %eax
je 0x3b78c
cmpb $0x0, 0x3c5f27(%rip) # 0x401674
jne 0x3b771
movq 0x20988a(%rip), %rax # 0x244fe0
movq (%rax), %rdi
leaq 0x3d1478(%rip), %rax # 0x40cbd8
movq (%rax), %rdx
leaq 0xa0562(%rip), %rsi # 0xdbccc
movb $0x0, %al
callq 0x381d0
movq -0x430(%rbp), %rdi
callq 0x48d00
movl $0x1, -0x414(%rbp)
jmp 0x3ba20
jmp 0x3b78e
movq -0x430(%rbp), %rdi
callq 0x51800
movq %rax, -0x438(%rbp)
cmpq $0x0, %rax
je 0x3ba0a
cmpl $0x0, 0x3c5e6e(%rip) # 0x401620
je 0x3b833
cmpl $0x0, -0x454(%rbp)
jne 0x3b833
cmpl $0x0, -0x428(%rbp)
je 0x3b7e8
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
callq 0x3e0f0
cmpl $0x0, %eax
je 0x3b7e8
movl $0x1, -0x414(%rbp)
jmp 0x3ba20
cmpb $0x0, 0x3c5dfb(%rip) # 0x4015ea
je 0x3b806
movq 0x3c5cb8(%rip), %rdi # 0x4014b0
leaq 0xa04ea(%rip), %rsi # 0xdbce9
movb $0x0, %al
callq 0x381d0
movq 0x3c5ca3(%rip), %rdi # 0x4014b0
movq -0x448(%rbp), %rdx
leaq -0x410(%rbp), %rcx
leaq 0xa0400(%rip), %rsi # 0xdbc22
movb $0x0, %al
callq 0x381d0
movl $0x1, -0x454(%rbp)
movq -0x438(%rbp), %rax
movl 0x3c5de0(%rip), %ecx # 0x401620
addl $0x9, %ecx
movl %ecx, %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x3ba05
movq -0x438(%rbp), %rax
movl 0x3c5dc3(%rip), %ecx # 0x401620
addl $0x15, %ecx
movl %ecx, %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x3ba05
cmpl $0x0, -0x424(%rbp)
je 0x3b8c5
cmpl $0x0, 0x3c5da3(%rip) # 0x401620
je 0x3b8a7
movq 0x3c5c2a(%rip), %rdi # 0x4014b0
movq -0x448(%rbp), %rdx
movq -0x438(%rbp), %rax
movq (%rax), %rcx
leaq 0xa047f(%rip), %rsi # 0xdbd1d
movb $0x0, %al
callq 0x381d0
jmp 0x3b8c3
movq 0x3c5c02(%rip), %rdi # 0x4014b0
movq -0x448(%rbp), %rdx
leaq 0xa0337(%rip), %rsi # 0xdbbf3
movb $0x0, %al
callq 0x381d0
jmp 0x3b8c5
cmpb $0x0, 0x3c5d1e(%rip) # 0x4015ea
je 0x3b8e3
movq 0x3c5bdb(%rip), %rdi # 0x4014b0
leaq 0xa0478(%rip), %rsi # 0xdbd54
movb $0x0, %al
callq 0x381d0
cmpl $0x0, 0x3c5d36(%rip) # 0x401620
je 0x3b914
movq 0x3c5bbd(%rip), %rdi # 0x4014b0
movq -0x450(%rbp), %rdx
movq -0x438(%rbp), %rax
movq (%rax), %rcx
leaq 0xa04ad(%rip), %rsi # 0xdbdb8
movb $0x0, %al
callq 0x381d0
jmp 0x3b930
movq 0x3c5b95(%rip), %rdi # 0x4014b0
movq -0x450(%rbp), %rdx
leaq 0xa04ab(%rip), %rsi # 0xdbdd4
movb $0x0, %al
callq 0x381d0
cmpb $0x0, 0x3c5f00(%rip) # 0x401837
je 0x3b9b8
movq -0x438(%rbp), %rax
movl 0x3c5cda(%rip), %ecx # 0x401620
addl $0x1, %ecx
movl %ecx, %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x3b97d
movq 0x3c5b57(%rip), %rdi # 0x4014b0
movq -0x438(%rbp), %rax
movl 0x3c5cba(%rip), %ecx # 0x401620
addl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
leaq 0xa0472(%rip), %rsi # 0xdbde8
movb $0x0, %al
callq 0x381d0
movq -0x438(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3b9b6
movq 0x3c5b1e(%rip), %rdi # 0x4014b0
movq -0x438(%rbp), %rax
movl 0x3c5c81(%rip), %ecx # 0x401620
addl $0x3, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
leaq 0xa044c(%rip), %rsi # 0xdbdfb
movb $0x0, %al
callq 0x381d0
jmp 0x3b9b8
movq 0x3c5af1(%rip), %rdi # 0x4014b0
movq -0x438(%rbp), %rax
movl 0x3c5c54(%rip), %ecx # 0x401620
addl $0x9, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq -0x438(%rbp), %rax
movl 0x3c5c3e(%rip), %ecx # 0x401620
addl $0x15, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rcx
leaq 0xa01ac(%rip), %rsi # 0xdbb9e
movb $0x0, %al
callq 0x381d0
movq 0x3c5ab0(%rip), %rdi # 0x4014b0
callq 0x38d60
jmp 0x3b78e
movq -0x430(%rbp), %rdi
callq 0x48d00
movl $0x0, -0x414(%rbp)
movl -0x414(%rbp), %eax
movl %eax, -0x46c(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3ba4d
movl -0x46c(%rbp), %eax
addq $0x470, %rsp # imm = 0x470
popq %rbp
retq
callq 0x382c0
nopw %cs:(%rax,%rax)
| do_show_slave_status:
push rbp
mov rbp, rsp
sub rsp, 470h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_420], rdi
mov [rbp+var_424], esi
mov [rbp+var_428], edx
mov rax, [rbp+var_430]
mov [rbp+var_430], rax
mov edx, cs:opt_slave_data
lea rax, asc_DCB4A+2; ""
lea rcx, asc_DB81D+2; "-- "
cmp edx, 2
cmovz rax, rcx
mov [rbp+var_440], rax
cmp [rbp+var_424], 0
jz short loc_3B6B4
mov rax, [rbp+var_440]
mov [rbp+var_460], rax
jmp short loc_3B6C4
loc_3B6B4:
lea rax, asc_DB81D+2; "-- "
mov [rbp+var_460], rax
jmp short $+2
loc_3B6C4:
mov rax, [rbp+var_460]
mov [rbp+var_448], rax
cmp [rbp+var_424], 0
jnz short loc_3B6EB
mov rax, [rbp+var_440]
mov [rbp+var_468], rax
jmp short loc_3B6FB
loc_3B6EB:
lea rax, asc_DB81D+2; "-- "
mov [rbp+var_468], rax
jmp short $+2
loc_3B6FB:
mov rax, [rbp+var_468]
mov [rbp+var_450], rax
mov [rbp+var_454], 0
mov rdi, [rbp+var_420]
mov ecx, cs:multi_source
lea rdx, aShowSlaveStatu; "SHOW SLAVE STATUS"
lea rax, aShowAllSlavesS; "SHOW ALL SLAVES STATUS"
cmp ecx, 0
cmovnz rdx, rax
lea rsi, [rbp+var_430]
call mysql_query_with_error_report
cmp eax, 0
jz short loc_3B78C
cmp cs:ignore_errors, 0
jnz short loc_3B771
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rax, my_progname_short
mov rdx, [rax]
lea rsi, aSErrorSlaveNot; "%s: Error: Slave not set up\n"
mov al, 0
call _fprintf
loc_3B771:
mov rdi, [rbp+var_430]
call mysql_free_result
mov [rbp+var_414], 1
jmp loc_3BA20
loc_3B78C:
jmp short $+2
loc_3B78E:
mov rdi, [rbp+var_430]
call mysql_fetch_row
mov [rbp+var_438], rax
cmp rax, 0
jz loc_3BA0A
cmp cs:multi_source, 0
jz short loc_3B833
cmp [rbp+var_454], 0
jnz short loc_3B833
cmp [rbp+var_428], 0
jz short loc_3B7E8
lea rdi, [rbp+var_410]
xor esi, esi
call get_gtid_pos
cmp eax, 0
jz short loc_3B7E8
mov [rbp+var_414], 1
jmp loc_3BA20
loc_3B7E8:
cmp cs:opt_comments, 0
jz short loc_3B806
mov rdi, cs:md_result_file
lea rsi, aGtidPositionTo; "\n--\n-- Gtid position to start replica"...
mov al, 0
call _fprintf
loc_3B806:
mov rdi, cs:md_result_file
mov rdx, [rbp+var_448]
lea rcx, [rbp+var_410]
lea rsi, aSsetGlobalGtid; "%sSET GLOBAL gtid_slave_pos='%s';\n"
mov al, 0
call _fprintf
mov [rbp+var_454], 1
loc_3B833:
mov rax, [rbp+var_438]
mov ecx, cs:multi_source
add ecx, 9
mov ecx, ecx
cmp qword ptr [rax+rcx*8], 0
jz loc_3BA05
mov rax, [rbp+var_438]
mov ecx, cs:multi_source
add ecx, 15h
mov ecx, ecx
cmp qword ptr [rax+rcx*8], 0
jz loc_3BA05
cmp [rbp+var_424], 0
jz short loc_3B8C5
cmp cs:multi_source, 0
jz short loc_3B8A7
mov rdi, cs:md_result_file
mov rdx, [rbp+var_448]
mov rax, [rbp+var_438]
mov rcx, [rax]
lea rsi, aSchangeMaster8; "%sCHANGE MASTER '%.80s' TO MASTER_USE_G"...
mov al, 0
call _fprintf
jmp short loc_3B8C3
loc_3B8A7:
mov rdi, cs:md_result_file
mov rdx, [rbp+var_448]
lea rsi, aSchangeMasterT_0; "%sCHANGE MASTER TO MASTER_USE_GTID=slav"...
mov al, 0
call _fprintf
loc_3B8C3:
jmp short $+2
loc_3B8C5:
cmp cs:opt_comments, 0
jz short loc_3B8E3
mov rdi, cs:md_result_file
lea rsi, aPositionToStar_0; "\n--\n-- Position to start replication "...
mov al, 0
call _fprintf
loc_3B8E3:
cmp cs:multi_source, 0
jz short loc_3B914
mov rdi, cs:md_result_file
mov rdx, [rbp+var_450]
mov rax, [rbp+var_438]
mov rcx, [rax]
lea rsi, aSchangeMaster8_0; "%sCHANGE MASTER '%.80s' TO "
mov al, 0
call _fprintf
jmp short loc_3B930
loc_3B914:
mov rdi, cs:md_result_file
mov rdx, [rbp+var_450]
lea rsi, aSchangeMasterT_1; "%sCHANGE MASTER TO "
mov al, 0
call _fprintf
loc_3B930:
cmp cs:opt_include_master_host_port, 0
jz short loc_3B9B8
mov rax, [rbp+var_438]
mov ecx, cs:multi_source
add ecx, 1
mov ecx, ecx
cmp qword ptr [rax+rcx*8], 0
jz short loc_3B97D
mov rdi, cs:md_result_file
mov rax, [rbp+var_438]
mov ecx, cs:multi_source
add ecx, 1
mov ecx, ecx
mov rdx, [rax+rcx*8]
lea rsi, aMasterHostS; "MASTER_HOST='%s', "
mov al, 0
call _fprintf
loc_3B97D:
mov rax, [rbp+var_438]
cmp qword ptr [rax+18h], 0
jz short loc_3B9B6
mov rdi, cs:md_result_file
mov rax, [rbp+var_438]
mov ecx, cs:multi_source
add ecx, 3
mov ecx, ecx
mov rdx, [rax+rcx*8]
lea rsi, aMasterPortS; "MASTER_PORT=%s, "
mov al, 0
call _fprintf
loc_3B9B6:
jmp short $+2
loc_3B9B8:
mov rdi, cs:md_result_file
mov rax, [rbp+var_438]
mov ecx, cs:multi_source
add ecx, 9
mov ecx, ecx
mov rdx, [rax+rcx*8]
mov rax, [rbp+var_438]
mov ecx, cs:multi_source
add ecx, 15h
mov ecx, ecx
mov rcx, [rax+rcx*8]
lea rsi, aSchangeMasterT+13h; "MASTER_LOG_FILE='%s', MASTER_LOG_POS=%s"...
mov al, 0
call _fprintf
mov rdi, cs:md_result_file
call check_io
loc_3BA05:
jmp loc_3B78E
loc_3BA0A:
mov rdi, [rbp+var_430]
call mysql_free_result
mov [rbp+var_414], 0
loc_3BA20:
mov eax, [rbp+var_414]
mov [rbp+var_46C], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3BA4D
mov eax, [rbp+var_46C]
add rsp, 470h
pop rbp
retn
loc_3BA4D:
call ___stack_chk_fail
| long long do_show_slave_status(long long a1, int a2, int a3)
{
char *v3; // rax
const char *v4; // rdx
const char *v6; // [rsp+8h] [rbp-468h]
const char *v7; // [rsp+10h] [rbp-460h]
int v8; // [rsp+1Ch] [rbp-454h]
const char **row; // [rsp+38h] [rbp-438h]
long long v10; // [rsp+40h] [rbp-430h] BYREF
int v11; // [rsp+48h] [rbp-428h]
int v12; // [rsp+4Ch] [rbp-424h]
long long v13; // [rsp+50h] [rbp-420h]
char v15[1032]; // [rsp+60h] [rbp-410h] BYREF
unsigned long long v16; // [rsp+468h] [rbp-8h]
v16 = __readfsqword(0x28u);
v13 = a1;
v12 = a2;
v11 = a3;
v3 = "";
if ( opt_slave_data == 2 )
v3 = "-- ";
if ( v12 )
v7 = v3;
else
v7 = "-- ";
if ( v12 )
v6 = "-- ";
else
v6 = v3;
v8 = 0;
v4 = "SHOW SLAVE STATUS";
if ( multi_source )
v4 = "SHOW ALL SLAVES STATUS";
if ( (unsigned int)mysql_query_with_error_report(v13, &v10, (long long)v4) )
{
if ( !ignore_errors )
fprintf(stderr, "%s: Error: Slave not set up\n", my_progname_short);
mysql_free_result(v10);
return 1;
}
else
{
while ( 1 )
{
row = (const char **)mysql_fetch_row(v10);
if ( !row )
break;
if ( multi_source && !v8 )
{
if ( v11 && (unsigned int)get_gtid_pos(v15, 0LL) )
return 1;
if ( opt_comments )
fprintf(md_result_file, "\n--\n-- Gtid position to start replication from\n--\n\n");
fprintf(md_result_file, "%sSET GLOBAL gtid_slave_pos='%s';\n", v7, v15);
v8 = 1;
}
if ( row[multi_source + 9] && row[multi_source + 21] )
{
if ( v12 )
{
if ( multi_source )
fprintf(md_result_file, "%sCHANGE MASTER '%.80s' TO MASTER_USE_GTID=slave_pos;\n", v7, *row);
else
fprintf(md_result_file, "%sCHANGE MASTER TO MASTER_USE_GTID=slave_pos;\n", v7);
}
if ( opt_comments )
fprintf(
md_result_file,
"\n--\n-- Position to start replication or point-in-time recovery from (the master of this slave)\n--\n\n");
if ( multi_source )
fprintf(md_result_file, "%sCHANGE MASTER '%.80s' TO ", v6, *row);
else
fprintf(md_result_file, "%sCHANGE MASTER TO ", v6);
if ( opt_include_master_host_port )
{
if ( row[multi_source + 1] )
fprintf(md_result_file, "MASTER_HOST='%s', ", row[multi_source + 1]);
if ( row[3] )
fprintf(md_result_file, "MASTER_PORT=%s, ", row[multi_source + 3]);
}
fprintf(
md_result_file,
"MASTER_LOG_FILE='%s', MASTER_LOG_POS=%s;\n",
row[multi_source + 9],
row[multi_source + 21]);
check_io(md_result_file);
}
}
mysql_free_result(v10);
return 0;
}
}
| do_show_slave_status:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x470
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x420],RDI
MOV dword ptr [RBP + -0x424],ESI
MOV dword ptr [RBP + -0x428],EDX
MOV RAX,qword ptr [RBP + -0x430]
MOV qword ptr [RBP + -0x430],RAX
MOV EDX,dword ptr [0x00501624]
LEA RAX,[0x1dcb4c]
LEA RCX,[0x1db81f]
CMP EDX,0x2
CMOVZ RAX,RCX
MOV qword ptr [RBP + -0x440],RAX
CMP dword ptr [RBP + -0x424],0x0
JZ 0x0013b6b4
MOV RAX,qword ptr [RBP + -0x440]
MOV qword ptr [RBP + -0x460],RAX
JMP 0x0013b6c4
LAB_0013b6b4:
LEA RAX,[0x1db81f]
MOV qword ptr [RBP + -0x460],RAX
JMP 0x0013b6c4
LAB_0013b6c4:
MOV RAX,qword ptr [RBP + -0x460]
MOV qword ptr [RBP + -0x448],RAX
CMP dword ptr [RBP + -0x424],0x0
JNZ 0x0013b6eb
MOV RAX,qword ptr [RBP + -0x440]
MOV qword ptr [RBP + -0x468],RAX
JMP 0x0013b6fb
LAB_0013b6eb:
LEA RAX,[0x1db81f]
MOV qword ptr [RBP + -0x468],RAX
JMP 0x0013b6fb
LAB_0013b6fb:
MOV RAX,qword ptr [RBP + -0x468]
MOV qword ptr [RBP + -0x450],RAX
MOV dword ptr [RBP + -0x454],0x0
MOV RDI,qword ptr [RBP + -0x420]
MOV ECX,dword ptr [0x00501620]
LEA RDX,[0x1db844]
LEA RAX,[0x1db82d]
CMP ECX,0x0
CMOVNZ RDX,RAX
LEA RSI,[RBP + -0x430]
CALL 0x00139350
CMP EAX,0x0
JZ 0x0013b78c
CMP byte ptr [0x00501674],0x0
JNZ 0x0013b771
MOV RAX,qword ptr [0x00344fe0]
MOV RDI,qword ptr [RAX]
LEA RAX,[0x50cbd8]
MOV RDX,qword ptr [RAX]
LEA RSI,[0x1dbccc]
MOV AL,0x0
CALL 0x001381d0
LAB_0013b771:
MOV RDI,qword ptr [RBP + -0x430]
CALL 0x00148d00
MOV dword ptr [RBP + -0x414],0x1
JMP 0x0013ba20
LAB_0013b78c:
JMP 0x0013b78e
LAB_0013b78e:
MOV RDI,qword ptr [RBP + -0x430]
CALL 0x00151800
MOV qword ptr [RBP + -0x438],RAX
CMP RAX,0x0
JZ 0x0013ba0a
CMP dword ptr [0x00501620],0x0
JZ 0x0013b833
CMP dword ptr [RBP + -0x454],0x0
JNZ 0x0013b833
CMP dword ptr [RBP + -0x428],0x0
JZ 0x0013b7e8
LEA RDI,[RBP + -0x410]
XOR ESI,ESI
CALL 0x0013e0f0
CMP EAX,0x0
JZ 0x0013b7e8
MOV dword ptr [RBP + -0x414],0x1
JMP 0x0013ba20
LAB_0013b7e8:
CMP byte ptr [0x005015ea],0x0
JZ 0x0013b806
MOV RDI,qword ptr [0x005014b0]
LEA RSI,[0x1dbce9]
MOV AL,0x0
CALL 0x001381d0
LAB_0013b806:
MOV RDI,qword ptr [0x005014b0]
MOV RDX,qword ptr [RBP + -0x448]
LEA RCX,[RBP + -0x410]
LEA RSI,[0x1dbc22]
MOV AL,0x0
CALL 0x001381d0
MOV dword ptr [RBP + -0x454],0x1
LAB_0013b833:
MOV RAX,qword ptr [RBP + -0x438]
MOV ECX,dword ptr [0x00501620]
ADD ECX,0x9
MOV ECX,ECX
CMP qword ptr [RAX + RCX*0x8],0x0
JZ 0x0013ba05
MOV RAX,qword ptr [RBP + -0x438]
MOV ECX,dword ptr [0x00501620]
ADD ECX,0x15
MOV ECX,ECX
CMP qword ptr [RAX + RCX*0x8],0x0
JZ 0x0013ba05
CMP dword ptr [RBP + -0x424],0x0
JZ 0x0013b8c5
CMP dword ptr [0x00501620],0x0
JZ 0x0013b8a7
MOV RDI,qword ptr [0x005014b0]
MOV RDX,qword ptr [RBP + -0x448]
MOV RAX,qword ptr [RBP + -0x438]
MOV RCX,qword ptr [RAX]
LEA RSI,[0x1dbd1d]
MOV AL,0x0
CALL 0x001381d0
JMP 0x0013b8c3
LAB_0013b8a7:
MOV RDI,qword ptr [0x005014b0]
MOV RDX,qword ptr [RBP + -0x448]
LEA RSI,[0x1dbbf3]
MOV AL,0x0
CALL 0x001381d0
LAB_0013b8c3:
JMP 0x0013b8c5
LAB_0013b8c5:
CMP byte ptr [0x005015ea],0x0
JZ 0x0013b8e3
MOV RDI,qword ptr [0x005014b0]
LEA RSI,[0x1dbd54]
MOV AL,0x0
CALL 0x001381d0
LAB_0013b8e3:
CMP dword ptr [0x00501620],0x0
JZ 0x0013b914
MOV RDI,qword ptr [0x005014b0]
MOV RDX,qword ptr [RBP + -0x450]
MOV RAX,qword ptr [RBP + -0x438]
MOV RCX,qword ptr [RAX]
LEA RSI,[0x1dbdb8]
MOV AL,0x0
CALL 0x001381d0
JMP 0x0013b930
LAB_0013b914:
MOV RDI,qword ptr [0x005014b0]
MOV RDX,qword ptr [RBP + -0x450]
LEA RSI,[0x1dbdd4]
MOV AL,0x0
CALL 0x001381d0
LAB_0013b930:
CMP byte ptr [0x00501837],0x0
JZ 0x0013b9b8
MOV RAX,qword ptr [RBP + -0x438]
MOV ECX,dword ptr [0x00501620]
ADD ECX,0x1
MOV ECX,ECX
CMP qword ptr [RAX + RCX*0x8],0x0
JZ 0x0013b97d
MOV RDI,qword ptr [0x005014b0]
MOV RAX,qword ptr [RBP + -0x438]
MOV ECX,dword ptr [0x00501620]
ADD ECX,0x1
MOV ECX,ECX
MOV RDX,qword ptr [RAX + RCX*0x8]
LEA RSI,[0x1dbde8]
MOV AL,0x0
CALL 0x001381d0
LAB_0013b97d:
MOV RAX,qword ptr [RBP + -0x438]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x0013b9b6
MOV RDI,qword ptr [0x005014b0]
MOV RAX,qword ptr [RBP + -0x438]
MOV ECX,dword ptr [0x00501620]
ADD ECX,0x3
MOV ECX,ECX
MOV RDX,qword ptr [RAX + RCX*0x8]
LEA RSI,[0x1dbdfb]
MOV AL,0x0
CALL 0x001381d0
LAB_0013b9b6:
JMP 0x0013b9b8
LAB_0013b9b8:
MOV RDI,qword ptr [0x005014b0]
MOV RAX,qword ptr [RBP + -0x438]
MOV ECX,dword ptr [0x00501620]
ADD ECX,0x9
MOV ECX,ECX
MOV RDX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RBP + -0x438]
MOV ECX,dword ptr [0x00501620]
ADD ECX,0x15
MOV ECX,ECX
MOV RCX,qword ptr [RAX + RCX*0x8]
LEA RSI,[0x1dbb9e]
MOV AL,0x0
CALL 0x001381d0
MOV RDI,qword ptr [0x005014b0]
CALL 0x00138d60
LAB_0013ba05:
JMP 0x0013b78e
LAB_0013ba0a:
MOV RDI,qword ptr [RBP + -0x430]
CALL 0x00148d00
MOV dword ptr [RBP + -0x414],0x0
LAB_0013ba20:
MOV EAX,dword ptr [RBP + -0x414]
MOV dword ptr [RBP + -0x46c],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013ba4d
MOV EAX,dword ptr [RBP + -0x46c]
ADD RSP,0x470
POP RBP
RET
LAB_0013ba4d:
CALL 0x001382c0
|
int4 do_show_slave_status(int8 param_1,int param_2,int param_3)
{
bool bVar1;
int iVar2;
int *puVar3;
int8 *puVar4;
char *pcVar5;
long in_FS_OFFSET;
int *local_470;
int *local_468;
int8 local_438;
int local_430;
int local_42c;
int8 local_428;
int4 local_41c;
int1 local_418 [1032];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
puVar3 = &DAT_001dcb4c;
if (opt_slave_data == 2) {
puVar3 = &DAT_001db81f;
}
if (param_2 == 0) {
local_468 = &DAT_001db81f;
local_470 = puVar3;
puVar3 = local_468;
}
else {
local_470 = &DAT_001db81f;
}
bVar1 = false;
pcVar5 = "SHOW SLAVE STATUS";
if (multi_source != 0) {
pcVar5 = "SHOW ALL SLAVES STATUS";
}
local_430 = param_3;
local_42c = param_2;
local_428 = param_1;
iVar2 = mysql_query_with_error_report(param_1,&local_438,pcVar5);
if (iVar2 == 0) {
while (puVar4 = (int8 *)mysql_fetch_row(local_438), puVar4 != (int8 *)0x0) {
if ((multi_source != 0) && (!bVar1)) {
if ((local_430 != 0) && (iVar2 = get_gtid_pos(local_418,0), iVar2 != 0)) {
local_41c = 1;
goto LAB_0013ba20;
}
if (opt_comments != '\0') {
fprintf(md_result_file,"\n--\n-- Gtid position to start replication from\n--\n\n");
}
fprintf(md_result_file,"%sSET GLOBAL gtid_slave_pos=\'%s\';\n",puVar3,local_418);
bVar1 = true;
}
if ((puVar4[multi_source + 9] != 0) && (puVar4[multi_source + 0x15] != 0)) {
if (local_42c != 0) {
if (multi_source == 0) {
fprintf(md_result_file,"%sCHANGE MASTER TO MASTER_USE_GTID=slave_pos;\n",puVar3);
}
else {
fprintf(md_result_file,"%sCHANGE MASTER \'%.80s\' TO MASTER_USE_GTID=slave_pos;\n",
puVar3,*puVar4);
}
}
if (opt_comments != '\0') {
fprintf(md_result_file,
"\n--\n-- Position to start replication or point-in-time recovery from (the master of this slave)\n--\n\n"
);
}
if (multi_source == 0) {
fprintf(md_result_file,"%sCHANGE MASTER TO ",local_470);
}
else {
fprintf(md_result_file,"%sCHANGE MASTER \'%.80s\' TO ",local_470,*puVar4);
}
if (opt_include_master_host_port != '\0') {
if (puVar4[multi_source + 1] != 0) {
fprintf(md_result_file,"MASTER_HOST=\'%s\', ",puVar4[multi_source + 1]);
}
if (puVar4[3] != 0) {
fprintf(md_result_file,"MASTER_PORT=%s, ",puVar4[multi_source + 3]);
}
}
fprintf(md_result_file,"MASTER_LOG_FILE=\'%s\', MASTER_LOG_POS=%s;\n",
puVar4[multi_source + 9],puVar4[multi_source + 0x15]);
check_io(md_result_file);
}
}
mysql_free_result(local_438);
local_41c = 0;
}
else {
if (ignore_errors == '\0') {
fprintf(*(FILE **)PTR_stderr_00344fe0,"%s: Error: Slave not set up\n",my_progname_short);
}
mysql_free_result(local_438);
local_41c = 1;
}
LAB_0013ba20:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_41c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
38,184 | my_b_safe_write | eloqsql/mysys/mf_iocache.c | int my_b_safe_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
/*
Sasha: We are not writing this with the ? operator to avoid hitting
a possible compiler bug. At least gcc 2.95 cannot deal with
several layers of ternary operators that evaluated comma(,) operator
expressions inside - I do have a test case if somebody wants it
*/
if (info->type == SEQ_READ_APPEND)
return my_b_append(info, Buffer, Count);
return my_b_write(info, Buffer, Count);
} | O3 | c | my_b_safe_write:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x3, 0xb0(%rdi)
jne 0x971ae
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x96f56
movq 0x40(%r14), %rdi
leaq (%rdi,%rbx), %rax
cmpq 0x48(%r14), %rax
jbe 0x971cb
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x9674f
testq %rbx, %rbx
je 0x971dc
movq %rbx, %rdx
callq 0x29080
addq %rbx, 0x40(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
| my_b_safe_write:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdx
mov r14, rdi
cmp dword ptr [rdi+0B0h], 3
jnz short loc_971AE
mov rdi, r14
mov rdx, rbx
pop rbx
pop r14
pop rbp
jmp my_b_append
loc_971AE:
mov rdi, [r14+40h]
lea rax, [rdi+rbx]
cmp rax, [r14+48h]
jbe short loc_971CB
mov rdi, r14
mov rdx, rbx
pop rbx
pop r14
pop rbp
jmp _my_b_write
loc_971CB:
test rbx, rbx
jz short loc_971DC
mov rdx, rbx
call _memcpy
add [r14+40h], rbx
loc_971DC:
xor eax, eax
pop rbx
pop r14
pop rbp
retn
| long long my_b_safe_write(long long a1, const char *a2, unsigned long long a3)
{
long long v6; // rdi
if ( *(_DWORD *)(a1 + 176) == 3 )
return my_b_append(a1, (long long)a2, a3);
v6 = *(_QWORD *)(a1 + 64);
if ( v6 + a3 > *(_QWORD *)(a1 + 72) )
return my_b_write(a1, a2, a3);
if ( a3 )
{
memcpy(v6, a2, a3);
*(_QWORD *)(a1 + 64) += a3;
}
return 0LL;
}
| my_b_safe_write:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RDI
CMP dword ptr [RDI + 0xb0],0x3
JNZ 0x001971ae
MOV RDI,R14
MOV RDX,RBX
POP RBX
POP R14
POP RBP
JMP 0x00196f56
LAB_001971ae:
MOV RDI,qword ptr [R14 + 0x40]
LEA RAX,[RDI + RBX*0x1]
CMP RAX,qword ptr [R14 + 0x48]
JBE 0x001971cb
MOV RDI,R14
MOV RDX,RBX
POP RBX
POP R14
POP RBP
JMP 0x0019674f
LAB_001971cb:
TEST RBX,RBX
JZ 0x001971dc
MOV RDX,RBX
CALL 0x00129080
ADD qword ptr [R14 + 0x40],RBX
LAB_001971dc:
XOR EAX,EAX
POP RBX
POP R14
POP RBP
RET
|
int8 my_b_safe_write(long param_1,void *param_2,size_t param_3)
{
int8 uVar1;
if (*(int *)(param_1 + 0xb0) == 3) {
uVar1 = my_b_append(param_1,param_2,param_3);
return uVar1;
}
if (*(ulong *)(param_1 + 0x48) < (long)*(void **)(param_1 + 0x40) + param_3) {
uVar1 = _my_b_write(param_1,param_2,param_3);
return uVar1;
}
if (param_3 != 0) {
memcpy(*(void **)(param_1 + 0x40),param_2,param_3);
*(long *)(param_1 + 0x40) = *(long *)(param_1 + 0x40) + param_3;
}
return 0;
}
| |
38,185 | testing::internal::Mutex::Mutex() | giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h | Mutex() {
GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
has_owner_ = false;
} | O3 | c | testing::internal::Mutex::Mutex():
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x8830
testl %eax, %eax
je 0x33ae2
movl %eax, %ebp
leaq 0x105b4(%rip), %rdx # 0x4403a
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x6d3, %ecx # imm = 0x6D3
callq 0x16b08
movq 0x25547(%rip), %rdi # 0x58fe8
leaq 0x10675(%rip), %rsi # 0x4411d
movl $0x24, %edx
callq 0x85b0
movq 0x2552f(%rip), %rdi # 0x58fe8
leaq 0x10621(%rip), %rsi # 0x440e1
movl $0x12, %edx
callq 0x85b0
movq 0x25517(%rip), %rdi # 0x58fe8
movl %ebp, %esi
callq 0x8950
leaq 0x4(%rsp), %rdi
callq 0x16c4a
movb $0x0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x16c4a
movq %rbx, %rdi
callq 0x8990
| _ZN7testing8internal5MutexC2Ev:
push rbp
push rbx
push rax
mov rbx, rdi
xor esi, esi
call _pthread_mutex_init
test eax, eax
jz short loc_33AE2
mov ebp, eax
lea rdx, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rsp+18h+var_14]
mov esi, 3
mov ecx, 6D3h
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aPthreadMutexIn_0; "pthread_mutex_init(&mutex_, nullptr)"
mov edx, 24h ; '$'
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, cs:_ZSt4cerr_ptr
lea rsi, aFailedWithErro; "failed with error "
mov edx, 12h
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, cs:_ZSt4cerr_ptr
mov esi, ebp
call __ZNSolsEi; std::ostream::operator<<(int)
lea rdi, [rsp+18h+var_14]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
loc_33AE2:
mov byte ptr [rbx+28h], 0
add rsp, 8
pop rbx
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+4]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
mov rdi, rbx
call __Unwind_Resume
| void testing::internal::Mutex::Mutex(testing::internal::Mutex *this)
{
long long v1; // rax
unsigned int v2; // eax
unsigned int v3; // ebp
long long v4; // rdx
long long v5; // rcx
_DWORD v6[5]; // [rsp+0h] [rbp-14h] BYREF
v6[0] = HIDWORD(v1);
v2 = pthread_mutex_init(this, 0LL);
if ( v2 )
{
v3 = v2;
testing::internal::GTestLog::GTestLog(
v6,
3,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/include/gte"
"st/internal/gtest-port.h",
1747);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "pthread_mutex_init(&mutex_, nullptr)", 36LL);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "failed with error ", 18LL);
std::ostream::operator<<(&std::cerr, v3);
testing::internal::GTestLog::~GTestLog((testing::internal::GTestLog *)v6, v3, v4, v5);
}
*((_BYTE *)this + 40) = 0;
}
| Mutex:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
XOR ESI,ESI
CALL 0x00108830
TEST EAX,EAX
JZ 0x00133ae2
MOV EBP,EAX
LEA RDX,[0x14403a]
LEA RDI,[RSP + 0x4]
MOV ESI,0x3
MOV ECX,0x6d3
CALL 0x00116b08
LAB_00133a9a:
MOV RDI,qword ptr [0x00158fe8]
LEA RSI,[0x14411d]
MOV EDX,0x24
CALL 0x001085b0
MOV RDI,qword ptr [0x00158fe8]
LEA RSI,[0x1440e1]
MOV EDX,0x12
CALL 0x001085b0
MOV RDI,qword ptr [0x00158fe8]
MOV ESI,EBP
CALL 0x00108950
LAB_00133ad8:
LEA RDI,[RSP + 0x4]
CALL 0x00116c4a
LAB_00133ae2:
MOV byte ptr [RBX + 0x28],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* testing::internal::Mutex::Mutex() */
void __thiscall testing::internal::Mutex::Mutex(Mutex *this)
{
int iVar1;
GTestLog local_14 [4];
iVar1 = pthread_mutex_init((pthread_mutex_t *)this,(pthread_mutexattr_t *)0x0);
if (iVar1 != 0) {
GTestLog::GTestLog(local_14,3,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h"
,0x6d3);
/* try { // try from 00133a9a to 00133ad7 has its CatchHandler @ 00133aed */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00158fe8,"pthread_mutex_init(&mutex_, nullptr)",0x24);
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00158fe8,"failed with error ",0x12);
std::ostream::operator<<((ostream *)PTR_cerr_00158fe8,iVar1);
GTestLog::~GTestLog(local_14);
}
this[0x28] = (Mutex)0x0;
return;
}
| |
38,186 | lf_dynarray_lvalue | eloqsql/mysys/lf_dynarray.c | void *lf_dynarray_lvalue(LF_DYNARRAY *array, uint idx)
{
void * ptr, * volatile * ptr_ptr= 0;
int i;
for (i= LF_DYNARRAY_LEVELS-1; idx < dynarray_idxes_in_prev_levels[i]; i--)
/* no-op */;
ptr_ptr= &array->level[i];
idx-= dynarray_idxes_in_prev_levels[i];
for (; i > 0; i--)
{
if (!(ptr= *ptr_ptr))
{
void *alloc= my_malloc(key_memory_lf_dynarray, LF_DYNARRAY_LEVEL_LENGTH *
sizeof(void *), MYF(MY_WME|MY_ZEROFILL));
if (unlikely(!alloc))
return(NULL);
if (my_atomic_casptr(ptr_ptr, &ptr, alloc))
ptr= alloc;
else
my_free(alloc);
}
ptr_ptr= ((void **)ptr) + idx / dynarray_idxes_in_prev_level[i];
idx%= dynarray_idxes_in_prev_level[i];
}
if (!(ptr= *ptr_ptr))
{
uchar *alloc, *data;
alloc= my_malloc(key_memory_lf_dynarray,
LF_DYNARRAY_LEVEL_LENGTH * array->size_of_element +
MY_MAX(array->size_of_element, sizeof(void *)),
MYF(MY_WME|MY_ZEROFILL));
if (unlikely(!alloc))
return(NULL);
/* reserve the space for free() address */
data= alloc + sizeof(void *);
{ /* alignment */
intptr mod= ((intptr)data) % array->size_of_element;
if (mod)
data+= array->size_of_element - mod;
}
((void **)data)[-1]= alloc; /* free() will need the original pointer */
if (my_atomic_casptr(ptr_ptr, &ptr, data))
ptr= data;
else
my_free(alloc);
}
return ((uchar*)ptr) + array->size_of_element * idx;
} | O3 | c | lf_dynarray_lvalue:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %esi, %ecx
leaq 0x20(%rdi), %r12
pushq $0x5
popq %r13
pushq $0x4
popq %rax
leaq 0xbc021(%rip), %rdx # 0xed040
movq -0x8(%rdx,%rax,8), %rsi
decl %r13d
decq %rax
addq $-0x8, %r12
cmpq %rcx, %rsi
ja 0x3101f
movq %rdi, -0x30(%rbp)
subl %esi, %r14d
testq %rax, %rax
jle 0x310b0
leal -0x1(%r13), %eax
movl %eax, %eax
leaq 0xbc014(%rip), %rcx # 0xed060
leaq (%rcx,%rax,8), %rbx
pushq $0x30
popq %r15
movq (%r12), %rdi
testq %rdi, %rdi
jne 0x31094
leaq 0xbe5178(%rip), %rax # 0xc161dc
movl (%rax), %edi
movl $0x800, %esi # imm = 0x800
movq %r15, %rdx
callq 0xaa1d9
testq %rax, %rax
je 0x3113b
movq %rax, %rdi
xorl %eax, %eax
lock
cmpxchgq %rdi, (%r12)
je 0x31094
movq %rax, %r12
callq 0xaa406
movq %r12, %rdi
movl %r14d, %eax
xorl %edx, %edx
divq (%rbx)
leaq (%rdi,%rax,8), %r12
decl %r13d
addq $-0x8, %rbx
movq %rdx, %r14
cmpl $0x1, %r13d
jg 0x31054
movq (%r12), %rcx
testq %rcx, %rcx
movq -0x30(%rbp), %rbx
jne 0x31121
leaq 0xbe5118(%rip), %rax # 0xc161dc
movl (%rax), %edi
movl 0x20(%rbx), %eax
movl %eax, %ecx
shll $0x8, %ecx
cmpl $0x9, %eax
pushq $0x8
popq %rsi
cmovael %eax, %esi
addq %rcx, %rsi
pushq $0x30
popq %rdx
callq 0xaa1d9
testq %rax, %rax
je 0x3113b
movq %rax, %rdi
addq $0x8, %rax
movl 0x20(%rbx), %esi
xorl %edx, %edx
divq %rsi
subq %rdx, %rsi
testq %rdx, %rdx
cmoveq %rdx, %rsi
leaq (%rdi,%rsi), %rcx
addq $0x8, %rcx
movq %rdi, (%rdi,%rsi)
xorl %eax, %eax
lock
cmpxchgq %rcx, (%r12)
je 0x31121
movq %rax, %r15
callq 0xaa406
movq %r15, %rcx
imull 0x20(%rbx), %r14d
addq %rcx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x31129
| lf_dynarray_lvalue:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14d, esi
mov ecx, esi
lea r12, [rdi+20h]
push 5
pop r13
push 4
pop rax
lea rdx, dynarray_idxes_in_prev_levels
loc_3101F:
mov rsi, [rdx+rax*8-8]
dec r13d
dec rax
add r12, 0FFFFFFFFFFFFFFF8h
cmp rsi, rcx
ja short loc_3101F
mov [rbp+var_30], rdi
sub r14d, esi
test rax, rax
jle short loc_310B0
lea eax, [r13-1]
mov eax, eax
lea rcx, dynarray_idxes_in_prev_level
lea rbx, [rcx+rax*8]
push 30h ; '0'
pop r15
loc_31054:
mov rdi, [r12]
test rdi, rdi
jnz short loc_31094
lea rax, key_memory_lf_dynarray
mov edi, [rax]
mov esi, 800h
mov rdx, r15
call my_malloc
test rax, rax
jz loc_3113B
mov rdi, rax
xor eax, eax
lock cmpxchg [r12], rdi
jz short loc_31094
mov r12, rax
call my_free
mov rdi, r12
loc_31094:
mov eax, r14d
xor edx, edx
div qword ptr [rbx]
lea r12, [rdi+rax*8]
dec r13d
add rbx, 0FFFFFFFFFFFFFFF8h
mov r14, rdx
cmp r13d, 1
jg short loc_31054
loc_310B0:
mov rcx, [r12]
test rcx, rcx
mov rbx, [rbp+var_30]
jnz short loc_31121
lea rax, key_memory_lf_dynarray
mov edi, [rax]
mov eax, [rbx+20h]
mov ecx, eax
shl ecx, 8
cmp eax, 9
push 8
pop rsi
cmovnb esi, eax
add rsi, rcx
push 30h ; '0'
pop rdx
call my_malloc
test rax, rax
jz short loc_3113B
mov rdi, rax
add rax, 8
mov esi, [rbx+20h]
xor edx, edx
div rsi
sub rsi, rdx
test rdx, rdx
cmovz rsi, rdx
lea rcx, [rdi+rsi]
add rcx, 8
mov [rdi+rsi], rdi
xor eax, eax
lock cmpxchg [r12], rcx
jz short loc_31121
mov r15, rax
call my_free
mov rcx, r15
loc_31121:
imul r14d, [rbx+20h]
add r14, rcx
loc_31129:
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3113B:
xor r14d, r14d
jmp short loc_31129
| signed long long lf_dynarray_lvalue(long long a1, unsigned int a2)
{
unsigned long long v3; // rcx
volatile signed long long *v4; // r12
int v5; // r13d
long long v6; // rax
unsigned long long v7; // rsi
unsigned int v8; // r14d
_QWORD *v9; // rbx
volatile signed long long v10; // rdi
signed long long v11; // rax
signed long long v12; // rax
volatile signed long long v13; // r12
unsigned long long v14; // rdx
signed long long v15; // rcx
unsigned int v16; // eax
long long v17; // rsi
long long v18; // rax
long long v19; // rdi
unsigned long long v20; // rdx
unsigned long long v21; // rsi
signed long long v22; // rax
signed long long v23; // r15
v3 = a2;
v4 = (volatile signed long long *)(a1 + 32);
v5 = 5;
v6 = 4LL;
do
{
v7 = dynarray_idxes_in_prev_levels[v6 - 1];
--v5;
--v6;
--v4;
}
while ( v7 > v3 );
v8 = a2 - v7;
if ( v6 > 0 )
{
v9 = (_QWORD *)((char *)&dynarray_idxes_in_prev_level + 8 * (unsigned int)(v5 - 1));
do
{
v10 = *v4;
if ( !*v4 )
{
v11 = my_malloc(key_memory_lf_dynarray, 2048LL, 48LL);
if ( !v11 )
return 0LL;
v10 = v11;
v12 = _InterlockedCompareExchange64(v4, v11, 0LL);
if ( v12 )
{
v13 = v12;
my_free(v10);
v10 = v13;
}
}
v14 = (unsigned long long)v8 % *v9;
v4 = (volatile signed long long *)(v10 + 8 * ((unsigned long long)v8 / *v9));
--v5;
--v9;
v8 = v14;
}
while ( v5 > 1 );
}
v15 = *v4;
if ( !*v4 )
{
v16 = *(_DWORD *)(a1 + 32);
v17 = 8LL;
if ( v16 >= 9 )
v17 = v16;
v18 = my_malloc(key_memory_lf_dynarray, (unsigned int)(*(_DWORD *)(a1 + 32) << 8) + v17, 48LL);
if ( !v18 )
return 0LL;
v19 = v18;
v20 = (v18 + 8) % (unsigned long long)*(unsigned int *)(a1 + 32);
v21 = *(unsigned int *)(a1 + 32) - v20;
if ( !v20 )
v21 = 0LL;
v15 = v18 + v21 + 8;
*(_QWORD *)(v18 + v21) = v18;
v22 = _InterlockedCompareExchange64(v4, v15, 0LL);
if ( v22 )
{
v23 = v22;
my_free(v19);
v15 = v23;
}
}
return v15 + *(_DWORD *)(a1 + 32) * v8;
}
| lf_dynarray_lvalue:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14D,ESI
MOV ECX,ESI
LEA R12,[RDI + 0x20]
PUSH 0x5
POP R13
PUSH 0x4
POP RAX
LEA RDX,[0x1ed040]
LAB_0013101f:
MOV RSI,qword ptr [RDX + RAX*0x8 + -0x8]
DEC R13D
DEC RAX
ADD R12,-0x8
CMP RSI,RCX
JA 0x0013101f
MOV qword ptr [RBP + -0x30],RDI
SUB R14D,ESI
TEST RAX,RAX
JLE 0x001310b0
LEA EAX,[R13 + -0x1]
MOV EAX,EAX
LEA RCX,[0x1ed060]
LEA RBX,[RCX + RAX*0x8]
PUSH 0x30
POP R15
LAB_00131054:
MOV RDI,qword ptr [R12]
TEST RDI,RDI
JNZ 0x00131094
LEA RAX,[0xd161dc]
MOV EDI,dword ptr [RAX]
MOV ESI,0x800
MOV RDX,R15
CALL 0x001aa1d9
TEST RAX,RAX
JZ 0x0013113b
MOV RDI,RAX
XOR EAX,EAX
CMPXCHG.LOCK qword ptr [R12],RDI
JZ 0x00131094
MOV R12,RAX
CALL 0x001aa406
MOV RDI,R12
LAB_00131094:
MOV EAX,R14D
XOR EDX,EDX
DIV qword ptr [RBX]
LEA R12,[RDI + RAX*0x8]
DEC R13D
ADD RBX,-0x8
MOV R14,RDX
CMP R13D,0x1
JG 0x00131054
LAB_001310b0:
MOV RCX,qword ptr [R12]
TEST RCX,RCX
MOV RBX,qword ptr [RBP + -0x30]
JNZ 0x00131121
LEA RAX,[0xd161dc]
MOV EDI,dword ptr [RAX]
MOV EAX,dword ptr [RBX + 0x20]
MOV ECX,EAX
SHL ECX,0x8
CMP EAX,0x9
PUSH 0x8
POP RSI
CMOVNC ESI,EAX
ADD RSI,RCX
PUSH 0x30
POP RDX
CALL 0x001aa1d9
TEST RAX,RAX
JZ 0x0013113b
MOV RDI,RAX
ADD RAX,0x8
MOV ESI,dword ptr [RBX + 0x20]
XOR EDX,EDX
DIV RSI
SUB RSI,RDX
TEST RDX,RDX
CMOVZ RSI,RDX
LEA RCX,[RDI + RSI*0x1]
ADD RCX,0x8
MOV qword ptr [RDI + RSI*0x1],RDI
XOR EAX,EAX
CMPXCHG.LOCK qword ptr [R12],RCX
JZ 0x00131121
MOV R15,RAX
CALL 0x001aa406
MOV RCX,R15
LAB_00131121:
IMUL R14D,dword ptr [RBX + 0x20]
ADD R14,RCX
LAB_00131129:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013113b:
XOR R14D,R14D
JMP 0x00131129
|
long lf_dynarray_lvalue(long param_1,uint param_2)
{
uint uVar1;
long lVar2;
ulong uVar3;
long lVar4;
ulong uVar5;
ulong *puVar6;
long lVar7;
long *plVar8;
int iVar9;
int iVar10;
bool bVar11;
plVar8 = (long *)(param_1 + 0x20);
lVar2 = 4;
iVar10 = 5;
do {
iVar9 = iVar10;
lVar4 = lVar2 * 8;
iVar10 = iVar9 + -1;
lVar2 = lVar2 + -1;
plVar8 = plVar8 + -1;
} while ((ulong)param_2 < *(ulong *)(write_pin_change_table + lVar4 + 0x18));
param_2 = param_2 - (int)*(ulong *)(write_pin_change_table + lVar4 + 0x18);
uVar5 = (ulong)param_2;
if (0 < lVar2) {
puVar6 = (ulong *)(dynarray_idxes_in_prev_level + (ulong)(iVar9 - 2) * 8);
do {
lVar2 = *plVar8;
if (*plVar8 == 0) {
lVar2 = my_malloc(key_memory_lf_dynarray,0x800,0x30);
if (lVar2 == 0) {
return 0;
}
LOCK();
lVar4 = *plVar8;
bVar11 = lVar4 == 0;
if (bVar11) {
*plVar8 = lVar2;
lVar4 = 0;
}
UNLOCK();
if (!bVar11) {
my_free();
lVar2 = lVar4;
}
}
uVar3 = uVar5 & 0xffffffff;
uVar5 = uVar3 % *puVar6;
param_2 = (uint)uVar5;
plVar8 = (long *)(lVar2 + (uVar3 / *puVar6) * 8);
iVar10 = iVar10 + -1;
puVar6 = puVar6 + -1;
} while (1 < iVar10);
}
lVar2 = *plVar8;
if (*plVar8 == 0) {
uVar1 = *(uint *)(param_1 + 0x20);
uVar5 = 8;
if (8 < uVar1) {
uVar5 = (ulong)uVar1;
}
lVar4 = my_malloc(key_memory_lf_dynarray,uVar5 + (uVar1 << 8),0x30);
if (lVar4 == 0) {
return 0;
}
uVar5 = (lVar4 + 8U) % (ulong)*(uint *)(param_1 + 0x20);
lVar7 = *(uint *)(param_1 + 0x20) - uVar5;
if (uVar5 == 0) {
lVar7 = 0;
}
lVar2 = lVar4 + lVar7 + 8;
*(long *)(lVar4 + lVar7) = lVar4;
LOCK();
lVar4 = *plVar8;
bVar11 = lVar4 == 0;
if (bVar11) {
*plVar8 = lVar2;
lVar4 = 0;
}
UNLOCK();
if (!bVar11) {
my_free();
lVar2 = lVar4;
}
}
return (ulong)(param_2 * *(int *)(param_1 + 0x20)) + lVar2;
}
| |
38,187 | Test_Demangle_Clones::RunTest() | ng-log[P]ng-log/src/demangle_unittest.cc | TEST(Demangle, Clones) {
char tmp[20];
EXPECT_TRUE(Demangle("_ZL3Foov", tmp, sizeof(tmp)));
EXPECT_STREQ("Foo()", tmp);
EXPECT_TRUE(Demangle("_ZL3Foov.clone.3", tmp, sizeof(tmp)));
EXPECT_STREQ("Foo()", tmp);
EXPECT_TRUE(Demangle("_ZL3Foov.constprop.80", tmp, sizeof(tmp)));
EXPECT_STREQ("Foo()", tmp);
EXPECT_TRUE(Demangle("_ZL3Foov.isra.18", tmp, sizeof(tmp)));
EXPECT_STREQ("Foo()", tmp);
EXPECT_TRUE(Demangle("_ZL3Foov.isra.2.constprop.18", tmp, sizeof(tmp)));
EXPECT_STREQ("Foo()", tmp);
// Invalid (truncated), should not demangle.
EXPECT_FALSE(Demangle("_ZL3Foov.clo", tmp, sizeof(tmp)));
// Invalid (.clone. not followed by number), should not demangle.
EXPECT_FALSE(Demangle("_ZL3Foov.clone.", tmp, sizeof(tmp)));
// Invalid (.clone. followed by non-number), should not demangle.
EXPECT_FALSE(Demangle("_ZL3Foov.clone.foo", tmp, sizeof(tmp)));
// Invalid (.constprop. not followed by number), should not demangle.
EXPECT_FALSE(Demangle("_ZL3Foov.isra.2.constprop.", tmp, sizeof(tmp)));
} | O3 | cpp | Test_Demangle_Clones::RunTest():
subq $0x18, %rsp
leaq 0x19d22(%rip), %rdi # 0x23163
movq %rsp, %rsi
movl $0x14, %edx
callq 0xa358
testb %al, %al
je 0x95a3
movl $0x286f6f46, %eax # imm = 0x286F6F46
xorl (%rsp), %eax
movzwl 0x4(%rsp), %ecx
xorl $0x29, %ecx
orl %eax, %ecx
jne 0x95a8
leaq 0x19d2c(%rip), %rdi # 0x231a1
movq %rsp, %rsi
movl $0x14, %edx
callq 0xa358
testb %al, %al
je 0x95ad
movl $0x286f6f46, %eax # imm = 0x286F6F46
xorl (%rsp), %eax
movzwl 0x4(%rsp), %ecx
xorl $0x29, %ecx
orl %eax, %ecx
jne 0x95b2
leaq 0x19d38(%rip), %rdi # 0x231e1
movq %rsp, %rsi
movl $0x14, %edx
callq 0xa358
testb %al, %al
je 0x95b7
movl $0x286f6f46, %eax # imm = 0x286F6F46
xorl (%rsp), %eax
movzwl 0x4(%rsp), %ecx
xorl $0x29, %ecx
orl %eax, %ecx
jne 0x95bc
leaq 0x19d4e(%rip), %rdi # 0x2322b
movq %rsp, %rsi
movl $0x14, %edx
callq 0xa358
testb %al, %al
je 0x95c1
movl $0x286f6f46, %eax # imm = 0x286F6F46
xorl (%rsp), %eax
movzwl 0x4(%rsp), %ecx
xorl $0x29, %ecx
orl %eax, %ecx
jne 0x95c6
leaq 0x19d5a(%rip), %rdi # 0x2326b
movq %rsp, %rsi
movl $0x14, %edx
callq 0xa358
testb %al, %al
je 0x95cb
movl $0x286f6f46, %eax # imm = 0x286F6F46
xorl (%rsp), %eax
movzwl 0x4(%rsp), %ecx
xorl $0x29, %ecx
orl %eax, %ecx
jne 0x95d0
leaq 0x19d7e(%rip), %rdi # 0x232c3
movq %rsp, %rsi
movl $0x14, %edx
callq 0xa358
testb %al, %al
jne 0x95d5
leaq 0x19da1(%rip), %rdi # 0x232fe
movq %rsp, %rsi
movl $0x14, %edx
callq 0xa358
testb %al, %al
jne 0x95da
leaq 0x19dca(%rip), %rdi # 0x2333f
movq %rsp, %rsi
movl $0x14, %edx
callq 0xa358
testb %al, %al
jne 0x95df
leaq 0x19df9(%rip), %rdi # 0x23386
movq %rsp, %rsi
movl $0x14, %edx
callq 0xa358
testb %al, %al
jne 0x95e4
addq $0x18, %rsp
retq
callq 0x7bbe
callq 0x7be6
callq 0x7c15
callq 0x7c3d
callq 0x7c6c
callq 0x7c94
callq 0x7cc3
callq 0x7ceb
callq 0x7d1a
callq 0x7d42
callq 0x7de9
callq 0x7dc1
callq 0x7d99
callq 0x7d71
nop
| _ZN20Test_Demangle_Clones7RunTestEv:
sub rsp, 18h
lea rdi, aZl3foov; "_ZL3Foov"
mov rsi, rsp; char *
mov edx, offset dword_14; char *
call _ZN5nglog5tools8DemangleEPKcPcm; nglog::tools::Demangle(char const*,char *,ulong)
test al, al
jz loc_95A3
mov eax, 286F6F46h
xor eax, [rsp+18h+var_18]
movzx ecx, [rsp+18h+var_14]
xor ecx, 29h
or ecx, eax; unsigned __int64
jnz loc_95A8
lea rdi, aZl3foovClone3; "_ZL3Foov.clone.3"
mov rsi, rsp; char *
mov edx, offset dword_14; char *
call _ZN5nglog5tools8DemangleEPKcPcm; nglog::tools::Demangle(char const*,char *,ulong)
test al, al
jz loc_95AD
mov eax, 286F6F46h
xor eax, [rsp+18h+var_18]
movzx ecx, [rsp+18h+var_14]
xor ecx, 29h
or ecx, eax; unsigned __int64
jnz loc_95B2
lea rdi, aZl3foovConstpr; "_ZL3Foov.constprop.80"
mov rsi, rsp; char *
mov edx, offset dword_14; char *
call _ZN5nglog5tools8DemangleEPKcPcm; nglog::tools::Demangle(char const*,char *,ulong)
test al, al
jz loc_95B7
mov eax, 286F6F46h
xor eax, [rsp+18h+var_18]
movzx ecx, [rsp+18h+var_14]
xor ecx, 29h
or ecx, eax; unsigned __int64
jnz loc_95BC
lea rdi, aZl3foovIsra18; "_ZL3Foov.isra.18"
mov rsi, rsp; char *
mov edx, offset dword_14; char *
call _ZN5nglog5tools8DemangleEPKcPcm; nglog::tools::Demangle(char const*,char *,ulong)
test al, al
jz loc_95C1
mov eax, 286F6F46h
xor eax, [rsp+18h+var_18]
movzx ecx, [rsp+18h+var_14]
xor ecx, 29h
or ecx, eax; unsigned __int64
jnz loc_95C6
lea rdi, aZl3foovIsra2Co; "_ZL3Foov.isra.2.constprop.18"
mov rsi, rsp; char *
mov edx, offset dword_14; char *
call _ZN5nglog5tools8DemangleEPKcPcm; nglog::tools::Demangle(char const*,char *,ulong)
test al, al
jz loc_95CB
mov eax, 286F6F46h
xor eax, [rsp+18h+var_18]
movzx ecx, [rsp+18h+var_14]
xor ecx, 29h
or ecx, eax; unsigned __int64
jnz loc_95D0
lea rdi, aZl3foovClo; "_ZL3Foov.clo"
mov rsi, rsp; char *
mov edx, offset dword_14; char *
call _ZN5nglog5tools8DemangleEPKcPcm; nglog::tools::Demangle(char const*,char *,ulong)
test al, al
jnz short loc_95D5
lea rdi, aZl3foovClone; "_ZL3Foov.clone."
mov rsi, rsp; char *
mov edx, offset dword_14; char *
call _ZN5nglog5tools8DemangleEPKcPcm; nglog::tools::Demangle(char const*,char *,ulong)
test al, al
jnz short loc_95DA
lea rdi, aZl3foovCloneFo; "_ZL3Foov.clone.foo"
mov rsi, rsp; char *
mov edx, offset dword_14; char *
call _ZN5nglog5tools8DemangleEPKcPcm; nglog::tools::Demangle(char const*,char *,ulong)
test al, al
jnz short loc_95DF
lea rdi, aZl3foovIsra2Co_0; "_ZL3Foov.isra.2.constprop."
mov rsi, rsp; char *
mov edx, offset dword_14; char *
call _ZN5nglog5tools8DemangleEPKcPcm; nglog::tools::Demangle(char const*,char *,ulong)
test al, al
jnz short loc_95E4
add rsp, 18h
retn
loc_95A3:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_1; Test_Demangle_Clones::RunTest(void) [clone]
loc_95A8:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_2; Test_Demangle_Clones::RunTest(void) [clone]
loc_95AD:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_3; Test_Demangle_Clones::RunTest(void) [clone]
loc_95B2:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_4; Test_Demangle_Clones::RunTest(void) [clone]
loc_95B7:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_5; Test_Demangle_Clones::RunTest(void) [clone]
loc_95BC:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_6; Test_Demangle_Clones::RunTest(void) [clone]
loc_95C1:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_7; Test_Demangle_Clones::RunTest(void) [clone]
loc_95C6:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_8; Test_Demangle_Clones::RunTest(void) [clone]
loc_95CB:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_9; Test_Demangle_Clones::RunTest(void) [clone]
loc_95D0:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_10; Test_Demangle_Clones::RunTest(void) [clone]
loc_95D5:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_14; Test_Demangle_Clones::RunTest(void) [clone]
loc_95DA:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_13; Test_Demangle_Clones::RunTest(void) [clone]
loc_95DF:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_12; Test_Demangle_Clones::RunTest(void) [clone]
loc_95E4:
call _ZN20Test_Demangle_Clones7RunTestEv_cold_11; Test_Demangle_Clones::RunTest(void) [clone]
| long long Test_Demangle_Clones::RunTest(
Test_Demangle_Clones *this,
long long a2,
long long a3,
unsigned long long a4)
{
unsigned long long v4; // rcx
unsigned long long v5; // rcx
unsigned long long v6; // rcx
long long result; // rax
int v8; // [rsp+0h] [rbp-18h] BYREF
unsigned __int16 v9; // [rsp+4h] [rbp-14h]
if ( !(unsigned __int8)nglog::tools::Demangle((nglog::tools *)"_ZL3Foov", (const char *)&v8, (char *)dword_14, a4) )
Test_Demangle_Clones::RunTest();
if ( v8 ^ 0x286F6F46 | v9 ^ 0x29 )
Test_Demangle_Clones::RunTest();
if ( !(unsigned __int8)nglog::tools::Demangle(
(nglog::tools *)"_ZL3Foov.clone.3",
(const char *)&v8,
(char *)dword_14,
v8 ^ 0x286F6F46 | v9 ^ 0x29u) )
Test_Demangle_Clones::RunTest();
if ( v8 ^ 0x286F6F46 | v9 ^ 0x29 )
Test_Demangle_Clones::RunTest();
if ( !(unsigned __int8)nglog::tools::Demangle(
(nglog::tools *)"_ZL3Foov.constprop.80",
(const char *)&v8,
(char *)dword_14,
v8 ^ 0x286F6F46 | v9 ^ 0x29u) )
Test_Demangle_Clones::RunTest();
if ( v8 ^ 0x286F6F46 | v9 ^ 0x29 )
Test_Demangle_Clones::RunTest();
if ( !(unsigned __int8)nglog::tools::Demangle(
(nglog::tools *)"_ZL3Foov.isra.18",
(const char *)&v8,
(char *)dword_14,
v8 ^ 0x286F6F46 | v9 ^ 0x29u) )
Test_Demangle_Clones::RunTest();
if ( v8 ^ 0x286F6F46 | v9 ^ 0x29 )
Test_Demangle_Clones::RunTest();
if ( !(unsigned __int8)nglog::tools::Demangle(
(nglog::tools *)"_ZL3Foov.isra.2.constprop.18",
(const char *)&v8,
(char *)dword_14,
v8 ^ 0x286F6F46 | v9 ^ 0x29u) )
Test_Demangle_Clones::RunTest();
if ( v8 ^ 0x286F6F46 | v9 ^ 0x29 )
Test_Demangle_Clones::RunTest();
if ( (unsigned __int8)nglog::tools::Demangle(
(nglog::tools *)"_ZL3Foov.clo",
(const char *)&v8,
(char *)dword_14,
v8 ^ 0x286F6F46 | v9 ^ 0x29u) )
Test_Demangle_Clones::RunTest();
if ( (unsigned __int8)nglog::tools::Demangle(
(nglog::tools *)"_ZL3Foov.clone.",
(const char *)&v8,
(char *)dword_14,
v4) )
Test_Demangle_Clones::RunTest();
if ( (unsigned __int8)nglog::tools::Demangle(
(nglog::tools *)"_ZL3Foov.clone.foo",
(const char *)&v8,
(char *)dword_14,
v5) )
Test_Demangle_Clones::RunTest();
result = nglog::tools::Demangle((nglog::tools *)"_ZL3Foov.isra.2.constprop.", (const char *)&v8, (char *)dword_14, v6);
if ( (_BYTE)result )
Test_Demangle_Clones::RunTest();
return result;
}
| RunTest:
SUB RSP,0x18
LEA RDI,[0x123163]
MOV RSI,RSP
MOV EDX,0x14
CALL 0x0010a358
TEST AL,AL
JZ 0x001095a3
MOV EAX,0x286f6f46
XOR EAX,dword ptr [RSP]
MOVZX ECX,word ptr [RSP + 0x4]
XOR ECX,0x29
OR ECX,EAX
JNZ 0x001095a8
LEA RDI,[0x1231a1]
MOV RSI,RSP
MOV EDX,0x14
CALL 0x0010a358
TEST AL,AL
JZ 0x001095ad
MOV EAX,0x286f6f46
XOR EAX,dword ptr [RSP]
MOVZX ECX,word ptr [RSP + 0x4]
XOR ECX,0x29
OR ECX,EAX
JNZ 0x001095b2
LEA RDI,[0x1231e1]
MOV RSI,RSP
MOV EDX,0x14
CALL 0x0010a358
TEST AL,AL
JZ 0x001095b7
MOV EAX,0x286f6f46
XOR EAX,dword ptr [RSP]
MOVZX ECX,word ptr [RSP + 0x4]
XOR ECX,0x29
OR ECX,EAX
JNZ 0x001095bc
LEA RDI,[0x12322b]
MOV RSI,RSP
MOV EDX,0x14
CALL 0x0010a358
TEST AL,AL
JZ 0x001095c1
MOV EAX,0x286f6f46
XOR EAX,dword ptr [RSP]
MOVZX ECX,word ptr [RSP + 0x4]
XOR ECX,0x29
OR ECX,EAX
JNZ 0x001095c6
LEA RDI,[0x12326b]
MOV RSI,RSP
MOV EDX,0x14
CALL 0x0010a358
TEST AL,AL
JZ 0x001095cb
MOV EAX,0x286f6f46
XOR EAX,dword ptr [RSP]
MOVZX ECX,word ptr [RSP + 0x4]
XOR ECX,0x29
OR ECX,EAX
JNZ 0x001095d0
LEA RDI,[0x1232c3]
MOV RSI,RSP
MOV EDX,0x14
CALL 0x0010a358
TEST AL,AL
JNZ 0x001095d5
LEA RDI,[0x1232fe]
MOV RSI,RSP
MOV EDX,0x14
CALL 0x0010a358
TEST AL,AL
JNZ 0x001095da
LEA RDI,[0x12333f]
MOV RSI,RSP
MOV EDX,0x14
CALL 0x0010a358
TEST AL,AL
JNZ 0x001095df
LEA RDI,[0x123386]
MOV RSI,RSP
MOV EDX,0x14
CALL 0x0010a358
TEST AL,AL
JNZ 0x001095e4
ADD RSP,0x18
RET
LAB_001095a3:
CALL 0x00107bbe
LAB_001095a8:
CALL 0x00107be6
LAB_001095ad:
CALL 0x00107c15
LAB_001095b2:
CALL 0x00107c3d
LAB_001095b7:
CALL 0x00107c6c
LAB_001095bc:
CALL 0x00107c94
LAB_001095c1:
CALL 0x00107cc3
LAB_001095c6:
CALL 0x00107ceb
LAB_001095cb:
CALL 0x00107d1a
LAB_001095d0:
CALL 0x00107d42
LAB_001095d5:
CALL 0x00107de9
LAB_001095da:
CALL 0x00107dc1
LAB_001095df:
CALL 0x00107d99
LAB_001095e4:
CALL 0x00107d71
NOP
|
/* Test_Demangle_Clones::RunTest() */
void Test_Demangle_Clones::RunTest(void)
{
char cVar1;
int iVar2;
istream *piVar3;
long lVar4;
int8 uVar5;
char *pcStack_2d0;
long lStack_2c8;
char acStack_2c0 [16];
int1 *apuStack_2b0 [2];
int1 auStack_2a0 [16];
char *apcStack_290 [2];
char acStack_280 [16];
int1 *apuStack_270 [2];
int1 auStack_260 [16];
long alStack_250 [4];
byte abStack_230 [488];
int local_18;
short local_14;
cVar1 = nglog::tools::Demangle("_ZL3Foov",(char *)&local_18,0x14);
if (cVar1 == '\0') {
RunTest();
LAB_001095a8:
RunTest();
LAB_001095ad:
RunTest();
LAB_001095b2:
RunTest();
LAB_001095b7:
RunTest();
LAB_001095bc:
RunTest();
LAB_001095c1:
RunTest();
LAB_001095c6:
RunTest();
LAB_001095cb:
RunTest();
LAB_001095d0:
RunTest();
LAB_001095d5:
RunTest();
LAB_001095da:
RunTest();
}
else {
if (local_14 != 0x29 || local_18 != 0x286f6f46) goto LAB_001095a8;
cVar1 = nglog::tools::Demangle("_ZL3Foov.clone.3",(char *)&local_18,0x14);
if (cVar1 == '\0') goto LAB_001095ad;
if (local_14 != 0x29 || local_18 != 0x286f6f46) goto LAB_001095b2;
cVar1 = nglog::tools::Demangle("_ZL3Foov.constprop.80",(char *)&local_18,0x14);
if (cVar1 == '\0') goto LAB_001095b7;
if (local_14 != 0x29 || local_18 != 0x286f6f46) goto LAB_001095bc;
cVar1 = nglog::tools::Demangle("_ZL3Foov.isra.18",(char *)&local_18,0x14);
if (cVar1 == '\0') goto LAB_001095c1;
if (local_14 != 0x29 || local_18 != 0x286f6f46) goto LAB_001095c6;
cVar1 = nglog::tools::Demangle("_ZL3Foov.isra.2.constprop.18",(char *)&local_18,0x14);
if (cVar1 == '\0') goto LAB_001095cb;
if (local_14 != 0x29 || local_18 != 0x286f6f46) goto LAB_001095d0;
cVar1 = nglog::tools::Demangle("_ZL3Foov.clo",(char *)&local_18,0x14);
if (cVar1 != '\0') goto LAB_001095d5;
cVar1 = nglog::tools::Demangle("_ZL3Foov.clone.",(char *)&local_18,0x14);
if (cVar1 != '\0') goto LAB_001095da;
cVar1 = nglog::tools::Demangle("_ZL3Foov.clone.foo",(char *)&local_18,0x14);
if (cVar1 == '\0') {
cVar1 = nglog::tools::Demangle("_ZL3Foov.isra.2.constprop.",(char *)&local_18,0x14);
if (cVar1 == '\0') {
return;
}
goto LAB_001095e4;
}
}
RunTest();
LAB_001095e4:
RunTest();
apuStack_2b0[0] = auStack_2a0;
std::__cxx11::string::_M_construct<char*>
(apuStack_2b0,fLS::FLAGS_test_srcdir_buf_abi_cxx11_,
DAT_001319b8 + fLS::FLAGS_test_srcdir_buf_abi_cxx11_);
std::__cxx11::string::append((char *)apuStack_2b0);
std::ifstream::ifstream((ifstream *)alStack_250,apuStack_2b0[0],8);
if ((abStack_230[*(long *)(alStack_250[0] + -0x18)] & 5) == 0) {
pcStack_2d0 = acStack_2c0;
lStack_2c8 = 0;
acStack_2c0[0] = '\0';
while( true ) {
do {
cVar1 = std::ios::widen((char)*(int8 *)(alStack_250[0] + -0x18) +
(char)(istream *)alStack_250);
piVar3 = std::getline<char,std::char_traits<char>,std::allocator<char>>
((istream *)alStack_250,(string *)&pcStack_2d0,cVar1);
if (((byte)piVar3[*(long *)(*(long *)piVar3 + -0x18) + 0x20] & 5) != 0) {
if (pcStack_2d0 != acStack_2c0) {
free(pcStack_2d0);
}
std::ifstream::~ifstream((ifstream *)alStack_250);
if (apuStack_2b0[0] != auStack_2a0) {
free(apuStack_2b0[0]);
}
return;
}
} while ((lStack_2c8 == 0) || (*pcStack_2d0 == '#'));
lVar4 = std::__cxx11::string::find((char)&pcStack_2d0,9);
if (lVar4 == -1) break;
std::__cxx11::string::substr((ulong)apcStack_290,(ulong)&pcStack_2d0);
std::__cxx11::string::substr((ulong)apuStack_270,(ulong)&pcStack_2d0);
nglog::tools::Demangle(apcStack_290[0],DemangleIt(char_const*)::demangled,0x1000);
iVar2 = std::__cxx11::string::compare((char *)apuStack_270);
if (iVar2 != 0) goto LAB_001097c9;
if (apuStack_270[0] != auStack_260) {
free(apuStack_270[0]);
}
if (apcStack_290[0] != acStack_280) {
free(apcStack_290[0]);
}
}
Test_Demangle_FromFile::RunTest();
LAB_001097c9:
Test_Demangle_FromFile::RunTest();
}
uVar5 = Test_Demangle_FromFile::RunTest();
if (apuStack_2b0[0] != auStack_2a0) {
free(apuStack_2b0[0]);
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar5);
}
| |
38,188 | google::protobuf::io::Tokenizer::IsIdentifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/tokenizer.cc | bool Tokenizer::IsIdentifier(const std::string& text) {
// Mirrors IDENTIFIER definition in Tokenizer::Next() above.
if (text.size() == 0) return false;
if (!Letter::InClass(text.at(0))) return false;
if (!AllInClass<Alphanumeric>(text.substr(1))) return false;
return true;
} | O0 | cpp | google::protobuf::io::Tokenizer::IsIdentifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x147d0
cmpq $0x0, %rax
jne 0x127f63
movb $0x0, 0x57(%rsp)
jmp 0x127ff8
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13540
movsbl (%rax), %edi
callq 0x128010
testb $0x1, %al
jne 0x127f84
movb $0x0, 0x57(%rsp)
jmp 0x127ff8
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x14820
movq 0x10(%rsp), %rdi
callq 0x128070
movb %al, 0x1b(%rsp)
jmp 0x127fb4
movb 0x1b(%rsp), %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x13290
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x127fd2
jmp 0x127ff3
movb $0x0, 0x57(%rsp)
jmp 0x127ff8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x13290
jmp 0x128003
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x13750
nopl (%rax)
| _ZN6google8protobuf2io9Tokenizer12IsIdentifierERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 58h
mov [rsp+58h+var_10], rdi
mov rdi, [rsp+58h+var_10]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv; std::string::size(void)
cmp rax, 0
jnz short loc_127F63
mov [rsp+58h+var_1], 0
jmp loc_127FF8
loc_127F63:
mov rdi, [rsp+58h+var_10]
xor eax, eax
mov esi, eax; char
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE2atEm; std::string::at(ulong)
movsx edi, byte ptr [rax]; this
call _ZN6google8protobuf2io12_GLOBAL__N_16Letter7InClassEc; google::protobuf::io::`anonymous namespace'::Letter::InClass(char)
test al, 1
jnz short loc_127F84
mov [rsp+58h+var_1], 0
jmp short loc_127FF8
loc_127F84:
mov rsi, [rsp+58h+var_10]
lea rdi, [rsp+58h+var_30]
mov [rsp+58h+var_48], rdi
mov edx, 1
mov rcx, 0FFFFFFFFFFFFFFFFh
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, [rsp+58h+var_48]
call _ZN6google8protobuf2ioL10AllInClassINS1_12_GLOBAL__N_112AlphanumericEEEbRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::io::AllInClass<google::protobuf::io::`anonymous namespace'::Alphanumeric>(std::string const&)
mov [rsp+58h+var_3D], al
jmp short $+2
loc_127FB4:
mov al, [rsp+58h+var_3D]
xor al, 0FFh
mov [rsp+58h+var_49], al
lea rdi, [rsp+58h+var_30]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov al, [rsp+58h+var_49]
test al, 1
jnz short loc_127FD2
jmp short loc_127FF3
loc_127FD2:
mov [rsp+58h+var_1], 0
jmp short loc_127FF8
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_128003
loc_127FF3:
mov [rsp+58h+var_1], 1
loc_127FF8:
mov al, [rsp+58h+var_1]
and al, 1
add rsp, 58h
retn
loc_128003:
mov rdi, [rsp+arg_18]
call __Unwind_Resume
| bool google::protobuf::io::Tokenizer::IsIdentifier(long long a1)
{
char *v1; // rax
char v3; // [rsp+Fh] [rbp-49h]
_BYTE v4[32]; // [rsp+28h] [rbp-30h] BYREF
long long v5; // [rsp+48h] [rbp-10h]
v5 = a1;
if ( !std::string::size(a1) )
return 0;
v1 = (char *)std::string::at(v5, 0LL);
if ( (google::protobuf::io::`anonymous namespace'::Letter::InClass(
(google::protobuf::io::_anonymous_namespace_::Letter *)(unsigned int)*v1,
0) & 1) == 0 )
return 0;
std::string::substr(v4, v5, 1LL, -1LL);
v3 = ~(unsigned __int8)google::protobuf::io::AllInClass<google::protobuf::io::`anonymous namespace'::Alphanumeric>(v4);
std::string::~string(v4);
return (v3 & 1) == 0;
}
| |||
38,189 | google::protobuf::io::Tokenizer::IsIdentifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/tokenizer.cc | bool Tokenizer::IsIdentifier(const std::string& text) {
// Mirrors IDENTIFIER definition in Tokenizer::Next() above.
if (text.size() == 0) return false;
if (!Letter::InClass(text.at(0))) return false;
if (!AllInClass<Alphanumeric>(text.substr(1))) return false;
return true;
} | O3 | cpp | google::protobuf::io::Tokenizer::IsIdentifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbx
subq $0x20, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x7250c
movq %rdi, %rsi
movq (%rdi), %rax
movb (%rax), %al
cmpb $0x5f, %al
je 0x72510
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x19, %al
jbe 0x72510
xorl %ebx, %ebx
jmp 0x72589
movq %rsp, %rbx
movl $0x1, %edx
movq %rbx, %rdi
movq $-0x1, %rcx
callq 0x11d9c
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x72578
decq %rax
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
movl %edx, %esi
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x1a, %sil
setb %sil
leal -0x30(%rdx), %r8d
cmpb $0xa, %r8b
setb %r8b
cmpb $0x5f, %dl
sete %bl
orb %r8b, %bl
orb %sil, %bl
cmpb $0x1, %bl
jne 0x7257a
leaq 0x1(%rcx), %rdx
cmpq %rcx, %rax
movq %rdx, %rcx
jne 0x72538
jmp 0x7257a
movb $0x1, %bl
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x72589
callq 0xf330
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
nop
| _ZN6google8protobuf2io9Tokenizer12IsIdentifierERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbx
sub rsp, 20h
cmp qword ptr [rdi+8], 0
jz short loc_7250C
mov rsi, rdi
mov rax, [rdi]
mov al, [rax]
cmp al, 5Fh ; '_'
jz short loc_72510
and al, 0DFh
add al, 0BFh
cmp al, 19h
jbe short loc_72510
loc_7250C:
xor ebx, ebx
jmp short loc_72589
loc_72510:
mov rbx, rsp
mov edx, 1
mov rdi, rbx
mov rcx, 0FFFFFFFFFFFFFFFFh
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, [rbx]; void *
mov rax, [rbx+8]
test rax, rax
jz short loc_72578
dec rax
xor ecx, ecx
loc_72538:
mov dl, [rdi+rcx]
mov esi, edx
and sil, 0DFh
add sil, 0BFh
cmp sil, 1Ah
setb sil
lea r8d, [rdx-30h]
cmp r8b, 0Ah
setb r8b
cmp dl, 5Fh ; '_'
setz bl
or bl, r8b
or bl, sil
cmp bl, 1
jnz short loc_7257A
lea rdx, [rcx+1]
cmp rax, rcx
mov rcx, rdx
jnz short loc_72538
jmp short loc_7257A
loc_72578:
mov bl, 1
loc_7257A:
lea rax, [rsp+28h+var_18]
cmp rdi, rax
jz short loc_72589
call __ZdlPv; operator delete(void *)
loc_72589:
mov eax, ebx
add rsp, 20h
pop rbx
retn
| long long google::protobuf::io::Tokenizer::IsIdentifier(long long a1)
{
char v1; // al
void **v2; // rbx
long long v3; // rcx
char *v6; // [rsp+0h] [rbp-28h] BYREF
long long v7; // [rsp+8h] [rbp-20h]
char v8; // [rsp+10h] [rbp-18h] BYREF
if ( *(_QWORD *)(a1 + 8) && ((v1 = **(_BYTE **)a1, v1 == 95) || (unsigned __int8)((v1 & 0xDF) - 65) <= 0x19u) )
{
v2 = (void **)&v6;
std::string::substr((long long)&v6, a1, 1uLL);
if ( v7 )
{
v3 = 0LL;
do
{
LOBYTE(v2) = (unsigned __int8)((v6[v3] & 0xDF) - 65) < 0x1Au
|| (unsigned __int8)(v6[v3] - 48) < 0xAu
|| v6[v3] == 95;
if ( (_BYTE)v2 != 1 )
break;
}
while ( v7 - 1 != v3++ );
}
else
{
LOBYTE(v2) = 1;
}
if ( v6 != &v8 )
operator delete(v6);
}
else
{
LODWORD(v2) = 0;
}
return (unsigned int)v2;
}
| IsIdentifier:
PUSH RBX
SUB RSP,0x20
CMP qword ptr [RDI + 0x8],0x0
JZ 0x0017250c
MOV RSI,RDI
MOV RAX,qword ptr [RDI]
MOV AL,byte ptr [RAX]
CMP AL,0x5f
JZ 0x00172510
AND AL,0xdf
ADD AL,0xbf
CMP AL,0x19
JBE 0x00172510
LAB_0017250c:
XOR EBX,EBX
JMP 0x00172589
LAB_00172510:
MOV RBX,RSP
MOV EDX,0x1
MOV RDI,RBX
MOV RCX,-0x1
CALL 0x00111d9c
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RBX + 0x8]
TEST RAX,RAX
JZ 0x00172578
DEC RAX
XOR ECX,ECX
LAB_00172538:
MOV DL,byte ptr [RDI + RCX*0x1]
MOV ESI,EDX
AND SIL,0xdf
ADD SIL,0xbf
CMP SIL,0x1a
SETC SIL
LEA R8D,[RDX + -0x30]
CMP R8B,0xa
SETC R8B
CMP DL,0x5f
SETZ BL
OR BL,R8B
OR BL,SIL
CMP BL,0x1
JNZ 0x0017257a
LEA RDX,[RCX + 0x1]
CMP RAX,RCX
MOV RCX,RDX
JNZ 0x00172538
JMP 0x0017257a
LAB_00172578:
MOV BL,0x1
LAB_0017257a:
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x00172589
CALL 0x0010f330
LAB_00172589:
MOV EAX,EBX
ADD RSP,0x20
POP RBX
RET
|
/* google::protobuf::io::Tokenizer::IsIdentifier(std::__cxx11::string const&) */
ulong google::protobuf::io::Tokenizer::IsIdentifier(string *param_1)
{
byte bVar1;
long lVar2;
int1 **ppuVar3;
bool bVar4;
bool bVar5;
int1 *local_28;
long local_20;
int1 local_18 [16];
ppuVar3 = &local_28;
if ((*(long *)(param_1 + 8) == 0) ||
((**(byte **)param_1 != 0x5f && (0x19 < (byte)((**(byte **)param_1 & 0xdf) + 0xbf))))) {
ppuVar3 = (int1 **)0x0;
}
else {
std::__cxx11::string::substr((ulong)&local_28,(ulong)param_1);
if (local_20 == 0) {
ppuVar3 = (int1 **)CONCAT71((int7)((ulong)&local_28 >> 8),1);
}
else {
lVar2 = 0;
do {
bVar1 = local_28[lVar2];
bVar4 = (byte)((bVar1 & 0xdf) + 0xbf) < 0x1a;
bVar5 = (byte)(bVar1 - 0x30) < 10;
ppuVar3 = (int1 **)
CONCAT71((int7)((ulong)ppuVar3 >> 8),(bVar1 == 0x5f || bVar5) || bVar4);
if ((bVar1 != 0x5f && !bVar5) && !bVar4) break;
bVar4 = local_20 + -1 != lVar2;
lVar2 = lVar2 + 1;
} while (bVar4);
}
if (local_28 != local_18) {
operator_delete(local_28);
}
}
return (ulong)ppuVar3 & 0xffffffff;
}
| |
38,190 | YAML::as_if<aimrt::plugins::echo_plugin::EchoPlugin::Options, void>::operator()() const | aimrt_mujoco_sim/_deps/yaml-cpp-src/include/yaml-cpp/node/impl.h | T operator()() const {
if (!node.m_pNode)
throw TypedBadConversion<T>(node.Mark());
T t;
if (convert<T>::decode(node, t))
return t;
throw TypedBadConversion<T>(node.Mark());
} | O3 | c | YAML::as_if<aimrt::plugins::echo_plugin::EchoPlugin::Options, void>::operator()() const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
cmpq $0x0, 0x38(%rdi)
je 0x6b4a5
movb $0x1, (%rbx)
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movl $0x292a2e28, 0x18(%rbx) # imm = 0x292A2E28
movq $0x4, 0x10(%rbx)
xorl %eax, %eax
movb %al, 0x1c(%rbx)
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
leaq 0x58(%rbx), %rcx
movq %rcx, 0x48(%rbx)
movq %rax, 0x50(%rbx)
movb %al, 0x58(%rbx)
movq %rbx, %rsi
callq 0x6b560
testb %al, %al
je 0x6b4eb
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x40, %edi
callq 0x1e7e0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x33be0
movq %rsp, %rsi
movq %rax, (%rsi)
movl %edx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x34c84
leaq 0x43e06(%rip), %rax # 0xaf2d8
movq %rax, (%rbx)
leaq 0x43dd4(%rip), %rsi # 0xaf2b0
leaq 0x152a1(%rip), %rdx # 0x80784
movq %rbx, %rdi
callq 0x1fec0
movl $0x40, %edi
callq 0x1e7e0
movq %rax, %r15
movq (%r14), %rdi
callq 0x33be0
movq %rsp, %rsi
movq %rax, (%rsi)
movl %edx, 0x8(%rsi)
movq %r15, %rdi
callq 0x34c84
leaq 0x43dc0(%rip), %rax # 0xaf2d8
movq %rax, (%r15)
leaq 0x43d8e(%rip), %rsi # 0xaf2b0
leaq 0x1525b(%rip), %rdx # 0x80784
movq %r15, %rdi
callq 0x1fec0
jmp 0x6b54d
movq %rax, %r14
movq %r15, %rdi
callq 0x1ebc0
jmp 0x6b550
movq %rax, %r14
movq %rbx, %rdi
callq 0x1ebc0
jmp 0x6b558
movq %rax, %r14
movq %rbx, %rdi
callq 0x5bad2
movq %r14, %rdi
callq 0x1ffd0
| _ZNK4YAML5as_ifIN5aimrt7runtime4core6logger20ConsoleLoggerBackend7OptionsEvEclEv:
push r15
push r14
push rbx; __int64
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
mov rdi, [rsi]
cmp qword ptr [rdi+38h], 0
jz short loc_6B4A5
mov byte ptr [rbx], 1
lea rax, [rbx+18h]
mov [rbx+8], rax
mov dword ptr [rbx+18h], 292A2E28h
mov qword ptr [rbx+10h], 4
xor eax, eax
mov [rbx+1Ch], al
lea rcx, [rbx+38h]
mov [rbx+28h], rcx
mov [rbx+30h], rax
mov [rbx+38h], al
lea rcx, [rbx+58h]
mov [rbx+48h], rcx
mov [rbx+50h], rax
mov [rbx+58h], al
mov rsi, rbx
call _ZN4YAML7convertIN5aimrt7runtime4core6logger20ConsoleLoggerBackend7OptionsEE6decodeERKNS_4NodeERS6_; YAML::convert<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options>::decode(YAML::Node const&,aimrt::runtime::core::logger::ConsoleLoggerBackend::Options&)
test al, al
jz short loc_6B4EB
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
loc_6B4A5:
mov edi, 40h ; '@'; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, [r14]; this
call _ZNK4YAML4Node4MarkEv; YAML::Node::Mark(void)
mov rsi, rsp; int
mov [rsi], rax
mov [rsi+8], edx
mov rdi, rbx; int
call _ZN4YAML13BadConversionC2ERKNS_4MarkE; YAML::BadConversion::BadConversion(YAML::Mark const&)
lea rax, off_AF2D8
mov [rbx], rax
lea rsi, _ZTIN4YAML18TypedBadConversionIN5aimrt7runtime4core6logger20ConsoleLoggerBackend7OptionsEEE; lptinfo
lea rdx, _ZN4YAML9ExceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_6B4EB:
mov edi, 40h ; '@'; thrown_size
call ___cxa_allocate_exception
mov r15, rax
mov rdi, [r14]; this
call _ZNK4YAML4Node4MarkEv; YAML::Node::Mark(void)
mov rsi, rsp; int
mov [rsi], rax
mov [rsi+8], edx
mov rdi, r15; int
call _ZN4YAML13BadConversionC2ERKNS_4MarkE; YAML::BadConversion::BadConversion(YAML::Mark const&)
lea rax, off_AF2D8
mov [r15], rax
lea rsi, _ZTIN4YAML18TypedBadConversionIN5aimrt7runtime4core6logger20ConsoleLoggerBackend7OptionsEEE; lptinfo
lea rdx, _ZN4YAML9ExceptionD2Ev; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp short loc_6B54D
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_6B550
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_6B558
loc_6B54D:
mov r14, rax
loc_6B550:
mov rdi, rbx; this
call _ZN5aimrt7runtime4core6logger20ConsoleLoggerBackend7OptionsD2Ev; aimrt::runtime::core::logger::ConsoleLoggerBackend::Options::~Options()
loc_6B558:
mov rdi, r14
call __Unwind_Resume
| long long YAML::as_if<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options,void>::operator()(
long long a1,
YAML::Node **a2)
{
YAML::Node *v3; // rdi
_QWORD *exception; // rbx
int v6; // edx
_QWORD *v7; // r15
int v8; // edx
long long v9; // [rsp+0h] [rbp-28h] BYREF
int v10; // [rsp+8h] [rbp-20h]
v3 = *a2;
if ( !*((_QWORD *)*a2 + 7) )
{
exception = __cxa_allocate_exception(0x40uLL);
v9 = YAML::Node::Mark(*a2);
v10 = v6;
YAML::BadConversion::BadConversion(exception, (int)&v9);
*exception = &off_AF2D8;
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'YAML::TypedBadConversion<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options>,
YAML::Exception::~Exception);
}
*(_BYTE *)a1 = 1;
*(_QWORD *)(a1 + 8) = a1 + 24;
strcpy((char *)(a1 + 24), "(.*)");
*(_QWORD *)(a1 + 16) = 4LL;
*(_QWORD *)(a1 + 40) = a1 + 56;
*(_QWORD *)(a1 + 48) = 0LL;
*(_BYTE *)(a1 + 56) = 0;
*(_QWORD *)(a1 + 72) = a1 + 88;
*(_QWORD *)(a1 + 80) = 0LL;
*(_BYTE *)(a1 + 88) = 0;
if ( !(unsigned __int8)YAML::convert<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options>::decode(v3, a1) )
{
v7 = __cxa_allocate_exception(0x40uLL);
v9 = YAML::Node::Mark(*a2);
v10 = v8;
YAML::BadConversion::BadConversion(v7, (int)&v9);
*v7 = &off_AF2D8;
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'YAML::TypedBadConversion<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options>,
YAML::Exception::~Exception);
}
return a1;
}
| operator():
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RSI]
CMP qword ptr [RDI + 0x38],0x0
JZ 0x0016b4a5
MOV byte ptr [RBX],0x1
LEA RAX,[RBX + 0x18]
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX + 0x18],0x292a2e28
MOV qword ptr [RBX + 0x10],0x4
XOR EAX,EAX
MOV byte ptr [RBX + 0x1c],AL
LEA RCX,[RBX + 0x38]
MOV qword ptr [RBX + 0x28],RCX
MOV qword ptr [RBX + 0x30],RAX
MOV byte ptr [RBX + 0x38],AL
LEA RCX,[RBX + 0x58]
MOV qword ptr [RBX + 0x48],RCX
MOV qword ptr [RBX + 0x50],RAX
MOV byte ptr [RBX + 0x58],AL
LAB_0016b48c:
MOV RSI,RBX
CALL 0x0016b560
LAB_0016b494:
TEST AL,AL
JZ 0x0016b4eb
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
LAB_0016b4a5:
MOV EDI,0x40
CALL 0x0011e7e0
MOV RBX,RAX
MOV RDI,qword ptr [R14]
LAB_0016b4b5:
CALL 0x00133be0
MOV RSI,RSP
MOV qword ptr [RSI],RAX
MOV dword ptr [RSI + 0x8],EDX
MOV RDI,RBX
CALL 0x00134c84
LAB_0016b4cb:
LEA RAX,[0x1af2d8]
MOV qword ptr [RBX],RAX
LEA RSI,[0x1af2b0]
LEA RDX,[0x180784]
MOV RDI,RBX
CALL 0x0011fec0
LAB_0016b4eb:
MOV EDI,0x40
CALL 0x0011e7e0
MOV R15,RAX
MOV RDI,qword ptr [R14]
LAB_0016b4fb:
CALL 0x00133be0
MOV RSI,RSP
MOV qword ptr [RSI],RAX
MOV dword ptr [RSI + 0x8],EDX
MOV RDI,R15
CALL 0x00134c84
LEA RAX,[0x1af2d8]
MOV qword ptr [R15],RAX
LAB_0016b51b:
LEA RSI,[0x1af2b0]
LEA RDX,[0x180784]
MOV RDI,R15
CALL 0x0011fec0
|
/* YAML::as_if<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options,
void>::TEMPNAMEPLACEHOLDERVALUE() const */
as_if<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options,void> * __thiscall
YAML::as_if<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options,void>::operator()
(as_if<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options,void> *this)
{
Node *pNVar1;
char cVar2;
BadConversion *pBVar3;
int8 *in_RSI;
Mark local_28 [16];
pNVar1 = (Node *)*in_RSI;
if (*(long *)(pNVar1 + 0x38) == 0) {
pBVar3 = (BadConversion *)__cxa_allocate_exception(0x40);
/* try { // try from 0016b4b5 to 0016b4ca has its CatchHandler @ 0016b540 */
local_28._0_12_ = Node::Mark((Node *)*in_RSI);
BadConversion::BadConversion(pBVar3,local_28);
*(int ***)pBVar3 = &PTR__BadInsert_001af2d8;
/* WARNING: Subroutine does not return */
__cxa_throw(pBVar3,&TypedBadConversion<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options>
::typeinfo,BadInsert::~BadInsert);
}
*this = (as_if<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options,void>)0x1;
*(as_if<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options,void> **)(this + 8) =
this + 0x18;
*(int4 *)(this + 0x18) = 0x292a2e28;
*(int8 *)(this + 0x10) = 4;
this[0x1c] = (as_if<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options,void>)0x0;
*(as_if<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options,void> **)(this + 0x28) =
this + 0x38;
*(int8 *)(this + 0x30) = 0;
this[0x38] = (as_if<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options,void>)0x0;
*(as_if<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options,void> **)(this + 0x48) =
this + 0x58;
*(int8 *)(this + 0x50) = 0;
this[0x58] = (as_if<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options,void>)0x0;
/* try { // try from 0016b48c to 0016b493 has its CatchHandler @ 0016b54d */
cVar2 = convert<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options>::decode
(pNVar1,(Options *)this);
if (cVar2 != '\0') {
return this;
}
pBVar3 = (BadConversion *)__cxa_allocate_exception(0x40);
/* try { // try from 0016b4fb to 0016b510 has its CatchHandler @ 0016b533 */
local_28._0_12_ = Node::Mark((Node *)*in_RSI);
BadConversion::BadConversion(pBVar3,local_28);
*(int ***)pBVar3 = &PTR__BadInsert_001af2d8;
/* try { // try from 0016b51b to 0016b530 has its CatchHandler @ 0016b531 */
/* WARNING: Subroutine does not return */
__cxa_throw(pBVar3,&TypedBadConversion<aimrt::runtime::core::logger::ConsoleLoggerBackend::Options>
::typeinfo,BadInsert::~BadInsert);
}
| |
38,191 | delete_prepared_stmt(PFS_prepared_stmt*) | eloqsql/storage/perfschema/pfs_prepared_stmt.cc | void delete_prepared_stmt(PFS_prepared_stmt *pfs)
{
global_prepared_stmt_container.deallocate(pfs);
return;
} | O3 | cpp | delete_prepared_stmt(PFS_prepared_stmt*):
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movl (%rdi), %ecx
andl $-0x4, %ecx
xchgl %ecx, (%rdi)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x381bfe(%rip), %rax # 0x3c5fc0
movb %cl, 0x9(%rax)
popq %rbp
retq
nop
| _Z20delete_prepared_stmtP17PFS_prepared_stmt:
push rbp
mov rbp, rsp
mov rax, [rdi+8]
mov ecx, [rdi]
and ecx, 0FFFFFFFCh
xchg ecx, [rdi]
xor ecx, ecx
mov [rax], cl
lea rax, global_prepared_stmt_container
mov [rax+9], cl
pop rbp
retn
| long long * delete_prepared_stmt(PFS_prepared_stmt *a1)
{
_BYTE *v1; // rax
long long *result; // rax
v1 = (_BYTE *)*((_QWORD *)a1 + 1);
_InterlockedExchange((volatile __int32 *)a1, *(_DWORD *)a1 & 0xFFFFFFFC);
*v1 = 0;
result = global_prepared_stmt_container;
BYTE1(global_prepared_stmt_container[1]) = 0;
return result;
}
| delete_prepared_stmt:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI + 0x8]
MOV ECX,dword ptr [RDI]
AND ECX,0xfffffffc
XCHG dword ptr [RDI],ECX
XOR ECX,ECX
MOV byte ptr [RAX],CL
LEA RAX,[0x4c5fc0]
MOV byte ptr [RAX + 0x9],CL
POP RBP
RET
|
/* delete_prepared_stmt(PFS_prepared_stmt*) */
void delete_prepared_stmt(PFS_prepared_stmt *param_1)
{
LOCK();
*(uint *)param_1 = *(uint *)param_1 & 0xfffffffc;
UNLOCK();
**(int1 **)(param_1 + 8) = 0;
global_prepared_stmt_container[9] = 0;
return;
}
| |
38,192 | minja::Value::operator-(minja::Value const&) const | llama.cpp/common/minja/minja.hpp | Value operator-(const Value& rhs) const {
if (is_number_integer() && rhs.is_number_integer())
return get<int64_t>() - rhs.get<int64_t>();
else
return get<double>() - rhs.get<double>();
} | O3 | cpp | minja::Value::operator-(minja::Value const&) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movb 0x40(%rsi), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0xedc6d
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0xedc6d
movq %rsi, %rdi
callq 0xc23da
movq %rax, %r15
movq %r14, %rdi
callq 0xc23da
subq %rax, %r15
leaq 0x40(%rbx), %r14
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movupd %xmm0, 0x10(%rbx)
movupd %xmm0, 0x20(%rbx)
movupd %xmm0, 0x30(%rbx)
movupd %xmm0, 0x40(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x8c674
jmp 0xedcb9
movq %rsi, %rdi
callq 0xbf594
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0xbf594
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
leaq 0x40(%rbx), %r14
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movupd %xmm0, 0x10(%rbx)
movupd %xmm0, 0x20(%rbx)
movupd %xmm0, 0x30(%rbx)
movupd %xmm0, 0x40(%rbx)
movq %r14, %rdi
movapd %xmm1, %xmm0
callq 0x8bc3c
movq %r14, %rdi
movl $0x1, %esi
callq 0x858ca
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZNK5minja5ValuemiERKS0_:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rdx
mov rbx, rdi
mov al, [rsi+40h]
add al, 0FBh
cmp al, 1
ja short loc_EDC6D
mov al, [r14+40h]
add al, 0FBh
cmp al, 1
ja short loc_EDC6D
mov rdi, rsi
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov r15, rax
mov rdi, r14
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
sub r15, rax
lea r14, [rbx+40h]
xorpd xmm0, xmm0
movupd xmmword ptr [rbx], xmm0
movupd xmmword ptr [rbx+10h], xmm0
movupd xmmword ptr [rbx+20h], xmm0
movupd xmmword ptr [rbx+30h], xmm0
movupd xmmword ptr [rbx+40h], xmm0
mov rdi, r14
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE5EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_16number_integer_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::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>::number_integer_t)
jmp short loc_EDCB9
loc_EDC6D:
mov rdi, rsi
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+28h+var_20], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd xmm1, [rsp+28h+var_20]
subsd xmm1, xmm0
lea r14, [rbx+40h]
xorpd xmm0, xmm0
movupd xmmword ptr [rbx], xmm0
movupd xmmword ptr [rbx+10h], xmm0
movupd xmmword ptr [rbx+20h], xmm0
movupd xmmword ptr [rbx+30h], xmm0
movupd xmmword ptr [rbx+40h], xmm0
mov rdi, r14
movapd xmm0, xmm1
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE7EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_14number_float_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::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>::number_float_t)
loc_EDCB9:
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)
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
| long long minja::Value::operator-(long long a1, long long a2, long long a3)
{
long long v4; // r15
long long v5; // rax
char *v6; // r14
double v7; // xmm0_8
double v9; // [rsp+8h] [rbp-20h]
if ( (unsigned __int8)(*(_BYTE *)(a2 + 64) - 5) > 1u || (unsigned __int8)(*(_BYTE *)(a3 + 64) - 5) > 1u )
{
v9 = minja::Value::get<double>((_QWORD *)a2);
v7 = minja::Value::get<double>((_QWORD *)a3);
v6 = (char *)(a1 + 64);
*(_OWORD *)a1 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<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>>(
(unsigned __int8 *)(a1 + 64),
v9 - v7);
}
else
{
v4 = minja::Value::get<long>((_QWORD *)a2);
v5 = minja::Value::get<long>((_QWORD *)a3);
v6 = (char *)(a1 + 64);
*(_OWORD *)a1 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<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>>(
(unsigned __int8 *)(a1 + 64),
v4 - v5);
}
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(v6);
return a1;
}
| operator-:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RDX
MOV RBX,RDI
MOV AL,byte ptr [RSI + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x001edc6d
MOV AL,byte ptr [R14 + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x001edc6d
MOV RDI,RSI
CALL 0x001c23da
MOV R15,RAX
MOV RDI,R14
CALL 0x001c23da
SUB R15,RAX
LEA R14,[RBX + 0x40]
XORPD XMM0,XMM0
MOVUPD xmmword ptr [RBX],XMM0
MOVUPD xmmword ptr [RBX + 0x10],XMM0
MOVUPD xmmword ptr [RBX + 0x20],XMM0
MOVUPD xmmword ptr [RBX + 0x30],XMM0
MOVUPD xmmword ptr [RBX + 0x40],XMM0
MOV RDI,R14
MOV RSI,R15
CALL 0x0018c674
JMP 0x001edcb9
LAB_001edc6d:
MOV RDI,RSI
CALL 0x001bf594
MOVSD qword ptr [RSP + 0x8],XMM0
MOV RDI,R14
CALL 0x001bf594
MOVSD XMM1,qword ptr [RSP + 0x8]
SUBSD XMM1,XMM0
LEA R14,[RBX + 0x40]
XORPD XMM0,XMM0
MOVUPD xmmword ptr [RBX],XMM0
MOVUPD xmmword ptr [RBX + 0x10],XMM0
MOVUPD xmmword ptr [RBX + 0x20],XMM0
MOVUPD xmmword ptr [RBX + 0x30],XMM0
MOVUPD xmmword ptr [RBX + 0x40],XMM0
MOV RDI,R14
MOVAPD XMM0,XMM1
CALL 0x0018bc3c
LAB_001edcb9:
MOV RDI,R14
MOV ESI,0x1
CALL 0x001858ca
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
Value * __thiscall minja::Value::operator-(Value *this,Value *param_1)
{
long lVar1;
long lVar2;
Value *in_RDX;
double dVar3;
double dVar4;
if (((byte)((char)param_1[0x40] - 5U) < 2) && ((byte)((char)in_RDX[0x40] - 5U) < 2)) {
lVar1 = get<long>(param_1);
lVar2 = get<long>(in_RDX);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::
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,lVar1 - lVar2);
}
else {
dVar3 = get<double>(param_1);
dVar4 = get<double>(in_RDX);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::
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>>
(dVar3 - dVar4,this + 0x40);
}
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 + '@'));
return this;
}
| |
38,193 | js_std_file_get | bluesky950520[P]quickjs/quickjs-libc.c | static FILE *js_std_file_get(JSContext *ctx, JSValue obj)
{
JSRuntime *rt = JS_GetRuntime(ctx);
JSThreadState *ts = js_get_thread_state(rt);
JSSTDFile *s = JS_GetOpaque2(ctx, obj, ts->std_file_class_id);
if (!s)
return NULL;
if (!s->f) {
JS_ThrowTypeError(ctx, "invalid file handle");
return NULL;
}
return s->f;
} | O0 | c | js_std_file_get:
subq $0x48, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2e1f0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x178c0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x78(%rax), %ecx
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x3e6a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x19dd5
movq $0x0, 0x40(%rsp)
jmp 0x19e14
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x19e07
movq 0x28(%rsp), %rdi
leaq 0xf6090(%rip), %rsi # 0x10fe7c
movb $0x0, %al
callq 0x335f0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq $0x0, 0x40(%rsp)
jmp 0x19e14
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
| js_std_file_get:
sub rsp, 48h
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_10], rdx
mov [rsp+48h+var_20], rdi
mov rdi, [rsp+48h+var_20]
call JS_GetRuntime
mov [rsp+48h+var_28], rax
mov rdi, [rsp+48h+var_28]
call js_get_thread_state
mov [rsp+48h+var_30], rax
mov rdi, [rsp+48h+var_20]
mov rax, [rsp+48h+var_30]
mov ecx, [rax+78h]
mov rsi, [rsp+48h+var_18]
mov rdx, [rsp+48h+var_10]
call JS_GetOpaque2
mov [rsp+48h+var_38], rax
cmp [rsp+48h+var_38], 0
jnz short loc_19DD5
mov [rsp+48h+var_8], 0
jmp short loc_19E14
loc_19DD5:
mov rax, [rsp+48h+var_38]
cmp qword ptr [rax], 0
jnz short loc_19E07
mov rdi, [rsp+48h+var_20]
lea rsi, aInvalidFileHan; "invalid file handle"
mov al, 0
call JS_ThrowTypeError
mov [rsp+48h+var_48], rax
mov [rsp+48h+var_40], rdx
mov [rsp+48h+var_8], 0
jmp short loc_19E14
loc_19E07:
mov rax, [rsp+48h+var_38]
mov rax, [rax]
mov [rsp+48h+var_8], rax
loc_19E14:
mov rax, [rsp+48h+var_8]
add rsp, 48h
retn
| long long js_std_file_get(long long a1, long long a2, long long a3)
{
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
long long Opaque2; // [rsp+10h] [rbp-38h]
long long thread_state; // [rsp+18h] [rbp-30h]
int Runtime; // [rsp+20h] [rbp-28h]
Runtime = JS_GetRuntime(a1);
thread_state = js_get_thread_state(Runtime, a2, v3, v4, v5, v6);
Opaque2 = JS_GetOpaque2(a1, a2, a3, *(unsigned int *)(thread_state + 120));
if ( !Opaque2 )
return 0LL;
if ( *(_QWORD *)Opaque2 )
return *(_QWORD *)Opaque2;
JS_ThrowTypeError(a1, (unsigned int)"invalid file handle", v7, v8, v9, v10);
return 0LL;
}
| js_std_file_get:
SUB RSP,0x48
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x28],RDI
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0012e1f0
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x001178c0
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x18]
MOV ECX,dword ptr [RAX + 0x78]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x0013e6a0
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x00119dd5
MOV qword ptr [RSP + 0x40],0x0
JMP 0x00119e14
LAB_00119dd5:
MOV RAX,qword ptr [RSP + 0x10]
CMP qword ptr [RAX],0x0
JNZ 0x00119e07
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[0x20fe7c]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP + 0x40],0x0
JMP 0x00119e14
LAB_00119e07:
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x40],RAX
LAB_00119e14:
MOV RAX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
long js_std_file_get(int8 param_1,int8 param_2,int8 param_3)
{
int8 uVar1;
long lVar2;
long *plVar3;
long local_8;
uVar1 = JS_GetRuntime(param_1);
lVar2 = js_get_thread_state(uVar1);
plVar3 = (long *)JS_GetOpaque2(param_1,param_2,param_3,*(int4 *)(lVar2 + 0x78));
if (plVar3 == (long *)0x0) {
local_8 = 0;
}
else if (*plVar3 == 0) {
JS_ThrowTypeError(param_1,"invalid file handle");
local_8 = 0;
}
else {
local_8 = *plVar3;
}
return local_8;
}
| |
38,194 | js_std_file_get | bluesky950520[P]quickjs/quickjs-libc.c | static FILE *js_std_file_get(JSContext *ctx, JSValue obj)
{
JSRuntime *rt = JS_GetRuntime(ctx);
JSThreadState *ts = js_get_thread_state(rt);
JSSTDFile *s = JS_GetOpaque2(ctx, obj, ts->std_file_class_id);
if (!s)
return NULL;
if (!s->f) {
JS_ThrowTypeError(ctx, "invalid file handle");
return NULL;
}
return s->f;
} | O2 | c | js_std_file_get:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1dd35
movq %rax, %rdi
callq 0x13e3a
movl 0x78(%rax), %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x24db7
testq %rax, %rax
je 0x14fc5
movq (%rax), %r14
testq %r14, %r14
jne 0x14fc8
leaq 0x70dba(%rip), %rsi # 0x85d70
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x201fd
jmp 0x14fc8
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| js_std_file_get:
push r15
push r14
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
call JS_GetRuntime
mov rdi, rax
call js_get_thread_state
mov ecx, [rax+78h]
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_GetOpaque2
test rax, rax
jz short loc_14FC5
mov r14, [rax]
test r14, r14
jnz short loc_14FC8
lea rsi, aInvalidFileHan; "invalid file handle"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
jmp short loc_14FC8
loc_14FC5:
xor r14d, r14d
loc_14FC8:
mov rax, r14
pop rbx
pop r14
pop r15
retn
| long long js_std_file_get(long long a1, long long a2, long long a3)
{
int Runtime; // eax
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
long long thread_state; // rax
long long *Opaque2; // rax
int v11; // edx
int v12; // ecx
int v13; // r8d
int v14; // r9d
long long v15; // r14
char v17; // [rsp+0h] [rbp-18h]
Runtime = JS_GetRuntime(a1);
thread_state = js_get_thread_state(Runtime, a2, v5, v6, v7, v8, v17);
Opaque2 = (long long *)JS_GetOpaque2(a1, a2, a3, *(unsigned int *)(thread_state + 120));
if ( !Opaque2 )
return 0LL;
v15 = *Opaque2;
if ( !*Opaque2 )
{
v15 = 0LL;
JS_ThrowTypeError(a1, (unsigned int)"invalid file handle", v11, v12, v13, v14);
}
return v15;
}
| js_std_file_get:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
CALL 0x0011dd35
MOV RDI,RAX
CALL 0x00113e3a
MOV ECX,dword ptr [RAX + 0x78]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x00124db7
TEST RAX,RAX
JZ 0x00114fc5
MOV R14,qword ptr [RAX]
TEST R14,R14
JNZ 0x00114fc8
LEA RSI,[0x185d70]
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x001201fd
JMP 0x00114fc8
LAB_00114fc5:
XOR R14D,R14D
LAB_00114fc8:
MOV RAX,R14
POP RBX
POP R14
POP R15
RET
|
long js_std_file_get(int8 param_1,int8 param_2,int8 param_3)
{
int8 uVar1;
long lVar2;
long *plVar3;
uVar1 = JS_GetRuntime();
lVar2 = js_get_thread_state(uVar1);
plVar3 = (long *)JS_GetOpaque2(param_1,param_2,param_3,*(int4 *)(lVar2 + 0x78));
if (plVar3 == (long *)0x0) {
lVar2 = 0;
}
else {
lVar2 = *plVar3;
if (lVar2 == 0) {
lVar2 = 0;
JS_ThrowTypeError(param_1,"invalid file handle");
}
}
return lVar2;
}
| |
38,195 | js_callsite_isnative | bluesky950520[P]quickjs/quickjs.c | static JSValue js_callsite_isnative(JSContext *ctx, JSValue this_val, int argc, JSValue *argv)
{
JSCallSiteData *csd = JS_GetOpaque2(ctx, this_val, JS_CLASS_CALL_SITE);
if (!csd)
return JS_EXCEPTION;
return JS_NewBool(ctx, csd->native);
} | O0 | c | js_callsite_isnative:
subq $0x68, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl $0x3c, %ecx
callq 0x3e6a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xec015
movl $0x0, 0x38(%rsp)
movq $0x6, 0x40(%rsp)
jmp 0xec058
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movl 0x30(%rax), %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
testl %eax, %eax
setne %al
movzbl %al, %eax
movl %eax, 0x58(%rsp)
movq $0x1, 0x60(%rsp)
movq 0x58(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x68, %rsp
retq
nopw (%rax,%rax)
| js_callsite_isnative:
sub rsp, 68h
mov [rsp+68h+var_40], rsi
mov [rsp+68h+var_38], rdx
mov [rsp+68h+var_48], rdi
mov [rsp+68h+var_4C], ecx
mov [rsp+68h+var_58], r8
mov rdi, [rsp+68h+var_48]
mov rsi, [rsp+68h+var_40]
mov rdx, [rsp+68h+var_38]
mov ecx, 3Ch ; '<'
call JS_GetOpaque2
mov [rsp+68h+var_60], rax
cmp [rsp+68h+var_60], 0
jnz short loc_EC015
mov dword ptr [rsp+68h+var_30], 0
mov [rsp+68h+var_28], 6
jmp short loc_EC058
loc_EC015:
mov rcx, [rsp+68h+var_48]
mov rax, [rsp+68h+var_60]
mov eax, [rax+30h]
mov [rsp+68h+var_18], rcx
mov [rsp+68h+var_1C], eax
mov eax, [rsp+68h+var_1C]
test eax, eax
setnz al
movzx eax, al
mov dword ptr [rsp+68h+var_10], eax
mov [rsp+68h+var_8], 1
mov rcx, [rsp+68h+var_10]
mov rax, [rsp+68h+var_8]
mov [rsp+68h+var_30], rcx
mov [rsp+68h+var_28], rax
loc_EC058:
mov rax, [rsp+68h+var_30]
mov rdx, [rsp+68h+var_28]
add rsp, 68h
retn
| long long js_callsite_isnative(long long a1, long long a2, int a3)
{
long long Opaque2; // [rsp+8h] [rbp-60h]
long long v5; // [rsp+38h] [rbp-30h]
long long v6; // [rsp+58h] [rbp-10h]
Opaque2 = JS_GetOpaque2(a1, a2, a3, 0x3Cu);
if ( Opaque2 )
{
LODWORD(v6) = *(_DWORD *)(Opaque2 + 48) != 0;
return v6;
}
else
{
LODWORD(v5) = 0;
}
return v5;
}
| js_callsite_isnative:
SUB RSP,0x68
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ECX
MOV qword ptr [RSP + 0x10],R8
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
MOV ECX,0x3c
CALL 0x0013e6a0
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x001ec015
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x6
JMP 0x001ec058
LAB_001ec015:
MOV RCX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x50],RCX
MOV dword ptr [RSP + 0x4c],EAX
MOV EAX,dword ptr [RSP + 0x4c]
TEST EAX,EAX
SETNZ AL
MOVZX EAX,AL
MOV dword ptr [RSP + 0x58],EAX
MOV qword ptr [RSP + 0x60],0x1
MOV RCX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x40],RAX
LAB_001ec058:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x68
RET
|
int1 [16] js_callsite_isnative(int8 param_1,int8 param_2,int8 param_3)
{
int1 auVar1 [16];
long lVar2;
int4 local_30;
int4 uStack_2c;
int8 local_28;
int4 uStack_c;
lVar2 = JS_GetOpaque2(param_1,param_2,param_3,0x3c);
if (lVar2 == 0) {
local_30 = 0;
local_28 = 6;
}
else {
local_30 = (uint)(*(int *)(lVar2 + 0x30) != 0);
uStack_2c = uStack_c;
local_28 = 1;
}
auVar1._4_4_ = uStack_2c;
auVar1._0_4_ = local_30;
auVar1._8_8_ = local_28;
return auVar1;
}
| |
38,196 | PFS_memory_stat::partial_aggregate_to(PFS_memory_stat*, PFS_memory_stat*) | eloqsql/storage/perfschema/pfs_stat.h | inline void partial_aggregate_to(PFS_memory_stat *stat1, PFS_memory_stat *stat2)
{
if (! m_used)
return;
size_t base;
stat1->m_used= true;
stat2->m_used= true;
base= std::min<size_t>(m_alloc_count, m_free_count);
if (base != 0)
{
stat1->m_alloc_count+= base;
stat2->m_alloc_count+= base;
stat1->m_free_count+= base;
stat2->m_free_count+= base;
m_alloc_count-= base;
m_free_count-= base;
}
base= std::min<size_t>(m_alloc_size, m_free_size);
if (base != 0)
{
stat1->m_alloc_size+= base;
stat2->m_alloc_size+= base;
stat1->m_free_size+= base;
stat2->m_free_size+= base;
m_alloc_size-= base;
m_free_size-= base;
}
stat1->m_alloc_count_capacity+= m_alloc_count_capacity;
stat2->m_alloc_count_capacity+= m_alloc_count_capacity;
stat1->m_free_count_capacity+= m_free_count_capacity;
stat2->m_free_count_capacity+= m_free_count_capacity;
stat1->m_alloc_size_capacity+= m_alloc_size_capacity;
stat2->m_alloc_size_capacity+= m_alloc_size_capacity;
stat1->m_free_size_capacity+= m_free_size_capacity;
stat2->m_free_size_capacity+= m_free_size_capacity;
m_alloc_count_capacity= 0;
m_free_count_capacity= 0;
m_alloc_size_capacity= 0;
m_free_size_capacity= 0;
} | O0 | c | PFS_memory_stat::partial_aggregate_to(PFS_memory_stat*, PFS_memory_stat*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, (%rax)
jne 0x414b6
jmp 0x41670
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x10, %rsi
callq 0x42000
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x41548
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rcx)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rcx)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rcx)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rcx)
movq -0x20(%rbp), %rdx
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdx
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rsi
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x20, %rsi
callq 0x42000
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x415cc
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rcx)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rcx)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq 0x20(%rcx), %rdx
movq %rdx, 0x20(%rcx)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq 0x20(%rcx), %rdx
movq %rdx, 0x20(%rcx)
movq -0x20(%rbp), %rdx
movq 0x18(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdx
movq 0x20(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x10(%rbp), %rcx
addq 0x28(%rcx), %rdx
movq %rdx, 0x28(%rcx)
movq 0x28(%rax), %rdx
movq -0x18(%rbp), %rcx
addq 0x28(%rcx), %rdx
movq %rdx, 0x28(%rcx)
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rcx
addq 0x30(%rcx), %rdx
movq %rdx, 0x30(%rcx)
movq 0x30(%rax), %rdx
movq -0x18(%rbp), %rcx
addq 0x30(%rcx), %rdx
movq %rdx, 0x30(%rcx)
movq 0x38(%rax), %rdx
movq -0x10(%rbp), %rcx
addq 0x38(%rcx), %rdx
movq %rdx, 0x38(%rcx)
movq 0x38(%rax), %rdx
movq -0x18(%rbp), %rcx
addq 0x38(%rcx), %rdx
movq %rdx, 0x38(%rcx)
movq 0x40(%rax), %rdx
movq -0x10(%rbp), %rcx
addq 0x40(%rcx), %rdx
movq %rdx, 0x40(%rcx)
movq 0x40(%rax), %rdx
movq -0x18(%rbp), %rcx
addq 0x40(%rcx), %rdx
movq %rdx, 0x40(%rcx)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN15PFS_memory_stat20partial_aggregate_toEPS_S0_:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
test byte ptr [rax], 1
jnz short loc_414B6
jmp loc_41670
loc_414B6:
mov rsi, [rbp+var_28]
mov rax, [rbp+var_10]
mov byte ptr [rax], 1
mov rax, [rbp+var_18]
mov byte ptr [rax], 1
mov rdi, rsi
add rdi, 8
add rsi, 10h
call _ZSt3minImERKT_S2_S2_; std::min<ulong>(ulong const&,ulong const&)
mov rax, [rax]
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_41548
mov rax, [rbp+var_28]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_10]
add rdx, [rcx+8]
mov [rcx+8], rdx
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_18]
add rdx, [rcx+8]
mov [rcx+8], rdx
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_10]
add rdx, [rcx+10h]
mov [rcx+10h], rdx
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_18]
add rdx, [rcx+10h]
mov [rcx+10h], rdx
mov rdx, [rbp+var_20]
mov rcx, [rax+8]
sub rcx, rdx
mov [rax+8], rcx
mov rdx, [rbp+var_20]
mov rcx, [rax+10h]
sub rcx, rdx
mov [rax+10h], rcx
loc_41548:
mov rsi, [rbp+var_28]
mov rdi, rsi
add rdi, 18h
add rsi, 20h ; ' '
call _ZSt3minImERKT_S2_S2_; std::min<ulong>(ulong const&,ulong const&)
mov rax, [rax]
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_415CC
mov rax, [rbp+var_28]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_10]
add rdx, [rcx+18h]
mov [rcx+18h], rdx
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_18]
add rdx, [rcx+18h]
mov [rcx+18h], rdx
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_10]
add rdx, [rcx+20h]
mov [rcx+20h], rdx
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_18]
add rdx, [rcx+20h]
mov [rcx+20h], rdx
mov rdx, [rbp+var_20]
mov rcx, [rax+18h]
sub rcx, rdx
mov [rax+18h], rcx
mov rdx, [rbp+var_20]
mov rcx, [rax+20h]
sub rcx, rdx
mov [rax+20h], rcx
loc_415CC:
mov rax, [rbp+var_28]
mov rdx, [rax+28h]
mov rcx, [rbp+var_10]
add rdx, [rcx+28h]
mov [rcx+28h], rdx
mov rdx, [rax+28h]
mov rcx, [rbp+var_18]
add rdx, [rcx+28h]
mov [rcx+28h], rdx
mov rdx, [rax+30h]
mov rcx, [rbp+var_10]
add rdx, [rcx+30h]
mov [rcx+30h], rdx
mov rdx, [rax+30h]
mov rcx, [rbp+var_18]
add rdx, [rcx+30h]
mov [rcx+30h], rdx
mov rdx, [rax+38h]
mov rcx, [rbp+var_10]
add rdx, [rcx+38h]
mov [rcx+38h], rdx
mov rdx, [rax+38h]
mov rcx, [rbp+var_18]
add rdx, [rcx+38h]
mov [rcx+38h], rdx
mov rdx, [rax+40h]
mov rcx, [rbp+var_10]
add rdx, [rcx+40h]
mov [rcx+40h], rdx
mov rdx, [rax+40h]
mov rcx, [rbp+var_18]
add rdx, [rcx+40h]
mov [rcx+40h], rdx
mov qword ptr [rax+28h], 0
mov qword ptr [rax+30h], 0
mov qword ptr [rax+38h], 0
mov qword ptr [rax+40h], 0
loc_41670:
add rsp, 30h
pop rbp
retn
| PFS_memory_stat * PFS_memory_stat::partial_aggregate_to(
PFS_memory_stat *this,
PFS_memory_stat *a2,
PFS_memory_stat *a3)
{
PFS_memory_stat *result; // rax
long long v4; // [rsp+10h] [rbp-20h]
long long v5; // [rsp+10h] [rbp-20h]
result = this;
if ( (*(_BYTE *)this & 1) != 0 )
{
*(_BYTE *)a2 = 1;
*(_BYTE *)a3 = 1;
v4 = *(_QWORD *)std::min<unsigned long>((char *)this + 8, (char *)this + 16);
if ( v4 )
{
*((_QWORD *)a2 + 1) += v4;
*((_QWORD *)a3 + 1) += v4;
*((_QWORD *)a2 + 2) += v4;
*((_QWORD *)a3 + 2) += v4;
*((_QWORD *)this + 1) -= v4;
*((_QWORD *)this + 2) -= v4;
}
v5 = *(_QWORD *)std::min<unsigned long>((char *)this + 24, (char *)this + 32);
if ( v5 )
{
*((_QWORD *)a2 + 3) += v5;
*((_QWORD *)a3 + 3) += v5;
*((_QWORD *)a2 + 4) += v5;
*((_QWORD *)a3 + 4) += v5;
*((_QWORD *)this + 3) -= v5;
*((_QWORD *)this + 4) -= v5;
}
result = this;
*((_QWORD *)a2 + 5) += *((_QWORD *)this + 5);
*((_QWORD *)a3 + 5) += *((_QWORD *)this + 5);
*((_QWORD *)a2 + 6) += *((_QWORD *)this + 6);
*((_QWORD *)a3 + 6) += *((_QWORD *)this + 6);
*((_QWORD *)a2 + 7) += *((_QWORD *)this + 7);
*((_QWORD *)a3 + 7) += *((_QWORD *)this + 7);
*((_QWORD *)a2 + 8) += *((_QWORD *)this + 8);
*((_QWORD *)a3 + 8) += *((_QWORD *)this + 8);
*((_QWORD *)this + 5) = 0LL;
*((_QWORD *)this + 6) = 0LL;
*((_QWORD *)this + 7) = 0LL;
*((_QWORD *)this + 8) = 0LL;
}
return result;
}
| partial_aggregate_to:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
TEST byte ptr [RAX],0x1
JNZ 0x001414b6
JMP 0x00141670
LAB_001414b6:
MOV RSI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x1
MOV RDI,RSI
ADD RDI,0x8
ADD RSI,0x10
CALL 0x00142000
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00141548
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RCX + 0x8]
MOV qword ptr [RCX + 0x8],RDX
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
ADD RDX,qword ptr [RCX + 0x8]
MOV qword ptr [RCX + 0x8],RDX
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RCX + 0x10]
MOV qword ptr [RCX + 0x10],RDX
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
ADD RDX,qword ptr [RCX + 0x10]
MOV qword ptr [RCX + 0x10],RDX
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x8]
SUB RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,RDX
MOV qword ptr [RAX + 0x10],RCX
LAB_00141548:
MOV RSI,qword ptr [RBP + -0x28]
MOV RDI,RSI
ADD RDI,0x18
ADD RSI,0x20
CALL 0x00142000
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001415cc
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RCX + 0x18]
MOV qword ptr [RCX + 0x18],RDX
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
ADD RDX,qword ptr [RCX + 0x18]
MOV qword ptr [RCX + 0x18],RDX
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RCX + 0x20]
MOV qword ptr [RCX + 0x20],RDX
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
ADD RDX,qword ptr [RCX + 0x20]
MOV qword ptr [RCX + 0x20],RDX
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x18]
SUB RCX,RDX
MOV qword ptr [RAX + 0x18],RCX
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x20]
SUB RCX,RDX
MOV qword ptr [RAX + 0x20],RCX
LAB_001415cc:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RCX + 0x28]
MOV qword ptr [RCX + 0x28],RDX
MOV RDX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x18]
ADD RDX,qword ptr [RCX + 0x28]
MOV qword ptr [RCX + 0x28],RDX
MOV RDX,qword ptr [RAX + 0x30]
MOV RCX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RCX + 0x30]
MOV qword ptr [RCX + 0x30],RDX
MOV RDX,qword ptr [RAX + 0x30]
MOV RCX,qword ptr [RBP + -0x18]
ADD RDX,qword ptr [RCX + 0x30]
MOV qword ptr [RCX + 0x30],RDX
MOV RDX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RCX + 0x38]
MOV qword ptr [RCX + 0x38],RDX
MOV RDX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RBP + -0x18]
ADD RDX,qword ptr [RCX + 0x38]
MOV qword ptr [RCX + 0x38],RDX
MOV RDX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RCX + 0x40]
MOV qword ptr [RCX + 0x40],RDX
MOV RDX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x18]
ADD RDX,qword ptr [RCX + 0x40]
MOV qword ptr [RCX + 0x40],RDX
MOV qword ptr [RAX + 0x28],0x0
MOV qword ptr [RAX + 0x30],0x0
MOV qword ptr [RAX + 0x38],0x0
MOV qword ptr [RAX + 0x40],0x0
LAB_00141670:
ADD RSP,0x30
POP RBP
RET
|
/* PFS_memory_stat::partial_aggregate_to(PFS_memory_stat*, PFS_memory_stat*) */
void __thiscall
PFS_memory_stat::partial_aggregate_to
(PFS_memory_stat *this,PFS_memory_stat *param_1,PFS_memory_stat *param_2)
{
ulong uVar1;
ulong *puVar2;
if (((byte)*this & 1) != 0) {
*param_1 = (PFS_memory_stat)0x1;
*param_2 = (PFS_memory_stat)0x1;
puVar2 = std::min<unsigned_long>((ulong *)(this + 8),(ulong *)(this + 0x10));
uVar1 = *puVar2;
if (uVar1 != 0) {
*(ulong *)(param_1 + 8) = uVar1 + *(long *)(param_1 + 8);
*(ulong *)(param_2 + 8) = uVar1 + *(long *)(param_2 + 8);
*(ulong *)(param_1 + 0x10) = uVar1 + *(long *)(param_1 + 0x10);
*(ulong *)(param_2 + 0x10) = uVar1 + *(long *)(param_2 + 0x10);
*(ulong *)(this + 8) = *(long *)(this + 8) - uVar1;
*(ulong *)(this + 0x10) = *(long *)(this + 0x10) - uVar1;
}
puVar2 = std::min<unsigned_long>((ulong *)(this + 0x18),(ulong *)(this + 0x20));
uVar1 = *puVar2;
if (uVar1 != 0) {
*(ulong *)(param_1 + 0x18) = uVar1 + *(long *)(param_1 + 0x18);
*(ulong *)(param_2 + 0x18) = uVar1 + *(long *)(param_2 + 0x18);
*(ulong *)(param_1 + 0x20) = uVar1 + *(long *)(param_1 + 0x20);
*(ulong *)(param_2 + 0x20) = uVar1 + *(long *)(param_2 + 0x20);
*(ulong *)(this + 0x18) = *(long *)(this + 0x18) - uVar1;
*(ulong *)(this + 0x20) = *(long *)(this + 0x20) - uVar1;
}
*(long *)(param_1 + 0x28) = *(long *)(this + 0x28) + *(long *)(param_1 + 0x28);
*(long *)(param_2 + 0x28) = *(long *)(this + 0x28) + *(long *)(param_2 + 0x28);
*(long *)(param_1 + 0x30) = *(long *)(this + 0x30) + *(long *)(param_1 + 0x30);
*(long *)(param_2 + 0x30) = *(long *)(this + 0x30) + *(long *)(param_2 + 0x30);
*(long *)(param_1 + 0x38) = *(long *)(this + 0x38) + *(long *)(param_1 + 0x38);
*(long *)(param_2 + 0x38) = *(long *)(this + 0x38) + *(long *)(param_2 + 0x38);
*(long *)(param_1 + 0x40) = *(long *)(this + 0x40) + *(long *)(param_1 + 0x40);
*(long *)(param_2 + 0x40) = *(long *)(this + 0x40) + *(long *)(param_2 + 0x40);
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
}
return;
}
| |
38,197 | LefDefParser::defwStartPins(int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp | int
defwStartPins(int count)
{
defwFunc = DEFW_PIN_START; // Current function of writer
if (!defwFile)
return DEFW_UNINITIALIZED;
if (!defwDidComponents)
return DEFW_BAD_ORDER;
if ((defwState >= DEFW_PIN_START) && (defwState <= DEFW_PIN_END))
return DEFW_BAD_ORDER;
fprintf(defwFile, "PINS %d", count);
defwLines++;
defwCounter = count;
defwState = DEFW_PIN_START;
return DEFW_OK;
} | O3 | cpp | LefDefParser::defwStartPins(int):
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x13c9c(%rip), %rax # 0x1e178
movl $0x24, (%rax)
leaq 0x13c7f(%rip), %rax # 0x1e168
movq (%rax), %rdi
testq %rdi, %rdi
je 0xa541
leaq 0x13c88(%rip), %rax # 0x1e180
movl $0x2, %ebp
cmpl $0x0, (%rax)
je 0xa546
leaq 0x13c6b(%rip), %r14 # 0x1e174
movl (%r14), %eax
andl $-0x4, %eax
cmpl $0x24, %eax
je 0xa546
leaq 0xb1f6(%rip), %rsi # 0x15711
xorl %ebp, %ebp
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
leaq 0x13c43(%rip), %rax # 0x1e170
incl (%rax)
leaq 0x13c52(%rip), %rax # 0x1e188
movl %ebx, (%rax)
movl $0x24, (%r14)
jmp 0xa546
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| _ZN12LefDefParser13defwStartPinsEi:
push rbp
push r14
push rbx
mov ebx, edi
lea rax, _ZN12LefDefParser8defwFuncE; LefDefParser::defwFunc
mov dword ptr [rax], 24h ; '$'
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
test rdi, rdi
jz short loc_A541
lea rax, _ZN12LefDefParser17defwDidComponentsE; LefDefParser::defwDidComponents
mov ebp, 2
cmp dword ptr [rax], 0
jz short loc_A546
lea r14, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov eax, [r14]
and eax, 0FFFFFFFCh
cmp eax, 24h ; '$'
jz short loc_A546
lea rsi, aPinsD; "PINS %d"
xor ebp, ebp
mov edx, ebx
xor eax, eax
call _fprintf
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
inc dword ptr [rax]
lea rax, _ZN12LefDefParser11defwCounterE; LefDefParser::defwCounter
mov [rax], ebx
mov dword ptr [r14], 24h ; '$'
jmp short loc_A546
loc_A541:
mov ebp, 1
loc_A546:
mov eax, ebp
pop rbx
pop r14
pop rbp
retn
| long long LefDefParser::defwStartPins(LefDefParser *this)
{
unsigned int v1; // ebp
LefDefParser::defwFunc = 36;
if ( LefDefParser::defwFile )
{
v1 = 2;
if ( LefDefParser::defwDidComponents && (LefDefParser::defwState & 0xFFFFFFFC) != 0x24 )
{
v1 = 0;
fprintf(LefDefParser::defwFile, "PINS %d", (_DWORD)this);
++LefDefParser::defwLines;
LefDefParser::defwCounter = (_DWORD)this;
LefDefParser::defwState = 36;
}
}
else
{
return 1;
}
return v1;
}
| defwStartPins:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBX,EDI
LEA RAX,[0x11e178]
MOV dword ptr [RAX],0x24
LEA RAX,[0x11e168]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x0010a541
LEA RAX,[0x11e180]
MOV EBP,0x2
CMP dword ptr [RAX],0x0
JZ 0x0010a546
LEA R14,[0x11e174]
MOV EAX,dword ptr [R14]
AND EAX,0xfffffffc
CMP EAX,0x24
JZ 0x0010a546
LEA RSI,[0x115711]
XOR EBP,EBP
MOV EDX,EBX
XOR EAX,EAX
CALL 0x001010e0
LEA RAX,[0x11e170]
INC dword ptr [RAX]
LEA RAX,[0x11e188]
MOV dword ptr [RAX],EBX
MOV dword ptr [R14],0x24
JMP 0x0010a546
LAB_0010a541:
MOV EBP,0x1
LAB_0010a546:
MOV EAX,EBP
POP RBX
POP R14
POP RBP
RET
|
/* LefDefParser::defwStartPins(int) */
int8 LefDefParser::defwStartPins(int param_1)
{
int8 uVar1;
defwFunc = 0x24;
if (defwFile == (FILE *)0x0) {
uVar1 = 1;
}
else {
uVar1 = 2;
if ((defwDidComponents != 0) && ((defwState & 0xfffffffc) != 0x24)) {
uVar1 = 0;
fprintf(defwFile,"PINS %d",param_1);
defwLines = defwLines + 1;
defwState = 0x24;
defwCounter = param_1;
}
}
return uVar1;
}
| |
38,198 | net_get_error | eloqsql/libmariadb/libmariadb/mariadb_lib.c | void net_get_error(char *buf, size_t buf_len,
char *error, size_t error_len,
unsigned int *error_no,
char *sqlstate)
{
char *p= buf;
size_t error_msg_len= 0;
if (buf_len > 2)
{
*error_no= uint2korr(p);
p+= 2;
/* since 4.1 sqlstate is following */
if (*p == '#')
{
memcpy(sqlstate, ++p, SQLSTATE_LENGTH);
p+= SQLSTATE_LENGTH;
}
error_msg_len= buf_len - (p - buf);
error_msg_len= MIN(error_msg_len, error_len - 1);
memcpy(error, p, error_msg_len);
}
else
{
*error_no= CR_UNKNOWN_ERROR;
memcpy(sqlstate, SQLSTATE_UNKNOWN, SQLSTATE_LENGTH);
}
} | O3 | c | net_get_error:
pushq %rbp
movq %rsp, %rbp
cmpq $0x3, %rsi
jb 0x26ba9
movzwl (%rdi), %eax
movl %eax, (%r8)
cmpb $0x23, 0x2(%rdi)
jne 0x26bc8
movb 0x7(%rdi), %al
movb %al, 0x4(%r9)
movl 0x3(%rdi), %eax
movl %eax, (%r9)
leaq 0x8(%rdi), %rax
jmp 0x26bcc
movl $0x7d0, (%r8) # imm = 0x7D0
leaq 0x3be39(%rip), %rax # 0x629f0
movq (%rax), %rax
movb 0x4(%rax), %cl
movb %cl, 0x4(%r9)
movl (%rax), %eax
movl %eax, (%r9)
popq %rbp
retq
leaq 0x2(%rdi), %rax
addq %rsi, %rdi
subq %rax, %rdi
decq %rcx
cmpq %rcx, %rdi
cmovbq %rdi, %rcx
movq %rdx, %rdi
movq %rax, %rsi
movq %rcx, %rdx
popq %rbp
jmp 0x143a0
| net_get_error:
push rbp
mov rbp, rsp
cmp rsi, 3
jb short loc_26BA9
movzx eax, word ptr [rdi]
mov [r8], eax
cmp byte ptr [rdi+2], 23h ; '#'
jnz short loc_26BC8
mov al, [rdi+7]
mov [r9+4], al
mov eax, [rdi+3]
mov [r9], eax
lea rax, [rdi+8]
jmp short loc_26BCC
loc_26BA9:
mov dword ptr [r8], 7D0h
lea rax, SQLSTATE_UNKNOWN
mov rax, [rax]
mov cl, [rax+4]
mov [r9+4], cl
mov eax, [rax]
mov [r9], eax
pop rbp
retn
loc_26BC8:
lea rax, [rdi+2]
loc_26BCC:
add rdi, rsi
sub rdi, rax
dec rcx
cmp rdi, rcx
cmovb rcx, rdi
mov rdi, rdx
mov rsi, rax
mov rdx, rcx
pop rbp
jmp _memcpy
| long long net_get_error(
unsigned __int16 *a1,
unsigned long long a2,
long long a3,
long long a4,
_DWORD *a5,
long long a6)
{
unsigned __int16 *v6; // rax
char *v7; // rax
long long result; // rax
char *v9; // rdi
char *v10; // rcx
if ( a2 < 3 )
{
*a5 = 2000;
v7 = SQLSTATE_UNKNOWN;
*(_BYTE *)(a6 + 4) = SQLSTATE_UNKNOWN[4];
result = *(unsigned int *)v7;
*(_DWORD *)a6 = result;
}
else
{
*a5 = *a1;
if ( *((_BYTE *)a1 + 2) == 35 )
{
*(_BYTE *)(a6 + 4) = *((_BYTE *)a1 + 7);
*(_DWORD *)a6 = *(_DWORD *)((char *)a1 + 3);
v6 = a1 + 4;
}
else
{
v6 = a1 + 1;
}
v9 = (char *)((char *)a1 + a2 - (char *)v6);
v10 = (char *)(a4 - 1);
if ( v9 < v10 )
v10 = v9;
return memcpy(a3, v6, v10);
}
return result;
}
| net_get_error:
PUSH RBP
MOV RBP,RSP
CMP RSI,0x3
JC 0x00126ba9
MOVZX EAX,word ptr [RDI]
MOV dword ptr [R8],EAX
CMP byte ptr [RDI + 0x2],0x23
JNZ 0x00126bc8
MOV AL,byte ptr [RDI + 0x7]
MOV byte ptr [R9 + 0x4],AL
MOV EAX,dword ptr [RDI + 0x3]
MOV dword ptr [R9],EAX
LEA RAX,[RDI + 0x8]
JMP 0x00126bcc
LAB_00126ba9:
MOV dword ptr [R8],0x7d0
LEA RAX,[0x1629f0]
MOV RAX,qword ptr [RAX]
MOV CL,byte ptr [RAX + 0x4]
MOV byte ptr [R9 + 0x4],CL
MOV EAX,dword ptr [RAX]
MOV dword ptr [R9],EAX
POP RBP
RET
LAB_00126bc8:
LEA RAX,[RDI + 0x2]
LAB_00126bcc:
ADD RDI,RSI
SUB RDI,RAX
DEC RCX
CMP RDI,RCX
CMOVC RCX,RDI
MOV RDI,RDX
MOV RSI,RAX
MOV RDX,RCX
POP RBP
JMP 0x001143a0
|
void net_get_error(ushort *param_1,ulong param_2,void *param_3,long param_4,uint *param_5,
int4 *param_6)
{
int *puVar1;
ushort *__src;
ulong __n;
ulong uVar2;
if (2 < param_2) {
*param_5 = (uint)*param_1;
if ((char)param_1[1] == '#') {
*(int1 *)(param_6 + 1) = *(int1 *)((long)param_1 + 7);
*param_6 = *(int4 *)((long)param_1 + 3);
__src = param_1 + 4;
}
else {
__src = param_1 + 1;
}
uVar2 = (long)param_1 + (param_2 - (long)__src);
__n = param_4 - 1U;
if (uVar2 < param_4 - 1U) {
__n = uVar2;
}
memcpy(param_3,__src,__n);
return;
}
*param_5 = 2000;
puVar1 = SQLSTATE_UNKNOWN;
*(int *)(param_6 + 1) = SQLSTATE_UNKNOWN[4];
*param_6 = *(int4 *)puVar1;
return;
}
| |
38,199 | my_wc_mb_gbk | eloqsql/strings/ctype-gbk.c | static int
my_wc_mb_gbk(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_gbk_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL2;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
} | O0 | c | my_wc_mb_gbk:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0xa186b
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0xa18e4
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jae 0xa188b
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa18e4
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0xa1bb0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0xa18a7
movl $0x0, -0x4(%rbp)
jmp 0xa18e4
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0xa18be
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0xa18e4
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_wc_mb_gbk:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_A186B
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_A18E4
loc_A186B:
mov rax, [rbp+var_18]
cmp eax, 80h
jnb short loc_A188B
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp short loc_A18E4
loc_A188B:
mov rax, [rbp+var_18]
mov edi, eax
call func_uni_gbk_onechar
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_A18A7
mov [rbp+var_4], 0
jmp short loc_A18E4
loc_A18A7:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_A18BE
mov [rbp+var_4], 0FFFFFF9Ah
jmp short loc_A18E4
loc_A18BE:
mov eax, [rbp+var_2C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov eax, [rbp+var_2C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
loc_A18E4:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_wc_mb_gbk(long long a1, unsigned int a2, _BYTE *a3, unsigned long long a4)
{
int v5; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
if ( a2 >= 0x80 )
{
v5 = func_uni_gbk_onechar(a2);
if ( v5 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = BYTE1(v5);
a3[1] = v5;
return 2;
}
else
{
return (unsigned int)-102;
}
}
else
{
return 0;
}
}
else
{
*a3 = a2;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_gbk:
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 qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x001a186b
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x001a18e4
LAB_001a186b:
MOV RAX,qword ptr [RBP + -0x18]
CMP EAX,0x80
JNC 0x001a188b
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001a18e4
LAB_001a188b:
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,EAX
CALL 0x001a1bb0
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x001a18a7
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001a18e4
LAB_001a18a7:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001a18be
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x001a18e4
LAB_001a18be:
MOV EAX,dword ptr [RBP + -0x2c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
LAB_001a18e4:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_wc_mb_gbk(int8 param_1,uint param_2,int1 *param_3,int1 *param_4)
{
int iVar1;
int4 local_c;
if (param_3 < param_4) {
if (param_2 < 0x80) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
iVar1 = func_uni_gbk_onechar(param_2);
if (iVar1 == 0) {
local_c = 0;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = (char)((uint)iVar1 >> 8);
param_3[1] = (char)iVar1;
local_c = 2;
}
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
|
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.