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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
50,600 | utf8_decode_buf16 | bluesky950520[P]quickjs/cutils.c | size_t utf8_decode_buf16(uint16_t *dest, size_t dest_len, const char *src, size_t src_len)
{
const uint8_t *p, *p_end;
size_t i;
p = (const uint8_t *)src;
p_end = p + src_len;
for (i = 0; p < p_end; i++) {
uint32_t c = *p++;
if (c >= 0x80) {
/* parse utf-8 sequence */
c = utf8_decode_len(p - 1, p_end - (p - 1), &p);
/* encoding errors are converted as 0xFFFD and use a single byte */
if (c > 0xFFFF) {
if (i < dest_len)
dest[i] = get_hi_surrogate(c);
i++;
c = get_lo_surrogate(c);
}
}
if (i < dest_len)
dest[i] = c;
}
return i;
} | O2 | c | utf8_decode_buf16:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq %rdx, %rbx
xorl %r12d, %r12d
leaq 0x8(%rsp), %r13
cmpq %rbx, %rdx
jae 0x15700
leaq 0x1(%rdx), %rax
movq %rax, 0x8(%rsp)
movsbl (%rdx), %eax
testl %eax, %eax
jns 0x156ec
movq %rbx, %rsi
subq %rdx, %rsi
movq %rdx, %rdi
movq %r13, %rdx
callq 0x15512
cmpl $0x10000, %eax # imm = 0x10000
jb 0x156ec
cmpq %r14, %r12
jae 0x156df
movl %eax, %ecx
shrl $0xa, %ecx
addl $0xffffd7c0, %ecx # imm = 0xFFFFD7C0
movw %cx, (%r15,%r12,2)
incq %r12
andl $0x3ff, %eax # imm = 0x3FF
orl $0xdc00, %eax # imm = 0xDC00
cmpq %r14, %r12
jae 0x156f6
movw %ax, (%r15,%r12,2)
incq %r12
movq 0x8(%rsp), %rdx
jmp 0x1569d
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| utf8_decode_buf16:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov rbx, rcx
mov r14, rsi
mov r15, rdi
add rbx, rdx
xor r12d, r12d
lea r13, [rsp+38h+var_30]
loc_1569D:
cmp rdx, rbx
jnb short loc_15700
lea rax, [rdx+1]
mov [rsp+38h+var_30], rax
movsx eax, byte ptr [rdx]
test eax, eax
jns short loc_156EC
mov rsi, rbx
sub rsi, rdx
mov rdi, rdx
mov rdx, r13
call utf8_decode_len
cmp eax, 10000h
jb short loc_156EC
cmp r12, r14
jnb short loc_156DF
mov ecx, eax
shr ecx, 0Ah
add ecx, 0FFFFD7C0h
mov [r15+r12*2], cx
loc_156DF:
inc r12
and eax, 3FFh
or eax, 0DC00h
loc_156EC:
cmp r12, r14
jnb short loc_156F6
mov [r15+r12*2], ax
loc_156F6:
inc r12
mov rdx, [rsp+38h+var_30]
jmp short loc_1569D
loc_15700:
mov rax, r12
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| unsigned long long utf8_decode_buf16(long long a1, unsigned long long a2, char *a3, long long a4)
{
char *v4; // rbx
unsigned long long v5; // r12
int v6; // eax
char *v8; // [rsp+8h] [rbp-30h] BYREF
v4 = &a3[a4];
v5 = 0LL;
while ( a3 < v4 )
{
v8 = a3 + 1;
v6 = *a3;
if ( v6 < 0 )
{
v6 = utf8_decode_len(a3, v4 - a3, &v8);
if ( (unsigned int)v6 >= 0x10000 )
{
if ( v5 < a2 )
*(_WORD *)(a1 + 2 * v5) = ((unsigned int)v6 >> 10) - 10304;
++v5;
LOWORD(v6) = v6 & 0x3FF | 0xDC00;
}
}
if ( v5 < a2 )
*(_WORD *)(a1 + 2 * v5) = v6;
++v5;
a3 = v8;
}
return v5;
}
| utf8_decode_buf16:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RCX
MOV R14,RSI
MOV R15,RDI
ADD RBX,RDX
XOR R12D,R12D
LEA R13,[RSP + 0x8]
LAB_0011569d:
CMP RDX,RBX
JNC 0x00115700
LEA RAX,[RDX + 0x1]
MOV qword ptr [RSP + 0x8],RAX
MOVSX EAX,byte ptr [RDX]
TEST EAX,EAX
JNS 0x001156ec
MOV RSI,RBX
SUB RSI,RDX
MOV RDI,RDX
MOV RDX,R13
CALL 0x00115512
CMP EAX,0x10000
JC 0x001156ec
CMP R12,R14
JNC 0x001156df
MOV ECX,EAX
SHR ECX,0xa
ADD ECX,0xffffd7c0
MOV word ptr [R15 + R12*0x2],CX
LAB_001156df:
INC R12
AND EAX,0x3ff
OR EAX,0xdc00
LAB_001156ec:
CMP R12,R14
JNC 0x001156f6
MOV word ptr [R15 + R12*0x2],AX
LAB_001156f6:
INC R12
MOV RDX,qword ptr [RSP + 0x8]
JMP 0x0011569d
LAB_00115700:
MOV RAX,R12
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
ulong utf8_decode_buf16(long param_1,ulong param_2,char *param_3,long param_4)
{
ulong uVar1;
char *pcVar2;
ulong uVar3;
char *local_30;
pcVar2 = param_3 + param_4;
uVar3 = 0;
while (param_3 < pcVar2) {
local_30 = param_3 + 1;
uVar1 = (ulong)(uint)(int)*param_3;
if (*param_3 < 0) {
uVar1 = utf8_decode_len(param_3,(long)pcVar2 - (long)param_3,&local_30);
if (0xffff < (uint)uVar1) {
if (uVar3 < param_2) {
*(short *)(param_1 + uVar3 * 2) = (short)(uVar1 >> 10) + -0x2840;
}
uVar3 = uVar3 + 1;
uVar1 = (ulong)((uint)uVar1 & 0x3ff | 0xdc00);
}
}
if (uVar3 < param_2) {
*(short *)(param_1 + uVar3 * 2) = (short)uVar1;
}
uVar3 = uVar3 + 1;
param_3 = local_30;
}
return uVar3;
}
| |
50,601 | utf8_decode_buf16 | bluesky950520[P]quickjs/cutils.c | size_t utf8_decode_buf16(uint16_t *dest, size_t dest_len, const char *src, size_t src_len)
{
const uint8_t *p, *p_end;
size_t i;
p = (const uint8_t *)src;
p_end = p + src_len;
for (i = 0; p < p_end; i++) {
uint32_t c = *p++;
if (c >= 0x80) {
/* parse utf-8 sequence */
c = utf8_decode_len(p - 1, p_end - (p - 1), &p);
/* encoding errors are converted as 0xFFFD and use a single byte */
if (c > 0xFFFF) {
if (i < dest_len)
dest[i] = get_hi_surrogate(c);
i++;
c = get_lo_surrogate(c);
}
}
if (i < dest_len)
dest[i] = c;
}
return i;
} | O3 | c | utf8_decode_buf16:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rcx, %rcx
jle 0x1b6ff
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r12
addq %rdx, %rbx
xorl %r15d, %r15d
leaq 0x8(%rsp), %r13
leaq 0x1(%rdx), %rax
movq %rax, 0x8(%rsp)
movsbl (%rdx), %eax
testl %eax, %eax
jns 0x1b6e6
movq %rbx, %rsi
subq %rdx, %rsi
movq %rdx, %rdi
movq %r13, %rdx
callq 0x1b52c
cmpl $0x10000, %eax # imm = 0x10000
jb 0x1b6e6
cmpq %r14, %r15
jae 0x1b6d9
movl %eax, %ecx
shrl $0xa, %ecx
addl $0xffffd7c0, %ecx # imm = 0xFFFFD7C0
movw %cx, (%r12,%r15,2)
incq %r15
andl $0x3ff, %eax # imm = 0x3FF
orl $0xdc00, %eax # imm = 0xDC00
cmpq %r14, %r15
jae 0x1b6f0
movw %ax, (%r12,%r15,2)
incq %r15
movq 0x8(%rsp), %rdx
cmpq %rbx, %rdx
jb 0x1b69c
jmp 0x1b702
xorl %r15d, %r15d
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| utf8_decode_buf16:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
test rcx, rcx
jle short loc_1B6FF
mov rbx, rcx
mov r14, rsi
mov r12, rdi
add rbx, rdx
xor r15d, r15d
lea r13, [rsp+38h+var_30]
loc_1B69C:
lea rax, [rdx+1]
mov [rsp+38h+var_30], rax
movsx eax, byte ptr [rdx]
test eax, eax
jns short loc_1B6E6
mov rsi, rbx
sub rsi, rdx
mov rdi, rdx
mov rdx, r13
call utf8_decode_len
cmp eax, offset loc_10000
jb short loc_1B6E6
cmp r15, r14
jnb short loc_1B6D9
mov ecx, eax
shr ecx, 0Ah
add ecx, 0FFFFD7C0h
mov [r12+r15*2], cx
loc_1B6D9:
inc r15
and eax, 3FFh
or eax, 0DC00h
loc_1B6E6:
cmp r15, r14
jnb short loc_1B6F0
mov [r12+r15*2], ax
loc_1B6F0:
inc r15
mov rdx, [rsp+38h+var_30]
cmp rdx, rbx
jb short loc_1B69C
jmp short loc_1B702
loc_1B6FF:
xor r15d, r15d
loc_1B702:
mov rax, r15
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| unsigned long long utf8_decode_buf16(long long a1, unsigned long long a2, char *a3, long long a4)
{
unsigned long long v4; // rbx
unsigned long long v5; // r15
int v6; // eax
char *v8; // [rsp+8h] [rbp-30h] BYREF
if ( a4 <= 0 )
return 0LL;
v4 = (unsigned long long)&a3[a4];
v5 = 0LL;
do
{
v8 = a3 + 1;
v6 = *a3;
if ( v6 < 0 )
{
v6 = utf8_decode_len(a3, v4 - (_QWORD)a3, &v8);
if ( v6 >= (unsigned int)&loc_10000 )
{
if ( v5 < a2 )
*(_WORD *)(a1 + 2 * v5) = ((unsigned int)v6 >> 10) - 10304;
++v5;
LOWORD(v6) = v6 & 0x3FF | 0xDC00;
}
}
if ( v5 < a2 )
*(_WORD *)(a1 + 2 * v5) = v6;
++v5;
a3 = v8;
}
while ( (unsigned long long)v8 < v4 );
return v5;
}
| utf8_decode_buf16:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
TEST RCX,RCX
JLE 0x0011b6ff
MOV RBX,RCX
MOV R14,RSI
MOV R12,RDI
ADD RBX,RDX
XOR R15D,R15D
LEA R13,[RSP + 0x8]
LAB_0011b69c:
LEA RAX,[RDX + 0x1]
MOV qword ptr [RSP + 0x8],RAX
MOVSX EAX,byte ptr [RDX]
TEST EAX,EAX
JNS 0x0011b6e6
MOV RSI,RBX
SUB RSI,RDX
MOV RDI,RDX
MOV RDX,R13
CALL 0x0011b52c
CMP EAX,0x10000
JC 0x0011b6e6
CMP R15,R14
JNC 0x0011b6d9
MOV ECX,EAX
SHR ECX,0xa
ADD ECX,0xffffd7c0
MOV word ptr [R12 + R15*0x2],CX
LAB_0011b6d9:
INC R15
AND EAX,0x3ff
OR EAX,0xdc00
LAB_0011b6e6:
CMP R15,R14
JNC 0x0011b6f0
MOV word ptr [R12 + R15*0x2],AX
LAB_0011b6f0:
INC R15
MOV RDX,qword ptr [RSP + 0x8]
CMP RDX,RBX
JC 0x0011b69c
JMP 0x0011b702
LAB_0011b6ff:
XOR R15D,R15D
LAB_0011b702:
MOV RAX,R15
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
ulong utf8_decode_buf16(long param_1,ulong param_2,char *param_3,long param_4)
{
ulong uVar1;
char *pcVar2;
ulong uVar3;
char *local_30;
if (param_4 < 1) {
uVar3 = 0;
}
else {
pcVar2 = param_3 + param_4;
uVar3 = 0;
do {
local_30 = param_3 + 1;
uVar1 = (ulong)(uint)(int)*param_3;
if (*param_3 < 0) {
uVar1 = utf8_decode_len(param_3,(long)pcVar2 - (long)param_3,&local_30);
if (0xffff < (uint)uVar1) {
if (uVar3 < param_2) {
*(short *)(param_1 + uVar3 * 2) = (short)(uVar1 >> 10) + -0x2840;
}
uVar3 = uVar3 + 1;
uVar1 = (ulong)((uint)uVar1 & 0x3ff | 0xdc00);
}
}
if (uVar3 < param_2) {
*(short *)(param_1 + uVar3 * 2) = (short)uVar1;
}
uVar3 = uVar3 + 1;
param_3 = local_30;
} while (local_30 < pcVar2);
}
return uVar3;
}
| |
50,602 | r3d_billboard_mode_front | r3d/src/details/r3d_billboard.c | void r3d_billboard_mode_front(Matrix* model, const Matrix* invView)
{
// Extract original scales
float scaleX = Vector3Length((Vector3) { model->m0, model->m1, model->m2 });
float scaleY = Vector3Length((Vector3) { model->m4, model->m5, model->m6 });
float scaleZ = Vector3Length((Vector3) { model->m8, model->m9, model->m10 });
// Copy the view basis vectors, applying original scales
model->m0 = invView->m0 * scaleX;
model->m1 = invView->m1 * scaleX;
model->m2 = invView->m2 * scaleX;
model->m4 = invView->m4 * scaleY;
model->m5 = invView->m5 * scaleY;
model->m6 = invView->m6 * scaleY;
model->m8 = invView->m8 * scaleZ;
model->m9 = invView->m9 * scaleZ;
model->m10 = invView->m10 * scaleZ;
} | O3 | c | r3d_billboard_mode_front:
pushq %rbp
movq %rsp, %rbp
movss 0x10(%rdi), %xmm0
movss 0x20(%rdi), %xmm1
mulss %xmm0, %xmm0
movss (%rdi), %xmm2
movss 0x4(%rdi), %xmm3
mulss %xmm2, %xmm2
addss %xmm0, %xmm2
mulss %xmm1, %xmm1
addss %xmm2, %xmm1
xorps %xmm0, %xmm0
sqrtss %xmm1, %xmm0
movss 0x14(%rdi), %xmm1
movss 0x24(%rdi), %xmm2
mulss %xmm1, %xmm1
mulss %xmm3, %xmm3
addss %xmm1, %xmm3
mulss %xmm2, %xmm2
addss %xmm3, %xmm2
xorps %xmm1, %xmm1
sqrtss %xmm2, %xmm1
movss 0x8(%rdi), %xmm2
movss 0x18(%rdi), %xmm3
movss 0x28(%rdi), %xmm4
mulss %xmm3, %xmm3
mulss %xmm2, %xmm2
addss %xmm3, %xmm2
mulss %xmm4, %xmm4
addss %xmm2, %xmm4
movss (%rsi), %xmm2
mulss %xmm0, %xmm2
movss %xmm2, (%rdi)
movss 0x10(%rsi), %xmm2
mulss %xmm0, %xmm2
movss %xmm2, 0x10(%rdi)
mulss 0x20(%rsi), %xmm0
xorps %xmm2, %xmm2
sqrtss %xmm4, %xmm2
movss %xmm0, 0x20(%rdi)
movss 0x4(%rsi), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x4(%rdi)
movss 0x14(%rsi), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x14(%rdi)
mulss 0x24(%rsi), %xmm1
movss %xmm1, 0x24(%rdi)
movss 0x8(%rsi), %xmm0
mulss %xmm2, %xmm0
movss %xmm0, 0x8(%rdi)
movss 0x18(%rsi), %xmm0
mulss %xmm2, %xmm0
movss %xmm0, 0x18(%rdi)
mulss 0x28(%rsi), %xmm2
movss %xmm2, 0x28(%rdi)
popq %rbp
retq
| r3d_billboard_mode_front:
push rbp
mov rbp, rsp
movss xmm0, dword ptr [rdi+10h]
movss xmm1, dword ptr [rdi+20h]
mulss xmm0, xmm0
movss xmm2, dword ptr [rdi]
movss xmm3, dword ptr [rdi+4]
mulss xmm2, xmm2
addss xmm2, xmm0
mulss xmm1, xmm1
addss xmm1, xmm2
xorps xmm0, xmm0
sqrtss xmm0, xmm1
movss xmm1, dword ptr [rdi+14h]
movss xmm2, dword ptr [rdi+24h]
mulss xmm1, xmm1
mulss xmm3, xmm3
addss xmm3, xmm1
mulss xmm2, xmm2
addss xmm2, xmm3
xorps xmm1, xmm1
sqrtss xmm1, xmm2
movss xmm2, dword ptr [rdi+8]
movss xmm3, dword ptr [rdi+18h]
movss xmm4, dword ptr [rdi+28h]
mulss xmm3, xmm3
mulss xmm2, xmm2
addss xmm2, xmm3
mulss xmm4, xmm4
addss xmm4, xmm2
movss xmm2, dword ptr [rsi]
mulss xmm2, xmm0
movss dword ptr [rdi], xmm2
movss xmm2, dword ptr [rsi+10h]
mulss xmm2, xmm0
movss dword ptr [rdi+10h], xmm2
mulss xmm0, dword ptr [rsi+20h]
xorps xmm2, xmm2
sqrtss xmm2, xmm4
movss dword ptr [rdi+20h], xmm0
movss xmm0, dword ptr [rsi+4]
mulss xmm0, xmm1
movss dword ptr [rdi+4], xmm0
movss xmm0, dword ptr [rsi+14h]
mulss xmm0, xmm1
movss dword ptr [rdi+14h], xmm0
mulss xmm1, dword ptr [rsi+24h]
movss dword ptr [rdi+24h], xmm1
movss xmm0, dword ptr [rsi+8]
mulss xmm0, xmm2
movss dword ptr [rdi+8], xmm0
movss xmm0, dword ptr [rsi+18h]
mulss xmm0, xmm2
movss dword ptr [rdi+18h], xmm0
mulss xmm2, dword ptr [rsi+28h]
movss dword ptr [rdi+28h], xmm2
pop rbp
retn
| void r3d_billboard_mode_front(float *a1, float *a2)
{
float v2; // xmm0_4
float v3; // xmm1_4
float v4; // xmm4_4
float v5; // xmm2_4
v2 = fsqrt((float)(a1[8] * a1[8]) + (float)((float)(*a1 * *a1) + (float)(a1[4] * a1[4])));
v3 = fsqrt((float)(a1[9] * a1[9]) + (float)((float)(a1[1] * a1[1]) + (float)(a1[5] * a1[5])));
v4 = (float)(a1[10] * a1[10]) + (float)((float)(a1[2] * a1[2]) + (float)(a1[6] * a1[6]));
*a1 = *a2 * v2;
a1[4] = a2[4] * v2;
v5 = fsqrt(v4);
a1[8] = v2 * a2[8];
a1[1] = a2[1] * v3;
a1[5] = a2[5] * v3;
a1[9] = v3 * a2[9];
a1[2] = a2[2] * v5;
a1[6] = a2[6] * v5;
a1[10] = v5 * a2[10];
}
| r3d_billboard_mode_front:
PUSH RBP
MOV RBP,RSP
MOVSS XMM0,dword ptr [RDI + 0x10]
MOVSS XMM1,dword ptr [RDI + 0x20]
MULSS XMM0,XMM0
MOVSS XMM2,dword ptr [RDI]
MOVSS XMM3,dword ptr [RDI + 0x4]
MULSS XMM2,XMM2
ADDSS XMM2,XMM0
MULSS XMM1,XMM1
ADDSS XMM1,XMM2
XORPS XMM0,XMM0
SQRTSS XMM0,XMM1
MOVSS XMM1,dword ptr [RDI + 0x14]
MOVSS XMM2,dword ptr [RDI + 0x24]
MULSS XMM1,XMM1
MULSS XMM3,XMM3
ADDSS XMM3,XMM1
MULSS XMM2,XMM2
ADDSS XMM2,XMM3
XORPS XMM1,XMM1
SQRTSS XMM1,XMM2
MOVSS XMM2,dword ptr [RDI + 0x8]
MOVSS XMM3,dword ptr [RDI + 0x18]
MOVSS XMM4,dword ptr [RDI + 0x28]
MULSS XMM3,XMM3
MULSS XMM2,XMM2
ADDSS XMM2,XMM3
MULSS XMM4,XMM4
ADDSS XMM4,XMM2
MOVSS XMM2,dword ptr [RSI]
MULSS XMM2,XMM0
MOVSS dword ptr [RDI],XMM2
MOVSS XMM2,dword ptr [RSI + 0x10]
MULSS XMM2,XMM0
MOVSS dword ptr [RDI + 0x10],XMM2
MULSS XMM0,dword ptr [RSI + 0x20]
XORPS XMM2,XMM2
SQRTSS XMM2,XMM4
MOVSS dword ptr [RDI + 0x20],XMM0
MOVSS XMM0,dword ptr [RSI + 0x4]
MULSS XMM0,XMM1
MOVSS dword ptr [RDI + 0x4],XMM0
MOVSS XMM0,dword ptr [RSI + 0x14]
MULSS XMM0,XMM1
MOVSS dword ptr [RDI + 0x14],XMM0
MULSS XMM1,dword ptr [RSI + 0x24]
MOVSS dword ptr [RDI + 0x24],XMM1
MOVSS XMM0,dword ptr [RSI + 0x8]
MULSS XMM0,XMM2
MOVSS dword ptr [RDI + 0x8],XMM0
MOVSS XMM0,dword ptr [RSI + 0x18]
MULSS XMM0,XMM2
MOVSS dword ptr [RDI + 0x18],XMM0
MULSS XMM2,dword ptr [RSI + 0x28]
MOVSS dword ptr [RDI + 0x28],XMM2
POP RBP
RET
|
void r3d_billboard_mode_front(float *param_1,float *param_2)
{
float fVar1;
float fVar2;
float fVar3;
fVar1 = SQRT(param_1[8] * param_1[8] + *param_1 * *param_1 + param_1[4] * param_1[4]);
fVar2 = SQRT(param_1[9] * param_1[9] + param_1[1] * param_1[1] + param_1[5] * param_1[5]);
*param_1 = *param_2 * fVar1;
param_1[4] = param_2[4] * fVar1;
fVar3 = SQRT(param_1[10] * param_1[10] + param_1[2] * param_1[2] + param_1[6] * param_1[6]);
param_1[8] = fVar1 * param_2[8];
param_1[1] = param_2[1] * fVar2;
param_1[5] = param_2[5] * fVar2;
param_1[9] = fVar2 * param_2[9];
param_1[2] = param_2[2] * fVar3;
param_1[6] = param_2[6] * fVar3;
param_1[10] = fVar3 * param_2[10];
return;
}
| |
50,603 | ma_pvio_write_async | eloqsql/libmariadb/libmariadb/ma_pvio.c | static ssize_t ma_pvio_write_async(MARIADB_PVIO *pvio, const uchar *buffer, size_t length)
{
ssize_t res;
struct mysql_async_context *b= pvio->mysql->options.extension->async_context;
int timeout= pvio->timeout[PVIO_WRITE_TIMEOUT];
for (;;)
{
res= pvio->methods->async_write(pvio, buffer, length);
if (res >= 0 || IS_BLOCKING_ERROR())
return res;
b->events_to_wait_for= MYSQL_WAIT_WRITE;
if (timeout >= 0)
{
b->events_to_wait_for|= MYSQL_WAIT_TIMEOUT;
b->timeout_value= timeout;
}
if (b->suspend_resume_hook)
(*b->suspend_resume_hook)(TRUE, b->suspend_resume_hook_user_data);
my_context_yield(&b->async_context);
if (b->suspend_resume_hook)
(*b->suspend_resume_hook)(FALSE, b->suspend_resume_hook_user_data);
if (b->events_occurred & MYSQL_WAIT_TIMEOUT)
return -1;
}
} | O0 | c | ma_pvio_write_async:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x3e2be
callq 0x14050
cmpl $0xb, (%rax)
je 0x3e2cb
callq 0x14050
cmpl $0x4, (%rax)
je 0x3e2cb
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e35c
movq -0x30(%rbp), %rax
movl $0x2, (%rax)
cmpl $0x0, -0x34(%rbp)
jl 0x3e2f0
movq -0x30(%rbp), %rax
movl (%rax), %ecx
orl $0x8, %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3e312
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x28(%rcx), %rsi
movl $0x1, %edi
callq *%rax
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
callq 0x59c30
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3e33e
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x28(%rcx), %rsi
xorl %edi, %edi
callq *%rax
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x3e357
movq $-0x1, -0x8(%rbp)
jmp 0x3e35c
jmp 0x3e285
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_pvio_write_async:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov eax, [rax+2Ch]
mov [rbp+var_34], eax
loc_3E285:
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov rax, [rax+28h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call rax
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jge short loc_3E2BE
call ___errno_location
cmp dword ptr [rax], 0Bh
jz short loc_3E2CB
call ___errno_location
cmp dword ptr [rax], 4
jz short loc_3E2CB
loc_3E2BE:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp loc_3E35C
loc_3E2CB:
mov rax, [rbp+var_30]
mov dword ptr [rax], 2
cmp [rbp+var_34], 0
jl short loc_3E2F0
mov rax, [rbp+var_30]
mov ecx, [rax]
or ecx, 8
mov [rax], ecx
mov ecx, [rbp+var_34]
mov rax, [rbp+var_30]
mov [rax+10h], ecx
loc_3E2F0:
mov rax, [rbp+var_30]
cmp qword ptr [rax+20h], 0
jz short loc_3E312
mov rax, [rbp+var_30]
mov rax, [rax+20h]
mov rcx, [rbp+var_30]
mov rsi, [rcx+28h]
mov edi, 1
call rax
loc_3E312:
mov rdi, [rbp+var_30]
add rdi, 38h ; '8'
call my_context_yield
mov rax, [rbp+var_30]
cmp qword ptr [rax+20h], 0
jz short loc_3E33E
mov rax, [rbp+var_30]
mov rax, [rax+20h]
mov rcx, [rbp+var_30]
mov rsi, [rcx+28h]
xor edi, edi
call rax
loc_3E33E:
mov rax, [rbp+var_30]
mov eax, [rax+4]
and eax, 8
cmp eax, 0
jz short loc_3E357
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_3E35C
loc_3E357:
jmp loc_3E285
loc_3E35C:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long ma_pvio_write_async(long long a1, long long a2, long long a3)
{
int v4; // [rsp+Ch] [rbp-34h]
long long v5; // [rsp+10h] [rbp-30h]
long long v6; // [rsp+18h] [rbp-28h]
v5 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 64) + 1152LL) + 40LL);
v4 = *(_DWORD *)(a1 + 44);
do
{
v6 = (*(long long ( **)(long long, long long, long long))(*(_QWORD *)(a1 + 72) + 40LL))(a1, a2, a3);
if ( v6 >= 0 || *(_DWORD *)__errno_location() != 11 && *(_DWORD *)__errno_location() != 4 )
return v6;
*(_DWORD *)v5 = 2;
if ( v4 >= 0 )
{
*(_DWORD *)v5 |= 8u;
*(_DWORD *)(v5 + 16) = v4;
}
if ( *(_QWORD *)(v5 + 32) )
(*(void ( **)(long long, _QWORD))(v5 + 32))(1LL, *(_QWORD *)(v5 + 40));
my_context_yield(v5 + 56);
if ( *(_QWORD *)(v5 + 32) )
(*(void ( **)(_QWORD, _QWORD))(v5 + 32))(0LL, *(_QWORD *)(v5 + 40));
}
while ( (*(_DWORD *)(v5 + 4) & 8) == 0 );
return -1LL;
}
| ma_pvio_write_async:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x2c]
MOV dword ptr [RBP + -0x34],EAX
LAB_0013e285:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RAX + 0x28]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL RAX
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JGE 0x0013e2be
CALL 0x00114050
CMP dword ptr [RAX],0xb
JZ 0x0013e2cb
CALL 0x00114050
CMP dword ptr [RAX],0x4
JZ 0x0013e2cb
LAB_0013e2be:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0013e35c
LAB_0013e2cb:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x2
CMP dword ptr [RBP + -0x34],0x0
JL 0x0013e2f0
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
OR ECX,0x8
MOV dword ptr [RAX],ECX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x10],ECX
LAB_0013e2f0:
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x0013e312
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RCX + 0x28]
MOV EDI,0x1
CALL RAX
LAB_0013e312:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x38
CALL 0x00159c30
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x0013e33e
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RCX + 0x28]
XOR EDI,EDI
CALL RAX
LAB_0013e33e:
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x4]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0013e357
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x0013e35c
LAB_0013e357:
JMP 0x0013e285
LAB_0013e35c:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
long ma_pvio_write_async(long param_1,int8 param_2,int8 param_3)
{
uint uVar1;
uint *puVar2;
long lVar3;
int *piVar4;
puVar2 = *(uint **)(*(long *)(*(long *)(param_1 + 0x40) + 0x480) + 0x28);
uVar1 = *(uint *)(param_1 + 0x2c);
while( true ) {
lVar3 = (**(code **)(*(long *)(param_1 + 0x48) + 0x28))(param_1,param_2,param_3);
if (-1 < lVar3) {
return lVar3;
}
piVar4 = __errno_location();
if ((*piVar4 != 0xb) && (piVar4 = __errno_location(), *piVar4 != 4)) break;
*puVar2 = 2;
if (-1 < (int)uVar1) {
*puVar2 = *puVar2 | 8;
puVar2[4] = uVar1;
}
if (*(long *)(puVar2 + 8) != 0) {
(**(code **)(puVar2 + 8))(1,*(int8 *)(puVar2 + 10));
}
my_context_yield(puVar2 + 0xe);
if (*(long *)(puVar2 + 8) != 0) {
(**(code **)(puVar2 + 8))(0,*(int8 *)(puVar2 + 10));
}
if ((puVar2[1] & 8) != 0) {
return -1;
}
}
return lVar3;
}
| |
50,604 | ggml_tallocr_alloc | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c | void ggml_tallocr_alloc(struct ggml_tallocr * talloc, struct ggml_tensor * tensor) {
size_t size = ggml_backend_buffer_get_alloc_size(talloc->buffer, tensor);
size = GGML_PAD(size, talloc->alignment);
if (talloc->offset + size > ggml_backend_buffer_get_size(talloc->buffer)) {
GGML_LOG_ERROR("%s: not enough space in the buffer to allocate %s (needed %zu, available %zu)\n",
__func__, tensor->name, size, ggml_backend_buffer_get_size(talloc->buffer) - talloc->offset);
GGML_ABORT("not enough space in the buffer");
}
void * addr = (char *)ggml_backend_buffer_get_base(talloc->buffer) + talloc->offset;
talloc->offset += size;
assert(((uintptr_t)addr % talloc->alignment) == 0);
ggml_backend_tensor_alloc(talloc->buffer, tensor, addr);
} | O1 | c | ggml_tallocr_alloc:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x177a0
movq (%r14), %rdi
movq 0x10(%r14), %r15
addq %r15, %rax
decq %rax
negq %r15
andq %rax, %r15
movq 0x18(%r14), %r12
addq %r15, %r12
callq 0x188b0
cmpq %rax, %r12
ja 0x250b7
movq (%r14), %rdi
callq 0x18550
movq %rax, %rcx
movq 0x18(%r14), %rax
addq %rax, %rcx
addq %rax, %r15
movq %r15, 0x18(%r14)
movq %rcx, %rax
xorl %edx, %edx
divq 0x10(%r14)
testq %rdx, %rdx
jne 0x25107
movq (%r14), %rdi
movq %rbx, %rsi
movq %rcx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x18770
addq $0x100, %rbx # imm = 0x100
movq (%r14), %rdi
callq 0x188b0
subq 0x18(%r14), %rax
leaq 0x29f2b(%rip), %rsi # 0x4effc
leaq 0x29f73(%rip), %rdx # 0x4f04b
movl $0x4, %edi
movq %rbx, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x17810
leaq 0x29e74(%rip), %rdi # 0x4ef68
leaq 0x29f63(%rip), %rdx # 0x4f05e
movl $0x5e, %esi
xorl %eax, %eax
callq 0x18ce0
leaq 0x29f6f(%rip), %rdi # 0x4f07d
leaq 0x29e53(%rip), %rsi # 0x4ef68
leaq 0x29f8c(%rip), %rcx # 0x4f0a8
movl $0x64, %edx
callq 0x17b00
| ggml_tallocr_alloc:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rdi, [rdi]
call _ggml_backend_buffer_get_alloc_size
mov rdi, [r14]
mov r15, [r14+10h]
add rax, r15
dec rax
neg r15
and r15, rax
mov r12, [r14+18h]
add r12, r15
call _ggml_backend_buffer_get_size
cmp r12, rax
ja short loc_250B7
mov rdi, [r14]
call _ggml_backend_buffer_get_base
mov rcx, rax
mov rax, [r14+18h]
add rcx, rax
add r15, rax
mov [r14+18h], r15
mov rax, rcx
xor edx, edx
div qword ptr [r14+10h]
test rdx, rdx
jnz short loc_25107
mov rdi, [r14]
mov rsi, rbx
mov rdx, rcx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp _ggml_backend_tensor_alloc
loc_250B7:
add rbx, 100h
mov rdi, [r14]
call _ggml_backend_buffer_get_size
sub rax, [r14+18h]
lea rsi, aSNotEnoughSpac_0; "%s: not enough space in the buffer to a"...
lea rdx, aGgmlTallocrAll_0; "ggml_tallocr_alloc"
mov edi, 4
mov rcx, rbx
mov r8, r15
mov r9, rax
xor eax, eax
call _ggml_log_internal
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aNotEnoughSpace_0; "not enough space in the buffer"
mov esi, 5Eh ; '^'
xor eax, eax
call _ggml_abort
loc_25107:
lea rdi, aUintptrTAddrTa; "((uintptr_t)addr % talloc->alignment) ="...
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlTalloc; "void ggml_tallocr_alloc(struct ggml_tal"...
mov edx, 64h ; 'd'
call ___assert_fail
| long long ggml_tallocr_alloc(
_QWORD *a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // r15
unsigned long long v11; // r12
long long base; // rcx
long long v13; // rax
unsigned long long v14; // rcx
long long size; // rax
__m128 v17; // xmm4
__m128 v18; // xmm5
int v19; // ecx
int v20; // r8d
int v21; // r9d
v10 = (a1[2] + ggml_backend_buffer_get_alloc_size(*a1) - 1) & -a1[2];
v11 = v10 + a1[3];
if ( v11 > ggml_backend_buffer_get_size(*a1) )
{
size = ggml_backend_buffer_get_size(*a1);
ggml_log_internal(
4u,
(long long)"%s: not enough space in the buffer to allocate %s (needed %zu, available %zu)\n",
(long long)"ggml_tallocr_alloc",
a2 + 256,
v10,
size - a1[3],
a3,
a4,
a5,
a6,
v17,
v18,
a9,
a10);
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c",
94,
(unsigned int)"not enough space in the buffer",
v19,
v20,
v21);
}
base = ggml_backend_buffer_get_base(*a1);
v13 = a1[3];
v14 = v13 + base;
a1[3] = v13 + v10;
if ( v14 % a1[2] )
__assert_fail(
"((uintptr_t)addr % talloc->alignment) == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c",
100LL,
"void ggml_tallocr_alloc(struct ggml_tallocr *, struct ggml_tensor *)");
return ggml_backend_tensor_alloc(*a1, a2, v14);
}
| ggml_tallocr_alloc:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI]
CALL 0x001177a0
MOV RDI,qword ptr [R14]
MOV R15,qword ptr [R14 + 0x10]
ADD RAX,R15
DEC RAX
NEG R15
AND R15,RAX
MOV R12,qword ptr [R14 + 0x18]
ADD R12,R15
CALL 0x001188b0
CMP R12,RAX
JA 0x001250b7
MOV RDI,qword ptr [R14]
CALL 0x00118550
MOV RCX,RAX
MOV RAX,qword ptr [R14 + 0x18]
ADD RCX,RAX
ADD R15,RAX
MOV qword ptr [R14 + 0x18],R15
MOV RAX,RCX
XOR EDX,EDX
DIV qword ptr [R14 + 0x10]
TEST RDX,RDX
JNZ 0x00125107
MOV RDI,qword ptr [R14]
MOV RSI,RBX
MOV RDX,RCX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x00118770
LAB_001250b7:
ADD RBX,0x100
MOV RDI,qword ptr [R14]
CALL 0x001188b0
SUB RAX,qword ptr [R14 + 0x18]
LEA RSI,[0x14effc]
LEA RDX,[0x14f04b]
MOV EDI,0x4
MOV RCX,RBX
MOV R8,R15
MOV R9,RAX
XOR EAX,EAX
CALL 0x00117810
LEA RDI,[0x14ef68]
LEA RDX,[0x14f05e]
MOV ESI,0x5e
XOR EAX,EAX
CALL 0x00118ce0
LAB_00125107:
LEA RDI,[0x14f07d]
LEA RSI,[0x14ef68]
LEA RCX,[0x14f0a8]
MOV EDX,0x64
CALL 0x00117b00
|
void ggml_tallocr_alloc(int8 *param_1,long param_2)
{
long lVar1;
ulong uVar2;
ulong uVar3;
lVar1 = ggml_backend_buffer_get_alloc_size(*param_1);
uVar3 = -param_1[2] & (lVar1 + param_1[2]) - 1U;
lVar1 = param_1[3];
uVar2 = ggml_backend_buffer_get_size(*param_1);
if (uVar2 < lVar1 + uVar3) {
lVar1 = ggml_backend_buffer_get_size(*param_1);
ggml_log_internal(4,
"%s: not enough space in the buffer to allocate %s (needed %zu, available %zu)\n"
,"ggml_tallocr_alloc",param_2 + 0x100,uVar3,lVar1 - param_1[3]);
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c"
,0x5e,"not enough space in the buffer");
}
lVar1 = ggml_backend_buffer_get_base(*param_1);
uVar2 = lVar1 + param_1[3];
param_1[3] = uVar3 + param_1[3];
if (uVar2 % (ulong)param_1[2] == 0) {
ggml_backend_tensor_alloc(*param_1,param_2,uVar2);
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("((uintptr_t)addr % talloc->alignment) == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c"
,100,"void ggml_tallocr_alloc(struct ggml_tallocr *, struct ggml_tensor *)");
}
| |
50,605 | ggml_tallocr_alloc | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c | void ggml_tallocr_alloc(struct ggml_tallocr * talloc, struct ggml_tensor * tensor) {
size_t size = ggml_backend_buffer_get_alloc_size(talloc->buffer, tensor);
size = GGML_PAD(size, talloc->alignment);
if (talloc->offset + size > ggml_backend_buffer_get_size(talloc->buffer)) {
GGML_LOG_ERROR("%s: not enough space in the buffer to allocate %s (needed %zu, available %zu)\n",
__func__, tensor->name, size, ggml_backend_buffer_get_size(talloc->buffer) - talloc->offset);
GGML_ABORT("not enough space in the buffer");
}
void * addr = (char *)ggml_backend_buffer_get_base(talloc->buffer) + talloc->offset;
talloc->offset += size;
assert(((uintptr_t)addr % talloc->alignment) == 0);
ggml_backend_tensor_alloc(talloc->buffer, tensor, addr);
} | O3 | c | ggml_tallocr_alloc:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x167a0
movq (%r14), %rdi
movq 0x10(%r14), %r15
addq %r15, %rax
decq %rax
negq %r15
andq %rax, %r15
movq 0x18(%r14), %r12
addq %r15, %r12
callq 0x178a0
cmpq %rax, %r12
ja 0x23d67
movq (%r14), %rdi
callq 0x17540
movq %rax, %rcx
movq 0x18(%r14), %rax
addq %rax, %rcx
addq %rax, %r15
movq %r15, 0x18(%r14)
movq %rcx, %rax
xorl %edx, %edx
divq 0x10(%r14)
testq %rdx, %rdx
jne 0x23db7
movq (%r14), %rdi
movq %rbx, %rsi
movq %rcx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x17760
addq $0x100, %rbx # imm = 0x100
movq (%r14), %rdi
callq 0x178a0
subq 0x18(%r14), %rax
leaq 0x2b31b(%rip), %rsi # 0x4f09c
leaq 0x2b363(%rip), %rdx # 0x4f0eb
movl $0x4, %edi
movq %rbx, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x16810
leaq 0x2b264(%rip), %rdi # 0x4f008
leaq 0x2b353(%rip), %rdx # 0x4f0fe
movl $0x5e, %esi
xorl %eax, %eax
callq 0x17cd0
leaq 0x2b35f(%rip), %rdi # 0x4f11d
leaq 0x2b243(%rip), %rsi # 0x4f008
leaq 0x2b37c(%rip), %rcx # 0x4f148
movl $0x64, %edx
callq 0x16b00
| ggml_tallocr_alloc:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rdi, [rdi]
call _ggml_backend_buffer_get_alloc_size
mov rdi, [r14]
mov r15, [r14+10h]
add rax, r15
dec rax
neg r15
and r15, rax
mov r12, [r14+18h]
add r12, r15
call _ggml_backend_buffer_get_size
cmp r12, rax
ja short loc_23D67
mov rdi, [r14]
call _ggml_backend_buffer_get_base
mov rcx, rax
mov rax, [r14+18h]
add rcx, rax
add r15, rax
mov [r14+18h], r15
mov rax, rcx
xor edx, edx
div qword ptr [r14+10h]
test rdx, rdx
jnz short loc_23DB7
mov rdi, [r14]
mov rsi, rbx
mov rdx, rcx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp _ggml_backend_tensor_alloc
loc_23D67:
add rbx, 100h
mov rdi, [r14]
call _ggml_backend_buffer_get_size
sub rax, [r14+18h]
lea rsi, aSNotEnoughSpac_0; "%s: not enough space in the buffer to a"...
lea rdx, aGgmlTallocrAll_0; "ggml_tallocr_alloc"
mov edi, 4
mov rcx, rbx
mov r8, r15
mov r9, rax
xor eax, eax
call _ggml_log_internal
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aNotEnoughSpace_0; "not enough space in the buffer"
mov esi, 5Eh ; '^'
xor eax, eax
call _ggml_abort
loc_23DB7:
lea rdi, aUintptrTAddrTa; "((uintptr_t)addr % talloc->alignment) ="...
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlTalloc; "void ggml_tallocr_alloc(struct ggml_tal"...
mov edx, 64h ; 'd'
call ___assert_fail
| long long ggml_tallocr_alloc(
_QWORD *a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // r15
unsigned long long v11; // r12
long long base; // rcx
long long v13; // rax
unsigned long long v14; // rcx
long long size; // rax
__m128 v17; // xmm4
__m128 v18; // xmm5
int v19; // ecx
int v20; // r8d
int v21; // r9d
v10 = (a1[2] + ggml_backend_buffer_get_alloc_size(*a1) - 1) & -a1[2];
v11 = v10 + a1[3];
if ( v11 > ggml_backend_buffer_get_size(*a1) )
{
size = ggml_backend_buffer_get_size(*a1);
ggml_log_internal(
4u,
(long long)"%s: not enough space in the buffer to allocate %s (needed %zu, available %zu)\n",
(long long)"ggml_tallocr_alloc",
a2 + 256,
v10,
size - a1[3],
a3,
a4,
a5,
a6,
v17,
v18,
a9,
a10);
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c",
94,
(unsigned int)"not enough space in the buffer",
v19,
v20,
v21);
}
base = ggml_backend_buffer_get_base(*a1);
v13 = a1[3];
v14 = v13 + base;
a1[3] = v13 + v10;
if ( v14 % a1[2] )
__assert_fail(
"((uintptr_t)addr % talloc->alignment) == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c",
100LL,
"void ggml_tallocr_alloc(struct ggml_tallocr *, struct ggml_tensor *)");
return ggml_backend_tensor_alloc(*a1, a2, v14);
}
| ggml_tallocr_alloc:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI]
CALL 0x001167a0
MOV RDI,qword ptr [R14]
MOV R15,qword ptr [R14 + 0x10]
ADD RAX,R15
DEC RAX
NEG R15
AND R15,RAX
MOV R12,qword ptr [R14 + 0x18]
ADD R12,R15
CALL 0x001178a0
CMP R12,RAX
JA 0x00123d67
MOV RDI,qword ptr [R14]
CALL 0x00117540
MOV RCX,RAX
MOV RAX,qword ptr [R14 + 0x18]
ADD RCX,RAX
ADD R15,RAX
MOV qword ptr [R14 + 0x18],R15
MOV RAX,RCX
XOR EDX,EDX
DIV qword ptr [R14 + 0x10]
TEST RDX,RDX
JNZ 0x00123db7
MOV RDI,qword ptr [R14]
MOV RSI,RBX
MOV RDX,RCX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x00117760
LAB_00123d67:
ADD RBX,0x100
MOV RDI,qword ptr [R14]
CALL 0x001178a0
SUB RAX,qword ptr [R14 + 0x18]
LEA RSI,[0x14f09c]
LEA RDX,[0x14f0eb]
MOV EDI,0x4
MOV RCX,RBX
MOV R8,R15
MOV R9,RAX
XOR EAX,EAX
CALL 0x00116810
LEA RDI,[0x14f008]
LEA RDX,[0x14f0fe]
MOV ESI,0x5e
XOR EAX,EAX
CALL 0x00117cd0
LAB_00123db7:
LEA RDI,[0x14f11d]
LEA RSI,[0x14f008]
LEA RCX,[0x14f148]
MOV EDX,0x64
CALL 0x00116b00
|
void ggml_tallocr_alloc(int8 *param_1,long param_2)
{
long lVar1;
ulong uVar2;
ulong uVar3;
lVar1 = ggml_backend_buffer_get_alloc_size(*param_1);
uVar3 = -param_1[2] & (lVar1 + param_1[2]) - 1U;
lVar1 = param_1[3];
uVar2 = ggml_backend_buffer_get_size(*param_1);
if (uVar2 < lVar1 + uVar3) {
lVar1 = ggml_backend_buffer_get_size(*param_1);
ggml_log_internal(4,
"%s: not enough space in the buffer to allocate %s (needed %zu, available %zu)\n"
,"ggml_tallocr_alloc",param_2 + 0x100,uVar3,lVar1 - param_1[3]);
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c"
,0x5e,"not enough space in the buffer");
}
lVar1 = ggml_backend_buffer_get_base(*param_1);
uVar2 = lVar1 + param_1[3];
param_1[3] = uVar3 + param_1[3];
if (uVar2 % (ulong)param_1[2] == 0) {
ggml_backend_tensor_alloc(*param_1,param_2,uVar2);
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("((uintptr_t)addr % talloc->alignment) == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c"
,100,"void ggml_tallocr_alloc(struct ggml_tallocr *, struct ggml_tensor *)");
}
| |
50,606 | ftxui::IsControl(unsigned int) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/screen/string.cpp | bool IsControl(uint32_t ucs) {
if (ucs == 0) {
return true;
}
if (ucs < 32) { // NOLINT
const uint32_t LINE_FEED = 10;
return ucs != LINE_FEED;
}
if (ucs >= 0x7f && ucs < 0xa0) { // NOLINT
return true;
}
return false;
} | O1 | cpp | ftxui::IsControl(unsigned int):
testl %edi, %edi
je 0x3b524
cmpl $0x1f, %edi
ja 0x3b527
cmpl $0xa, %edi
setne %al
retq
movb $0x1, %al
retq
addl $-0x7f, %edi
cmpl $0x21, %edi
setb %al
retq
| _ZN5ftxui9IsControlEj:
test edi, edi
jz short loc_3B524
cmp edi, 1Fh
ja short loc_3B527
cmp edi, 0Ah
setnz al
retn
loc_3B524:
mov al, 1
retn
loc_3B527:
add edi, 0FFFFFF81h
cmp edi, 21h ; '!'
setb al
retn
| char ftxui::IsControl(ftxui *this)
{
if ( !(_DWORD)this )
return 1;
if ( (unsigned int)this > 0x1F )
return (unsigned int)((_DWORD)this - 127) < 0x21;
return (_DWORD)this != 10;
}
| IsControl:
TEST EDI,EDI
JZ 0x0013b524
CMP EDI,0x1f
JA 0x0013b527
CMP EDI,0xa
SETNZ AL
RET
LAB_0013b524:
MOV AL,0x1
RET
LAB_0013b527:
ADD EDI,-0x7f
CMP EDI,0x21
SETC AL
RET
|
/* ftxui::IsControl(unsigned int) */
bool ftxui::IsControl(uint param_1)
{
if (param_1 == 0) {
return true;
}
if (param_1 < 0x20) {
return param_1 != 10;
}
return param_1 - 0x7f < 0x21;
}
| |
50,607 | my_casedn_8bit | eloqsql/strings/ctype-simple.c | size_t my_casedn_8bit(CHARSET_INFO * cs, const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)))
{
const char *end= src + srclen;
register const uchar *map=cs->to_lower;
DBUG_ASSERT(srclen <= dstlen);
for ( ; src != end ; src++)
*dst++= (char) map[(uchar) *src];
return srclen;
} | O3 | c | my_casedn_8bit:
movq %rdx, %rax
testq %rdx, %rdx
je 0x70264
pushq %rbp
movq %rsp, %rbp
movq 0x48(%rdi), %rdx
xorl %edi, %edi
movzbl (%rsi,%rdi), %r8d
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx,%rdi)
incq %rdi
cmpq %rdi, %rax
jne 0x7024e
popq %rbp
retq
| my_casedn_8bit:
mov rax, rdx
test rdx, rdx
jz short locret_70264
push rbp
mov rbp, rsp
mov rdx, [rdi+48h]
xor edi, edi
loc_7024E:
movzx r8d, byte ptr [rsi+rdi]
mov r8b, [rdx+r8]
mov [rcx+rdi], r8b
inc rdi
cmp rax, rdi
jnz short loc_7024E
pop rbp
locret_70264:
retn
| long long my_casedn_8bit(long long a1, long long a2, long long a3, long long a4)
{
long long result; // rax
long long v5; // rdx
long long v6; // rdi
result = a3;
if ( a3 )
{
v5 = *(_QWORD *)(a1 + 72);
v6 = 0LL;
do
{
*(_BYTE *)(a4 + v6) = *(_BYTE *)(v5 + *(unsigned __int8 *)(a2 + v6));
++v6;
}
while ( result != v6 );
}
return result;
}
| my_casedn_8bit:
MOV RAX,RDX
TEST RDX,RDX
JZ 0x00170264
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RDI + 0x48]
XOR EDI,EDI
LAB_0017024e:
MOVZX R8D,byte ptr [RSI + RDI*0x1]
MOV R8B,byte ptr [RDX + R8*0x1]
MOV byte ptr [RCX + RDI*0x1],R8B
INC RDI
CMP RAX,RDI
JNZ 0x0017024e
POP RBP
LAB_00170264:
RET
|
void my_casedn_8bit(long param_1,long param_2,long param_3,long param_4)
{
long lVar1;
long lVar2;
if (param_3 != 0) {
lVar1 = *(long *)(param_1 + 0x48);
lVar2 = 0;
do {
*(int1 *)(param_4 + lVar2) = *(int1 *)(lVar1 + (ulong)*(byte *)(param_2 + lVar2));
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
return;
}
| |
50,608 | json_prepend_member | xtate/src/crypto/crypto-json.c | void json_prepend_member(JsonNode *object, const char *key, JsonNode *value) {
assert(object->tag == JSON_OBJECT);
assert(value->parent == NULL);
value->key = json_strdup(key);
prepend_node(object, value);
} | O3 | c | json_prepend_member:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1c282
movq %rax, 0x18(%rbx)
movq %r14, (%rbx)
movq $0x0, 0x8(%rbx)
movq 0x28(%r14), %rax
movq %rax, 0x10(%rbx)
leaq 0x30(%r14), %rcx
leaq 0x8(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %rbx, (%rdx)
movq %rbx, 0x28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| json_prepend_member:
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rdi
mov rdi, rsi
call json_strdup
mov [rbx+18h], rax
mov [rbx], r14
mov qword ptr [rbx+8], 0
mov rax, [r14+28h]
mov [rbx+10h], rax
lea rcx, [r14+30h]
lea rdx, [rax+8]
test rax, rax
cmovz rdx, rcx
mov [rdx], rbx
mov [r14+28h], rbx
add rsp, 8
pop rbx
pop r14
retn
| long long json_prepend_member(long long a1, long long a2, _QWORD *a3)
{
long long result; // rax
_QWORD *v5; // rdx
a3[3] = json_strdup(a2);
*a3 = a1;
a3[1] = 0LL;
result = *(_QWORD *)(a1 + 40);
a3[2] = result;
v5 = (_QWORD *)(result + 8);
if ( !result )
v5 = (_QWORD *)(a1 + 48);
*v5 = a3;
*(_QWORD *)(a1 + 40) = a3;
return result;
}
| json_prepend_member:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
MOV RDI,RSI
CALL 0x0011c282
MOV qword ptr [RBX + 0x18],RAX
MOV qword ptr [RBX],R14
MOV qword ptr [RBX + 0x8],0x0
MOV RAX,qword ptr [R14 + 0x28]
MOV qword ptr [RBX + 0x10],RAX
LEA RCX,[R14 + 0x30]
LEA RDX,[RAX + 0x8]
TEST RAX,RAX
CMOVZ RDX,RCX
MOV qword ptr [RDX],RBX
MOV qword ptr [R14 + 0x28],RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
void json_prepend_member(long param_1,int8 param_2,long *param_3)
{
long lVar1;
long *plVar2;
lVar1 = json_strdup(param_2);
param_3[3] = lVar1;
*param_3 = param_1;
param_3[1] = 0;
lVar1 = *(long *)(param_1 + 0x28);
param_3[2] = lVar1;
plVar2 = (long *)(lVar1 + 8);
if (lVar1 == 0) {
plVar2 = (long *)(param_1 + 0x30);
}
*plVar2 = (long)param_3;
*(long **)(param_1 + 0x28) = param_3;
return;
}
| |
50,609 | my_create_with_symlink | eloqsql/mysys/my_symlink2.c | File my_create_with_symlink(const char *linkname, const char *filename,
int createflags, int access_flags, myf MyFlags)
{
File file;
int tmp_errno;
/* Test if we should create a link */
int create_link;
char abs_linkname[FN_REFLEN];
DBUG_ENTER("my_create_with_symlink");
DBUG_PRINT("enter", ("linkname: %s filename: %s",
linkname ? linkname : "(NULL)",
filename ? filename : "(NULL)"));
if (my_disable_symlinks)
{
DBUG_PRINT("info", ("Symlinks disabled"));
/* Create only the file, not the link and file */
create_link= 0;
if (linkname)
filename= linkname;
}
else
{
if (linkname)
my_realpath(abs_linkname, linkname, MYF(0));
create_link= (linkname && strcmp(abs_linkname,filename));
}
if (!(MyFlags & MY_DELETE_OLD))
{
if (!access(filename,F_OK))
{
my_errno= errno= EEXIST;
my_error(EE_CANTCREATEFILE, MYF(0), filename, EEXIST);
DBUG_RETURN(-1);
}
if (create_link && !access(linkname,F_OK))
{
my_errno= errno= EEXIST;
my_error(EE_CANTCREATEFILE, MYF(0), linkname, EEXIST);
DBUG_RETURN(-1);
}
}
if ((file=my_create(filename, createflags, access_flags, MyFlags)) >= 0)
{
if (create_link)
{
/* Delete old link/file */
if (MyFlags & MY_DELETE_OLD)
my_delete(linkname, MYF(0));
/* Create link */
if (my_symlink(filename, linkname, MyFlags))
{
/* Fail, remove everything we have done */
tmp_errno=my_errno;
my_close(file,MYF(0));
my_delete(filename, MYF(0));
file= -1;
my_errno=tmp_errno;
}
}
}
DBUG_RETURN(file);
} | O0 | c | my_create_with_symlink:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x220(%rbp)
movq %rsi, -0x228(%rbp)
movl %edx, -0x22c(%rbp)
movl %ecx, -0x230(%rbp)
movq %r8, -0x238(%rbp)
jmp 0x8173b
leaq 0x37740a(%rip), %rax # 0x3f8b4c
cmpb $0x0, (%rax)
je 0x8176f
jmp 0x81749
jmp 0x8174b
movl $0x0, -0x244(%rbp)
cmpq $0x0, -0x220(%rbp)
je 0x8176d
movq -0x220(%rbp), %rax
movq %rax, -0x228(%rbp)
jmp 0x817d2
cmpq $0x0, -0x220(%rbp)
je 0x81790
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x81320
xorl %eax, %eax
cmpq $0x0, -0x220(%rbp)
movb %al, -0x245(%rbp)
je 0x817c1
leaq -0x210(%rbp), %rdi
movq -0x228(%rbp), %rsi
callq 0x284c0
cmpl $0x0, %eax
setne %al
movb %al, -0x245(%rbp)
movb -0x245(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x244(%rbp)
movq -0x238(%rbp), %rax
andq $0x100, %rax # imm = 0x100
cmpq $0x0, %rax
jne 0x8189c
movq -0x228(%rbp), %rdi
xorl %esi, %esi
callq 0x28640
cmpl $0x0, %eax
jne 0x8183d
callq 0x28040
movl $0x11, (%rax)
callq 0x82360
movl $0x11, (%rax)
movq -0x228(%rbp), %rdx
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x11, %ecx
movb $0x0, %al
callq 0x7bff0
movl $0xffffffff, -0x214(%rbp) # imm = 0xFFFFFFFF
jmp 0x8197a
cmpl $0x0, -0x244(%rbp)
je 0x8189a
movq -0x220(%rbp), %rdi
xorl %esi, %esi
callq 0x28640
cmpl $0x0, %eax
jne 0x8189a
callq 0x28040
movl $0x11, (%rax)
callq 0x82360
movl $0x11, (%rax)
movq -0x220(%rbp), %rdx
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x11, %ecx
movb $0x0, %al
callq 0x7bff0
movl $0xffffffff, -0x214(%rbp) # imm = 0xFFFFFFFF
jmp 0x8197a
jmp 0x8189c
movq -0x228(%rbp), %rdi
movl -0x22c(%rbp), %esi
movl -0x230(%rbp), %edx
movq -0x238(%rbp), %rcx
callq 0x7bb30
movl %eax, -0x23c(%rbp)
cmpl $0x0, %eax
jl 0x8196c
cmpl $0x0, -0x244(%rbp)
je 0x8196a
movq -0x238(%rbp), %rax
andq $0x100, %rax # imm = 0x100
cmpq $0x0, %rax
je 0x818fa
movq -0x220(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7bc00
movq -0x228(%rbp), %rdi
movq -0x220(%rbp), %rsi
movq -0x238(%rbp), %rdx
callq 0x811f0
cmpl $0x0, %eax
je 0x81968
callq 0x82360
movl (%rax), %eax
movl %eax, -0x240(%rbp)
movl -0x23c(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x807f0
movq -0x228(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7bc00
movl $0xffffffff, -0x23c(%rbp) # imm = 0xFFFFFFFF
movl -0x240(%rbp), %eax
movl %eax, -0x24c(%rbp)
callq 0x82360
movl -0x24c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x8196a
jmp 0x8196c
jmp 0x8196e
movl -0x23c(%rbp), %eax
movl %eax, -0x214(%rbp)
movl -0x214(%rbp), %eax
movl %eax, -0x250(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x819a7
movl -0x250(%rbp), %eax
addq $0x250, %rsp # imm = 0x250
popq %rbp
retq
callq 0x283b0
nopl (%rax)
| my_create_with_symlink:
push rbp
mov rbp, rsp
sub rsp, 250h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_220], rdi
mov [rbp+var_228], rsi
mov [rbp+var_22C], edx
mov [rbp+var_230], ecx
mov [rbp+var_238], r8
jmp short $+2
loc_8173B:
lea rax, my_disable_symlinks
cmp byte ptr [rax], 0
jz short loc_8176F
jmp short $+2
loc_81749:
jmp short $+2
loc_8174B:
mov [rbp+var_244], 0
cmp [rbp+var_220], 0
jz short loc_8176D
mov rax, [rbp+var_220]
mov [rbp+var_228], rax
loc_8176D:
jmp short loc_817D2
loc_8176F:
cmp [rbp+var_220], 0
jz short loc_81790
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
xor eax, eax
mov edx, eax
call my_realpath
loc_81790:
xor eax, eax
cmp [rbp+var_220], 0
mov [rbp+var_245], al
jz short loc_817C1
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_228]
call _strcmp
cmp eax, 0
setnz al
mov [rbp+var_245], al
loc_817C1:
mov al, [rbp+var_245]
and al, 1
movzx eax, al
mov [rbp+var_244], eax
loc_817D2:
mov rax, [rbp+var_238]
and rax, 100h
cmp rax, 0
jnz loc_8189C
mov rdi, [rbp+var_228]
xor esi, esi
call _access
cmp eax, 0
jnz short loc_8183D
call ___errno_location
mov dword ptr [rax], 11h
call _my_thread_var
mov dword ptr [rax], 11h
mov rdx, [rbp+var_228]
mov edi, 1
xor eax, eax
mov esi, eax
mov ecx, 11h
mov al, 0
call my_error
mov [rbp+var_214], 0FFFFFFFFh
jmp loc_8197A
loc_8183D:
cmp [rbp+var_244], 0
jz short loc_8189A
mov rdi, [rbp+var_220]
xor esi, esi
call _access
cmp eax, 0
jnz short loc_8189A
call ___errno_location
mov dword ptr [rax], 11h
call _my_thread_var
mov dword ptr [rax], 11h
mov rdx, [rbp+var_220]
mov edi, 1
xor eax, eax
mov esi, eax
mov ecx, 11h
mov al, 0
call my_error
mov [rbp+var_214], 0FFFFFFFFh
jmp loc_8197A
loc_8189A:
jmp short $+2
loc_8189C:
mov rdi, [rbp+var_228]
mov esi, [rbp+var_22C]
mov edx, [rbp+var_230]
mov rcx, [rbp+var_238]
call my_create
mov [rbp+var_23C], eax
cmp eax, 0
jl loc_8196C
cmp [rbp+var_244], 0
jz loc_8196A
mov rax, [rbp+var_238]
and rax, 100h
cmp rax, 0
jz short loc_818FA
mov rdi, [rbp+var_220]
xor eax, eax
mov esi, eax
call my_delete
loc_818FA:
mov rdi, [rbp+var_228]
mov rsi, [rbp+var_220]
mov rdx, [rbp+var_238]
call my_symlink
cmp eax, 0
jz short loc_81968
call _my_thread_var
mov eax, [rax]
mov [rbp+var_240], eax
mov edi, [rbp+var_23C]
xor eax, eax
mov esi, eax
call my_close
mov rdi, [rbp+var_228]
xor eax, eax
mov esi, eax
call my_delete
mov [rbp+var_23C], 0FFFFFFFFh
mov eax, [rbp+var_240]
mov [rbp+var_24C], eax
call _my_thread_var
mov ecx, [rbp+var_24C]
mov [rax], ecx
loc_81968:
jmp short $+2
loc_8196A:
jmp short $+2
loc_8196C:
jmp short $+2
loc_8196E:
mov eax, [rbp+var_23C]
mov [rbp+var_214], eax
loc_8197A:
mov eax, [rbp+var_214]
mov [rbp+var_250], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_819A7
mov eax, [rbp+var_250]
add rsp, 250h
pop rbp
retn
loc_819A7:
call ___stack_chk_fail
| long long my_create_with_symlink(const char *a1, long long a2, unsigned int a3, int a4, long long a5)
{
bool v6; // [rsp+Bh] [rbp-245h]
int v7; // [rsp+Ch] [rbp-244h]
int v8; // [rsp+10h] [rbp-240h]
signed int v9; // [rsp+14h] [rbp-23Ch]
long long v13; // [rsp+28h] [rbp-228h]
_BYTE v15[520]; // [rsp+40h] [rbp-210h] BYREF
unsigned long long v16; // [rsp+248h] [rbp-8h]
v16 = __readfsqword(0x28u);
v13 = a2;
if ( my_disable_symlinks )
{
v7 = 0;
if ( a1 )
v13 = (long long)a1;
}
else
{
if ( a1 )
my_realpath((long long)v15, a1, 0);
v6 = 0;
if ( a1 )
v6 = (unsigned int)strcmp(v15, a2) != 0;
v7 = v6;
}
if ( (a5 & 0x100) == 0 )
{
if ( !(unsigned int)access(v13, 0LL) )
{
*(_DWORD *)__errno_location() = 17;
*(_DWORD *)my_thread_var(v13, 0LL) = 17;
my_error(1u, 0LL, v13, 17LL);
return (unsigned int)-1;
}
if ( v7 && !(unsigned int)access(a1, 0LL) )
{
*(_DWORD *)__errno_location() = 17;
*(_DWORD *)my_thread_var(a1, 0LL) = 17;
my_error(1u, 0LL, a1, 17LL);
return (unsigned int)-1;
}
}
v9 = my_create(v13, a3, a4, a5);
if ( v9 >= 0 && v7 )
{
if ( (a5 & 0x100) != 0 )
my_delete((long long)a1, 0LL);
if ( (unsigned int)my_symlink(v13, a1, a5) )
{
v8 = *(_DWORD *)my_thread_var(v13, a1);
my_close(v9, 0LL);
my_delete(v13, 0LL);
v9 = -1;
*(_DWORD *)my_thread_var(v13, 0LL) = v8;
}
}
return (unsigned int)v9;
}
| my_create_with_symlink:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x250
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x220],RDI
MOV qword ptr [RBP + -0x228],RSI
MOV dword ptr [RBP + -0x22c],EDX
MOV dword ptr [RBP + -0x230],ECX
MOV qword ptr [RBP + -0x238],R8
JMP 0x0018173b
LAB_0018173b:
LEA RAX,[0x4f8b4c]
CMP byte ptr [RAX],0x0
JZ 0x0018176f
JMP 0x00181749
LAB_00181749:
JMP 0x0018174b
LAB_0018174b:
MOV dword ptr [RBP + -0x244],0x0
CMP qword ptr [RBP + -0x220],0x0
JZ 0x0018176d
MOV RAX,qword ptr [RBP + -0x220]
MOV qword ptr [RBP + -0x228],RAX
LAB_0018176d:
JMP 0x001817d2
LAB_0018176f:
CMP qword ptr [RBP + -0x220],0x0
JZ 0x00181790
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00181320
LAB_00181790:
XOR EAX,EAX
CMP qword ptr [RBP + -0x220],0x0
MOV byte ptr [RBP + -0x245],AL
JZ 0x001817c1
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x228]
CALL 0x001284c0
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x245],AL
LAB_001817c1:
MOV AL,byte ptr [RBP + -0x245]
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x244],EAX
LAB_001817d2:
MOV RAX,qword ptr [RBP + -0x238]
AND RAX,0x100
CMP RAX,0x0
JNZ 0x0018189c
MOV RDI,qword ptr [RBP + -0x228]
XOR ESI,ESI
CALL 0x00128640
CMP EAX,0x0
JNZ 0x0018183d
CALL 0x00128040
MOV dword ptr [RAX],0x11
CALL 0x00182360
MOV dword ptr [RAX],0x11
MOV RDX,qword ptr [RBP + -0x228]
MOV EDI,0x1
XOR EAX,EAX
MOV ESI,EAX
MOV ECX,0x11
MOV AL,0x0
CALL 0x0017bff0
MOV dword ptr [RBP + -0x214],0xffffffff
JMP 0x0018197a
LAB_0018183d:
CMP dword ptr [RBP + -0x244],0x0
JZ 0x0018189a
MOV RDI,qword ptr [RBP + -0x220]
XOR ESI,ESI
CALL 0x00128640
CMP EAX,0x0
JNZ 0x0018189a
CALL 0x00128040
MOV dword ptr [RAX],0x11
CALL 0x00182360
MOV dword ptr [RAX],0x11
MOV RDX,qword ptr [RBP + -0x220]
MOV EDI,0x1
XOR EAX,EAX
MOV ESI,EAX
MOV ECX,0x11
MOV AL,0x0
CALL 0x0017bff0
MOV dword ptr [RBP + -0x214],0xffffffff
JMP 0x0018197a
LAB_0018189a:
JMP 0x0018189c
LAB_0018189c:
MOV RDI,qword ptr [RBP + -0x228]
MOV ESI,dword ptr [RBP + -0x22c]
MOV EDX,dword ptr [RBP + -0x230]
MOV RCX,qword ptr [RBP + -0x238]
CALL 0x0017bb30
MOV dword ptr [RBP + -0x23c],EAX
CMP EAX,0x0
JL 0x0018196c
CMP dword ptr [RBP + -0x244],0x0
JZ 0x0018196a
MOV RAX,qword ptr [RBP + -0x238]
AND RAX,0x100
CMP RAX,0x0
JZ 0x001818fa
MOV RDI,qword ptr [RBP + -0x220]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0017bc00
LAB_001818fa:
MOV RDI,qword ptr [RBP + -0x228]
MOV RSI,qword ptr [RBP + -0x220]
MOV RDX,qword ptr [RBP + -0x238]
CALL 0x001811f0
CMP EAX,0x0
JZ 0x00181968
CALL 0x00182360
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x240],EAX
MOV EDI,dword ptr [RBP + -0x23c]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001807f0
MOV RDI,qword ptr [RBP + -0x228]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0017bc00
MOV dword ptr [RBP + -0x23c],0xffffffff
MOV EAX,dword ptr [RBP + -0x240]
MOV dword ptr [RBP + -0x24c],EAX
CALL 0x00182360
MOV ECX,dword ptr [RBP + -0x24c]
MOV dword ptr [RAX],ECX
LAB_00181968:
JMP 0x0018196a
LAB_0018196a:
JMP 0x0018196c
LAB_0018196c:
JMP 0x0018196e
LAB_0018196e:
MOV EAX,dword ptr [RBP + -0x23c]
MOV dword ptr [RBP + -0x214],EAX
LAB_0018197a:
MOV EAX,dword ptr [RBP + -0x214]
MOV dword ptr [RBP + -0x250],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001819a7
MOV EAX,dword ptr [RBP + -0x250]
ADD RSP,0x250
POP RBP
RET
LAB_001819a7:
CALL 0x001283b0
|
int my_create_with_symlink
(char *param_1,char *param_2,int4 param_3,int4 param_4,ulong param_5)
{
int4 uVar1;
int iVar2;
int *piVar3;
int4 *puVar4;
long in_FS_OFFSET;
bool bVar5;
int local_244;
char *local_230;
int local_21c;
char local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_230 = param_2;
if (my_disable_symlinks == '\0') {
if (param_1 != (char *)0x0) {
my_realpath(local_218,param_1,0);
}
bVar5 = false;
if (param_1 != (char *)0x0) {
iVar2 = strcmp(local_218,param_2);
bVar5 = iVar2 != 0;
}
}
else {
bVar5 = false;
if (param_1 != (char *)0x0) {
local_230 = param_1;
}
}
if ((param_5 & 0x100) == 0) {
iVar2 = access(local_230,0);
if (iVar2 == 0) {
piVar3 = __errno_location();
*piVar3 = 0x11;
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x11;
my_error(1,0,local_230,0x11);
local_21c = -1;
goto LAB_0018197a;
}
if ((bVar5) && (iVar2 = access(param_1,0), iVar2 == 0)) {
piVar3 = __errno_location();
*piVar3 = 0x11;
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x11;
my_error(1,0,param_1,0x11);
local_21c = -1;
goto LAB_0018197a;
}
}
local_244 = my_create(local_230,param_3,param_4,param_5);
if ((-1 < local_244) && (bVar5)) {
if ((param_5 & 0x100) != 0) {
my_delete(param_1,0);
}
iVar2 = my_symlink(local_230,param_1,param_5);
if (iVar2 != 0) {
puVar4 = (int4 *)_my_thread_var();
uVar1 = *puVar4;
my_close(local_244,0);
my_delete(local_230,0);
local_244 = -1;
puVar4 = (int4 *)_my_thread_var();
*puVar4 = uVar1;
}
}
local_21c = local_244;
LAB_0018197a:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_21c;
}
| |
50,610 | is_sorted | davidesantangelo[P]vsort/examples/benchmark.c | int is_sorted(const int arr[], int n) // Mark input as const
{
if (!arr)
return 0; // Null array is not sorted
for (int i = 1; i < n; i++)
{
if (arr[i] < arr[i - 1])
{
fprintf(stderr, "Verification FAILED at index %d: %d < %d\n", i, arr[i], arr[i - 1]);
return 0; // Not sorted
}
}
return 1; // Sorted
} | O3 | c | is_sorted:
pushq %rbx
testq %rdi, %rdi
je 0x199c
movl $0x1, %ebx
cmpl $0x2, %esi
jl 0x19a5
movl (%rdi), %r8d
movl 0x4(%rdi), %ecx
cmpl %r8d, %ecx
jl 0x19a9
movl %esi, %eax
movl $0x2, %esi
subq %rax, %rsi
movl $0x1, %edx
leaq (%rsi,%rdx), %rcx
cmpq $0x1, %rcx
je 0x19a0
movl (%rdi,%rdx,4), %r8d
movl 0x4(%rdi,%rdx,4), %ecx
incq %rdx
cmpl %r8d, %ecx
jge 0x1978
xorl %ebx, %ebx
cmpq %rax, %rdx
setae %bl
jmp 0x19b0
xorl %ebx, %ebx
jmp 0x19a5
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
xorl %ebx, %ebx
movl $0x1, %edx
movq 0x5641(%rip), %rax # 0x6ff8
movq (%rax), %rdi
leaq 0x2707(%rip), %rsi # 0x40c8
xorl %eax, %eax
callq 0x1120
jmp 0x19a5
| is_sorted:
push rbx
test rdi, rdi
jz short loc_199C
mov ebx, 1
cmp esi, 2
jl short loc_19A5
mov r8d, [rdi]
mov ecx, [rdi+4]
cmp ecx, r8d
jl short loc_19A9
mov eax, esi
mov esi, 2
sub rsi, rax
mov edx, 1
loc_1978:
lea rcx, [rsi+rdx]
cmp rcx, 1
jz short loc_19A0
mov r8d, [rdi+rdx*4]
mov ecx, [rdi+rdx*4+4]
inc rdx
cmp ecx, r8d
jge short loc_1978
xor ebx, ebx
cmp rdx, rax
setnb bl
jmp short loc_19B0
loc_199C:
xor ebx, ebx
jmp short loc_19A5
loc_19A0:
mov ebx, 1
loc_19A5:
mov eax, ebx
pop rbx
retn
loc_19A9:
xor ebx, ebx
mov edx, 1
loc_19B0:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aVerificationFa; "Verification FAILED at index %d: %d < %"...
xor eax, eax
call _fprintf
jmp short loc_19A5
| _BOOL8 is_sorted(_DWORD *a1, int a2)
{
BOOL v2; // ebx
unsigned long long v3; // rax
long long v4; // rsi
unsigned long long v5; // rdx
int v6; // r8d
int v7; // ecx
if ( a1 )
{
v2 = 1;
if ( a2 >= 2 )
{
if ( a1[1] < *a1 )
{
v2 = 0;
v5 = 1LL;
LABEL_12:
fprintf(stderr, "Verification FAILED at index %d: %d < %d\n", v5);
}
else
{
v3 = (unsigned int)a2;
v4 = 2LL - (unsigned int)a2;
v5 = 1LL;
while ( v4 + v5 != 1 )
{
v6 = a1[v5];
v7 = a1[++v5];
if ( v7 < v6 )
{
v2 = v5 >= v3;
goto LABEL_12;
}
}
return 1;
}
}
}
else
{
return 0;
}
return v2;
}
| is_sorted:
PUSH RBX
TEST RDI,RDI
JZ 0x0010199c
MOV EBX,0x1
CMP ESI,0x2
JL 0x001019a5
MOV R8D,dword ptr [RDI]
MOV ECX,dword ptr [RDI + 0x4]
CMP ECX,R8D
JL 0x001019a9
MOV EAX,ESI
MOV ESI,0x2
SUB RSI,RAX
MOV EDX,0x1
LAB_00101978:
LEA RCX,[RSI + RDX*0x1]
CMP RCX,0x1
JZ 0x001019a0
MOV R8D,dword ptr [RDI + RDX*0x4]
MOV ECX,dword ptr [RDI + RDX*0x4 + 0x4]
INC RDX
CMP ECX,R8D
JGE 0x00101978
XOR EBX,EBX
CMP RDX,RAX
SETNC BL
JMP 0x001019b0
LAB_0010199c:
XOR EBX,EBX
JMP 0x001019a5
LAB_001019a0:
MOV EBX,0x1
LAB_001019a5:
MOV EAX,EBX
POP RBX
RET
LAB_001019a9:
XOR EBX,EBX
MOV EDX,0x1
LAB_001019b0:
MOV RAX,qword ptr [0x00106ff8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1040c8]
XOR EAX,EAX
CALL 0x00101120
JMP 0x001019a5
|
bool is_sorted(int *param_1,uint param_2)
{
int *piVar1;
long lVar2;
ulong uVar3;
bool bVar4;
if (param_1 == (int *)0x0) {
bVar4 = false;
}
else {
bVar4 = true;
if (1 < (int)param_2) {
if (param_1[1] < *param_1) {
bVar4 = false;
uVar3 = 1;
}
else {
uVar3 = 1;
do {
if ((2 - (ulong)param_2) + uVar3 == 1) {
return true;
}
piVar1 = param_1 + uVar3;
lVar2 = uVar3 + 1;
uVar3 = uVar3 + 1;
} while (*piVar1 <= param_1[lVar2]);
bVar4 = param_2 <= uVar3;
}
fprintf(*(FILE **)PTR_stderr_00106ff8,"Verification FAILED at index %d: %d < %d\n",uVar3);
}
}
return bVar4;
}
| |
50,611 | bitmap_lock_clear_bit | eloqsql/mysys/my_bitmap.c | void bitmap_lock_clear_bit(MY_BITMAP *map, uint bitmap_bit)
{
bitmap_lock(map);
DBUG_ASSERT(map->bitmap);
DBUG_ASSERT(bitmap_bit < map->n_bits);
bitmap_clear_bit(map, bitmap_bit);
bitmap_unlock(map);
} | O3 | c | bitmap_lock_clear_bit:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xba8e4
cmpq $0x0, 0x40(%rdi)
jne 0xba925
callq 0x2a230
movq (%rbx), %rax
movl %r14d, %edx
shrl $0x3, %edx
andb $0x7, %r14b
movl $0x1, %esi
movl %r14d, %ecx
shll %cl, %esi
notb %sil
andb %sil, (%rax,%rdx)
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0xba920
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
jne 0xba938
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2a1f0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x45426(%rip), %rsi # 0xffd52
movl $0x81, %edx
callq 0x312ea
jmp 0xba8e4
leaq 0x2f40d9(%rip), %rax # 0x3aea18
movq (%rax), %rax
callq *0x160(%rax)
jmp 0xba914
nop
| bitmap_lock_clear_bit:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14d, esi
mov rbx, rdi
mov rdi, [rdi+10h]
test rdi, rdi
jz short loc_BA8E4
cmp qword ptr [rdi+40h], 0
jnz short loc_BA925
call _pthread_mutex_lock
loc_BA8E4:
mov rax, [rbx]
mov edx, r14d
shr edx, 3
and r14b, 7
mov esi, 1
mov ecx, r14d
shl esi, cl
not sil
and [rax+rdx], sil
mov rbx, [rbx+10h]
test rbx, rbx
jz short loc_BA920
mov rdi, [rbx+40h]
test rdi, rdi
jnz short loc_BA938
loc_BA914:
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp _pthread_mutex_unlock
loc_BA920:
pop rbx
pop r14
pop rbp
retn
loc_BA925:
lea rsi, aWorkspaceLlm4b_52; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 81h
call psi_mutex_lock
jmp short loc_BA8E4
loc_BA938:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_BA914
| long long bitmap_lock_clear_bit(long long *a1, unsigned int a2)
{
long long v3; // rdi
long long result; // rax
long long v5; // rbx
v3 = a1[2];
if ( v3 )
{
if ( *(_QWORD *)(v3 + 64) )
psi_mutex_lock(v3, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/my_bitmap.c", 0x81u);
else
pthread_mutex_lock(v3);
}
result = *a1;
*(_BYTE *)(*a1 + (a2 >> 3)) &= ~(unsigned __int8)(1 << (a2 & 7));
v5 = a1[2];
if ( v5 )
{
if ( *(_QWORD *)(v5 + 64) )
PSI_server[44]();
return pthread_mutex_unlock(v5);
}
return result;
}
| bitmap_lock_clear_bit:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14D,ESI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x10]
TEST RDI,RDI
JZ 0x001ba8e4
CMP qword ptr [RDI + 0x40],0x0
JNZ 0x001ba925
CALL 0x0012a230
LAB_001ba8e4:
MOV RAX,qword ptr [RBX]
MOV EDX,R14D
SHR EDX,0x3
AND R14B,0x7
MOV ESI,0x1
MOV ECX,R14D
SHL ESI,CL
NOT SIL
AND byte ptr [RAX + RDX*0x1],SIL
MOV RBX,qword ptr [RBX + 0x10]
TEST RBX,RBX
JZ 0x001ba920
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JNZ 0x001ba938
LAB_001ba914:
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x0012a1f0
LAB_001ba920:
POP RBX
POP R14
POP RBP
RET
LAB_001ba925:
LEA RSI,[0x1ffd52]
MOV EDX,0x81
CALL 0x001312ea
JMP 0x001ba8e4
LAB_001ba938:
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001ba914
|
void bitmap_lock_clear_bit(long *param_1,uint param_2)
{
byte *pbVar1;
pthread_mutex_t *ppVar2;
ppVar2 = (pthread_mutex_t *)param_1[2];
if (ppVar2 != (pthread_mutex_t *)0x0) {
if (*(long *)((long)ppVar2 + 0x40) == 0) {
pthread_mutex_lock(ppVar2);
}
else {
psi_mutex_lock(ppVar2,"/workspace/llm4binary/github2025/eloqsql/mysys/my_bitmap.c",0x81);
}
}
pbVar1 = (byte *)(*param_1 + (ulong)(param_2 >> 3));
*pbVar1 = *pbVar1 & ~(byte)(1 << ((byte)param_2 & 7));
ppVar2 = (pthread_mutex_t *)param_1[2];
if (ppVar2 != (pthread_mutex_t *)0x0) {
if (*(long *)((long)ppVar2 + 0x40) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(ppVar2);
return;
}
return;
}
| |
50,612 | plutovg_skip_ws | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-utils.h | static inline bool plutovg_skip_ws(const char** begin, const char* end)
{
const char* it = *begin;
while(it < end && PLUTOVG_IS_WS(*it))
++it;
*begin = it;
return it < end;
} | O0 | c | plutovg_skip_ws:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
jae 0xdcaf
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x1a(%rbp)
je 0xdca9
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x1a(%rbp)
je 0xdca9
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x1a(%rbp)
je 0xdca9
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xdcb8
jmp 0xdcc6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xdc57
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
setb %al
andb $0x1, %al
popq %rbp
retq
| plutovg_skip_ws_0:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
loc_DC57:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_10]
mov [rbp+var_19], al
jnb short loc_DCAF
mov rax, [rbp+var_18]
movsx ecx, byte ptr [rax]
mov al, 1
cmp ecx, 20h ; ' '
mov [rbp+var_1A], al
jz short loc_DCA9
mov rax, [rbp+var_18]
movsx ecx, byte ptr [rax]
mov al, 1
cmp ecx, 9
mov [rbp+var_1A], al
jz short loc_DCA9
mov rax, [rbp+var_18]
movsx ecx, byte ptr [rax]
mov al, 1
cmp ecx, 0Ah
mov [rbp+var_1A], al
jz short loc_DCA9
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
cmp eax, 0Dh
setz al
mov [rbp+var_1A], al
loc_DCA9:
mov al, [rbp+var_1A]
mov [rbp+var_19], al
loc_DCAF:
mov al, [rbp+var_19]
test al, 1
jnz short loc_DCB8
jmp short loc_DCC6
loc_DCB8:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_DC57
loc_DCC6:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
mov [rax], rcx
mov rax, [rbp+var_18]
cmp rax, [rbp+var_10]
setb al
and al, 1
pop rbp
retn
| bool plutovg_skip_ws_0(_BYTE **a1, unsigned long long a2)
{
bool v3; // [rsp+0h] [rbp-1Ah]
bool v4; // [rsp+1h] [rbp-19h]
_BYTE *i; // [rsp+2h] [rbp-18h]
for ( i = *a1; ; ++i )
{
v4 = 0;
if ( (unsigned long long)i < a2 )
{
v3 = 1;
if ( *i != 32 )
{
v3 = 1;
if ( *i != 9 )
{
v3 = 1;
if ( *i != 10 )
v3 = *i == 13;
}
}
v4 = v3;
}
if ( !v4 )
break;
}
*a1 = i;
return (unsigned long long)i < a2;
}
| plutovg_skip_ws:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LAB_0010dc57:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x10]
MOV byte ptr [RBP + -0x19],AL
JNC 0x0010dcaf
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RAX]
MOV AL,0x1
CMP ECX,0x20
MOV byte ptr [RBP + -0x1a],AL
JZ 0x0010dca9
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RAX]
MOV AL,0x1
CMP ECX,0x9
MOV byte ptr [RBP + -0x1a],AL
JZ 0x0010dca9
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RAX]
MOV AL,0x1
CMP ECX,0xa
MOV byte ptr [RBP + -0x1a],AL
JZ 0x0010dca9
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0xd
SETZ AL
MOV byte ptr [RBP + -0x1a],AL
LAB_0010dca9:
MOV AL,byte ptr [RBP + -0x1a]
MOV byte ptr [RBP + -0x19],AL
LAB_0010dcaf:
MOV AL,byte ptr [RBP + -0x19]
TEST AL,0x1
JNZ 0x0010dcb8
JMP 0x0010dcc6
LAB_0010dcb8:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0010dc57
LAB_0010dcc6:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x10]
SETC AL
AND AL,0x1
POP RBP
RET
|
int8 plutovg_skip_ws(int8 *param_1,char *param_2)
{
bool bVar1;
char *local_20;
local_20 = (char *)*param_1;
while( true ) {
bVar1 = false;
if ((((local_20 < param_2) && (bVar1 = true, *local_20 != ' ')) &&
(bVar1 = true, *local_20 != '\t')) && (bVar1 = true, *local_20 != '\n')) {
bVar1 = *local_20 == '\r';
}
if (!bVar1) break;
local_20 = local_20 + 1;
}
*param_1 = local_20;
return CONCAT71((int7)((ulong)local_20 >> 8),local_20 < param_2);
}
| |
50,613 | fs_validate_filename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | bool fs_validate_filename(const std::string & filename) {
if (!filename.length()) {
// Empty filename invalid
return false;
}
if (filename.length() > 255) {
// Limit at common largest possible filename on Linux filesystems
// to avoid unnecessary further validation
// (On systems with smaller limits it will be caught by the OS)
return false;
}
std::u32string filename_utf32;
try {
#if defined(__clang__)
// disable C++17 deprecation warning for std::codecvt_utf8
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wdeprecated-declarations"
#endif
std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
#if defined(__clang__)
# pragma clang diagnostic pop
#endif
filename_utf32 = converter.from_bytes(filename);
// If the reverse conversion mismatches, it means overlong UTF-8 sequences were used,
// or invalid encodings were encountered. Reject such attempts
std::string filename_reencoded = converter.to_bytes(filename_utf32);
if (filename_reencoded != filename) {
return false;
}
} catch (const std::exception &) {
return false;
}
// Check for forbidden codepoints:
// - Control characters
// - Unicode equivalents of illegal characters
// - UTF-16 surrogate pairs
// - UTF-8 replacement character
// - Byte order mark (BOM)
// - Illegal characters: / \ : * ? " < > |
for (char32_t c : filename_utf32) {
if (c <= 0x1F // Control characters (C0)
|| c == 0x7F // Control characters (DEL)
|| (c >= 0x80 && c <= 0x9F) // Control characters (C1)
|| c == 0xFF0E // Fullwidth Full Stop (period equivalent)
|| c == 0x2215 // Division Slash (forward slash equivalent)
|| c == 0x2216 // Set Minus (backslash equivalent)
|| (c >= 0xD800 && c <= 0xDFFF) // UTF-16 surrogate pairs
|| c == 0xFFFD // Replacement Character (UTF-8)
|| c == 0xFEFF // Byte Order Mark (BOM)
|| c == '/' || c == '\\' || c == ':' || c == '*' // Illegal characters
|| c == '?' || c == '"' || c == '<' || c == '>' || c == '|') {
return false;
}
}
// Reject any leading or trailing ' ', or any trailing '.', these are stripped on Windows and will cause a different filename
// Unicode and other whitespace is not affected, only 0x20 space
if (filename.front() == ' ' || filename.back() == ' ' || filename.back() == '.') {
return false;
}
// Reject any ".." (currently stricter than necessary, it should be fine to just check for == ".." instead)
if (filename.find("..") != std::string::npos) {
return false;
}
// Reject "."
if (filename == ".") {
return false;
}
return true;
} | O0 | cpp | fs_validate_filename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x118(%rsp)
movq 0x118(%rsp), %rdi
callq 0x5da10
cmpq $0x0, %rax
jne 0xf024f
movb $0x0, 0x127(%rsp)
jmp 0xf05e7
movq 0x118(%rsp), %rdi
callq 0x5da10
cmpq $0xff, %rax
jbe 0xf0271
movb $0x0, 0x127(%rsp)
jmp 0xf05e7
leaq 0xf8(%rsp), %rdi
callq 0xf9c30
leaq 0x98(%rsp), %rdi
callq 0xf9cb0
jmp 0xf028d
movq 0x118(%rsp), %rdx
leaq 0x68(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xf9d70
jmp 0xf02a9
leaq 0xf8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x68(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0xf9df0
movq 0x8(%rsp), %rdi
callq 0xfa030
movq 0x10(%rsp), %rdx
leaq 0x48(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xfa070
jmp 0xf02e8
movq 0x118(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0xfa0f0
testb $0x1, %al
jne 0xf0303
jmp 0xf0389
movb $0x0, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xf0391
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xf034c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xfa120
movl 0x8c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xf05d8
movq 0x90(%rsp), %rdi
callq 0x5d0e0
movq %rax, 0x38(%rsp)
movb $0x0, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
callq 0x5ddc0
jmp 0xf03b8
movl $0x0, 0x44(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5e548
leaq 0x98(%rsp), %rdi
callq 0xfa120
movl 0x44(%rsp), %eax
testl %eax, %eax
jne 0xf05c9
jmp 0xf03b6
jmp 0xf03d6
jmp 0xf05c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xf05d8
leaq 0xf8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0xfa160
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0xfa190
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xfa1f0
testb $0x1, %al
jne 0xf0419
jmp 0xf0502
leaq 0x28(%rsp), %rdi
callq 0xfa230
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x1f, 0x1c(%rsp)
jbe 0xf04dc
cmpl $0x7f, 0x1c(%rsp)
je 0xf04dc
cmpl $0x80, 0x1c(%rsp)
jb 0xf0457
cmpl $0x9f, 0x1c(%rsp)
jbe 0xf04dc
cmpl $0xff0e, 0x1c(%rsp) # imm = 0xFF0E
je 0xf04dc
cmpl $0x2215, 0x1c(%rsp) # imm = 0x2215
je 0xf04dc
cmpl $0x2216, 0x1c(%rsp) # imm = 0x2216
je 0xf04dc
cmpl $0xd800, 0x1c(%rsp) # imm = 0xD800
jb 0xf0489
cmpl $0xdfff, 0x1c(%rsp) # imm = 0xDFFF
jbe 0xf04dc
cmpl $0xfffd, 0x1c(%rsp) # imm = 0xFFFD
je 0xf04dc
cmpl $0xfeff, 0x1c(%rsp) # imm = 0xFEFF
je 0xf04dc
cmpl $0x2f, 0x1c(%rsp)
je 0xf04dc
cmpl $0x5c, 0x1c(%rsp)
je 0xf04dc
cmpl $0x3a, 0x1c(%rsp)
je 0xf04dc
cmpl $0x2a, 0x1c(%rsp)
je 0xf04dc
cmpl $0x3f, 0x1c(%rsp)
je 0xf04dc
cmpl $0x22, 0x1c(%rsp)
je 0xf04dc
cmpl $0x3c, 0x1c(%rsp)
je 0xf04dc
cmpl $0x3e, 0x1c(%rsp)
je 0xf04dc
cmpl $0x7c, 0x1c(%rsp)
jne 0xf04f1
movb $0x0, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xf05c9
jmp 0xf04f3
leaq 0x28(%rsp), %rdi
callq 0xfa240
jmp 0xf0401
movq 0x118(%rsp), %rdi
callq 0x5d250
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0xf0541
movq 0x118(%rsp), %rdi
callq 0x5df30
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0xf0541
movq 0x118(%rsp), %rdi
callq 0x5df30
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xf0553
movb $0x0, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xf05c9
movq 0x118(%rsp), %rdi
leaq 0x123042(%rip), %rsi # 0x2135a4
xorl %eax, %eax
movl %eax, %edx
callq 0x5d060
cmpq $-0x1, %rax
je 0xf0583
movb $0x0, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xf05c9
movq 0x118(%rsp), %rdi
leaq 0x123013(%rip), %rsi # 0x2135a5
callq 0x8dbd0
movb %al, 0x7(%rsp)
jmp 0xf059d
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xf05a7
jmp 0xf05b9
movb $0x0, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xf05c9
movb $0x1, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0xfa030
jmp 0xf05e7
leaq 0xf8(%rsp), %rdi
callq 0xfa030
jmp 0xf05f8
movb 0x127(%rsp), %al
andb $0x1, %al
addq $0x128, %rsp # imm = 0x128
retq
movq 0x90(%rsp), %rdi
callq 0x5dbc0
nopw %cs:(%rax,%rax)
| _Z20fs_validate_filenameRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 128h
mov [rsp+128h+var_10], rdi
mov rdi, [rsp+128h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
cmp rax, 0
jnz short loc_F024F
mov [rsp+128h+var_1], 0
jmp loc_F05E7
loc_F024F:
mov rdi, [rsp+128h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
cmp rax, 0FFh
jbe short loc_F0271
mov [rsp+128h+var_1], 0
jmp loc_F05E7
loc_F0271:
lea rdi, [rsp+128h+var_30]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEC2Ev; std::basic_string<char32_t>::basic_string(void)
lea rdi, [rsp+128h+var_90]; int
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEEC2Ev; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::wstring_convert(void)
jmp short $+2
loc_F028D:
mov rdx, [rsp+128h+var_10]
lea rdi, [rsp+128h+var_C0]
lea rsi, [rsp+128h+var_90]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEE10from_bytesERKNS_12basic_stringIcSt11char_traitsIcES5_EE; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::from_bytes(std::string const&)
jmp short $+2
loc_F02A9:
lea rdi, [rsp+128h+var_30]
mov [rsp+128h+var_118], rdi
lea rsi, [rsp+128h+var_C0]
mov [rsp+128h+var_120], rsi
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEaSEOS4_; std::basic_string<char32_t>::operator=(std::basic_string<char32_t>&&)
mov rdi, [rsp+128h+var_120]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEED2Ev; std::basic_string<char32_t>::~basic_string()
mov rdx, [rsp+128h+var_118]
lea rdi, [rsp+128h+var_E0]
lea rsi, [rsp+128h+var_90]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEE8to_bytesERKNS_12basic_stringIDiSt11char_traitsIDiES4_EE; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::to_bytes(std::basic_string<char32_t> const&)
jmp short $+2
loc_F02E8:
mov rsi, [rsp+128h+var_10]
lea rdi, [rsp+128h+var_E0]
call _ZStneIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EESA_; std::operator!=<char>(std::string const&,std::string const&)
test al, 1
jnz short loc_F0303
jmp loc_F0389
loc_F0303:
mov [rsp+128h+var_1], 0
mov [rsp+128h+var_E4], 1
jmp short loc_F0391
mov rcx, rax
mov eax, edx
mov [rsp+128h+var_98], rcx
mov [rsp+128h+var_9C], eax
jmp short loc_F034C
mov rcx, rax
mov eax, edx
mov [rsp+128h+var_98], rcx
mov [rsp+128h+var_9C], eax
lea rdi, [rsp+128h+var_90]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEED2Ev; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::~wstring_convert()
loc_F034C:
mov eax, [rsp+128h+var_9C]
mov ecx, 1
cmp eax, ecx
jnz loc_F05D8
mov rdi, [rsp+128h+var_98]; void *
call ___cxa_begin_catch
mov [rsp+128h+var_F0], rax
mov [rsp+128h+var_1], 0
mov [rsp+128h+var_E4], 1
call ___cxa_end_catch
jmp short loc_F03B8
loc_F0389:
mov [rsp+128h+var_E4], 0
loc_F0391:
lea rdi, [rsp+128h+var_E0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+128h+var_90]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEED2Ev; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::~wstring_convert()
mov eax, [rsp+128h+var_E4]
test eax, eax
jnz loc_F05C9
jmp short $+2
loc_F03B6:
jmp short loc_F03D6
loc_F03B8:
jmp loc_F05C9
mov rcx, rax
mov eax, edx
mov [rsp+128h+var_98], rcx
mov [rsp+128h+var_9C], eax
jmp loc_F05D8
loc_F03D6:
lea rax, [rsp+128h+var_30]
mov [rsp+128h+var_F8], rax
mov rdi, [rsp+128h+var_F8]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEE5beginEv; std::basic_string<char32_t>::begin(void)
mov [rsp+128h+var_100], rax
mov rdi, [rsp+128h+var_F8]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEE3endEv; std::basic_string<char32_t>::end(void)
mov [rsp+128h+var_108], rax
loc_F0401:
lea rdi, [rsp+128h+var_100]
lea rsi, [rsp+128h+var_108]
call _ZN9__gnu_cxxneIPDiNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEEEEbRKNS_17__normal_iteratorIT_T0_EESD_; __gnu_cxx::operator!=<char32_t *,std::basic_string<char32_t>>(__gnu_cxx::__normal_iterator<char32_t *,std::basic_string<char32_t>> const&,__gnu_cxx::__normal_iterator<char32_t *,std::basic_string<char32_t>> const&)
test al, 1
jnz short loc_F0419
jmp loc_F0502
loc_F0419:
lea rdi, [rsp+128h+var_100]
call _ZNK9__gnu_cxx17__normal_iteratorIPDiNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEEEdeEv; __gnu_cxx::__normal_iterator<char32_t *,std::basic_string<char32_t>>::operator*(void)
mov eax, [rax]
mov [rsp+128h+var_10C], eax
cmp [rsp+128h+var_10C], 1Fh
jbe loc_F04DC
cmp [rsp+128h+var_10C], 7Fh
jz loc_F04DC
cmp [rsp+128h+var_10C], 80h
jb short loc_F0457
cmp [rsp+128h+var_10C], 9Fh
jbe loc_F04DC
loc_F0457:
cmp [rsp+128h+var_10C], 0FF0Eh
jz short loc_F04DC
cmp [rsp+128h+var_10C], 2215h
jz short loc_F04DC
cmp [rsp+128h+var_10C], 2216h
jz short loc_F04DC
cmp [rsp+128h+var_10C], 0D800h
jb short loc_F0489
cmp [rsp+128h+var_10C], 0DFFFh
jbe short loc_F04DC
loc_F0489:
cmp [rsp+128h+var_10C], 0FFFDh
jz short loc_F04DC
cmp [rsp+128h+var_10C], 0FEFFh
jz short loc_F04DC
cmp [rsp+128h+var_10C], 2Fh ; '/'
jz short loc_F04DC
cmp [rsp+128h+var_10C], 5Ch ; '\'
jz short loc_F04DC
cmp [rsp+128h+var_10C], 3Ah ; ':'
jz short loc_F04DC
cmp [rsp+128h+var_10C], 2Ah ; '*'
jz short loc_F04DC
cmp [rsp+128h+var_10C], 3Fh ; '?'
jz short loc_F04DC
cmp [rsp+128h+var_10C], 22h ; '"'
jz short loc_F04DC
cmp [rsp+128h+var_10C], 3Ch ; '<'
jz short loc_F04DC
cmp [rsp+128h+var_10C], 3Eh ; '>'
jz short loc_F04DC
cmp [rsp+128h+var_10C], 7Ch ; '|'
jnz short loc_F04F1
loc_F04DC:
mov [rsp+128h+var_1], 0
mov [rsp+128h+var_E4], 1
jmp loc_F05C9
loc_F04F1:
jmp short $+2
loc_F04F3:
lea rdi, [rsp+128h+var_100]
call _ZN9__gnu_cxx17__normal_iteratorIPDiNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEEEppEv; __gnu_cxx::__normal_iterator<char32_t *,std::basic_string<char32_t>>::operator++(void)
jmp loc_F0401
loc_F0502:
mov rdi, [rsp+128h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5frontEv; std::string::front(void)
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
jz short loc_F0541
mov rdi, [rsp+128h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4backEv; std::string::back(void)
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
jz short loc_F0541
mov rdi, [rsp+128h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4backEv; std::string::back(void)
movsx eax, byte ptr [rax]
cmp eax, 2Eh ; '.'
jnz short loc_F0553
loc_F0541:
mov [rsp+128h+var_1], 0
mov [rsp+128h+var_E4], 1
jmp short loc_F05C9
loc_F0553:
mov rdi, [rsp+128h+var_10]
lea rsi, aN0N1+7; ".."
xor eax, eax
mov edx, eax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcm; std::string::find(char const*,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_F0583
mov [rsp+128h+var_1], 0
mov [rsp+128h+var_E4], 1
jmp short loc_F05C9
loc_F0583:
mov rdi, [rsp+128h+var_10]
lea rsi, aN0N1+8; "."
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov [rsp+128h+var_121], al
jmp short $+2
loc_F059D:
mov al, [rsp+128h+var_121]
test al, 1
jnz short loc_F05A7
jmp short loc_F05B9
loc_F05A7:
mov [rsp+128h+var_1], 0
mov [rsp+128h+var_E4], 1
jmp short loc_F05C9
loc_F05B9:
mov [rsp+128h+var_1], 1
mov [rsp+128h+var_E4], 1
loc_F05C9:
lea rdi, [rsp+128h+var_30]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEED2Ev; std::basic_string<char32_t>::~basic_string()
jmp short loc_F05E7
loc_F05D8:
lea rdi, [rsp+128h+var_30]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEED2Ev; std::basic_string<char32_t>::~basic_string()
jmp short loc_F05F8
loc_F05E7:
mov al, [rsp+128h+var_1]
and al, 1
add rsp, 128h
retn
loc_F05F8:
mov rdi, [rsp+128h+var_98]
call __Unwind_Resume
| bool fs_validate_filename(long long a1, int a2)
{
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
int v7; // [rsp+0h] [rbp-128h]
int v8; // [rsp+8h] [rbp-120h]
void *v9; // [rsp+10h] [rbp-118h]
int v10; // [rsp+18h] [rbp-110h]
unsigned int v11; // [rsp+1Ch] [rbp-10Ch]
long long v12; // [rsp+20h] [rbp-108h] BYREF
_QWORD v13[2]; // [rsp+28h] [rbp-100h] BYREF
int v14; // [rsp+44h] [rbp-E4h]
_BYTE v15[32]; // [rsp+48h] [rbp-E0h] BYREF
_BYTE v16[36]; // [rsp+68h] [rbp-C0h] BYREF
int v17[24]; // [rsp+98h] [rbp-90h] BYREF
_BYTE v18[32]; // [rsp+F8h] [rbp-30h] BYREF
long long v19; // [rsp+118h] [rbp-10h]
bool v20; // [rsp+127h] [rbp-1h]
v19 = a1;
if ( std::string::length(a1) )
{
if ( (unsigned long long)std::string::length(v19) <= 0xFF )
{
std::basic_string<char32_t>::basic_string(v18);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::wstring_convert(
(int)v17,
a2,
v2,
v3,
v4,
v5,
v7,
v8,
v9,
v10,
v12);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::from_bytes(
v16,
v17,
v19);
std::basic_string<char32_t>::operator=();
std::basic_string<char32_t>::~basic_string(v16);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::to_bytes(
v15,
v17,
v18);
if ( (std::operator!=<char>(v15, v19) & 1) != 0 )
{
v20 = 0;
v14 = 1;
}
else
{
v14 = 0;
}
std::string::~string(v15);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::~wstring_convert(v17);
if ( !v14 )
{
v13[1] = v18;
v13[0] = std::basic_string<char32_t>::begin(v18);
v12 = std::basic_string<char32_t>::end(v18);
while ( (__gnu_cxx::operator!=<char32_t *,std::basic_string<char32_t>>(v13, &v12) & 1) != 0 )
{
v11 = *(_DWORD *)__gnu_cxx::__normal_iterator<char32_t *,std::basic_string<char32_t>>::operator*(v13);
if ( v11 <= 0x1F
|| v11 == 127
|| v11 >= 0x80 && v11 <= 0x9F
|| v11 == 65294
|| v11 == 8725
|| v11 == 8726
|| v11 >= 0xD800 && v11 <= 0xDFFF
|| v11 == 65533
|| v11 == 65279
|| v11 == 47
|| v11 == 92
|| v11 == 58
|| v11 == 42
|| v11 == 63
|| v11 == 34
|| v11 == 60
|| v11 == 62
|| v11 == 124 )
{
v20 = 0;
v14 = 1;
goto LABEL_41;
}
__gnu_cxx::__normal_iterator<char32_t *,std::basic_string<char32_t>>::operator++(v13);
}
if ( *(_BYTE *)std::string::front(v19) == 32
|| *(_BYTE *)std::string::back(v19) == 32
|| *(_BYTE *)std::string::back(v19) == 46 )
{
v20 = 0;
v14 = 1;
}
else
{
v20 = std::string::find(v19, "..", 0LL) == -1 && !std::operator==<char>(v19, (long long)".");
v14 = 1;
}
}
LABEL_41:
std::basic_string<char32_t>::~basic_string(v18);
}
else
{
return 0;
}
}
else
{
return 0;
}
return v20;
}
| fs_validate_filename:
SUB RSP,0x128
MOV qword ptr [RSP + 0x118],RDI
MOV RDI,qword ptr [RSP + 0x118]
CALL 0x0015da10
CMP RAX,0x0
JNZ 0x001f024f
MOV byte ptr [RSP + 0x127],0x0
JMP 0x001f05e7
LAB_001f024f:
MOV RDI,qword ptr [RSP + 0x118]
CALL 0x0015da10
CMP RAX,0xff
JBE 0x001f0271
MOV byte ptr [RSP + 0x127],0x0
JMP 0x001f05e7
LAB_001f0271:
LEA RDI,[RSP + 0xf8]
CALL 0x001f9c30
LAB_001f027e:
LEA RDI,[RSP + 0x98]
CALL 0x001f9cb0
JMP 0x001f028d
LAB_001f028d:
MOV RDX,qword ptr [RSP + 0x118]
LAB_001f0295:
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x98]
CALL 0x001f9d70
JMP 0x001f02a9
LAB_001f02a9:
LEA RDI,[RSP + 0xf8]
MOV qword ptr [RSP + 0x10],RDI
LEA RSI,[RSP + 0x68]
MOV qword ptr [RSP + 0x8],RSI
CALL 0x001f9df0
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001fa030
MOV RDX,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x98]
CALL 0x001fa070
LAB_001f02e6:
JMP 0x001f02e8
LAB_001f02e8:
MOV RSI,qword ptr [RSP + 0x118]
LEA RDI,[RSP + 0x48]
CALL 0x001fa0f0
TEST AL,0x1
JNZ 0x001f0303
JMP 0x001f0389
LAB_001f0303:
MOV byte ptr [RSP + 0x127],0x0
MOV dword ptr [RSP + 0x44],0x1
JMP 0x001f0391
LAB_001f0389:
MOV dword ptr [RSP + 0x44],0x0
LAB_001f0391:
LEA RDI,[RSP + 0x48]
CALL 0x0015e548
LEA RDI,[RSP + 0x98]
CALL 0x001fa120
MOV EAX,dword ptr [RSP + 0x44]
TEST EAX,EAX
JNZ 0x001f05c9
JMP 0x001f03b6
LAB_001f03b6:
JMP 0x001f03d6
LAB_001f03d6:
LEA RAX,[RSP + 0xf8]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x001fa160
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x001fa190
MOV qword ptr [RSP + 0x20],RAX
LAB_001f0401:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x20]
CALL 0x001fa1f0
TEST AL,0x1
JNZ 0x001f0419
JMP 0x001f0502
LAB_001f0419:
LEA RDI,[RSP + 0x28]
CALL 0x001fa230
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x1c],EAX
CMP dword ptr [RSP + 0x1c],0x1f
JBE 0x001f04dc
CMP dword ptr [RSP + 0x1c],0x7f
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0x80
JC 0x001f0457
CMP dword ptr [RSP + 0x1c],0x9f
JBE 0x001f04dc
LAB_001f0457:
CMP dword ptr [RSP + 0x1c],0xff0e
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0x2215
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0x2216
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0xd800
JC 0x001f0489
CMP dword ptr [RSP + 0x1c],0xdfff
JBE 0x001f04dc
LAB_001f0489:
CMP dword ptr [RSP + 0x1c],0xfffd
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0xfeff
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0x2f
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0x5c
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0x3a
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0x2a
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0x3f
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0x22
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0x3c
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0x3e
JZ 0x001f04dc
CMP dword ptr [RSP + 0x1c],0x7c
JNZ 0x001f04f1
LAB_001f04dc:
MOV byte ptr [RSP + 0x127],0x0
MOV dword ptr [RSP + 0x44],0x1
JMP 0x001f05c9
LAB_001f04f1:
JMP 0x001f04f3
LAB_001f04f3:
LEA RDI,[RSP + 0x28]
CALL 0x001fa240
JMP 0x001f0401
LAB_001f0502:
MOV RDI,qword ptr [RSP + 0x118]
CALL 0x0015d250
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
JZ 0x001f0541
MOV RDI,qword ptr [RSP + 0x118]
CALL 0x0015df30
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
JZ 0x001f0541
MOV RDI,qword ptr [RSP + 0x118]
CALL 0x0015df30
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2e
JNZ 0x001f0553
LAB_001f0541:
MOV byte ptr [RSP + 0x127],0x0
MOV dword ptr [RSP + 0x44],0x1
JMP 0x001f05c9
LAB_001f0553:
MOV RDI,qword ptr [RSP + 0x118]
LEA RSI,[0x3135a4]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x0015d060
CMP RAX,-0x1
JZ 0x001f0583
MOV byte ptr [RSP + 0x127],0x0
MOV dword ptr [RSP + 0x44],0x1
JMP 0x001f05c9
LAB_001f0583:
MOV RDI,qword ptr [RSP + 0x118]
LEA RSI,[0x3135a5]
CALL 0x0018dbd0
LAB_001f0597:
MOV byte ptr [RSP + 0x7],AL
JMP 0x001f059d
LAB_001f059d:
MOV AL,byte ptr [RSP + 0x7]
TEST AL,0x1
JNZ 0x001f05a7
JMP 0x001f05b9
LAB_001f05a7:
MOV byte ptr [RSP + 0x127],0x0
MOV dword ptr [RSP + 0x44],0x1
JMP 0x001f05c9
LAB_001f05b9:
MOV byte ptr [RSP + 0x127],0x1
MOV dword ptr [RSP + 0x44],0x1
LAB_001f05c9:
LEA RDI,[RSP + 0xf8]
CALL 0x001fa030
JMP 0x001f05e7
LAB_001f05e7:
MOV AL,byte ptr [RSP + 0x127]
AND AL,0x1
ADD RSP,0x128
RET
|
/* fs_validate_filename(std::__cxx11::string const&) */
ulong fs_validate_filename(string *param_1)
{
uint uVar1;
bool bVar2;
long lVar3;
ulong uVar4;
uint *puVar5;
char *pcVar6;
int8 local_108;
int8 local_100;
u32string *local_f8;
uint local_e4;
u32string local_e0 [32];
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
local_c0 [48];
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
local_90 [96];
u32string local_30 [32];
string *local_10;
int1 local_1;
local_10 = param_1;
lVar3 = std::__cxx11::string::length();
if (lVar3 == 0) {
local_1 = 0;
uVar4 = 0;
}
else {
uVar4 = std::__cxx11::string::length();
if (uVar4 < 0x100) {
std::__cxx11::u32string::u32string(local_30);
/* try { // try from 001f027e to 001f028a has its CatchHandler @ 001f0315 */
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::wstring_convert(local_90);
/* try { // try from 001f0295 to 001f02e5 has its CatchHandler @ 001f032b */
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::from_bytes(local_c0,(string *)local_90);
std::__cxx11::u32string::operator=(local_30,(u32string *)local_c0);
std::__cxx11::u32string::~u32string((u32string *)local_c0);
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::to_bytes(local_e0);
bVar2 = std::operator!=((string *)local_e0,local_10);
if (bVar2) {
local_1 = 0;
}
local_e4 = (uint)bVar2;
std::__cxx11::string::~string((string *)local_e0);
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::~wstring_convert(local_90);
if (local_e4 == 0) {
local_f8 = local_30;
local_100 = std::__cxx11::u32string::begin(local_f8);
local_108 = std::__cxx11::u32string::end(local_f8);
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_100,(__normal_iterator *)&local_108),
bVar2) {
puVar5 = (uint *)__gnu_cxx::__normal_iterator<char32_t*,std::__cxx11::u32string>::
operator*((__normal_iterator<char32_t*,std::__cxx11::u32string> *)
&local_100);
uVar1 = *puVar5;
if ((((((uVar1 < 0x20) || (uVar1 == 0x7f)) || ((0x7f < uVar1 && (uVar1 < 0xa0)))) ||
((uVar1 == 0xff0e || (uVar1 == 0x2215)))) ||
((uVar1 == 0x2216 ||
((((0xd7ff < uVar1 && (uVar1 < 0xe000)) || (uVar1 == 0xfffd)) ||
(((uVar1 == 0xfeff || (uVar1 == 0x2f)) ||
((uVar1 == 0x5c || ((uVar1 == 0x3a || (uVar1 == 0x2a)))))))))))) ||
((uVar1 == 0x3f ||
((((uVar1 == 0x22 || (uVar1 == 0x3c)) || (uVar1 == 0x3e)) || (uVar1 == 0x7c)))))) {
local_1 = 0;
local_e4 = 1;
goto LAB_001f05c9;
}
__gnu_cxx::__normal_iterator<char32_t*,std::__cxx11::u32string>::operator++
((__normal_iterator<char32_t*,std::__cxx11::u32string> *)&local_100);
}
pcVar6 = (char *)std::__cxx11::string::front();
if (((*pcVar6 == ' ') || (pcVar6 = (char *)std::__cxx11::string::back(), *pcVar6 == ' ')) ||
(pcVar6 = (char *)std::__cxx11::string::back(), *pcVar6 == '.')) {
local_1 = 0;
local_e4 = 1;
}
else {
lVar3 = std::__cxx11::string::find((char *)local_10,0x3135a4);
if (lVar3 == -1) {
bVar2 = std::operator==(local_10,".");
if (bVar2) {
local_1 = 0;
local_e4 = 1;
}
else {
local_1 = 1;
local_e4 = 1;
}
}
else {
local_1 = 0;
local_e4 = 1;
}
}
}
LAB_001f05c9:
uVar4 = std::__cxx11::u32string::~u32string(local_30);
}
else {
local_1 = 0;
}
}
return CONCAT71((int7)(uVar4 >> 8),local_1) & 0xffffffffffffff01;
}
| |
50,614 | ImPlot::TagV(int, double, ImVec4 const&, char const*, __va_list_tag*) | zkingston[P]unknot/build_O1/_deps/implot-src/implot.cpp | void TagV(ImAxis axis, double v, const ImVec4& col, const char* fmt, va_list args) {
ImPlotContext& gp = *GImPlot;
SetupLock();
ImU32 bg = ImGui::GetColorU32(col);
ImU32 fg = col.w == 0 ? GetStyleColorU32(ImPlotCol_AxisText) : CalcTextColor(col);
gp.Tags.AppendV(axis,v,bg,fg,fmt,args);
} | O1 | cpp | ImPlot::TagV(int, double, ImVec4 const&, char const*, __va_list_tag*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movsd %xmm0, (%rsp)
movl %edi, %ebp
movq 0x275f05(%rip), %r15 # 0x336ca0
movq 0x50(%r15), %rax
cmpb $0x0, 0x9de(%rax)
jne 0xc0dad
callq 0xb930f
movq 0x50(%r15), %rax
movb $0x1, 0x9de(%rax)
movq %r13, %rdi
callq 0x215ebe
movl %eax, %r12d
movss 0xc(%r13), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xc0dfd
jp 0xc0dfd
movq 0x275ec6(%rip), %rcx # 0x336ca0
movss 0x28c(%rcx), %xmm0
ucomiss 0x1ce21b(%rip), %xmm0 # 0x28f004
jne 0xc0e45
jp 0xc0e45
xorl %edi, %edi
callq 0x215eee
movq %rax, %rcx
addq $0x8, %rcx
jmp 0xc0e53
movss 0x4(%r13), %xmm0
mulss 0x1d8d7d(%rip), %xmm0 # 0x299b88
movss (%r13), %xmm1
mulss 0x1d8d73(%rip), %xmm1 # 0x299b8c
addss %xmm0, %xmm1
movss 0x8(%r13), %xmm0
mulss 0x1d8d65(%rip), %xmm0 # 0x299b90
addss %xmm1, %xmm0
xorl %ecx, %ecx
ucomiss 0x1ce1e8(%rip), %xmm0 # 0x28f020
setbe %cl
negl %ecx
orl $0xff000000, %ecx # imm = 0xFF000000
jmp 0xc0e69
leaq 0x280(%rcx), %rax
addq $0x288, %rcx # imm = 0x288
movsd (%rax), %xmm0
movhps (%rcx), %xmm0 # xmm0 = xmm0[0,1],mem[0,1]
leaq 0x8(%rsp), %rdi
movups %xmm0, (%rdi)
callq 0x213cfe
movl %eax, %ecx
addq $0xd8, %r15
movq %r15, %rdi
movl %ebp, %esi
movsd (%rsp), %xmm0
movl %r12d, %edx
movq %r14, %r8
movq %rbx, %r9
callq 0xc9012
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN6ImPlot4TagVEidRK6ImVec4PKcP13__va_list_tag:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rcx
mov r14, rdx
mov r13, rsi
movsd [rsp+48h+var_48], xmm0
mov ebp, edi
mov r15, cs:GImPlot
mov rax, [r15+50h]
cmp byte ptr [rax+9DEh], 0
jnz short loc_C0DAD
call _ZN6ImPlot11SetupFinishEv; ImPlot::SetupFinish(void)
loc_C0DAD:
mov rax, [r15+50h]
mov byte ptr [rax+9DEh], 1
mov rdi, r13
call _ZN5ImGui11GetColorU32ERK6ImVec4; ImGui::GetColorU32(ImVec4 const&)
mov r12d, eax
movss xmm0, dword ptr [r13+0Ch]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jnz short loc_C0DFD
jp short loc_C0DFD
mov rcx, cs:GImPlot
movss xmm0, dword ptr [rcx+28Ch]
ucomiss xmm0, cs:flt_28F004
jnz short loc_C0E45
jp short loc_C0E45
xor edi, edi; this
call _ZN5ImGui17GetStyleColorVec4Ei; ImGui::GetStyleColorVec4(int)
mov rcx, rax
add rcx, 8
jmp short loc_C0E53
loc_C0DFD:
movss xmm0, dword ptr [r13+4]
mulss xmm0, cs:dword_299B88
movss xmm1, dword ptr [r13+0]
mulss xmm1, cs:dword_299B8C
addss xmm1, xmm0
movss xmm0, dword ptr [r13+8]
mulss xmm0, cs:dword_299B90
addss xmm0, xmm1
xor ecx, ecx
ucomiss xmm0, dword ptr cs:xmmword_28F020
setbe cl
neg ecx
or ecx, 0FF000000h
jmp short loc_C0E69
loc_C0E45:
lea rax, [rcx+280h]
add rcx, 288h
loc_C0E53:
movsd xmm0, qword ptr [rax]
movhps xmm0, qword ptr [rcx]
lea rdi, [rsp+48h+var_40]
movups xmmword ptr [rdi], xmm0
call _ZN5ImGui23ColorConvertFloat4ToU32ERK6ImVec4; ImGui::ColorConvertFloat4ToU32(ImVec4 const&)
mov ecx, eax; unsigned int
loc_C0E69:
add r15, 0D8h
mov rdi, r15; this
mov esi, ebp; int
movsd xmm0, [rsp+48h+var_48]; double
mov edx, r12d; unsigned int
mov r8, r14; char *
mov r9, rbx; __va_list_tag *
call _ZN19ImPlotTagCollection7AppendVEidjjPKcP13__va_list_tag; ImPlotTagCollection::AppendV(int,double,uint,uint,char const*,__va_list_tag *)
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ImPlot::TagV(ImPlot *a1, long long a2, const char *a3, __va_list_tag *a4, double a5)
{
ImGui *v7; // r15
unsigned int ColorU32; // r12d
const double *v9; // rcx
unsigned int v10; // ecx
__m128 v12[4]; // [rsp+8h] [rbp-40h] BYREF
v7 = GImPlot;
if ( !*(_BYTE *)(*((_QWORD *)GImPlot + 10) + 2526LL) )
ImPlot::SetupFinish(a1, (const char *)a2);
*(_BYTE *)(*((_QWORD *)v7 + 10) + 2526LL) = 1;
ColorU32 = ImGui::GetColorU32(a2);
if ( *(float *)(a2 + 12) == 0.0 )
{
if ( *((float *)GImPlot + 163) == -1.0 )
v9 = (const double *)(ImGui::GetStyleColorVec4(0LL, a2) + 8);
else
v9 = (const double *)((char *)GImPlot + 648);
v12[0] = _mm_loadh_ps(v9);
v10 = ImGui::ColorConvertFloat4ToU32(v12);
}
else
{
v10 = (float)((float)(*(float *)(a2 + 8) * 0.114)
+ (float)((float)(*(float *)a2 * 0.29899999) + (float)(*(float *)(a2 + 4) * 0.58700001))) <= 0.5
? -1
: 0xFF000000;
}
return ImPlotTagCollection::AppendV((ImGui *)((char *)v7 + 216), (int)a1, a5, ColorU32, v10, a3, a4);
}
| TagV:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RCX
MOV R14,RDX
MOV R13,RSI
MOVSD qword ptr [RSP],XMM0
MOV EBP,EDI
MOV R15,qword ptr [0x00436ca0]
MOV RAX,qword ptr [R15 + 0x50]
CMP byte ptr [RAX + 0x9de],0x0
JNZ 0x001c0dad
CALL 0x001b930f
LAB_001c0dad:
MOV RAX,qword ptr [R15 + 0x50]
MOV byte ptr [RAX + 0x9de],0x1
MOV RDI,R13
CALL 0x00315ebe
MOV R12D,EAX
MOVSS XMM0,dword ptr [R13 + 0xc]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JNZ 0x001c0dfd
JP 0x001c0dfd
MOV RCX,qword ptr [0x00436ca0]
MOVSS XMM0,dword ptr [RCX + 0x28c]
UCOMISS XMM0,dword ptr [0x0038f004]
JNZ 0x001c0e45
JP 0x001c0e45
XOR EDI,EDI
CALL 0x00315eee
MOV RCX,RAX
ADD RCX,0x8
JMP 0x001c0e53
LAB_001c0dfd:
MOVSS XMM0,dword ptr [R13 + 0x4]
MULSS XMM0,dword ptr [0x00399b88]
MOVSS XMM1,dword ptr [R13]
MULSS XMM1,dword ptr [0x00399b8c]
ADDSS XMM1,XMM0
MOVSS XMM0,dword ptr [R13 + 0x8]
MULSS XMM0,dword ptr [0x00399b90]
ADDSS XMM0,XMM1
XOR ECX,ECX
UCOMISS XMM0,dword ptr [0x0038f020]
SETBE CL
NEG ECX
OR ECX,0xff000000
JMP 0x001c0e69
LAB_001c0e45:
LEA RAX,[RCX + 0x280]
ADD RCX,0x288
LAB_001c0e53:
MOVSD XMM0,qword ptr [RAX]
MOVHPS XMM0,qword ptr [RCX]
LEA RDI,[RSP + 0x8]
MOVUPS xmmword ptr [RDI],XMM0
CALL 0x00313cfe
MOV ECX,EAX
LAB_001c0e69:
ADD R15,0xd8
MOV RDI,R15
MOV ESI,EBP
MOVSD XMM0,qword ptr [RSP]
MOV EDX,R12D
MOV R8,R14
MOV R9,RBX
CALL 0x001c9012
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* ImPlot::TagV(int, double, ImVec4 const&, char const*, __va_list_tag*) */
void ImPlot::TagV(int param_1,double param_2,ImVec4 *param_3,char *param_4,__va_list_tag *param_5)
{
long lVar1;
uint uVar2;
uint uVar3;
int4 *puVar4;
int8 *puVar5;
int4 local_40;
int4 uStack_3c;
int4 uStack_38;
int4 uStack_34;
lVar1 = GImPlot;
if (*(char *)(*(long *)(GImPlot + 0x50) + 0x9de) == '\0') {
SetupFinish();
}
*(int1 *)(*(long *)(lVar1 + 0x50) + 0x9de) = 1;
uVar2 = ImGui::GetColorU32(param_3);
if ((*(float *)(param_3 + 0xc) != 0.0) || (NAN(*(float *)(param_3 + 0xc)))) {
uVar3 = -(uint)(*(float *)(param_3 + 8) * _DAT_00399b90 +
*(float *)param_3 * _DAT_00399b8c + *(float *)(param_3 + 4) * _DAT_00399b88 <=
DAT_0038f020) | 0xff000000;
}
else {
if ((*(float *)(GImPlot + 0x28c) != DAT_0038f004) ||
(NAN(*(float *)(GImPlot + 0x28c)) || NAN(DAT_0038f004))) {
puVar4 = (int4 *)(GImPlot + 0x280);
puVar5 = (int8 *)(GImPlot + 0x288);
}
else {
puVar4 = (int4 *)ImGui::GetStyleColorVec4(0);
puVar5 = (int8 *)(puVar4 + 2);
}
local_40 = *puVar4;
uStack_3c = puVar4[1];
uStack_38 = (int4)*puVar5;
uStack_34 = (int4)((ulong)*puVar5 >> 0x20);
uVar3 = ImGui::ColorConvertFloat4ToU32((ImVec4 *)&local_40);
}
ImPlotTagCollection::AppendV
((ImPlotTagCollection *)(lVar1 + 0xd8),param_1,param_2,uVar2,uVar3,param_4,param_5);
return;
}
| |
50,615 | clip_init | llama.cpp/examples/llava/clip.cpp | struct clip_ctx * clip_init(const char * fname, struct clip_context_params ctx_params) {
g_logger_state.verbosity_thold = ctx_params.verbosity;
clip_ctx * ctx_clip = new clip_ctx(ctx_params);
try {
clip_model_loader loader(fname, *ctx_clip);
loader.load_hparams();
loader.load_tensors();
loader.alloc_compute_meta();
} catch (const std::exception & e) {
LOG_ERR("%s: failed to load model '%s': %s\n", __func__, fname, e.what());
delete ctx_clip;
return nullptr;
}
return ctx_clip;
} | O3 | cpp | clip_init:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
leaq 0x48(%rsp), %r15
movq %rsi, (%r15)
shrq $0x20, %rsi
leaq 0x3ab1b(%rip), %r13 # 0x55730
movl %esi, (%r13)
movl $0x3a8, %edi # imm = 0x3A8
callq 0x15140
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x305ec
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x308c2
leaq 0x8(%rsp), %rdi
callq 0x30e04
leaq 0x8(%rsp), %rdi
callq 0x31986
leaq 0x8(%rsp), %rdi
callq 0x3506c
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ac7a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x15120
leaq 0x10(%rsp), %rdi
callq 0x35ab4
leaq 0x8(%rsp), %rdi
callq 0x35bda
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rax, %r15
jmp 0x1accf
movq %rax, %r15
movl $0x3a8, %esi # imm = 0x3A8
movq %rbx, %rdi
callq 0x15120
movq %r15, %rdi
callq 0x157c0
movq %rdx, %r12
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x351b2
cmpl $0x1, %r12d
jne 0x1acb7
movq %r15, %rdi
callq 0x150c0
cmpl $0x4, (%r13)
jg 0x1ad0d
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x2b407(%rip), %rsi # 0x460fb
leaq 0x2b423(%rip), %rdx # 0x4611e
movl $0x4, %edi
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1ad43
movq %rbx, %rdi
callq 0x351e0
movl $0x3a8, %esi # imm = 0x3A8
movq %rbx, %rdi
callq 0x15120
callq 0x15920
xorl %ebx, %ebx
jmp 0x1ac8e
movq %rax, %r15
callq 0x15920
jmp 0x1acb7
movq %rax, %rdi
callq 0x352e0
| clip_init:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 50h
mov r14, rdi
lea r15, [rsp+78h+var_30]
mov [r15], rsi
shr rsi, 20h
lea r13, g_logger_state
mov [r13+0], esi
mov edi, 3A8h; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
mov rdi, rax
mov rsi, r15
call _ZN8clip_ctxC2ER19clip_context_params; clip_ctx::clip_ctx(clip_context_params &)
lea rdi, [rsp+78h+var_70]
mov rsi, r14
mov rdx, rbx
call _ZN17clip_model_loaderC2EPKcR8clip_ctx; clip_model_loader::clip_model_loader(char const*,clip_ctx &)
lea rdi, [rsp+78h+var_70]; this
call _ZN17clip_model_loader12load_hparamsEv; clip_model_loader::load_hparams(void)
lea rdi, [rsp+78h+var_70]; this
call _ZN17clip_model_loader12load_tensorsEv; clip_model_loader::load_tensors(void)
lea rdi, [rsp+78h+var_70]; this
call _ZN17clip_model_loader18alloc_compute_metaEv; clip_model_loader::alloc_compute_meta(void)
lea rax, [rsp+78h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_1AC7A
mov rsi, [rsp+78h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1AC7A:
lea rdi, [rsp+78h+var_68]
call _ZNSt10unique_ptrI12gguf_context20gguf_context_deleterED2Ev; std::unique_ptr<gguf_context,gguf_context_deleter>::~unique_ptr()
lea rdi, [rsp+78h+var_70]
call _ZNSt10unique_ptrI12ggml_context20ggml_context_deleterED2Ev; std::unique_ptr<ggml_context,ggml_context_deleter>::~unique_ptr()
loc_1AC8E:
mov rax, rbx
add rsp, 50h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r12, rdx
mov r15, rax
jmp short loc_1ACCF
mov r15, rax
mov esi, 3A8h; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1ACB7:
mov rdi, r15
call __Unwind_Resume
mov r12, rdx
mov r15, rax
lea rdi, [rsp+78h+var_70]; this
call _ZN17clip_model_loaderD2Ev; clip_model_loader::~clip_model_loader()
loc_1ACCF:
cmp r12d, 1
jnz short loc_1ACB7
mov rdi, r15; void *
call ___cxa_begin_catch
cmp dword ptr [r13+0], 4
jg short loc_1AD0D
mov rcx, [rax]
mov rdi, rax
call qword ptr [rcx+10h]
lea rsi, aSFailedToLoadM; "%s: failed to load model '%s': %s\n"
lea rdx, aClipInit; "clip_init"
mov edi, 4
mov rcx, r14
mov r8, rax
xor eax, eax
call _ZL17clip_log_internal14ggml_log_levelPKcz; clip_log_internal(ggml_log_level,char const*,...)
loc_1AD0D:
mov rdi, rbx; this
call _ZN8clip_ctxD2Ev; clip_ctx::~clip_ctx()
mov esi, 3A8h; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
call ___cxa_end_catch
xor ebx, ebx
jmp loc_1AC8E
mov r15, rax
call ___cxa_end_catch
jmp loc_1ACB7
mov rdi, rax
call __clang_call_terminate
| clip_ctx * clip_init(const char *a1, long long a2)
{
clip_ctx *v2; // rbx
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
_BYTE v8[8]; // [rsp+8h] [rbp-70h] BYREF
_BYTE v9[16]; // [rsp+10h] [rbp-68h] BYREF
long long *v10; // [rsp+20h] [rbp-58h]
long long v11; // [rsp+30h] [rbp-48h] BYREF
long long v12; // [rsp+48h] [rbp-30h] BYREF
v12 = a2;
g_logger_state = HIDWORD(a2);
v2 = (clip_ctx *)operator new(0x3A8uLL);
clip_ctx::clip_ctx((_DWORD)v2, (unsigned int)&v12, v3, v4, v5, v6);
clip_model_loader::clip_model_loader((clip_model_loader *)v8, a1, v2);
clip_model_loader::load_hparams((clip_model_loader *)v8);
clip_model_loader::load_tensors((clip_model_loader *)v8);
clip_model_loader::alloc_compute_meta((clip_model_loader *)v8);
if ( v10 != &v11 )
operator delete(v10, v11 + 1);
std::unique_ptr<gguf_context,gguf_context_deleter>::~unique_ptr(v9);
std::unique_ptr<ggml_context,ggml_context_deleter>::~unique_ptr(v8);
return v2;
}
| clip_init:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV R14,RDI
LEA R15,[RSP + 0x48]
MOV qword ptr [R15],RSI
SHR RSI,0x20
LEA R13,[0x155730]
MOV dword ptr [R13],ESI
MOV EDI,0x3a8
CALL 0x00115140
MOV RBX,RAX
LAB_0011ac26:
MOV RDI,RAX
MOV RSI,R15
CALL 0x001305ec
LAB_0011ac31:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV RDX,RBX
CALL 0x001308c2
LAB_0011ac41:
LEA RDI,[RSP + 0x8]
CALL 0x00130e04
LEA RDI,[RSP + 0x8]
CALL 0x00131986
LEA RDI,[RSP + 0x8]
CALL 0x0013506c
LAB_0011ac5f:
LEA RAX,[RSP + 0x30]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0011ac7a
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x00115120
LAB_0011ac7a:
LEA RDI,[RSP + 0x10]
CALL 0x00135ab4
LEA RDI,[RSP + 0x8]
CALL 0x00135bda
LAB_0011ac8e:
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
clip_ctx * clip_init(char *param_1,int8 param_2)
{
clip_ctx *this;
clip_model_loader local_70 [8];
unique_ptr<gguf_context,gguf_context_deleter> local_68 [16];
long *local_58;
long local_48 [3];
int8 local_30;
g_logger_state = (int4)((ulong)param_2 >> 0x20);
local_30 = param_2;
this = (clip_ctx *)operator_new(0x3a8);
/* try { // try from 0011ac26 to 0011ac30 has its CatchHandler @ 0011aca7 */
clip_ctx::clip_ctx(this,(clip_context_params *)&local_30);
/* try { // try from 0011ac31 to 0011ac40 has its CatchHandler @ 0011ac9f */
clip_model_loader::clip_model_loader(local_70,param_1,this);
/* try { // try from 0011ac41 to 0011ac5e has its CatchHandler @ 0011acbf */
clip_model_loader::load_hparams(local_70);
clip_model_loader::load_tensors(local_70);
clip_model_loader::alloc_compute_meta(local_70);
if (local_58 != local_48) {
operator_delete(local_58,local_48[0] + 1);
}
std::unique_ptr<gguf_context,gguf_context_deleter>::~unique_ptr(local_68);
std::unique_ptr<ggml_context,ggml_context_deleter>::~unique_ptr
((unique_ptr<ggml_context,ggml_context_deleter> *)local_70);
return this;
}
| |
50,616 | mysql_client_find_plugin | eloqsql/build_O0/libmariadb/libmariadb/ma_client_plugin.c | struct st_mysql_client_plugin * STDCALL
mysql_client_find_plugin(MYSQL *mysql, const char *name, int type)
{
struct st_mysql_client_plugin *p;
int plugin_nr= get_plugin_nr(type);
if (is_not_initialized(mysql, name))
return NULL;
if (plugin_nr == -1)
{
my_set_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD, SQLSTATE_UNKNOWN,
ER(CR_AUTH_PLUGIN_CANNOT_LOAD), name, "invalid type");
}
if ((p= find_plugin(name, type)))
return p;
/* not found, load it */
return mysql_load_plugin(mysql, name, type, 0);
} | O0 | c | mysql_client_find_plugin:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0xbe910
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xbe2a0
cmpl $0x0, %eax
je 0xbe88a
movq $0x0, -0x8(%rbp)
jmp 0xbe8fb
cmpl $-0x1, -0x2c(%rbp)
jne 0xbe8c3
movq -0x10(%rbp), %rdi
leaq 0x1f4155(%rip), %rax # 0x2b29f0
movq (%rax), %rdx
leaq 0x1f415b(%rip), %rax # 0x2b2a00
movq 0x1d8(%rax), %rcx
movq -0x18(%rbp), %r8
movl $0x80b, %esi # imm = 0x80B
leaq 0x88622(%rip), %r9 # 0x146ede
movb $0x0, %al
callq 0x9e610
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xbe310
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xbe8e3
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbe8fb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
xorl %ecx, %ecx
movb $0x0, %al
callq 0xbe7b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mysql_client_find_plugin:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov edi, [rbp+var_1C]
call get_plugin_nr
mov [rbp+var_2C], eax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call is_not_initialized
cmp eax, 0
jz short loc_BE88A
mov [rbp+var_8], 0
jmp short loc_BE8FB
loc_BE88A:
cmp [rbp+var_2C], 0FFFFFFFFh
jnz short loc_BE8C3
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
mov r8, [rbp+var_18]
mov esi, 80Bh
lea r9, aInvalidType; "invalid type"
mov al, 0
call my_set_error
loc_BE8C3:
mov rdi, [rbp+var_18]
mov esi, [rbp+var_1C]
call find_plugin
mov [rbp+var_28], rax
cmp rax, 0
jz short loc_BE8E3
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp short loc_BE8FB
loc_BE8E3:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
xor ecx, ecx
mov al, 0
call mysql_load_plugin
mov [rbp+var_8], rax
loc_BE8FB:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| void (** mysql_client_find_plugin(long long a1, const char *a2, unsigned int a3))(void)
{
int plugin_nr; // [rsp+4h] [rbp-2Ch]
long long plugin; // [rsp+8h] [rbp-28h]
plugin_nr = get_plugin_nr(a3);
if ( (unsigned int)is_not_initialized(a1, (long long)a2) )
return 0LL;
if ( plugin_nr == -1 )
my_set_error(a1, 0x80Bu, (long long)SQLSTATE_UNKNOWN, (long long)client_errors[59], a2, "invalid type");
plugin = find_plugin((long long)a2, a3);
if ( plugin )
return (void (**)(void))plugin;
else
return mysql_load_plugin(a1, a2, a3, 0);
}
| mysql_client_find_plugin:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV EDI,dword ptr [RBP + -0x1c]
CALL 0x001be910
MOV dword ptr [RBP + -0x2c],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001be2a0
CMP EAX,0x0
JZ 0x001be88a
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001be8fb
LAB_001be88a:
CMP dword ptr [RBP + -0x2c],-0x1
JNZ 0x001be8c3
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x3b29f0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x3b2a00]
MOV RCX,qword ptr [RAX + 0x1d8]
MOV R8,qword ptr [RBP + -0x18]
MOV ESI,0x80b
LEA R9,[0x246ede]
MOV AL,0x0
CALL 0x0019e610
LAB_001be8c3:
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x1c]
CALL 0x001be310
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JZ 0x001be8e3
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001be8fb
LAB_001be8e3:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
XOR ECX,ECX
MOV AL,0x0
CALL 0x001be7b0
MOV qword ptr [RBP + -0x8],RAX
LAB_001be8fb:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
long mysql_client_find_plugin(int8 param_1,int8 param_2,int4 param_3)
{
int iVar1;
int iVar2;
long local_10;
iVar1 = get_plugin_nr(param_3);
iVar2 = is_not_initialized(param_1,param_2);
if (iVar2 == 0) {
if (iVar1 == -1) {
my_set_error(param_1,0x80b,SQLSTATE_UNKNOWN,PTR_s_Plugin__s_could_not_be_loaded____003b2bd8,
param_2,"invalid type");
}
local_10 = find_plugin(param_2,param_3);
if (local_10 == 0) {
local_10 = mysql_load_plugin(param_1,param_2,param_3,0);
}
}
else {
local_10 = 0;
}
return local_10;
}
| |
50,617 | ma_check_unique | eloqsql/storage/maria/ma_unique.c | my_bool _ma_check_unique(MARIA_HA *info, MARIA_UNIQUEDEF *def,
const uchar *record,
ha_checksum unique_hash, my_off_t disk_pos)
{
my_off_t lastpos=info->cur_row.lastpos;
MARIA_KEYDEF *keyinfo= &info->s->keyinfo[def->key];
uchar *key_buff= info->lastkey_buff2;
MARIA_KEY key;
int error= 0;
DBUG_ENTER("_ma_check_unique");
DBUG_PRINT("enter",("unique_hash: %lu", (ulong) unique_hash));
/* We need to store the hash value as a key in the record, breaking const */
maria_unique_store(record+keyinfo->seg->start, unique_hash);
/* Can't be spatial so it's ok to call _ma_make_key directly here */
_ma_make_key(info, &key, def->key, key_buff, record, 0, 0);
/* The above changed info->lastkey_buff2. Inform maria_rnext_same(). */
info->update&= ~HA_STATE_RNEXT_SAME;
/* Setup that unique key is active key */
info->last_key.keyinfo= keyinfo;
/* any key pointer in data is destroyed */
info->lastinx= ~0;
DBUG_ASSERT(key.data_length == MARIA_UNIQUE_HASH_LENGTH);
if (_ma_search(info, &key, SEARCH_FIND | SEARCH_SAVE_BUFF,
info->s->state.key_root[def->key]))
{
info->page_changed=1; /* Can't optimize read next */
info->cur_row.lastpos= lastpos;
goto end;
}
for (;;)
{
if (info->cur_row.lastpos != disk_pos &&
!(*info->s->compare_unique)(info,def,record,info->cur_row.lastpos))
{
my_errno=HA_ERR_FOUND_DUPP_UNIQUE;
info->errkey= (int) def->key;
info->dup_key_pos= info->cur_row.lastpos;
info->page_changed= 1; /* Can't optimize read next */
info->cur_row.lastpos= lastpos;
DBUG_PRINT("info",("Found duplicate"));
error= 1; /* Found identical */
goto end;
}
DBUG_ASSERT(info->last_key.data_length == MARIA_UNIQUE_HASH_LENGTH);
if (_ma_search_next(info, &info->last_key, SEARCH_BIGGER,
info->s->state.key_root[def->key]) ||
bcmp(info->last_key.data, key_buff, MARIA_UNIQUE_HASH_LENGTH))
{
info->page_changed= 1; /* Can't optimize read next */
info->cur_row.lastpos= lastpos;
break; /* end of tree */
}
}
end:
DBUG_RETURN(error);
} | O3 | c | ma_check_unique:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, -0x38(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x98(%rdi), %r15
movq 0x570(%rax), %rax
movzbl 0x2(%rsi), %esi
imulq $0x118, %rsi, %r9 # imm = 0x118
leaq (%rax,%r9), %rsi
movq %rsi, -0x30(%rbp)
movq 0x390(%rdi), %r12
movq 0xc0(%rax,%r9), %rsi
movl 0x8(%rsi), %esi
movb %cl, 0x3(%rdx,%rsi)
movq 0xc0(%rax,%r9), %rsi
movl 0x8(%rsi), %esi
movb %ch, 0x2(%rdx,%rsi)
movq %rdx, %r8
movl %ecx, %esi
shrl $0x10, %esi
movq 0xc0(%rax,%r9), %rdi
movl 0x8(%rdi), %edi
movb %sil, 0x1(%rdx,%rdi)
shrl $0x18, %ecx
movq 0xc0(%rax,%r9), %rax
movl 0x8(%rax), %eax
movb %cl, (%rdx,%rax)
movzbl 0x2(%r14), %edx
movq $0x0, (%rsp)
leaq -0x60(%rbp), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rcx
movq %r8, -0x40(%rbp)
xorl %r9d, %r9d
callq 0x36bab
andb $-0x11, 0x625(%rbx)
movq -0x30(%rbp), %rax
movq %rax, 0x208(%rbx)
movl $0xffffffff, 0x62c(%rbx) # imm = 0xFFFFFFFF
movq (%rbx), %rax
movq 0x118(%rax), %rax
movzbl 0x2(%r14), %ecx
movq (%rax,%rcx,8), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movl $0x21, %edx
callq 0x55f1f
xorl %ecx, %ecx
testl %eax, %eax
movq %r15, %rax
jne 0x4280e
movq -0x38(%rbp), %r15
movq %rax, -0x30(%rbp)
leaq 0x200(%rbx), %r13
movq 0x98(%rbx), %rcx
cmpq %r15, %rcx
je 0x427ad
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movq -0x40(%rbp), %rdx
callq *0x6c0(%rax)
testb %al, %al
je 0x427e4
movq (%rbx), %rax
movq 0x118(%rax), %rax
movzbl 0x2(%r14), %ecx
movq (%rax,%rcx,8), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movl $0x8, %edx
callq 0x57e4b
testl %eax, %eax
jne 0x427e0
movq (%r13), %rax
movl (%rax), %eax
cmpl (%r12), %eax
je 0x4278a
xorl %ecx, %ecx
jmp 0x4280a
callq 0xa1b22
movl $0x8d, (%rax)
movzbl 0x2(%r14), %eax
movl %eax, 0x660(%rbx)
movq 0x98(%rbx), %rax
movq %rax, 0x428(%rbx)
movb $0x1, %cl
movq -0x30(%rbp), %rax
movb $0x1, 0x684(%rbx)
movq %rax, 0x98(%rbx)
movl %ecx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_check_unique:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_38], r8
mov r14, rsi
mov rbx, rdi
mov rax, [rdi]
mov r15, [rdi+98h]
mov rax, [rax+570h]
movzx esi, byte ptr [rsi+2]
imul r9, rsi, 118h
lea rsi, [rax+r9]
mov [rbp+var_30], rsi
mov r12, [rdi+390h]
mov rsi, [rax+r9+0C0h]
mov esi, [rsi+8]
mov [rdx+rsi+3], cl
mov rsi, [rax+r9+0C0h]
mov esi, [rsi+8]
mov [rdx+rsi+2], ch
mov r8, rdx
mov esi, ecx
shr esi, 10h
mov rdi, [rax+r9+0C0h]
mov edi, [rdi+8]
mov [rdx+rdi+1], sil
shr ecx, 18h
mov rax, [rax+r9+0C0h]
mov eax, [rax+8]
mov [rdx+rax], cl
movzx edx, byte ptr [r14+2]
mov [rsp+70h+var_70], 0
lea r13, [rbp+var_60]
mov rdi, rbx
mov rsi, r13
mov rcx, r12
mov [rbp+var_40], r8
xor r9d, r9d
call _ma_make_key
and byte ptr [rbx+625h], 0EFh
mov rax, [rbp+var_30]
mov [rbx+208h], rax
mov dword ptr [rbx+62Ch], 0FFFFFFFFh
mov rax, [rbx]
mov rax, [rax+118h]
movzx ecx, byte ptr [r14+2]
mov rcx, [rax+rcx*8]
mov rdi, rbx
mov rsi, r13
mov edx, 21h ; '!'
call _ma_search
xor ecx, ecx
test eax, eax
mov rax, r15
jnz loc_4280E
mov r15, [rbp+var_38]
mov [rbp+var_30], rax
lea r13, [rbx+200h]
loc_4278A:
mov rcx, [rbx+98h]
cmp rcx, r15
jz short loc_427AD
mov rax, [rbx]
mov rdi, rbx
mov rsi, r14
mov rdx, [rbp+var_40]
call qword ptr [rax+6C0h]
test al, al
jz short loc_427E4
loc_427AD:
mov rax, [rbx]
mov rax, [rax+118h]
movzx ecx, byte ptr [r14+2]
mov rcx, [rax+rcx*8]
mov rdi, rbx
mov rsi, r13
mov edx, 8
call _ma_search_next
test eax, eax
jnz short loc_427E0
mov rax, [r13+0]
mov eax, [rax]
cmp eax, [r12]
jz short loc_4278A
loc_427E0:
xor ecx, ecx
jmp short loc_4280A
loc_427E4:
call _my_thread_var
mov dword ptr [rax], 8Dh
movzx eax, byte ptr [r14+2]
mov [rbx+660h], eax
mov rax, [rbx+98h]
mov [rbx+428h], rax
mov cl, 1
loc_4280A:
mov rax, [rbp+var_30]
loc_4280E:
mov byte ptr [rbx+684h], 1
mov [rbx+98h], rax
mov eax, ecx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_check_unique(_QWORD *a1, long long a2, long long a3, int a4, long long a5)
{
long long v5; // r15
long long v6; // rax
long long v7; // r9
char *v8; // r12
unsigned int v10; // edx
int v11; // eax
unsigned int v12; // ecx
bool v13; // zf
long long v14; // rax
long long v15; // r15
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
_BYTE v20[32]; // [rsp+10h] [rbp-60h] BYREF
long long v21; // [rsp+30h] [rbp-40h]
long long v22; // [rsp+38h] [rbp-38h]
long long v23; // [rsp+40h] [rbp-30h]
v22 = a5;
v5 = a1[19];
v6 = *(_QWORD *)(*a1 + 1392LL);
v7 = 280LL * *(unsigned __int8 *)(a2 + 2);
v23 = v6 + v7;
v8 = (char *)a1[114];
*(_BYTE *)(a3 + *(unsigned int *)(*(_QWORD *)(v6 + v7 + 192) + 8LL) + 3) = a4;
*(_BYTE *)(a3 + *(unsigned int *)(*(_QWORD *)(v6 + v7 + 192) + 8LL) + 2) = BYTE1(a4);
*(_BYTE *)(a3 + *(unsigned int *)(*(_QWORD *)(v6 + v7 + 192) + 8LL) + 1) = BYTE2(a4);
*(_BYTE *)(a3 + *(unsigned int *)(*(_QWORD *)(v6 + v7 + 192) + 8LL)) = HIBYTE(a4);
v10 = *(unsigned __int8 *)(a2 + 2);
v21 = a3;
ma_make_key(a1, (long long)v20, v10, v8, a3, 0LL, 0LL);
*((_BYTE *)a1 + 1573) &= ~0x10u;
a1[65] = v23;
*((_DWORD *)a1 + 395) = -1;
v11 = ma_search(a1, v20, 33LL, *(_QWORD *)(*(_QWORD *)(*a1 + 280LL) + 8LL * *(unsigned __int8 *)(a2 + 2)));
v12 = 0;
v13 = v11 == 0;
v14 = v5;
if ( v13 )
{
v15 = v22;
v23 = v14;
while ( a1[19] == v15 || (*(unsigned __int8 ( **)(_QWORD *, long long, long long))(*a1 + 1728LL))(a1, a2, v21) )
{
if ( (unsigned int)ma_search_next(
a1,
a1 + 64,
8LL,
*(_QWORD *)(*(_QWORD *)(*a1 + 280LL) + 8LL * *(unsigned __int8 *)(a2 + 2)))
|| *(_DWORD *)a1[64] != *(_DWORD *)v8 )
{
v12 = 0;
goto LABEL_9;
}
}
*(_DWORD *)my_thread_var(a1, a2, v16, v17, v18) = 141;
*((_DWORD *)a1 + 408) = *(unsigned __int8 *)(a2 + 2);
a1[133] = a1[19];
LOBYTE(v12) = 1;
LABEL_9:
v14 = v23;
}
*((_BYTE *)a1 + 1668) = 1;
a1[19] = v14;
return v12;
}
| _ma_check_unique:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],R8
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV R15,qword ptr [RDI + 0x98]
MOV RAX,qword ptr [RAX + 0x570]
MOVZX ESI,byte ptr [RSI + 0x2]
IMUL R9,RSI,0x118
LEA RSI,[RAX + R9*0x1]
MOV qword ptr [RBP + -0x30],RSI
MOV R12,qword ptr [RDI + 0x390]
MOV RSI,qword ptr [RAX + R9*0x1 + 0xc0]
MOV ESI,dword ptr [RSI + 0x8]
MOV byte ptr [RDX + RSI*0x1 + 0x3],CL
MOV RSI,qword ptr [RAX + R9*0x1 + 0xc0]
MOV ESI,dword ptr [RSI + 0x8]
MOV byte ptr [RDX + RSI*0x1 + 0x2],CH
MOV R8,RDX
MOV ESI,ECX
SHR ESI,0x10
MOV RDI,qword ptr [RAX + R9*0x1 + 0xc0]
MOV EDI,dword ptr [RDI + 0x8]
MOV byte ptr [RDX + RDI*0x1 + 0x1],SIL
SHR ECX,0x18
MOV RAX,qword ptr [RAX + R9*0x1 + 0xc0]
MOV EAX,dword ptr [RAX + 0x8]
MOV byte ptr [RDX + RAX*0x1],CL
MOVZX EDX,byte ptr [R14 + 0x2]
MOV qword ptr [RSP],0x0
LEA R13,[RBP + -0x60]
MOV RDI,RBX
MOV RSI,R13
MOV RCX,R12
MOV qword ptr [RBP + -0x40],R8
XOR R9D,R9D
CALL 0x00136bab
AND byte ptr [RBX + 0x625],0xef
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBX + 0x208],RAX
MOV dword ptr [RBX + 0x62c],0xffffffff
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + 0x118]
MOVZX ECX,byte ptr [R14 + 0x2]
MOV RCX,qword ptr [RAX + RCX*0x8]
MOV RDI,RBX
MOV RSI,R13
MOV EDX,0x21
CALL 0x00155f1f
XOR ECX,ECX
TEST EAX,EAX
MOV RAX,R15
JNZ 0x0014280e
MOV R15,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
LEA R13,[RBX + 0x200]
LAB_0014278a:
MOV RCX,qword ptr [RBX + 0x98]
CMP RCX,R15
JZ 0x001427ad
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,qword ptr [RBP + -0x40]
CALL qword ptr [RAX + 0x6c0]
TEST AL,AL
JZ 0x001427e4
LAB_001427ad:
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + 0x118]
MOVZX ECX,byte ptr [R14 + 0x2]
MOV RCX,qword ptr [RAX + RCX*0x8]
MOV RDI,RBX
MOV RSI,R13
MOV EDX,0x8
CALL 0x00157e4b
TEST EAX,EAX
JNZ 0x001427e0
MOV RAX,qword ptr [R13]
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [R12]
JZ 0x0014278a
LAB_001427e0:
XOR ECX,ECX
JMP 0x0014280a
LAB_001427e4:
CALL 0x001a1b22
MOV dword ptr [RAX],0x8d
MOVZX EAX,byte ptr [R14 + 0x2]
MOV dword ptr [RBX + 0x660],EAX
MOV RAX,qword ptr [RBX + 0x98]
MOV qword ptr [RBX + 0x428],RAX
MOV CL,0x1
LAB_0014280a:
MOV RAX,qword ptr [RBP + -0x30]
LAB_0014280e:
MOV byte ptr [RBX + 0x684],0x1
MOV qword ptr [RBX + 0x98],RAX
MOV EAX,ECX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong _ma_check_unique(long *param_1,long param_2,long param_3,int4 param_4,long param_5)
{
long lVar1;
int *piVar2;
char cVar3;
int iVar4;
int4 *puVar5;
long lVar6;
ulong uVar7;
long lVar8;
int1 local_68 [32];
long local_48;
long local_40;
long local_38;
lVar6 = param_1[0x13];
lVar1 = *(long *)(*param_1 + 0x570);
lVar8 = (ulong)*(byte *)(param_2 + 2) * 0x118;
local_38 = lVar1 + lVar8;
piVar2 = (int *)param_1[0x72];
*(char *)(param_3 + 3 + (ulong)*(uint *)(*(long *)(lVar1 + 0xc0 + lVar8) + 8)) = (char)param_4;
*(char *)(param_3 + 2 + (ulong)*(uint *)(*(long *)(lVar1 + 0xc0 + lVar8) + 8)) =
(char)((uint)param_4 >> 8);
*(char *)(param_3 + 1 + (ulong)*(uint *)(*(long *)(lVar1 + 0xc0 + lVar8) + 8)) =
(char)((uint)param_4 >> 0x10);
*(char *)(param_3 + (ulong)*(uint *)(*(long *)(lVar1 + 0xc0 + lVar8) + 8)) =
(char)((uint)param_4 >> 0x18);
local_48 = param_3;
local_40 = param_5;
_ma_make_key(param_1,local_68,*(int1 *)(param_2 + 2),piVar2,param_3,0,0);
*(byte *)((long)param_1 + 0x625) = *(byte *)((long)param_1 + 0x625) & 0xef;
param_1[0x41] = local_38;
*(int4 *)((long)param_1 + 0x62c) = 0xffffffff;
iVar4 = _ma_search(param_1,local_68,0x21,
*(int8 *)
(*(long *)(*param_1 + 0x118) + (ulong)*(byte *)(param_2 + 2) * 8));
lVar1 = local_40;
uVar7 = 0;
local_38 = lVar6;
if (iVar4 == 0) {
do {
lVar6 = param_1[0x13];
if ((lVar6 != lVar1) &&
(cVar3 = (**(code **)(*param_1 + 0x6c0))(param_1,param_2,local_48), cVar3 == '\0')) {
puVar5 = (int4 *)_my_thread_var();
*puVar5 = 0x8d;
*(uint *)(param_1 + 0xcc) = (uint)*(byte *)(param_2 + 2);
param_1[0x85] = param_1[0x13];
uVar7 = CONCAT71((int7)((ulong)lVar6 >> 8),1);
goto LAB_0014280e;
}
iVar4 = _ma_search_next(param_1,param_1 + 0x40,8,
*(int8 *)
(*(long *)(*param_1 + 0x118) + (ulong)*(byte *)(param_2 + 2) * 8));
} while ((iVar4 == 0) && (*(int *)param_1[0x40] == *piVar2));
uVar7 = 0;
}
LAB_0014280e:
*(int1 *)((long)param_1 + 0x684) = 1;
param_1[0x13] = local_38;
return uVar7 & 0xffffffff;
}
| |
50,618 | mi_report_error | eloqsql/storage/myisam/mi_info.c | void mi_report_error(int errcode, const char *file_name)
{
size_t lgt;
DBUG_ENTER("mi_report_error");
DBUG_PRINT("enter",("errcode %d, table '%s'", errcode, file_name));
if ((lgt= strlen(file_name)) > 64)
file_name+= lgt - 64;
my_error(errcode, MYF(ME_ERROR_LOG), file_name);
DBUG_VOID_RETURN;
} | O0 | c | mi_report_error:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xaf901
movq -0x10(%rbp), %rdi
callq 0x2a350
movq %rax, -0x18(%rbp)
cmpq $0x40, %rax
jbe 0xaf924
movq -0x18(%rbp), %rax
subq $0x40, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
movl $0x40, %esi
movb $0x0, %al
callq 0xf0ef0
jmp 0xaf939
addq $0x20, %rsp
popq %rbp
retq
nop
| mi_report_error:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
jmp short $+2
loc_AF901:
mov rdi, [rbp+var_10]
call _strlen
mov [rbp+var_18], rax
cmp rax, 40h ; '@'
jbe short loc_AF924
mov rax, [rbp+var_18]
sub rax, 40h ; '@'
add rax, [rbp+var_10]
mov [rbp+var_10], rax
loc_AF924:
mov edi, [rbp+var_4]
mov rdx, [rbp+var_10]
mov esi, 40h ; '@'
mov al, 0
call my_error
jmp short $+2
loc_AF939:
add rsp, 20h
pop rbp
retn
| long long mi_report_error(int a1, long long a2)
{
int v2; // ecx
int v3; // r8d
int v4; // r9d
unsigned long long v6; // [rsp+8h] [rbp-18h]
int v7; // [rsp+10h] [rbp-10h]
v7 = a2;
v6 = strlen(a2);
if ( v6 > 0x40 )
v7 = a2 + v6 - 64;
return my_error(a1, 64, v7, v2, v3, v4);
}
| mi_report_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x001af901
LAB_001af901:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0012a350
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x40
JBE 0x001af924
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x40
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
LAB_001af924:
MOV EDI,dword ptr [RBP + -0x4]
MOV RDX,qword ptr [RBP + -0x10]
MOV ESI,0x40
MOV AL,0x0
CALL 0x001f0ef0
JMP 0x001af939
LAB_001af939:
ADD RSP,0x20
POP RBP
RET
|
void mi_report_error(int4 param_1,char *param_2)
{
size_t sVar1;
char *local_18;
sVar1 = strlen(param_2);
local_18 = param_2;
if (0x40 < sVar1) {
local_18 = param_2 + (sVar1 - 0x40);
}
my_error(param_1,0x40,local_18);
return;
}
| |
50,619 | LefDefParser::lefwBeginextRevision(int, int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwBeginextRevision(int vers1,
int vers2)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (lefwState != LEFW_BEGINEXT_START &&
lefwState != LEFW_BEGINEXT)
return LEFW_BAD_ORDER;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) "\n REVISION %d.%d", vers1, vers2);
else
fprintf(lefwFile, "\n REVISION %d.%d", vers1, vers2);
lefwState = LEFW_BEGINEXT;
lefwLines++;
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwBeginextRevision(int, int):
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
leaq 0xab0d(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0x28306
movl $0x1, 0x14(%rsp)
jmp 0x283b6
leaq 0xad47(%rip), %rax # 0x33054
cmpl $0x0, (%rax)
jne 0x2831f
movl $0x2, 0x14(%rsp)
jmp 0x283b6
leaq 0xad2a(%rip), %rax # 0x33050
cmpl $0x3, (%rax)
je 0x28341
leaq 0xad1e(%rip), %rax # 0x33050
cmpl $0x14, (%rax)
je 0x28341
movl $0x2, 0x14(%rsp)
jmp 0x283b6
cmpl $0x0, 0xada4(%rip) # 0x330ec
je 0x2836c
leaq 0xaaaf(%rip), %rax # 0x32e00
movq (%rax), %rdi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
leaq 0x3daf(%rip), %rsi # 0x2c112
movb $0x0, %al
callq 0x289b0
jmp 0x2838c
leaq 0xaa8d(%rip), %rax # 0x32e00
movq (%rax), %rdi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
leaq 0x3d8d(%rip), %rsi # 0x2c112
movb $0x0, %al
callq 0x1100
leaq 0xacbd(%rip), %rax # 0x33050
movl $0x14, (%rax)
leaq 0xacac(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xaca0(%rip), %rax # 0x3304c
movl %ecx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
| _ZN12LefDefParser20lefwBeginextRevisionEii:
sub rsp, 18h
mov [rsp+18h+var_8], edi
mov [rsp+18h+var_C], esi
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_28306
mov [rsp+18h+var_4], 1
jmp loc_283B6
loc_28306:
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
jnz short loc_2831F
mov [rsp+18h+var_4], 2
jmp loc_283B6
loc_2831F:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 3
jz short loc_28341
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 14h
jz short loc_28341
mov [rsp+18h+var_4], 2
jmp short loc_283B6
loc_28341:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_2836C
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov edx, [rsp+18h+var_8]
mov ecx, [rsp+18h+var_C]
lea rsi, aRevisionDD; "\n REVISION %d.%d"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_2838C
loc_2836C:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov edx, [rsp+18h+var_8]
mov ecx, [rsp+18h+var_C]
lea rsi, aRevisionDD; "\n REVISION %d.%d"
mov al, 0
call _fprintf
loc_2838C:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 14h
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
mov [rsp+18h+var_4], 0
loc_283B6:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long LefDefParser::lefwBeginextRevision(LefDefParser *this, int a2, int a3, long long a4, int a5, int a6)
{
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwState == 3 || LefDefParser::lefwState == 20 )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"\n REVISION %d.%d", (_DWORD)this, a2, a5, a6);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "\n REVISION %d.%d", (_DWORD)this, a2);
LefDefParser::lefwState = 20;
++LefDefParser::lefwLines;
return 0;
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwBeginextRevision:
SUB RSP,0x18
MOV dword ptr [RSP + 0x10],EDI
MOV dword ptr [RSP + 0xc],ESI
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x00128306
MOV dword ptr [RSP + 0x14],0x1
JMP 0x001283b6
LAB_00128306:
LEA RAX,[0x133054]
CMP dword ptr [RAX],0x0
JNZ 0x0012831f
MOV dword ptr [RSP + 0x14],0x2
JMP 0x001283b6
LAB_0012831f:
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x3
JZ 0x00128341
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x14
JZ 0x00128341
MOV dword ptr [RSP + 0x14],0x2
JMP 0x001283b6
LAB_00128341:
CMP dword ptr [0x001330ec],0x0
JZ 0x0012836c
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOV EDX,dword ptr [RSP + 0x10]
MOV ECX,dword ptr [RSP + 0xc]
LEA RSI,[0x12c112]
MOV AL,0x0
CALL 0x001289b0
JMP 0x0012838c
LAB_0012836c:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOV EDX,dword ptr [RSP + 0x10]
MOV ECX,dword ptr [RSP + 0xc]
LEA RSI,[0x12c112]
MOV AL,0x0
CALL 0x00101100
LAB_0012838c:
LEA RAX,[0x133050]
MOV dword ptr [RAX],0x14
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x14],0x0
LAB_001283b6:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwBeginextRevision(int, int) */
int4 LefDefParser::lefwBeginextRevision(int param_1,int param_2)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if (lefwDidInit == 0) {
local_4 = 2;
}
else if ((lefwState == 3) || (lefwState == 0x14)) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile,"\n REVISION %d.%d",(ulong)(uint)param_1,(ulong)(uint)param_2);
}
else {
encPrint(lefwFile,"\n REVISION %d.%d",(ulong)(uint)param_1,(ulong)(uint)param_2);
}
lefwState = 0x14;
lefwLines = lefwLines + 1;
local_4 = 0;
}
else {
local_4 = 2;
}
return local_4;
}
| |
50,620 | LefDefParser::lefwBeginextRevision(int, int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwBeginextRevision(int vers1,
int vers2)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (lefwState != LEFW_BEGINEXT_START &&
lefwState != LEFW_BEGINEXT)
return LEFW_BAD_ORDER;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) "\n REVISION %d.%d", vers1, vers2);
else
fprintf(lefwFile, "\n REVISION %d.%d", vers1, vers2);
lefwState = LEFW_BEGINEXT;
lefwLines++;
return LEFW_OK;
} | O3 | cpp | LefDefParser::lefwBeginextRevision(int, int):
pushq %rbx
movl %edi, %edx
leaq 0xc5c0(%rip), %rax # 0x24e00
movq (%rax), %rdi
testq %rdi, %rdi
je 0x18887
movl %esi, %ecx
leaq 0xc803(%rip), %rsi # 0x25054
movl $0x2, %eax
cmpl $0x0, (%rsi)
je 0x188ad
leaq 0xc7ee(%rip), %rbx # 0x25050
movl (%rbx), %esi
cmpl $0x14, %esi
je 0x1886e
cmpl $0x3, %esi
jne 0x188ad
cmpb $0x1, 0xc877(%rip) # 0x250ec
jne 0x1888e
leaq 0x3b50(%rip), %rsi # 0x1c3ce
xorl %eax, %eax
callq 0x18c35
jmp 0x1889c
movl $0x1, %eax
jmp 0x188ad
leaq 0x3b39(%rip), %rsi # 0x1c3ce
xorl %eax, %eax
callq 0x10f0
movl $0x14, (%rbx)
leaq 0xc7a3(%rip), %rax # 0x2504c
incl (%rax)
xorl %eax, %eax
popq %rbx
retq
| _ZN12LefDefParser20lefwBeginextRevisionEii:
push rbx
mov edx, edi
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
test rdi, rdi
jz short loc_18887
mov ecx, esi
lea rsi, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
mov eax, 2
cmp dword ptr [rsi], 0
jz short loc_188AD
lea rbx, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov esi, [rbx]
cmp esi, 14h
jz short loc_1886E
cmp esi, 3
jnz short loc_188AD
loc_1886E:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_1888E
lea rsi, aRevisionDD; "\n REVISION %d.%d"
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_1889C
loc_18887:
mov eax, 1
jmp short loc_188AD
loc_1888E:
lea rsi, aRevisionDD; "\n REVISION %d.%d"
xor eax, eax
call _fprintf
loc_1889C:
mov dword ptr [rbx], 14h
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
xor eax, eax
loc_188AD:
pop rbx
retn
| long long LefDefParser::lefwBeginextRevision(LefDefParser *this, int a2, int a3, long long a4, int a5, int a6)
{
long long result; // rax
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
result = 2LL;
if ( LefDefParser::lefwDidInit && (LefDefParser::lefwState == 20 || LefDefParser::lefwState == 3) )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"\n REVISION %d.%d", (_DWORD)this, a2, a5, a6);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "\n REVISION %d.%d", (_DWORD)this, a2);
LefDefParser::lefwState = 20;
++LefDefParser::lefwLines;
return 0LL;
}
return result;
}
| lefwBeginextRevision:
PUSH RBX
MOV EDX,EDI
LEA RAX,[0x124e00]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x00118887
MOV ECX,ESI
LEA RSI,[0x125054]
MOV EAX,0x2
CMP dword ptr [RSI],0x0
JZ 0x001188ad
LEA RBX,[0x125050]
MOV ESI,dword ptr [RBX]
CMP ESI,0x14
JZ 0x0011886e
CMP ESI,0x3
JNZ 0x001188ad
LAB_0011886e:
CMP byte ptr [0x001250ec],0x1
JNZ 0x0011888e
LEA RSI,[0x11c3ce]
XOR EAX,EAX
CALL 0x00118c35
JMP 0x0011889c
LAB_00118887:
MOV EAX,0x1
JMP 0x001188ad
LAB_0011888e:
LEA RSI,[0x11c3ce]
XOR EAX,EAX
CALL 0x001010f0
LAB_0011889c:
MOV dword ptr [RBX],0x14
LEA RAX,[0x12504c]
INC dword ptr [RAX]
XOR EAX,EAX
LAB_001188ad:
POP RBX
RET
|
/* LefDefParser::lefwBeginextRevision(int, int) */
int8 LefDefParser::lefwBeginextRevision(int param_1,int param_2)
{
int8 uVar1;
if (lefwFile == (_IO_FILE *)0x0) {
uVar1 = 1;
}
else {
uVar1 = 2;
if ((lefwDidInit != 0) && ((lefwState == 0x14 || (lefwState == 3)))) {
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile,"\n REVISION %d.%d");
}
else {
fprintf(lefwFile,"\n REVISION %d.%d",param_1,param_2);
}
lefwState = 0x14;
lefwLines = lefwLines + 1;
uVar1 = 0;
}
}
return uVar1;
}
| |
50,621 | server_game::init_late() | untodesu[P]voxelius/game/server/game.cc | void server_game::init_late(void)
{
server_game::password_hash = crc64::get(password_string.get());
sessions::init_late();
whitelist::init_late();
ENetAddress address;
address.host = ENET_HOST_ANY;
address.port = listen_port.get_value();
globals::server_host = enet_host_create(&address, sessions::max_players.get_value() + status_peers.get_value(), 1, 0, 0);
if(!globals::server_host) {
spdlog::critical("game: unable to setup an ENet host");
std::terminate();
}
spdlog::info("game: host: {} player + {} status peers", sessions::max_players.get_value(), status_peers.get_value());
spdlog::info("game: host: listening on UDP port {}", address.port);
game_voxels::populate();
game_items::populate();
unloader::init_late();
universe::init_late();
sessions::init_post_universe();
} | O0 | cpp | server_game::init_late():
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x2ad15e(%rip), %rdi # 0x2d11e0
callq 0xf8270
movq %rax, -0xa8(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1b000
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x1cfc0
jmp 0x240b7
xorl %eax, %eax
movl %eax, %esi
leaq -0x50(%rbp), %rdi
callq 0xfb430
movq %rax, -0xb0(%rbp)
jmp 0x240cd
movq -0xb0(%rbp), %rax
movq %rax, 0x2ac865(%rip) # 0x2d0940
leaq -0x50(%rbp), %rdi
callq 0x1b238
leaq -0x51(%rbp), %rdi
callq 0x1a9c0
callq 0x5a560
callq 0x89e30
movl $0x0, -0x6c(%rbp)
leaq 0x2ad073(%rip), %rdi # 0x2d1178
callq 0x246f0
movw %ax, -0x68(%rbp)
leaq 0x2ad2db(%rip), %rdi # 0x2d13f0
callq 0x24710
movl %eax, -0xb4(%rbp)
leaq 0x2ad081(%rip), %rdi # 0x2d11a8
callq 0x24710
movl %eax, %ecx
movl -0xb4(%rbp), %eax
addl %ecx, %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x6c(%rbp), %rdi
movl $0x1, %edx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x1b6850
movq %rax, %rcx
leaq 0x2ad0f8(%rip), %rax # 0x2d1250
movq %rcx, (%rax)
leaq 0x2ad0ee(%rip), %rax # 0x2d1250
cmpq $0x0, (%rax)
jne 0x241aa
leaq 0x1c04f6(%rip), %rdi # 0x1e4665
callq 0x24730
callq 0x1a210
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2419c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1b238
leaq -0x51(%rbp), %rdi
callq 0x1a9c0
jmp 0x24279
leaq -0x80(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x1c04cf(%rip), %rax # 0x1e4688
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x23f90
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x2ad217(%rip), %rdi # 0x2d13f0
callq 0x24710
movl %eax, -0x84(%rbp)
leaq 0x2acfbd(%rip), %rdi # 0x2d11a8
callq 0x24710
movl %eax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
leaq -0x84(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x24760
leaq -0x98(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1c048d(%rip), %rax # 0x1e46b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x23f90
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x6c(%rbp), %rdx
addq $0x4, %rdx
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x247b0
callq 0xa9a30
callq 0xa97e0
callq 0x81700
callq 0x70830
callq 0x5a700
addq $0xc0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x1aff0
nopw %cs:(%rax,%rax)
| _ZN11server_game9init_lateEv:
push rbp
mov rbp, rsp
sub rsp, 0C0h
lea rdi, _ZL15password_string; this
call _ZNK12ConfigString3getEv; ConfigString::get(void)
mov [rbp+var_A8], rax
lea rdi, [rbp+var_51]
mov [rbp+var_A0], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rbp+var_A8]
mov rdx, [rbp+var_A0]
lea rdi, [rbp+var_50]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_240B7:
xor eax, eax
mov esi, eax
lea rdi, [rbp+var_50]
call _ZN5crc643getERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; crc64::get(std::string const&,ulong)
mov [rbp+var_B0], rax
jmp short $+2
loc_240CD:
mov rax, [rbp+var_B0]
mov cs:_ZN11server_game13password_hashE, rax; server_game::password_hash
lea rdi, [rbp+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_51]; this
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
call _ZN8sessions9init_lateEv; sessions::init_late(void)
call _ZN9whitelist9init_lateEv; whitelist::init_late(void)
mov [rbp+var_6C], 0
lea rdi, _ZL11listen_port; listen_port
call _ZNK12ConfigNumberItE9get_valueEv; ConfigNumber<ushort>::get_value(void)
mov [rbp+var_68], ax
lea rdi, _ZN8sessions11max_playersE; sessions::max_players
call _ZNK12ConfigNumberIjE9get_valueEv; ConfigNumber<uint>::get_value(void)
mov [rbp+var_B4], eax
lea rdi, _ZL12status_peers; status_peers
call _ZNK12ConfigNumberIjE9get_valueEv; ConfigNumber<uint>::get_value(void)
mov ecx, eax
mov eax, [rbp+var_B4]
add eax, ecx
mov eax, eax
mov esi, eax
lea rdi, [rbp+var_6C]
mov edx, 1
xor r8d, r8d
mov ecx, r8d
call enet_host_create
mov rcx, rax
lea rax, _ZN7globals11server_hostE; globals::server_host
mov [rax], rcx
lea rax, _ZN7globals11server_hostE; globals::server_host
cmp qword ptr [rax], 0
jnz short loc_241AA
lea rdi, aGameUnableToSe; "game: unable to setup an ENet host"
call _ZN6spdlog8criticalIA35_cEEvRKT_; spdlog::critical<char [35]>(char [35] const&)
call __ZSt9terminatev; std::terminate(void)
mov rcx, rax
mov eax, edx
mov [rbp+var_60], rcx
mov [rbp+var_64], eax
jmp short loc_2419C
mov rcx, rax
mov eax, edx
mov [rbp+var_60], rcx
mov [rbp+var_64], eax
lea rdi, [rbp+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_2419C:
lea rdi, [rbp+var_51]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_24279
loc_241AA:
lea rax, [rbp+var_80]
mov [rbp+var_28], rax
lea rax, aGameHostPlayer; "game: host: {} player + {} status peers"
mov [rbp+var_30], rax
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_30]
call _ZN3fmt3v1117basic_string_viewIcEC2EPKc; fmt::v11::basic_string_view<char>::basic_string_view(char const*)
mov rax, [rbp+var_30]
mov [rbp+var_10], rax
lea rdi, _ZN8sessions11max_playersE; sessions::max_players
call _ZNK12ConfigNumberIjE9get_valueEv; ConfigNumber<uint>::get_value(void)
mov [rbp+var_84], eax
lea rdi, _ZL12status_peers; status_peers
call _ZNK12ConfigNumberIjE9get_valueEv; ConfigNumber<uint>::get_value(void)
mov [rbp+var_88], eax
mov rdi, [rbp+var_80]
mov rsi, [rbp+var_78]
lea rdx, [rbp+var_84]
lea rcx, [rbp+var_88]
call _ZN6spdlog4infoIJjjEEEvN3fmt3v1119basic_format_stringIcJDpNS2_13type_identityIT_E4typeEEEEDpOS5_; spdlog::info<uint,uint>(fmt::v11::basic_format_string<char,fmt::v11::type_identity<uint,uint>::type>,uint,uint&&)
lea rax, [rbp+var_98]
mov [rbp+var_18], rax
lea rax, aGameHostListen; "game: host: listening on UDP port {}"
mov [rbp+var_20], rax
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
call _ZN3fmt3v1117basic_string_viewIcEC2EPKc; fmt::v11::basic_string_view<char>::basic_string_view(char const*)
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
lea rdx, [rbp+var_6C]
add rdx, 4
mov rdi, [rbp+var_98]; this
mov rsi, [rbp+var_90]
call _ZN6spdlog4infoIJRtEEEvN3fmt3v1119basic_format_stringIcJDpNS3_13type_identityIT_E4typeEEEEDpOS6_; spdlog::info<ushort &>(fmt::v11::basic_format_string<char,fmt::v11::type_identity<ushort &>::type>,ushort &&&)
call _ZN11game_voxels8populateEv; game_voxels::populate(void)
call _ZN10game_items8populateEv; game_items::populate(void)
call _ZN8unloader9init_lateEv; unloader::init_late(void)
call _ZN8universe9init_lateEv; universe::init_late(void)
call _ZN8sessions18init_post_universeEv; sessions::init_post_universe(void)
add rsp, 0C0h
pop rbp
retn
loc_24279:
mov rdi, [rbp+var_60]
call __Unwind_Resume
| long long server_game::init_late(server_game *this)
{
int v1; // eax
game_voxels *v2; // rdi
int value; // [rsp+Ch] [rbp-B4h]
long long v5; // [rsp+18h] [rbp-A8h]
unloader *v6[2]; // [rsp+28h] [rbp-98h] BYREF
int v7; // [rsp+38h] [rbp-88h] BYREF
int v8; // [rsp+3Ch] [rbp-84h] BYREF
_QWORD v9[2]; // [rsp+40h] [rbp-80h] BYREF
int v10; // [rsp+54h] [rbp-6Ch] BYREF
_WORD v11[2]; // [rsp+58h] [rbp-68h] BYREF
char v12; // [rsp+6Fh] [rbp-51h] BYREF
_BYTE v13[32]; // [rsp+70h] [rbp-50h] BYREF
const char *v14; // [rsp+90h] [rbp-30h]
_QWORD *v15; // [rsp+98h] [rbp-28h]
const char *v16; // [rsp+A0h] [rbp-20h]
unloader **v17; // [rsp+A8h] [rbp-18h]
const char *v18; // [rsp+B0h] [rbp-10h]
const char *v19; // [rsp+B8h] [rbp-8h]
v5 = ConfigString::get((ConfigString *)&password_string);
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v13, v5, (long long)&v12);
server_game::password_hash = crc64::get(v13, 0LL);
std::string::~string(v13);
std::allocator<char>::~allocator(&v12);
sessions::init_late((sessions *)&v12);
whitelist::init_late((whitelist *)&v12);
v10 = 0;
v11[0] = ConfigNumber<unsigned short>::get_value(&listen_port);
value = ConfigNumber<unsigned int>::get_value(&sessions::max_players);
v1 = ConfigNumber<unsigned int>::get_value(&status_peers);
globals::server_host = enet_host_create(&v10, (unsigned int)(v1 + value), 1LL, 0LL);
if ( !globals::server_host )
{
spdlog::critical<char [35]>("game: unable to setup an ENet host");
std::terminate();
}
v15 = v9;
v14 = "game: host: {} player + {} status peers";
fmt::v11::basic_string_view<char>::basic_string_view(v9, (long long)"game: host: {} player + {} status peers");
v18 = v14;
v8 = ConfigNumber<unsigned int>::get_value(&sessions::max_players);
v7 = ConfigNumber<unsigned int>::get_value(&status_peers);
spdlog::info<unsigned int,unsigned int>(v9[0], v9[1], &v8, &v7);
v17 = v6;
v16 = "game: host: listening on UDP port {}";
fmt::v11::basic_string_view<char>::basic_string_view(v6, (long long)"game: host: listening on UDP port {}");
v19 = v16;
v2 = v6[0];
spdlog::info<unsigned short &>(v6[0], v6[1], v11);
game_voxels::populate(v2);
game_items::populate(v2);
unloader::init_late(v2);
universe::init_late(v2);
return sessions::init_post_universe(v2);
}
| init_late:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
LEA RDI,[0x3d11e0]
CALL 0x001f8270
MOV qword ptr [RBP + -0xa8],RAX
LEA RDI,[RBP + -0x51]
MOV qword ptr [RBP + -0xa0],RDI
CALL 0x0011b000
MOV RSI,qword ptr [RBP + -0xa8]
MOV RDX,qword ptr [RBP + -0xa0]
LAB_001240ac:
LEA RDI,[RBP + -0x50]
CALL 0x0011cfc0
JMP 0x001240b7
LAB_001240b7:
XOR EAX,EAX
MOV ESI,EAX
LEA RDI,[RBP + -0x50]
CALL 0x001fb430
LAB_001240c4:
MOV qword ptr [RBP + -0xb0],RAX
JMP 0x001240cd
LAB_001240cd:
MOV RAX,qword ptr [RBP + -0xb0]
MOV qword ptr [0x003d0940],RAX
LEA RDI,[RBP + -0x50]
CALL 0x0011b238
LEA RDI,[RBP + -0x51]
CALL 0x0011a9c0
CALL 0x0015a560
CALL 0x00189e30
MOV dword ptr [RBP + -0x6c],0x0
LEA RDI,[0x3d1178]
CALL 0x001246f0
MOV word ptr [RBP + -0x68],AX
LEA RDI,[0x3d13f0]
CALL 0x00124710
MOV dword ptr [RBP + -0xb4],EAX
LEA RDI,[0x3d11a8]
CALL 0x00124710
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0xb4]
ADD EAX,ECX
MOV EAX,EAX
MOV ESI,EAX
LEA RDI,[RBP + -0x6c]
MOV EDX,0x1
XOR R8D,R8D
MOV ECX,R8D
CALL 0x002b6850
MOV RCX,RAX
LEA RAX,[0x3d1250]
MOV qword ptr [RAX],RCX
LEA RAX,[0x3d1250]
CMP qword ptr [RAX],0x0
JNZ 0x001241aa
LEA RDI,[0x2e4665]
CALL 0x00124730
CALL 0x0011a210
LAB_001241aa:
LEA RAX,[RBP + -0x80]
MOV qword ptr [RBP + -0x28],RAX
LEA RAX,[0x2e4688]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00123f90
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x10],RAX
LEA RDI,[0x3d13f0]
CALL 0x00124710
MOV dword ptr [RBP + -0x84],EAX
LEA RDI,[0x3d11a8]
CALL 0x00124710
MOV dword ptr [RBP + -0x88],EAX
MOV RDI,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x78]
LEA RDX,[RBP + -0x84]
LEA RCX,[RBP + -0x88]
CALL 0x00124760
LEA RAX,[RBP + -0x98]
MOV qword ptr [RBP + -0x18],RAX
LEA RAX,[0x2e46b0]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00123f90
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LEA RDX,[RBP + -0x6c]
ADD RDX,0x4
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x90]
CALL 0x001247b0
CALL 0x001a9a30
CALL 0x001a97e0
CALL 0x00181700
CALL 0x00170830
CALL 0x0015a700
ADD RSP,0xc0
POP RBP
RET
|
/* server_game::init_late() */
void server_game::init_late(void)
{
int iVar1;
int iVar2;
char *pcVar3;
spdlog *local_a0;
int8 local_98;
int4 local_90;
int4 local_8c;
spdlog *local_88;
int8 local_80;
int4 local_74;
int2 local_70 [11];
allocator local_59;
string local_58 [32];
char *local_38;
basic_string_view<char> *local_30;
char *local_28;
basic_string_view<char> *local_20;
char *local_18;
char *local_10;
pcVar3 = (char *)ConfigString::get();
std::allocator<char>::allocator();
/* try { // try from 001240ac to 001240b4 has its CatchHandler @ 00124179 */
std::__cxx11::string::string<std::allocator<char>>(local_58,pcVar3,&local_59);
/* try { // try from 001240b7 to 001240c3 has its CatchHandler @ 00124187 */
password_hash = crc64::get(local_58,0);
std::__cxx11::string::~string(local_58);
std::allocator<char>::~allocator((allocator<char> *)&local_59);
sessions::init_late();
whitelist::init_late();
local_74 = 0;
local_70[0] = ConfigNumber<unsigned_short>::get_value((ConfigNumber<unsigned_short> *)listen_port)
;
iVar1 = ConfigNumber<unsigned_int>::get_value((ConfigNumber<unsigned_int> *)sessions::max_players)
;
iVar2 = ConfigNumber<unsigned_int>::get_value((ConfigNumber<unsigned_int> *)status_peers);
globals::server_host = enet_host_create(&local_74,iVar1 + iVar2,1,0);
if (globals::server_host == 0) {
spdlog::critical<char[35]>("game: unable to setup an ENet host");
/* WARNING: Subroutine does not return */
std::terminate();
}
local_30 = (basic_string_view<char> *)&local_88;
local_38 = "game: host: {} player + {} status peers";
fmt::v11::basic_string_view<char>::basic_string_view
(local_30,"game: host: {} player + {} status peers");
local_18 = local_38;
local_8c = ConfigNumber<unsigned_int>::get_value
((ConfigNumber<unsigned_int> *)sessions::max_players);
local_90 = ConfigNumber<unsigned_int>::get_value((ConfigNumber<unsigned_int> *)status_peers);
spdlog::info<unsigned_int,unsigned_int>(local_88,local_80,&local_8c,&local_90);
local_20 = (basic_string_view<char> *)&local_a0;
local_28 = "game: host: listening on UDP port {}";
fmt::v11::basic_string_view<char>::basic_string_view
(local_20,"game: host: listening on UDP port {}");
local_10 = local_28;
spdlog::info<unsigned_short&>(local_a0,local_98,local_70);
game_voxels::populate();
game_items::populate();
unloader::init_late();
universe::init_late();
sessions::init_post_universe();
return;
}
| |
50,622 | my_caseup_utf32 | eloqsql/strings/ctype-ucs2.c | static size_t
my_caseup_utf32(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
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= my_utf32_uni(cs, &wc, (uchar *)src, (uchar*) srcend)) > 0)
{
my_toupper_utf32(uni_plane, &wc);
if (res != my_uni_utf32(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
} | O0 | c | my_caseup_utf32:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x63dc2
jmp 0x63dc4
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x51(%rbp)
jae 0x63df4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x63ca0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x63dfd
jmp 0x63e57
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x67f90
movl -0x34(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x63cd0
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
je 0x63e30
jmp 0x63e57
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x63dc4
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_caseup_utf32:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_50], rax
jmp short $+2
loc_63DC2:
jmp short $+2
loc_63DC4:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_51], al
jnb short loc_63DF4
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_utf32_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_51], al
loc_63DF4:
mov al, [rbp+var_51]
test al, 1
jnz short loc_63DFD
jmp short loc_63E57
loc_63DFD:
mov rdi, [rbp+var_50]
lea rsi, [rbp+var_30]
call my_toupper_utf32
mov eax, [rbp+var_34]
mov [rbp+var_58], eax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_uni_utf32
mov ecx, eax
mov eax, [rbp+var_58]
cmp eax, ecx
jz short loc_63E30
jmp short loc_63E57
loc_63E30:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_34]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_63DC4
loc_63E57:
mov rax, [rbp+var_18]
add rsp, 60h
pop rbp
retn
| long long my_caseup_utf32(long long a1, unsigned long long a2, long long a3, _BYTE *a4, long long a5, long long a6)
{
bool v7; // [rsp+Fh] [rbp-51h]
long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v9; // [rsp+18h] [rbp-48h]
unsigned long long v10; // [rsp+20h] [rbp-40h]
int v11; // [rsp+2Ch] [rbp-34h]
unsigned long long v12[2]; // [rsp+30h] [rbp-30h] BYREF
_BYTE *v13; // [rsp+40h] [rbp-20h]
long long v14; // [rsp+48h] [rbp-18h]
unsigned long long v15; // [rsp+50h] [rbp-10h]
long long v16; // [rsp+58h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12[1] = a5;
v10 = a3 + a2;
v9 = (unsigned long long)&a4[a5];
v8 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( v15 < v10 )
{
v11 = my_utf32_uni(v16, (long long)v12, v15, v10, a5, a6);
v7 = v11 > 0;
}
if ( !v7 )
break;
my_toupper_utf32(v8, v12);
if ( v11 != (unsigned int)my_uni_utf32(v16, v12[0], v13, v9) )
break;
v15 += v11;
v13 += v11;
}
return v14;
}
| my_caseup_utf32:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00163dc2
LAB_00163dc2:
JMP 0x00163dc4
LAB_00163dc4:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x51],AL
JNC 0x00163df4
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x00163ca0
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x51],AL
LAB_00163df4:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x00163dfd
JMP 0x00163e57
LAB_00163dfd:
MOV RDI,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0x30]
CALL 0x00167f90
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x58],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x00163cd0
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x58]
CMP EAX,ECX
JZ 0x00163e30
JMP 0x00163e57
LAB_00163e30:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00163dc4
LAB_00163e57:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x60
POP RBP
RET
|
long my_caseup_utf32(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
int8 uVar1;
bool bVar2;
int iVar3;
int local_3c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_utf32_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_toupper_utf32(uVar1,&local_38);
iVar3 = my_uni_utf32(local_10,local_38,local_28,param_4 + param_5);
if (local_3c != iVar3) {
return local_20;
}
local_18 = local_18 + (long)local_3c;
local_28 = local_28 + local_3c;
}
return local_20;
}
| |
50,623 | my_caseup_utf32 | eloqsql/strings/ctype-ucs2.c | static size_t
my_caseup_utf32(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
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= my_utf32_uni(cs, &wc, (uchar *)src, (uchar*) srcend)) > 0)
{
my_toupper_utf32(uni_plane, &wc);
if (res != my_uni_utf32(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
} | O3 | c | my_caseup_utf32:
movq %rdx, %rax
cmpq $0x4, %rdx
jl 0x4cbcd
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq (%rsi,%rax), %rdx
addq %rcx, %r8
movq 0x78(%rdi), %rdi
addq $0x4, %rcx
movzbl (%rsi), %r9d
shll $0x18, %r9d
movzbl 0x1(%rsi), %r10d
shll $0x10, %r10d
orl %r9d, %r10d
cmpl $0x10ffff, %r10d # imm = 0x10FFFF
ja 0x4cbcb
movzbl 0x2(%rsi), %ebx
shll $0x8, %ebx
movzbl 0x3(%rsi), %r9d
orq %r9, %rbx
orq %r10, %rbx
cmpq (%rdi), %rbx
ja 0x4cb8c
movq 0x8(%rdi), %r10
movl %ebx, %r11d
shrl $0x8, %r11d
movq (%r10,%r11,8), %r10
testq %r10, %r10
je 0x4cb8c
leaq (%r9,%r9,2), %r9
movl (%r10,%r9,4), %ebx
cmpq %r8, %rcx
ja 0x4cbcb
cmpl $0x10ffff, %ebx # imm = 0x10FFFF
ja 0x4cbcb
movb $0x0, -0x4(%rcx)
movl %ebx, %r9d
shrl $0x10, %r9d
movb %r9b, -0x3(%rcx)
movb %bh, -0x2(%rcx)
movb %bl, -0x1(%rcx)
leaq 0x4(%rsi), %r9
cmpq %rdx, %r9
jae 0x4cbcb
addq $0x8, %rsi
addq $0x4, %rcx
cmpq %rdx, %rsi
movq %r9, %rsi
jbe 0x4cb3c
popq %rbx
popq %rbp
retq
| my_caseup_utf32:
mov rax, rdx
cmp rdx, 4
jl locret_4CBCD
push rbp
mov rbp, rsp
push rbx
lea rdx, [rsi+rax]
add r8, rcx
mov rdi, [rdi+78h]
add rcx, 4
loc_4CB3C:
movzx r9d, byte ptr [rsi]
shl r9d, 18h
movzx r10d, byte ptr [rsi+1]
shl r10d, 10h
or r10d, r9d
cmp r10d, offset unk_10FFFF
ja short loc_4CBCB
movzx ebx, byte ptr [rsi+2]
shl ebx, 8
movzx r9d, byte ptr [rsi+3]
or rbx, r9
or rbx, r10
cmp rbx, [rdi]
ja short loc_4CB8C
mov r10, [rdi+8]
mov r11d, ebx
shr r11d, 8
mov r10, [r10+r11*8]
test r10, r10
jz short loc_4CB8C
lea r9, [r9+r9*2]
mov ebx, [r10+r9*4]
loc_4CB8C:
cmp rcx, r8
ja short loc_4CBCB
cmp ebx, offset unk_10FFFF
ja short loc_4CBCB
mov byte ptr [rcx-4], 0
mov r9d, ebx
shr r9d, 10h
mov [rcx-3], r9b
mov [rcx-2], bh
mov [rcx-1], bl
lea r9, [rsi+4]
cmp r9, rdx
jnb short loc_4CBCB
add rsi, 8
add rcx, 4
cmp rsi, rdx
mov rsi, r9
jbe loc_4CB3C
loc_4CBCB:
pop rbx
pop rbp
locret_4CBCD:
retn
| long long my_caseup_utf32(long long a1, unsigned __int8 *a2, long long a3, long long a4, long long a5)
{
long long result; // rax
unsigned long long v6; // rdx
unsigned long long v7; // r8
unsigned long long *v8; // rdi
unsigned long long v9; // rcx
long long v10; // r10
long long v11; // r9
unsigned long long v12; // rbx
long long v13; // r10
bool v14; // cc
result = a3;
if ( a3 >= 4 )
{
v6 = (unsigned long long)&a2[a3];
v7 = a4 + a5;
v8 = *(unsigned long long **)(a1 + 120);
v9 = a4 + 4;
do
{
v10 = (*a2 << 24) | (a2[1] << 16);
if ( (unsigned int)v10 > (unsigned int)&unk_10FFFF )
break;
v11 = a2[3];
v12 = v10 | v11 | (a2[2] << 8);
if ( v12 <= *v8 )
{
v13 = *(_QWORD *)(v8[1] + 8LL * ((unsigned int)v12 >> 8));
if ( v13 )
LODWORD(v12) = *(_DWORD *)(v13 + 12 * v11);
}
if ( v9 > v7 )
break;
if ( (unsigned int)v12 > (unsigned int)&unk_10FFFF )
break;
*(_BYTE *)(v9 - 4) = 0;
*(_BYTE *)(v9 - 3) = BYTE2(v12);
*(_BYTE *)(v9 - 2) = BYTE1(v12);
*(_BYTE *)(v9 - 1) = v12;
if ( (unsigned long long)(a2 + 4) >= v6 )
break;
v9 += 4LL;
v14 = (unsigned long long)(a2 + 8) <= v6;
a2 += 4;
}
while ( v14 );
}
return result;
}
| my_caseup_utf32:
MOV RAX,RDX
CMP RDX,0x4
JL 0x0014cbcd
PUSH RBP
MOV RBP,RSP
PUSH RBX
LEA RDX,[RSI + RAX*0x1]
ADD R8,RCX
MOV RDI,qword ptr [RDI + 0x78]
ADD RCX,0x4
LAB_0014cb3c:
MOVZX R9D,byte ptr [RSI]
SHL R9D,0x18
MOVZX R10D,byte ptr [RSI + 0x1]
SHL R10D,0x10
OR R10D,R9D
CMP R10D,0x10ffff
JA 0x0014cbcb
MOVZX EBX,byte ptr [RSI + 0x2]
SHL EBX,0x8
MOVZX R9D,byte ptr [RSI + 0x3]
OR RBX,R9
OR RBX,R10
CMP RBX,qword ptr [RDI]
JA 0x0014cb8c
MOV R10,qword ptr [RDI + 0x8]
MOV R11D,EBX
SHR R11D,0x8
MOV R10,qword ptr [R10 + R11*0x8]
TEST R10,R10
JZ 0x0014cb8c
LEA R9,[R9 + R9*0x2]
MOV EBX,dword ptr [R10 + R9*0x4]
LAB_0014cb8c:
CMP RCX,R8
JA 0x0014cbcb
CMP EBX,0x10ffff
JA 0x0014cbcb
MOV byte ptr [RCX + -0x4],0x0
MOV R9D,EBX
SHR R9D,0x10
MOV byte ptr [RCX + -0x3],R9B
MOV byte ptr [RCX + -0x2],BH
MOV byte ptr [RCX + -0x1],BL
LEA R9,[RSI + 0x4]
CMP R9,RDX
JNC 0x0014cbcb
ADD RSI,0x8
ADD RCX,0x4
CMP RSI,RDX
MOV RSI,R9
JBE 0x0014cb3c
LAB_0014cbcb:
POP RBX
POP RBP
LAB_0014cbcd:
RET
|
void my_caseup_utf32(long param_1,byte *param_2,long param_3,long param_4,long param_5)
{
ulong *puVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
byte *pbVar5;
byte *pbVar6;
uint uVar7;
if (3 < param_3) {
puVar1 = *(ulong **)(param_1 + 0x78);
uVar3 = param_4 + 4;
pbVar5 = param_2;
while (uVar7 = (uint)pbVar5[1] << 0x10 | (uint)*pbVar5 << 0x18, uVar7 < 0x110000) {
uVar4 = (ulong)CONCAT11(pbVar5[2],pbVar5[3]) | (ulong)uVar7;
if ((uVar4 <= *puVar1) && (lVar2 = *(long *)(puVar1[1] + (uVar4 >> 8) * 8), lVar2 != 0)) {
uVar4 = (ulong)*(uint *)(lVar2 + (ulong)pbVar5[3] * 0xc);
}
if ((ulong)(param_5 + param_4) < uVar3) {
return;
}
if (0x10ffff < (uint)uVar4) {
return;
}
*(int1 *)(uVar3 - 4) = 0;
*(char *)(uVar3 - 3) = (char)(uVar4 >> 0x10);
*(char *)(uVar3 - 2) = (char)(uVar4 >> 8);
*(char *)(uVar3 - 1) = (char)uVar4;
if (param_2 + param_3 <= pbVar5 + 4) {
return;
}
pbVar6 = pbVar5 + 8;
uVar3 = uVar3 + 4;
pbVar5 = pbVar5 + 4;
if (param_2 + param_3 < pbVar6) {
return;
}
}
}
return;
}
| |
50,624 | 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 0x5f2a3
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 0x5f299
addq $-0x4, %rcx
addq $-0x4, %rdi
cmpq %rax, %rcx
ja 0x5f261
xorl %edi, %edi
movq %rdx, %rsi
callq 0x5ed20
movl $0x1, 0x14(%rax)
movq (%rax), %rcx
movl $0x0, (%rcx)
jmp 0x5f33f
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 0x5ed20
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 0x5f2e0
leaq (%r8,%rcx,4), %r8
cmpq %r8, %rsi
jae 0x5f32b
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 0x5f309
incl %ecx
addq $-0x4, %rdx
decl %ecx
cmpl $0x0, (%rdx)
leaq -0x4(%rdx), %rdx
je 0x5f331
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_5F2A3
mov rax, [rbx]
lea rcx, [rax+rdi*4]
mov r8, [rsi]
lea rdi, [r8+rdi*4]
add rdi, 0FFFFFFFFFFFFFFFCh
loc_5F261:
mov r8d, [rcx-4]
mov r9d, [rdi]
cmp r8d, r9d
jnz short loc_5F299
add rcx, 0FFFFFFFFFFFFFFFCh
add rdi, 0FFFFFFFFFFFFFFFCh
cmp rcx, rax
ja short loc_5F261
xor edi, edi
mov rsi, rdx
call Balloc
mov dword ptr [rax+14h], 1
mov rcx, [rax]
mov dword ptr [rcx], 0
jmp loc_5F33F
loc_5F299:
xor eax, eax
cmp r8d, r9d
sbb eax, eax
or eax, 1
loc_5F2A3:
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_5F2E0:
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_5F2E0
lea r8, [r8+rcx*4]
loc_5F309:
cmp rsi, r8
jnb short loc_5F32B
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_5F309
loc_5F32B:
inc ecx
add rdx, 0FFFFFFFFFFFFFFFCh
loc_5F331:
dec ecx
cmp dword ptr [rdx], 0
lea rdx, [rdx-4]
jz short loc_5F331
mov [rax+14h], ecx
loc_5F33F:
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 0x0015f2a3
MOV RAX,qword ptr [RBX]
LEA RCX,[RAX + RDI*0x4]
MOV R8,qword ptr [RSI]
LEA RDI,[R8 + RDI*0x4]
ADD RDI,-0x4
LAB_0015f261:
MOV R8D,dword ptr [RCX + -0x4]
MOV R9D,dword ptr [RDI]
CMP R8D,R9D
JNZ 0x0015f299
ADD RCX,-0x4
ADD RDI,-0x4
CMP RCX,RAX
JA 0x0015f261
XOR EDI,EDI
MOV RSI,RDX
CALL 0x0015ed20
MOV dword ptr [RAX + 0x14],0x1
MOV RCX,qword ptr [RAX]
MOV dword ptr [RCX],0x0
JMP 0x0015f33f
LAB_0015f299:
XOR EAX,EAX
CMP R8D,R9D
SBB EAX,EAX
OR EAX,0x1
LAB_0015f2a3:
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 0x0015ed20
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_0015f2e0:
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 0x0015f2e0
LEA R8,[R8 + RCX*0x4]
LAB_0015f309:
CMP RSI,R8
JNC 0x0015f32b
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 0x0015f309
LAB_0015f32b:
INC ECX
ADD RDX,-0x4
LAB_0015f331:
DEC ECX
CMP dword ptr [RDX],0x0
LEA RDX,[RDX + -0x4]
JZ 0x0015f331
MOV dword ptr [RAX + 0x14],ECX
LAB_0015f33f:
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_0015f2a3;
}
uVar6 = uVar6 - 4;
} while (*param_1 < uVar6);
puVar4 = (int8 *)Balloc(0,param_3);
*(int4 *)((long)puVar4 + 0x14) = 1;
*(int4 *)*puVar4 = 0;
}
else {
LAB_0015f2a3:
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;
}
| |
50,625 | thr_lock_delete | eloqsql/mysys/thr_lock.c | void thr_lock_delete(THR_LOCK *lock)
{
DBUG_ENTER("thr_lock_delete");
mysql_mutex_lock(&THR_LOCK_lock);
thr_lock_thread_list=list_delete(thr_lock_thread_list,&lock->list);
mysql_mutex_unlock(&THR_LOCK_lock);
mysql_mutex_destroy(&lock->mutex);
DBUG_VOID_RETURN;
} | O3 | c | thr_lock_delete:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb65f45(%rip), %r14 # 0xc08708
cmpq $0x0, 0x40(%r14)
jne 0xa2834
leaq 0xb65f37(%rip), %rdi # 0xc08708
callq 0x29210
leaq 0xb661db(%rip), %r15 # 0xc089b8
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x94784
movq %rax, (%r15)
movq 0x40(%r14), %rdi
testq %rdi, %rdi
jne 0xa283b
leaq 0xb65f0d(%rip), %rdi # 0xc08708
callq 0x291d0
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xa281e
leaq 0x2e3800(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x58(%rbx)
addq $0x18, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x290c0
callq 0x2f1db
jmp 0xa27d6
leaq 0x2e37ce(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0xa27f4
| thr_lock_delete:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
lea r14, THR_LOCK_lock
cmp qword ptr [r14+40h], 0
jnz short loc_A2834
lea rdi, THR_LOCK_lock
call _pthread_mutex_lock
loc_A27D6:
lea r15, thr_lock_thread_list
mov rdi, [r15]
mov rsi, rbx
call list_delete
mov [r15], rax
mov rdi, [r14+40h]
test rdi, rdi
jnz short loc_A283B
loc_A27F4:
lea rdi, THR_LOCK_lock
call _pthread_mutex_unlock
mov rdi, [rbx+58h]
test rdi, rdi
jz short loc_A281E
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+58h], 0
loc_A281E:
add rbx, 18h
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _pthread_mutex_destroy
loc_A2834:
call thr_lock_delete_cold_1
jmp short loc_A27D6
loc_A283B:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_A27F4
| long long thr_lock_delete(_QWORD *a1)
{
long long v2; // rdi
long long v3; // rdi
if ( THR_LOCK_lock[8] )
thr_lock_delete_cold_1(a1);
else
pthread_mutex_lock(THR_LOCK_lock);
thr_lock_thread_list = list_delete(thr_lock_thread_list, a1);
v2 = THR_LOCK_lock[8];
if ( v2 )
((void ( *)(long long))PSI_server[44])(v2);
pthread_mutex_unlock(THR_LOCK_lock);
v3 = a1[11];
if ( v3 )
{
((void ( *)(long long))PSI_server[9])(v3);
a1[11] = 0LL;
}
return pthread_mutex_destroy(a1 + 3);
}
| thr_lock_delete:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA R14,[0xd08708]
CMP qword ptr [R14 + 0x40],0x0
JNZ 0x001a2834
LEA RDI,[0xd08708]
CALL 0x00129210
LAB_001a27d6:
LEA R15,[0xd089b8]
MOV RDI,qword ptr [R15]
MOV RSI,RBX
CALL 0x00194784
MOV qword ptr [R15],RAX
MOV RDI,qword ptr [R14 + 0x40]
TEST RDI,RDI
JNZ 0x001a283b
LAB_001a27f4:
LEA RDI,[0xd08708]
CALL 0x001291d0
MOV RDI,qword ptr [RBX + 0x58]
TEST RDI,RDI
JZ 0x001a281e
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x58],0x0
LAB_001a281e:
ADD RBX,0x18
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001290c0
LAB_001a2834:
CALL 0x0012f1db
JMP 0x001a27d6
LAB_001a283b:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001a27f4
|
void thr_lock_delete(long param_1)
{
if (THR_LOCK_lock._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_lock);
}
else {
thr_lock_delete_cold_1();
}
thr_lock_thread_list = list_delete(thr_lock_thread_list,param_1);
if (THR_LOCK_lock._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_lock);
if (*(long *)(param_1 + 0x58) != 0) {
(**(code **)(PSI_server + 0x48))();
*(int8 *)(param_1 + 0x58) = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x18));
return;
}
| |
50,626 | google::protobuf::FieldDescriptorProto::ByteSizeLong() const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc | size_t FieldDescriptorProto::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.protobuf.FieldDescriptorProto)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x000000ffu) {
// optional string name = 1;
if (cached_has_bits & 0x00000001u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_name());
}
// optional string extendee = 2;
if (cached_has_bits & 0x00000002u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_extendee());
}
// optional string type_name = 6;
if (cached_has_bits & 0x00000004u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_type_name());
}
// optional string default_value = 7;
if (cached_has_bits & 0x00000008u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_default_value());
}
// optional string json_name = 10;
if (cached_has_bits & 0x00000010u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_json_name());
}
// optional .google.protobuf.FieldOptions options = 8;
if (cached_has_bits & 0x00000020u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
*_impl_.options_);
}
// optional int32 number = 3;
if (cached_has_bits & 0x00000040u) {
total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_number());
}
// optional int32 oneof_index = 9;
if (cached_has_bits & 0x00000080u) {
total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_oneof_index());
}
}
if (cached_has_bits & 0x00000700u) {
// optional bool proto3_optional = 17;
if (cached_has_bits & 0x00000100u) {
total_size += 2 + 1;
}
// optional .google.protobuf.FieldDescriptorProto.Label label = 4;
if (cached_has_bits & 0x00000200u) {
total_size += 1 +
::_pbi::WireFormatLite::EnumSize(this->_internal_label());
}
// optional .google.protobuf.FieldDescriptorProto.Type type = 5;
if (cached_has_bits & 0x00000400u) {
total_size += 1 +
::_pbi::WireFormatLite::EnumSize(this->_internal_type());
}
}
return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
} | O3 | cpp | google::protobuf::FieldDescriptorProto::ByteSizeLong() const:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %ebp
testb %bpl, %bpl
je 0xeec9a
testb $0x1, %bpl
jne 0xeeca2
xorl %r14d, %r14d
jmp 0xeecc6
xorl %r14d, %r14d
jmp 0xeedd4
movq 0x18(%rbx), %rax
andq $-0x4, %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
orl $0x1, %ecx
bsrl %ecx, %ecx
leal (%rcx,%rcx,8), %ecx
addl $0x49, %ecx
shrl $0x6, %ecx
leaq (%rax,%rcx), %r14
incq %r14
testb $0x2, %bpl
je 0xeecf0
movq 0x20(%rbx), %rax
andq $-0x4, %rax
movq 0x8(%rax), %rax
addq %rax, %r14
orl $0x1, %eax
bsrl %eax, %eax
leal (%rax,%rax,8), %eax
addl $0x49, %eax
shrl $0x6, %eax
addq %rax, %r14
incq %r14
testb $0x4, %bpl
je 0xeed1a
movq 0x28(%rbx), %rax
andq $-0x4, %rax
movq 0x8(%rax), %rax
addq %rax, %r14
orl $0x1, %eax
bsrl %eax, %eax
leal (%rax,%rax,8), %eax
addl $0x49, %eax
shrl $0x6, %eax
addq %rax, %r14
incq %r14
testb $0x8, %bpl
je 0xeed44
movq 0x30(%rbx), %rax
andq $-0x4, %rax
movq 0x8(%rax), %rax
addq %rax, %r14
orl $0x1, %eax
bsrl %eax, %eax
leal (%rax,%rax,8), %eax
addl $0x49, %eax
shrl $0x6, %eax
addq %rax, %r14
incq %r14
testb $0x10, %bpl
je 0xeed6e
movq 0x38(%rbx), %rax
andq $-0x4, %rax
movq 0x8(%rax), %rax
addq %rax, %r14
orl $0x1, %eax
bsrl %eax, %eax
leal (%rax,%rax,8), %eax
addl $0x49, %eax
shrl $0x6, %eax
addq %rax, %r14
incq %r14
testb $0x20, %bpl
je 0xeed95
movq 0x40(%rbx), %rdi
callq 0xf4fac
addq %rax, %r14
orl $0x1, %eax
bsrl %eax, %eax
leal (%rax,%rax,8), %eax
addl $0x49, %eax
shrl $0x6, %eax
addq %rax, %r14
incq %r14
testb $0x40, %bpl
je 0xeedb5
movslq 0x48(%rbx), %rax
orq $0x1, %rax
bsrq %rax, %rax
leal (%rax,%rax,8), %eax
addl $0x89, %eax
shrl $0x6, %eax
addq %rax, %r14
testb %bpl, %bpl
jns 0xeedd4
movslq 0x4c(%rbx), %rax
orq $0x1, %rax
bsrq %rax, %rax
leal (%rax,%rax,8), %eax
addl $0x89, %eax
shrl $0x6, %eax
addq %rax, %r14
testl $0x700, %ebp # imm = 0x700
je 0xeee30
leaq 0x3(%r14), %rax
btl $0x8, %ebp
cmovaeq %r14, %rax
btl $0x9, %ebp
jae 0xeee09
movslq 0x54(%rbx), %rcx
orq $0x1, %rcx
bsrq %rcx, %rcx
leal (%rcx,%rcx,8), %ecx
addl $0x49, %ecx
shrl $0x6, %ecx
addq %rcx, %rax
incq %rax
btl $0xa, %ebp
jb 0xeee14
movq %rax, %r14
jmp 0xeee30
movslq 0x58(%rbx), %rcx
orq $0x1, %rcx
bsrq %rcx, %rcx
leal (%rcx,%rcx,8), %ecx
addl $0x49, %ecx
shrl $0x6, %ecx
leaq (%rax,%rcx), %r14
incq %r14
leaq 0x14(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x9f36e
nop
| _ZNK6google8protobuf20FieldDescriptorProto12ByteSizeLongEv:
push rbp
push r14
push rbx
mov rbx, rdi
mov ebp, [rdi+10h]
test bpl, bpl
jz short loc_EEC9A
test bpl, 1
jnz short loc_EECA2
xor r14d, r14d
jmp short loc_EECC6
loc_EEC9A:
xor r14d, r14d
jmp loc_EEDD4
loc_EECA2:
mov rax, [rbx+18h]
and rax, 0FFFFFFFFFFFFFFFCh
mov rax, [rax+8]
mov ecx, eax
or ecx, 1
bsr ecx, ecx
lea ecx, [rcx+rcx*8]
add ecx, 49h ; 'I'
shr ecx, 6
lea r14, [rax+rcx]
inc r14
loc_EECC6:
test bpl, 2
jz short loc_EECF0
mov rax, [rbx+20h]
and rax, 0FFFFFFFFFFFFFFFCh
mov rax, [rax+8]
add r14, rax
or eax, 1
bsr eax, eax
lea eax, [rax+rax*8]
add eax, 49h ; 'I'
shr eax, 6
add r14, rax
inc r14
loc_EECF0:
test bpl, 4
jz short loc_EED1A
mov rax, [rbx+28h]
and rax, 0FFFFFFFFFFFFFFFCh
mov rax, [rax+8]
add r14, rax
or eax, 1
bsr eax, eax
lea eax, [rax+rax*8]
add eax, 49h ; 'I'
shr eax, 6
add r14, rax
inc r14
loc_EED1A:
test bpl, 8
jz short loc_EED44
mov rax, [rbx+30h]
and rax, 0FFFFFFFFFFFFFFFCh
mov rax, [rax+8]
add r14, rax
or eax, 1
bsr eax, eax
lea eax, [rax+rax*8]
add eax, 49h ; 'I'
shr eax, 6
add r14, rax
inc r14
loc_EED44:
test bpl, 10h
jz short loc_EED6E
mov rax, [rbx+38h]
and rax, 0FFFFFFFFFFFFFFFCh
mov rax, [rax+8]
add r14, rax
or eax, 1
bsr eax, eax
lea eax, [rax+rax*8]
add eax, 49h ; 'I'
shr eax, 6
add r14, rax
inc r14
loc_EED6E:
test bpl, 20h
jz short loc_EED95
mov rdi, [rbx+40h]; this
call _ZNK6google8protobuf12FieldOptions12ByteSizeLongEv; google::protobuf::FieldOptions::ByteSizeLong(void)
add r14, rax
or eax, 1
bsr eax, eax
lea eax, [rax+rax*8]
add eax, 49h ; 'I'
shr eax, 6
add r14, rax
inc r14
loc_EED95:
test bpl, 40h
jz short loc_EEDB5
movsxd rax, dword ptr [rbx+48h]
or rax, 1
bsr rax, rax
lea eax, [rax+rax*8]
add eax, 89h
shr eax, 6
add r14, rax
loc_EEDB5:
test bpl, bpl
jns short loc_EEDD4
movsxd rax, dword ptr [rbx+4Ch]
or rax, 1
bsr rax, rax
lea eax, [rax+rax*8]
add eax, 89h
shr eax, 6
add r14, rax
loc_EEDD4:
test ebp, 700h
jz short loc_EEE30
lea rax, [r14+3]
bt ebp, 8
cmovnb rax, r14
bt ebp, 9
jnb short loc_EEE09
movsxd rcx, dword ptr [rbx+54h]
or rcx, 1
bsr rcx, rcx
lea ecx, [rcx+rcx*8]
add ecx, 49h ; 'I'
shr ecx, 6
add rax, rcx
inc rax
loc_EEE09:
bt ebp, 0Ah
jb short loc_EEE14
mov r14, rax
jmp short loc_EEE30
loc_EEE14:
movsxd rcx, dword ptr [rbx+58h]
or rcx, 1
bsr rcx, rcx
lea ecx, [rcx+rcx*8]
add ecx, 49h ; 'I'
shr ecx, 6
lea r14, [rax+rcx]
inc r14
loc_EEE30:
lea rdx, [rbx+14h]
mov rdi, rbx
mov rsi, r14
pop rbx
pop r14
pop rbp
jmp _ZNK6google8protobuf7Message29MaybeComputeUnknownFieldsSizeEmPNS0_8internal10CachedSizeE; google::protobuf::Message::MaybeComputeUnknownFieldsSize(ulong,google::protobuf::internal::CachedSize *)
| char * google::protobuf::FieldDescriptorProto::ByteSizeLong(google::protobuf::FieldDescriptorProto *this)
{
int v1; // ebp
const google::protobuf::UnknownFieldSet *v2; // r14
unsigned int v3; // ecx
long long v4; // rax
char *v5; // r14
long long v6; // rax
char *v7; // r14
long long v8; // rax
char *v9; // r14
long long v10; // rax
char *v11; // r14
long long v12; // rax
char *v13; // r14
unsigned long long v14; // rax
unsigned long long v15; // rax
const google::protobuf::UnknownFieldSet *v16; // rax
unsigned long long v17; // rcx
unsigned long long v18; // rcx
v1 = *((_DWORD *)this + 4);
if ( (_BYTE)v1 )
{
if ( (v1 & 1) != 0 )
{
_BitScanReverse(&v3, *(_QWORD *)((*((_QWORD *)this + 3) & 0xFFFFFFFFFFFFFFFCLL) + 8) | 1);
v2 = (const google::protobuf::UnknownFieldSet *)(*(_QWORD *)((*((_QWORD *)this + 3) & 0xFFFFFFFFFFFFFFFCLL) + 8)
+ ((9 * v3 + 73) >> 6)
+ 1LL);
}
else
{
v2 = 0LL;
}
if ( (v1 & 2) != 0 )
{
v4 = *(_QWORD *)((*((_QWORD *)this + 4) & 0xFFFFFFFFFFFFFFFCLL) + 8);
v5 = (char *)v2 + v4;
_BitScanReverse((unsigned int *)&v4, v4 | 1);
v2 = (const google::protobuf::UnknownFieldSet *)&v5[((unsigned int)(9 * v4 + 73) >> 6) + 1];
}
if ( (v1 & 4) != 0 )
{
v6 = *(_QWORD *)((*((_QWORD *)this + 5) & 0xFFFFFFFFFFFFFFFCLL) + 8);
v7 = (char *)v2 + v6;
_BitScanReverse((unsigned int *)&v6, v6 | 1);
v2 = (const google::protobuf::UnknownFieldSet *)&v7[((unsigned int)(9 * v6 + 73) >> 6) + 1];
}
if ( (v1 & 8) != 0 )
{
v8 = *(_QWORD *)((*((_QWORD *)this + 6) & 0xFFFFFFFFFFFFFFFCLL) + 8);
v9 = (char *)v2 + v8;
_BitScanReverse((unsigned int *)&v8, v8 | 1);
v2 = (const google::protobuf::UnknownFieldSet *)&v9[((unsigned int)(9 * v8 + 73) >> 6) + 1];
}
if ( (v1 & 0x10) != 0 )
{
v10 = *(_QWORD *)((*((_QWORD *)this + 7) & 0xFFFFFFFFFFFFFFFCLL) + 8);
v11 = (char *)v2 + v10;
_BitScanReverse((unsigned int *)&v10, v10 | 1);
v2 = (const google::protobuf::UnknownFieldSet *)&v11[((unsigned int)(9 * v10 + 73) >> 6) + 1];
}
if ( (v1 & 0x20) != 0 )
{
v12 = google::protobuf::FieldOptions::ByteSizeLong(*((google::protobuf::FieldOptions **)this + 8));
v13 = (char *)v2 + v12;
_BitScanReverse((unsigned int *)&v12, v12 | 1);
v2 = (const google::protobuf::UnknownFieldSet *)&v13[((unsigned int)(9 * v12 + 73) >> 6) + 1];
}
if ( (v1 & 0x40) != 0 )
{
_BitScanReverse64(&v14, *((int *)this + 18) | 1LL);
v2 = (const google::protobuf::UnknownFieldSet *)((char *)v2 + ((unsigned int)(9 * v14 + 137) >> 6));
}
if ( (v1 & 0x80u) != 0 )
{
_BitScanReverse64(&v15, *((int *)this + 19) | 1LL);
v2 = (const google::protobuf::UnknownFieldSet *)((char *)v2 + ((unsigned int)(9 * v15 + 137) >> 6));
}
}
else
{
v2 = 0LL;
}
if ( (v1 & 0x700) != 0 )
{
v16 = (const google::protobuf::UnknownFieldSet *)((char *)v2 + 3);
if ( (v1 & 0x100) == 0 )
v16 = v2;
if ( (v1 & 0x200) != 0 )
{
_BitScanReverse64(&v17, *((int *)this + 21) | 1LL);
v16 = (const google::protobuf::UnknownFieldSet *)((char *)v16 + ((unsigned int)(9 * v17 + 73) >> 6) + 1);
}
if ( (v1 & 0x400) != 0 )
{
_BitScanReverse64(&v18, *((int *)this + 22) | 1LL);
v2 = (const google::protobuf::UnknownFieldSet *)((char *)v16 + ((unsigned int)(9 * v18 + 73) >> 6) + 1);
}
else
{
v2 = v16;
}
}
return google::protobuf::Message::MaybeComputeUnknownFieldsSize((long long)this, v2, (_DWORD *)this + 5);
}
| ByteSizeLong:
PUSH RBP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV EBP,dword ptr [RDI + 0x10]
TEST BPL,BPL
JZ 0x001eec9a
TEST BPL,0x1
JNZ 0x001eeca2
XOR R14D,R14D
JMP 0x001eecc6
LAB_001eec9a:
XOR R14D,R14D
JMP 0x001eedd4
LAB_001eeca2:
MOV RAX,qword ptr [RBX + 0x18]
AND RAX,-0x4
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,EAX
OR ECX,0x1
BSR ECX,ECX
LEA ECX,[RCX + RCX*0x8]
ADD ECX,0x49
SHR ECX,0x6
LEA R14,[RAX + RCX*0x1]
INC R14
LAB_001eecc6:
TEST BPL,0x2
JZ 0x001eecf0
MOV RAX,qword ptr [RBX + 0x20]
AND RAX,-0x4
MOV RAX,qword ptr [RAX + 0x8]
ADD R14,RAX
OR EAX,0x1
BSR EAX,EAX
LEA EAX,[RAX + RAX*0x8]
ADD EAX,0x49
SHR EAX,0x6
ADD R14,RAX
INC R14
LAB_001eecf0:
TEST BPL,0x4
JZ 0x001eed1a
MOV RAX,qword ptr [RBX + 0x28]
AND RAX,-0x4
MOV RAX,qword ptr [RAX + 0x8]
ADD R14,RAX
OR EAX,0x1
BSR EAX,EAX
LEA EAX,[RAX + RAX*0x8]
ADD EAX,0x49
SHR EAX,0x6
ADD R14,RAX
INC R14
LAB_001eed1a:
TEST BPL,0x8
JZ 0x001eed44
MOV RAX,qword ptr [RBX + 0x30]
AND RAX,-0x4
MOV RAX,qword ptr [RAX + 0x8]
ADD R14,RAX
OR EAX,0x1
BSR EAX,EAX
LEA EAX,[RAX + RAX*0x8]
ADD EAX,0x49
SHR EAX,0x6
ADD R14,RAX
INC R14
LAB_001eed44:
TEST BPL,0x10
JZ 0x001eed6e
MOV RAX,qword ptr [RBX + 0x38]
AND RAX,-0x4
MOV RAX,qword ptr [RAX + 0x8]
ADD R14,RAX
OR EAX,0x1
BSR EAX,EAX
LEA EAX,[RAX + RAX*0x8]
ADD EAX,0x49
SHR EAX,0x6
ADD R14,RAX
INC R14
LAB_001eed6e:
TEST BPL,0x20
JZ 0x001eed95
MOV RDI,qword ptr [RBX + 0x40]
CALL 0x001f4fac
ADD R14,RAX
OR EAX,0x1
BSR EAX,EAX
LEA EAX,[RAX + RAX*0x8]
ADD EAX,0x49
SHR EAX,0x6
ADD R14,RAX
INC R14
LAB_001eed95:
TEST BPL,0x40
JZ 0x001eedb5
MOVSXD RAX,dword ptr [RBX + 0x48]
OR RAX,0x1
BSR RAX,RAX
LEA EAX,[RAX + RAX*0x8]
ADD EAX,0x89
SHR EAX,0x6
ADD R14,RAX
LAB_001eedb5:
TEST BPL,BPL
JNS 0x001eedd4
MOVSXD RAX,dword ptr [RBX + 0x4c]
OR RAX,0x1
BSR RAX,RAX
LEA EAX,[RAX + RAX*0x8]
ADD EAX,0x89
SHR EAX,0x6
ADD R14,RAX
LAB_001eedd4:
TEST EBP,0x700
JZ 0x001eee30
LEA RAX,[R14 + 0x3]
BT EBP,0x8
CMOVNC RAX,R14
BT EBP,0x9
JNC 0x001eee09
MOVSXD RCX,dword ptr [RBX + 0x54]
OR RCX,0x1
BSR RCX,RCX
LEA ECX,[RCX + RCX*0x8]
ADD ECX,0x49
SHR ECX,0x6
ADD RAX,RCX
INC RAX
LAB_001eee09:
BT EBP,0xa
JC 0x001eee14
MOV R14,RAX
JMP 0x001eee30
LAB_001eee14:
MOVSXD RCX,dword ptr [RBX + 0x58]
OR RCX,0x1
BSR RCX,RCX
LEA ECX,[RCX + RCX*0x8]
ADD ECX,0x49
SHR ECX,0x6
LEA R14,[RAX + RCX*0x1]
INC R14
LAB_001eee30:
LEA RDX,[RBX + 0x14]
MOV RDI,RBX
MOV RSI,R14
POP RBX
POP R14
POP RBP
JMP 0x0019f36e
|
/* google::protobuf::FieldDescriptorProto::ByteSizeLong() const */
void __thiscall google::protobuf::FieldDescriptorProto::ByteSizeLong(FieldDescriptorProto *this)
{
uint uVar1;
int iVar2;
uint uVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
uVar1 = *(uint *)(this + 0x10);
if ((char)uVar1 == '\0') {
uVar6 = 0;
}
else {
if ((uVar1 & 1) == 0) {
uVar6 = 0;
}
else {
lVar4 = *(long *)((*(ulong *)(this + 0x18) & 0xfffffffffffffffc) + 8);
uVar3 = (uint)lVar4 | 1;
iVar2 = 0x1f;
if (uVar3 != 0) {
for (; uVar3 >> iVar2 == 0; iVar2 = iVar2 + -1) {
}
}
uVar6 = lVar4 + (ulong)(iVar2 * 9 + 0x49U >> 6) + 1;
}
if ((uVar1 & 2) != 0) {
lVar4 = *(long *)((*(ulong *)(this + 0x20) & 0xfffffffffffffffc) + 8);
uVar3 = (uint)lVar4 | 1;
iVar2 = 0x1f;
if (uVar3 != 0) {
for (; uVar3 >> iVar2 == 0; iVar2 = iVar2 + -1) {
}
}
uVar6 = uVar6 + lVar4 + (ulong)(iVar2 * 9 + 0x49U >> 6) + 1;
}
if ((uVar1 & 4) != 0) {
lVar4 = *(long *)((*(ulong *)(this + 0x28) & 0xfffffffffffffffc) + 8);
uVar3 = (uint)lVar4 | 1;
iVar2 = 0x1f;
if (uVar3 != 0) {
for (; uVar3 >> iVar2 == 0; iVar2 = iVar2 + -1) {
}
}
uVar6 = uVar6 + lVar4 + (ulong)(iVar2 * 9 + 0x49U >> 6) + 1;
}
if ((uVar1 & 8) != 0) {
lVar4 = *(long *)((*(ulong *)(this + 0x30) & 0xfffffffffffffffc) + 8);
uVar3 = (uint)lVar4 | 1;
iVar2 = 0x1f;
if (uVar3 != 0) {
for (; uVar3 >> iVar2 == 0; iVar2 = iVar2 + -1) {
}
}
uVar6 = uVar6 + lVar4 + (ulong)(iVar2 * 9 + 0x49U >> 6) + 1;
}
if ((uVar1 & 0x10) != 0) {
lVar4 = *(long *)((*(ulong *)(this + 0x38) & 0xfffffffffffffffc) + 8);
uVar3 = (uint)lVar4 | 1;
iVar2 = 0x1f;
if (uVar3 != 0) {
for (; uVar3 >> iVar2 == 0; iVar2 = iVar2 + -1) {
}
}
uVar6 = uVar6 + lVar4 + (ulong)(iVar2 * 9 + 0x49U >> 6) + 1;
}
if ((uVar1 & 0x20) != 0) {
lVar4 = FieldOptions::ByteSizeLong(*(FieldOptions **)(this + 0x40));
uVar3 = (uint)lVar4 | 1;
iVar2 = 0x1f;
if (uVar3 != 0) {
for (; uVar3 >> iVar2 == 0; iVar2 = iVar2 + -1) {
}
}
uVar6 = uVar6 + lVar4 + (ulong)(iVar2 * 9 + 0x49U >> 6) + 1;
}
if ((uVar1 & 0x40) != 0) {
lVar4 = 0x3f;
if (((long)*(int *)(this + 0x48) | 1U) != 0) {
for (; ((long)*(int *)(this + 0x48) | 1U) >> lVar4 == 0; lVar4 = lVar4 + -1) {
}
}
uVar6 = uVar6 + ((int)lVar4 * 9 + 0x89U >> 6);
}
if ((char)uVar1 < '\0') {
lVar4 = 0x3f;
if (((long)*(int *)(this + 0x4c) | 1U) != 0) {
for (; ((long)*(int *)(this + 0x4c) | 1U) >> lVar4 == 0; lVar4 = lVar4 + -1) {
}
}
uVar6 = uVar6 + ((int)lVar4 * 9 + 0x89U >> 6);
}
}
uVar5 = uVar6;
if ((uVar1 & 0x700) != 0) {
uVar5 = uVar6 + 3;
if ((uVar1 >> 8 & 1) == 0) {
uVar5 = uVar6;
}
if ((uVar1 >> 9 & 1) != 0) {
lVar4 = 0x3f;
if (((long)*(int *)(this + 0x54) | 1U) != 0) {
for (; ((long)*(int *)(this + 0x54) | 1U) >> lVar4 == 0; lVar4 = lVar4 + -1) {
}
}
uVar5 = uVar5 + ((int)lVar4 * 9 + 0x49U >> 6) + 1;
}
if ((uVar1 >> 10 & 1) != 0) {
lVar4 = 0x3f;
if (((long)*(int *)(this + 0x58) | 1U) != 0) {
for (; ((long)*(int *)(this + 0x58) | 1U) >> lVar4 == 0; lVar4 = lVar4 + -1) {
}
}
uVar5 = uVar5 + ((int)lVar4 * 9 + 0x49U >> 6) + 1;
}
}
Message::MaybeComputeUnknownFieldsSize((Message *)this,uVar5,(CachedSize *)(this + 0x14));
return;
}
| |
50,627 | set_prealloc_root | eloqsql/mysys/my_alloc.c | void set_prealloc_root(MEM_ROOT *root, char *ptr)
{
USED_MEM *next;
for (next=root->used; next ; next=next->next)
{
if ((char*) next <= ptr && (char*) next + next->size > ptr)
{
root->pre_alloc=next;
return;
}
}
for (next=root->free ; next ; next=next->next)
{
if ((char*) next <= ptr && (char*) next + next->size > ptr)
{
root->pre_alloc=next;
return;
}
}
} | O3 | c | set_prealloc_root:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xa3042
cmpq %rsi, %rax
ja 0xa303d
movq 0x10(%rax), %rcx
addq %rax, %rcx
cmpq %rsi, %rcx
ja 0xa3060
movq (%rax), %rax
jmp 0xa3027
movq (%rdi), %rax
testq %rax, %rax
je 0xa3064
cmpq %rsi, %rax
ja 0xa305b
movq 0x10(%rax), %rcx
addq %rax, %rcx
cmpq %rsi, %rcx
ja 0xa3060
movq (%rax), %rax
jmp 0xa3045
movq %rax, 0x10(%rdi)
popq %rbp
retq
| set_prealloc_root:
push rbp
mov rbp, rsp
mov rax, [rdi+8]
loc_A3027:
test rax, rax
jz short loc_A3042
cmp rax, rsi
ja short loc_A303D
mov rcx, [rax+10h]
add rcx, rax
cmp rcx, rsi
ja short loc_A3060
loc_A303D:
mov rax, [rax]
jmp short loc_A3027
loc_A3042:
mov rax, [rdi]
loc_A3045:
test rax, rax
jz short loc_A3064
cmp rax, rsi
ja short loc_A305B
mov rcx, [rax+10h]
add rcx, rax
cmp rcx, rsi
ja short loc_A3060
loc_A305B:
mov rax, [rax]
jmp short loc_A3045
loc_A3060:
mov [rdi+10h], rax
loc_A3064:
pop rbp
retn
| _QWORD * set_prealloc_root(_QWORD *a1, unsigned long long a2)
{
_QWORD *result; // rax
for ( result = (_QWORD *)a1[1]; result; result = (_QWORD *)*result )
{
if ( (unsigned long long)result <= a2 && (unsigned long long)result + result[2] > a2 )
{
LABEL_11:
a1[2] = result;
return result;
}
}
for ( result = (_QWORD *)*a1; result; result = (_QWORD *)*result )
{
if ( (unsigned long long)result <= a2 && (unsigned long long)result + result[2] > a2 )
goto LABEL_11;
}
return result;
}
| set_prealloc_root:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI + 0x8]
LAB_001a3027:
TEST RAX,RAX
JZ 0x001a3042
CMP RAX,RSI
JA 0x001a303d
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,RAX
CMP RCX,RSI
JA 0x001a3060
LAB_001a303d:
MOV RAX,qword ptr [RAX]
JMP 0x001a3027
LAB_001a3042:
MOV RAX,qword ptr [RDI]
LAB_001a3045:
TEST RAX,RAX
JZ 0x001a3064
CMP RAX,RSI
JA 0x001a305b
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,RAX
CMP RCX,RSI
JA 0x001a3060
LAB_001a305b:
MOV RAX,qword ptr [RAX]
JMP 0x001a3045
LAB_001a3060:
MOV qword ptr [RDI + 0x10],RAX
LAB_001a3064:
POP RBP
RET
|
void set_prealloc_root(int8 *param_1,int8 *param_2)
{
int8 *puVar1;
for (puVar1 = (int8 *)param_1[1]; puVar1 != (int8 *)0x0;
puVar1 = (int8 *)*puVar1) {
if ((puVar1 <= param_2) && (param_2 < (int8 *)(puVar1[2] + (long)puVar1)))
goto LAB_001a3060;
}
puVar1 = (int8 *)*param_1;
while( true ) {
if (puVar1 == (int8 *)0x0) {
return;
}
if ((puVar1 <= param_2) && (param_2 < (int8 *)(puVar1[2] + (long)puVar1))) break;
puVar1 = (int8 *)*puVar1;
}
LAB_001a3060:
param_1[2] = puVar1;
return;
}
| |
50,628 | ma_check_status | eloqsql/storage/maria/ma_state.c | my_bool _ma_check_status(void *param)
{
MARIA_HA *info=(MARIA_HA*) param;
/*
The test for w_locks == 1 is here because this thread has already done an
external lock (in other words: w_locks == 1 means no other threads has
a write lock)
*/
DBUG_PRINT("info",("dellink: %ld r_locks: %u w_locks: %u",
(long) info->s->state.dellink, (uint) info->s->r_locks,
(uint) info->s->w_locks));
return (my_bool) !(info->s->state.dellink == HA_OFFSET_ERROR ||
(maria_concurrent_insert == 2 && info->s->r_locks &&
info->s->w_locks == 1));
} | O0 | c | ma_check_status:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x47fb2
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpq $-0x1, 0xc8(%rcx)
movb %al, -0x11(%rbp)
je 0x48009
xorl %eax, %eax
leaq 0x27c56f(%rip), %rcx # 0x2c4540
cmpq $0x2, (%rcx)
movb %al, -0x12(%rbp)
jne 0x48003
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpl $0x0, 0x7b4(%rcx)
movb %al, -0x12(%rbp)
je 0x48003
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x7b0(%rax)
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_check_status:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
jmp short $+2
loc_47FB2:
mov rax, [rbp+var_10]
mov rcx, [rax]
mov al, 1
cmp qword ptr [rcx+0C8h], 0FFFFFFFFFFFFFFFFh
mov [rbp+var_11], al
jz short loc_48009
xor eax, eax
lea rcx, maria_concurrent_insert
cmp qword ptr [rcx], 2
mov [rbp+var_12], al
jnz short loc_48003
mov rax, [rbp+var_10]
mov rcx, [rax]
xor eax, eax
cmp dword ptr [rcx+7B4h], 0
mov [rbp+var_12], al
jz short loc_48003
mov rax, [rbp+var_10]
mov rax, [rax]
cmp dword ptr [rax+7B0h], 1
setz al
mov [rbp+var_12], al
loc_48003:
mov al, [rbp+var_12]
mov [rbp+var_11], al
loc_48009:
mov al, [rbp+var_11]
xor al, 0FFh
and al, 1
movzx eax, al
pop rbp
retn
| _BOOL8 ma_check_status(long long a1)
{
bool v2; // [rsp+0h] [rbp-12h]
char v3; // [rsp+1h] [rbp-11h]
v3 = 1;
if ( *(_QWORD *)(*(_QWORD *)a1 + 200LL) != -1LL )
{
v2 = 0;
if ( maria_concurrent_insert == 2LL )
{
v2 = 0;
if ( *(_DWORD *)(*(_QWORD *)a1 + 1972LL) )
v2 = *(_DWORD *)(*(_QWORD *)a1 + 1968LL) == 1;
}
v3 = v2;
}
return (v3 & 1) == 0;
}
| _ma_check_status:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00147fb2
LAB_00147fb2:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
MOV AL,0x1
CMP qword ptr [RCX + 0xc8],-0x1
MOV byte ptr [RBP + -0x11],AL
JZ 0x00148009
XOR EAX,EAX
LEA RCX,[0x3c4540]
CMP qword ptr [RCX],0x2
MOV byte ptr [RBP + -0x12],AL
JNZ 0x00148003
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
XOR EAX,EAX
CMP dword ptr [RCX + 0x7b4],0x0
MOV byte ptr [RBP + -0x12],AL
JZ 0x00148003
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x7b0],0x1
SETZ AL
MOV byte ptr [RBP + -0x12],AL
LAB_00148003:
MOV AL,byte ptr [RBP + -0x12]
MOV byte ptr [RBP + -0x11],AL
LAB_00148009:
MOV AL,byte ptr [RBP + -0x11]
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
POP RBP
RET
|
byte _ma_check_status(long *param_1)
{
int1 local_1a;
int1 local_19;
local_19 = true;
if (*(long *)(*param_1 + 200) != -1) {
local_1a = false;
if ((maria_concurrent_insert == 2) && (local_1a = false, *(int *)(*param_1 + 0x7b4) != 0)) {
local_1a = *(int *)(*param_1 + 0x7b0) == 1;
}
local_19 = local_1a;
}
return (local_19 ^ 0xffU) & 1;
}
| |
50,629 | my_8bit_collation_flags_from_data | eloqsql/strings/ctype-simple.c | uint my_8bit_collation_flags_from_data(CHARSET_INFO *cs)
{
uint flags= 0;
if (cs->sort_order && cs->sort_order['A'] < cs->sort_order['a'] &&
cs->sort_order['a'] < cs->sort_order['B'])
flags|= MY_CS_CSSORT;
return flags;
} | O0 | c | my_8bit_collation_flags_from_data:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x3a79d
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movzbl 0x41(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
movzbl 0x61(%rcx), %ecx
cmpl %ecx, %eax
jge 0x3a79d
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movzbl 0x61(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
movzbl 0x42(%rcx), %ecx
cmpl %ecx, %eax
jge 0x3a79d
movl -0xc(%rbp), %eax
orl $0x400, %eax # imm = 0x400
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_8bit_collation_flags_from_data:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], 0
mov rax, [rbp+var_8]
cmp qword ptr [rax+58h], 0
jz short loc_3A79D
mov rax, [rbp+var_8]
mov rax, [rax+58h]
movzx eax, byte ptr [rax+41h]
mov rcx, [rbp+var_8]
mov rcx, [rcx+58h]
movzx ecx, byte ptr [rcx+61h]
cmp eax, ecx
jge short loc_3A79D
mov rax, [rbp+var_8]
mov rax, [rax+58h]
movzx eax, byte ptr [rax+61h]
mov rcx, [rbp+var_8]
mov rcx, [rcx+58h]
movzx ecx, byte ptr [rcx+42h]
cmp eax, ecx
jge short loc_3A79D
mov eax, [rbp+var_C]
or eax, 400h
mov [rbp+var_C], eax
loc_3A79D:
mov eax, [rbp+var_C]
pop rbp
retn
| long long my_8bit_collation_flags_from_data(long long a1)
{
unsigned int v2; // [rsp+0h] [rbp-Ch]
v2 = 0;
if ( *(_QWORD *)(a1 + 88)
&& *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + 65LL) < (int)*(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + 97LL)
&& *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + 97LL) < (int)*(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + 66LL) )
{
return 1024;
}
return v2;
}
| my_8bit_collation_flags_from_data:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x58],0x0
JZ 0x0013a79d
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
MOVZX EAX,byte ptr [RAX + 0x41]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x58]
MOVZX ECX,byte ptr [RCX + 0x61]
CMP EAX,ECX
JGE 0x0013a79d
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
MOVZX EAX,byte ptr [RAX + 0x61]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x58]
MOVZX ECX,byte ptr [RCX + 0x42]
CMP EAX,ECX
JGE 0x0013a79d
MOV EAX,dword ptr [RBP + -0xc]
OR EAX,0x400
MOV dword ptr [RBP + -0xc],EAX
LAB_0013a79d:
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET
|
int4 my_8bit_collation_flags_from_data(long param_1)
{
int4 local_14;
local_14 = 0;
if (((*(long *)(param_1 + 0x58) != 0) &&
(*(byte *)(*(long *)(param_1 + 0x58) + 0x41) < *(byte *)(*(long *)(param_1 + 0x58) + 0x61)))
&& (*(byte *)(*(long *)(param_1 + 0x58) + 0x61) < *(byte *)(*(long *)(param_1 + 0x58) + 0x42)))
{
local_14 = 0x400;
}
return local_14;
}
| |
50,630 | ggml_backend_sched_new | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | ggml_backend_sched_t ggml_backend_sched_new(
ggml_backend_t * backends,
ggml_backend_buffer_type_t * bufts,
int n_backends,
size_t graph_size,
bool parallel) {
GGML_ASSERT(n_backends > 0);
GGML_ASSERT(n_backends <= GGML_SCHED_MAX_BACKENDS);
GGML_ASSERT(ggml_backend_dev_type(ggml_backend_get_device(backends[n_backends - 1])) == GGML_BACKEND_DEVICE_TYPE_CPU);
struct ggml_backend_sched * sched = (ggml_backend_sched *) calloc(1, sizeof(struct ggml_backend_sched));
const char * GGML_SCHED_DEBUG = getenv("GGML_SCHED_DEBUG");
sched->debug = GGML_SCHED_DEBUG ? atoi(GGML_SCHED_DEBUG) : 0;
sched->n_backends = n_backends;
sched->n_copies = parallel ? GGML_SCHED_MAX_COPIES : 1;
// initialize hash table
// FIXME: needs to be size*2 to account for leafs (do it in graph_split instead)
sched->hash_set = ggml_hash_set_new(graph_size);
sched->hv_tensor_backend_ids = (int *) malloc(sched->hash_set.size * sizeof(sched->hv_tensor_backend_ids[0]));
sched->hv_tensor_copies = (ggml_tensor **) malloc(sched->hash_set.size * sched->n_backends * sched->n_copies * sizeof(struct ggml_tensor *));
const size_t ggml_sched_max_splits = graph_size; // at most there is one split for each node in the graph
const size_t nodes_size = graph_size + ggml_sched_max_splits*GGML_SCHED_MAX_SPLIT_INPUTS*2;
sched->node_backend_ids = (int *) calloc(nodes_size, sizeof(sched->node_backend_ids[0]));
sched->leaf_backend_ids = (int *) calloc(nodes_size, sizeof(sched->leaf_backend_ids[0]));
sched->prev_node_backend_ids = (int *) calloc(nodes_size, sizeof(sched->prev_node_backend_ids[0]));
sched->prev_leaf_backend_ids = (int *) calloc(nodes_size, sizeof(sched->prev_leaf_backend_ids[0]));
sched->context_buffer_size = ggml_sched_max_splits*GGML_SCHED_MAX_SPLIT_INPUTS*2*sizeof(struct ggml_tensor) + ggml_graph_overhead_custom(graph_size, false);
sched->context_buffer = (char *) malloc(sched->context_buffer_size);
const int initial_splits_capacity = 16;
sched->splits = (ggml_backend_sched_split *) calloc(initial_splits_capacity, sizeof(sched->splits[0]));
sched->splits_capacity = initial_splits_capacity;
for (int b = 0; b < n_backends; b++) {
sched->backends[b] = backends[b];
sched->bufts[b] = bufts ? bufts[b] : ggml_backend_get_default_buffer_type(backends[b]);
GGML_ASSERT(ggml_backend_supports_buft(backends[b], sched->bufts[b]));
if (sched->n_copies > 1) {
for (int c = 0; c < sched->n_copies; c++) {
sched->events[b][c] = ggml_backend_event_new(backends[b]->device);
}
}
}
sched->galloc = ggml_gallocr_new_n(sched->bufts, n_backends);
ggml_backend_sched_reset(sched);
return sched;
} | O0 | cpp | ggml_backend_sched_new:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x5f249
leaq 0x559e8(%rip), %rdi # 0xb4c17
movl $0x5ae, %esi # imm = 0x5AE
leaq 0x523ce(%rip), %rdx # 0xb1609
leaq 0x55da4(%rip), %rcx # 0xb4fe6
movb $0x0, %al
callq 0x48a00
cmpl $0x10, -0x14(%rbp)
jle 0x5f270
leaq 0x559c1(%rip), %rdi # 0xb4c17
movl $0x5af, %esi # imm = 0x5AF
leaq 0x523a7(%rip), %rdx # 0xb1609
leaq 0x55d8c(%rip), %rcx # 0xb4ff5
movb $0x0, %al
callq 0x48a00
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x42160
movq %rax, %rdi
callq 0x429f0
cmpl $0x0, %eax
je 0x5f2b4
leaq 0x5597d(%rip), %rdi # 0xb4c17
movl $0x5b0, %esi # imm = 0x5B0
leaq 0x52363(%rip), %rdx # 0xb1609
leaq 0x55d6e(%rip), %rcx # 0xb501b
movb $0x0, %al
callq 0x48a00
movl $0x1, %edi
movl $0x448, %esi # imm = 0x448
callq 0x44900
movq %rax, -0x30(%rbp)
leaq 0x55db6(%rip), %rdi # 0xb5084
callq 0x46c40
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x5f2ec
movq -0x38(%rbp), %rdi
callq 0x481d0
movl %eax, -0x70(%rbp)
jmp 0x5f2f3
xorl %eax, %eax
movl %eax, -0x70(%rbp)
jmp 0x5f2f3
movl -0x70(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x440(%rax)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movb -0x21(%rbp), %dl
movl $0x1, %ecx
movl $0x4, %eax
testb $0x1, %dl
cmovnel %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x1b8(%rax)
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x42570
movq -0x30(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x110(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x118(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x120(%rax)
movq -0x30(%rbp), %rax
movq 0x110(%rax), %rdi
shlq $0x2, %rdi
callq 0x47270
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x128(%rax)
movq -0x30(%rbp), %rax
movq 0x110(%rax), %rdi
movq -0x30(%rbp), %rax
movslq 0x4(%rax), %rax
imulq %rax, %rdi
movq -0x30(%rbp), %rax
movslq 0x1b8(%rax), %rax
imulq %rax, %rdi
shlq $0x3, %rdi
callq 0x47270
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x130(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
imulq $0xa, -0x58(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movl $0x4, %esi
callq 0x44900
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x138(%rax)
movq -0x60(%rbp), %rdi
movl $0x4, %esi
callq 0x44900
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x140(%rax)
movq -0x60(%rbp), %rdi
movl $0x4, %esi
callq 0x44900
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x60(%rbp), %rdi
movl $0x4, %esi
callq 0x44900
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x150(%rax)
imulq $0xa, -0x58(%rbp), %rax
shlq %rax
imulq $0x150, %rax, %rax # imm = 0x150
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x47610
movq -0x78(%rbp), %rcx
addq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x438(%rax)
movq -0x30(%rbp), %rax
movq 0x438(%rax), %rdi
callq 0x47270
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x430(%rax)
movl $0x10, -0x64(%rbp)
movl $0x10, %edi
movl $0xb8, %esi
callq 0x44900
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x1a8(%rax)
movq -0x30(%rbp), %rax
movl $0x10, 0x1b4(%rax)
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5f5ec
movq -0x8(%rbp), %rax
movslq -0x68(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x30(%rbp), %rax
movslq -0x68(%rbp), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
cmpq $0x0, -0x10(%rbp)
je 0x5f508
movq -0x10(%rbp), %rax
movslq -0x68(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x80(%rbp)
jmp 0x5f51d
movq -0x8(%rbp), %rax
movslq -0x68(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x49280
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdx
movq -0x30(%rbp), %rax
movslq -0x68(%rbp), %rcx
movq %rdx, 0x88(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x68(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x30(%rbp), %rax
movslq -0x68(%rbp), %rcx
movq 0x88(%rax,%rcx,8), %rsi
callq 0x47fe0
testb $0x1, %al
jne 0x5f577
leaq 0x556ba(%rip), %rdi # 0xb4c17
movl $0x5d0, %esi # imm = 0x5D0
leaq 0x520a0(%rip), %rdx # 0xb1609
leaq 0x55b25(%rip), %rcx # 0xb5095
movb $0x0, %al
callq 0x48a00
movq -0x30(%rbp), %rax
cmpl $0x1, 0x1b8(%rax)
jle 0x5f5dc
movl $0x0, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x1b8(%rcx), %eax
jge 0x5f5da
movq -0x8(%rbp), %rax
movslq -0x68(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x70(%rax), %rdi
callq 0x43310
movq %rax, %rdx
movq -0x30(%rbp), %rax
addq $0x1c0, %rax # imm = 0x1C0
movslq -0x68(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x6c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x5f58b
jmp 0x5f5dc
jmp 0x5f5de
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x5f4ca
movq -0x30(%rbp), %rdi
addq $0x88, %rdi
movl -0x14(%rbp), %esi
callq 0x49ba0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x108(%rax)
movq -0x30(%rbp), %rdi
callq 0x447e0
movq -0x30(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ggml_backend_sched_new:
push rbp
mov rbp, rsp
sub rsp, 80h
mov al, r8b
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
and al, 1
mov [rbp+var_21], al
cmp [rbp+var_14], 0
jg short loc_5F249
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov esi, 5AEh
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNBackends0; "n_backends > 0"
mov al, 0
call _ggml_abort
loc_5F249:
cmp [rbp+var_14], 10h
jle short loc_5F270
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov esi, 5AFh
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNBackendsGgmlS; "n_backends <= GGML_SCHED_MAX_BACKENDS"
mov al, 0
call _ggml_abort
loc_5F270:
mov rax, [rbp+var_8]
mov ecx, [rbp+var_14]
sub ecx, 1
movsxd rcx, ecx
mov rdi, [rax+rcx*8]
call _ggml_backend_get_device
mov rdi, rax
call _ggml_backend_dev_type
cmp eax, 0
jz short loc_5F2B4
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov esi, 5B0h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlBackendDev_12; "ggml_backend_dev_type(ggml_backend_get_"...
mov al, 0
call _ggml_abort
loc_5F2B4:
mov edi, 1
mov esi, 448h
call _calloc
mov [rbp+var_30], rax
lea rdi, aGgmlSchedDebug; "GGML_SCHED_DEBUG"
call _getenv
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jz short loc_5F2EC
mov rdi, [rbp+var_38]
call _atoi
mov [rbp+var_70], eax
jmp short loc_5F2F3
loc_5F2EC:
xor eax, eax
mov [rbp+var_70], eax
jmp short $+2
loc_5F2F3:
mov ecx, [rbp+var_70]
mov rax, [rbp+var_30]
mov [rax+440h], ecx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_30]
mov [rax+4], ecx
mov dl, [rbp+var_21]
mov ecx, 1
mov eax, 4
test dl, 1
cmovnz ecx, eax
mov rax, [rbp+var_30]
mov [rax+1B8h], ecx
mov rsi, [rbp+var_20]
lea rdi, [rbp+var_50]
call _ggml_hash_set_new
mov rax, [rbp+var_30]
mov rcx, [rbp+var_50]
mov [rax+110h], rcx
mov rcx, [rbp+var_48]
mov [rax+118h], rcx
mov rcx, [rbp+var_40]
mov [rax+120h], rcx
mov rax, [rbp+var_30]
mov rdi, [rax+110h]
shl rdi, 2
call _malloc
mov rcx, rax
mov rax, [rbp+var_30]
mov [rax+128h], rcx
mov rax, [rbp+var_30]
mov rdi, [rax+110h]
mov rax, [rbp+var_30]
movsxd rax, dword ptr [rax+4]
imul rdi, rax
mov rax, [rbp+var_30]
movsxd rax, dword ptr [rax+1B8h]
imul rdi, rax
shl rdi, 3
call _malloc
mov rcx, rax
mov rax, [rbp+var_30]
mov [rax+130h], rcx
mov rax, [rbp+var_20]
mov [rbp+var_58], rax
mov rax, [rbp+var_20]
imul rcx, [rbp+var_58], 0Ah
shl rcx, 1
add rax, rcx
mov [rbp+var_60], rax
mov rdi, [rbp+var_60]
mov esi, 4
call _calloc
mov rcx, rax
mov rax, [rbp+var_30]
mov [rax+138h], rcx
mov rdi, [rbp+var_60]
mov esi, 4
call _calloc
mov rcx, rax
mov rax, [rbp+var_30]
mov [rax+140h], rcx
mov rdi, [rbp+var_60]
mov esi, 4
call _calloc
mov rcx, rax
mov rax, [rbp+var_30]
mov [rax+148h], rcx
mov rdi, [rbp+var_60]
mov esi, 4
call _calloc
mov rcx, rax
mov rax, [rbp+var_30]
mov [rax+150h], rcx
imul rax, [rbp+var_58], 0Ah
shl rax, 1
imul rax, 150h
mov [rbp+var_78], rax
mov rdi, [rbp+var_20]
xor esi, esi
call _ggml_graph_overhead_custom
mov rcx, [rbp+var_78]
add rcx, rax
mov rax, [rbp+var_30]
mov [rax+438h], rcx
mov rax, [rbp+var_30]
mov rdi, [rax+438h]
call _malloc
mov rcx, rax
mov rax, [rbp+var_30]
mov [rax+430h], rcx
mov [rbp+var_64], 10h
mov edi, 10h
mov esi, 0B8h
call _calloc
mov rcx, rax
mov rax, [rbp+var_30]
mov [rax+1A8h], rcx
mov rax, [rbp+var_30]
mov dword ptr [rax+1B4h], 10h
mov [rbp+var_68], 0
loc_5F4CA:
mov eax, [rbp+var_68]
cmp eax, [rbp+var_14]
jge loc_5F5EC
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_68]
mov rdx, [rax+rcx*8]
mov rax, [rbp+var_30]
movsxd rcx, [rbp+var_68]
mov [rax+rcx*8+8], rdx
cmp [rbp+var_10], 0
jz short loc_5F508
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_68]
mov rax, [rax+rcx*8]
mov [rbp+var_80], rax
jmp short loc_5F51D
loc_5F508:
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_68]
mov rdi, [rax+rcx*8]
call _ggml_backend_get_default_buffer_type
mov [rbp+var_80], rax
loc_5F51D:
mov rdx, [rbp+var_80]
mov rax, [rbp+var_30]
movsxd rcx, [rbp+var_68]
mov [rax+rcx*8+88h], rdx
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_68]
mov rdi, [rax+rcx*8]
mov rax, [rbp+var_30]
movsxd rcx, [rbp+var_68]
mov rsi, [rax+rcx*8+88h]
call _ggml_backend_supports_buft
test al, 1
jnz short loc_5F577
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov esi, 5D0h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlBackendSup_1; "ggml_backend_supports_buft(backends[b],"...
mov al, 0
call _ggml_abort
loc_5F577:
mov rax, [rbp+var_30]
cmp dword ptr [rax+1B8h], 1
jle short loc_5F5DC
mov [rbp+var_6C], 0
loc_5F58B:
mov eax, [rbp+var_6C]
mov rcx, [rbp+var_30]
cmp eax, [rcx+1B8h]
jge short loc_5F5DA
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_68]
mov rax, [rax+rcx*8]
mov rdi, [rax+70h]
call _ggml_backend_event_new
mov rdx, rax
mov rax, [rbp+var_30]
add rax, 1C0h
movsxd rcx, [rbp+var_68]
shl rcx, 5
add rax, rcx
movsxd rcx, [rbp+var_6C]
mov [rax+rcx*8], rdx
mov eax, [rbp+var_6C]
add eax, 1
mov [rbp+var_6C], eax
jmp short loc_5F58B
loc_5F5DA:
jmp short $+2
loc_5F5DC:
jmp short $+2
loc_5F5DE:
mov eax, [rbp+var_68]
add eax, 1
mov [rbp+var_68], eax
jmp loc_5F4CA
loc_5F5EC:
mov rdi, [rbp+var_30]
add rdi, 88h
mov esi, [rbp+var_14]
call _ggml_gallocr_new_n
mov rcx, rax
mov rax, [rbp+var_30]
mov [rax+108h], rcx
mov rdi, [rbp+var_30]
call _ggml_backend_sched_reset
mov rax, [rbp+var_30]
add rsp, 80h
pop rbp
retn
| long long ggml_backend_sched_new(long long a1, long long a2, int a3, long long a4, char a5)
{
long long device; // rax
int v6; // ecx
long long v7; // rax
long long v8; // rax
long long v9; // rax
long long v10; // rax
unsigned long long v11; // rax
long long v12; // rax
long long v13; // rax
long long v14; // rax
long long default_buffer_type; // [rsp+0h] [rbp-80h]
int v17; // [rsp+10h] [rbp-70h]
int j; // [rsp+14h] [rbp-6Ch]
int i; // [rsp+18h] [rbp-68h]
long long v20; // [rsp+20h] [rbp-60h]
long long v21; // [rsp+28h] [rbp-58h]
long long v22[3]; // [rsp+30h] [rbp-50h] BYREF
long long v23; // [rsp+48h] [rbp-38h]
long long v24; // [rsp+50h] [rbp-30h]
char v25; // [rsp+5Fh] [rbp-21h]
long long v26; // [rsp+60h] [rbp-20h]
int v27; // [rsp+6Ch] [rbp-14h]
long long v28; // [rsp+70h] [rbp-10h]
long long v29; // [rsp+78h] [rbp-8h]
v29 = a1;
v28 = a2;
v27 = a3;
v26 = a4;
v25 = a5 & 1;
if ( a3 <= 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
1454,
(long long)"GGML_ASSERT(%s) failed",
"n_backends > 0");
if ( v27 > 16 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
1455,
(long long)"GGML_ASSERT(%s) failed",
"n_backends <= GGML_SCHED_MAX_BACKENDS");
device = ggml_backend_get_device(*(_QWORD *)(v29 + 8LL * (v27 - 1)));
if ( (unsigned int)ggml_backend_dev_type(device) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
1456,
(long long)"GGML_ASSERT(%s) failed",
"ggml_backend_dev_type(ggml_backend_get_device(backends[n_backends - 1])) == GGML_BACKEND_DEVICE_TYPE_CPU");
v24 = calloc(1LL, 1096LL);
v23 = getenv("GGML_SCHED_DEBUG");
if ( v23 )
v17 = atoi(v23);
else
v17 = 0;
*(_DWORD *)(v24 + 1088) = v17;
*(_DWORD *)(v24 + 4) = v27;
v6 = 1;
if ( (v25 & 1) != 0 )
v6 = 4;
*(_DWORD *)(v24 + 440) = v6;
ggml_hash_set_new(v22, v26);
v7 = v24;
*(_QWORD *)(v24 + 272) = v22[0];
*(_QWORD *)(v7 + 280) = v22[1];
*(_QWORD *)(v7 + 288) = v22[2];
*(_QWORD *)(v24 + 296) = malloc(4LL * *(_QWORD *)(v24 + 272));
*(_QWORD *)(v24 + 304) = malloc(8 * *(int *)(v24 + 440) * *(int *)(v24 + 4) * *(_QWORD *)(v24 + 272));
v21 = v26;
v20 = 21 * v26;
*(_QWORD *)(v24 + 312) = calloc(21 * v26, 4LL);
v8 = calloc(v20, 4LL);
*(_QWORD *)(v24 + 320) = v8;
v9 = calloc(v20, 4LL);
*(_QWORD *)(v24 + 328) = v9;
v10 = calloc(v20, 4LL);
*(_QWORD *)(v24 + 336) = v10;
v11 = ggml_graph_overhead_custom(v26, 0);
*(_QWORD *)(v24 + 1080) = v11 + 6720 * v21;
v12 = malloc(*(_QWORD *)(v24 + 1080));
*(_QWORD *)(v24 + 1072) = v12;
*(_QWORD *)(v24 + 424) = calloc(16LL, 184LL);
*(_DWORD *)(v24 + 436) = 16;
for ( i = 0; i < v27; ++i )
{
*(_QWORD *)(v24 + 8LL * i + 8) = *(_QWORD *)(v29 + 8LL * i);
if ( v28 )
default_buffer_type = *(_QWORD *)(v28 + 8LL * i);
else
default_buffer_type = ggml_backend_get_default_buffer_type(*(_QWORD *)(v29 + 8LL * i));
*(_QWORD *)(v24 + 8LL * i + 136) = default_buffer_type;
if ( (ggml_backend_supports_buft(*(_QWORD *)(v29 + 8LL * i), *(_QWORD *)(v24 + 8LL * i + 136)) & 1) == 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
1488,
(long long)"GGML_ASSERT(%s) failed",
"ggml_backend_supports_buft(backends[b], sched->bufts[b])");
if ( *(int *)(v24 + 440) > 1 )
{
for ( j = 0; j < *(_DWORD *)(v24 + 440); ++j )
{
v13 = ggml_backend_event_new(*(_QWORD *)(*(_QWORD *)(v29 + 8LL * i) + 112LL));
*(_QWORD *)(32LL * i + v24 + 448 + 8LL * j) = v13;
}
}
}
v14 = ggml_gallocr_new_n(v24 + 136, v27);
*(_QWORD *)(v24 + 264) = v14;
ggml_backend_sched_reset(v24);
return v24;
}
| ggml_backend_sched_new:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV AL,R8B
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
AND AL,0x1
MOV byte ptr [RBP + -0x21],AL
CMP dword ptr [RBP + -0x14],0x0
JG 0x0015f249
LEA RDI,[0x1b4c17]
MOV ESI,0x5ae
LEA RDX,[0x1b1609]
LEA RCX,[0x1b4fe6]
MOV AL,0x0
CALL 0x00148a00
LAB_0015f249:
CMP dword ptr [RBP + -0x14],0x10
JLE 0x0015f270
LEA RDI,[0x1b4c17]
MOV ESI,0x5af
LEA RDX,[0x1b1609]
LEA RCX,[0x1b4ff5]
MOV AL,0x0
CALL 0x00148a00
LAB_0015f270:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x14]
SUB ECX,0x1
MOVSXD RCX,ECX
MOV RDI,qword ptr [RAX + RCX*0x8]
CALL 0x00142160
MOV RDI,RAX
CALL 0x001429f0
CMP EAX,0x0
JZ 0x0015f2b4
LEA RDI,[0x1b4c17]
MOV ESI,0x5b0
LEA RDX,[0x1b1609]
LEA RCX,[0x1b501b]
MOV AL,0x0
CALL 0x00148a00
LAB_0015f2b4:
MOV EDI,0x1
MOV ESI,0x448
CALL 0x00144900
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[0x1b5084]
CALL 0x00146c40
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JZ 0x0015f2ec
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001481d0
MOV dword ptr [RBP + -0x70],EAX
JMP 0x0015f2f3
LAB_0015f2ec:
XOR EAX,EAX
MOV dword ptr [RBP + -0x70],EAX
JMP 0x0015f2f3
LAB_0015f2f3:
MOV ECX,dword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x440],ECX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x4],ECX
MOV DL,byte ptr [RBP + -0x21]
MOV ECX,0x1
MOV EAX,0x4
TEST DL,0x1
CMOVNZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x1b8],ECX
MOV RSI,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x50]
CALL 0x00142570
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX + 0x110],RCX
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x118],RCX
MOV RCX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x120],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x110]
SHL RDI,0x2
CALL 0x00147270
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x128],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x110]
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RAX,dword ptr [RAX + 0x4]
IMUL RDI,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RAX,dword ptr [RAX + 0x1b8]
IMUL RDI,RAX
SHL RDI,0x3
CALL 0x00147270
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x130],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x20]
IMUL RCX,qword ptr [RBP + -0x58],0xa
SHL RCX,0x1
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x60]
MOV ESI,0x4
CALL 0x00144900
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x138],RCX
MOV RDI,qword ptr [RBP + -0x60]
MOV ESI,0x4
CALL 0x00144900
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x140],RCX
MOV RDI,qword ptr [RBP + -0x60]
MOV ESI,0x4
CALL 0x00144900
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x148],RCX
MOV RDI,qword ptr [RBP + -0x60]
MOV ESI,0x4
CALL 0x00144900
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x150],RCX
IMUL RAX,qword ptr [RBP + -0x58],0xa
SHL RAX,0x1
IMUL RAX,RAX,0x150
MOV qword ptr [RBP + -0x78],RAX
MOV RDI,qword ptr [RBP + -0x20]
XOR ESI,ESI
CALL 0x00147610
MOV RCX,qword ptr [RBP + -0x78]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x438],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x438]
CALL 0x00147270
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x430],RCX
MOV dword ptr [RBP + -0x64],0x10
MOV EDI,0x10
MOV ESI,0xb8
CALL 0x00144900
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x1a8],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x1b4],0x10
MOV dword ptr [RBP + -0x68],0x0
LAB_0015f4ca:
MOV EAX,dword ptr [RBP + -0x68]
CMP EAX,dword ptr [RBP + -0x14]
JGE 0x0015f5ec
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x68]
MOV RDX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RCX,dword ptr [RBP + -0x68]
MOV qword ptr [RAX + RCX*0x8 + 0x8],RDX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0015f508
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x80],RAX
JMP 0x0015f51d
LAB_0015f508:
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x68]
MOV RDI,qword ptr [RAX + RCX*0x8]
CALL 0x00149280
MOV qword ptr [RBP + -0x80],RAX
LAB_0015f51d:
MOV RDX,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RCX,dword ptr [RBP + -0x68]
MOV qword ptr [RAX + RCX*0x8 + 0x88],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x68]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RCX,dword ptr [RBP + -0x68]
MOV RSI,qword ptr [RAX + RCX*0x8 + 0x88]
CALL 0x00147fe0
TEST AL,0x1
JNZ 0x0015f577
LEA RDI,[0x1b4c17]
MOV ESI,0x5d0
LEA RDX,[0x1b1609]
LEA RCX,[0x1b5095]
MOV AL,0x0
CALL 0x00148a00
LAB_0015f577:
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX + 0x1b8],0x1
JLE 0x0015f5dc
MOV dword ptr [RBP + -0x6c],0x0
LAB_0015f58b:
MOV EAX,dword ptr [RBP + -0x6c]
MOV RCX,qword ptr [RBP + -0x30]
CMP EAX,dword ptr [RCX + 0x1b8]
JGE 0x0015f5da
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV RDI,qword ptr [RAX + 0x70]
CALL 0x00143310
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1c0
MOVSXD RCX,dword ptr [RBP + -0x68]
SHL RCX,0x5
ADD RAX,RCX
MOVSXD RCX,dword ptr [RBP + -0x6c]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV EAX,dword ptr [RBP + -0x6c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x0015f58b
LAB_0015f5da:
JMP 0x0015f5dc
LAB_0015f5dc:
JMP 0x0015f5de
LAB_0015f5de:
MOV EAX,dword ptr [RBP + -0x68]
ADD EAX,0x1
MOV dword ptr [RBP + -0x68],EAX
JMP 0x0015f4ca
LAB_0015f5ec:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x88
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x00149ba0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x108],RCX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001447e0
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x80
POP RBP
RET
|
void * ggml_backend_sched_new(long param_1,long param_2,int param_3,long param_4,byte param_5)
{
size_t __nmemb;
long lVar1;
int iVar2;
int8 uVar3;
void *pvVar4;
long lVar5;
ulong uVar6;
int4 uVar7;
int8 local_88;
int local_78;
int local_74;
int local_70;
int8 local_58;
int8 local_50;
int8 local_48;
char *local_40;
void *local_38;
byte local_29;
long local_28;
int local_1c;
long local_18;
long local_10;
local_29 = param_5 & 1;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
if (param_3 < 1) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,0x5ae,"GGML_ASSERT(%s) failed","n_backends > 0");
}
if (0x10 < local_1c) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,0x5af,"GGML_ASSERT(%s) failed","n_backends <= GGML_SCHED_MAX_BACKENDS");
}
uVar3 = ggml_backend_get_device(*(int8 *)(local_10 + (long)(local_1c + -1) * 8));
iVar2 = ggml_backend_dev_type(uVar3);
if (iVar2 != 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,0x5b0,"GGML_ASSERT(%s) failed",
"ggml_backend_dev_type(ggml_backend_get_device(backends[n_backends - 1])) == GGML_BACKEND_DEVICE_TYPE_CPU"
);
}
local_38 = calloc(1,0x448);
local_40 = getenv("GGML_SCHED_DEBUG");
if (local_40 == (char *)0x0) {
local_78 = 0;
}
else {
local_78 = atoi(local_40);
}
*(int *)((long)local_38 + 0x440) = local_78;
*(int *)((long)local_38 + 4) = local_1c;
uVar7 = 1;
if ((local_29 & 1) != 0) {
uVar7 = 4;
}
*(int4 *)((long)local_38 + 0x1b8) = uVar7;
ggml_hash_set_new(&local_58,local_28);
*(int8 *)((long)local_38 + 0x110) = local_58;
*(int8 *)((long)local_38 + 0x118) = local_50;
*(int8 *)((long)local_38 + 0x120) = local_48;
pvVar4 = malloc(*(long *)((long)local_38 + 0x110) << 2);
*(void **)((long)local_38 + 0x128) = pvVar4;
pvVar4 = malloc(*(long *)((long)local_38 + 0x110) * (long)*(int *)((long)local_38 + 4) *
(long)*(int *)((long)local_38 + 0x1b8) * 8);
lVar1 = local_28;
*(void **)((long)local_38 + 0x130) = pvVar4;
__nmemb = local_28 * 0x15;
pvVar4 = calloc(__nmemb,4);
*(void **)((long)local_38 + 0x138) = pvVar4;
pvVar4 = calloc(__nmemb,4);
*(void **)((long)local_38 + 0x140) = pvVar4;
pvVar4 = calloc(__nmemb,4);
*(void **)((long)local_38 + 0x148) = pvVar4;
pvVar4 = calloc(__nmemb,4);
*(void **)((long)local_38 + 0x150) = pvVar4;
lVar5 = ggml_graph_overhead_custom(local_28,0);
*(long *)((long)local_38 + 0x438) = lVar1 * 0x1a40 + lVar5;
pvVar4 = malloc(*(size_t *)((long)local_38 + 0x438));
*(void **)((long)local_38 + 0x430) = pvVar4;
pvVar4 = calloc(0x10,0xb8);
*(void **)((long)local_38 + 0x1a8) = pvVar4;
*(int4 *)((long)local_38 + 0x1b4) = 0x10;
for (local_70 = 0; local_70 < local_1c; local_70 = local_70 + 1) {
*(int8 *)((long)local_38 + (long)local_70 * 8 + 8) =
*(int8 *)(local_10 + (long)local_70 * 8);
if (local_18 == 0) {
local_88 = ggml_backend_get_default_buffer_type
(*(int8 *)(local_10 + (long)local_70 * 8));
}
else {
local_88 = *(int8 *)(local_18 + (long)local_70 * 8);
}
*(int8 *)((long)local_38 + (long)local_70 * 8 + 0x88) = local_88;
uVar6 = ggml_backend_supports_buft
(*(int8 *)(local_10 + (long)local_70 * 8),
*(int8 *)((long)local_38 + (long)local_70 * 8 + 0x88));
if ((uVar6 & 1) == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,0x5d0,"GGML_ASSERT(%s) failed",
"ggml_backend_supports_buft(backends[b], sched->bufts[b])");
}
if (1 < *(int *)((long)local_38 + 0x1b8)) {
for (local_74 = 0; local_74 < *(int *)((long)local_38 + 0x1b8); local_74 = local_74 + 1) {
uVar3 = ggml_backend_event_new
(*(int8 *)(*(long *)(local_10 + (long)local_70 * 8) + 0x70));
*(int8 *)((long)local_38 + (long)local_74 * 8 + (long)local_70 * 0x20 + 0x1c0) = uVar3
;
}
}
}
uVar3 = ggml_gallocr_new_n((long)local_38 + 0x88,local_1c);
*(int8 *)((long)local_38 + 0x108) = uVar3;
ggml_backend_sched_reset(local_38);
return local_38;
}
| |
50,631 | ggml_backend_sched_new | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | ggml_backend_sched_t ggml_backend_sched_new(
ggml_backend_t * backends,
ggml_backend_buffer_type_t * bufts,
int n_backends,
size_t graph_size,
bool parallel) {
GGML_ASSERT(n_backends > 0);
GGML_ASSERT(n_backends <= GGML_SCHED_MAX_BACKENDS);
GGML_ASSERT(ggml_backend_dev_type(ggml_backend_get_device(backends[n_backends - 1])) == GGML_BACKEND_DEVICE_TYPE_CPU);
struct ggml_backend_sched * sched = (ggml_backend_sched *) calloc(1, sizeof(struct ggml_backend_sched));
const char * GGML_SCHED_DEBUG = getenv("GGML_SCHED_DEBUG");
sched->debug = GGML_SCHED_DEBUG ? atoi(GGML_SCHED_DEBUG) : 0;
sched->n_backends = n_backends;
sched->n_copies = parallel ? GGML_SCHED_MAX_COPIES : 1;
// initialize hash table
// FIXME: needs to be size*2 to account for leafs (do it in graph_split instead)
sched->hash_set = ggml_hash_set_new(graph_size);
sched->hv_tensor_backend_ids = (int *) malloc(sched->hash_set.size * sizeof(sched->hv_tensor_backend_ids[0]));
sched->hv_tensor_copies = (ggml_tensor **) malloc(sched->hash_set.size * sched->n_backends * sched->n_copies * sizeof(struct ggml_tensor *));
const size_t ggml_sched_max_splits = graph_size; // at most there is one split for each node in the graph
const size_t nodes_size = graph_size + ggml_sched_max_splits*GGML_SCHED_MAX_SPLIT_INPUTS*2;
sched->node_backend_ids = (int *) calloc(nodes_size, sizeof(sched->node_backend_ids[0]));
sched->leaf_backend_ids = (int *) calloc(nodes_size, sizeof(sched->leaf_backend_ids[0]));
sched->prev_node_backend_ids = (int *) calloc(nodes_size, sizeof(sched->prev_node_backend_ids[0]));
sched->prev_leaf_backend_ids = (int *) calloc(nodes_size, sizeof(sched->prev_leaf_backend_ids[0]));
sched->context_buffer_size = ggml_sched_max_splits*GGML_SCHED_MAX_SPLIT_INPUTS*2*sizeof(struct ggml_tensor) + ggml_graph_overhead_custom(graph_size, false);
sched->context_buffer = (char *) malloc(sched->context_buffer_size);
const int initial_splits_capacity = 16;
sched->splits = (ggml_backend_sched_split *) calloc(initial_splits_capacity, sizeof(sched->splits[0]));
sched->splits_capacity = initial_splits_capacity;
for (int b = 0; b < n_backends; b++) {
sched->backends[b] = backends[b];
sched->bufts[b] = bufts ? bufts[b] : ggml_backend_get_default_buffer_type(backends[b]);
GGML_ASSERT(ggml_backend_supports_buft(backends[b], sched->bufts[b]));
if (sched->n_copies > 1) {
for (int c = 0; c < sched->n_copies; c++) {
sched->events[b][c] = ggml_backend_event_new(backends[b]->device);
}
}
}
sched->galloc = ggml_gallocr_new_n(sched->bufts, n_backends);
ggml_backend_sched_reset(sched);
return sched;
} | O1 | cpp | ggml_backend_sched_new:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testl %edx, %edx
jle 0x27ada
movl %edx, %ebx
cmpl $0x11, %edx
jge 0x27af6
movl %r8d, %ebp
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %r15
movl %ebx, %eax
movq -0x8(%rdi,%rax,8), %rax
movq 0x70(%rax), %rdi
callq *0x18(%rdi)
testl %eax, %eax
jne 0x27b12
movl $0x1, %edi
movl $0x448, %esi # imm = 0x448
callq 0x17b60
movq %rax, %r12
leaq 0x28372(%rip), %rdi # 0x4fbe1
callq 0x184b0
testq %rax, %rax
movq %r14, 0x8(%rsp)
je 0x27888
movq %rax, %rdi
callq 0x18a80
jmp 0x2788a
xorl %eax, %eax
movl %eax, 0x440(%r12)
movl %ebx, 0x4(%r12)
movzbl %bpl, %eax
leal (%rax,%rax,2), %eax
incl %eax
movl %eax, 0x1b8(%r12)
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x17180
movq 0x10(%rbp), %rax
movq %rax, 0x120(%r12)
movups (%rbp), %xmm0
movups %xmm0, 0x110(%r12)
movl %ebx, %r14d
movq 0x110(%r12), %rbx
leaq (,%rbx,4), %rdi
callq 0x18650
movq %rax, 0x128(%r12)
movslq 0x4(%r12), %rdi
movslq 0x1b8(%r12), %rax
imulq %rbx, %rdi
imulq %rax, %rdi
shlq $0x3, %rdi
callq 0x18650
movq %rax, 0x130(%r12)
leaq (,%r13,4), %rax
addq %r13, %rax
leaq (,%rax,4), %rbp
addq %r13, %rbp
movl $0x4, %esi
movq %rbp, %rdi
callq 0x17b60
movq %rax, 0x138(%r12)
movl $0x4, %esi
movq %rbp, %rdi
callq 0x17b60
movq %rax, 0x140(%r12)
movl $0x4, %esi
movq %rbp, %rdi
callq 0x17b60
movq %rax, 0x148(%r12)
movl $0x4, %esi
movq %rbp, %rdi
callq 0x17b60
movq %rax, 0x150(%r12)
imulq $0x1a40, %r13, %rbp # imm = 0x1A40
xorl %ebx, %ebx
movq %r13, %rdi
xorl %esi, %esi
callq 0x18790
addq %rax, %rbp
movq %rbp, 0x438(%r12)
movq %rbp, %rdi
callq 0x18650
movq %rax, 0x430(%r12)
movl $0x10, %edi
movl $0xb8, %esi
callq 0x17b60
movq %rax, 0x1a8(%r12)
movl $0x10, 0x1b4(%r12)
leaq 0x1c0(%r12), %r13
cmpl $0x2, %r14d
movl $0x1, %ebp
movl %r14d, 0x4(%rsp)
cmovgel %r14d, %ebp
movq (%r15,%rbx,8), %rax
movq %rax, 0x8(%r12,%rbx,8)
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x27a05
movq (%rcx,%rbx,8), %rsi
jmp 0x27a0f
movq 0x70(%rax), %rdi
callq *0x30(%rdi)
movq %rax, %rsi
movq %rsi, 0x88(%r12,%rbx,8)
movq (%r15,%rbx,8), %rax
movq 0x70(%rax), %rdi
callq *0x50(%rdi)
testb %al, %al
je 0x27ab9
cmpl $0x2, 0x1b8(%r12)
jl 0x27a74
cmpl $0x0, 0x1b8(%r12)
jle 0x27a74
xorl %r14d, %r14d
movq (%r15,%rbx,8), %rax
movq 0x70(%rax), %rdi
testq %rdi, %rdi
je 0x27a5d
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0x27a5d
callq *%rax
jmp 0x27a5f
xorl %eax, %eax
movq %rax, (%r13,%r14,8)
incq %r14
movslq 0x1b8(%r12), %rax
cmpq %rax, %r14
jl 0x27a43
incq %rbx
addq $0x20, %r13
cmpq %rbp, %rbx
jne 0x279ec
movq %r12, %rdi
addq $0x88, %rdi
movl 0x4(%rsp), %esi
callq 0x19160
movq %rax, 0x108(%r12)
movq %r12, %rdi
callq 0x17af0
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27cb4(%rip), %rdi # 0x4f774
leaq 0x24afa(%rip), %rdx # 0x4c5c1
leaq 0x28124(%rip), %rcx # 0x4fbf2
movl $0x5d0, %esi # imm = 0x5D0
xorl %eax, %eax
callq 0x18ce0
leaq 0x27c93(%rip), %rdi # 0x4f774
leaq 0x24ad9(%rip), %rdx # 0x4c5c1
leaq 0x28054(%rip), %rcx # 0x4fb43
movl $0x5ae, %esi # imm = 0x5AE
jmp 0x27ad3
leaq 0x27c77(%rip), %rdi # 0x4f774
leaq 0x24abd(%rip), %rdx # 0x4c5c1
leaq 0x28047(%rip), %rcx # 0x4fb52
movl $0x5af, %esi # imm = 0x5AF
jmp 0x27ad3
leaq 0x27c5b(%rip), %rdi # 0x4f774
leaq 0x24aa1(%rip), %rdx # 0x4c5c1
leaq 0x28051(%rip), %rcx # 0x4fb78
movl $0x5b0, %esi # imm = 0x5B0
jmp 0x27ad3
| ggml_backend_sched_new:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
test edx, edx
jle loc_27ADA
mov ebx, edx
cmp edx, 11h
jge loc_27AF6
mov ebp, r8d
mov r13, rcx
mov r14, rsi
mov r15, rdi
mov eax, ebx
mov rax, [rdi+rax*8-8]
mov rdi, [rax+70h]
call qword ptr [rdi+18h]
test eax, eax
jnz loc_27B12
mov edi, 1
mov esi, 448h
call _calloc
mov r12, rax
lea rdi, aGgmlSchedDebug; "GGML_SCHED_DEBUG"
call _getenv
test rax, rax
mov [rsp+58h+var_50], r14
jz short loc_27888
mov rdi, rax
call _atoi
jmp short loc_2788A
loc_27888:
xor eax, eax
loc_2788A:
mov [r12+440h], eax
mov [r12+4], ebx
movzx eax, bpl
lea eax, [rax+rax*2]
inc eax
mov [r12+1B8h], eax
lea rbp, [rsp+58h+var_48]
mov rdi, rbp
mov rsi, r13
call _ggml_hash_set_new
mov rax, [rbp+10h]
mov [r12+120h], rax
movups xmm0, xmmword ptr [rbp+0]
movups xmmword ptr [r12+110h], xmm0
mov r14d, ebx
mov rbx, [r12+110h]
lea rdi, ds:0[rbx*4]
call _malloc
mov [r12+128h], rax
movsxd rdi, dword ptr [r12+4]
movsxd rax, dword ptr [r12+1B8h]
imul rdi, rbx
imul rdi, rax
shl rdi, 3
call _malloc
mov [r12+130h], rax
lea rax, ds:0[r13*4]
add rax, r13
lea rbp, ds:0[rax*4]
add rbp, r13
mov esi, 4
mov rdi, rbp
call _calloc
mov [r12+138h], rax
mov esi, 4
mov rdi, rbp
call _calloc
mov [r12+140h], rax
mov esi, 4
mov rdi, rbp
call _calloc
mov [r12+148h], rax
mov esi, 4
mov rdi, rbp
call _calloc
mov [r12+150h], rax
imul rbp, r13, 1A40h
xor ebx, ebx
mov rdi, r13
xor esi, esi
call _ggml_graph_overhead_custom
add rbp, rax
mov [r12+438h], rbp
mov rdi, rbp
call _malloc
mov [r12+430h], rax
mov edi, 10h
mov esi, 0B8h
call _calloc
mov [r12+1A8h], rax
mov dword ptr [r12+1B4h], 10h
lea r13, [r12+1C0h]
cmp r14d, 2
mov ebp, 1
mov [rsp+58h+var_54], r14d
cmovge ebp, r14d
loc_279EC:
mov rax, [r15+rbx*8]
mov [r12+rbx*8+8], rax
mov rcx, [rsp+58h+var_50]
test rcx, rcx
jz short loc_27A05
mov rsi, [rcx+rbx*8]
jmp short loc_27A0F
loc_27A05:
mov rdi, [rax+70h]
call qword ptr [rdi+30h]
mov rsi, rax
loc_27A0F:
mov [r12+rbx*8+88h], rsi
mov rax, [r15+rbx*8]
mov rdi, [rax+70h]
call qword ptr [rdi+50h]
test al, al
jz loc_27AB9
cmp dword ptr [r12+1B8h], 2
jl short loc_27A74
cmp dword ptr [r12+1B8h], 0
jle short loc_27A74
xor r14d, r14d
loc_27A43:
mov rax, [r15+rbx*8]
mov rdi, [rax+70h]
test rdi, rdi
jz short loc_27A5D
mov rax, [rdi+60h]
test rax, rax
jz short loc_27A5D
call rax
jmp short loc_27A5F
loc_27A5D:
xor eax, eax
loc_27A5F:
mov [r13+r14*8+0], rax
inc r14
movsxd rax, dword ptr [r12+1B8h]
cmp r14, rax
jl short loc_27A43
loc_27A74:
inc rbx
add r13, 20h ; ' '
cmp rbx, rbp
jnz loc_279EC
mov rdi, r12
add rdi, 88h
mov esi, [rsp+58h+var_54]
call _ggml_gallocr_new_n
mov [r12+108h], rax
mov rdi, r12
call _ggml_backend_sched_reset
mov rax, r12
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_27AB9:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlBackendSup_1; "ggml_backend_supports_buft(backends[b],"...
mov esi, 5D0h
loc_27AD3:
xor eax, eax
call _ggml_abort
loc_27ADA:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNBackends0; "n_backends > 0"
mov esi, 5AEh
jmp short loc_27AD3
loc_27AF6:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNBackendsGgmlS; "n_backends <= GGML_SCHED_MAX_BACKENDS"
mov esi, 5AFh
jmp short loc_27AD3
loc_27B12:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlBackendDev_12; "ggml_backend_dev_type(ggml_backend_get_"...
mov esi, 5B0h
jmp short loc_27AD3
| long long ggml_backend_sched_new(
long long a1,
long long a2,
int a3,
unsigned long long a4,
unsigned __int8 a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
long long v18; // r12
long long v19; // rax
long long v20; // rdx
long long v21; // rcx
long long v22; // r8
long long v23; // r9
__m128 v24; // xmm4
__m128 v25; // xmm5
int v26; // eax
int v27; // r14d
long long v28; // rbx
long long v29; // rbx
unsigned long long v30; // rbp
long long v31; // r13
long long v32; // rbp
long long v33; // rax
long long v34; // rsi
long long v35; // r14
long long v36; // rdi
long long (*v37)(void); // rax
long long v38; // rax
const char *v40; // rcx
int v41; // esi
int v42; // [rsp+4h] [rbp-54h]
__int128 v44; // [rsp+10h] [rbp-48h] BYREF
long long v45; // [rsp+20h] [rbp-38h]
if ( a3 <= 0 )
{
v40 = "n_backends > 0";
v41 = 1454;
goto LABEL_23;
}
if ( a3 >= 17 )
{
v40 = "n_backends <= GGML_SCHED_MAX_BACKENDS";
v41 = 1455;
goto LABEL_23;
}
if ( (*(unsigned int (**)(void))(*(_QWORD *)(*(_QWORD *)(a1 + 8LL * (unsigned int)a3 - 8) + 112LL) + 24LL))() )
{
v40 = "ggml_backend_dev_type(ggml_backend_get_device(backends[n_backends - 1])) == GGML_BACKEND_DEVICE_TYPE_CPU";
v41 = 1456;
LABEL_23:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
v41,
(unsigned int)"GGML_ASSERT(%s) failed",
(_DWORD)v40,
a5,
a6);
}
v18 = calloc(1LL, 1096LL);
v19 = getenv("GGML_SCHED_DEBUG");
if ( v19 )
v26 = atoi(v19);
else
v26 = 0;
*(_DWORD *)(v18 + 1088) = v26;
*(_DWORD *)(v18 + 4) = a3;
*(_DWORD *)(v18 + 440) = 3 * a5 + 1;
ggml_hash_set_new((long long *)&v44, a4, a7, a8, a9, a10, v24, v25, a13, a14, v20, v21, v22, v23);
*(_QWORD *)(v18 + 288) = v45;
*(_OWORD *)(v18 + 272) = v44;
v27 = a3;
v28 = *(_QWORD *)(v18 + 272);
*(_QWORD *)(v18 + 296) = malloc(4 * v28);
*(_QWORD *)(v18 + 304) = malloc(8 * *(int *)(v18 + 440) * v28 * *(int *)(v18 + 4));
*(_QWORD *)(v18 + 312) = calloc(21 * a4, 4LL);
*(_QWORD *)(v18 + 320) = calloc(21 * a4, 4LL);
*(_QWORD *)(v18 + 328) = calloc(21 * a4, 4LL);
*(_QWORD *)(v18 + 336) = calloc(21 * a4, 4LL);
v29 = 0LL;
v30 = ggml_graph_overhead_custom(a4) + 6720 * a4;
*(_QWORD *)(v18 + 1080) = v30;
*(_QWORD *)(v18 + 1072) = malloc(v30);
*(_QWORD *)(v18 + 424) = calloc(16LL, 184LL);
*(_DWORD *)(v18 + 436) = 16;
v31 = v18 + 448;
v32 = 1LL;
v42 = v27;
if ( v27 >= 2 )
v32 = (unsigned int)v27;
do
{
v33 = *(_QWORD *)(a1 + 8 * v29);
*(_QWORD *)(v18 + 8 * v29 + 8) = v33;
if ( a2 )
v34 = *(_QWORD *)(a2 + 8 * v29);
else
v34 = (*(long long (**)(void))(*(_QWORD *)(v33 + 112) + 48LL))();
*(_QWORD *)(v18 + 8 * v29 + 136) = v34;
if ( !(*(unsigned __int8 (**)(void))(*(_QWORD *)(*(_QWORD *)(a1 + 8 * v29) + 112LL) + 80LL))() )
{
v40 = "ggml_backend_supports_buft(backends[b], sched->bufts[b])";
v41 = 1488;
goto LABEL_23;
}
if ( *(int *)(v18 + 440) >= 2 )
{
v35 = 0LL;
do
{
v36 = *(_QWORD *)(*(_QWORD *)(a1 + 8 * v29) + 112LL);
if ( v36 && (v37 = *(long long (**)(void))(v36 + 96)) != 0LL )
v38 = v37();
else
v38 = 0LL;
*(_QWORD *)(v31 + 8 * v35++) = v38;
}
while ( v35 < *(int *)(v18 + 440) );
}
++v29;
v31 += 32LL;
}
while ( v29 != v32 );
*(_QWORD *)(v18 + 264) = ggml_gallocr_new_n(v18 + 136, v42);
ggml_backend_sched_reset(v18);
return v18;
}
| ggml_backend_sched_new:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
TEST EDX,EDX
JLE 0x00127ada
MOV EBX,EDX
CMP EDX,0x11
JGE 0x00127af6
MOV EBP,R8D
MOV R13,RCX
MOV R14,RSI
MOV R15,RDI
MOV EAX,EBX
MOV RAX,qword ptr [RDI + RAX*0x8 + -0x8]
MOV RDI,qword ptr [RAX + 0x70]
CALL qword ptr [RDI + 0x18]
TEST EAX,EAX
JNZ 0x00127b12
MOV EDI,0x1
MOV ESI,0x448
CALL 0x00117b60
MOV R12,RAX
LEA RDI,[0x14fbe1]
CALL 0x001184b0
TEST RAX,RAX
MOV qword ptr [RSP + 0x8],R14
JZ 0x00127888
MOV RDI,RAX
CALL 0x00118a80
JMP 0x0012788a
LAB_00127888:
XOR EAX,EAX
LAB_0012788a:
MOV dword ptr [R12 + 0x440],EAX
MOV dword ptr [R12 + 0x4],EBX
MOVZX EAX,BPL
LEA EAX,[RAX + RAX*0x2]
INC EAX
MOV dword ptr [R12 + 0x1b8],EAX
LEA RBP,[RSP + 0x10]
MOV RDI,RBP
MOV RSI,R13
CALL 0x00117180
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [R12 + 0x120],RAX
MOVUPS XMM0,xmmword ptr [RBP]
MOVUPS xmmword ptr [R12 + 0x110],XMM0
MOV R14D,EBX
MOV RBX,qword ptr [R12 + 0x110]
LEA RDI,[RBX*0x4]
CALL 0x00118650
MOV qword ptr [R12 + 0x128],RAX
MOVSXD RDI,dword ptr [R12 + 0x4]
MOVSXD RAX,dword ptr [R12 + 0x1b8]
IMUL RDI,RBX
IMUL RDI,RAX
SHL RDI,0x3
CALL 0x00118650
MOV qword ptr [R12 + 0x130],RAX
LEA RAX,[R13*0x4]
ADD RAX,R13
LEA RBP,[RAX*0x4]
ADD RBP,R13
MOV ESI,0x4
MOV RDI,RBP
CALL 0x00117b60
MOV qword ptr [R12 + 0x138],RAX
MOV ESI,0x4
MOV RDI,RBP
CALL 0x00117b60
MOV qword ptr [R12 + 0x140],RAX
MOV ESI,0x4
MOV RDI,RBP
CALL 0x00117b60
MOV qword ptr [R12 + 0x148],RAX
MOV ESI,0x4
MOV RDI,RBP
CALL 0x00117b60
MOV qword ptr [R12 + 0x150],RAX
IMUL RBP,R13,0x1a40
XOR EBX,EBX
MOV RDI,R13
XOR ESI,ESI
CALL 0x00118790
ADD RBP,RAX
MOV qword ptr [R12 + 0x438],RBP
MOV RDI,RBP
CALL 0x00118650
MOV qword ptr [R12 + 0x430],RAX
MOV EDI,0x10
MOV ESI,0xb8
CALL 0x00117b60
MOV qword ptr [R12 + 0x1a8],RAX
MOV dword ptr [R12 + 0x1b4],0x10
LEA R13,[R12 + 0x1c0]
CMP R14D,0x2
MOV EBP,0x1
MOV dword ptr [RSP + 0x4],R14D
CMOVGE EBP,R14D
LAB_001279ec:
MOV RAX,qword ptr [R15 + RBX*0x8]
MOV qword ptr [R12 + RBX*0x8 + 0x8],RAX
MOV RCX,qword ptr [RSP + 0x8]
TEST RCX,RCX
JZ 0x00127a05
MOV RSI,qword ptr [RCX + RBX*0x8]
JMP 0x00127a0f
LAB_00127a05:
MOV RDI,qword ptr [RAX + 0x70]
CALL qword ptr [RDI + 0x30]
MOV RSI,RAX
LAB_00127a0f:
MOV qword ptr [R12 + RBX*0x8 + 0x88],RSI
MOV RAX,qword ptr [R15 + RBX*0x8]
MOV RDI,qword ptr [RAX + 0x70]
CALL qword ptr [RDI + 0x50]
TEST AL,AL
JZ 0x00127ab9
CMP dword ptr [R12 + 0x1b8],0x2
JL 0x00127a74
CMP dword ptr [R12 + 0x1b8],0x0
JLE 0x00127a74
XOR R14D,R14D
LAB_00127a43:
MOV RAX,qword ptr [R15 + RBX*0x8]
MOV RDI,qword ptr [RAX + 0x70]
TEST RDI,RDI
JZ 0x00127a5d
MOV RAX,qword ptr [RDI + 0x60]
TEST RAX,RAX
JZ 0x00127a5d
CALL RAX
JMP 0x00127a5f
LAB_00127a5d:
XOR EAX,EAX
LAB_00127a5f:
MOV qword ptr [R13 + R14*0x8],RAX
INC R14
MOVSXD RAX,dword ptr [R12 + 0x1b8]
CMP R14,RAX
JL 0x00127a43
LAB_00127a74:
INC RBX
ADD R13,0x20
CMP RBX,RBP
JNZ 0x001279ec
MOV RDI,R12
ADD RDI,0x88
MOV ESI,dword ptr [RSP + 0x4]
CALL 0x00119160
MOV qword ptr [R12 + 0x108],RAX
MOV RDI,R12
CALL 0x00117af0
MOV RAX,R12
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00127ab9:
LEA RDI,[0x14f774]
LEA RDX,[0x14c5c1]
LEA RCX,[0x14fbf2]
MOV ESI,0x5d0
LAB_00127ad3:
XOR EAX,EAX
CALL 0x00118ce0
LAB_00127ada:
LEA RDI,[0x14f774]
LEA RDX,[0x14c5c1]
LEA RCX,[0x14fb43]
MOV ESI,0x5ae
JMP 0x00127ad3
LAB_00127af6:
LEA RDI,[0x14f774]
LEA RDX,[0x14c5c1]
LEA RCX,[0x14fb52]
MOV ESI,0x5af
JMP 0x00127ad3
LAB_00127b12:
LEA RDI,[0x14f774]
LEA RDX,[0x14c5c1]
LEA RCX,[0x14fb78]
MOV ESI,0x5b0
JMP 0x00127ad3
|
void * ggml_backend_sched_new(long param_1,long param_2,uint param_3,long param_4,uint param_5)
{
long lVar1;
code *pcVar2;
char cVar3;
int iVar4;
void *pvVar5;
char *pcVar6;
void *pvVar7;
long lVar8;
int8 uVar9;
ulong uVar10;
size_t sVar11;
ulong uVar12;
long lVar13;
int8 local_48;
int8 uStack_40;
int8 local_38;
if ((int)param_3 < 1) {
pcVar6 = "n_backends > 0";
uVar9 = 0x5ae;
}
else if ((int)param_3 < 0x11) {
iVar4 = (**(code **)(*(long *)(*(long *)(param_1 + -8 + (ulong)param_3 * 8) + 0x70) + 0x18))();
if (iVar4 == 0) {
pvVar5 = calloc(1,0x448);
pcVar6 = getenv("GGML_SCHED_DEBUG");
if (pcVar6 == (char *)0x0) {
iVar4 = 0;
}
else {
iVar4 = atoi(pcVar6);
}
*(int *)((long)pvVar5 + 0x440) = iVar4;
*(uint *)((long)pvVar5 + 4) = param_3;
*(uint *)((long)pvVar5 + 0x1b8) = (param_5 & 0xff) * 3 + 1;
ggml_hash_set_new(&local_48,param_4);
*(int8 *)((long)pvVar5 + 0x120) = local_38;
*(int8 *)((long)pvVar5 + 0x110) = local_48;
*(int8 *)((long)pvVar5 + 0x118) = uStack_40;
lVar8 = *(long *)((long)pvVar5 + 0x110);
pvVar7 = malloc(lVar8 * 4);
*(void **)((long)pvVar5 + 0x128) = pvVar7;
pvVar7 = malloc(*(int *)((long)pvVar5 + 4) * lVar8 * (long)*(int *)((long)pvVar5 + 0x1b8) * 8)
;
*(void **)((long)pvVar5 + 0x130) = pvVar7;
sVar11 = param_4 * 0x15;
pvVar7 = calloc(sVar11,4);
*(void **)((long)pvVar5 + 0x138) = pvVar7;
pvVar7 = calloc(sVar11,4);
*(void **)((long)pvVar5 + 0x140) = pvVar7;
pvVar7 = calloc(sVar11,4);
*(void **)((long)pvVar5 + 0x148) = pvVar7;
pvVar7 = calloc(sVar11,4);
*(void **)((long)pvVar5 + 0x150) = pvVar7;
uVar10 = 0;
lVar8 = ggml_graph_overhead_custom(param_4,0);
sVar11 = param_4 * 0x1a40 + lVar8;
*(size_t *)((long)pvVar5 + 0x438) = sVar11;
pvVar7 = malloc(sVar11);
*(void **)((long)pvVar5 + 0x430) = pvVar7;
pvVar7 = calloc(0x10,0xb8);
*(void **)((long)pvVar5 + 0x1a8) = pvVar7;
*(int4 *)((long)pvVar5 + 0x1b4) = 0x10;
lVar8 = (long)pvVar5 + 0x1c0;
uVar12 = 1;
if (1 < (int)param_3) {
uVar12 = (ulong)param_3;
}
while( true ) {
lVar13 = *(long *)(param_1 + uVar10 * 8);
*(long *)((long)pvVar5 + uVar10 * 8 + 8) = lVar13;
if (param_2 == 0) {
uVar9 = (**(code **)(*(long *)(lVar13 + 0x70) + 0x30))();
}
else {
uVar9 = *(int8 *)(param_2 + uVar10 * 8);
}
*(int8 *)((long)pvVar5 + uVar10 * 8 + 0x88) = uVar9;
cVar3 = (**(code **)(*(long *)(*(long *)(param_1 + uVar10 * 8) + 0x70) + 0x50))();
if (cVar3 == '\0') break;
if ((1 < *(int *)((long)pvVar5 + 0x1b8)) && (0 < *(int *)((long)pvVar5 + 0x1b8))) {
lVar13 = 0;
do {
lVar1 = *(long *)(*(long *)(param_1 + uVar10 * 8) + 0x70);
if ((lVar1 == 0) || (pcVar2 = *(code **)(lVar1 + 0x60), pcVar2 == (code *)0x0)) {
uVar9 = 0;
}
else {
uVar9 = (*pcVar2)();
}
*(int8 *)(lVar8 + lVar13 * 8) = uVar9;
lVar13 = lVar13 + 1;
} while (lVar13 < *(int *)((long)pvVar5 + 0x1b8));
}
uVar10 = uVar10 + 1;
lVar8 = lVar8 + 0x20;
if (uVar10 == uVar12) {
uVar9 = ggml_gallocr_new_n((long)pvVar5 + 0x88,param_3);
*(int8 *)((long)pvVar5 + 0x108) = uVar9;
ggml_backend_sched_reset(pvVar5);
return pvVar5;
}
}
pcVar6 = "ggml_backend_supports_buft(backends[b], sched->bufts[b])";
uVar9 = 0x5d0;
}
else {
pcVar6 =
"ggml_backend_dev_type(ggml_backend_get_device(backends[n_backends - 1])) == GGML_BACKEND_DEVICE_TYPE_CPU"
;
uVar9 = 0x5b0;
}
}
else {
pcVar6 = "n_backends <= GGML_SCHED_MAX_BACKENDS";
uVar9 = 0x5af;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,uVar9,"GGML_ASSERT(%s) failed",pcVar6);
}
| |
50,632 | ggml_backend_sched_new | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | ggml_backend_sched_t ggml_backend_sched_new(
ggml_backend_t * backends,
ggml_backend_buffer_type_t * bufts,
int n_backends,
size_t graph_size,
bool parallel) {
GGML_ASSERT(n_backends > 0);
GGML_ASSERT(n_backends <= GGML_SCHED_MAX_BACKENDS);
GGML_ASSERT(ggml_backend_dev_type(ggml_backend_get_device(backends[n_backends - 1])) == GGML_BACKEND_DEVICE_TYPE_CPU);
struct ggml_backend_sched * sched = (ggml_backend_sched *) calloc(1, sizeof(struct ggml_backend_sched));
const char * GGML_SCHED_DEBUG = getenv("GGML_SCHED_DEBUG");
sched->debug = GGML_SCHED_DEBUG ? atoi(GGML_SCHED_DEBUG) : 0;
sched->n_backends = n_backends;
sched->n_copies = parallel ? GGML_SCHED_MAX_COPIES : 1;
// initialize hash table
// FIXME: needs to be size*2 to account for leafs (do it in graph_split instead)
sched->hash_set = ggml_hash_set_new(graph_size);
sched->hv_tensor_backend_ids = (int *) malloc(sched->hash_set.size * sizeof(sched->hv_tensor_backend_ids[0]));
sched->hv_tensor_copies = (ggml_tensor **) malloc(sched->hash_set.size * sched->n_backends * sched->n_copies * sizeof(struct ggml_tensor *));
const size_t ggml_sched_max_splits = graph_size; // at most there is one split for each node in the graph
const size_t nodes_size = graph_size + ggml_sched_max_splits*GGML_SCHED_MAX_SPLIT_INPUTS*2;
sched->node_backend_ids = (int *) calloc(nodes_size, sizeof(sched->node_backend_ids[0]));
sched->leaf_backend_ids = (int *) calloc(nodes_size, sizeof(sched->leaf_backend_ids[0]));
sched->prev_node_backend_ids = (int *) calloc(nodes_size, sizeof(sched->prev_node_backend_ids[0]));
sched->prev_leaf_backend_ids = (int *) calloc(nodes_size, sizeof(sched->prev_leaf_backend_ids[0]));
sched->context_buffer_size = ggml_sched_max_splits*GGML_SCHED_MAX_SPLIT_INPUTS*2*sizeof(struct ggml_tensor) + ggml_graph_overhead_custom(graph_size, false);
sched->context_buffer = (char *) malloc(sched->context_buffer_size);
const int initial_splits_capacity = 16;
sched->splits = (ggml_backend_sched_split *) calloc(initial_splits_capacity, sizeof(sched->splits[0]));
sched->splits_capacity = initial_splits_capacity;
for (int b = 0; b < n_backends; b++) {
sched->backends[b] = backends[b];
sched->bufts[b] = bufts ? bufts[b] : ggml_backend_get_default_buffer_type(backends[b]);
GGML_ASSERT(ggml_backend_supports_buft(backends[b], sched->bufts[b]));
if (sched->n_copies > 1) {
for (int c = 0; c < sched->n_copies; c++) {
sched->events[b][c] = ggml_backend_event_new(backends[b]->device);
}
}
}
sched->galloc = ggml_gallocr_new_n(sched->bufts, n_backends);
ggml_backend_sched_reset(sched);
return sched;
} | O3 | cpp | ggml_backend_sched_new:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, 0xc(%rsp)
testl %edx, %edx
jle 0x26660
movl %edx, %ebx
cmpl $0x11, %edx
jae 0x2667c
movq %rcx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl %ebx, %eax
movq %rax, 0x28(%rsp)
movq -0x8(%rdi,%rax,8), %rax
movq 0x70(%rax), %rdi
callq *0x18(%rdi)
testl %eax, %eax
jne 0x26698
movl $0x1, %edi
movl $0x448, %esi # imm = 0x448
callq 0x16b60
movq %rax, 0x10(%rsp)
leaq 0x29872(%rip), %rdi # 0x4fc81
callq 0x174a0
testq %rax, %rax
movq %r12, 0x20(%rsp)
je 0x26428
movq %rax, %rdi
callq 0x17a70
jmp 0x2642a
xorl %eax, %eax
movq 0x10(%rsp), %r12
movl %eax, 0x440(%r12)
movl %ebx, 0x1c(%rsp)
movl %ebx, 0x4(%r12)
movzbl 0xc(%rsp), %ebx
leal 0x1(%rbx,%rbx,2), %ebp
movl %ebp, 0x1b8(%r12)
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq 0x20(%rsp), %rsi
callq 0x16180
movq 0x10(%r13), %rax
movq %rax, 0x120(%r12)
movups (%r13), %xmm0
movups %xmm0, 0x110(%r12)
movq 0x110(%r12), %r13
leaq (,%r13,4), %rdi
callq 0x17640
movq %rax, 0x128(%r12)
imulq 0x28(%rsp), %r13
shlq $0x3, %r13
addb %bl, %bl
movl %ebx, %ecx
shlq %cl, %r13
movq %r13, %rdi
callq 0x17640
movq %rax, 0x130(%r12)
movq 0x20(%rsp), %rcx
leaq (%rcx,%rcx,4), %rax
leaq (%rcx,%rax,4), %rbx
movq %rcx, %r13
movl $0x4, %esi
movq %rbx, %rdi
callq 0x16b60
movq %rax, 0x138(%r12)
movl $0x4, %esi
movq %rbx, %rdi
callq 0x16b60
movq %rax, 0x140(%r12)
movl $0x4, %esi
movq %rbx, %rdi
callq 0x16b60
movq %rax, 0x148(%r12)
movl $0x4, %esi
movq %rbx, %rdi
callq 0x16b60
movq %rax, 0x150(%r12)
movq %r13, %rdi
imulq $0x1a40, %r13, %rbx # imm = 0x1A40
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x17780
addq %rax, %rbx
movq %rbx, 0x438(%r12)
movq %rbx, %rdi
callq 0x17640
movq %rax, 0x430(%r12)
movl $0x10, %edi
movl $0xb8, %esi
callq 0x16b60
movq %rax, 0x1a8(%r12)
movl $0x10, 0x1b4(%r12)
leaq 0x1c0(%r12), %rbx
movq (%r15,%r13,8), %rax
movq 0x10(%rsp), %rcx
movq %rax, 0x8(%rcx,%r13,8)
testq %r14, %r14
je 0x26592
movq (%r14,%r13,8), %rsi
jmp 0x265a0
movq 0x70(%rax), %rdi
callq *0x30(%rdi)
movq %rax, %rsi
movq (%r15,%r13,8), %rax
movq %r14, %r12
movq 0x10(%rsp), %rcx
movq %rsi, 0x88(%rcx,%r13,8)
movq 0x70(%rax), %rdi
callq *0x50(%rdi)
testb %al, %al
je 0x2663f
cmpb $0x0, 0xc(%rsp)
je 0x265f1
xorl %r14d, %r14d
movq (%r15,%r13,8), %rax
movq 0x70(%rax), %rdi
testq %rdi, %rdi
je 0x265e3
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0x265e3
callq *%rax
jmp 0x265e5
xorl %eax, %eax
movq %rax, (%rbx,%r14,8)
incq %r14
cmpq %rbp, %r14
jb 0x265c9
incq %r13
addq $0x20, %rbx
cmpq 0x28(%rsp), %r13
movq %r12, %r14
jne 0x26579
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
addq $0x88, %rdi
movl 0x1c(%rsp), %esi
callq 0x18140
movq %rax, 0x108(%rbx)
movq %rbx, %rdi
callq 0x16af0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x291ce(%rip), %rdi # 0x4f814
leaq 0x26018(%rip), %rdx # 0x4c665
leaq 0x2963e(%rip), %rcx # 0x4fc92
movl $0x5d0, %esi # imm = 0x5D0
xorl %eax, %eax
callq 0x17cd0
leaq 0x291ad(%rip), %rdi # 0x4f814
leaq 0x25ff7(%rip), %rdx # 0x4c665
leaq 0x2956e(%rip), %rcx # 0x4fbe3
movl $0x5ae, %esi # imm = 0x5AE
jmp 0x26659
leaq 0x29191(%rip), %rdi # 0x4f814
leaq 0x25fdb(%rip), %rdx # 0x4c665
leaq 0x29561(%rip), %rcx # 0x4fbf2
movl $0x5af, %esi # imm = 0x5AF
jmp 0x26659
leaq 0x29175(%rip), %rdi # 0x4f814
leaq 0x25fbf(%rip), %rdx # 0x4c665
leaq 0x2956b(%rip), %rcx # 0x4fc18
movl $0x5b0, %esi # imm = 0x5B0
jmp 0x26659
| ggml_backend_sched_new:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rsp+78h+var_6C], r8d
test edx, edx
jle loc_26660
mov ebx, edx
cmp edx, 11h
jnb loc_2667C
mov r12, rcx
mov r14, rsi
mov r15, rdi
mov eax, ebx
mov [rsp+78h+var_50], rax
mov rax, [rdi+rax*8-8]
mov rdi, [rax+70h]
call qword ptr [rdi+18h]
test eax, eax
jnz loc_26698
mov edi, 1
mov esi, 448h
call _calloc
mov [rsp+78h+var_68], rax
lea rdi, aGgmlSchedDebug; "GGML_SCHED_DEBUG"
call _getenv
test rax, rax
mov [rsp+78h+var_58], r12
jz short loc_26428
mov rdi, rax
call _atoi
jmp short loc_2642A
loc_26428:
xor eax, eax
loc_2642A:
mov r12, [rsp+78h+var_68]
mov [r12+440h], eax
mov [rsp+78h+var_5C], ebx
mov [r12+4], ebx
movzx ebx, byte ptr [rsp+78h+var_6C]
lea ebp, [rbx+rbx*2+1]
mov [r12+1B8h], ebp
lea r13, [rsp+78h+var_48]
mov rdi, r13
mov rsi, [rsp+78h+var_58]
call _ggml_hash_set_new
mov rax, [r13+10h]
mov [r12+120h], rax
movups xmm0, xmmword ptr [r13+0]
movups xmmword ptr [r12+110h], xmm0
mov r13, [r12+110h]
lea rdi, ds:0[r13*4]
call _malloc
mov [r12+128h], rax
imul r13, [rsp+78h+var_50]
shl r13, 3
add bl, bl
mov ecx, ebx
shl r13, cl
mov rdi, r13
call _malloc
mov [r12+130h], rax
mov rcx, [rsp+78h+var_58]
lea rax, [rcx+rcx*4]
lea rbx, [rcx+rax*4]
mov r13, rcx
mov esi, 4
mov rdi, rbx
call _calloc
mov [r12+138h], rax
mov esi, 4
mov rdi, rbx
call _calloc
mov [r12+140h], rax
mov esi, 4
mov rdi, rbx
call _calloc
mov [r12+148h], rax
mov esi, 4
mov rdi, rbx
call _calloc
mov [r12+150h], rax
mov rdi, r13
imul rbx, r13, 1A40h
xor r13d, r13d
xor esi, esi
call _ggml_graph_overhead_custom
add rbx, rax
mov [r12+438h], rbx
mov rdi, rbx
call _malloc
mov [r12+430h], rax
mov edi, 10h
mov esi, 0B8h
call _calloc
mov [r12+1A8h], rax
mov dword ptr [r12+1B4h], 10h
lea rbx, [r12+1C0h]
loc_26579:
mov rax, [r15+r13*8]
mov rcx, [rsp+78h+var_68]
mov [rcx+r13*8+8], rax
test r14, r14
jz short loc_26592
mov rsi, [r14+r13*8]
jmp short loc_265A0
loc_26592:
mov rdi, [rax+70h]
call qword ptr [rdi+30h]
mov rsi, rax
mov rax, [r15+r13*8]
loc_265A0:
mov r12, r14
mov rcx, [rsp+78h+var_68]
mov [rcx+r13*8+88h], rsi
mov rdi, [rax+70h]
call qword ptr [rdi+50h]
test al, al
jz loc_2663F
cmp byte ptr [rsp+78h+var_6C], 0
jz short loc_265F1
xor r14d, r14d
loc_265C9:
mov rax, [r15+r13*8]
mov rdi, [rax+70h]
test rdi, rdi
jz short loc_265E3
mov rax, [rdi+60h]
test rax, rax
jz short loc_265E3
call rax
jmp short loc_265E5
loc_265E3:
xor eax, eax
loc_265E5:
mov [rbx+r14*8], rax
inc r14
cmp r14, rbp
jb short loc_265C9
loc_265F1:
inc r13
add rbx, 20h ; ' '
cmp r13, [rsp+78h+var_50]
mov r14, r12
jnz loc_26579
mov rbx, [rsp+78h+var_68]
mov rdi, rbx
add rdi, 88h
mov esi, [rsp+78h+var_5C]
call _ggml_gallocr_new_n
mov [rbx+108h], rax
mov rdi, rbx
call _ggml_backend_sched_reset
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2663F:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlBackendSup_1; "ggml_backend_supports_buft(backends[b],"...
mov esi, 5D0h
loc_26659:
xor eax, eax
call _ggml_abort
loc_26660:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNBackends0; "n_backends > 0"
mov esi, 5AEh
jmp short loc_26659
loc_2667C:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNBackendsGgmlS; "n_backends <= GGML_SCHED_MAX_BACKENDS"
mov esi, 5AFh
jmp short loc_26659
loc_26698:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlBackendDev_12; "ggml_backend_dev_type(ggml_backend_get_"...
mov esi, 5B0h
jmp short loc_26659
| long long ggml_backend_sched_new(
long long a1,
long long a2,
unsigned int a3,
unsigned long long a4,
unsigned __int8 a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
long long v18; // rax
long long v19; // rdx
long long v20; // rcx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
int v25; // eax
unsigned long long v26; // rbp
long long v27; // r13
long long v28; // r13
unsigned long long v29; // rbx
long long v30; // rbx
long long v31; // rax
long long v32; // rsi
long long v33; // r12
unsigned long long v34; // r14
long long v35; // rdi
long long (*v36)(void); // rax
long long v37; // rax
const char *v39; // rcx
int v40; // esi
long long v42; // [rsp+10h] [rbp-68h]
int v43; // [rsp+1Ch] [rbp-5Ch]
long long v44; // [rsp+28h] [rbp-50h]
__int128 v45; // [rsp+30h] [rbp-48h] BYREF
long long v46; // [rsp+40h] [rbp-38h]
if ( (int)a3 <= 0 )
{
v39 = "n_backends > 0";
v40 = 1454;
goto LABEL_22;
}
if ( a3 >= 0x11 )
{
v39 = "n_backends <= GGML_SCHED_MAX_BACKENDS";
v40 = 1455;
goto LABEL_22;
}
v44 = a3;
if ( (*(unsigned int (**)(void))(*(_QWORD *)(*(_QWORD *)(a1 + 8LL * a3 - 8) + 112LL) + 24LL))() )
{
v39 = "ggml_backend_dev_type(ggml_backend_get_device(backends[n_backends - 1])) == GGML_BACKEND_DEVICE_TYPE_CPU";
v40 = 1456;
LABEL_22:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
v40,
(unsigned int)"GGML_ASSERT(%s) failed",
(_DWORD)v39,
a5,
a6);
}
v42 = calloc(1LL, 1096LL);
v18 = getenv("GGML_SCHED_DEBUG");
if ( v18 )
v25 = atoi(v18);
else
v25 = 0;
*(_DWORD *)(v42 + 1088) = v25;
v43 = a3;
*(_DWORD *)(v42 + 4) = a3;
v26 = 3 * (unsigned int)a5 + 1;
*(_DWORD *)(v42 + 440) = v26;
ggml_hash_set_new((long long *)&v45, a4, a7, a8, a9, a10, v23, v24, a13, a14, v19, v20, v21, v22);
*(_QWORD *)(v42 + 288) = v46;
*(_OWORD *)(v42 + 272) = v45;
v27 = *(_QWORD *)(v42 + 272);
*(_QWORD *)(v42 + 296) = malloc(4 * v27);
*(_QWORD *)(v42 + 304) = malloc((8 * v44 * v27) << (2 * a5));
*(_QWORD *)(v42 + 312) = calloc(21 * a4, 4LL);
*(_QWORD *)(v42 + 320) = calloc(21 * a4, 4LL);
*(_QWORD *)(v42 + 328) = calloc(21 * a4, 4LL);
*(_QWORD *)(v42 + 336) = calloc(21 * a4, 4LL);
v28 = 0LL;
v29 = ggml_graph_overhead_custom(a4) + 6720 * a4;
*(_QWORD *)(v42 + 1080) = v29;
*(_QWORD *)(v42 + 1072) = malloc(v29);
*(_QWORD *)(v42 + 424) = calloc(16LL, 184LL);
*(_DWORD *)(v42 + 436) = 16;
v30 = v42 + 448;
do
{
v31 = *(_QWORD *)(a1 + 8 * v28);
*(_QWORD *)(v42 + 8 * v28 + 8) = v31;
if ( a2 )
{
v32 = *(_QWORD *)(a2 + 8 * v28);
}
else
{
v32 = (*(long long (**)(void))(*(_QWORD *)(v31 + 112) + 48LL))();
v31 = *(_QWORD *)(a1 + 8 * v28);
}
v33 = a2;
*(_QWORD *)(v42 + 8 * v28 + 136) = v32;
if ( !(*(unsigned __int8 (**)(void))(*(_QWORD *)(v31 + 112) + 80LL))() )
{
v39 = "ggml_backend_supports_buft(backends[b], sched->bufts[b])";
v40 = 1488;
goto LABEL_22;
}
if ( a5 )
{
v34 = 0LL;
do
{
v35 = *(_QWORD *)(*(_QWORD *)(a1 + 8 * v28) + 112LL);
if ( v35 && (v36 = *(long long (**)(void))(v35 + 96)) != 0LL )
v37 = v36();
else
v37 = 0LL;
*(_QWORD *)(v30 + 8 * v34++) = v37;
}
while ( v34 < v26 );
}
++v28;
v30 += 32LL;
a2 = v33;
}
while ( v28 != v44 );
*(_QWORD *)(v42 + 264) = ggml_gallocr_new_n(v42 + 136, v43);
ggml_backend_sched_reset(v42);
return v42;
}
| ggml_backend_sched_new:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RSP + 0xc],R8D
TEST EDX,EDX
JLE 0x00126660
MOV EBX,EDX
CMP EDX,0x11
JNC 0x0012667c
MOV R12,RCX
MOV R14,RSI
MOV R15,RDI
MOV EAX,EBX
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RDI + RAX*0x8 + -0x8]
MOV RDI,qword ptr [RAX + 0x70]
CALL qword ptr [RDI + 0x18]
TEST EAX,EAX
JNZ 0x00126698
MOV EDI,0x1
MOV ESI,0x448
CALL 0x00116b60
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[0x14fc81]
CALL 0x001174a0
TEST RAX,RAX
MOV qword ptr [RSP + 0x20],R12
JZ 0x00126428
MOV RDI,RAX
CALL 0x00117a70
JMP 0x0012642a
LAB_00126428:
XOR EAX,EAX
LAB_0012642a:
MOV R12,qword ptr [RSP + 0x10]
MOV dword ptr [R12 + 0x440],EAX
MOV dword ptr [RSP + 0x1c],EBX
MOV dword ptr [R12 + 0x4],EBX
MOVZX EBX,byte ptr [RSP + 0xc]
LEA EBP,[RBX + RBX*0x2 + 0x1]
MOV dword ptr [R12 + 0x1b8],EBP
LEA R13,[RSP + 0x30]
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x00116180
MOV RAX,qword ptr [R13 + 0x10]
MOV qword ptr [R12 + 0x120],RAX
MOVUPS XMM0,xmmword ptr [R13]
MOVUPS xmmword ptr [R12 + 0x110],XMM0
MOV R13,qword ptr [R12 + 0x110]
LEA RDI,[R13*0x4]
CALL 0x00117640
MOV qword ptr [R12 + 0x128],RAX
IMUL R13,qword ptr [RSP + 0x28]
SHL R13,0x3
ADD BL,BL
MOV ECX,EBX
SHL R13,CL
MOV RDI,R13
CALL 0x00117640
MOV qword ptr [R12 + 0x130],RAX
MOV RCX,qword ptr [RSP + 0x20]
LEA RAX,[RCX + RCX*0x4]
LEA RBX,[RCX + RAX*0x4]
MOV R13,RCX
MOV ESI,0x4
MOV RDI,RBX
CALL 0x00116b60
MOV qword ptr [R12 + 0x138],RAX
MOV ESI,0x4
MOV RDI,RBX
CALL 0x00116b60
MOV qword ptr [R12 + 0x140],RAX
MOV ESI,0x4
MOV RDI,RBX
CALL 0x00116b60
MOV qword ptr [R12 + 0x148],RAX
MOV ESI,0x4
MOV RDI,RBX
CALL 0x00116b60
MOV qword ptr [R12 + 0x150],RAX
MOV RDI,R13
IMUL RBX,R13,0x1a40
XOR R13D,R13D
XOR ESI,ESI
CALL 0x00117780
ADD RBX,RAX
MOV qword ptr [R12 + 0x438],RBX
MOV RDI,RBX
CALL 0x00117640
MOV qword ptr [R12 + 0x430],RAX
MOV EDI,0x10
MOV ESI,0xb8
CALL 0x00116b60
MOV qword ptr [R12 + 0x1a8],RAX
MOV dword ptr [R12 + 0x1b4],0x10
LEA RBX,[R12 + 0x1c0]
LAB_00126579:
MOV RAX,qword ptr [R15 + R13*0x8]
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RCX + R13*0x8 + 0x8],RAX
TEST R14,R14
JZ 0x00126592
MOV RSI,qword ptr [R14 + R13*0x8]
JMP 0x001265a0
LAB_00126592:
MOV RDI,qword ptr [RAX + 0x70]
CALL qword ptr [RDI + 0x30]
MOV RSI,RAX
MOV RAX,qword ptr [R15 + R13*0x8]
LAB_001265a0:
MOV R12,R14
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RCX + R13*0x8 + 0x88],RSI
MOV RDI,qword ptr [RAX + 0x70]
CALL qword ptr [RDI + 0x50]
TEST AL,AL
JZ 0x0012663f
CMP byte ptr [RSP + 0xc],0x0
JZ 0x001265f1
XOR R14D,R14D
LAB_001265c9:
MOV RAX,qword ptr [R15 + R13*0x8]
MOV RDI,qword ptr [RAX + 0x70]
TEST RDI,RDI
JZ 0x001265e3
MOV RAX,qword ptr [RDI + 0x60]
TEST RAX,RAX
JZ 0x001265e3
CALL RAX
JMP 0x001265e5
LAB_001265e3:
XOR EAX,EAX
LAB_001265e5:
MOV qword ptr [RBX + R14*0x8],RAX
INC R14
CMP R14,RBP
JC 0x001265c9
LAB_001265f1:
INC R13
ADD RBX,0x20
CMP R13,qword ptr [RSP + 0x28]
MOV R14,R12
JNZ 0x00126579
MOV RBX,qword ptr [RSP + 0x10]
MOV RDI,RBX
ADD RDI,0x88
MOV ESI,dword ptr [RSP + 0x1c]
CALL 0x00118140
MOV qword ptr [RBX + 0x108],RAX
MOV RDI,RBX
CALL 0x00116af0
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012663f:
LEA RDI,[0x14f814]
LEA RDX,[0x14c665]
LEA RCX,[0x14fc92]
MOV ESI,0x5d0
LAB_00126659:
XOR EAX,EAX
CALL 0x00117cd0
LAB_00126660:
LEA RDI,[0x14f814]
LEA RDX,[0x14c665]
LEA RCX,[0x14fbe3]
MOV ESI,0x5ae
JMP 0x00126659
LAB_0012667c:
LEA RDI,[0x14f814]
LEA RDX,[0x14c665]
LEA RCX,[0x14fbf2]
MOV ESI,0x5af
JMP 0x00126659
LAB_00126698:
LEA RDI,[0x14f814]
LEA RDX,[0x14c665]
LEA RCX,[0x14fc18]
MOV ESI,0x5b0
JMP 0x00126659
|
void * ggml_backend_sched_new(long param_1,long param_2,uint param_3,long param_4,byte param_5)
{
ulong uVar1;
code *pcVar2;
char cVar3;
int iVar4;
void *pvVar5;
char *pcVar6;
void *pvVar7;
long lVar8;
long lVar9;
int8 uVar10;
ulong uVar11;
size_t sVar12;
ulong uVar13;
ulong uVar14;
int8 local_48;
int8 uStack_40;
int8 local_38;
if ((int)param_3 < 1) {
pcVar6 = "n_backends > 0";
uVar10 = 0x5ae;
}
else {
uVar11 = (ulong)param_3;
if (param_3 < 0x11) {
iVar4 = (**(code **)(*(long *)(*(long *)(param_1 + -8 + uVar11 * 8) + 0x70) + 0x18))();
if (iVar4 == 0) {
pvVar5 = calloc(1,0x448);
pcVar6 = getenv("GGML_SCHED_DEBUG");
if (pcVar6 == (char *)0x0) {
iVar4 = 0;
}
else {
iVar4 = atoi(pcVar6);
}
*(int *)((long)pvVar5 + 0x440) = iVar4;
*(uint *)((long)pvVar5 + 4) = param_3;
uVar1 = (ulong)param_5 * 3 + 1;
*(int *)((long)pvVar5 + 0x1b8) = (int)uVar1;
ggml_hash_set_new(&local_48,param_4);
*(int8 *)((long)pvVar5 + 0x120) = local_38;
*(int8 *)((long)pvVar5 + 0x110) = local_48;
*(int8 *)((long)pvVar5 + 0x118) = uStack_40;
lVar8 = *(long *)((long)pvVar5 + 0x110);
pvVar7 = malloc(lVar8 * 4);
*(void **)((long)pvVar5 + 0x128) = pvVar7;
pvVar7 = malloc(lVar8 * uVar11 * 8 << (param_5 * '\x02' & 0x3f));
*(void **)((long)pvVar5 + 0x130) = pvVar7;
sVar12 = param_4 * 0x15;
pvVar7 = calloc(sVar12,4);
*(void **)((long)pvVar5 + 0x138) = pvVar7;
pvVar7 = calloc(sVar12,4);
*(void **)((long)pvVar5 + 0x140) = pvVar7;
pvVar7 = calloc(sVar12,4);
*(void **)((long)pvVar5 + 0x148) = pvVar7;
pvVar7 = calloc(sVar12,4);
*(void **)((long)pvVar5 + 0x150) = pvVar7;
uVar13 = 0;
lVar8 = ggml_graph_overhead_custom(param_4,0);
sVar12 = param_4 * 0x1a40 + lVar8;
*(size_t *)((long)pvVar5 + 0x438) = sVar12;
pvVar7 = malloc(sVar12);
*(void **)((long)pvVar5 + 0x430) = pvVar7;
pvVar7 = calloc(0x10,0xb8);
*(void **)((long)pvVar5 + 0x1a8) = pvVar7;
*(int4 *)((long)pvVar5 + 0x1b4) = 0x10;
lVar8 = (long)pvVar5 + 0x1c0;
while( true ) {
lVar9 = *(long *)(param_1 + uVar13 * 8);
*(long *)((long)pvVar5 + uVar13 * 8 + 8) = lVar9;
if (param_2 == 0) {
uVar10 = (**(code **)(*(long *)(lVar9 + 0x70) + 0x30))();
lVar9 = *(long *)(param_1 + uVar13 * 8);
}
else {
uVar10 = *(int8 *)(param_2 + uVar13 * 8);
}
*(int8 *)((long)pvVar5 + uVar13 * 8 + 0x88) = uVar10;
cVar3 = (**(code **)(*(long *)(lVar9 + 0x70) + 0x50))();
if (cVar3 == '\0') break;
if (param_5 != 0) {
uVar14 = 0;
do {
lVar9 = *(long *)(*(long *)(param_1 + uVar13 * 8) + 0x70);
if ((lVar9 == 0) || (pcVar2 = *(code **)(lVar9 + 0x60), pcVar2 == (code *)0x0)) {
uVar10 = 0;
}
else {
uVar10 = (*pcVar2)();
}
*(int8 *)(lVar8 + uVar14 * 8) = uVar10;
uVar14 = uVar14 + 1;
} while (uVar14 < uVar1);
}
uVar13 = uVar13 + 1;
lVar8 = lVar8 + 0x20;
if (uVar13 == uVar11) {
uVar10 = ggml_gallocr_new_n((long)pvVar5 + 0x88,param_3);
*(int8 *)((long)pvVar5 + 0x108) = uVar10;
ggml_backend_sched_reset(pvVar5);
return pvVar5;
}
}
pcVar6 = "ggml_backend_supports_buft(backends[b], sched->bufts[b])";
uVar10 = 0x5d0;
}
else {
pcVar6 =
"ggml_backend_dev_type(ggml_backend_get_device(backends[n_backends - 1])) == GGML_BACKEND_DEVICE_TYPE_CPU"
;
uVar10 = 0x5b0;
}
}
else {
pcVar6 = "n_backends <= GGML_SCHED_MAX_BACKENDS";
uVar10 = 0x5af;
}
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,uVar10,"GGML_ASSERT(%s) failed",pcVar6);
}
| |
50,633 | google::protobuf::MapKey::SetType(google::protobuf::FieldDescriptor::CppType) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/map_field.h | void SetType(FieldDescriptor::CppType type) {
if (type_ == type) return;
if (type_ == FieldDescriptor::CPPTYPE_STRING) {
val_.string_value_.Destruct();
}
type_ = type;
if (type_ == FieldDescriptor::CPPTYPE_STRING) {
val_.string_value_.DefaultConstruct();
}
} | O0 | c | google::protobuf::MapKey::SetType(google::protobuf::FieldDescriptor::CppType):
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl 0x20(%rax), %eax
cmpl 0xc(%rsp), %eax
jne 0x1c2191
jmp 0x1c21be
movq (%rsp), %rax
cmpl $0x9, 0x20(%rax)
jne 0x1c21a4
movq (%rsp), %rdi
callq 0x1c2240
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x20(%rax)
cmpl $0x9, 0x20(%rax)
jne 0x1c21be
movq (%rsp), %rdi
callq 0x1c2260
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN6google8protobuf6MapKey7SetTypeENS0_15FieldDescriptor7CppTypeE:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_C], esi
mov rax, [rsp+18h+var_8]
mov [rsp+18h+var_18], rax
mov eax, [rax+20h]
cmp eax, [rsp+18h+var_C]
jnz short loc_1C2191
jmp short loc_1C21BE
loc_1C2191:
mov rax, [rsp+18h+var_18]
cmp dword ptr [rax+20h], 9
jnz short loc_1C21A4
mov rdi, [rsp+18h+var_18]
call _ZN6google8protobuf8internal21ExplicitlyConstructedINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEELm1EE8DestructEv; google::protobuf::internal::ExplicitlyConstructed<std::string,1ul>::Destruct(void)
loc_1C21A4:
mov rax, [rsp+18h+var_18]
mov ecx, [rsp+18h+var_C]
mov [rax+20h], ecx
cmp dword ptr [rax+20h], 9
jnz short loc_1C21BE
mov rdi, [rsp+18h+var_18]
call _ZN6google8protobuf8internal21ExplicitlyConstructedINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEELm1EE16DefaultConstructEv; google::protobuf::internal::ExplicitlyConstructed<std::string,1ul>::DefaultConstruct(void)
loc_1C21BE:
add rsp, 18h
retn
| long long google::protobuf::MapKey::SetType(long long a1, int a2)
{
long long result; // rax
result = *(unsigned int *)(a1 + 32);
if ( (_DWORD)result != a2 )
{
if ( *(_DWORD *)(a1 + 32) == 9 )
google::protobuf::internal::ExplicitlyConstructed<std::string,1ul>::Destruct(a1);
result = a1;
*(_DWORD *)(a1 + 32) = a2;
if ( *(_DWORD *)(a1 + 32) == 9 )
return google::protobuf::internal::ExplicitlyConstructed<std::string,1ul>::DefaultConstruct(a1);
}
return result;
}
| |||
50,634 | google::protobuf::MapKey::SetType(google::protobuf::FieldDescriptor::CppType) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/map_field.h | void SetType(FieldDescriptor::CppType type) {
if (type_ == type) return;
if (type_ == FieldDescriptor::CPPTYPE_STRING) {
val_.string_value_.Destruct();
}
type_ = type;
if (type_ == FieldDescriptor::CPPTYPE_STRING) {
val_.string_value_.DefaultConstruct();
}
} | O3 | c | google::protobuf::MapKey::SetType(google::protobuf::FieldDescriptor::CppType):
movl 0x20(%rdi), %eax
cmpl %esi, %eax
je 0x97f76
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x9, %eax
jne 0x97f55
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x97f55
callq 0x2d160
movl %ebp, 0x20(%rbx)
cmpl $0x9, %ebp
jne 0x97f70
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| _ZN6google8protobuf6MapKey7SetTypeENS0_15FieldDescriptor7CppTypeE:
mov eax, [rdi+20h]
cmp eax, esi
jz short locret_97F76
push rbp
push rbx
push rax
mov ebp, esi
mov rbx, rdi
cmp eax, 9
jnz short loc_97F55
mov rdi, [rbx]; void *
lea rax, [rbx+10h]
cmp rdi, rax
jz short loc_97F55
call __ZdlPv; operator delete(void *)
loc_97F55:
mov [rbx+20h], ebp
cmp ebp, 9
jnz short loc_97F70
lea rax, [rbx+10h]
mov [rbx], rax
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
loc_97F70:
add rsp, 8
pop rbx
pop rbp
locret_97F76:
retn
| void google::protobuf::MapKey::SetType(long long a1, int a2)
{
int v2; // eax
void *v4; // rdi
v2 = *(_DWORD *)(a1 + 32);
if ( v2 != a2 )
{
if ( v2 == 9 )
{
v4 = *(void **)a1;
if ( *(_QWORD *)a1 != a1 + 16 )
operator delete(v4);
}
*(_DWORD *)(a1 + 32) = a2;
if ( a2 == 9 )
{
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
}
}
}
| SetType:
MOV EAX,dword ptr [RDI + 0x20]
CMP EAX,ESI
JZ 0x00197f76
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBP,ESI
MOV RBX,RDI
CMP EAX,0x9
JNZ 0x00197f55
MOV RDI,qword ptr [RBX]
LEA RAX,[RBX + 0x10]
CMP RDI,RAX
JZ 0x00197f55
CALL 0x0012d160
LAB_00197f55:
MOV dword ptr [RBX + 0x20],EBP
CMP EBP,0x9
JNZ 0x00197f70
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
LAB_00197f70:
ADD RSP,0x8
POP RBX
POP RBP
LAB_00197f76:
RET
|
/* google::protobuf::MapKey::SetType(google::protobuf::FieldDescriptor::CppType) */
void __thiscall google::protobuf::MapKey::SetType(MapKey *this,int param_2)
{
if (*(int *)(this + 0x20) != param_2) {
if ((*(int *)(this + 0x20) == 9) && (*(MapKey **)this != this + 0x10)) {
operator_delete(*(MapKey **)this);
}
*(int *)(this + 0x20) = param_2;
if (param_2 == 9) {
*(MapKey **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (MapKey)0x0;
}
}
return;
}
| |
50,635 | common_kv_cache_dump_view_seqs(llama_kv_cache_view const&, int) | monkey531[P]llama/common/common.cpp | void common_kv_cache_dump_view_seqs(const llama_kv_cache_view & view, int row_size) {
static const char slot_chars[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
printf("=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, largest empty slot=%d @ %d\n",
view.n_cells, view.n_seq_max, view.used_cells, view.token_count, view.max_contiguous, view.max_contiguous_idx);
std::unordered_map<llama_seq_id, size_t> seqs;
llama_kv_cache_view_cell * c_curr = view.cells;
llama_seq_id * cs_curr = view.cells_sequences;
for (int i = 0; i < view.n_cells; i++, c_curr++, cs_curr += view.n_seq_max) {
for (int j = 0; j < view.n_seq_max; j++) {
if (cs_curr[j] < 0) { continue; }
if (seqs.find(cs_curr[j]) == seqs.end()) {
if (seqs.size() + 1 >= sizeof(slot_chars)) { break; }
const size_t sz = seqs.size();
seqs[cs_curr[j]] = sz;
}
}
if (seqs.size() + 1 >= sizeof(slot_chars)) { break; }
}
printf("=== Sequence legend: ");
for (const auto & it : seqs) {
printf("%zu=%d, ", it.second, it.first);
}
printf("'+'=other sequence ids");
c_curr = view.cells;
cs_curr = view.cells_sequences;
for (int i = 0; i < view.n_cells; i++, c_curr++, cs_curr += view.n_seq_max) {
if (i % row_size == 0) {
printf("\n%5d: ", i);
}
for (int j = 0; j < view.n_seq_max; j++) {
if (cs_curr[j] >= 0) {
const auto & it = seqs.find(cs_curr[j]);
putchar(it != seqs.end() ? int(slot_chars[it->second]) : '+');
} else {
putchar('.');
}
}
putchar(' ');
}
printf("\n=== Done dumping\n");
} | O0 | cpp | common_kv_cache_dump_view_seqs(llama_kv_cache_view const&, int):
subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x100(%rsp)
movl %esi, 0xfc(%rsp)
movq 0x100(%rsp), %rax
movl (%rax), %esi
movq 0x100(%rsp), %rax
movl 0x4(%rax), %edx
movq 0x100(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x100(%rsp), %rax
movl 0x8(%rax), %r8d
movq 0x100(%rsp), %rax
movl 0x10(%rax), %r9d
movq 0x100(%rsp), %rax
movl 0x14(%rax), %eax
leaq 0x11c7c3(%rip), %rdi # 0x20ddb3
movl %eax, (%rsp)
movb $0x0, %al
callq 0x590f0
leaq 0xc0(%rsp), %rdi
callq 0xff9c0
movq 0x100(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0xb8(%rsp)
movq 0x100(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0xb0(%rsp)
movl $0x0, 0xac(%rsp)
movl 0xac(%rsp), %eax
movq 0x100(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xf1814
movl $0x0, 0xa8(%rsp)
movl 0xa8(%rsp), %eax
movq 0x100(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0xf17aa
movq 0xb0(%rsp), %rax
movslq 0xa8(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0xf168f
jmp 0xf1794
movq 0xb0(%rsp), %rax
movslq 0xa8(%rsp), %rcx
leaq (%rax,%rcx,4), %rsi
leaq 0xc0(%rsp), %rdi
callq 0xff9f0
movq %rax, 0x38(%rsp)
jmp 0xf16b7
movq 0x38(%rsp), %rax
movq %rax, 0xa0(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0xffa20
movq %rax, 0x88(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xff9d0
testb $0x1, %al
jne 0xf16f7
jmp 0xf1792
leaq 0xc0(%rsp), %rdi
callq 0xffa50
addq $0x1, %rax
cmpq $0x3f, %rax
jb 0xf1739
jmp 0xf17aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0xffb50
jmp 0xf1a88
leaq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xffa50
movq 0x20(%rsp), %rdi
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb0(%rsp), %rax
movslq 0xa8(%rsp), %rcx
leaq (%rax,%rcx,4), %rsi
callq 0xffa60
movq %rax, 0x30(%rsp)
jmp 0xf1785
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
jmp 0xf1794
movl 0xa8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa8(%rsp)
jmp 0xf165c
leaq 0xc0(%rsp), %rdi
callq 0xffa50
addq $0x1, %rax
cmpq $0x3f, %rax
jb 0xf17c3
jmp 0xf1814
jmp 0xf17c5
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
movq 0xb8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xb8(%rsp)
movq 0x100(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0xb0(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0xb0(%rsp)
jmp 0xf163a
leaq 0x11c623(%rip), %rdi # 0x20de3e
xorl %eax, %eax
callq 0x590f0
jmp 0xf1824
leaq 0xc0(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0xffa90
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0xffa20
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xffac0
testb $0x1, %al
jne 0xf1864
jmp 0xf189c
leaq 0x70(%rsp), %rdi
callq 0xffae0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rsi
movl (%rax), %edx
leaq 0x11c5cf(%rip), %rdi # 0x20de54
xorl %eax, %eax
callq 0x590f0
jmp 0xf188e
jmp 0xf1890
leaq 0x70(%rsp), %rdi
callq 0xffb00
jmp 0xf184f
leaq 0x11c5ba(%rip), %rdi # 0x20de5d
xorl %eax, %eax
callq 0x590f0
jmp 0xf18ac
movq 0x100(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0xb8(%rsp)
movq 0x100(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0xb0(%rsp)
movl $0x0, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movq 0x100(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xf1a63
movl 0x5c(%rsp), %eax
cltd
idivl 0xfc(%rsp)
cmpl $0x0, %edx
jne 0xf1917
movl 0x5c(%rsp), %esi
leaq 0x11c48d(%rip), %rdi # 0x20dd99
xorl %eax, %eax
callq 0x590f0
jmp 0xf1915
jmp 0xf1917
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
movq 0x100(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0xf1a0c
movq 0xb0(%rsp), %rax
movslq 0x58(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0xf19ec
movq 0xb0(%rsp), %rax
movslq 0x58(%rsp), %rcx
leaq (%rax,%rcx,4), %rsi
leaq 0xc0(%rsp), %rdi
callq 0xff9f0
movq %rax, 0x18(%rsp)
jmp 0xf1970
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0xffa20
movq 0x10(%rsp), %rdi
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0xffac0
testb $0x1, %al
jne 0xf19b5
jmp 0xf19d4
movq 0x50(%rsp), %rdi
callq 0xffb30
movq 0x8(%rax), %rcx
leaq 0x11b0f6(%rip), %rax # 0x20cac0
movsbl (%rax,%rcx), %eax
movl %eax, 0xc(%rsp)
jmp 0xf19df
movl $0x2b, %eax
movl %eax, 0xc(%rsp)
jmp 0xf19df
movl 0xc(%rsp), %edi
callq 0x5a300
jmp 0xf19ea
jmp 0xf19fa
movl $0x2e, %edi
callq 0x5a300
jmp 0xf19f8
jmp 0xf19fa
jmp 0xf19fc
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0xf191f
movl $0x20, %edi
callq 0x5a300
jmp 0xf1a18
jmp 0xf1a1a
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
movq 0xb8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0xb8(%rsp)
movq 0x100(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0xb0(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0xb0(%rsp)
jmp 0xf18dc
leaq 0x11c336(%rip), %rdi # 0x20dda0
xorl %eax, %eax
callq 0x590f0
jmp 0xf1a73
leaq 0xc0(%rsp), %rdi
callq 0xffb50
addq $0x108, %rsp # imm = 0x108
retq
movq 0x98(%rsp), %rdi
callq 0x59b80
nopw %cs:(%rax,%rax)
| _Z30common_kv_cache_dump_view_seqsRK19llama_kv_cache_viewi:
sub rsp, 108h
mov [rsp+108h+var_8], rdi
mov [rsp+108h+var_C], esi
mov rax, [rsp+108h+var_8]
mov esi, [rax]
mov rax, [rsp+108h+var_8]
mov edx, [rax+4]
mov rax, [rsp+108h+var_8]
mov ecx, [rax+0Ch]
mov rax, [rsp+108h+var_8]
mov r8d, [rax+8]
mov rax, [rsp+108h+var_8]
mov r9d, [rax+10h]
mov rax, [rsp+108h+var_8]
mov eax, [rax+14h]
lea rdi, aDumpingKvCache_0; "=== Dumping KV cache. total cells %d, m"...
mov [rsp+108h+var_108], eax
mov al, 0
call _printf
lea rdi, [rsp+108h+var_48]
call _ZNSt13unordered_mapIimSt4hashIiESt8equal_toIiESaISt4pairIKimEEEC2Ev; std::unordered_map<int,ulong>::unordered_map(void)
mov rax, [rsp+108h+var_8]
mov rax, [rax+18h]
mov [rsp+108h+var_50], rax
mov rax, [rsp+108h+var_8]
mov rax, [rax+20h]
mov [rsp+108h+var_58], rax
mov [rsp+108h+var_5C], 0
loc_F163A:
mov eax, [rsp+108h+var_5C]
mov rcx, [rsp+108h+var_8]
cmp eax, [rcx]
jge loc_F1814
mov [rsp+108h+var_60], 0
loc_F165C:
mov eax, [rsp+108h+var_60]
mov rcx, [rsp+108h+var_8]
cmp eax, [rcx+4]
jge loc_F17AA
mov rax, [rsp+108h+var_58]
movsxd rcx, [rsp+108h+var_60]
cmp dword ptr [rax+rcx*4], 0
jge short loc_F168F
jmp loc_F1794
loc_F168F:
mov rax, [rsp+108h+var_58]
movsxd rcx, [rsp+108h+var_60]
lea rsi, [rax+rcx*4]
lea rdi, [rsp+108h+var_48]
call _ZNSt13unordered_mapIimSt4hashIiESt8equal_toIiESaISt4pairIKimEEE4findERS5_; std::unordered_map<int,ulong>::find(int const&)
mov [rsp+108h+var_D0], rax
jmp short $+2
loc_F16B7:
mov rax, [rsp+108h+var_D0]
mov [rsp+108h+var_68], rax
lea rdi, [rsp+108h+var_48]
call _ZNSt13unordered_mapIimSt4hashIiESt8equal_toIiESaISt4pairIKimEEE3endEv; std::unordered_map<int,ulong>::end(void)
mov [rsp+108h+var_80], rax
lea rdi, [rsp+108h+var_68]
lea rsi, [rsp+108h+var_80]
call _ZNSt8__detaileqERKNS_19_Node_iterator_baseISt4pairIKimELb0EEES6_; std::__detail::operator==(std::__detail::_Node_iterator_base<std::pair<int const,ulong>,false> const&,std::__detail::_Node_iterator_base<std::pair<int const,ulong>,false> const&)
test al, 1
jnz short loc_F16F7
jmp loc_F1792
loc_F16F7:
lea rdi, [rsp+108h+var_48]
call _ZNKSt13unordered_mapIimSt4hashIiESt8equal_toIiESaISt4pairIKimEEE4sizeEv; std::unordered_map<int,ulong>::size(void)
add rax, 1
cmp rax, 3Fh ; '?'
jb short loc_F1739
jmp loc_F17AA
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
lea rdi, [rsp+arg_B8]
call _ZNSt13unordered_mapIimSt4hashIiESt8equal_toIiESaISt4pairIKimEEED2Ev; std::unordered_map<int,ulong>::~unordered_map()
jmp loc_F1A88
loc_F1739:
lea rdi, [rsp+108h+var_48]
mov [rsp+108h+var_E8], rdi
call _ZNKSt13unordered_mapIimSt4hashIiESt8equal_toIiESaISt4pairIKimEEE4sizeEv; std::unordered_map<int,ulong>::size(void)
mov rdi, [rsp+108h+var_E8]
mov [rsp+108h+var_88], rax
mov rax, [rsp+108h+var_88]
mov [rsp+108h+var_E0], rax
mov rax, [rsp+108h+var_58]
movsxd rcx, [rsp+108h+var_60]
lea rsi, [rax+rcx*4]
call _ZNSt13unordered_mapIimSt4hashIiESt8equal_toIiESaISt4pairIKimEEEixERS5_; std::unordered_map<int,ulong>::operator[](int const&)
mov [rsp+108h+var_D8], rax
jmp short $+2
loc_F1785:
mov rax, [rsp+108h+var_D8]
mov rcx, [rsp+108h+var_E0]
mov [rax], rcx
loc_F1792:
jmp short $+2
loc_F1794:
mov eax, [rsp+108h+var_60]
add eax, 1
mov [rsp+108h+var_60], eax
jmp loc_F165C
loc_F17AA:
lea rdi, [rsp+108h+var_48]
call _ZNKSt13unordered_mapIimSt4hashIiESt8equal_toIiESaISt4pairIKimEEE4sizeEv; std::unordered_map<int,ulong>::size(void)
add rax, 1
cmp rax, 3Fh ; '?'
jb short loc_F17C3
jmp short loc_F1814
loc_F17C3:
jmp short $+2
loc_F17C5:
mov eax, [rsp+108h+var_5C]
add eax, 1
mov [rsp+108h+var_5C], eax
mov rax, [rsp+108h+var_50]
add rax, 4
mov [rsp+108h+var_50], rax
mov rax, [rsp+108h+var_8]
mov ecx, [rax+4]
mov rax, [rsp+108h+var_58]
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
mov [rsp+108h+var_58], rax
jmp loc_F163A
loc_F1814:
lea rdi, aSequenceLegend; "=== Sequence legend: "
xor eax, eax
call _printf
jmp short $+2
loc_F1824:
lea rax, [rsp+108h+var_48]
mov [rsp+108h+var_90], rax
mov rdi, [rsp+108h+var_90]
call _ZNSt13unordered_mapIimSt4hashIiESt8equal_toIiESaISt4pairIKimEEE5beginEv; std::unordered_map<int,ulong>::begin(void)
mov [rsp+108h+var_98], rax
mov rdi, [rsp+108h+var_90]
call _ZNSt13unordered_mapIimSt4hashIiESt8equal_toIiESaISt4pairIKimEEE3endEv; std::unordered_map<int,ulong>::end(void)
mov [rsp+108h+var_A0], rax
loc_F184F:
lea rdi, [rsp+108h+var_98]
lea rsi, [rsp+108h+var_A0]
call _ZNSt8__detailneERKNS_19_Node_iterator_baseISt4pairIKimELb0EEES6_; std::__detail::operator!=(std::__detail::_Node_iterator_base<std::pair<int const,ulong>,false> const&,std::__detail::_Node_iterator_base<std::pair<int const,ulong>,false> const&)
test al, 1
jnz short loc_F1864
jmp short loc_F189C
loc_F1864:
lea rdi, [rsp+108h+var_98]
call _ZNKSt8__detail14_Node_iteratorISt4pairIKimELb0ELb0EEdeEv; std::__detail::_Node_iterator<std::pair<int const,ulong>,false,false>::operator*(void)
mov [rsp+108h+var_A8], rax
mov rax, [rsp+108h+var_A8]
mov rsi, [rax+8]
mov edx, [rax]
lea rdi, aZuD; "%zu=%d, "
xor eax, eax
call _printf
jmp short $+2
loc_F188E:
jmp short $+2
loc_F1890:
lea rdi, [rsp+108h+var_98]
call _ZNSt8__detail14_Node_iteratorISt4pairIKimELb0ELb0EEppEv; std::__detail::_Node_iterator<std::pair<int const,ulong>,false,false>::operator++(void)
jmp short loc_F184F
loc_F189C:
lea rdi, aOtherSequenceI; "'+'=other sequence ids"
xor eax, eax
call _printf
jmp short $+2
loc_F18AC:
mov rax, [rsp+108h+var_8]
mov rax, [rax+18h]
mov [rsp+108h+var_50], rax
mov rax, [rsp+108h+var_8]
mov rax, [rax+20h]
mov [rsp+108h+var_58], rax
mov [rsp+108h+var_AC], 0
loc_F18DC:
mov eax, [rsp+108h+var_AC]
mov rcx, [rsp+108h+var_8]
cmp eax, [rcx]
jge loc_F1A63
mov eax, [rsp+108h+var_AC]
cdq
idiv [rsp+108h+var_C]
cmp edx, 0
jnz short loc_F1917
mov esi, [rsp+108h+var_AC]
lea rdi, a5d; "\n%5d: "
xor eax, eax
call _printf
jmp short $+2
loc_F1915:
jmp short $+2
loc_F1917:
mov [rsp+108h+var_B0], 0
loc_F191F:
mov eax, [rsp+108h+var_B0]
mov rcx, [rsp+108h+var_8]
cmp eax, [rcx+4]
jge loc_F1A0C
mov rax, [rsp+108h+var_58]
movsxd rcx, [rsp+108h+var_B0]
cmp dword ptr [rax+rcx*4], 0
jl loc_F19EC
mov rax, [rsp+108h+var_58]
movsxd rcx, [rsp+108h+var_B0]
lea rsi, [rax+rcx*4]
lea rdi, [rsp+108h+var_48]
call _ZNSt13unordered_mapIimSt4hashIiESt8equal_toIiESaISt4pairIKimEEE4findERS5_; std::unordered_map<int,ulong>::find(int const&)
mov [rsp+108h+var_F0], rax
jmp short $+2
loc_F1970:
mov rax, [rsp+108h+var_F0]
mov [rsp+108h+var_C0], rax
lea rax, [rsp+108h+var_C0]
mov [rsp+108h+var_B8], rax
mov rax, [rsp+108h+var_B8]
mov [rsp+108h+var_F8], rax
lea rdi, [rsp+108h+var_48]
call _ZNSt13unordered_mapIimSt4hashIiESt8equal_toIiESaISt4pairIKimEEE3endEv; std::unordered_map<int,ulong>::end(void)
mov rdi, [rsp+108h+var_F8]
mov [rsp+108h+var_C8], rax
lea rsi, [rsp+108h+var_C8]
call _ZNSt8__detailneERKNS_19_Node_iterator_baseISt4pairIKimELb0EEES6_; std::__detail::operator!=(std::__detail::_Node_iterator_base<std::pair<int const,ulong>,false> const&,std::__detail::_Node_iterator_base<std::pair<int const,ulong>,false> const&)
test al, 1
jnz short loc_F19B5
jmp short loc_F19D4
loc_F19B5:
mov rdi, [rsp+108h+var_B8]
call _ZNKSt8__detail14_Node_iteratorISt4pairIKimELb0ELb0EEptEv; std::__detail::_Node_iterator<std::pair<int const,ulong>,false,false>::operator->(void)
mov rcx, [rax+8]
lea rax, _ZZ30common_kv_cache_dump_view_seqsRK19llama_kv_cache_viewiE10slot_chars; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabc"...
movsx eax, byte ptr [rax+rcx]
mov [rsp+108h+var_FC], eax
jmp short loc_F19DF
loc_F19D4:
mov eax, 2Bh ; '+'
mov [rsp+108h+var_FC], eax
jmp short $+2
loc_F19DF:
mov edi, [rsp+108h+var_FC]
call _putchar
jmp short $+2
loc_F19EA:
jmp short loc_F19FA
loc_F19EC:
mov edi, 2Eh ; '.'
call _putchar
jmp short $+2
loc_F19F8:
jmp short $+2
loc_F19FA:
jmp short $+2
loc_F19FC:
mov eax, [rsp+108h+var_B0]
add eax, 1
mov [rsp+108h+var_B0], eax
jmp loc_F191F
loc_F1A0C:
mov edi, 20h ; ' '
call _putchar
jmp short $+2
loc_F1A18:
jmp short $+2
loc_F1A1A:
mov eax, [rsp+108h+var_AC]
add eax, 1
mov [rsp+108h+var_AC], eax
mov rax, [rsp+108h+var_50]
add rax, 4
mov [rsp+108h+var_50], rax
mov rax, [rsp+108h+var_8]
mov ecx, [rax+4]
mov rax, [rsp+108h+var_58]
movsxd rcx, ecx
shl rcx, 2
add rax, rcx
mov [rsp+108h+var_58], rax
jmp loc_F18DC
loc_F1A63:
lea rdi, aDoneDumping; "\n=== Done dumping\n"
xor eax, eax
call _printf
jmp short $+2
loc_F1A73:
lea rdi, [rsp+108h+var_48]
call _ZNSt13unordered_mapIimSt4hashIiESt8equal_toIiESaISt4pairIKimEEED2Ev; std::unordered_map<int,ulong>::~unordered_map()
add rsp, 108h
retn
loc_F1A88:
mov rdi, [rsp+arg_90]
call __Unwind_Resume
| long long common_kv_cache_dump_view_seqs(int *a1, int a2)
{
unsigned int v3; // [rsp+Ch] [rbp-FCh]
long long v4; // [rsp+40h] [rbp-C8h] BYREF
long long v5; // [rsp+48h] [rbp-C0h] BYREF
long long *v6; // [rsp+50h] [rbp-B8h]
int j; // [rsp+58h] [rbp-B0h]
int v8; // [rsp+5Ch] [rbp-ACh]
long long v9; // [rsp+60h] [rbp-A8h]
long long v10; // [rsp+68h] [rbp-A0h] BYREF
_QWORD v11[2]; // [rsp+70h] [rbp-98h] BYREF
long long v12; // [rsp+80h] [rbp-88h]
long long v13[3]; // [rsp+88h] [rbp-80h] BYREF
long long v14; // [rsp+A0h] [rbp-68h] BYREF
int i; // [rsp+A8h] [rbp-60h]
int v16; // [rsp+ACh] [rbp-5Ch]
long long v17; // [rsp+B0h] [rbp-58h]
long long v18; // [rsp+B8h] [rbp-50h]
_BYTE v19[60]; // [rsp+C0h] [rbp-48h] BYREF
int v20; // [rsp+FCh] [rbp-Ch]
int *v21; // [rsp+100h] [rbp-8h]
v21 = a1;
v20 = a2;
printf(
"=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, large"
"st empty slot=%d @ %d\n",
*a1,
a1[1],
a1[3],
a1[2],
a1[4],
a1[5]);
std::unordered_map<int,unsigned long>::unordered_map(v19);
v18 = *((_QWORD *)v21 + 3);
v17 = *((_QWORD *)v21 + 4);
v16 = 0;
while ( v16 < *v21 )
{
for ( i = 0; i < v21[1]; ++i )
{
if ( *(int *)(v17 + 4LL * i) >= 0 )
{
v14 = std::unordered_map<int,unsigned long>::find(v19, v17 + 4LL * i);
v13[0] = std::unordered_map<int,unsigned long>::end(v19);
if ( (std::__detail::operator==(&v14, v13) & 1) != 0 )
{
if ( (unsigned long long)(std::unordered_map<int,unsigned long>::size(v19) + 1) >= 0x3F )
break;
v12 = std::unordered_map<int,unsigned long>::size(v19);
*(_QWORD *)std::unordered_map<int,unsigned long>::operator[](v19, v17 + 4LL * i) = v12;
}
}
}
if ( (unsigned long long)(std::unordered_map<int,unsigned long>::size(v19) + 1) >= 0x3F )
break;
++v16;
v18 += 4LL;
v17 += 4LL * v21[1];
}
printf("=== Sequence legend: ");
v11[1] = v19;
v11[0] = std::unordered_map<int,unsigned long>::begin(v19);
v10 = std::unordered_map<int,unsigned long>::end(v19);
while ( (std::__detail::operator!=(v11, &v10) & 1) != 0 )
{
v9 = std::__detail::_Node_iterator<std::pair<int const,unsigned long>,false,false>::operator*(v11);
printf("%zu=%d, ", *(_QWORD *)(v9 + 8), *(_DWORD *)v9);
std::__detail::_Node_iterator<std::pair<int const,unsigned long>,false,false>::operator++(v11);
}
printf("'+'=other sequence ids");
v18 = *((_QWORD *)v21 + 3);
v17 = *((_QWORD *)v21 + 4);
v8 = 0;
while ( v8 < *v21 )
{
if ( !(v8 % v20) )
printf("\n%5d: ", v8);
for ( j = 0; j < v21[1]; ++j )
{
if ( *(int *)(v17 + 4LL * j) < 0 )
{
putchar(46LL);
}
else
{
v5 = std::unordered_map<int,unsigned long>::find(v19, v17 + 4LL * j);
v6 = &v5;
v4 = std::unordered_map<int,unsigned long>::end(v19);
if ( (std::__detail::operator!=(&v5, &v4) & 1) != 0 )
v3 = common_kv_cache_dump_view_seqs(llama_kv_cache_view const&,int)::slot_chars[*(_QWORD *)(std::__detail::_Node_iterator<std::pair<int const,unsigned long>,false,false>::operator->(v6) + 8)];
else
v3 = 43;
putchar(v3);
}
}
putchar(32LL);
++v8;
v18 += 4LL;
v17 += 4LL * v21[1];
}
printf("\n=== Done dumping\n");
return std::unordered_map<int,unsigned long>::~unordered_map(v19);
}
| common_kv_cache_dump_view_seqs:
SUB RSP,0x108
MOV qword ptr [RSP + 0x100],RDI
MOV dword ptr [RSP + 0xfc],ESI
MOV RAX,qword ptr [RSP + 0x100]
MOV ESI,dword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x100]
MOV EDX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RSP + 0x100]
MOV ECX,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RSP + 0x100]
MOV R8D,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RSP + 0x100]
MOV R9D,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RSP + 0x100]
MOV EAX,dword ptr [RAX + 0x14]
LEA RDI,[0x30ddb3]
MOV dword ptr [RSP],EAX
MOV AL,0x0
CALL 0x001590f0
LEA RDI,[RSP + 0xc0]
CALL 0x001ff9c0
MOV RAX,qword ptr [RSP + 0x100]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0x100]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RSP + 0xb0],RAX
MOV dword ptr [RSP + 0xac],0x0
LAB_001f163a:
MOV EAX,dword ptr [RSP + 0xac]
MOV RCX,qword ptr [RSP + 0x100]
CMP EAX,dword ptr [RCX]
JGE 0x001f1814
MOV dword ptr [RSP + 0xa8],0x0
LAB_001f165c:
MOV EAX,dword ptr [RSP + 0xa8]
MOV RCX,qword ptr [RSP + 0x100]
CMP EAX,dword ptr [RCX + 0x4]
JGE 0x001f17aa
MOV RAX,qword ptr [RSP + 0xb0]
MOVSXD RCX,dword ptr [RSP + 0xa8]
CMP dword ptr [RAX + RCX*0x4],0x0
JGE 0x001f168f
JMP 0x001f1794
LAB_001f168f:
MOV RAX,qword ptr [RSP + 0xb0]
MOVSXD RCX,dword ptr [RSP + 0xa8]
LEA RSI,[RAX + RCX*0x4]
LAB_001f16a3:
LEA RDI,[RSP + 0xc0]
CALL 0x001ff9f0
MOV qword ptr [RSP + 0x38],RAX
JMP 0x001f16b7
LAB_001f16b7:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0xa0],RAX
LEA RDI,[RSP + 0xc0]
CALL 0x001ffa20
MOV qword ptr [RSP + 0x88],RAX
LEA RDI,[RSP + 0xa0]
LEA RSI,[RSP + 0x88]
CALL 0x001ff9d0
TEST AL,0x1
JNZ 0x001f16f7
JMP 0x001f1792
LAB_001f16f7:
LEA RDI,[RSP + 0xc0]
CALL 0x001ffa50
ADD RAX,0x1
CMP RAX,0x3f
JC 0x001f1739
JMP 0x001f17aa
LAB_001f1739:
LEA RDI,[RSP + 0xc0]
MOV qword ptr [RSP + 0x20],RDI
CALL 0x001ffa50
MOV RDI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOVSXD RCX,dword ptr [RSP + 0xa8]
LEA RSI,[RAX + RCX*0x4]
CALL 0x001ffa60
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001f1785
LAB_001f1785:
MOV RAX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX],RCX
LAB_001f1792:
JMP 0x001f1794
LAB_001f1794:
MOV EAX,dword ptr [RSP + 0xa8]
ADD EAX,0x1
MOV dword ptr [RSP + 0xa8],EAX
JMP 0x001f165c
LAB_001f17aa:
LEA RDI,[RSP + 0xc0]
CALL 0x001ffa50
ADD RAX,0x1
CMP RAX,0x3f
JC 0x001f17c3
JMP 0x001f1814
LAB_001f17c3:
JMP 0x001f17c5
LAB_001f17c5:
MOV EAX,dword ptr [RSP + 0xac]
ADD EAX,0x1
MOV dword ptr [RSP + 0xac],EAX
MOV RAX,qword ptr [RSP + 0xb8]
ADD RAX,0x4
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0x100]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RSP + 0xb0]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RSP + 0xb0],RAX
JMP 0x001f163a
LAB_001f1814:
LEA RDI,[0x30de3e]
XOR EAX,EAX
CALL 0x001590f0
JMP 0x001f1824
LAB_001f1824:
LEA RAX,[RSP + 0xc0]
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0x78]
CALL 0x001ffa90
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0x78]
CALL 0x001ffa20
MOV qword ptr [RSP + 0x68],RAX
LAB_001f184f:
LEA RDI,[RSP + 0x70]
LEA RSI,[RSP + 0x68]
CALL 0x001ffac0
TEST AL,0x1
JNZ 0x001f1864
JMP 0x001f189c
LAB_001f1864:
LEA RDI,[RSP + 0x70]
CALL 0x001ffae0
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RAX + 0x8]
MOV EDX,dword ptr [RAX]
LEA RDI,[0x30de54]
XOR EAX,EAX
CALL 0x001590f0
JMP 0x001f188e
LAB_001f188e:
JMP 0x001f1890
LAB_001f1890:
LEA RDI,[RSP + 0x70]
CALL 0x001ffb00
JMP 0x001f184f
LAB_001f189c:
LEA RDI,[0x30de5d]
XOR EAX,EAX
CALL 0x001590f0
JMP 0x001f18ac
LAB_001f18ac:
MOV RAX,qword ptr [RSP + 0x100]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0x100]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RSP + 0xb0],RAX
MOV dword ptr [RSP + 0x5c],0x0
LAB_001f18dc:
MOV EAX,dword ptr [RSP + 0x5c]
MOV RCX,qword ptr [RSP + 0x100]
CMP EAX,dword ptr [RCX]
JGE 0x001f1a63
MOV EAX,dword ptr [RSP + 0x5c]
CDQ
IDIV dword ptr [RSP + 0xfc]
CMP EDX,0x0
JNZ 0x001f1917
MOV ESI,dword ptr [RSP + 0x5c]
LEA RDI,[0x30dd99]
XOR EAX,EAX
CALL 0x001590f0
JMP 0x001f1915
LAB_001f1915:
JMP 0x001f1917
LAB_001f1917:
MOV dword ptr [RSP + 0x58],0x0
LAB_001f191f:
MOV EAX,dword ptr [RSP + 0x58]
MOV RCX,qword ptr [RSP + 0x100]
CMP EAX,dword ptr [RCX + 0x4]
JGE 0x001f1a0c
MOV RAX,qword ptr [RSP + 0xb0]
MOVSXD RCX,dword ptr [RSP + 0x58]
CMP dword ptr [RAX + RCX*0x4],0x0
JL 0x001f19ec
MOV RAX,qword ptr [RSP + 0xb0]
MOVSXD RCX,dword ptr [RSP + 0x58]
LEA RSI,[RAX + RCX*0x4]
LEA RDI,[RSP + 0xc0]
CALL 0x001ff9f0
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001f1970
LAB_001f1970:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x48],RAX
LEA RAX,[RSP + 0x48]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0xc0]
CALL 0x001ffa20
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x40],RAX
LEA RSI,[RSP + 0x40]
CALL 0x001ffac0
TEST AL,0x1
JNZ 0x001f19b5
JMP 0x001f19d4
LAB_001f19b5:
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x001ffb30
MOV RCX,qword ptr [RAX + 0x8]
LEA RAX,[0x30cac0]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RSP + 0xc],EAX
JMP 0x001f19df
LAB_001f19d4:
MOV EAX,0x2b
MOV dword ptr [RSP + 0xc],EAX
JMP 0x001f19df
LAB_001f19df:
MOV EDI,dword ptr [RSP + 0xc]
CALL 0x0015a300
JMP 0x001f19ea
LAB_001f19ea:
JMP 0x001f19fa
LAB_001f19ec:
MOV EDI,0x2e
CALL 0x0015a300
JMP 0x001f19f8
LAB_001f19f8:
JMP 0x001f19fa
LAB_001f19fa:
JMP 0x001f19fc
LAB_001f19fc:
MOV EAX,dword ptr [RSP + 0x58]
ADD EAX,0x1
MOV dword ptr [RSP + 0x58],EAX
JMP 0x001f191f
LAB_001f1a0c:
MOV EDI,0x20
CALL 0x0015a300
JMP 0x001f1a18
LAB_001f1a18:
JMP 0x001f1a1a
LAB_001f1a1a:
MOV EAX,dword ptr [RSP + 0x5c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x5c],EAX
MOV RAX,qword ptr [RSP + 0xb8]
ADD RAX,0x4
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0x100]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RSP + 0xb0]
MOVSXD RCX,ECX
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RSP + 0xb0],RAX
JMP 0x001f18dc
LAB_001f1a63:
LEA RDI,[0x30dda0]
XOR EAX,EAX
CALL 0x001590f0
LAB_001f1a71:
JMP 0x001f1a73
LAB_001f1a73:
LEA RDI,[RSP + 0xc0]
CALL 0x001ffb50
ADD RSP,0x108
RET
|
/* common_kv_cache_dump_view_seqs(llama_kv_cache_view const&, int) */
void common_kv_cache_dump_view_seqs(llama_kv_cache_view *param_1,int param_2)
{
ulong uVar1;
long lVar2;
int8 uVar3;
int8 *puVar4;
int local_fc;
int8 local_c8;
int8 local_c0;
_Node_iterator_base *local_b8;
int local_b0;
uint local_ac;
uint *local_a8;
int8 local_a0;
int8 local_98;
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
*local_90;
int8 local_88;
int8 local_80 [3];
int8 local_68;
int local_60;
int local_5c;
long local_58;
long local_50;
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
local_48 [60];
int local_c;
llama_kv_cache_view *local_8;
local_c = param_2;
local_8 = param_1;
printf("=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, largest empty slot=%d @ %d\n"
,(ulong)*(uint *)param_1,(ulong)*(uint *)(param_1 + 4),(ulong)*(uint *)(param_1 + 0xc),
(ulong)*(uint *)(param_1 + 8),(ulong)*(uint *)(param_1 + 0x10),
*(int4 *)(param_1 + 0x14));
std::
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::unordered_map(local_48);
local_50 = *(long *)(local_8 + 0x18);
local_58 = *(long *)(local_8 + 0x20);
for (local_5c = 0; local_5c < *(int *)local_8; local_5c = local_5c + 1) {
for (local_60 = 0; local_60 < *(int *)(local_8 + 4); local_60 = local_60 + 1) {
if (-1 < *(int *)(local_58 + (long)local_60 * 4)) {
/* try { // try from 001f16a3 to 001f1a70 has its CatchHandler @ 001f1713 */
local_68 = std::
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::find(local_48,(int *)(local_58 + (long)local_60 * 4));
local_80[0] = std::
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::end();
uVar1 = std::__detail::operator==
((_Node_iterator_base *)&local_68,(_Node_iterator_base *)local_80);
if ((uVar1 & 1) != 0) {
lVar2 = std::
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::size(local_48);
if (0x3e < lVar2 + 1U) break;
uVar3 = std::
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::size(local_48);
local_88 = uVar3;
puVar4 = (int8 *)
std::
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::operator[](local_48,(int *)(local_58 + (long)local_60 * 4));
*puVar4 = uVar3;
}
}
}
lVar2 = std::
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::size(local_48);
if (0x3e < lVar2 + 1U) break;
local_50 = local_50 + 4;
local_58 = local_58 + (long)*(int *)(local_8 + 4) * 4;
}
printf("=== Sequence legend: ");
local_90 = local_48;
local_98 = std::
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::begin(local_90);
local_a0 = std::
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::end();
while (uVar1 = std::__detail::operator!=
((_Node_iterator_base *)&local_98,(_Node_iterator_base *)&local_a0),
(uVar1 & 1) != 0) {
local_a8 = (uint *)std::__detail::_Node_iterator<std::pair<int_const,unsigned_long>,false,false>
::operator*((_Node_iterator<std::pair<int_const,unsigned_long>,false,false> *
)&local_98);
printf("%zu=%d, ",*(int8 *)(local_a8 + 2),(ulong)*local_a8);
std::__detail::_Node_iterator<std::pair<int_const,unsigned_long>,false,false>::operator++
((_Node_iterator<std::pair<int_const,unsigned_long>,false,false> *)&local_98);
}
printf("\'+\'=other sequence ids");
local_50 = *(long *)(local_8 + 0x18);
local_58 = *(long *)(local_8 + 0x20);
for (local_ac = 0; (int)local_ac < *(int *)local_8; local_ac = local_ac + 1) {
if ((int)local_ac % local_c == 0) {
printf("\n%5d: ",(ulong)local_ac);
}
for (local_b0 = 0; local_b0 < *(int *)(local_8 + 4); local_b0 = local_b0 + 1) {
if (*(int *)(local_58 + (long)local_b0 * 4) < 0) {
putchar(0x2e);
}
else {
local_c0 = std::
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::find(local_48,(int *)(local_58 + (long)local_b0 * 4));
local_b8 = (_Node_iterator_base *)&local_c0;
local_c8 = std::
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::end();
uVar1 = std::__detail::operator!=
((_Node_iterator_base *)&local_c0,(_Node_iterator_base *)&local_c8);
if ((uVar1 & 1) == 0) {
local_fc = 0x2b;
}
else {
lVar2 = std::__detail::_Node_iterator<std::pair<int_const,unsigned_long>,false,false>::
operator->((_Node_iterator<std::pair<int_const,unsigned_long>,false,false> *)
local_b8);
local_fc = (int)"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
[*(long *)(lVar2 + 8)];
}
putchar(local_fc);
}
}
putchar(0x20);
local_50 = local_50 + 4;
local_58 = local_58 + (long)*(int *)(local_8 + 4) * 4;
}
printf("\n=== Done dumping\n");
std::
unordered_map<int,unsigned_long,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,unsigned_long>>>
::~unordered_map(local_48);
return;
}
| |
50,636 | ma_ft_segiterator_init | eloqsql/storage/maria/ma_ft_update.c | void _ma_ft_segiterator_init(MARIA_HA *info, uint keynr, const uchar *record,
FT_SEG_ITERATOR *ftsi)
{
DBUG_ENTER("_ma_ft_segiterator_init");
ftsi->num=info->s->keyinfo[keynr].keysegs;
ftsi->seg=info->s->keyinfo[keynr].seg;
ftsi->rec=record;
ftsi->pos= 0; /* Avoid warnings from gcc */
ftsi->len= 0; /* Avoid warnings from gcc */
DBUG_VOID_RETURN;
} | O0 | c | ma_ft_segiterator_init:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movzwl 0xa0(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movq 0xc0(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0x78a8a
popq %rbp
retq
nopl (%rax)
| _ma_ft_segiterator_init:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+570h]
mov ecx, [rbp+var_C]
imul rcx, 118h
add rax, rcx
movzx ecx, word ptr [rax+0A0h]
mov rax, [rbp+var_20]
mov [rax], ecx
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+570h]
mov ecx, [rbp+var_C]
imul rcx, 118h
add rax, rcx
mov rcx, [rax+0C0h]
mov rax, [rbp+var_20]
mov [rax+8], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+10h], rcx
mov rax, [rbp+var_20]
mov qword ptr [rax+18h], 0
mov rax, [rbp+var_20]
mov dword ptr [rax+4], 0
jmp short $+2
loc_78A8A:
pop rbp
retn
| long long ma_ft_segiterator_init(long long a1, unsigned int a2, long long a3, long long a4)
{
long long result; // rax
*(_DWORD *)a4 = *(unsigned __int16 *)(280LL * a2 + *(_QWORD *)(*(_QWORD *)a1 + 1392LL) + 160);
*(_QWORD *)(a4 + 8) = *(_QWORD *)(280LL * a2 + *(_QWORD *)(*(_QWORD *)a1 + 1392LL) + 192);
*(_QWORD *)(a4 + 16) = a3;
*(_QWORD *)(a4 + 24) = 0LL;
result = a4;
*(_DWORD *)(a4 + 4) = 0;
return result;
}
| _ma_ft_segiterator_init:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,dword ptr [RBP + -0xc]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOVZX ECX,word ptr [RAX + 0xa0]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,dword ptr [RBP + -0xc]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOV RCX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x18],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x4],0x0
JMP 0x00178a8a
LAB_00178a8a:
POP RBP
RET
|
void _ma_ft_segiterator_init(long *param_1,uint param_2,int8 param_3,uint *param_4)
{
*param_4 = (uint)*(ushort *)(*(long *)(*param_1 + 0x570) + (ulong)param_2 * 0x118 + 0xa0);
*(int8 *)(param_4 + 2) =
*(int8 *)(*(long *)(*param_1 + 0x570) + (ulong)param_2 * 0x118 + 0xc0);
*(int8 *)(param_4 + 4) = param_3;
param_4[6] = 0;
param_4[7] = 0;
param_4[1] = 0;
return;
}
| |
50,637 | FileWriterText::writeFileSkipped(std::filesystem::__cxx11::path const&, std::filesystem::__cxx11::path const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | shubhamoy[P]dir2txt/src/FileWriterText.cpp | void FileWriterText::writeFileSkipped(const std::filesystem::path& filePath,
const std::filesystem::path& rootPath,
const std::string& reason) {
std::string relPath = std::filesystem::relative(filePath, rootPath).string();
out << "\n";
out << "==============================\n";
out << "📄 File: " << relPath << "\n";
out << "------------------------------\n";
out << reason << "\n";
out << "------------------------------\n";
out << "📄 End: " << relPath << "\n";
out << "==============================\n";
} | O0 | cpp | FileWriterText::writeFileSkipped(std::filesystem::__cxx11::path const&, std::filesystem::__cxx11::path const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xa3c0
movq -0x80(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x5ff60
jmp 0x6373a
leaq -0x68(%rbp), %rdi
callq 0xbd30
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
leaq 0x2e88b(%rip), %rsi # 0x91fe0
callq 0xa400
jmp 0x6375c
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
leaq 0x2e876(%rip), %rsi # 0x91fe4
callq 0xa400
jmp 0x63775
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
leaq 0x2e888(%rip), %rsi # 0x9200f
callq 0xa400
movq %rax, -0x90(%rbp)
jmp 0x63795
movq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xa3e0
movq %rax, -0x98(%rbp)
jmp 0x637ae
movq -0x98(%rbp), %rdi
leaq 0x2e824(%rip), %rsi # 0x91fe0
callq 0xa400
jmp 0x637c3
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
leaq 0x2e846(%rip), %rsi # 0x9201b
callq 0xa400
jmp 0x637dc
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0xa3e0
movq %rax, -0xa0(%rbp)
jmp 0x637f9
movq -0xa0(%rbp), %rdi
leaq 0x2e7d9(%rip), %rsi # 0x91fe0
callq 0xa400
jmp 0x6380e
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
leaq 0x2e7fb(%rip), %rsi # 0x9201b
callq 0xa400
jmp 0x63827
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
leaq 0x2e819(%rip), %rsi # 0x92052
callq 0xa400
movq %rax, -0xa8(%rbp)
jmp 0x63847
movq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xa3e0
movq %rax, -0xb0(%rbp)
jmp 0x63860
movq -0xb0(%rbp), %rdi
leaq 0x2e772(%rip), %rsi # 0x91fe0
callq 0xa400
jmp 0x63875
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
leaq 0x2e75d(%rip), %rsi # 0x91fe4
callq 0xa400
jmp 0x6388e
leaq -0x40(%rbp), %rdi
callq 0xb6c0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xbd30
jmp 0x638cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xb6c0
movq -0x70(%rbp), %rdi
callq 0xa6c0
nopw %cs:(%rax,%rax)
nop
| _ZN14FileWriterText16writeFileSkippedERKNSt10filesystem7__cxx114pathES4_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_8]
mov [rbp+var_88], rax
mov rsi, [rbp+var_10]; std::filesystem::__cxx11::path *
mov rdx, [rbp+var_18]; std::filesystem::__cxx11::path *
lea rdi, [rbp+var_68]; this
mov [rbp+var_80], rdi
call __ZNSt10filesystem8relativeERKNS_7__cxx114pathES3_; std::filesystem::relative(std::filesystem::__cxx11::path const&,std::filesystem::__cxx11::path const&)
mov rsi, [rbp+var_80]
lea rdi, [rbp+var_40]; this
call _ZNKSt10filesystem7__cxx114path6stringEv; std::filesystem::__cxx11::path::string(void)
jmp short $+2
loc_6373A:
lea rdi, [rbp+var_68]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
mov rdi, [rbp+var_88]
add rdi, 8
lea rsi, asc_91FC1+1Fh; "\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_6375C:
mov rdi, [rbp+var_88]
add rdi, 8
lea rsi, asc_91FE2+2; "==============================\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_63775:
mov rdi, [rbp+var_88]
add rdi, 8
lea rsi, unk_9200F
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_90], rax
jmp short $+2
loc_63795:
mov rdi, [rbp+var_90]
lea rsi, [rbp+var_40]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rbp+var_98], rax
jmp short $+2
loc_637AE:
mov rdi, [rbp+var_98]
lea rsi, asc_91FC1+1Fh; "\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_637C3:
mov rdi, [rbp+var_88]
add rdi, 8
lea rsi, asc_9201B; "------------------------------\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_637DC:
mov rdi, [rbp+var_88]
add rdi, 8
mov rsi, [rbp+var_20]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rbp+var_A0], rax
jmp short $+2
loc_637F9:
mov rdi, [rbp+var_A0]
lea rsi, asc_91FC1+1Fh; "\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_6380E:
mov rdi, [rbp+var_88]
add rdi, 8
lea rsi, asc_9201B; "------------------------------\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_63827:
mov rdi, [rbp+var_88]
add rdi, 8
lea rsi, unk_92052
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_A8], rax
jmp short $+2
loc_63847:
mov rdi, [rbp+var_A8]
lea rsi, [rbp+var_40]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rbp+var_B0], rax
jmp short $+2
loc_63860:
mov rdi, [rbp+var_B0]
lea rsi, asc_91FC1+1Fh; "\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_63875:
mov rdi, [rbp+var_88]
add rdi, 8
lea rsi, asc_91FE2+2; "==============================\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_6388E:
lea rdi, [rbp+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add rsp, 0B0h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_70], rcx
mov [rbp+var_74], eax
lea rdi, [rbp+var_68]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
jmp short loc_638CC
mov rcx, rax
mov eax, edx
mov [rbp+var_70], rcx
mov [rbp+var_74], eax
lea rdi, [rbp+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_638CC:
mov rdi, [rbp+var_70]
call __Unwind_Resume
| void FileWriterText::writeFileSkipped(
long long a1,
std::filesystem::__cxx11::path *a2,
std::filesystem::__cxx11::path *a3,
long long a4)
{
long long v4; // rdx
long long v5; // rdx
long long v6; // rdx
long long v7; // rdx
long long v8; // rdx
long long v9; // rdx
long long v10; // rdx
long long v11; // rdx
long long v12; // rdx
long long v13; // rdx
long long v14; // [rsp+0h] [rbp-B0h]
long long v15; // [rsp+8h] [rbp-A8h]
long long v16; // [rsp+10h] [rbp-A0h]
long long v17; // [rsp+18h] [rbp-98h]
long long v18; // [rsp+20h] [rbp-90h]
_BYTE v19[40]; // [rsp+48h] [rbp-68h] BYREF
_BYTE v20[32]; // [rsp+70h] [rbp-40h] BYREF
long long v21; // [rsp+90h] [rbp-20h]
std::filesystem::__cxx11::path *v22; // [rsp+98h] [rbp-18h]
std::filesystem::__cxx11::path *v23; // [rsp+A0h] [rbp-10h]
long long v24; // [rsp+A8h] [rbp-8h]
v24 = a1;
v23 = a2;
v22 = a3;
v21 = a4;
std::filesystem::relative((std::filesystem *)v19, a2, a3);
std::filesystem::__cxx11::path::string((std::filesystem::__cxx11::path *)v20, (long long)v19);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v19);
std::operator<<<std::char_traits<char>>(a1 + 8, "\n", v4);
std::operator<<<std::char_traits<char>>(a1 + 8, "==============================\n", v5);
v18 = std::operator<<<std::char_traits<char>>(a1 + 8, &unk_9200F, v6);
v17 = std::operator<<<char>(v18, v20);
std::operator<<<std::char_traits<char>>(v17, "\n", v7);
std::operator<<<std::char_traits<char>>(a1 + 8, "------------------------------\n", v8);
v16 = std::operator<<<char>(a1 + 8, v21);
std::operator<<<std::char_traits<char>>(v16, "\n", v9);
std::operator<<<std::char_traits<char>>(a1 + 8, "------------------------------\n", v10);
v15 = std::operator<<<std::char_traits<char>>(a1 + 8, &unk_92052, v11);
v14 = std::operator<<<char>(v15, v20);
std::operator<<<std::char_traits<char>>(v14, "\n", v12);
std::operator<<<std::char_traits<char>>(a1 + 8, "==============================\n", v13);
std::string::~string(v20);
}
| writeFileSkipped:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
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 RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x88],RAX
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x68]
MOV qword ptr [RBP + -0x80],RDI
CALL 0x0010a3c0
MOV RSI,qword ptr [RBP + -0x80]
LAB_0016372f:
LEA RDI,[RBP + -0x40]
CALL 0x0015ff60
JMP 0x0016373a
LAB_0016373a:
LEA RDI,[RBP + -0x68]
CALL 0x0010bd30
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x8
LAB_0016374e:
LEA RSI,[0x191fe0]
CALL 0x0010a400
JMP 0x0016375c
LAB_0016375c:
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x8
LEA RSI,[0x191fe4]
CALL 0x0010a400
JMP 0x00163775
LAB_00163775:
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x8
LEA RSI,[0x19200f]
CALL 0x0010a400
MOV qword ptr [RBP + -0x90],RAX
JMP 0x00163795
LAB_00163795:
MOV RDI,qword ptr [RBP + -0x90]
LEA RSI,[RBP + -0x40]
CALL 0x0010a3e0
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001637ae
LAB_001637ae:
MOV RDI,qword ptr [RBP + -0x98]
LEA RSI,[0x191fe0]
CALL 0x0010a400
JMP 0x001637c3
LAB_001637c3:
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x8
LEA RSI,[0x19201b]
CALL 0x0010a400
JMP 0x001637dc
LAB_001637dc:
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0010a3e0
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001637f9
LAB_001637f9:
MOV RDI,qword ptr [RBP + -0xa0]
LEA RSI,[0x191fe0]
CALL 0x0010a400
JMP 0x0016380e
LAB_0016380e:
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x8
LEA RSI,[0x19201b]
CALL 0x0010a400
JMP 0x00163827
LAB_00163827:
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x8
LEA RSI,[0x192052]
CALL 0x0010a400
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x00163847
LAB_00163847:
MOV RDI,qword ptr [RBP + -0xa8]
LEA RSI,[RBP + -0x40]
CALL 0x0010a3e0
MOV qword ptr [RBP + -0xb0],RAX
JMP 0x00163860
LAB_00163860:
MOV RDI,qword ptr [RBP + -0xb0]
LEA RSI,[0x191fe0]
CALL 0x0010a400
JMP 0x00163875
LAB_00163875:
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x8
LEA RSI,[0x191fe4]
CALL 0x0010a400
LAB_0016388c:
JMP 0x0016388e
LAB_0016388e:
LEA RDI,[RBP + -0x40]
CALL 0x0010b6c0
ADD RSP,0xb0
POP RBP
RET
|
/* FileWriterText::writeFileSkipped(std::filesystem::__cxx11::path const&,
std::filesystem::__cxx11::path const&, std::__cxx11::string const&) */
void __thiscall
FileWriterText::writeFileSkipped(FileWriterText *this,path *param_1,path *param_2,string *param_3)
{
ostream *poVar1;
path local_70 [40];
string local_48 [32];
string *local_28;
path *local_20;
path *local_18;
FileWriterText *local_10;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_10 = this;
std::filesystem::relative(local_70,param_1);
/* try { // try from 0016372f to 00163737 has its CatchHandler @ 001638a0 */
std::filesystem::__cxx11::path::string();
std::filesystem::__cxx11::path::~path(local_70);
/* try { // try from 0016374e to 0016388b has its CatchHandler @ 001638b7 */
std::operator<<((ostream *)(this + 8),"\n");
std::operator<<((ostream *)(this + 8),"==============================\n");
poVar1 = std::operator<<((ostream *)(this + 8),&DAT_0019200f);
poVar1 = std::operator<<(poVar1,local_48);
std::operator<<(poVar1,"\n");
std::operator<<((ostream *)(this + 8),"------------------------------\n");
poVar1 = std::operator<<((ostream *)(this + 8),local_28);
std::operator<<(poVar1,"\n");
std::operator<<((ostream *)(this + 8),"------------------------------\n");
poVar1 = std::operator<<((ostream *)(this + 8),&DAT_00192052);
poVar1 = std::operator<<(poVar1,local_48);
std::operator<<(poVar1,"\n");
std::operator<<((ostream *)(this + 8),"==============================\n");
std::__cxx11::string::~string(local_48);
return;
}
| |
50,638 | FileWriterText::writeFileSkipped(std::filesystem::__cxx11::path const&, std::filesystem::__cxx11::path const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | shubhamoy[P]dir2txt/src/FileWriterText.cpp | void FileWriterText::writeFileSkipped(const std::filesystem::path& filePath,
const std::filesystem::path& rootPath,
const std::string& reason) {
std::string relPath = std::filesystem::relative(filePath, rootPath).string();
out << "\n";
out << "==============================\n";
out << "📄 File: " << relPath << "\n";
out << "------------------------------\n";
out << reason << "\n";
out << "------------------------------\n";
out << "📄 End: " << relPath << "\n";
out << "==============================\n";
} | O1 | cpp | FileWriterText::writeFileSkipped(std::filesystem::__cxx11::path const&, std::filesystem::__cxx11::path const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x8320
movq (%r15), %rsi
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x9a84
leaq 0x20(%rsp), %rdi
callq 0x9990
addq $0x8, %rbx
leaq 0xf68b(%rip), %rsi # 0x36f3e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8400
leaq 0xf67b(%rip), %rsi # 0x36f42
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x8400
leaq 0xf692(%rip), %rsi # 0x36f6d
movl $0xb, %edx
movq %rbx, %rdi
callq 0x8400
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8400
leaq 0xf63e(%rip), %rsi # 0x36f3e
movl $0x1, %edx
movq %rax, %rdi
callq 0x8400
leaq 0xf665(%rip), %rsi # 0x36f79
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x8400
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x8400
leaq 0xf607(%rip), %rsi # 0x36f3e
movl $0x1, %edx
movq %rax, %rdi
callq 0x8400
leaq 0xf62e(%rip), %rsi # 0x36f79
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x8400
leaq 0xf651(%rip), %rsi # 0x36fb0
movl $0xa, %edx
movq %rbx, %rdi
callq 0x8400
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8400
leaq 0xf5ba(%rip), %rsi # 0x36f3e
movl $0x1, %edx
movq %rax, %rdi
callq 0x8400
leaq 0xf5aa(%rip), %rsi # 0x36f42
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x8400
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x279bb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8380
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9990
jmp 0x279ef
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x279ef
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8380
movq %rbx, %rdi
callq 0x85d0
nop
| _ZN14FileWriterText16writeFileSkippedERKNSt10filesystem7__cxx114pathES4_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r12
push rbx
sub rsp, 48h
mov r14, rcx
mov rbx, rdi
lea r15, [rsp+68h+var_48]
mov rdi, r15; this
call __ZNSt10filesystem8relativeERKNS_7__cxx114pathES3_; std::filesystem::relative(std::filesystem::__cxx11::path const&,std::filesystem::__cxx11::path const&)
mov rsi, [r15]
lea r12, [rsp+68h+var_58]
mov [r12-10h], r12
mov rdx, [r15+8]
add rdx, rsi
mov rdi, rsp
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 rdi, [rsp+68h+var_48]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
add rbx, 8
lea rsi, asc_36F1F+1Fh; "\n"
mov edx, 1
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, asc_36F40+2; "==============================\n"
mov edx, 1Fh
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, unk_36F6D
mov edx, 0Bh
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rsp+68h+var_68]
mov rdx, [rsp+68h+var_60]
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, asc_36F1F+1Fh; "\n"
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, asc_36F79; "------------------------------\n"
mov edx, 1Fh
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, asc_36F1F+1Fh; "\n"
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, asc_36F79; "------------------------------\n"
mov edx, 1Fh
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, unk_36FB0
mov edx, 0Ah
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rsp+68h+var_68]
mov rdx, [rsp+68h+var_60]
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, asc_36F1F+1Fh; "\n"
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, asc_36F40+2; "==============================\n"
mov edx, 1Fh
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r12
jz short loc_279BB
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_279BB:
add rsp, 48h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_18]; this
call _ZNSt10filesystem7__cxx114pathD2Ev; std::filesystem::__cxx11::path::~path()
jmp short loc_279EF
mov rbx, rax
mov rdi, [rsp+0]; void *
cmp rdi, r12
jz short loc_279EF
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_279EF:
mov rdi, rbx
call __Unwind_Resume
| void FileWriterText::writeFileSkipped(
long long a1,
const std::filesystem::__cxx11::path *a2,
const std::filesystem::__cxx11::path *a3,
_QWORD *a4)
{
long long v5; // rax
long long v6; // rax
long long v7; // rax
void *v8; // [rsp+0h] [rbp-68h] BYREF
long long v9; // [rsp+8h] [rbp-60h]
_QWORD v10[2]; // [rsp+10h] [rbp-58h] BYREF
_BYTE *v11[9]; // [rsp+20h] [rbp-48h] BYREF
std::filesystem::relative((std::filesystem *)v11, a2, a3);
v8 = v10;
std::string::_M_construct<char const*>(&v8, v11[0], (long long)&v11[0][(unsigned long long)v11[1]]);
std::filesystem::__cxx11::path::~path((std::filesystem::__cxx11::path *)v11);
std::__ostream_insert<char,std::char_traits<char>>(a1 + 8, "\n", 1LL);
std::__ostream_insert<char,std::char_traits<char>>(a1 + 8, "==============================\n", 31LL);
std::__ostream_insert<char,std::char_traits<char>>(a1 + 8, &unk_36F6D, 11LL);
v5 = std::__ostream_insert<char,std::char_traits<char>>(a1 + 8, v8, v9);
std::__ostream_insert<char,std::char_traits<char>>(v5, "\n", 1LL);
std::__ostream_insert<char,std::char_traits<char>>(a1 + 8, "------------------------------\n", 31LL);
v6 = std::__ostream_insert<char,std::char_traits<char>>(a1 + 8, *a4, a4[1]);
std::__ostream_insert<char,std::char_traits<char>>(v6, "\n", 1LL);
std::__ostream_insert<char,std::char_traits<char>>(a1 + 8, "------------------------------\n", 31LL);
std::__ostream_insert<char,std::char_traits<char>>(a1 + 8, &unk_36FB0, 10LL);
v7 = std::__ostream_insert<char,std::char_traits<char>>(a1 + 8, v8, v9);
std::__ostream_insert<char,std::char_traits<char>>(v7, "\n", 1LL);
std::__ostream_insert<char,std::char_traits<char>>(a1 + 8, "==============================\n", 31LL);
if ( v8 != v10 )
operator delete(v8, v10[0] + 1LL);
}
| writeFileSkipped:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RCX
MOV RBX,RDI
LEA R15,[RSP + 0x20]
MOV RDI,R15
CALL 0x00108320
MOV RSI,qword ptr [R15]
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
MOV RDX,qword ptr [R15 + 0x8]
ADD RDX,RSI
LAB_00127896:
MOV RDI,RSP
CALL 0x00109a84
LEA RDI,[RSP + 0x20]
CALL 0x00109990
ADD RBX,0x8
LAB_001278ac:
LEA RSI,[0x136f3e]
MOV EDX,0x1
MOV RDI,RBX
CALL 0x00108400
LEA RSI,[0x136f42]
MOV EDX,0x1f
MOV RDI,RBX
CALL 0x00108400
LEA RSI,[0x136f6d]
MOV EDX,0xb
MOV RDI,RBX
CALL 0x00108400
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,RBX
CALL 0x00108400
LEA RSI,[0x136f3e]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00108400
LEA RSI,[0x136f79]
MOV EDX,0x1f
MOV RDI,RBX
CALL 0x00108400
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x00108400
LEA RSI,[0x136f3e]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00108400
LEA RSI,[0x136f79]
MOV EDX,0x1f
MOV RDI,RBX
CALL 0x00108400
LEA RSI,[0x136fb0]
MOV EDX,0xa
MOV RDI,RBX
CALL 0x00108400
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,RBX
CALL 0x00108400
LEA RSI,[0x136f3e]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00108400
LEA RSI,[0x136f42]
MOV EDX,0x1f
MOV RDI,RBX
CALL 0x00108400
LAB_001279a5:
MOV RDI,qword ptr [RSP]
CMP RDI,R12
JZ 0x001279bb
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00108380
LAB_001279bb:
ADD RSP,0x48
POP RBX
POP R12
POP R14
POP R15
RET
|
/* FileWriterText::writeFileSkipped(std::filesystem::__cxx11::path const&,
std::filesystem::__cxx11::path const&, std::__cxx11::string const&) */
void __thiscall
FileWriterText::writeFileSkipped(FileWriterText *this,path *param_1,path *param_2,string *param_3)
{
ostream *poVar1;
ostream *poVar2;
long *local_68;
long local_60;
long local_58 [2];
long local_48;
long local_40;
std::filesystem::relative((path *)&local_48,param_1);
local_68 = local_58;
/* try { // try from 00127896 to 0012789d has its CatchHandler @ 001279c7 */
std::__cxx11::string::_M_construct<char_const*>(&local_68,local_48,local_40 + local_48);
std::filesystem::__cxx11::path::~path((path *)&local_48);
poVar2 = (ostream *)(this + 8);
/* try { // try from 001278ac to 001279a4 has its CatchHandler @ 001279d6 */
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"\n",1);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"==============================\n",0x1f)
;
std::__ostream_insert<char,std::char_traits<char>>(poVar2,&DAT_00136f6d,0xb);
poVar1 = std::__ostream_insert<char,std::char_traits<char>>(poVar2,(char *)local_68,local_60);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,"\n",1);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"------------------------------\n",0x1f)
;
poVar1 = std::__ostream_insert<char,std::char_traits<char>>
(poVar2,*(char **)param_3,*(long *)(param_3 + 8));
std::__ostream_insert<char,std::char_traits<char>>(poVar1,"\n",1);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"------------------------------\n",0x1f)
;
std::__ostream_insert<char,std::char_traits<char>>(poVar2,&DAT_00136fb0,10);
poVar1 = std::__ostream_insert<char,std::char_traits<char>>(poVar2,(char *)local_68,local_60);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,"\n",1);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"==============================\n",0x1f)
;
if (local_68 != local_58) {
operator_delete(local_68,local_58[0] + 1);
}
return;
}
| |
50,639 | mysql_list_processes_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_list_processes_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_list_processes,
(parms->mysql),
parms->mysql,
MYSQL_RES *,
r_ptr)
} | O3 | c | mysql_list_processes_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq 0x480(%rdi), %rax
movq 0x28(%rax), %rbx
callq 0x1ba39
movq %rax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_list_processes_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdi, [rdi]
mov rax, [rdi+480h]
mov rbx, [rax+28h]
call mysql_list_processes
mov [rbx+8], rax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_list_processes_start_internal(long long *a1)
{
long long v1; // rdi
long long v2; // rbx
long long result; // rax
v1 = *a1;
v2 = *(_QWORD *)(*(_QWORD *)(v1 + 1152) + 40LL);
result = mysql_list_processes(v1);
*(_QWORD *)(v2 + 8) = result;
*(_DWORD *)v2 = 0;
return result;
}
| mysql_list_processes_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x480]
MOV RBX,qword ptr [RAX + 0x28]
CALL 0x0011ba39
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_list_processes_start_internal(long *param_1)
{
int4 *puVar1;
int8 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_list_processes();
*(int8 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
| |
50,640 | translog_record_read_next_chunk | eloqsql/storage/maria/ma_loghandler.c | static my_bool translog_record_read_next_chunk(TRANSLOG_READER_DATA *data)
{
translog_size_t new_current_offset= data->current_offset + data->chunk_size;
uint16 chunk_header_len, chunk_len;
uint8 type;
DBUG_ENTER("translog_record_read_next_chunk");
if (data->eor)
{
DBUG_PRINT("info", ("end of the record flag set"));
DBUG_RETURN(1);
}
if (data->header.groups_no &&
data->header.groups_no - 1 != data->current_group &&
data->header.groups[data->current_group].num == data->current_chunk)
{
/* Goto next group */
data->current_group++;
data->current_chunk= 0;
DBUG_PRINT("info", ("skip to group: #%u", data->current_group));
translog_destroy_scanner(&data->scanner);
translog_scanner_init(data->header.groups[data->current_group].addr,
1, &data->scanner, 1);
}
else
{
data->current_chunk++;
if (translog_get_next_chunk(&data->scanner))
DBUG_RETURN(1);
if (data->scanner.page == END_OF_LOG)
{
/*
Actually it should not happened, but we want to quit nicely in case
of a truncated log
*/
DBUG_RETURN(1);
}
}
type= data->scanner.page[data->scanner.page_offset] & TRANSLOG_CHUNK_TYPE;
if (type == TRANSLOG_CHUNK_LSN && data->header.groups_no)
{
DBUG_PRINT("info",
("Last chunk: data len: %u offset: %u group: %u of %u",
data->header.chunk0_data_len, data->scanner.page_offset,
data->current_group, data->header.groups_no - 1));
DBUG_ASSERT(data->header.groups_no - 1 == data->current_group);
DBUG_ASSERT(data->header.lsn ==
data->scanner.page_addr + data->scanner.page_offset);
translog_destroy_scanner(&data->scanner);
translog_scanner_init(data->header.chunk0_data_addr, 1, &data->scanner, 1);
data->chunk_size= data->header.chunk0_data_len;
data->body_offset= data->scanner.page_offset;
data->current_offset= new_current_offset;
data->eor= 1;
DBUG_RETURN(0);
}
if (type == TRANSLOG_CHUNK_LSN || type == TRANSLOG_CHUNK_FIXED)
{
data->eor= 1;
DBUG_RETURN(1); /* End of record */
}
chunk_header_len=
translog_get_chunk_header_length(data->scanner.page +
data->scanner.page_offset);
chunk_len= translog_get_total_chunk_length(data->scanner.page,
data->scanner.page_offset);
data->chunk_size= chunk_len - chunk_header_len;
data->body_offset= data->scanner.page_offset + chunk_header_len;
data->current_offset= new_current_offset;
DBUG_PRINT("info", ("grp: %u chunk: %u body_offset: %u chunk_size: %u "
"current_offset: %lu",
(uint) data->current_group,
(uint) data->current_chunk,
(uint) data->body_offset,
(uint) data->chunk_size, (ulong) data->current_offset));
DBUG_RETURN(0);
} | O0 | c | translog_record_read_next_chunk:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x246c(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2472(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x247c(%rax)
je 0x33c62
jmp 0x33c55
jmp 0x33c57
jmp 0x33c59
movb $0x1, -0x1(%rbp)
jmp 0x33eeb
movq -0x10(%rbp), %rax
cmpl $0x0, 0x418(%rax)
je 0x33d21
movq -0x10(%rbp), %rax
movl 0x418(%rax), %eax
subl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x2474(%rcx), %eax
je 0x33d21
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x2474(%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x2478(%rcx), %eax
jne 0x33d21
movq -0x10(%rbp), %rax
movl 0x2474(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2474(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2478(%rax)
jmp 0x33cdc
movq -0x10(%rbp), %rdi
addq $0x438, %rdi # imm = 0x438
callq 0x310a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x2474(%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x438, %rdx # imm = 0x438
movl $0x1, %ecx
movl %ecx, %esi
callq 0x30d70
jmp 0x33d74
movq -0x10(%rbp), %rax
movl 0x2478(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2478(%rax)
movq -0x10(%rbp), %rdi
addq $0x438, %rdi # imm = 0x438
callq 0x30ec0
cmpb $0x0, %al
je 0x33d53
jmp 0x33d4a
movb $0x1, -0x1(%rbp)
jmp 0x33eeb
movq -0x10(%rbp), %rax
leaq 0xc45e32(%rip), %rcx # 0xc79b90
cmpq %rcx, 0x2450(%rax)
jne 0x33d72
jmp 0x33d69
movb $0x1, -0x1(%rbp)
jmp 0x33eeb
jmp 0x33d74
movq -0x10(%rbp), %rax
movq 0x2450(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x2460(%rcx), %ecx
movzbl (%rax,%rcx), %eax
andl $0xc0, %eax
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0x33e3c
movq -0x10(%rbp), %rax
cmpl $0x0, 0x418(%rax)
je 0x33e3c
jmp 0x33db5
jmp 0x33db7
jmp 0x33db9
jmp 0x33dbb
jmp 0x33dbd
jmp 0x33dbf
movq -0x10(%rbp), %rdi
addq $0x438, %rdi # imm = 0x438
callq 0x310a0
movq -0x10(%rbp), %rax
movq 0x428(%rax), %rdi
movq -0x10(%rbp), %rdx
addq $0x438, %rdx # imm = 0x438
movl $0x1, %ecx
movl %ecx, %esi
callq 0x30d70
movq -0x10(%rbp), %rax
movw 0x436(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2472(%rax)
movq -0x10(%rbp), %rax
movl 0x2460(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2468(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x246c(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x247c(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x33eeb
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
je 0x33e4e
movzbl -0x19(%rbp), %eax
cmpl $0x40, %eax
jne 0x33e62
movq -0x10(%rbp), %rax
movb $0x1, 0x247c(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x33eeb
movq -0x10(%rbp), %rax
movq 0x2450(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x2460(%rax), %eax
addq %rax, %rdi
callq 0x3a7b0
movw %ax, -0x16(%rbp)
movq -0x10(%rbp), %rax
movq 0x2450(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x2460(%rax), %eax
movzwl %ax, %esi
callq 0x307b0
movw %ax, -0x18(%rbp)
movzwl -0x18(%rbp), %eax
movzwl -0x16(%rbp), %ecx
subl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2472(%rax)
movq -0x10(%rbp), %rax
movl 0x2460(%rax), %ecx
movzwl -0x16(%rbp), %eax
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2468(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x246c(%rax)
jmp 0x33ee5
jmp 0x33ee7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| translog_record_read_next_chunk:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov eax, [rax+246Ch]
mov rcx, [rbp+var_10]
movzx ecx, word ptr [rcx+2472h]
add eax, ecx
mov [rbp+var_14], eax
mov rax, [rbp+var_10]
cmp byte ptr [rax+247Ch], 0
jz short loc_33C62
jmp short $+2
loc_33C55:
jmp short $+2
loc_33C57:
jmp short $+2
loc_33C59:
mov [rbp+var_1], 1
jmp loc_33EEB
loc_33C62:
mov rax, [rbp+var_10]
cmp dword ptr [rax+418h], 0
jz loc_33D21
mov rax, [rbp+var_10]
mov eax, [rax+418h]
sub eax, 1
mov rcx, [rbp+var_10]
cmp eax, [rcx+2474h]
jz loc_33D21
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rcx, [rbp+var_10]
mov ecx, [rcx+2474h]
shl rcx, 4
add rax, rcx
movzx eax, byte ptr [rax+8]
mov rcx, [rbp+var_10]
cmp eax, [rcx+2478h]
jnz short loc_33D21
mov rax, [rbp+var_10]
mov ecx, [rax+2474h]
add ecx, 1
mov [rax+2474h], ecx
mov rax, [rbp+var_10]
mov dword ptr [rax+2478h], 0
jmp short $+2
loc_33CDC:
mov rdi, [rbp+var_10]
add rdi, 438h
call translog_destroy_scanner
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rcx, [rbp+var_10]
mov ecx, [rcx+2474h]
shl rcx, 4
add rax, rcx
mov rdi, [rax]
mov rdx, [rbp+var_10]
add rdx, 438h
mov ecx, 1
mov esi, ecx
call translog_scanner_init
jmp short loc_33D74
loc_33D21:
mov rax, [rbp+var_10]
mov ecx, [rax+2478h]
add ecx, 1
mov [rax+2478h], ecx
mov rdi, [rbp+var_10]
add rdi, 438h
call translog_get_next_chunk
cmp al, 0
jz short loc_33D53
jmp short $+2
loc_33D4A:
mov [rbp+var_1], 1
jmp loc_33EEB
loc_33D53:
mov rax, [rbp+var_10]
lea rcx, end_of_log
cmp [rax+2450h], rcx
jnz short loc_33D72
jmp short $+2
loc_33D69:
mov [rbp+var_1], 1
jmp loc_33EEB
loc_33D72:
jmp short $+2
loc_33D74:
mov rax, [rbp+var_10]
mov rax, [rax+2450h]
mov rcx, [rbp+var_10]
mov ecx, [rcx+2460h]
movzx eax, byte ptr [rax+rcx]
and eax, 0C0h
mov [rbp+var_19], al
movzx eax, [rbp+var_19]
cmp eax, 0
jnz loc_33E3C
mov rax, [rbp+var_10]
cmp dword ptr [rax+418h], 0
jz loc_33E3C
jmp short $+2
loc_33DB5:
jmp short $+2
loc_33DB7:
jmp short $+2
loc_33DB9:
jmp short $+2
loc_33DBB:
jmp short $+2
loc_33DBD:
jmp short $+2
loc_33DBF:
mov rdi, [rbp+var_10]
add rdi, 438h
call translog_destroy_scanner
mov rax, [rbp+var_10]
mov rdi, [rax+428h]
mov rdx, [rbp+var_10]
add rdx, 438h
mov ecx, 1
mov esi, ecx
call translog_scanner_init
mov rax, [rbp+var_10]
mov cx, [rax+436h]
mov rax, [rbp+var_10]
mov [rax+2472h], cx
mov rax, [rbp+var_10]
mov ecx, [rax+2460h]
mov rax, [rbp+var_10]
mov [rax+2468h], ecx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov [rax+246Ch], ecx
mov rax, [rbp+var_10]
mov byte ptr [rax+247Ch], 1
mov [rbp+var_1], 0
jmp loc_33EEB
loc_33E3C:
movzx eax, [rbp+var_19]
cmp eax, 0
jz short loc_33E4E
movzx eax, [rbp+var_19]
cmp eax, 40h ; '@'
jnz short loc_33E62
loc_33E4E:
mov rax, [rbp+var_10]
mov byte ptr [rax+247Ch], 1
mov [rbp+var_1], 1
jmp loc_33EEB
loc_33E62:
mov rax, [rbp+var_10]
mov rdi, [rax+2450h]
mov rax, [rbp+var_10]
mov eax, [rax+2460h]
add rdi, rax
call translog_get_chunk_header_length
mov [rbp+var_16], ax
mov rax, [rbp+var_10]
mov rdi, [rax+2450h]
mov rax, [rbp+var_10]
mov eax, [rax+2460h]
movzx esi, ax
call translog_get_total_chunk_length
mov [rbp+var_18], ax
movzx eax, [rbp+var_18]
movzx ecx, [rbp+var_16]
sub eax, ecx
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+2472h], cx
mov rax, [rbp+var_10]
mov ecx, [rax+2460h]
movzx eax, [rbp+var_16]
add ecx, eax
mov rax, [rbp+var_10]
mov [rax+2468h], ecx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov [rax+246Ch], ecx
jmp short $+2
loc_33EE5:
jmp short $+2
loc_33EE7:
mov [rbp+var_1], 0
loc_33EEB:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char translog_record_read_next_chunk(long long a1)
{
char v2; // [rsp+7h] [rbp-19h]
unsigned __int16 chunk_header_length; // [rsp+Ah] [rbp-16h]
int v4; // [rsp+Ch] [rbp-14h]
v4 = *(unsigned __int16 *)(a1 + 9330) + *(_DWORD *)(a1 + 9324);
if ( *(_BYTE *)(a1 + 9340) )
return 1;
if ( *(_DWORD *)(a1 + 1048)
&& *(_DWORD *)(a1 + 1048) - 1 != *(_DWORD *)(a1 + 9332)
&& *(unsigned __int8 *)(16LL * *(unsigned int *)(a1 + 9332) + *(_QWORD *)(a1 + 8) + 8) == *(_DWORD *)(a1 + 9336) )
{
++*(_DWORD *)(a1 + 9332);
*(_DWORD *)(a1 + 9336) = 0;
translog_destroy_scanner(a1 + 1080);
translog_scanner_init(*(_QWORD *)(16LL * *(unsigned int *)(a1 + 9332) + *(_QWORD *)(a1 + 8)), 1, a1 + 1080, 1);
}
else
{
++*(_DWORD *)(a1 + 9336);
if ( translog_get_next_chunk(a1 + 1080) )
return 1;
if ( *(_UNKNOWN **)(a1 + 9296) == &end_of_log )
return 1;
}
v2 = *(_BYTE *)(*(_QWORD *)(a1 + 9296) + *(unsigned int *)(a1 + 9312)) & 0xC0;
if ( v2 || !*(_DWORD *)(a1 + 1048) )
{
if ( v2 && v2 != 64 )
{
chunk_header_length = translog_get_chunk_header_length(*(unsigned int *)(a1 + 9312) + *(_QWORD *)(a1 + 9296));
*(_WORD *)(a1 + 9330) = translog_get_total_chunk_length(*(_QWORD *)(a1 + 9296), *(_DWORD *)(a1 + 9312))
- chunk_header_length;
*(_DWORD *)(a1 + 9320) = chunk_header_length + *(_DWORD *)(a1 + 9312);
*(_DWORD *)(a1 + 9324) = v4;
return 0;
}
else
{
*(_BYTE *)(a1 + 9340) = 1;
return 1;
}
}
else
{
translog_destroy_scanner(a1 + 1080);
translog_scanner_init(*(_QWORD *)(a1 + 1064), 1, a1 + 1080, 1);
*(_WORD *)(a1 + 9330) = *(_WORD *)(a1 + 1078);
*(_DWORD *)(a1 + 9320) = *(_DWORD *)(a1 + 9312);
*(_DWORD *)(a1 + 9324) = v4;
*(_BYTE *)(a1 + 9340) = 1;
return 0;
}
}
| translog_record_read_next_chunk:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x246c]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,word ptr [RCX + 0x2472]
ADD EAX,ECX
MOV dword ptr [RBP + -0x14],EAX
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x247c],0x0
JZ 0x00133c62
JMP 0x00133c55
LAB_00133c55:
JMP 0x00133c57
LAB_00133c57:
JMP 0x00133c59
LAB_00133c59:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00133eeb
LAB_00133c62:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x418],0x0
JZ 0x00133d21
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x418]
SUB EAX,0x1
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x2474]
JZ 0x00133d21
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x2474]
SHL RCX,0x4
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x2478]
JNZ 0x00133d21
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x2474]
ADD ECX,0x1
MOV dword ptr [RAX + 0x2474],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x2478],0x0
JMP 0x00133cdc
LAB_00133cdc:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x438
CALL 0x001310a0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x2474]
SHL RCX,0x4
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,0x438
MOV ECX,0x1
MOV ESI,ECX
CALL 0x00130d70
JMP 0x00133d74
LAB_00133d21:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x2478]
ADD ECX,0x1
MOV dword ptr [RAX + 0x2478],ECX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x438
CALL 0x00130ec0
CMP AL,0x0
JZ 0x00133d53
JMP 0x00133d4a
LAB_00133d4a:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00133eeb
LAB_00133d53:
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0xd79b90]
CMP qword ptr [RAX + 0x2450],RCX
JNZ 0x00133d72
JMP 0x00133d69
LAB_00133d69:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00133eeb
LAB_00133d72:
JMP 0x00133d74
LAB_00133d74:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2450]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x2460]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
AND EAX,0xc0
MOV byte ptr [RBP + -0x19],AL
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0x0
JNZ 0x00133e3c
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x418],0x0
JZ 0x00133e3c
JMP 0x00133db5
LAB_00133db5:
JMP 0x00133db7
LAB_00133db7:
JMP 0x00133db9
LAB_00133db9:
JMP 0x00133dbb
LAB_00133dbb:
JMP 0x00133dbd
LAB_00133dbd:
JMP 0x00133dbf
LAB_00133dbf:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x438
CALL 0x001310a0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x428]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,0x438
MOV ECX,0x1
MOV ESI,ECX
CALL 0x00130d70
MOV RAX,qword ptr [RBP + -0x10]
MOV CX,word ptr [RAX + 0x436]
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x2472],CX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x2460]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x2468],ECX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x246c],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x247c],0x1
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00133eeb
LAB_00133e3c:
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0x0
JZ 0x00133e4e
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0x40
JNZ 0x00133e62
LAB_00133e4e:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x247c],0x1
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00133eeb
LAB_00133e62:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x2450]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x2460]
ADD RDI,RAX
CALL 0x0013a7b0
MOV word ptr [RBP + -0x16],AX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x2450]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x2460]
MOVZX ESI,AX
CALL 0x001307b0
MOV word ptr [RBP + -0x18],AX
MOVZX EAX,word ptr [RBP + -0x18]
MOVZX ECX,word ptr [RBP + -0x16]
SUB EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x2472],CX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x2460]
MOVZX EAX,word ptr [RBP + -0x16]
ADD ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x2468],ECX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x246c],ECX
JMP 0x00133ee5
LAB_00133ee5:
JMP 0x00133ee7
LAB_00133ee7:
MOV byte ptr [RBP + -0x1],0x0
LAB_00133eeb:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 translog_record_read_next_chunk(long param_1)
{
char cVar1;
byte bVar2;
ushort uVar3;
short sVar4;
int iVar5;
int1 local_9;
iVar5 = *(int *)(param_1 + 0x246c) + (uint)*(ushort *)(param_1 + 0x2472);
if (*(char *)(param_1 + 0x247c) != '\0') {
return 1;
}
if (((*(int *)(param_1 + 0x418) == 0) ||
(*(int *)(param_1 + 0x418) + -1 == *(int *)(param_1 + 0x2474))) ||
((uint)*(byte *)(*(long *)(param_1 + 8) + (ulong)*(uint *)(param_1 + 0x2474) * 0x10 + 8) !=
*(uint *)(param_1 + 0x2478))) {
*(int *)(param_1 + 0x2478) = *(int *)(param_1 + 0x2478) + 1;
cVar1 = translog_get_next_chunk(param_1 + 0x438);
if (cVar1 != '\0') {
return 1;
}
if (*(int1 **)(param_1 + 0x2450) == &end_of_log) {
return 1;
}
}
else {
*(int *)(param_1 + 0x2474) = *(int *)(param_1 + 0x2474) + 1;
*(int4 *)(param_1 + 0x2478) = 0;
translog_destroy_scanner(param_1 + 0x438);
translog_scanner_init
(*(int8 *)(*(long *)(param_1 + 8) + (ulong)*(uint *)(param_1 + 0x2474) * 0x10),1
,param_1 + 0x438);
}
bVar2 = *(byte *)(*(long *)(param_1 + 0x2450) + (ulong)*(uint *)(param_1 + 0x2460)) & 0xc0;
if ((bVar2 == 0) && (*(int *)(param_1 + 0x418) != 0)) {
translog_destroy_scanner(param_1 + 0x438);
translog_scanner_init(*(int8 *)(param_1 + 0x428),1,param_1 + 0x438);
*(int2 *)(param_1 + 0x2472) = *(int2 *)(param_1 + 0x436);
*(int4 *)(param_1 + 0x2468) = *(int4 *)(param_1 + 0x2460);
*(int *)(param_1 + 0x246c) = iVar5;
*(int1 *)(param_1 + 0x247c) = 1;
local_9 = 0;
}
else if ((bVar2 == 0) || (bVar2 == 0x40)) {
*(int1 *)(param_1 + 0x247c) = 1;
local_9 = 1;
}
else {
uVar3 = translog_get_chunk_header_length
(*(long *)(param_1 + 0x2450) + (ulong)*(uint *)(param_1 + 0x2460));
sVar4 = translog_get_total_chunk_length
(*(int8 *)(param_1 + 0x2450),*(uint *)(param_1 + 0x2460) & 0xffff);
*(ushort *)(param_1 + 0x2472) = sVar4 - uVar3;
*(uint *)(param_1 + 0x2468) = *(int *)(param_1 + 0x2460) + (uint)uVar3;
*(int *)(param_1 + 0x246c) = iVar5;
local_9 = 0;
}
return local_9;
}
| |
50,641 | stbi__convert_format16(unsigned short*, int, int, unsigned int, unsigned int) | monkey531[P]llama/examples/llava/../../common/stb_image.h | static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
{
int i,j;
stbi__uint16 *good;
if (req_comp == img_n) return data;
STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);
if (good == NULL) {
STBI_FREE(data);
return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
}
for (j=0; j < (int) y; ++j) {
stbi__uint16 *src = data + j * x * img_n ;
stbi__uint16 *dest = good + j * x * req_comp;
#define STBI__COMBO(a,b) ((a)*8+(b))
#define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
// convert source image with img_n components to one with req_comp components;
// avoid switch per pixel, so use switch per scanline and massive macros
switch (STBI__COMBO(img_n, req_comp)) {
STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break;
STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break;
STBI__CASE(2,1) { dest[0]=src[0]; } break;
STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;
STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break;
STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;
STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;
STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;
STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;
STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;
default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion");
}
#undef STBI__CASE
}
STBI_FREE(data);
return good;
} | O1 | c | stbi__convert_format16(unsigned short*, int, int, unsigned int, unsigned int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
cmpl %esi, %edx
jne 0x3dfa5
movq %r14, %rbx
jmp 0x3e39f
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movl %edx, %eax
imull %ecx, %eax
movl %eax, 0x14(%rsp)
movl %eax, %edi
imull %r8d, %edi
addl %edi, %edi
callq 0x1e000
testq %rax, %rax
je 0x3e37b
movq %rax, %rbx
testl %ebp, %ebp
jle 0x3e371
movq 0x8(%rsp), %rax
leal (%r12,%rax,8), %eax
cmpl $0x23, %eax
ja 0x3e3b1
movabsq $0xe161a1c00, %rcx # imm = 0xE161A1C00
btq %rax, %rcx
jae 0x3e3b1
leal -0x1(%r15), %ecx
movl %ecx, 0x4(%rsp)
cmpl $0x2, %ebp
movl $0x1, %ecx
cmovgel %ebp, %ecx
movq %rcx, 0x20(%rsp)
movl %r15d, %ecx
imull 0x8(%rsp), %ecx
movl %ecx, 0x10(%rsp)
leaq 0x4(%rbx), %rcx
movq %rcx, 0x18(%rsp)
xorl %r8d, %r8d
addl $-0xa, %eax
movdqa 0xcece7(%rip), %xmm0 # 0x10cd20
xorl %r10d, %r10d
xorl %r11d, %r11d
movl %r11d, %ecx
imull %r15d, %ecx
movl %ecx, %edx
imull 0x8(%rsp), %edx
leaq (%r14,%rdx,2), %rbp
imull %r12d, %ecx
leaq (%rbx,%rcx,2), %rcx
cmpl $0x18, %eax
ja 0x3e334
movl %r10d, %edx
leaq (%rbx,%rdx,2), %rdi
movl %r8d, %r9d
leaq (%r14,%r9,2), %r9
leaq 0xceec9(%rip), %r13 # 0x10cf40
movslq (%r13,%rax,4), %rsi
addq %r13, %rsi
jmpq *%rsi
cmpl $0x0, 0x4(%rsp)
js 0x3e359
xorl %ecx, %ecx
movl %r15d, %edx
movzwl (%r9,%rcx), %esi
movw %si, (%rdi,%rcx,2)
movw $0xffff, 0x2(%rdi,%rcx,2) # imm = 0xFFFF
decl %edx
addq $0x2, %rcx
testl %edx, %edx
jg 0x3e091
jmp 0x3e359
cmpl $0x0, 0x4(%rsp)
js 0x3e359
xorl %ecx, %ecx
movl %r15d, %ebp
movzwl (%r9,%rcx,2), %edx
movzwl 0x2(%r9,%rcx,2), %esi
movzwl 0x4(%r9,%rcx,2), %r13d
imull $0x4d, %edx, %edx
imull $0x96, %esi, %esi
addl %edx, %esi
leal (%r13,%r13,8), %edx
leal (%rdx,%rdx,2), %edx
addl %r13d, %r13d
addl %edx, %r13d
addl %esi, %r13d
shrl $0x8, %r13d
movw %r13w, (%rdi,%rcx)
movzwl 0x6(%r9,%rcx,2), %edx
movw %dx, 0x2(%rdi,%rcx)
decl %ebp
addq $0x4, %rcx
testl %ebp, %ebp
jg 0x3e0c0
jmp 0x3e359
cmpl $0x0, 0x4(%rsp)
js 0x3e359
movq 0x18(%rsp), %rcx
leaq (%rcx,%rdx,2), %rcx
movl %r15d, %edi
movzwl (%rbp), %edx
movw %dx, (%rcx)
movw %dx, -0x2(%rcx)
movw %dx, -0x4(%rcx)
addq $0x4, %rbp
decl %edi
addq $0x6, %rcx
testl %edi, %edi
jg 0x3e127
jmp 0x3e359
cmpl $0x0, 0x4(%rsp)
js 0x3e359
xorl %ecx, %ecx
movl %r15d, %edx
movd (%r9,%rcx), %xmm1
pshuflw $0x40, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,1,4,5,6,7]
movq %xmm1, (%rdi,%rcx,2)
decl %edx
addq $0x4, %rcx
testl %edx, %edx
jg 0x3e159
jmp 0x3e359
cmpl $0x0, 0x4(%rsp)
js 0x3e359
xorl %ecx, %ecx
movl %r15d, %edx
movzwl (%r9,%rcx,2), %esi
movw %si, (%rdi,%rcx)
decl %edx
addq $0x2, %rcx
testl %edx, %edx
jg 0x3e188
jmp 0x3e359
cmpl $0x0, 0x4(%rsp)
js 0x3e359
xorl %ecx, %ecx
movl %r15d, %edx
movdqa %xmm0, %xmm1
pinsrw $0x0, (%r9,%rcx), %xmm1
pshuflw $0x40, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,1,4,5,6,7]
movq %xmm1, (%rdi,%rcx,4)
decl %edx
addq $0x2, %rcx
testl %edx, %edx
jg 0x3e1b0
jmp 0x3e359
cmpl $0x0, 0x4(%rsp)
js 0x3e359
movq 0x18(%rsp), %rcx
leaq (%rcx,%rdx,2), %rcx
movl %r15d, %edi
movzwl (%rbp), %edx
movw %dx, (%rcx)
movw %dx, -0x2(%rcx)
movw %dx, -0x4(%rcx)
addq $0x2, %rbp
decl %edi
addq $0x6, %rcx
testl %edi, %edi
jg 0x3e1eb
jmp 0x3e359
movl %r15d, %edi
cmpl $0x0, 0x4(%rsp)
js 0x3e359
movzwl (%rbp), %edx
movzwl 0x2(%rbp), %esi
movzwl 0x4(%rbp), %r9d
imull $0x4d, %edx, %edx
imull $0x96, %esi, %esi
addl %edx, %esi
leal (%r9,%r9,8), %edx
leal (%rdx,%rdx,2), %edx
addl %r9d, %r9d
addl %edx, %r9d
addl %esi, %r9d
shrl $0x8, %r9d
movw %r9w, (%rcx)
addq $0x6, %rbp
addq $0x2, %rcx
decl %edi
testl %edi, %edi
jg 0x3e21b
jmp 0x3e359
movl %r15d, %edi
cmpl $0x0, 0x4(%rsp)
js 0x3e359
movzwl (%rbp), %edx
movzwl 0x2(%rbp), %esi
movzwl 0x4(%rbp), %r9d
imull $0x4d, %edx, %edx
imull $0x96, %esi, %esi
addl %edx, %esi
leal (%r9,%r9,8), %edx
leal (%rdx,%rdx,2), %edx
addl %r9d, %r9d
addl %edx, %r9d
addl %esi, %r9d
shrl $0x8, %r9d
movw %r9w, (%rcx)
movw $0xffff, 0x2(%rcx) # imm = 0xFFFF
addq $0x6, %rbp
addq $0x4, %rcx
decl %edi
testl %edi, %edi
jg 0x3e26c
jmp 0x3e359
cmpl $0x0, 0x4(%rsp)
js 0x3e359
xorl %ecx, %ecx
movl %r15d, %ebp
movzwl (%r9,%rcx,4), %edx
movzwl 0x2(%r9,%rcx,4), %esi
movzwl 0x4(%r9,%rcx,4), %r13d
imull $0x4d, %edx, %edx
imull $0x96, %esi, %esi
addl %edx, %esi
leal (%r13,%r13,8), %edx
leal (%rdx,%rdx,2), %edx
addl %r13d, %r13d
addl %edx, %r13d
addl %esi, %r13d
shrl $0x8, %r13d
movw %r13w, (%rdi,%rcx)
decl %ebp
addq $0x2, %rcx
testl %ebp, %ebp
jg 0x3e2c5
jmp 0x3e359
movl %r15d, %edi
cmpl $0x0, 0x4(%rsp)
js 0x3e359
movl (%rbp), %edx
movl %edx, (%rcx)
movzwl 0x4(%rbp), %edx
movw %dx, 0x4(%rcx)
movw $0xffff, 0x6(%rcx) # imm = 0xFFFF
addq $0x6, %rbp
addq $0x8, %rcx
decl %edi
testl %edi, %edi
jg 0x3e311
jmp 0x3e359
movl %r15d, %edi
cmpl $0x0, 0x4(%rsp)
js 0x3e359
movl (%rbp), %edx
movl %edx, (%rcx)
movzwl 0x4(%rbp), %edx
movw %dx, 0x4(%rcx)
addq $0x8, %rbp
addq $0x6, %rcx
decl %edi
testl %edi, %edi
jg 0x3e33e
incq %r11
addl 0x14(%rsp), %r10d
addl 0x10(%rsp), %r8d
cmpq 0x20(%rsp), %r11
jne 0x3e03f
movq %r14, %rdi
callq 0x1de70
jmp 0x3e39f
movq %r14, %rdi
callq 0x1de70
movq %fs:0x0, %rax
leaq 0xd022d(%rip), %rcx # 0x10e5c3
movq %rcx, -0x20(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x1de70
movq %rbx, %rdi
callq 0x1de70
movq %fs:0x0, %rax
leaq 0xd022b(%rip), %rcx # 0x10e5ff
jmp 0x3e396
| _ZL22stbi__convert_format16Ptiijj:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdi
mov [rsp+58h+var_50], rsi
cmp edx, esi
jnz short loc_3DFA5
mov rbx, r14
jmp loc_3E39F
loc_3DFA5:
mov ebp, r8d
mov r15d, ecx
mov r12d, edx
mov eax, edx
imul eax, ecx
mov [rsp+58h+var_44], eax
mov edi, eax
imul edi, r8d
add edi, edi
call _malloc
test rax, rax
jz loc_3E37B
mov rbx, rax
test ebp, ebp
jle loc_3E371
mov rax, [rsp+58h+var_50]
lea eax, [r12+rax*8]
cmp eax, 23h ; '#'
ja loc_3E3B1
mov rcx, 0E161A1C00h
bt rcx, rax
jnb loc_3E3B1
lea ecx, [r15-1]
mov [rsp+58h+var_54], ecx
cmp ebp, 2
mov ecx, 1
cmovge ecx, ebp
mov [rsp+58h+var_38], rcx
mov ecx, r15d
imul ecx, dword ptr [rsp+58h+var_50]
mov [rsp+58h+var_48], ecx
lea rcx, [rbx+4]
mov [rsp+58h+var_40], rcx
xor r8d, r8d
add eax, 0FFFFFFF6h
movdqa xmm0, cs:xmmword_10CD20
xor r10d, r10d
xor r11d, r11d
loc_3E03F:
mov ecx, r11d
imul ecx, r15d
mov edx, ecx
imul edx, dword ptr [rsp+58h+var_50]
lea rbp, [r14+rdx*2]
imul ecx, r12d
lea rcx, [rbx+rcx*2]
cmp eax, 18h; switch 25 cases
ja def_3E07F; jumptable 000000000003E07F default case, cases 3-6,8,11-14,17,19-22
mov edx, r10d
lea rdi, [rbx+rdx*2]
mov r9d, r8d
lea r9, [r14+r9*2]
lea r13, jpt_3E07F
movsxd rsi, ds:(jpt_3E07F - 10CF40h)[r13+rax*4]
add rsi, r13
jmp rsi; switch jump
loc_3E081:
cmp [rsp+58h+var_54], 0; jumptable 000000000003E07F case 0
js loc_3E359
xor ecx, ecx
mov edx, r15d
loc_3E091:
movzx esi, word ptr [r9+rcx]
mov [rdi+rcx*2], si
mov word ptr [rdi+rcx*2+2], 0FFFFh
dec edx
add rcx, 2
test edx, edx
jg short loc_3E091
jmp loc_3E359
loc_3E0B0:
cmp [rsp+58h+var_54], 0; jumptable 000000000003E07F case 24
js loc_3E359
xor ecx, ecx
mov ebp, r15d
loc_3E0C0:
movzx edx, word ptr [r9+rcx*2]
movzx esi, word ptr [r9+rcx*2+2]
movzx r13d, word ptr [r9+rcx*2+4]
imul edx, 4Dh ; 'M'
imul esi, 96h
add esi, edx
lea edx, [r13+r13*8+0]
lea edx, [rdx+rdx*2]
add r13d, r13d
add r13d, edx
add r13d, esi
shr r13d, 8
mov [rdi+rcx], r13w
movzx edx, word ptr [r9+rcx*2+6]
mov [rdi+rcx+2], dx
dec ebp
add rcx, 4
test ebp, ebp
jg short loc_3E0C0
jmp loc_3E359
loc_3E110:
cmp [rsp+58h+var_54], 0; jumptable 000000000003E07F case 9
js loc_3E359
mov rcx, [rsp+58h+var_40]
lea rcx, [rcx+rdx*2]
mov edi, r15d
loc_3E127:
movzx edx, word ptr [rbp+0]
mov [rcx], dx
mov [rcx-2], dx
mov [rcx-4], dx
add rbp, 4
dec edi
add rcx, 6
test edi, edi
jg short loc_3E127
jmp loc_3E359
loc_3E149:
cmp [rsp+58h+var_54], 0; jumptable 000000000003E07F case 10
js loc_3E359
xor ecx, ecx
mov edx, r15d
loc_3E159:
movd xmm1, dword ptr [r9+rcx]
pshuflw xmm1, xmm1, 40h ; '@'
movq qword ptr [rdi+rcx*2], xmm1
dec edx
add rcx, 4
test edx, edx
jg short loc_3E159
jmp loc_3E359
loc_3E178:
cmp [rsp+58h+var_54], 0; jumptable 000000000003E07F case 7
js loc_3E359
xor ecx, ecx
mov edx, r15d
loc_3E188:
movzx esi, word ptr [r9+rcx*2]
mov [rdi+rcx], si
dec edx
add rcx, 2
test edx, edx
jg short loc_3E188
jmp loc_3E359
loc_3E1A0:
cmp [rsp+58h+var_54], 0; jumptable 000000000003E07F case 2
js loc_3E359
xor ecx, ecx
mov edx, r15d
loc_3E1B0:
movdqa xmm1, xmm0
pinsrw xmm1, word ptr [r9+rcx], 0
pshuflw xmm1, xmm1, 40h ; '@'
movq qword ptr [rdi+rcx*4], xmm1
dec edx
add rcx, 2
test edx, edx
jg short loc_3E1B0
jmp loc_3E359
loc_3E1D4:
cmp [rsp+58h+var_54], 0; jumptable 000000000003E07F case 1
js loc_3E359
mov rcx, [rsp+58h+var_40]
lea rcx, [rcx+rdx*2]
mov edi, r15d
loc_3E1EB:
movzx edx, word ptr [rbp+0]
mov [rcx], dx
mov [rcx-2], dx
mov [rcx-4], dx
add rbp, 2
dec edi
add rcx, 6
test edi, edi
jg short loc_3E1EB
jmp loc_3E359
loc_3E20D:
mov edi, r15d; jumptable 000000000003E07F case 15
cmp [rsp+58h+var_54], 0
js loc_3E359
loc_3E21B:
movzx edx, word ptr [rbp+0]
movzx esi, word ptr [rbp+2]
movzx r9d, word ptr [rbp+4]
imul edx, 4Dh ; 'M'
imul esi, 96h
add esi, edx
lea edx, [r9+r9*8]
lea edx, [rdx+rdx*2]
add r9d, r9d
add r9d, edx
add r9d, esi
shr r9d, 8
mov [rcx], r9w
add rbp, 6
add rcx, 2
dec edi
test edi, edi
jg short loc_3E21B
jmp loc_3E359
loc_3E25E:
mov edi, r15d; jumptable 000000000003E07F case 16
cmp [rsp+58h+var_54], 0
js loc_3E359
loc_3E26C:
movzx edx, word ptr [rbp+0]
movzx esi, word ptr [rbp+2]
movzx r9d, word ptr [rbp+4]
imul edx, 4Dh ; 'M'
imul esi, 96h
add esi, edx
lea edx, [r9+r9*8]
lea edx, [rdx+rdx*2]
add r9d, r9d
add r9d, edx
add r9d, esi
shr r9d, 8
mov [rcx], r9w
mov word ptr [rcx+2], 0FFFFh
add rbp, 6
add rcx, 4
dec edi
test edi, edi
jg short loc_3E26C
jmp loc_3E359
loc_3E2B5:
cmp [rsp+58h+var_54], 0; jumptable 000000000003E07F case 23
js loc_3E359
xor ecx, ecx
mov ebp, r15d
loc_3E2C5:
movzx edx, word ptr [r9+rcx*4]
movzx esi, word ptr [r9+rcx*4+2]
movzx r13d, word ptr [r9+rcx*4+4]
imul edx, 4Dh ; 'M'
imul esi, 96h
add esi, edx
lea edx, [r13+r13*8+0]
lea edx, [rdx+rdx*2]
add r13d, r13d
add r13d, edx
add r13d, esi
shr r13d, 8
mov [rdi+rcx], r13w
dec ebp
add rcx, 2
test ebp, ebp
jg short loc_3E2C5
jmp short loc_3E359
loc_3E307:
mov edi, r15d; jumptable 000000000003E07F case 18
cmp [rsp+58h+var_54], 0
js short loc_3E359
loc_3E311:
mov edx, [rbp+0]
mov [rcx], edx
movzx edx, word ptr [rbp+4]
mov [rcx+4], dx
mov word ptr [rcx+6], 0FFFFh
add rbp, 6
add rcx, 8
dec edi
test edi, edi
jg short loc_3E311
jmp short loc_3E359
def_3E07F:
mov edi, r15d; jumptable 000000000003E07F default case, cases 3-6,8,11-14,17,19-22
cmp [rsp+58h+var_54], 0
js short loc_3E359
loc_3E33E:
mov edx, [rbp+0]
mov [rcx], edx
movzx edx, word ptr [rbp+4]
mov [rcx+4], dx
add rbp, 8
add rcx, 6
dec edi
test edi, edi
jg short loc_3E33E
loc_3E359:
inc r11
add r10d, [rsp+58h+var_44]
add r8d, [rsp+58h+var_48]
cmp r11, [rsp+58h+var_38]
jnz loc_3E03F
loc_3E371:
mov rdi, r14
call _free
jmp short loc_3E39F
loc_3E37B:
mov rdi, r14
call _free
mov rax, fs:0
lea rcx, aOutofmem; "outofmem"
loc_3E396:
mov [rax-20h], rcx
xor ebx, ebx
loc_3E39F:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3E3B1:
mov rdi, r14
call _free
mov rdi, rbx
call _free
mov rax, fs:0
lea rcx, aUnsupported; "unsupported"
jmp short loc_3E396
| unsigned __int16 * stbi__convert_format16(unsigned __int16 *a1, int a2, int a3, int a4, int a5)
{
long long v6; // rbx
long long v10; // rax
unsigned long long v11; // rax
long long v12; // rcx
long long v13; // rcx
int v14; // r8d
int v15; // eax
__m128i si128; // xmm0
unsigned int v17; // r10d
long long i; // r11
unsigned __int16 *v19; // rbp
_WORD *v20; // rcx
long long v21; // rdi
unsigned __int16 *v22; // r9
long long v23; // rcx
int v24; // edx
long long v25; // rcx
int v26; // ebp
unsigned __int16 *v27; // rcx
int v28; // edi
unsigned __int16 v29; // dx
unsigned long long v30; // rcx
int v31; // edx
long long v32; // rcx
int v33; // edx
long long v34; // rcx
int v35; // edx
unsigned __int16 *v36; // rcx
int v37; // edi
unsigned __int16 v38; // dx
int v39; // edi
int v40; // edi
long long v41; // rcx
int v42; // ebp
int v43; // edi
int v44; // edi
unsigned long long v45; // rax
const char *v46; // rcx
int v48; // [rsp+4h] [rbp-54h]
int v49; // [rsp+14h] [rbp-44h]
long long v50; // [rsp+18h] [rbp-40h]
long long v51; // [rsp+20h] [rbp-38h]
if ( a3 != a2 )
{
v49 = a4 * a3;
v10 = malloc((unsigned int)(2 * a5 * a4 * a3));
if ( v10 )
{
v6 = v10;
if ( a5 <= 0 )
{
LABEL_55:
free(a1);
return (unsigned __int16 *)v6;
}
v11 = (unsigned int)(a3 + 8 * a2);
if ( (unsigned int)v11 <= 0x23 )
{
v12 = 0xE161A1C00LL;
if ( _bittest64(&v12, v11) )
{
v48 = a4 - 1;
v13 = 1LL;
if ( a5 >= 2 )
v13 = (unsigned int)a5;
v51 = v13;
v50 = v6 + 4;
v14 = 0;
v15 = v11 - 10;
si128 = _mm_load_si128((const __m128i *)&xmmword_10CD20);
v17 = 0;
for ( i = 0LL; i != v51; ++i )
{
v19 = &a1[(unsigned int)(a2 * a4 * i)];
v20 = (_WORD *)(v6 + 2LL * (unsigned int)(a3 * a4 * i));
v21 = v6 + 2LL * v17;
v22 = &a1[v14];
switch ( v15 )
{
case 0:
if ( v48 >= 0 )
{
v23 = 0LL;
v24 = a4;
do
{
*(_WORD *)(v21 + 1 * v23) = v22[v23];
*(_WORD *)(v21 + 1 * v23 + 2) = -1;
--v24;
++v23;
}
while ( v24 > 0 );
}
break;
case 1:
if ( v48 >= 0 )
{
v36 = (unsigned __int16 *)(v50 + 2LL * v17);
v37 = a4;
do
{
v38 = *v19;
*v36 = *v19;
*(v36 - 1) = v38;
*(v36 - 2) = v38;
++v19;
--v37;
v36 += 3;
}
while ( v37 > 0 );
}
break;
case 2:
if ( v48 >= 0 )
{
v34 = 0LL;
v35 = a4;
do
{
*(_QWORD *)(v21 + 2 * v34) = _mm_shufflelo_epi16(_mm_insert_epi16(si128, v22[v34], 0), 64).m128i_u64[0];
--v35;
++v34;
}
while ( v35 > 0 );
}
break;
case 7:
if ( v48 >= 0 )
{
v32 = 0LL;
v33 = a4;
do
{
*(_WORD *)(v21 + v32) = v22[v32];
--v33;
v32 += 2LL;
}
while ( v33 > 0 );
}
break;
case 9:
if ( v48 >= 0 )
{
v27 = (unsigned __int16 *)(v50 + 2LL * v17);
v28 = a4;
do
{
v29 = *v19;
*v27 = *v19;
*(v27 - 1) = v29;
*(v27 - 2) = v29;
v19 += 2;
--v28;
v27 += 3;
}
while ( v28 > 0 );
}
break;
case 10:
if ( v48 >= 0 )
{
v30 = 0LL;
v31 = a4;
do
{
*(_QWORD *)(v21 + 2 * v30) = _mm_shufflelo_epi16(_mm_cvtsi32_si128(*(_DWORD *)&v22[v30 / 2]), 64).m128i_u64[0];
--v31;
v30 += 4LL;
}
while ( v31 > 0 );
}
break;
case 15:
v39 = a4;
if ( v48 >= 0 )
{
do
{
*v20 = (77 * *v19 + 150 * v19[1] + 29 * (unsigned int)v19[2]) >> 8;
v19 += 3;
++v20;
--v39;
}
while ( v39 > 0 );
}
break;
case 16:
v40 = a4;
if ( v48 >= 0 )
{
do
{
*v20 = (77 * *v19 + 150 * v19[1] + 29 * (unsigned int)v19[2]) >> 8;
v20[1] = -1;
v19 += 3;
v20 += 2;
--v40;
}
while ( v40 > 0 );
}
break;
case 18:
v43 = a4;
if ( v48 >= 0 )
{
do
{
*(_DWORD *)v20 = *(_DWORD *)v19;
v20[2] = v19[2];
v20[3] = -1;
v19 += 3;
v20 += 4;
--v43;
}
while ( v43 > 0 );
}
break;
case 23:
if ( v48 >= 0 )
{
v41 = 0LL;
v42 = a4;
do
{
*(_WORD *)(v21 + v41) = (77 * v22[2 * v41]
+ 150 * v22[2 * v41 + 1]
+ 29 * (unsigned int)v22[2 * v41 + 2]) >> 8;
--v42;
v41 += 2LL;
}
while ( v42 > 0 );
}
break;
case 24:
if ( v48 >= 0 )
{
v25 = 0LL;
v26 = a4;
do
{
*(_WORD *)(v21 + v25) = (77 * v22[v25] + 150 * v22[v25 + 1] + 29 * (unsigned int)v22[v25 + 2]) >> 8;
*(_WORD *)(v21 + v25 + 2) = v22[v25 + 3];
--v26;
v25 += 4LL;
}
while ( v26 > 0 );
}
break;
default:
v44 = a4;
if ( v48 >= 0 )
{
do
{
*(_DWORD *)v20 = *(_DWORD *)v19;
v20[2] = v19[2];
v19 += 4;
v20 += 3;
--v44;
}
while ( v44 > 0 );
}
break;
}
v17 += v49;
v14 += a2 * a4;
}
goto LABEL_55;
}
}
free(a1);
free(v6);
v45 = __readfsqword(0);
v46 = "unsupported";
}
else
{
free(a1);
v45 = __readfsqword(0);
v46 = "outofmem";
}
*(_QWORD *)(v45 - 32) = v46;
return 0LL;
}
return a1;
}
| stbi__convert_format16:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RDI
MOV qword ptr [RSP + 0x8],RSI
CMP EDX,ESI
JNZ 0x0013dfa5
MOV RBX,R14
JMP 0x0013e39f
LAB_0013dfa5:
MOV EBP,R8D
MOV R15D,ECX
MOV R12D,EDX
MOV EAX,EDX
IMUL EAX,ECX
MOV dword ptr [RSP + 0x14],EAX
MOV EDI,EAX
IMUL EDI,R8D
ADD EDI,EDI
CALL 0x0011e000
TEST RAX,RAX
JZ 0x0013e37b
MOV RBX,RAX
TEST EBP,EBP
JLE 0x0013e371
MOV RAX,qword ptr [RSP + 0x8]
LEA EAX,[R12 + RAX*0x8]
CMP EAX,0x23
JA 0x0013e3b1
MOV RCX,0xe161a1c00
BT RCX,RAX
JNC 0x0013e3b1
LEA ECX,[R15 + -0x1]
MOV dword ptr [RSP + 0x4],ECX
CMP EBP,0x2
MOV ECX,0x1
CMOVGE ECX,EBP
MOV qword ptr [RSP + 0x20],RCX
MOV ECX,R15D
IMUL ECX,dword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x10],ECX
LEA RCX,[RBX + 0x4]
MOV qword ptr [RSP + 0x18],RCX
XOR R8D,R8D
ADD EAX,-0xa
MOVDQA XMM0,xmmword ptr [0x0020cd20]
XOR R10D,R10D
XOR R11D,R11D
LAB_0013e03f:
MOV ECX,R11D
IMUL ECX,R15D
MOV EDX,ECX
IMUL EDX,dword ptr [RSP + 0x8]
LEA RBP,[R14 + RDX*0x2]
IMUL ECX,R12D
LEA RCX,[RBX + RCX*0x2]
CMP EAX,0x18
JA 0x0013e334
MOV EDX,R10D
LEA RDI,[RBX + RDX*0x2]
MOV R9D,R8D
LEA R9,[R14 + R9*0x2]
LEA R13,[0x20cf40]
MOVSXD RSI,dword ptr [R13 + RAX*0x4]
ADD RSI,R13
switchD:
JMP RSI
caseD_a:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e359
XOR ECX,ECX
MOV EDX,R15D
LAB_0013e091:
MOVZX ESI,word ptr [R9 + RCX*0x1]
MOV word ptr [RDI + RCX*0x2],SI
MOV word ptr [RDI + RCX*0x2 + 0x2],0xffff
DEC EDX
ADD RCX,0x2
TEST EDX,EDX
JG 0x0013e091
JMP 0x0013e359
caseD_22:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e359
XOR ECX,ECX
MOV EBP,R15D
LAB_0013e0c0:
MOVZX EDX,word ptr [R9 + RCX*0x2]
MOVZX ESI,word ptr [R9 + RCX*0x2 + 0x2]
MOVZX R13D,word ptr [R9 + RCX*0x2 + 0x4]
IMUL EDX,EDX,0x4d
IMUL ESI,ESI,0x96
ADD ESI,EDX
LEA EDX,[R13 + R13*0x8]
LEA EDX,[RDX + RDX*0x2]
ADD R13D,R13D
ADD R13D,EDX
ADD R13D,ESI
SHR R13D,0x8
MOV word ptr [RDI + RCX*0x1],R13W
MOVZX EDX,word ptr [R9 + RCX*0x2 + 0x6]
MOV word ptr [RDI + RCX*0x1 + 0x2],DX
DEC EBP
ADD RCX,0x4
TEST EBP,EBP
JG 0x0013e0c0
JMP 0x0013e359
caseD_13:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e359
MOV RCX,qword ptr [RSP + 0x18]
LEA RCX,[RCX + RDX*0x2]
MOV EDI,R15D
LAB_0013e127:
MOVZX EDX,word ptr [RBP]
MOV word ptr [RCX],DX
MOV word ptr [RCX + -0x2],DX
MOV word ptr [RCX + -0x4],DX
ADD RBP,0x4
DEC EDI
ADD RCX,0x6
TEST EDI,EDI
JG 0x0013e127
JMP 0x0013e359
caseD_14:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e359
XOR ECX,ECX
MOV EDX,R15D
LAB_0013e159:
MOVD XMM1,dword ptr [R9 + RCX*0x1]
PSHUFLW XMM1,XMM1,0x40
MOVQ qword ptr [RDI + RCX*0x2],XMM1
DEC EDX
ADD RCX,0x4
TEST EDX,EDX
JG 0x0013e159
JMP 0x0013e359
caseD_11:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e359
XOR ECX,ECX
MOV EDX,R15D
LAB_0013e188:
MOVZX ESI,word ptr [R9 + RCX*0x2]
MOV word ptr [RDI + RCX*0x1],SI
DEC EDX
ADD RCX,0x2
TEST EDX,EDX
JG 0x0013e188
JMP 0x0013e359
caseD_c:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e359
XOR ECX,ECX
MOV EDX,R15D
LAB_0013e1b0:
MOVDQA XMM1,XMM0
PINSRW XMM1,word ptr [R9 + RCX*0x1],0x0
PSHUFLW XMM1,XMM1,0x40
MOVQ qword ptr [RDI + RCX*0x4],XMM1
DEC EDX
ADD RCX,0x2
TEST EDX,EDX
JG 0x0013e1b0
JMP 0x0013e359
caseD_b:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e359
MOV RCX,qword ptr [RSP + 0x18]
LEA RCX,[RCX + RDX*0x2]
MOV EDI,R15D
LAB_0013e1eb:
MOVZX EDX,word ptr [RBP]
MOV word ptr [RCX],DX
MOV word ptr [RCX + -0x2],DX
MOV word ptr [RCX + -0x4],DX
ADD RBP,0x2
DEC EDI
ADD RCX,0x6
TEST EDI,EDI
JG 0x0013e1eb
JMP 0x0013e359
caseD_19:
MOV EDI,R15D
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e359
LAB_0013e21b:
MOVZX EDX,word ptr [RBP]
MOVZX ESI,word ptr [RBP + 0x2]
MOVZX R9D,word ptr [RBP + 0x4]
IMUL EDX,EDX,0x4d
IMUL ESI,ESI,0x96
ADD ESI,EDX
LEA EDX,[R9 + R9*0x8]
LEA EDX,[RDX + RDX*0x2]
ADD R9D,R9D
ADD R9D,EDX
ADD R9D,ESI
SHR R9D,0x8
MOV word ptr [RCX],R9W
ADD RBP,0x6
ADD RCX,0x2
DEC EDI
TEST EDI,EDI
JG 0x0013e21b
JMP 0x0013e359
caseD_1a:
MOV EDI,R15D
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e359
LAB_0013e26c:
MOVZX EDX,word ptr [RBP]
MOVZX ESI,word ptr [RBP + 0x2]
MOVZX R9D,word ptr [RBP + 0x4]
IMUL EDX,EDX,0x4d
IMUL ESI,ESI,0x96
ADD ESI,EDX
LEA EDX,[R9 + R9*0x8]
LEA EDX,[RDX + RDX*0x2]
ADD R9D,R9D
ADD R9D,EDX
ADD R9D,ESI
SHR R9D,0x8
MOV word ptr [RCX],R9W
MOV word ptr [RCX + 0x2],0xffff
ADD RBP,0x6
ADD RCX,0x4
DEC EDI
TEST EDI,EDI
JG 0x0013e26c
JMP 0x0013e359
caseD_21:
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e359
XOR ECX,ECX
MOV EBP,R15D
LAB_0013e2c5:
MOVZX EDX,word ptr [R9 + RCX*0x4]
MOVZX ESI,word ptr [R9 + RCX*0x4 + 0x2]
MOVZX R13D,word ptr [R9 + RCX*0x4 + 0x4]
IMUL EDX,EDX,0x4d
IMUL ESI,ESI,0x96
ADD ESI,EDX
LEA EDX,[R13 + R13*0x8]
LEA EDX,[RDX + RDX*0x2]
ADD R13D,R13D
ADD R13D,EDX
ADD R13D,ESI
SHR R13D,0x8
MOV word ptr [RDI + RCX*0x1],R13W
DEC EBP
ADD RCX,0x2
TEST EBP,EBP
JG 0x0013e2c5
JMP 0x0013e359
caseD_1c:
MOV EDI,R15D
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e359
LAB_0013e311:
MOV EDX,dword ptr [RBP]
MOV dword ptr [RCX],EDX
MOVZX EDX,word ptr [RBP + 0x4]
MOV word ptr [RCX + 0x4],DX
MOV word ptr [RCX + 0x6],0xffff
ADD RBP,0x6
ADD RCX,0x8
DEC EDI
TEST EDI,EDI
JG 0x0013e311
JMP 0x0013e359
caseD_d:
MOV EDI,R15D
CMP dword ptr [RSP + 0x4],0x0
JS 0x0013e359
LAB_0013e33e:
MOV EDX,dword ptr [RBP]
MOV dword ptr [RCX],EDX
MOVZX EDX,word ptr [RBP + 0x4]
MOV word ptr [RCX + 0x4],DX
ADD RBP,0x8
ADD RCX,0x6
DEC EDI
TEST EDI,EDI
JG 0x0013e33e
LAB_0013e359:
INC R11
ADD R10D,dword ptr [RSP + 0x14]
ADD R8D,dword ptr [RSP + 0x10]
CMP R11,qword ptr [RSP + 0x20]
JNZ 0x0013e03f
LAB_0013e371:
MOV RDI,R14
CALL 0x0011de70
JMP 0x0013e39f
LAB_0013e37b:
MOV RDI,R14
CALL 0x0011de70
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x20e5c3]
LAB_0013e396:
MOV qword ptr [RAX + -0x20],RCX
XOR EBX,EBX
LAB_0013e39f:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013e3b1:
MOV RDI,R14
CALL 0x0011de70
MOV RDI,RBX
CALL 0x0011de70
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x20e5ff]
JMP 0x0013e396
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* stbi__convert_format16(unsigned short*, int, int, unsigned int, unsigned int) */
ushort * stbi__convert_format16(ushort *param_1,int param_2,int param_3,uint param_4,uint param_5)
{
int iVar1;
ushort uVar2;
ulong uVar3;
int8 uVar4;
uint uVar5;
ushort *__ptr;
int iVar6;
ulong uVar7;
long lVar8;
ushort *puVar9;
char *pcVar10;
ushort *puVar11;
uint uVar12;
ulong uVar13;
ulong uVar14;
ulong uVar15;
long *in_FS_OFFSET;
int1 auVar16 [16];
if (param_3 == param_2) {
return param_1;
}
__ptr = (ushort *)malloc((ulong)(param_3 * param_4 * param_5 * 2));
uVar4 = _UNK_0020cd28;
uVar3 = ram0x0020cd20;
if (__ptr == (ushort *)0x0) {
free(param_1);
lVar8 = *in_FS_OFFSET;
pcVar10 = "outofmem";
LAB_0013e396:
*(char **)(lVar8 + -0x20) = pcVar10;
__ptr = (ushort *)0x0;
}
else {
if (0 < (int)param_5) {
uVar5 = param_3 + param_2 * 8;
if ((0x23 < uVar5) || ((0xe161a1c00U >> ((ulong)uVar5 & 0x3f) & 1) == 0)) {
free(param_1);
free(__ptr);
lVar8 = *in_FS_OFFSET;
pcVar10 = "unsupported";
goto LAB_0013e396;
}
iVar1 = param_4 - 1;
uVar7 = 1;
if (1 < (int)param_5) {
uVar7 = (ulong)param_5;
}
uVar13 = 0;
uVar14 = 0;
uVar15 = 0;
do {
iVar6 = (int)uVar15 * param_4;
puVar11 = param_1 + (uint)(iVar6 * param_2);
puVar9 = __ptr + (uint)(iVar6 * param_3);
switch(uVar5) {
case 10:
if (-1 < iVar1) {
lVar8 = 0;
uVar12 = param_4;
do {
__ptr[uVar14 + lVar8] = *(ushort *)((long)param_1 + lVar8 + uVar13 * 2);
__ptr[uVar14 + lVar8 + 1] = 0xffff;
uVar12 = uVar12 - 1;
lVar8 = lVar8 + 2;
} while (0 < (int)uVar12);
}
break;
case 0xb:
if (-1 < iVar1) {
puVar9 = __ptr + uVar14 + 2;
uVar12 = param_4;
do {
uVar2 = *puVar11;
*puVar9 = uVar2;
puVar9[-1] = uVar2;
puVar9[-2] = uVar2;
puVar11 = puVar11 + 1;
uVar12 = uVar12 - 1;
puVar9 = puVar9 + 3;
} while (0 < (int)uVar12);
}
break;
case 0xc:
if (-1 < iVar1) {
lVar8 = 0;
uVar12 = param_4;
do {
auVar16._8_8_ = uVar4;
auVar16._0_8_ =
uVar3 & 0xffffffffffff0000 |
(ulong)*(ushort *)((long)param_1 + lVar8 + uVar13 * 2);
auVar16 = pshuflw(auVar16,auVar16,0x40);
*(long *)(__ptr + uVar14 + lVar8 * 2) = auVar16._0_8_;
uVar12 = uVar12 - 1;
lVar8 = lVar8 + 2;
} while (0 < (int)uVar12);
}
break;
default:
uVar12 = param_4;
if (-1 < iVar1) {
do {
*(int4 *)puVar9 = *(int4 *)puVar11;
puVar9[2] = puVar11[2];
puVar11 = puVar11 + 4;
puVar9 = puVar9 + 3;
uVar12 = uVar12 - 1;
} while (0 < (int)uVar12);
}
break;
case 0x11:
if (-1 < iVar1) {
lVar8 = 0;
uVar12 = param_4;
do {
*(ushort *)((long)__ptr + lVar8 + uVar14 * 2) = param_1[uVar13 + lVar8];
uVar12 = uVar12 - 1;
lVar8 = lVar8 + 2;
} while (0 < (int)uVar12);
}
break;
case 0x13:
if (-1 < iVar1) {
puVar9 = __ptr + uVar14 + 2;
uVar12 = param_4;
do {
uVar2 = *puVar11;
*puVar9 = uVar2;
puVar9[-1] = uVar2;
puVar9[-2] = uVar2;
puVar11 = puVar11 + 2;
uVar12 = uVar12 - 1;
puVar9 = puVar9 + 3;
} while (0 < (int)uVar12);
}
break;
case 0x14:
if (-1 < iVar1) {
lVar8 = 0;
uVar12 = param_4;
do {
auVar16 = ZEXT416(*(uint *)((long)param_1 + lVar8 + uVar13 * 2));
auVar16 = pshuflw(auVar16,auVar16,0x40);
*(long *)(__ptr + uVar14 + lVar8) = auVar16._0_8_;
uVar12 = uVar12 - 1;
lVar8 = lVar8 + 4;
} while (0 < (int)uVar12);
}
break;
case 0x19:
uVar12 = param_4;
if (-1 < iVar1) {
do {
uVar2 = puVar11[2];
*puVar9 = (ushort)((uint)uVar2 * 2 + ((uint)uVar2 + (uint)uVar2 * 8) * 3 +
(uint)puVar11[1] * 0x96 + (uint)*puVar11 * 0x4d >> 8);
puVar11 = puVar11 + 3;
puVar9 = puVar9 + 1;
uVar12 = uVar12 - 1;
} while (0 < (int)uVar12);
}
break;
case 0x1a:
uVar12 = param_4;
if (-1 < iVar1) {
do {
uVar2 = puVar11[2];
*puVar9 = (ushort)((uint)uVar2 * 2 + ((uint)uVar2 + (uint)uVar2 * 8) * 3 +
(uint)puVar11[1] * 0x96 + (uint)*puVar11 * 0x4d >> 8);
puVar9[1] = 0xffff;
puVar11 = puVar11 + 3;
puVar9 = puVar9 + 2;
uVar12 = uVar12 - 1;
} while (0 < (int)uVar12);
}
break;
case 0x1c:
uVar12 = param_4;
if (-1 < iVar1) {
do {
*(int4 *)puVar9 = *(int4 *)puVar11;
puVar9[2] = puVar11[2];
puVar9[3] = 0xffff;
puVar11 = puVar11 + 3;
puVar9 = puVar9 + 4;
uVar12 = uVar12 - 1;
} while (0 < (int)uVar12);
}
break;
case 0x21:
if (-1 < iVar1) {
lVar8 = 0;
uVar12 = param_4;
do {
uVar2 = param_1[uVar13 + lVar8 * 2 + 2];
*(short *)((long)__ptr + lVar8 + uVar14 * 2) =
(short)((uint)uVar2 * 2 + ((uint)uVar2 + (uint)uVar2 * 8) * 3 +
(uint)param_1[uVar13 + lVar8 * 2 + 1] * 0x96 +
(uint)param_1[uVar13 + lVar8 * 2] * 0x4d >> 8);
uVar12 = uVar12 - 1;
lVar8 = lVar8 + 2;
} while (0 < (int)uVar12);
}
break;
case 0x22:
if (-1 < iVar1) {
lVar8 = 0;
uVar12 = param_4;
do {
uVar2 = param_1[uVar13 + lVar8 + 2];
*(short *)((long)__ptr + lVar8 + uVar14 * 2) =
(short)((uint)uVar2 * 2 + ((uint)uVar2 + (uint)uVar2 * 8) * 3 +
(uint)param_1[uVar13 + lVar8 + 1] * 0x96 +
(uint)param_1[uVar13 + lVar8] * 0x4d >> 8);
*(ushort *)((long)__ptr + lVar8 + uVar14 * 2 + 2) = param_1[uVar13 + lVar8 + 3];
uVar12 = uVar12 - 1;
lVar8 = lVar8 + 4;
} while (0 < (int)uVar12);
}
}
uVar15 = uVar15 + 1;
uVar14 = (ulong)((int)uVar14 + param_3 * param_4);
uVar13 = (ulong)((int)uVar13 + param_4 * param_2);
} while (uVar15 != uVar7);
}
free(param_1);
}
return __ptr;
}
| |
50,642 | my_uuid_init | eloqsql/mysys/my_uuid.c | void my_uuid_init(ulong seed1, ulong seed2)
{
uchar *mac= uuid_suffix+2;
ulonglong now;
if (my_uuid_inited)
return;
my_uuid_inited= 1;
now= my_interval_timer()/100 + interval_timer_offset;
nanoseq= 0;
if (my_gethwaddr(mac))
{
uint i;
/*
Generating random "hardware addr"
Specs explicitly specify that node identifier should NOT
correlate with a clock_seq value, so we use a separate
randominit() here.
*/
/* purecov: begin inspected */
my_rnd_init(&uuid_rand, (ulong) (seed2+ now/2), (ulong) (now+rand()));
for (i=0; i < array_elements(uuid_suffix) -2 ; i++)
mac[i]= (uchar)(my_rnd(&uuid_rand)*255);
/* purecov: end */
}
my_rnd_init(&uuid_rand, (ulong) (seed1 + now), (ulong) (now/2+ getpid()));
set_clock_seq();
mysql_mutex_init(key_LOCK_uuid_generator, &LOCK_uuid_generator, MY_MUTEX_INIT_FAST);
} | O3 | c | my_uuid_init:
cmpb $0x0, 0xb6234d(%rip) # 0xc08580
je 0xa6236
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, -0x30(%rbp)
movb $0x1, 0xb6232e(%rip) # 0xc08580
callq 0x9e560
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
movq %rdx, %r14
shrq $0x2, %r14
addq 0xb62312(%rip), %r14 # 0xc08588
movl $0x0, 0xb62310(%rip) # 0xc08590
leaq 0xb622f3(%rip), %rdi # 0xc0857a
callq 0xa8fe4
movq %r14, %r15
shrq %r15
testb %al, %al
je 0xa62e4
addq %r15, %r12
callq 0x29780
movslq %eax, %rdx
addq %r14, %rdx
leaq 0xb622ed(%rip), %r13 # 0xc08598
movq %r13, %rdi
movq %r12, %rsi
callq 0xa9264
movl $0x2, %r12d
leaq 0xb622b5(%rip), %rbx # 0xc08578
movq %r13, %rdi
callq 0xa92da
mulsd 0x3ac45(%rip), %xmm0 # 0xe0f18
cvttsd2si %xmm0, %eax
movb %al, (%r12,%rbx)
incq %r12
cmpq $0x8, %r12
jne 0xa62c3
addq -0x30(%rbp), %r14
callq 0x298f0
cltq
addq %rax, %r15
leaq 0xb6229f(%rip), %rdi # 0xc08598
movq %r14, %rsi
movq %r15, %rdx
callq 0xa9264
callq 0xa658c
leaq 0xb61588(%rip), %rax # 0xc07898
movl (%rax), %edi
leaq 0x2dfcf7(%rip), %rax # 0x386010
movq (%rax), %rax
leaq 0xb62295(%rip), %rbx # 0xc085b8
movq %rbx, %rsi
callq *0x40(%rax)
movq %rax, 0xb622c8(%rip) # 0xc085f8
movq %rbx, 0xb622b9(%rip) # 0xc085f0
xorpd %xmm0, %xmm0
movupd %xmm0, 0xb6229d(%rip) # 0xc085e0
leaq 0xb62226(%rip), %rsi # 0xc08570
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29320
| my_uuid_init:
cmp cs:my_uuid_inited, 0
jz short loc_A6236
retn
loc_A6236:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rsi
mov [rbp-30h], rdi
mov cs:my_uuid_inited, 1
call my_interval_timer
shr rax, 2
mov rcx, 28F5C28F5C28F5C3h
mul rcx
mov r14, rdx
shr r14, 2
add r14, cs:interval_timer_offset
mov cs:nanoseq, 0
lea rdi, uuid_suffix+2
call my_gethwaddr
mov r15, r14
shr r15, 1
test al, al
jz short loc_A62E4
add r12, r15
call _rand
movsxd rdx, eax
add rdx, r14
lea r13, uuid_rand
mov rdi, r13
mov rsi, r12
call my_rnd_init
mov r12d, 2
lea rbx, uuid_suffix
loc_A62C3:
mov rdi, r13
call my_rnd
mulsd xmm0, cs:qword_E0F18
cvttsd2si eax, xmm0
mov [r12+rbx], al
inc r12
cmp r12, 8
jnz short loc_A62C3
loc_A62E4:
add r14, [rbp-30h]
call _getpid
cdqe
add r15, rax
lea rdi, uuid_rand
mov rsi, r14
mov rdx, r15
call my_rnd_init
call set_clock_seq
lea rax, key_LOCK_uuid_generator
mov edi, [rax]
lea rax, PSI_server
mov rax, [rax]
lea rbx, LOCK_uuid_generator
mov rsi, rbx
call qword ptr [rax+40h]
mov cs:qword_C085F8, rax
mov cs:qword_C085F0, rbx
xorpd xmm0, xmm0
movupd cs:xmmword_C085E0, xmm0
lea rsi, my_fast_mutexattr
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _pthread_mutex_init
| void my_uuid_init(long long a1, long long a2)
{
unsigned long long v2; // r14
unsigned long long v3; // r15
int v4; // eax
long long i; // r12
int v6; // eax
if ( !my_uuid_inited )
{
my_uuid_inited = 1;
v2 = interval_timer_offset + my_interval_timer() / 0x64uLL;
nanoseq = 0;
v3 = v2 >> 1;
if ( (unsigned __int8)my_gethwaddr((char *)&uuid_suffix + 2) )
{
v4 = rand();
my_rnd_init(&uuid_rand, v3 + a2, v2 + v4);
for ( i = 2LL; i != 8; ++i )
*((_BYTE *)&uuid_suffix + i) = (int)(my_rnd(&uuid_rand) * 255.0);
}
v6 = getpid();
my_rnd_init(&uuid_rand, a1 + v2, v6 + v3);
set_clock_seq();
qword_C085F8 = ((long long ( *)(_QWORD, void *))PSI_server[8])(
key_LOCK_uuid_generator,
&LOCK_uuid_generator);
qword_C085F0 = (long long)&LOCK_uuid_generator;
xmmword_C085E0 = 0LL;
pthread_mutex_init(&LOCK_uuid_generator, &my_fast_mutexattr);
}
}
| my_uuid_init:
CMP byte ptr [0x00d08580],0x0
JZ 0x001a6236
RET
LAB_001a6236:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RSI
MOV qword ptr [RBP + -0x30],RDI
MOV byte ptr [0x00d08580],0x1
CALL 0x0019e560
SHR RAX,0x2
MOV RCX,0x28f5c28f5c28f5c3
MUL RCX
MOV R14,RDX
SHR R14,0x2
ADD R14,qword ptr [0x00d08588]
MOV dword ptr [0x00d08590],0x0
LEA RDI,[0xd0857a]
CALL 0x001a8fe4
MOV R15,R14
SHR R15,0x1
TEST AL,AL
JZ 0x001a62e4
ADD R12,R15
CALL 0x00129780
MOVSXD RDX,EAX
ADD RDX,R14
LEA R13,[0xd08598]
MOV RDI,R13
MOV RSI,R12
CALL 0x001a9264
MOV R12D,0x2
LEA RBX,[0xd08578]
LAB_001a62c3:
MOV RDI,R13
CALL 0x001a92da
MULSD XMM0,qword ptr [0x001e0f18]
CVTTSD2SI EAX,XMM0
MOV byte ptr [R12 + RBX*0x1],AL
INC R12
CMP R12,0x8
JNZ 0x001a62c3
LAB_001a62e4:
ADD R14,qword ptr [RBP + -0x30]
CALL 0x001298f0
CDQE
ADD R15,RAX
LEA RDI,[0xd08598]
MOV RSI,R14
MOV RDX,R15
CALL 0x001a9264
CALL 0x001a658c
LEA RAX,[0xd07898]
MOV EDI,dword ptr [RAX]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RBX,[0xd085b8]
MOV RSI,RBX
CALL qword ptr [RAX + 0x40]
MOV qword ptr [0x00d085f8],RAX
MOV qword ptr [0x00d085f0],RBX
XORPD XMM0,XMM0
MOVUPD xmmword ptr [0x00d085e0],XMM0
LEA RSI,[0xd08570]
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00129320
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void my_uuid_init(long param_1,long param_2)
{
char cVar1;
int iVar2;
__pid_t _Var3;
ulong uVar4;
long lVar5;
double dVar6;
if (my_uuid_inited != '\0') {
return;
}
my_uuid_inited = 1;
uVar4 = my_interval_timer();
uVar4 = uVar4 / 100 + interval_timer_offset;
nanoseq = 0;
cVar1 = my_gethwaddr(0xd0857a);
if (cVar1 != '\0') {
iVar2 = rand();
my_rnd_init(uuid_rand,param_2 + (uVar4 >> 1),(long)iVar2 + uVar4);
lVar5 = 2;
do {
dVar6 = (double)my_rnd(uuid_rand);
*(char *)((long)&uuid_suffix + lVar5) = (char)(int)(dVar6 * _DAT_001e0f18);
lVar5 = lVar5 + 1;
} while (lVar5 != 8);
}
_Var3 = getpid();
my_rnd_init(uuid_rand,uVar4 + param_1,(uVar4 >> 1) + (long)_Var3);
set_clock_seq();
LOCK_uuid_generator._64_8_ =
(**(code **)(PSI_server + 0x40))(key_LOCK_uuid_generator,LOCK_uuid_generator);
LOCK_uuid_generator._56_8_ = LOCK_uuid_generator;
LOCK_uuid_generator._40_8_ = 0;
LOCK_uuid_generator._48_8_ = 0;
pthread_mutex_init((pthread_mutex_t *)LOCK_uuid_generator,
(pthread_mutexattr_t *)&my_fast_mutexattr);
return;
}
| |
50,643 | my_longlong10_to_str_8bit | eloqsql/strings/ctype-simple.c | size_t my_longlong10_to_str_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t len, int radix,
longlong val)
{
char buffer[65];
register char *p, *e;
long long_val;
uint sign= 0;
ulonglong uval = (ulonglong)val;
if (radix < 0)
{
if (val < 0)
{
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (ulonglong)0 - uval;
*dst++= '-';
len--;
sign= 1;
}
}
e = p = &buffer[sizeof(buffer)-1];
*p= 0;
if (uval == 0)
{
*--p= '0';
len= 1;
goto cnv;
}
while (uval > (ulonglong) LONG_MAX)
{
ulonglong quo= uval/(uint) 10;
uint rem= (uint) (uval- quo* (uint) 10);
*--p = '0' + rem;
uval= quo;
}
long_val= (long) uval;
while (long_val != 0)
{
long quo= long_val/10;
*--p = (char) ('0' + (long_val - quo*10));
long_val= quo;
}
len= MY_MIN(len, (size_t) (e-p));
cnv:
memcpy(dst, p, len);
return len+sign;
} | O3 | c | my_longlong10_to_str_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r9
movq %rsi, %rdi
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
testl %ecx, %ecx
setns %al
testq %r8, %r8
setns %cl
orb %al, %cl
jne 0xb594a
negq %r8
movb $0x2d, (%rdi)
incq %rdi
decq %r9
leaq -0x20(%rbp), %rbx
movb $0x0, (%rbx)
movl $0x1, %r14d
jmp 0xb595e
movb $0x0, -0x20(%rbp)
testq %r8, %r8
je 0xb59ea
leaq -0x20(%rbp), %rbx
xorl %r14d, %r14d
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
testq %r8, %r8
js 0xb5972
movq %rbx, %rsi
jmp 0xb5993
movq %r8, %rax
mulq %rcx
shrq $0x3, %rdx
leaq -0x21(%rbp), %rsi
imull $0xf6, %edx, %eax
addl %eax, %r8d
addb $0x30, %r8b
movb %r8b, (%rsi)
movq %rdx, %r8
subq %rsi, %rbx
movq %r8, %rax
mulq %rcx
shrq $0x3, %rdx
imull $0xf6, %edx, %eax
addl %r8d, %eax
addb $0x30, %al
movb %al, -0x1(%rsi)
decq %rsi
incq %rbx
cmpq $0x9, %r8
movq %rdx, %r8
ja 0xb5996
cmpq %rbx, %r9
cmovbq %r9, %rbx
movq %rbx, %rdx
callq 0x29080
movq %fs:0x28, %rax
cmpq -0x18(%rbp), %rax
jne 0xb59fb
addq %r14, %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x21(%rbp), %rsi
movb $0x30, (%rsi)
movl $0x1, %ebx
xorl %r14d, %r14d
jmp 0xb59c4
callq 0x29270
| my_longlong10_to_str_8bit:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 50h
mov r9, rdx
mov rdi, rsi
mov rax, fs:28h
mov [rbp+var_18], rax
test ecx, ecx
setns al
test r8, r8
setns cl
or cl, al
jnz short loc_B594A
neg r8
mov byte ptr [rdi], 2Dh ; '-'
inc rdi
dec r9
lea rbx, [rbp+var_20]
mov byte ptr [rbx], 0
mov r14d, 1
jmp short loc_B595E
loc_B594A:
mov [rbp+var_20], 0
test r8, r8
jz loc_B59EA
lea rbx, [rbp+var_20]
xor r14d, r14d
loc_B595E:
mov rcx, 0CCCCCCCCCCCCCCCDh
test r8, r8
js short loc_B5972
mov rsi, rbx
jmp short loc_B5993
loc_B5972:
mov rax, r8
mul rcx
shr rdx, 3
lea rsi, [rbp+var_21]
imul eax, edx, 0F6h
add r8d, eax
add r8b, 30h ; '0'
mov [rsi], r8b
mov r8, rdx
loc_B5993:
sub rbx, rsi
loc_B5996:
mov rax, r8
mul rcx
shr rdx, 3
imul eax, edx, 0F6h
add eax, r8d
add al, 30h ; '0'
mov [rsi-1], al
dec rsi
inc rbx
cmp r8, 9
mov r8, rdx
ja short loc_B5996
cmp r9, rbx
cmovb rbx, r9
loc_B59C4:
mov rdx, rbx
call _memcpy
mov rax, fs:28h
cmp rax, [rbp+var_18]
jnz short loc_B59FB
add rbx, r14
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_B59EA:
lea rsi, [rbp+var_21]
mov byte ptr [rsi], 30h ; '0'
mov ebx, 1
xor r14d, r14d
jmp short loc_B59C4
loc_B59FB:
call ___stack_chk_fail
| _BYTE * my_longlong10_to_str_8bit(long long a1, _BYTE *a2, _BYTE *a3, int a4, unsigned long long a5)
{
_BYTE *v5; // r9
_BYTE *v6; // rdi
long long v7; // r14
char *v8; // rsi
_BYTE *v9; // rbx
bool v10; // cc
char v12; // [rsp+3Fh] [rbp-21h] BYREF
_BYTE v13[8]; // [rsp+40h] [rbp-20h] BYREF
unsigned long long v14; // [rsp+48h] [rbp-18h]
v5 = a3;
v6 = a2;
v14 = __readfsqword(0x28u);
if ( a4 >= 0 || (a5 & 0x8000000000000000LL) == 0LL )
{
v13[0] = 0;
if ( !a5 )
{
v8 = &v12;
v12 = 48;
v9 = (_BYTE *)(&dword_0 + 1);
v7 = 0LL;
goto LABEL_12;
}
v7 = 0LL;
}
else
{
a5 = -(long long)a5;
*a2 = 45;
v6 = a2 + 1;
v5 = a3 - 1;
v13[0] = 0;
v7 = 1LL;
}
if ( (a5 & 0x8000000000000000LL) != 0LL )
{
v8 = &v12;
v12 = a5 % 0xA + 48;
a5 /= 0xAuLL;
}
else
{
v8 = v13;
}
v9 = (_BYTE *)(v13 - v8);
do
{
*--v8 = a5 % 0xA + 48;
++v9;
v10 = a5 <= 9;
a5 /= 0xAuLL;
}
while ( !v10 );
if ( v5 < v9 )
v9 = v5;
LABEL_12:
memcpy(v6, v8, v9);
return &v9[v7];
}
| my_longlong10_to_str_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R9,RDX
MOV RDI,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
TEST ECX,ECX
SETNS AL
TEST R8,R8
SETNS CL
OR CL,AL
JNZ 0x001b594a
NEG R8
MOV byte ptr [RDI],0x2d
INC RDI
DEC R9
LEA RBX,[RBP + -0x20]
MOV byte ptr [RBX],0x0
MOV R14D,0x1
JMP 0x001b595e
LAB_001b594a:
MOV byte ptr [RBP + -0x20],0x0
TEST R8,R8
JZ 0x001b59ea
LEA RBX,[RBP + -0x20]
XOR R14D,R14D
LAB_001b595e:
MOV RCX,-0x3333333333333333
TEST R8,R8
JS 0x001b5972
MOV RSI,RBX
JMP 0x001b5993
LAB_001b5972:
MOV RAX,R8
MUL RCX
SHR RDX,0x3
LEA RSI,[RBP + -0x21]
IMUL EAX,EDX,0xf6
ADD R8D,EAX
ADD R8B,0x30
MOV byte ptr [RSI],R8B
MOV R8,RDX
LAB_001b5993:
SUB RBX,RSI
LAB_001b5996:
MOV RAX,R8
MUL RCX
SHR RDX,0x3
IMUL EAX,EDX,0xf6
ADD EAX,R8D
ADD AL,0x30
MOV byte ptr [RSI + -0x1],AL
DEC RSI
INC RBX
CMP R8,0x9
MOV R8,RDX
JA 0x001b5996
CMP R9,RBX
CMOVC RBX,R9
LAB_001b59c4:
MOV RDX,RBX
CALL 0x00129080
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x001b59fb
ADD RBX,R14
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_001b59ea:
LEA RSI,[RBP + -0x21]
MOV byte ptr [RSI],0x30
MOV EBX,0x1
XOR R14D,R14D
JMP 0x001b59c4
LAB_001b59fb:
CALL 0x00129270
|
long my_longlong10_to_str_8bit
(int8 param_1,int1 *param_2,ulong param_3,int param_4,ulong param_5)
{
bool bVar1;
ulong __n;
char *__src;
long lVar2;
long in_FS_OFFSET;
char local_29 [9];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if ((long)param_5 < 0 && param_4 < 0) {
param_5 = -param_5;
*param_2 = 0x2d;
param_2 = param_2 + 1;
param_3 = param_3 - 1;
lVar2 = 1;
}
else {
if (param_5 == 0) {
__src = local_29;
local_29[0] = '0';
__n = 1;
lVar2 = 0;
goto LAB_001b59c4;
}
lVar2 = 0;
}
__src = local_29 + 1;
if ((long)param_5 < 0) {
local_29[0] = (char)param_5 + (char)(param_5 / 10) * -10 + '0';
__src = local_29;
param_5 = param_5 / 10;
}
__n = (long)(local_29 + 1) - (long)__src;
do {
__src[-1] = (char)(param_5 / 10) * -10 + (char)param_5 + '0';
__src = __src + -1;
__n = __n + 1;
bVar1 = 9 < param_5;
param_5 = param_5 / 10;
} while (bVar1);
if (param_3 < __n) {
__n = param_3;
}
LAB_001b59c4:
local_29[1] = 0;
memcpy(param_2,__src,__n);
if (*(long *)(in_FS_OFFSET + 0x28) != local_20) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __n + lVar2;
}
| |
50,644 | js_std_file_close | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_close(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSRuntime *rt = JS_GetRuntime(ctx);
JSThreadState *ts = js_get_thread_state(rt);
JSSTDFile *s = JS_GetOpaque2(ctx, this_val, ts->std_file_class_id);
int err;
if (!s)
return JS_EXCEPTION;
if (!s->f)
return JS_ThrowTypeError(ctx, "invalid file handle");
if (is_stdio(s->f))
return JS_ThrowTypeError(ctx, "cannot close stdio");
#if !defined(__wasi__)
if (s->is_popen)
err = js_get_errno(pclose(s->f));
else
#endif
err = js_get_errno(fclose(s->f));
s->f = NULL;
return JS_NewInt32(ctx, err);
} | O0 | c | js_std_file_close:
subq $0x78, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2e1f0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x178c0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x78(%rax), %ecx
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x3e6a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x18c49
movl $0x0, 0x48(%rsp)
movq $0x6, 0x50(%rsp)
jmp 0x18d2c
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x18c76
movq 0x30(%rsp), %rdi
leaq 0xf721c(%rip), %rsi # 0x10fe7c
movb $0x0, %al
callq 0x335f0
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
jmp 0x18d2c
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x18b70
cmpl $0x0, %eax
je 0x18caa
movq 0x30(%rsp), %rdi
leaq 0xf71fc(%rip), %rsi # 0x10fe90
movb $0x0, %al
callq 0x335f0
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
jmp 0x18d2c
movq 0x8(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x18cd0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xe2e0
movslq %eax, %rdi
callq 0x19d40
movl %eax, 0x4(%rsp)
jmp 0x18ce9
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xe240
movslq %eax, %rdi
callq 0x19d40
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x30(%rsp), %rcx
movl 0x4(%rsp), %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x68(%rsp)
movq $0x0, 0x70(%rsp)
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x78, %rsp
retq
nopl (%rax,%rax)
| js_std_file_close:
sub rsp, 78h
mov [rsp+78h+var_40], rsi
mov [rsp+78h+var_38], rdx
mov [rsp+78h+var_48], rdi
mov [rsp+78h+var_4C], ecx
mov [rsp+78h+var_58], r8
mov rdi, [rsp+78h+var_48]
call JS_GetRuntime
mov [rsp+78h+var_60], rax
mov rdi, [rsp+78h+var_60]
call js_get_thread_state
mov [rsp+78h+var_68], rax
mov rdi, [rsp+78h+var_48]
mov rax, [rsp+78h+var_68]
mov ecx, [rax+78h]
mov rsi, [rsp+78h+var_40]
mov rdx, [rsp+78h+var_38]
call JS_GetOpaque2
mov [rsp+78h+var_70], rax
cmp [rsp+78h+var_70], 0
jnz short loc_18C49
mov dword ptr [rsp+78h+var_30], 0
mov [rsp+78h+var_28], 6
jmp loc_18D2C
loc_18C49:
mov rax, [rsp+78h+var_70]
cmp qword ptr [rax], 0
jnz short loc_18C76
mov rdi, [rsp+78h+var_48]
lea rsi, aInvalidFileHan; "invalid file handle"
mov al, 0
call JS_ThrowTypeError
mov [rsp+78h+var_30], rax
mov [rsp+78h+var_28], rdx
jmp loc_18D2C
loc_18C76:
mov rax, [rsp+78h+var_70]
mov rdi, [rax]
call is_stdio
cmp eax, 0
jz short loc_18CAA
mov rdi, [rsp+78h+var_48]
lea rsi, aCannotCloseStd; "cannot close stdio"
mov al, 0
call JS_ThrowTypeError
mov [rsp+78h+var_30], rax
mov [rsp+78h+var_28], rdx
jmp loc_18D2C
loc_18CAA:
mov rax, [rsp+78h+var_70]
cmp dword ptr [rax+8], 0
jz short loc_18CD0
mov rax, [rsp+78h+var_70]
mov rdi, [rax]
call _pclose
movsxd rdi, eax
call js_get_errno
mov [rsp+78h+var_74], eax
jmp short loc_18CE9
loc_18CD0:
mov rax, [rsp+78h+var_70]
mov rdi, [rax]
call _fclose
movsxd rdi, eax
call js_get_errno
mov [rsp+78h+var_74], eax
loc_18CE9:
mov rax, [rsp+78h+var_70]
mov qword ptr [rax], 0
mov rcx, [rsp+78h+var_48]
mov eax, [rsp+78h+var_74]
mov [rsp+78h+var_18], rcx
mov [rsp+78h+var_1C], eax
mov eax, [rsp+78h+var_1C]
mov dword ptr [rsp+78h+var_10], eax
mov [rsp+78h+var_8], 0
mov rcx, [rsp+78h+var_10]
mov rax, [rsp+78h+var_8]
mov [rsp+78h+var_30], rcx
mov [rsp+78h+var_28], rax
loc_18D2C:
mov rax, [rsp+78h+var_30]
mov rdx, [rsp+78h+var_28]
add rsp, 78h
retn
| long long js_std_file_close(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
int v11; // edx
int v12; // ecx
int v13; // r8d
int v14; // r9d
int v15; // eax
int errno; // [rsp+4h] [rbp-74h]
long long *Opaque2; // [rsp+8h] [rbp-70h]
long long thread_state; // [rsp+10h] [rbp-68h]
int Runtime; // [rsp+18h] [rbp-60h]
long long v22; // [rsp+48h] [rbp-30h]
long long v23; // [rsp+68h] [rbp-10h]
Runtime = JS_GetRuntime(a1);
thread_state = js_get_thread_state(Runtime, a2, v3, v4, v5, v6);
Opaque2 = (long long *)JS_GetOpaque2(a1, a2, a3, *(unsigned int *)(thread_state + 120));
if ( Opaque2 )
{
if ( *Opaque2 )
{
if ( is_stdio(*Opaque2) )
{
return JS_ThrowTypeError(a1, (unsigned int)"cannot close stdio", v11, v12, v13, v14);
}
else
{
if ( *((_DWORD *)Opaque2 + 2) )
v15 = pclose(*Opaque2);
else
v15 = fclose(*Opaque2);
errno = js_get_errno(v15);
*Opaque2 = 0LL;
LODWORD(v23) = errno;
return v23;
}
}
else
{
return JS_ThrowTypeError(a1, (unsigned int)"invalid file handle", v7, v8, v9, v10);
}
}
else
{
LODWORD(v22) = 0;
}
return v22;
}
| js_std_file_close:
SUB RSP,0x78
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x30],RDI
MOV dword ptr [RSP + 0x2c],ECX
MOV qword ptr [RSP + 0x20],R8
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x0012e1f0
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001178c0
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RAX + 0x78]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
CALL 0x0013e6a0
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00118c49
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x6
JMP 0x00118d2c
LAB_00118c49:
MOV RAX,qword ptr [RSP + 0x8]
CMP qword ptr [RAX],0x0
JNZ 0x00118c76
MOV RDI,qword ptr [RSP + 0x30]
LEA RSI,[0x20fe7c]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x50],RDX
JMP 0x00118d2c
LAB_00118c76:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
CALL 0x00118b70
CMP EAX,0x0
JZ 0x00118caa
MOV RDI,qword ptr [RSP + 0x30]
LEA RSI,[0x20fe90]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x50],RDX
JMP 0x00118d2c
LAB_00118caa:
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x00118cd0
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
CALL 0x0010e2e0
MOVSXD RDI,EAX
CALL 0x00119d40
MOV dword ptr [RSP + 0x4],EAX
JMP 0x00118ce9
LAB_00118cd0:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX]
CALL 0x0010e240
MOVSXD RDI,EAX
CALL 0x00119d40
MOV dword ptr [RSP + 0x4],EAX
LAB_00118ce9:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],0x0
MOV RCX,qword ptr [RSP + 0x30]
MOV EAX,dword ptr [RSP + 0x4]
MOV qword ptr [RSP + 0x60],RCX
MOV dword ptr [RSP + 0x5c],EAX
MOV EAX,dword ptr [RSP + 0x5c]
MOV dword ptr [RSP + 0x68],EAX
MOV qword ptr [RSP + 0x70],0x0
MOV RCX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x48],RCX
MOV qword ptr [RSP + 0x50],RAX
LAB_00118d2c:
MOV RAX,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
ADD RSP,0x78
RET
|
int1 [16] js_std_file_close(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
int8 uVar2;
long lVar3;
long *plVar4;
int1 auVar5 [16];
int4 local_74;
int4 local_30;
int4 uStack_2c;
int8 local_28;
int4 uStack_c;
uVar2 = JS_GetRuntime(param_1);
lVar3 = js_get_thread_state(uVar2);
plVar4 = (long *)JS_GetOpaque2(param_1,param_2,param_3,*(int4 *)(lVar3 + 0x78));
if (plVar4 == (long *)0x0) {
local_30 = 0;
local_28 = 6;
}
else if (*plVar4 == 0) {
auVar5 = JS_ThrowTypeError(param_1,"invalid file handle");
local_28 = auVar5._8_8_;
local_30 = auVar5._0_4_;
uStack_2c = auVar5._4_4_;
}
else {
iVar1 = is_stdio(*plVar4);
if (iVar1 == 0) {
if ((int)plVar4[1] == 0) {
iVar1 = fclose((FILE *)*plVar4);
local_74 = js_get_errno((long)iVar1);
}
else {
iVar1 = pclose((FILE *)*plVar4);
local_74 = js_get_errno((long)iVar1);
}
*plVar4 = 0;
local_30 = local_74;
uStack_2c = uStack_c;
local_28 = 0;
}
else {
auVar5 = JS_ThrowTypeError(param_1,"cannot close stdio");
local_28 = auVar5._8_8_;
local_30 = auVar5._0_4_;
uStack_2c = auVar5._4_4_;
}
}
auVar5._4_4_ = uStack_2c;
auVar5._0_4_ = local_30;
auVar5._8_8_ = local_28;
return auVar5;
}
| |
50,645 | js_std_file_close | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_close(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSRuntime *rt = JS_GetRuntime(ctx);
JSThreadState *ts = js_get_thread_state(rt);
JSSTDFile *s = JS_GetOpaque2(ctx, this_val, ts->std_file_class_id);
int err;
if (!s)
return JS_EXCEPTION;
if (!s->f)
return JS_ThrowTypeError(ctx, "invalid file handle");
if (is_stdio(s->f))
return JS_ThrowTypeError(ctx, "cannot close stdio");
#if !defined(__wasi__)
if (s->is_popen)
err = js_get_errno(pclose(s->f));
else
#endif
err = js_get_errno(fclose(s->f));
s->f = NULL;
return JS_NewInt32(ctx, err);
} | O2 | c | js_std_file_close:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1dd35
movq %rax, %rdi
callq 0x13e3a
movl 0x78(%rax), %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x24db7
testq %rax, %rax
je 0x14957
movq %rax, %rbx
movq (%rax), %r15
testq %r15, %r15
je 0x14960
movq %r15, %rdi
callq 0x148d7
testl %eax, %eax
je 0x14980
leaq 0x7142f(%rip), %rsi # 0x85d84
jmp 0x14967
pushq $0x6
popq %rdx
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x149a8
leaq 0x71409(%rip), %rsi # 0x85d70
movq %r14, %rdi
xorl %eax, %eax
callq 0x201fd
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
jmp 0x149a8
cmpl $0x0, 0x8(%rbx)
je 0x14990
movq %r15, %rdi
callq 0xe300
jmp 0x14998
movq %r15, %rdi
callq 0xe260
movslq %eax, %rdi
callq 0x14f5b
andq $0x0, (%rbx)
xorl %ecx, %ecx
xorl %edx, %edx
movl %eax, %eax
orq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
| js_std_file_close:
push r15
push r14
push rbx
mov rbx, rdx
mov r15, rsi
mov r14, rdi
call JS_GetRuntime
mov rdi, rax
call js_get_thread_state
mov ecx, [rax+78h]
mov rdi, r14
mov rsi, r15
mov rdx, rbx
call JS_GetOpaque2
test rax, rax
jz short loc_14957
mov rbx, rax
mov r15, [rax]
test r15, r15
jz short loc_14960
mov rdi, r15
call is_stdio
test eax, eax
jz short loc_14980
lea rsi, aCannotCloseStd; "cannot close stdio"
jmp short loc_14967
loc_14957:
push 6
pop rdx
xor eax, eax
xor ecx, ecx
jmp short loc_149A8
loc_14960:
lea rsi, aInvalidFileHan; "invalid file handle"
loc_14967:
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
jmp short loc_149A8
loc_14980:
cmp dword ptr [rbx+8], 0
jz short loc_14990
mov rdi, r15
call _pclose
jmp short loc_14998
loc_14990:
mov rdi, r15
call _fclose
loc_14998:
movsxd rdi, eax
call js_get_errno
and qword ptr [rbx], 0
xor ecx, ecx
xor edx, edx
loc_149A8:
mov eax, eax
or rax, rcx
pop rbx
pop r14
pop r15
retn
| unsigned long long js_std_file_close(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; // rbx
long long v16; // r15
const char *v17; // rsi
long long v18; // rax
unsigned long long v19; // rcx
int v20; // eax
char v22; // [rsp+0h] [rbp-18h]
Runtime = JS_GetRuntime(a1);
thread_state = js_get_thread_state(Runtime, a2, v5, v6, v7, v8, v22);
Opaque2 = (long long *)JS_GetOpaque2(a1, a2, a3, *(unsigned int *)(thread_state + 120));
if ( Opaque2 )
{
v15 = Opaque2;
v16 = *Opaque2;
if ( !*Opaque2 )
{
v17 = "invalid file handle";
goto LABEL_7;
}
if ( (unsigned int)is_stdio(*Opaque2) )
{
v17 = "cannot close stdio";
LABEL_7:
v18 = JS_ThrowTypeError(a1, (_DWORD)v17, v11, v12, v13, v14);
v19 = v18 & 0xFFFFFFFF00000000LL;
return v19 | (unsigned int)v18;
}
if ( *((_DWORD *)v15 + 2) )
v20 = pclose(v16);
else
v20 = fclose(v16);
LODWORD(v18) = js_get_errno(v20);
*v15 = 0LL;
v19 = 0LL;
}
else
{
LODWORD(v18) = 0;
v19 = 0LL;
}
return v19 | (unsigned int)v18;
}
| js_std_file_close:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
CALL 0x0011dd35
MOV RDI,RAX
CALL 0x00113e3a
MOV ECX,dword ptr [RAX + 0x78]
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
CALL 0x00124db7
TEST RAX,RAX
JZ 0x00114957
MOV RBX,RAX
MOV R15,qword ptr [RAX]
TEST R15,R15
JZ 0x00114960
MOV RDI,R15
CALL 0x001148d7
TEST EAX,EAX
JZ 0x00114980
LEA RSI,[0x185d84]
JMP 0x00114967
LAB_00114957:
PUSH 0x6
POP RDX
XOR EAX,EAX
XOR ECX,ECX
JMP 0x001149a8
LAB_00114960:
LEA RSI,[0x185d70]
LAB_00114967:
MOV RDI,R14
XOR EAX,EAX
CALL 0x001201fd
MOV RCX,-0x100000000
AND RCX,RAX
JMP 0x001149a8
LAB_00114980:
CMP dword ptr [RBX + 0x8],0x0
JZ 0x00114990
MOV RDI,R15
CALL 0x0010e300
JMP 0x00114998
LAB_00114990:
MOV RDI,R15
CALL 0x0010e260
LAB_00114998:
MOVSXD RDI,EAX
CALL 0x00114f5b
AND qword ptr [RBX],0x0
XOR ECX,ECX
XOR EDX,EDX
LAB_001149a8:
MOV EAX,EAX
OR RAX,RCX
POP RBX
POP R14
POP R15
RET
|
ulong js_std_file_close(int8 param_1,int8 param_2,int8 param_3)
{
FILE *__stream;
int iVar1;
int8 uVar2;
long lVar3;
int8 *puVar4;
ulong uVar5;
ulong uVar6;
char *pcVar7;
uVar2 = JS_GetRuntime();
lVar3 = js_get_thread_state(uVar2);
puVar4 = (int8 *)JS_GetOpaque2(param_1,param_2,param_3,*(int4 *)(lVar3 + 0x78));
if (puVar4 == (int8 *)0x0) {
uVar5 = 0;
uVar6 = 0;
}
else {
__stream = (FILE *)*puVar4;
if (__stream == (FILE *)0x0) {
pcVar7 = "invalid file handle";
}
else {
iVar1 = is_stdio(__stream);
if (iVar1 == 0) {
if (*(int *)(puVar4 + 1) == 0) {
iVar1 = fclose(__stream);
}
else {
iVar1 = pclose(__stream);
}
uVar5 = js_get_errno((long)iVar1);
*puVar4 = 0;
uVar6 = 0;
goto LAB_001149a8;
}
pcVar7 = "cannot close stdio";
}
uVar5 = JS_ThrowTypeError(param_1,pcVar7);
uVar6 = uVar5 & 0xffffffff00000000;
}
LAB_001149a8:
return uVar5 & 0xffffffff | uVar6;
}
| |
50,646 | Catch::BinaryExpr<AST::ASTTree::DSFIterator&, AST::ASTTree::DSFIterator const&>::streamReconstructedExpression(std::ostream&) const | 11AgReS1SoR11[P]Graph/build_O2/_deps/catch2-src/src/catch2/../catch2/internal/catch_decomposer.hpp | void streamReconstructedExpression( std::ostream &os ) const override {
formatReconstructedExpression
( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
} | O2 | cpp | Catch::BinaryExpr<AST::ASTTree::DSFIterator&, AST::ASTTree::DSFIterator const&>::streamReconstructedExpression(std::ostream&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x741ba(%rip), %r12 # 0x8d2d0
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x183a4
movq 0x18(%r15), %r14
movq 0x20(%r15), %r15
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x183a4
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x29d68
leaq 0x8(%rsp), %rdi
callq 0x11240
leaq 0x28(%rsp), %rdi
callq 0x11240
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11240
jmp 0x19182
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11240
movq %rbx, %rdi
callq 0x119e0
| _ZNK5Catch10BinaryExprIRKN3AST7ASTTree11DSFIteratorERS3_E29streamReconstructedExpressionERSo:
push r15
push r14
push r12
push rbx
sub rsp, 48h
mov rbx, rsi
mov r15, rdi
lea r12, _ZN5Catch6DetailL17unprintableStringE; Catch::Detail::unprintableString
lea rdi, [rsp+68h+var_40]
mov rsi, r12
call _ZNK5Catch9StringRefcvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv; Catch::StringRef::operator std::string(void)
mov r14, [r15+18h]
mov r15, [r15+20h]
lea rdi, [rsp+68h+var_60]
mov rsi, r12
call _ZNK5Catch9StringRefcvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv; Catch::StringRef::operator std::string(void)
lea rsi, [rsp+68h+var_40]
lea r8, [rsp+68h+var_60]
mov rdi, rbx
mov rdx, r14
mov rcx, r15
call _ZN5Catch29formatReconstructedExpressionERSoRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_9StringRefES8_; Catch::formatReconstructedExpression(std::ostream &,std::string const&,Catch::StringRef,std::string const&)
lea rdi, [rsp+68h+var_60]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+68h+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add rsp, 48h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_19182
mov rbx, rax
loc_19182:
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| long long Catch::BinaryExpr<AST::ASTTree::DSFIterator const&,AST::ASTTree::DSFIterator&>::streamReconstructedExpression(
long long a1,
long long a2)
{
long long v2; // r14
long long v3; // r15
_QWORD v5[4]; // [rsp+8h] [rbp-60h] BYREF
_QWORD v6[8]; // [rsp+28h] [rbp-40h] BYREF
Catch::StringRef::operator std::string(v6, (long long)&Catch::Detail::unprintableString);
v2 = *(_QWORD *)(a1 + 24);
v3 = *(_QWORD *)(a1 + 32);
Catch::StringRef::operator std::string(v5, (long long)&Catch::Detail::unprintableString);
Catch::formatReconstructedExpression(a2, v6, v2, v3, v5);
std::string::~string(v5);
return std::string::~string(v6);
}
| streamReconstructedExpression:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RSI
MOV R15,RDI
LEA R12,[0x18d2d0]
LEA RDI,[RSP + 0x28]
MOV RSI,R12
CALL 0x001183a4
MOV R14,qword ptr [R15 + 0x18]
MOV R15,qword ptr [R15 + 0x20]
LAB_0011912b:
LEA RDI,[RSP + 0x8]
MOV RSI,R12
CALL 0x001183a4
LAB_00119138:
LEA RSI,[RSP + 0x28]
LEA R8,[RSP + 0x8]
MOV RDI,RBX
MOV RDX,R14
MOV RCX,R15
CALL 0x00129d68
LAB_00119150:
LEA RDI,[RSP + 0x8]
CALL 0x00111240
LEA RDI,[RSP + 0x28]
CALL 0x00111240
ADD RSP,0x48
POP RBX
POP R12
POP R14
POP R15
RET
|
/* Catch::BinaryExpr<AST::ASTTree::DSFIterator const&,
AST::ASTTree::DSFIterator&>::streamReconstructedExpression(std::ostream&) const */
void __thiscall
Catch::BinaryExpr<AST::ASTTree::DSFIterator_const&,AST::ASTTree::DSFIterator&>::
streamReconstructedExpression
(BinaryExpr<AST::ASTTree::DSFIterator_const&,AST::ASTTree::DSFIterator&> *this,
ostream *param_1)
{
int8 uVar1;
int8 uVar2;
StringRef local_60 [32];
StringRef local_40 [32];
StringRef::operator_cast_to_string(local_40);
uVar1 = *(int8 *)(this + 0x18);
uVar2 = *(int8 *)(this + 0x20);
/* try { // try from 0011912b to 00119137 has its CatchHandler @ 0011917f */
StringRef::operator_cast_to_string(local_60);
/* try { // try from 00119138 to 0011914f has its CatchHandler @ 00119170 */
formatReconstructedExpression((Catch *)param_1,local_40,uVar1,uVar2,local_60);
std::__cxx11::string::~string((string *)local_60);
std::__cxx11::string::~string((string *)local_40);
return;
}
| |
50,647 | unsigned char const* evmone::instr::core::push<16ul>(evmone::StackTop, evmone::ExecutionState&, unsigned char const*) | corpus-core[P]colibri-stateless/build_O2/_deps/evmone_external-src/lib/evmone/instructions.hpp | inline code_iterator push(StackTop stack, ExecutionState& /*state*/, code_iterator pos) noexcept
{
constexpr auto num_full_words = Len / sizeof(uint64_t);
constexpr auto num_partial_bytes = Len % sizeof(uint64_t);
auto data = pos + 1;
stack.push(0);
auto& r = stack.top();
// Load top partial word.
if constexpr (num_partial_bytes != 0)
{
r[num_full_words] = load_partial_push_data<num_partial_bytes>(data);
data += num_partial_bytes;
}
// Load full words.
for (size_t i = 0; i < num_full_words; ++i)
{
r[num_full_words - 1 - i] = intx::be::unsafe::load<uint64_t>(data);
data += sizeof(uint64_t);
}
return pos + (Len + 1);
} | O2 | cpp | unsigned char const* evmone::instr::core::push<16ul>(evmone::StackTop, evmone::ExecutionState&, unsigned char const*):
movq %rdx, %rax
leaq 0x1(%rdx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
pushq $0x7
popq %rdx
cmpq $0x3, %rdx
je 0x3c7be
movq (%rcx), %rsi
bswapq %rsi
movq %rsi, (%rdi,%rdx,8)
addq $0x8, %rcx
decq %rdx
jmp 0x3c7a5
addq $0x21, %rax
retq
| _ZN6evmone5instr4core4pushILm32EEEPKhNS_8StackTopERNS_14ExecutionStateES4_:
mov rax, rdx
lea rcx, [rdx+1]
xorps xmm0, xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
push 7
pop rdx
loc_3C7A5:
cmp rdx, 3
jz short loc_3C7BE
mov rsi, [rcx]
bswap rsi
mov [rdi+rdx*8], rsi
add rcx, 8
dec rdx
jmp short loc_3C7A5
loc_3C7BE:
add rax, 21h ; '!'
retn
| long long evmone::instr::core::push<32ul>(long long a1, long long a2, long long a3)
{
unsigned long long *v4; // rcx
long long i; // rdx
v4 = (unsigned long long *)(a3 + 1);
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
for ( i = 7LL; i != 3; --i )
*(_QWORD *)(a1 + 8 * i) = _byteswap_uint64(*v4++);
return a3 + 33;
}
| push<32ul>:
MOV RAX,RDX
LEA RCX,[RDX + 0x1]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
PUSH 0x7
POP RDX
LAB_0013c7a5:
CMP RDX,0x3
JZ 0x0013c7be
MOV RSI,qword ptr [RCX]
BSWAP RSI
MOV qword ptr [RDI + RDX*0x8],RSI
ADD RCX,0x8
DEC RDX
JMP 0x0013c7a5
LAB_0013c7be:
ADD RAX,0x21
RET
|
/* unsigned char const* evmone::instr::core::push<32ul>(evmone::StackTop, evmone::ExecutionState&,
unsigned char const*) */
uchar * evmone::instr::core::push<32ul>(long param_1,int8 param_2,long param_3)
{
ulong uVar1;
ulong *puVar2;
long lVar3;
puVar2 = (ulong *)(param_3 + 1);
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x38) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
for (lVar3 = 7; lVar3 != 3; lVar3 = lVar3 + -1) {
uVar1 = *puVar2;
*(ulong *)(param_1 + lVar3 * 8) =
uVar1 >> 0x38 | (uVar1 & 0xff000000000000) >> 0x28 | (uVar1 & 0xff0000000000) >> 0x18 |
(uVar1 & 0xff00000000) >> 8 | (uVar1 & 0xff000000) << 8 | (uVar1 & 0xff0000) << 0x18 |
(uVar1 & 0xff00) << 0x28 | uVar1 << 0x38;
puVar2 = puVar2 + 1;
}
return (uchar *)(param_3 + 0x21);
}
| |
50,648 | minja::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Options const&) | monkey531[P]llama/common/minja.hpp | static std::shared_ptr<TemplateNode> parse(const std::string& template_str, const Options & options) {
Parser parser(std::make_shared<std::string>(normalize_newlines(template_str)), options);
auto tokens = parser.tokenize();
TemplateTokenIterator begin = tokens.begin();
auto it = begin;
TemplateTokenIterator end = tokens.end();
return parser.parseTemplate(begin, it, end, /* full= */ true);
} | O3 | cpp | minja::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Options const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %rdi
movq %rax, %rsi
callq 0x210fc
movq $0x0, 0x20(%rsp)
movl $0x30, %edi
callq 0x1a870
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0xaa3cb(%rip), %rcx # 0x128250
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
movq %rax, %rdx
addq $0x20, %rdx
movq %rdx, 0x10(%rax)
movq (%rsp), %rsi
cmpq %r15, %rsi
je 0x7deb1
movq %rsi, (%rcx)
movq 0x10(%rsp), %rsi
movq %rsi, (%rdx)
jmp 0x7deb8
movups (%r15), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rsp), %rdx
movq %rdx, 0x18(%rax)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rsi
movq %rax, 0x8(%rsi)
movq %rcx, (%rsi)
leaq 0x40(%rsp), %rdi
movq %r14, %rdx
callq 0x7ed5a
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x7defb
callq 0x6c8e8
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7df11
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a890
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x7ee24
movq (%rsp), %rax
movq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x38(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x30(%rsp), %r8
movq %rsi, (%r8)
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x814aa
movq %rsp, %rdi
callq 0x82762
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x7df69
callq 0x6c8e8
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x82762
jmp 0x7df86
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x7dfc4
callq 0x6c8e8
jmp 0x7dfc4
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x7dfae
callq 0x6c8e8
jmp 0x7dfae
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7dfc4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a890
movq %rbx, %rdi
callq 0x1af20
| _ZN5minja6Parser5parseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7OptionsE:
push r15
push r14
push rbx
sub rsp, 70h
mov r14, rdx
mov rbx, rdi
lea r15, [rsp+88h+var_78]
mov [r15-10h], r15
mov rax, [rsi]
mov rdx, [rsi+8]
add rdx, rax
mov rdi, rsp
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov [rsp+88h+var_68], 0
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
mov rcx, 100000001h
mov [rax+8], rcx
lea rcx, _ZTVSt23_Sp_counted_ptr_inplaceINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_ELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<std::string,std::allocator<std::string>,(__gnu_cxx::_Lock_policy)2>
add rcx, 10h
mov [rax], rcx
lea rcx, [rax+10h]
mov rdx, rax
add rdx, 20h ; ' '
mov [rax+10h], rdx
mov rsi, [rsp+88h+var_88]
cmp rsi, r15
jz short loc_7DEB1
mov [rcx], rsi
mov rsi, [rsp+88h+var_78]
mov [rdx], rsi
jmp short loc_7DEB8
loc_7DEB1:
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rdx], xmm0
loc_7DEB8:
mov rdx, [rsp+88h+var_80]
mov [rax+18h], rdx
mov [rsp+88h+var_88], r15
mov [rsp+88h+var_80], 0
mov byte ptr [rsp+88h+var_78], 0
lea rsi, [rsp+88h+var_68]
mov [rsi+8], rax
mov [rsi], rcx
lea rdi, [rsp+88h+var_48]
mov rdx, r14
call _ZN5minja6ParserC2ERKSt10shared_ptrINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEERKNS_7OptionsE; minja::Parser::Parser(std::shared_ptr<std::string> const&,minja::Options const&)
mov rdi, [rsp+88h+var_60]
test rdi, rdi
jz short loc_7DEFB
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7DEFB:
mov rdi, [rsp+88h+var_88]; void *
cmp rdi, r15
jz short loc_7DF11
mov rsi, [rsp+88h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7DF11:
mov rdi, rsp; this
lea rsi, [rsp+88h+var_48]
call _ZN5minja6Parser8tokenizeEv; minja::Parser::tokenize(void)
mov rax, [rsp+88h+var_88]
mov rsi, [rsp+88h+var_80]
lea rdx, [rsp+88h+var_68]
mov [rdx], rax
lea rcx, [rsp+88h+var_50]
mov [rcx], rax
lea r8, [rsp+88h+var_58]
mov [r8], rsi
lea rsi, [rsp+88h+var_48]
mov rdi, rbx
mov r9d, 1
call _ZNK5minja6Parser13parseTemplateERKN9__gnu_cxx17__normal_iteratorIPKSt10unique_ptrINS_13TemplateTokenESt14default_deleteIS4_EESt6vectorIS7_SaIS7_EEEERSD_SF_b; minja::Parser::parseTemplate(__gnu_cxx::__normal_iterator<std::unique_ptr<minja::TemplateToken> const*,std::vector<std::unique_ptr<minja::TemplateToken>>> const&,__gnu_cxx::__normal_iterator<std::unique_ptr<minja::TemplateToken> const*,std::vector<std::unique_ptr<minja::TemplateToken>>>&,__gnu_cxx::__normal_iterator<std::unique_ptr<minja::TemplateToken> const*,std::vector<std::unique_ptr<minja::TemplateToken>>> const&,bool)
mov rdi, rsp
call _ZNSt6vectorISt10unique_ptrIN5minja13TemplateTokenESt14default_deleteIS2_EESaIS5_EED2Ev; std::vector<std::unique_ptr<minja::TemplateToken>>::~vector()
mov rdi, [rsp+88h+var_40]
test rdi, rdi
jz short loc_7DF69
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7DF69:
mov rax, rbx
add rsp, 70h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp
call _ZNSt6vectorISt10unique_ptrIN5minja13TemplateTokenESt14default_deleteIS2_EESaIS5_EED2Ev; std::vector<std::unique_ptr<minja::TemplateToken>>::~vector()
jmp short loc_7DF86
mov rbx, rax
loc_7DF86:
mov rdi, [rsp+arg_40]
test rdi, rdi
jz short loc_7DFC4
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_7DFC4
mov rbx, rax
mov rdi, [rsp+arg_20]
test rdi, rdi
jz short loc_7DFAE
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_7DFAE
mov rbx, rax
loc_7DFAE:
mov rdi, [rsp+0]; void *
cmp rdi, r15
jz short loc_7DFC4
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7DFC4:
mov rdi, rbx
call __Unwind_Resume
| long long minja::Parser::parse(long long a1, long long a2, long long a3)
{
long long v4; // rax
_OWORD *v5; // rdx
void *v7; // [rsp+0h] [rbp-88h] BYREF
long long v8; // [rsp+8h] [rbp-80h]
__int128 v9; // [rsp+10h] [rbp-78h] BYREF
void *v10; // [rsp+20h] [rbp-68h] BYREF
volatile signed __int32 *v11; // [rsp+28h] [rbp-60h]
long long v12; // [rsp+30h] [rbp-58h] BYREF
void *v13; // [rsp+38h] [rbp-50h] BYREF
_BYTE v14[8]; // [rsp+40h] [rbp-48h] BYREF
volatile signed __int32 *v15; // [rsp+48h] [rbp-40h]
v7 = &v9;
std::string::_M_construct<char *>((long long)&v7, *(_BYTE **)a2, *(_QWORD *)a2 + *(_QWORD *)(a2 + 8));
v10 = 0LL;
v4 = operator new(0x30uLL);
*(_QWORD *)(v4 + 8) = 0x100000001LL;
*(_QWORD *)v4 = &`vtable for'std::_Sp_counted_ptr_inplace<std::string,std::allocator<std::string>,(__gnu_cxx::_Lock_policy)2>
+ 2;
v5 = (_OWORD *)(v4 + 32);
*(_QWORD *)(v4 + 16) = v4 + 32;
if ( v7 == &v9 )
{
*v5 = v9;
}
else
{
*(_QWORD *)(v4 + 16) = v7;
*(_QWORD *)v5 = v9;
}
*(_QWORD *)(v4 + 24) = v8;
v7 = &v9;
v8 = 0LL;
LOBYTE(v9) = 0;
v11 = (volatile signed __int32 *)v4;
v10 = (void *)(v4 + 16);
minja::Parser::Parser(v14, &v10, a3);
if ( v11 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v11);
if ( v7 != &v9 )
operator delete(v7, v9 + 1);
minja::Parser::tokenize((minja::Parser *)&v7);
v10 = v7;
v13 = v7;
v12 = v8;
minja::Parser::parseTemplate(a1, v14, &v10, &v13, &v12, 1LL);
std::vector<std::unique_ptr<minja::TemplateToken>>::~vector(&v7);
if ( v15 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v15);
return a1;
}
| parse:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x70
MOV R14,RDX
MOV RBX,RDI
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
ADD RDX,RAX
MOV RDI,RSP
MOV RSI,RAX
CALL 0x001210fc
MOV qword ptr [RSP + 0x20],0x0
LAB_0017de66:
MOV EDI,0x30
CALL 0x0011a870
MOV RCX,0x100000001
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x228250]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
LEA RCX,[RAX + 0x10]
MOV RDX,RAX
ADD RDX,0x20
MOV qword ptr [RAX + 0x10],RDX
MOV RSI,qword ptr [RSP]
CMP RSI,R15
JZ 0x0017deb1
MOV qword ptr [RCX],RSI
MOV RSI,qword ptr [RSP + 0x10]
MOV qword ptr [RDX],RSI
JMP 0x0017deb8
LAB_0017deb1:
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RDX],XMM0
LAB_0017deb8:
MOV RDX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x18],RDX
MOV qword ptr [RSP],R15
MOV qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x10],0x0
LEA RSI,[RSP + 0x20]
MOV qword ptr [RSI + 0x8],RAX
MOV qword ptr [RSI],RCX
LAB_0017dedf:
LEA RDI,[RSP + 0x40]
MOV RDX,R14
CALL 0x0017ed5a
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x0017defb
CALL 0x0016c8e8
LAB_0017defb:
MOV RDI,qword ptr [RSP]
CMP RDI,R15
JZ 0x0017df11
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011a890
LAB_0017df11:
MOV RDI,RSP
LEA RSI,[RSP + 0x40]
CALL 0x0017ee24
MOV RAX,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LEA RCX,[RSP + 0x38]
MOV qword ptr [RCX],RAX
LEA R8,[RSP + 0x30]
MOV qword ptr [R8],RSI
LAB_0017df3f:
LEA RSI,[RSP + 0x40]
MOV RDI,RBX
MOV R9D,0x1
CALL 0x001814aa
LAB_0017df52:
MOV RDI,RSP
CALL 0x00182762
MOV RDI,qword ptr [RSP + 0x48]
TEST RDI,RDI
JZ 0x0017df69
CALL 0x0016c8e8
LAB_0017df69:
MOV RAX,RBX
ADD RSP,0x70
POP RBX
POP R14
POP R15
RET
|
/* minja::Parser::parse(std::__cxx11::string const&, minja::Options const&) */
Parser * __thiscall minja::Parser::parse(Parser *this,string *param_1,Options *param_2)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var1;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_88;
int8 local_80;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> local_78;
int7 uStack_77;
int8 uStack_70;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_60;
int8 local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_50;
Parser local_48 [8];
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
local_88 = &local_78;
std::__cxx11::string::_M_construct<char*>
(&local_88,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
local_68 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
/* try { // try from 0017de66 to 0017de6f has its CatchHandler @ 0017dfab */
local_60 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)operator_new(0x30);
*(int8 *)(local_60 + 8) = 0x100000001;
*(int ***)local_60 = &PTR___Sp_counted_ptr_inplace_00228260;
local_68 = local_60 + 0x10;
p_Var1 = local_60 + 0x20;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(local_60 + 0x10) = p_Var1;
if (local_88 == &local_78) {
*(ulong *)p_Var1 = CONCAT71(uStack_77,local_78);
*(int8 *)(local_60 + 0x28) = uStack_70;
}
else {
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)local_68 = local_88;
*(ulong *)p_Var1 = CONCAT71(uStack_77,local_78);
}
*(int8 *)(local_60 + 0x18) = local_80;
local_80 = 0;
local_78 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>)0x0;
/* try { // try from 0017dedf to 0017deeb has its CatchHandler @ 0017df97 */
local_88 = &local_78;
Parser(local_48,(shared_ptr *)&local_68,param_2);
if (local_60 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_60);
}
if (local_88 != &local_78) {
operator_delete(local_88,CONCAT71(uStack_77,local_78) + 1);
}
/* try { // try from 0017df11 to 0017df1d has its CatchHandler @ 0017df83 */
tokenize();
local_68 = local_88;
local_50 = local_88;
local_58 = local_80;
/* try { // try from 0017df3f to 0017df51 has its CatchHandler @ 0017df76 */
parseTemplate(this,local_48,(__normal_iterator *)&local_68,SUB81(&local_50,0));
std::
vector<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>,std::allocator<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>>>
::~vector((vector<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>,std::allocator<std::unique_ptr<minja::TemplateToken,std::default_delete<minja::TemplateToken>>>>
*)&local_88);
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
return this;
}
| |
50,649 | GetHostName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | ng-log[P]ng-log/src/logging.cc | static void GetHostName(string* hostname) {
#if defined(HAVE_SYS_UTSNAME_H)
struct utsname buf;
if (uname(&buf) < 0) {
// ensure null termination on failure
*buf.nodename = '\0';
}
*hostname = buf.nodename;
#elif defined(NGLOG_OS_WINDOWS)
char buf[MAX_COMPUTERNAME_LENGTH + 1];
DWORD len = MAX_COMPUTERNAME_LENGTH + 1;
if (GetComputerNameA(buf, &len)) {
*hostname = buf;
} else {
hostname->clear();
}
#else
# warning There is no way to retrieve the host name.
*hostname = "(unknown)";
#endif
} | O0 | cpp | GetHostName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*):
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x8(%rbp)
leaq -0x18e(%rbp), %rdi
callq 0x90d0
cmpl $0x0, %eax
jge 0x133e7
movb $0x0, -0x14d(%rbp)
leaq -0x18e(%rbp), %rsi
addq $0x41, %rsi
movq -0x8(%rbp), %rdi
callq 0x9a30
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL11GetHostNamePNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
mov rbp, rsp
sub rsp, 190h
mov [rbp+var_8], rdi
lea rdi, [rbp+var_18E]
call _uname
cmp eax, 0
jge short loc_133E7
mov [rbp+var_14D], 0
loc_133E7:
lea rsi, [rbp+var_18E]
add rsi, 41h ; 'A'
mov rdi, [rbp+var_8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
add rsp, 190h
pop rbp
retn
| long long GetHostName(long long a1)
{
_BYTE v2[65]; // [rsp+2h] [rbp-18Eh] BYREF
_BYTE v3[325]; // [rsp+43h] [rbp-14Dh] BYREF
long long v4; // [rsp+188h] [rbp-8h]
v4 = a1;
if ( (int)uname(v2) < 0 )
v3[0] = 0;
return std::string::operator=(v4, v3);
}
| GetHostName:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x190
MOV qword ptr [RBP + -0x8],RDI
LEA RDI,[RBP + -0x18e]
CALL 0x001090d0
CMP EAX,0x0
JGE 0x001133e7
MOV byte ptr [RBP + -0x14d],0x0
LAB_001133e7:
LEA RSI,[RBP + -0x18e]
ADD RSI,0x41
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00109a30
ADD RSP,0x190
POP RBP
RET
|
/* GetHostName(std::__cxx11::string*) */
void GetHostName(string *param_1)
{
int iVar1;
utsname local_196;
string *local_10;
local_10 = param_1;
iVar1 = uname(&local_196);
if (iVar1 < 0) {
local_196.nodename[0] = '\0';
}
std::__cxx11::string::operator=(local_10,local_196.nodename);
return;
}
| |
50,650 | GetHostName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | ng-log[P]ng-log/src/logging.cc | static void GetHostName(string* hostname) {
#if defined(HAVE_SYS_UTSNAME_H)
struct utsname buf;
if (uname(&buf) < 0) {
// ensure null termination on failure
*buf.nodename = '\0';
}
*hostname = buf.nodename;
#elif defined(NGLOG_OS_WINDOWS)
char buf[MAX_COMPUTERNAME_LENGTH + 1];
DWORD len = MAX_COMPUTERNAME_LENGTH + 1;
if (GetComputerNameA(buf, &len)) {
*hostname = buf;
} else {
hostname->clear();
}
#else
# warning There is no way to retrieve the host name.
*hostname = "(unknown)";
#endif
} | O2 | cpp | GetHostName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*):
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rdi, %rbx
leaq 0xa(%rsp), %rdi
callq 0x80a0
testl %eax, %eax
jns 0xb2da
movb $0x0, 0x4b(%rsp)
leaq 0x4b(%rsp), %rsi
movq %rbx, %rdi
callq 0x8ad0
addq $0x190, %rsp # imm = 0x190
popq %rbx
retq
| _ZL11GetHostNamePNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbx
sub rsp, 190h
mov rbx, rdi
lea rdi, [rsp+198h+var_18E]
call _uname
test eax, eax
jns short loc_B2DA
mov [rsp+198h+var_14D], 0
loc_B2DA:
lea rsi, [rsp+198h+var_14D]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKc; std::string::assign(char const*)
add rsp, 190h
pop rbx
retn
| long long GetHostName(long long a1)
{
_BYTE v2[65]; // [rsp+Ah] [rbp-18Eh] BYREF
_BYTE v3[333]; // [rsp+4Bh] [rbp-14Dh] BYREF
if ( (int)uname(v2) < 0 )
v3[0] = 0;
return std::string::assign(a1, v3);
}
| GetHostName:
PUSH RBX
SUB RSP,0x190
MOV RBX,RDI
LEA RDI,[RSP + 0xa]
CALL 0x001080a0
TEST EAX,EAX
JNS 0x0010b2da
MOV byte ptr [RSP + 0x4b],0x0
LAB_0010b2da:
LEA RSI,[RSP + 0x4b]
MOV RDI,RBX
CALL 0x00108ad0
ADD RSP,0x190
POP RBX
RET
|
/* GetHostName(std::__cxx11::string*) */
void GetHostName(string *param_1)
{
int iVar1;
utsname local_18e;
iVar1 = uname(&local_18e);
if (iVar1 < 0) {
local_18e.nodename[0] = '\0';
}
std::__cxx11::string::assign((char *)param_1);
return;
}
| |
50,651 | gguf_set_val_u16 | ngxson[P]ggml-easy/ggml/src/gguf.cpp | void gguf_set_val_u16(struct gguf_context * ctx, const char * key, uint16_t val) {
gguf_check_reserved_keys(key, val);
gguf_remove_key(ctx, key);
ctx->kv.emplace_back(key, val);
} | O2 | cpp | gguf_set_val_u16:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movw %dx, 0x4(%rsp)
leaq 0x10(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x1e820
leaq 0x1aa7b(%rip), %rsi # 0x5a982
movq %r15, %rdi
callq 0x1efa0
testb %al, %al
jne 0x3ff48
leaq 0x10(%rsp), %rdi
callq 0x1c9a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1def0
addq $0x8, %rbx
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x1cd10
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a9c6(%rip), %rdi # 0x5a915
leaq 0x1b220(%rip), %rdx # 0x5b176
movl $0x3a8, %esi # imm = 0x3A8
xorl %eax, %eax
callq 0x1e770
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1c9a0
movq %rbx, %rdi
callq 0x1e9b0
| gguf_set_val_u16:
push r15
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
mov [rsp+48h+var_40], rsi
mov [rsp+48h+var_44], dx
lea r15, [rsp+48h+var_38]
lea rdx, [rsp+48h+var_41]
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, aGeneralAlignme; "general.alignment"
mov rdi, r15
call __ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_3FF48
lea rdi, [rsp+48h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
mov rsi, r14
call _gguf_remove_key
add rbx, 8
lea rsi, [rsp+48h+var_40]
lea rdx, [rsp+48h+var_44]
mov rdi, rbx
call __ZNSt6vectorI7gguf_kvSaIS0_EE12emplace_backIJRPKcRtEEERS0_DpOT_; std::vector<gguf_kv>::emplace_back<char const*&,ushort &>(char const*&,ushort &)
add rsp, 30h
pop rbx
pop r14
pop r15
retn
loc_3FF48:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGeneralAlignme_0; "general.alignment must be type u32"
mov esi, 3A8h
xor eax, eax
call _ggml_abort
mov rbx, rax
lea rdi, [rsp+48h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| long long gguf_set_val_u16(
long long a1,
long long a2,
__int16 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v11; // rcx
long long v12; // r8
long long v13; // r9
__m128 v14; // xmm4
__m128 v15; // xmm5
long long v16; // rdx
char v18; // [rsp+0h] [rbp-48h]
__int16 v19; // [rsp+4h] [rbp-44h] BYREF
char v20; // [rsp+7h] [rbp-41h] BYREF
long long v21; // [rsp+8h] [rbp-40h] BYREF
_BYTE v22[56]; // [rsp+10h] [rbp-38h] BYREF
v21 = a2;
v19 = a3;
std::string::basic_string<std::allocator<char>>(v22, a2, &v20);
if ( (unsigned __int8)std::operator==<char>(v22, "general.alignment") )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",
936,
(long long)"general.alignment must be type u32",
v11,
v12,
v13,
a4,
a5,
a6,
a7,
v14,
v15,
a10,
a11,
v18);
std::string::~string(v22);
gguf_remove_key(a1, a2, v16);
return std::vector<gguf_kv>::emplace_back<char const*&,unsigned short &>(a1 + 8, &v21, &v19);
}
| gguf_set_val_u16:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
MOV qword ptr [RSP + 0x8],RSI
MOV word ptr [RSP + 0x4],DX
LEA R15,[RSP + 0x10]
LEA RDX,[RSP + 0x7]
MOV RDI,R15
CALL 0x0011e820
LEA RSI,[0x15a982]
MOV RDI,R15
CALL 0x0011efa0
TEST AL,AL
JNZ 0x0013ff48
LEA RDI,[RSP + 0x10]
CALL 0x0011c9a0
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011def0
ADD RBX,0x8
LEA RSI,[RSP + 0x8]
LEA RDX,[RSP + 0x4]
MOV RDI,RBX
CALL 0x0011cd10
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
LAB_0013ff48:
LEA RDI,[0x15a915]
LEA RDX,[0x15b176]
MOV ESI,0x3a8
XOR EAX,EAX
CALL 0x0011e770
|
void gguf_set_val_u16(long param_1,char *param_2,ushort param_3)
{
bool bVar1;
ushort local_44;
allocator local_41;
char *local_40;
string local_38 [32];
local_44 = param_3;
local_40 = param_2;
std::__cxx11::string::string<std::allocator<char>>(local_38,param_2,&local_41);
bVar1 = std::operator==(local_38,"general.alignment");
if (!bVar1) {
std::__cxx11::string::~string(local_38);
gguf_remove_key(param_1,param_2);
std::vector<gguf_kv,std::allocator<gguf_kv>>::emplace_back<char_const*&,unsigned_short&>
((vector<gguf_kv,std::allocator<gguf_kv>> *)(param_1 + 8),&local_40,&local_44);
return;
}
/* try { // try from 0013ff48 to 0013ff61 has its CatchHandler @ 0013ff62 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",0x3a8,
"general.alignment must be type u32");
}
| |
50,652 | my_aes_crypt | eloqsql/mysys_ssl/my_crypt.cc | int my_aes_crypt(enum my_aes_mode mode, int flags,
const uchar *src, uint slen, uchar *dst, uint *dlen,
const uchar *key, uint klen, const uchar *iv, uint ivlen)
{
void *ctx= alloca(MY_AES_CTX_SIZE);
int res1, res2;
uint d1= 0, d2;
if ((res1= my_aes_crypt_init(ctx, mode, flags, key, klen, iv, ivlen)))
return res1;
res1= my_aes_crypt_update(ctx, src, slen, dst, &d1);
res2= my_aes_crypt_finish(ctx, dst + d1, &d2);
if (res1 || res2)
ERR_remove_state(0); /* in case of failure clear error queue */
else
*dlen= d1 + d2;
return res1 ? res1 : res2;
} | O0 | cpp | my_aes_crypt:
pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp # imm = 0x310
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x2b8(%rbp)
movl %esi, -0x2bc(%rbp)
movq %rdx, -0x2c8(%rbp)
movl %ecx, -0x2cc(%rbp)
movq %r8, -0x2d8(%rbp)
movq %r9, -0x2e0(%rbp)
leaq -0x2b0(%rbp), %rax
movq %rax, -0x2e8(%rbp)
movl $0x0, -0x2f4(%rbp)
movq -0x2e8(%rbp), %rdi
movl -0x2b8(%rbp), %esi
movl -0x2bc(%rbp), %edx
movq 0x10(%rbp), %rcx
movl 0x18(%rbp), %r8d
movq 0x20(%rbp), %r9
movl 0x28(%rbp), %eax
movl %eax, (%rsp)
callq 0xdcb50
movl %eax, -0x2ec(%rbp)
cmpl $0x0, %eax
je 0xdcd4b
movl -0x2ec(%rbp), %eax
movl %eax, -0x2b4(%rbp)
jmp 0xdcdfe
movq -0x2e8(%rbp), %rdi
movq -0x2c8(%rbp), %rsi
movl -0x2cc(%rbp), %edx
movq -0x2d8(%rbp), %rcx
leaq -0x2f4(%rbp), %r8
callq 0xdcc20
movl %eax, -0x2ec(%rbp)
movq -0x2e8(%rbp), %rdi
movq -0x2d8(%rbp), %rsi
movl -0x2f4(%rbp), %eax
addq %rax, %rsi
leaq -0x2f8(%rbp), %rdx
callq 0xdcc60
movl %eax, -0x2f0(%rbp)
cmpl $0x0, -0x2ec(%rbp)
jne 0xdcdb3
cmpl $0x0, -0x2f0(%rbp)
je 0xdcdba
callq 0x2a780
jmp 0xdcdcf
movl -0x2f4(%rbp), %ecx
addl -0x2f8(%rbp), %ecx
movq -0x2e0(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x2ec(%rbp)
je 0xdcde6
movl -0x2ec(%rbp), %eax
movl %eax, -0x2fc(%rbp)
jmp 0xdcdf2
movl -0x2f0(%rbp), %eax
movl %eax, -0x2fc(%rbp)
movl -0x2fc(%rbp), %eax
movl %eax, -0x2b4(%rbp)
movl -0x2b4(%rbp), %eax
movl %eax, -0x300(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xdce2b
movl -0x300(%rbp), %eax
addq $0x310, %rsp # imm = 0x310
popq %rbp
retq
callq 0x2a260
| my_aes_crypt:
push rbp
mov rbp, rsp
sub rsp, 310h
mov eax, [rbp+arg_18]
mov rax, [rbp+arg_10]
mov eax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_2B8], edi
mov [rbp+var_2BC], esi
mov [rbp+var_2C8], rdx
mov [rbp+var_2CC], ecx
mov [rbp+var_2D8], r8
mov [rbp+var_2E0], r9
lea rax, [rbp+var_2B0]
mov [rbp+var_2E8], rax
mov [rbp+var_2F4], 0
mov rdi, [rbp+var_2E8]
mov esi, [rbp+var_2B8]
mov edx, [rbp+var_2BC]
mov rcx, [rbp+arg_0]
mov r8d, [rbp+arg_8]
mov r9, [rbp+arg_10]
mov eax, [rbp+arg_18]
mov [rsp+310h+var_310], eax
call my_aes_crypt_init
mov [rbp+var_2EC], eax
cmp eax, 0
jz short loc_DCD4B
mov eax, [rbp+var_2EC]
mov [rbp+var_2B4], eax
jmp loc_DCDFE
loc_DCD4B:
mov rdi, [rbp+var_2E8]
mov rsi, [rbp+var_2C8]
mov edx, [rbp+var_2CC]
mov rcx, [rbp+var_2D8]
lea r8, [rbp+var_2F4]
call my_aes_crypt_update
mov [rbp+var_2EC], eax
mov rdi, [rbp+var_2E8]
mov rsi, [rbp+var_2D8]
mov eax, [rbp+var_2F4]
add rsi, rax
lea rdx, [rbp+var_2F8]
call my_aes_crypt_finish
mov [rbp+var_2F0], eax
cmp [rbp+var_2EC], 0
jnz short loc_DCDB3
cmp [rbp+var_2F0], 0
jz short loc_DCDBA
loc_DCDB3:
call _ERR_clear_error
jmp short loc_DCDCF
loc_DCDBA:
mov ecx, [rbp+var_2F4]
add ecx, [rbp+var_2F8]
mov rax, [rbp+var_2E0]
mov [rax], ecx
loc_DCDCF:
cmp [rbp+var_2EC], 0
jz short loc_DCDE6
mov eax, [rbp+var_2EC]
mov [rbp+var_2FC], eax
jmp short loc_DCDF2
loc_DCDE6:
mov eax, [rbp+var_2F0]
mov [rbp+var_2FC], eax
loc_DCDF2:
mov eax, [rbp+var_2FC]
mov [rbp+var_2B4], eax
loc_DCDFE:
mov eax, [rbp+var_2B4]
mov [rbp+var_300], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_DCE2B
mov eax, [rbp+var_300]
add rsp, 310h
pop rbp
retn
loc_DCE2B:
call ___stack_chk_fail
| long long my_aes_crypt(
int a1,
int a2,
long long a3,
unsigned int a4,
long long a5,
_DWORD *a6,
long long a7,
unsigned int a8,
long long a9,
int a10)
{
int v12; // [rsp+18h] [rbp-2F8h] BYREF
unsigned int v13; // [rsp+1Ch] [rbp-2F4h] BYREF
unsigned int v14; // [rsp+20h] [rbp-2F0h]
unsigned int v15; // [rsp+24h] [rbp-2ECh]
_BYTE *v16; // [rsp+28h] [rbp-2E8h]
_DWORD *v17; // [rsp+30h] [rbp-2E0h]
long long v18; // [rsp+38h] [rbp-2D8h]
unsigned int v19; // [rsp+44h] [rbp-2CCh]
long long v20; // [rsp+48h] [rbp-2C8h]
int v21; // [rsp+54h] [rbp-2BCh]
int v22; // [rsp+58h] [rbp-2B8h]
_BYTE v24[680]; // [rsp+60h] [rbp-2B0h] BYREF
unsigned long long v25; // [rsp+308h] [rbp-8h]
v25 = __readfsqword(0x28u);
v22 = a1;
v21 = a2;
v20 = a3;
v19 = a4;
v18 = a5;
v17 = a6;
v16 = v24;
v13 = 0;
v15 = my_aes_crypt_init((MyCTX *)v24, a1, a2, a7, a8, a9, a10);
if ( v15 )
{
return v15;
}
else
{
v15 = my_aes_crypt_update((long long)v16, v20, v19, v18, (long long)&v13);
v14 = my_aes_crypt_finish((long long)v16, v13 + v18, (long long)&v12);
if ( v15 || v14 )
ERR_clear_error();
else
*v17 = v12 + v13;
if ( v15 )
return v15;
else
return v14;
}
}
| my_aes_crypt:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x310
MOV EAX,dword ptr [RBP + 0x28]
MOV RAX,qword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x2b8],EDI
MOV dword ptr [RBP + -0x2bc],ESI
MOV qword ptr [RBP + -0x2c8],RDX
MOV dword ptr [RBP + -0x2cc],ECX
MOV qword ptr [RBP + -0x2d8],R8
MOV qword ptr [RBP + -0x2e0],R9
LEA RAX,[RBP + -0x2b0]
MOV qword ptr [RBP + -0x2e8],RAX
MOV dword ptr [RBP + -0x2f4],0x0
MOV RDI,qword ptr [RBP + -0x2e8]
MOV ESI,dword ptr [RBP + -0x2b8]
MOV EDX,dword ptr [RBP + -0x2bc]
MOV RCX,qword ptr [RBP + 0x10]
MOV R8D,dword ptr [RBP + 0x18]
MOV R9,qword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x28]
MOV dword ptr [RSP],EAX
CALL 0x001dcb50
MOV dword ptr [RBP + -0x2ec],EAX
CMP EAX,0x0
JZ 0x001dcd4b
MOV EAX,dword ptr [RBP + -0x2ec]
MOV dword ptr [RBP + -0x2b4],EAX
JMP 0x001dcdfe
LAB_001dcd4b:
MOV RDI,qword ptr [RBP + -0x2e8]
MOV RSI,qword ptr [RBP + -0x2c8]
MOV EDX,dword ptr [RBP + -0x2cc]
MOV RCX,qword ptr [RBP + -0x2d8]
LEA R8,[RBP + -0x2f4]
CALL 0x001dcc20
MOV dword ptr [RBP + -0x2ec],EAX
MOV RDI,qword ptr [RBP + -0x2e8]
MOV RSI,qword ptr [RBP + -0x2d8]
MOV EAX,dword ptr [RBP + -0x2f4]
ADD RSI,RAX
LEA RDX,[RBP + -0x2f8]
CALL 0x001dcc60
MOV dword ptr [RBP + -0x2f0],EAX
CMP dword ptr [RBP + -0x2ec],0x0
JNZ 0x001dcdb3
CMP dword ptr [RBP + -0x2f0],0x0
JZ 0x001dcdba
LAB_001dcdb3:
CALL 0x0012a780
JMP 0x001dcdcf
LAB_001dcdba:
MOV ECX,dword ptr [RBP + -0x2f4]
ADD ECX,dword ptr [RBP + -0x2f8]
MOV RAX,qword ptr [RBP + -0x2e0]
MOV dword ptr [RAX],ECX
LAB_001dcdcf:
CMP dword ptr [RBP + -0x2ec],0x0
JZ 0x001dcde6
MOV EAX,dword ptr [RBP + -0x2ec]
MOV dword ptr [RBP + -0x2fc],EAX
JMP 0x001dcdf2
LAB_001dcde6:
MOV EAX,dword ptr [RBP + -0x2f0]
MOV dword ptr [RBP + -0x2fc],EAX
LAB_001dcdf2:
MOV EAX,dword ptr [RBP + -0x2fc]
MOV dword ptr [RBP + -0x2b4],EAX
LAB_001dcdfe:
MOV EAX,dword ptr [RBP + -0x2b4]
MOV dword ptr [RBP + -0x300],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001dce2b
MOV EAX,dword ptr [RBP + -0x300]
ADD RSP,0x310
POP RBP
RET
LAB_001dce2b:
CALL 0x0012a260
|
int my_aes_crypt(int4 param_1,int4 param_2,int8 param_3,int4 param_4,
long param_5,int *param_6,int8 param_7,int4 param_8,int8 param_9,
int4 param_10)
{
long in_FS_OFFSET;
int local_304;
int local_300;
uint local_2fc;
int local_2f8;
int local_2f4;
int1 *local_2f0;
int *local_2e8;
long local_2e0;
int4 local_2d4;
int8 local_2d0;
int4 local_2c4;
int4 local_2c0;
int local_2bc;
int1 local_2b8 [680];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_2f0 = local_2b8;
local_2fc = 0;
local_2e8 = param_6;
local_2e0 = param_5;
local_2d4 = param_4;
local_2d0 = param_3;
local_2c4 = param_2;
local_2c0 = param_1;
local_2f4 = my_aes_crypt_init(local_2f0,param_1,param_2,param_7,param_8,param_9,param_10);
local_2bc = local_2f4;
if (local_2f4 == 0) {
local_2f4 = my_aes_crypt_update(local_2f0,local_2d0,local_2d4,local_2e0,&local_2fc);
local_2f8 = my_aes_crypt_finish(local_2f0,local_2e0 + (ulong)local_2fc,&local_300);
if ((local_2f4 == 0) && (local_2f8 == 0)) {
*local_2e8 = local_2fc + local_300;
}
else {
ERR_clear_error();
}
if (local_2f4 == 0) {
local_304 = local_2f8;
}
else {
local_304 = local_2f4;
}
local_2bc = local_304;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_2bc;
}
| |
50,653 | free | seiftnesse[P]memoryallocator/src/custom_alloc_core.c | void _free(void *ptr) {
HEAP_LOG("Free request for pointer: %p\n", ptr);
if (!ptr) {
HEAP_LOG("Ignoring free request for NULL pointer\n");
return;
}
// Check if this is a small allocation
if (is_small_allocation(ptr)) {
free_small(ptr);
return;
}
segment_t *s = PtrToSegment(ptr);
if (!s) {
HEAP_LOG("Invalid pointer for free: %p (not a valid segment)\n", ptr);
return;
}
check_memory_corruption(s);
// Perform more comprehensive corruption check
verify_segment_integrity(s, 1);
// Guard against double-free
if (s->is_free) {
HEAP_LOG("WARNING: Attempted double-free detected for pointer: %p\n", ptr);
return;
}
HEAP_LOG("Freeing segment: %p, size=%d blocks, id=%u\n",
s, s->size, s->allocation_id);
if (zero_on_free_depth > ZERO_DEPTH_NONE) {
void *user_ptr = SegmentToPtr(s);
size_t total_size = s->size * BLOCK_SIZE;
size_t user_data_offset = (char *) user_ptr - (char *) s;
size_t user_data_size = total_size - user_data_offset;
if (user_data_size > 0) {
size_t zero_size = 0;
switch (zero_on_free_depth) {
case ZERO_DEPTH_SHALLOW:
// Zero only the first portion (headers/pointers)
zero_size = (shallow_zero_size < user_data_size) ? shallow_zero_size : user_data_size;
break;
case ZERO_DEPTH_MEDIUM:
// Zero half the memory
zero_size = user_data_size / 2;
break;
case ZERO_DEPTH_DEEP:
default:
// Zero all memory (most secure, but slowest)
zero_size = user_data_size;
break;
}
if (zero_size > 0) {
HEAP_LOG("Zeroing %zu bytes on free at %p (depth=%d)\n",
zero_size, user_ptr, zero_on_free_depth);
_memset(user_ptr, 0, zero_size);
}
}
}
// Update statistics
update_stats_free(s->size * BLOCK_SIZE);
// Mark as free and update cache
s->is_free = 1;
last_free_segment = s;
// Try to merge with adjacent segments
if (s->next && s->next->is_free) {
HEAP_LOG("Merging with next segment: %p\n", s->next);
s = MergeSegment(s, s->next);
}
if (s->prev && s->prev->is_free) {
HEAP_LOG("Merging with previous segment: %p\n", s->prev);
s = MergeSegment(s->prev, s);
}
last_free_segment = s;
HEAP_LOG("Free completed, last_free_segment updated to %p\n", s);
} | O1 | c | free:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x11219
movq %rdi, %rbx
callq 0x116ef
movq %rbx, %rdi
testl %eax, %eax
je 0x1113d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x115af
callq 0x118c0
testq %rax, %rax
je 0x11219
movq %rax, %rbx
movq %rax, %rdi
callq 0x11f4c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x11a05
cmpl $0x0, (%rbx)
jne 0x11219
leaq 0x414cc25(%rip), %r14 # 0x415dd98
cmpl $0x0, (%r14)
jle 0x111c6
movq %rbx, %rdi
callq 0x118b0
movslq 0x4(%rbx), %rcx
shlq $0xc, %rcx
movq %rbx, %rdx
subq %rax, %rdx
addq %rcx, %rdx
je 0x111c6
movl (%r14), %ecx
cmpl $0x2, %ecx
je 0x111b4
cmpl $0x1, %ecx
jne 0x111b7
leaq 0x493c8(%rip), %rcx # 0x5a570
movq (%rcx), %rcx
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
jmp 0x111b7
shrq %rdx
testq %rdx, %rdx
je 0x111c6
movq %rax, %rdi
xorl %esi, %esi
callq 0x11cea
movslq 0x4(%rbx), %rdi
shlq $0xc, %rdi
callq 0x11e77
movl $0x1, (%rbx)
movq %rbx, 0x4bb68(%rip) # 0x5cd48
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x111f9
cmpl $0x0, (%rsi)
je 0x111f9
movq %rbx, %rdi
callq 0x11834
movq %rax, %rbx
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x11212
cmpl $0x0, (%rdi)
je 0x11212
movq %rbx, %rsi
callq 0x11834
movq %rax, %rbx
movq %rbx, 0x4bb2f(%rip) # 0x5cd48
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _free:
push r14
push rbx
push rax
test rdi, rdi
jz loc_11219
mov rbx, rdi
call is_small_allocation
mov rdi, rbx
test eax, eax
jz short loc_1113D
add rsp, 8
pop rbx
pop r14
jmp free_small
loc_1113D:
call PtrToSegment
test rax, rax
jz loc_11219
mov rbx, rax
mov rdi, rax
call check_memory_corruption
mov rdi, rbx
mov esi, 1
call verify_segment_integrity
cmp dword ptr [rbx], 0
jnz loc_11219
lea r14, zero_on_free_depth
cmp dword ptr [r14], 0
jle short loc_111C6
mov rdi, rbx
call SegmentToPtr
movsxd rcx, dword ptr [rbx+4]
shl rcx, 0Ch
mov rdx, rbx
sub rdx, rax
add rdx, rcx
jz short loc_111C6
mov ecx, [r14]
cmp ecx, 2
jz short loc_111B4
cmp ecx, 1
jnz short loc_111B7
lea rcx, shallow_zero_size
mov rcx, [rcx]
cmp rcx, rdx
cmovb rdx, rcx
jmp short loc_111B7
loc_111B4:
shr rdx, 1
loc_111B7:
test rdx, rdx
jz short loc_111C6
mov rdi, rax
xor esi, esi
call _memset
loc_111C6:
movsxd rdi, dword ptr [rbx+4]
shl rdi, 0Ch
call update_stats_free
mov dword ptr [rbx], 1
mov cs:last_free_segment, rbx
mov rsi, [rbx+8]
test rsi, rsi
jz short loc_111F9
cmp dword ptr [rsi], 0
jz short loc_111F9
mov rdi, rbx
call MergeSegment
mov rbx, rax
loc_111F9:
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_11212
cmp dword ptr [rdi], 0
jz short loc_11212
mov rsi, rbx
call MergeSegment
mov rbx, rax
loc_11212:
mov cs:last_free_segment, rbx
loc_11219:
add rsp, 8
pop rbx
pop r14
retn
| long long free(long long a1)
{
long long result; // rax
long long v2; // rbx
long long v3; // rax
unsigned long long v4; // rdx
_DWORD *v5; // rsi
_DWORD *v6; // rdi
if ( a1 )
{
if ( (unsigned int)is_small_allocation(a1) )
{
return free_small();
}
else
{
result = PtrToSegment(a1);
if ( result )
{
v2 = result;
check_memory_corruption(result);
result = verify_segment_integrity(v2, 1LL);
if ( !*(_DWORD *)v2 )
{
if ( zero_on_free_depth > 0 )
{
v3 = SegmentToPtr(v2);
v4 = ((long long)*(int *)(v2 + 4) << 12) + v2 - v3;
if ( v4 )
{
if ( zero_on_free_depth == 2 )
{
v4 >>= 1;
}
else if ( zero_on_free_depth == 1 && (unsigned long long)shallow_zero_size < v4 )
{
v4 = (unsigned long long)shallow_zero_size;
}
if ( v4 )
memset(v3, 0LL, v4);
}
}
result = update_stats_free((long long)*(int *)(v2 + 4) << 12);
*(_DWORD *)v2 = 1;
last_free_segment = v2;
v5 = *(_DWORD **)(v2 + 8);
if ( v5 && *v5 )
{
result = MergeSegment(v2);
v2 = result;
}
v6 = *(_DWORD **)(v2 + 16);
if ( v6 )
{
if ( *v6 )
{
result = MergeSegment(v6);
v2 = result;
}
}
last_free_segment = v2;
}
}
}
}
return result;
}
| _free:
PUSH R14
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x00111219
MOV RBX,RDI
CALL 0x001116ef
MOV RDI,RBX
TEST EAX,EAX
JZ 0x0011113d
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001115af
LAB_0011113d:
CALL 0x001118c0
TEST RAX,RAX
JZ 0x00111219
MOV RBX,RAX
MOV RDI,RAX
CALL 0x00111f4c
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00111a05
CMP dword ptr [RBX],0x0
JNZ 0x00111219
LEA R14,[0x425dd98]
CMP dword ptr [R14],0x0
JLE 0x001111c6
MOV RDI,RBX
CALL 0x001118b0
MOVSXD RCX,dword ptr [RBX + 0x4]
SHL RCX,0xc
MOV RDX,RBX
SUB RDX,RAX
ADD RDX,RCX
JZ 0x001111c6
MOV ECX,dword ptr [R14]
CMP ECX,0x2
JZ 0x001111b4
CMP ECX,0x1
JNZ 0x001111b7
LEA RCX,[0x15a570]
MOV RCX,qword ptr [RCX]
CMP RCX,RDX
CMOVC RDX,RCX
JMP 0x001111b7
LAB_001111b4:
SHR RDX,0x1
LAB_001111b7:
TEST RDX,RDX
JZ 0x001111c6
MOV RDI,RAX
XOR ESI,ESI
CALL 0x00111cea
LAB_001111c6:
MOVSXD RDI,dword ptr [RBX + 0x4]
SHL RDI,0xc
CALL 0x00111e77
MOV dword ptr [RBX],0x1
MOV qword ptr [0x0015cd48],RBX
MOV RSI,qword ptr [RBX + 0x8]
TEST RSI,RSI
JZ 0x001111f9
CMP dword ptr [RSI],0x0
JZ 0x001111f9
MOV RDI,RBX
CALL 0x00111834
MOV RBX,RAX
LAB_001111f9:
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x00111212
CMP dword ptr [RDI],0x0
JZ 0x00111212
MOV RSI,RBX
CALL 0x00111834
MOV RBX,RAX
LAB_00111212:
MOV qword ptr [0x0015cd48],RBX
LAB_00111219:
ADD RSP,0x8
POP RBX
POP R14
RET
|
void _free(long param_1)
{
int *piVar1;
int *piVar2;
int iVar3;
int *piVar4;
long lVar5;
ulong uVar6;
piVar2 = last_free_segment;
if (param_1 != 0) {
iVar3 = is_small_allocation();
if (iVar3 != 0) {
free_small();
return;
}
piVar4 = (int *)PtrToSegment(param_1);
piVar2 = last_free_segment;
if (piVar4 != (int *)0x0) {
check_memory_corruption(piVar4);
verify_segment_integrity(piVar4,1);
piVar2 = last_free_segment;
if (*piVar4 == 0) {
if (0 < zero_on_free_depth) {
lVar5 = SegmentToPtr(piVar4);
uVar6 = (long)piVar4 + ((long)piVar4[1] * 0x1000 - lVar5);
if (uVar6 != 0) {
if (zero_on_free_depth == 2) {
uVar6 = uVar6 >> 1;
}
else if ((zero_on_free_depth == 1) && (shallow_zero_size < uVar6)) {
uVar6 = shallow_zero_size;
}
if (uVar6 != 0) {
_memset(lVar5,0);
}
}
}
update_stats_free((long)piVar4[1] << 0xc);
*piVar4 = 1;
last_free_segment = piVar4;
if ((*(int **)(piVar4 + 2) != (int *)0x0) && (**(int **)(piVar4 + 2) != 0)) {
piVar4 = (int *)MergeSegment(piVar4);
}
piVar1 = *(int **)(piVar4 + 4);
piVar2 = piVar4;
if ((piVar1 != (int *)0x0) && (*piVar1 != 0)) {
piVar2 = (int *)MergeSegment(piVar1,piVar4);
}
}
}
}
last_free_segment = piVar2;
return;
}
| |
50,654 | verbose_msg(char const*, ...) | eloqsql/client/mysqltest.cc | void verbose_msg(const char *fmt, ...)
{
va_list args;
DBUG_ENTER("verbose_msg");
DBUG_PRINT("enter", ("format: %s", fmt));
if (!verbose)
DBUG_VOID_RETURN;
fflush(stdout);
va_start(args, fmt);
fprintf(stderr, "mysqltest: ");
if (cur_file && cur_file != file_stack)
fprintf(stderr, "In included file \"%s\": ",
cur_file->file_name);
if (start_lineno != 0)
fprintf(stderr, "At line %u: ", start_lineno);
vfprintf(stderr, fmt, args);
fprintf(stderr, "\n");
va_end(args);
fflush(stderr);
DBUG_VOID_RETURN;
} | O3 | cpp | verbose_msg(char const*, ...):
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, -0xd8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %r8, -0xc0(%rbp)
movq %r9, -0xb8(%rbp)
testb %al, %al
je 0x63834
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
cmpb $0x0, 0x3f9585(%rip) # 0x45cdc0
jne 0x63849
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %rbx
movq 0x376745(%rip), %rax # 0x3d9f98
movq (%rax), %rdi
callq 0x5f570
movabsq $0x3000000008, %rax # imm = 0x3000000008
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x376725(%rip), %r14 # 0x3d9fa8
movq (%r14), %rcx
leaq 0x8d21a(%rip), %rdi # 0xf0aa7
movl $0xb, %esi
movl $0x1, %edx
callq 0x5fd30
movq 0x3f911d(%rip), %rdi # 0x45c9c0
testq %rdi, %rdi
sete %al
leaq 0x3f9120(%rip), %rcx # 0x45c9d0
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
je 0x638f2
movl 0x3f9504(%rip), %edx # 0x45cdc4
testl %edx, %edx
jne 0x638f9
movq (%r14), %rdi
leaq -0x30(%rbp), %rcx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x5fb40
movq (%r14), %rsi
movl $0xa, %edi
callq 0x5fa50
movq (%r14), %rdi
callq 0x5f570
jmp 0x6383d
callq 0x5ffce
jmp 0x638ba
movq (%r14), %rdi
leaq 0x8d1c8(%rip), %rsi # 0xf0acb
xorl %eax, %eax
callq 0x5f1f0
jmp 0x638c4
| _Z11verbose_msgPKcz:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 0D0h
mov [rbp+var_D8], rsi
mov [rbp+var_D0], rdx
mov [rbp+var_C8], rcx
mov [rbp+var_C0], r8
mov [rbp+var_B8], r9
test al, al
jz short loc_63834
movaps [rbp+var_B0], xmm0
movaps [rbp+var_A0], xmm1
movaps [rbp+var_90], xmm2
movaps [rbp+var_80], xmm3
movaps [rbp+var_70], xmm4
movaps [rbp+var_60], xmm5
movaps [rbp+var_50], xmm6
movaps [rbp+var_40], xmm7
loc_63834:
cmp cs:_ZL7verbose, 0; verbose
jnz short loc_63849
loc_6383D:
add rsp, 0D0h
pop rbx
pop r14
pop rbp
retn
loc_63849:
mov rbx, rdi
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, 3000000008h
mov [rbp+var_30], rax
lea rax, [rbp+arg_0]
mov [rbp+var_28], rax
lea rax, [rbp+var_E0]
mov [rbp+var_20], rax
mov r14, cs:stderr_ptr
mov rcx, [r14]
lea rdi, aMysqltest; "mysqltest: "
mov esi, 0Bh
mov edx, 1
call _fwrite
mov rdi, cs:_ZL8cur_file; cur_file
test rdi, rdi
setz al
lea rcx, _ZL10file_stack; file_stack
cmp rdi, rcx
setz cl
or cl, al
jz short loc_638F2
loc_638BA:
mov edx, cs:_ZL12start_lineno; start_lineno
test edx, edx
jnz short loc_638F9
loc_638C4:
mov rdi, [r14]
lea rcx, [rbp+var_30]
mov esi, 1
mov rdx, rbx
call ___vfprintf_chk
mov rsi, [r14]
mov edi, 0Ah
call _fputc
mov rdi, [r14]
call _fflush
jmp loc_6383D
loc_638F2:
call _Z11verbose_msgPKcz_cold_1; verbose_msg(char const*,...) [clone]
jmp short loc_638BA
loc_638F9:
mov rdi, [r14]
lea rsi, aAtLineU; "At line %u: "
xor eax, eax
call _fprintf
jmp short loc_638C4
| long long verbose_msg(const char *a1, ...)
{
long long result; // rax
va_list va; // [rsp+B0h] [rbp-30h] BYREF
if ( verbose )
{
fflush(stdout);
va_start(va, a1);
fwrite("mysqltest: ", 11LL, 1LL, stderr);
if ( cur_file != 0 && cur_file != (_QWORD)&file_stack )
verbose_msg(cur_file);
if ( start_lineno )
fprintf(stderr, "At line %u: ", start_lineno);
__vfprintf_chk(stderr, 1LL, a1, va);
fputc(10LL, stderr);
return fflush(stderr);
}
return result;
}
| verbose_msg:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0xd0
MOV qword ptr [RBP + -0xd8],RSI
MOV qword ptr [RBP + -0xd0],RDX
MOV qword ptr [RBP + -0xc8],RCX
MOV qword ptr [RBP + -0xc0],R8
MOV qword ptr [RBP + -0xb8],R9
TEST AL,AL
JZ 0x00163834
MOVAPS xmmword ptr [RBP + -0xb0],XMM0
MOVAPS xmmword ptr [RBP + -0xa0],XMM1
MOVAPS xmmword ptr [RBP + -0x90],XMM2
MOVAPS xmmword ptr [RBP + -0x80],XMM3
MOVAPS xmmword ptr [RBP + -0x70],XMM4
MOVAPS xmmword ptr [RBP + -0x60],XMM5
MOVAPS xmmword ptr [RBP + -0x50],XMM6
MOVAPS xmmword ptr [RBP + -0x40],XMM7
LAB_00163834:
CMP byte ptr [0x0055cdc0],0x0
JNZ 0x00163849
LAB_0016383d:
ADD RSP,0xd0
POP RBX
POP R14
POP RBP
RET
LAB_00163849:
MOV RBX,RDI
MOV RAX,qword ptr [0x004d9f98]
MOV RDI,qword ptr [RAX]
CALL 0x0015f570
MOV RAX,0x3000000008
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x28],RAX
LEA RAX,[RBP + -0xe0]
MOV qword ptr [RBP + -0x20],RAX
MOV R14,qword ptr [0x004d9fa8]
MOV RCX,qword ptr [R14]
LEA RDI,[0x1f0aa7]
MOV ESI,0xb
MOV EDX,0x1
CALL 0x0015fd30
MOV RDI,qword ptr [0x0055c9c0]
TEST RDI,RDI
SETZ AL
LEA RCX,[0x55c9d0]
CMP RDI,RCX
SETZ CL
OR CL,AL
JZ 0x001638f2
LAB_001638ba:
MOV EDX,dword ptr [0x0055cdc4]
TEST EDX,EDX
JNZ 0x001638f9
LAB_001638c4:
MOV RDI,qword ptr [R14]
LEA RCX,[RBP + -0x30]
MOV ESI,0x1
MOV RDX,RBX
CALL 0x0015fb40
MOV RSI,qword ptr [R14]
MOV EDI,0xa
CALL 0x0015fa50
MOV RDI,qword ptr [R14]
CALL 0x0015f570
JMP 0x0016383d
LAB_001638f2:
CALL 0x0015ffce
JMP 0x001638ba
LAB_001638f9:
MOV RDI,qword ptr [R14]
LEA RSI,[0x1f0acb]
XOR EAX,EAX
CALL 0x0015f1f0
JMP 0x001638c4
|
/* verbose_msg(char const*, ...) */
void verbose_msg(char *param_1,...)
{
int *puVar1;
char in_AL;
int8 in_RCX;
int8 in_RDX;
int8 in_RSI;
int8 in_R8;
int8 in_R9;
int8 in_XMM0_Qa;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
int1 local_e8 [8];
int8 local_e0;
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int1 *local_30;
int1 *local_28;
if (in_AL != '\0') {
local_b8 = in_XMM0_Qa;
local_a8 = in_XMM1_Qa;
local_98 = in_XMM2_Qa;
local_88 = in_XMM3_Qa;
local_78 = in_XMM4_Qa;
local_68 = in_XMM5_Qa;
local_58 = in_XMM6_Qa;
local_48 = in_XMM7_Qa;
}
if (verbose != '\0') {
local_e0 = in_RSI;
local_d8 = in_RDX;
local_d0 = in_RCX;
local_c8 = in_R8;
local_c0 = in_R9;
fflush(*(FILE **)PTR_stdout_004d9f98);
puVar1 = PTR_stderr_004d9fa8;
local_38 = 0x3000000008;
local_30 = &stack0x00000008;
local_28 = local_e8;
fwrite("mysqltest: ",0xb,1,*(FILE **)PTR_stderr_004d9fa8);
if (cur_file != (char *)&file_stack && cur_file != (char *)0x0) {
verbose_msg(cur_file);
}
if (start_lineno != 0) {
fprintf(*(FILE **)puVar1,"At line %u: ");
}
__vfprintf_chk(*(int8 *)puVar1,1,param_1,&local_38);
fputc(10,*(FILE **)puVar1);
fflush(*(FILE **)puVar1);
}
return;
}
| |
50,655 | s3_rename_directory | eloqsql/storage/maria/s3_func.c | int s3_rename_directory(ms3_st *s3_client, const char *aws_bucket,
const char *from_name, const char *to_name,
myf error_flags)
{
ms3_list_st *list, *org_list= 0;
my_bool error= 0;
char name[AWS_PATH_LENGTH], *end;
DBUG_ENTER("s3_delete_directory");
if ((error= ms3_list(s3_client, aws_bucket, from_name, &org_list)))
{
const char *errmsg;
if (!(errmsg= ms3_server_error(s3_client)))
errmsg= ms3_error(error);
my_printf_error(EE_FILENOTFOUND,
"Can't get list of files from %s. Error: %d %s",
MYF(error_flags & ~MY_WME),
from_name, error, errmsg);
DBUG_RETURN(EE_FILENOTFOUND);
}
end= strmov(name, to_name);
for (list= org_list ; list ; list= list->next)
{
const char *sep= strrchr(list->key, '/');
if (sep) /* Safety */
{
strmake(end, sep, (sizeof(name) - (end-name) - 1));
if (s3_rename_object(s3_client, aws_bucket, list->key, name,
error_flags))
error= 1;
}
}
if (org_list)
ms3_list_free(org_list);
DBUG_RETURN(error);
} | O0 | c | s3_rename_directory:
pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp # imm = 0x2E0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x280(%rbp)
movq %rsi, -0x288(%rbp)
movq %rdx, -0x290(%rbp)
movq %rcx, -0x298(%rbp)
movq %r8, -0x2a0(%rbp)
movq $0x0, -0x2b0(%rbp)
movb $0x0, -0x2b1(%rbp)
movq -0x280(%rbp), %rdi
movq -0x288(%rbp), %rsi
movq -0x290(%rbp), %rdx
leaq -0x2b0(%rbp), %rcx
callq 0x2cef0
movb %al, -0x2b1(%rbp)
cmpb $0x0, %al
je 0x2b0fd
movq -0x280(%rbp), %rdi
callq 0x2cd60
movq %rax, -0x2c8(%rbp)
cmpq $0x0, %rax
jne 0x2b0b4
movzbl -0x2b1(%rbp), %edi
callq 0x2ce00
movq %rax, -0x2c8(%rbp)
movabsq $0xffffffef, %rdx # imm = 0xFFFFFFEF
andq -0x2a0(%rbp), %rdx
movq -0x290(%rbp), %rcx
movsbl -0x2b1(%rbp), %r8d
movq -0x2c8(%rbp), %r9
movl $0x1d, %edi
leaq 0xf2827(%rip), %rsi # 0x11d90e
movb $0x0, %al
callq 0xb6900
movl $0x1d, -0x274(%rbp)
jmp 0x2b1fe
leaq -0x270(%rbp), %rdi
movq -0x298(%rbp), %rsi
callq 0x27880
movq %rax, -0x2c0(%rbp)
movq -0x2b0(%rbp), %rax
movq %rax, -0x2a8(%rbp)
cmpq $0x0, -0x2a8(%rbp)
je 0x2b1d9
movq -0x2a8(%rbp), %rax
movq (%rax), %rdi
movl $0x2f, %esi
callq 0x27870
movq %rax, -0x2d0(%rbp)
cmpq $0x0, -0x2d0(%rbp)
je 0x2b1c0
movq -0x2c0(%rbp), %rdi
movq -0x2d0(%rbp), %rsi
movq -0x2c0(%rbp), %rax
leaq -0x270(%rbp), %rcx
subq %rcx, %rax
movl $0x25e, %edx # imm = 0x25E
subq %rax, %rdx
subq $0x1, %rdx
callq 0x11b370
movq -0x280(%rbp), %rdi
movq -0x288(%rbp), %rsi
movq -0x2a8(%rbp), %rax
movq (%rax), %rdx
leaq -0x270(%rbp), %rcx
movq -0x2a0(%rbp), %r8
callq 0x2b230
cmpb $0x0, %al
je 0x2b1be
movb $0x1, -0x2b1(%rbp)
jmp 0x2b1c0
jmp 0x2b1c2
movq -0x2a8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x2a8(%rbp)
jmp 0x2b125
cmpq $0x0, -0x2b0(%rbp)
je 0x2b1ef
movq -0x2b0(%rbp), %rdi
callq 0x2d3c0
jmp 0x2b1f1
movsbl -0x2b1(%rbp), %eax
movl %eax, -0x274(%rbp)
movl -0x274(%rbp), %eax
movl %eax, -0x2d4(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2b22b
movl -0x2d4(%rbp), %eax
addq $0x2e0, %rsp # imm = 0x2E0
popq %rbp
retq
callq 0x272b0
| s3_rename_directory:
push rbp
mov rbp, rsp
sub rsp, 2E0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_280], rdi
mov [rbp+var_288], rsi
mov [rbp+var_290], rdx
mov [rbp+var_298], rcx
mov [rbp+var_2A0], r8
mov [rbp+var_2B0], 0
mov [rbp+var_2B1], 0
mov rdi, [rbp+var_280]
mov rsi, [rbp+var_288]
mov rdx, [rbp+var_290]
lea rcx, [rbp+var_2B0]
call ms3_list
mov [rbp+var_2B1], al
cmp al, 0
jz short loc_2B0FD
mov rdi, [rbp+var_280]
call ms3_server_error
mov [rbp+var_2C8], rax
cmp rax, 0
jnz short loc_2B0B4
movzx edi, [rbp+var_2B1]
call ms3_error
mov [rbp+var_2C8], rax
loc_2B0B4:
mov rdx, 0FFFFFFEFh
and rdx, [rbp+var_2A0]
mov rcx, [rbp+var_290]
movsx r8d, [rbp+var_2B1]
mov r9, [rbp+var_2C8]
mov edi, 1Dh
lea rsi, aCanTGetListOfF; "Can't get list of files from %s. Error:"...
mov al, 0
call my_printf_error
mov [rbp+var_274], 1Dh
jmp loc_2B1FE
loc_2B0FD:
lea rdi, [rbp+var_270]
mov rsi, [rbp+var_298]
call _stpcpy
mov [rbp+var_2C0], rax
mov rax, [rbp+var_2B0]
mov [rbp+var_2A8], rax
loc_2B125:
cmp [rbp+var_2A8], 0
jz loc_2B1D9
mov rax, [rbp+var_2A8]
mov rdi, [rax]
mov esi, 2Fh ; '/'
call _strrchr
mov [rbp+var_2D0], rax
cmp [rbp+var_2D0], 0
jz short loc_2B1C0
mov rdi, [rbp+var_2C0]
mov rsi, [rbp+var_2D0]
mov rax, [rbp+var_2C0]
lea rcx, [rbp+var_270]
sub rax, rcx
mov edx, 25Eh
sub rdx, rax
sub rdx, 1
call strmake
mov rdi, [rbp+var_280]
mov rsi, [rbp+var_288]
mov rax, [rbp+var_2A8]
mov rdx, [rax]
lea rcx, [rbp+var_270]
mov r8, [rbp+var_2A0]
call s3_rename_object
cmp al, 0
jz short loc_2B1BE
mov [rbp+var_2B1], 1
loc_2B1BE:
jmp short $+2
loc_2B1C0:
jmp short $+2
loc_2B1C2:
mov rax, [rbp+var_2A8]
mov rax, [rax+18h]
mov [rbp+var_2A8], rax
jmp loc_2B125
loc_2B1D9:
cmp [rbp+var_2B0], 0
jz short loc_2B1EF
mov rdi, [rbp+var_2B0]
call ms3_list_free
loc_2B1EF:
jmp short $+2
loc_2B1F1:
movsx eax, [rbp+var_2B1]
mov [rbp+var_274], eax
loc_2B1FE:
mov eax, [rbp+var_274]
mov [rbp+var_2D4], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_2B22B
mov eax, [rbp+var_2D4]
add rsp, 2E0h
pop rbp
retn
loc_2B22B:
call ___stack_chk_fail
| long long s3_rename_directory(long long a1, long long a2, long long a3, long long a4, long long a5)
{
long long v6; // [rsp+10h] [rbp-2D0h]
long long v7; // [rsp+18h] [rbp-2C8h]
long long v8; // [rsp+20h] [rbp-2C0h]
char v9; // [rsp+2Fh] [rbp-2B1h]
_QWORD *v10; // [rsp+30h] [rbp-2B0h] BYREF
_QWORD *i; // [rsp+38h] [rbp-2A8h]
long long v12; // [rsp+40h] [rbp-2A0h]
long long v13; // [rsp+48h] [rbp-298h]
long long v14; // [rsp+50h] [rbp-290h]
long long v15; // [rsp+58h] [rbp-288h]
long long v16; // [rsp+60h] [rbp-280h]
_BYTE v18[616]; // [rsp+70h] [rbp-270h] BYREF
unsigned long long v19; // [rsp+2D8h] [rbp-8h]
v19 = __readfsqword(0x28u);
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12 = a5;
v10 = 0LL;
v9 = ms3_list(a1, a2, a3, &v10);
if ( v9 )
{
v7 = ms3_server_error(v16);
if ( !v7 )
LODWORD(v7) = ms3_error((unsigned __int8)v9);
my_printf_error(29, (unsigned int)"Can't get list of files from %s. Error: %d %s", v12 & 0xFFFFFFEF, v14, v9, v7);
return 29;
}
else
{
v8 = stpcpy(v18, v13);
for ( i = v10; i; i = (_QWORD *)i[3] )
{
v6 = strrchr(*i, 47LL);
if ( v6 )
{
strmake(v8, v6, 606 - (v8 - (_QWORD)v18) - 1);
if ( (unsigned __int8)s3_rename_object(v16, v15, *i, v18, v12) )
v9 = 1;
}
}
if ( v10 )
ms3_list_free(v10);
return (unsigned int)v9;
}
}
| s3_rename_directory:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2e0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x280],RDI
MOV qword ptr [RBP + -0x288],RSI
MOV qword ptr [RBP + -0x290],RDX
MOV qword ptr [RBP + -0x298],RCX
MOV qword ptr [RBP + -0x2a0],R8
MOV qword ptr [RBP + -0x2b0],0x0
MOV byte ptr [RBP + -0x2b1],0x0
MOV RDI,qword ptr [RBP + -0x280]
MOV RSI,qword ptr [RBP + -0x288]
MOV RDX,qword ptr [RBP + -0x290]
LEA RCX,[RBP + -0x2b0]
CALL 0x0012cef0
MOV byte ptr [RBP + -0x2b1],AL
CMP AL,0x0
JZ 0x0012b0fd
MOV RDI,qword ptr [RBP + -0x280]
CALL 0x0012cd60
MOV qword ptr [RBP + -0x2c8],RAX
CMP RAX,0x0
JNZ 0x0012b0b4
MOVZX EDI,byte ptr [RBP + -0x2b1]
CALL 0x0012ce00
MOV qword ptr [RBP + -0x2c8],RAX
LAB_0012b0b4:
MOV RDX,0xffffffef
AND RDX,qword ptr [RBP + -0x2a0]
MOV RCX,qword ptr [RBP + -0x290]
MOVSX R8D,byte ptr [RBP + -0x2b1]
MOV R9,qword ptr [RBP + -0x2c8]
MOV EDI,0x1d
LEA RSI,[0x21d90e]
MOV AL,0x0
CALL 0x001b6900
MOV dword ptr [RBP + -0x274],0x1d
JMP 0x0012b1fe
LAB_0012b0fd:
LEA RDI,[RBP + -0x270]
MOV RSI,qword ptr [RBP + -0x298]
CALL 0x00127880
MOV qword ptr [RBP + -0x2c0],RAX
MOV RAX,qword ptr [RBP + -0x2b0]
MOV qword ptr [RBP + -0x2a8],RAX
LAB_0012b125:
CMP qword ptr [RBP + -0x2a8],0x0
JZ 0x0012b1d9
MOV RAX,qword ptr [RBP + -0x2a8]
MOV RDI,qword ptr [RAX]
MOV ESI,0x2f
CALL 0x00127870
MOV qword ptr [RBP + -0x2d0],RAX
CMP qword ptr [RBP + -0x2d0],0x0
JZ 0x0012b1c0
MOV RDI,qword ptr [RBP + -0x2c0]
MOV RSI,qword ptr [RBP + -0x2d0]
MOV RAX,qword ptr [RBP + -0x2c0]
LEA RCX,[RBP + -0x270]
SUB RAX,RCX
MOV EDX,0x25e
SUB RDX,RAX
SUB RDX,0x1
CALL 0x0021b370
MOV RDI,qword ptr [RBP + -0x280]
MOV RSI,qword ptr [RBP + -0x288]
MOV RAX,qword ptr [RBP + -0x2a8]
MOV RDX,qword ptr [RAX]
LEA RCX,[RBP + -0x270]
MOV R8,qword ptr [RBP + -0x2a0]
CALL 0x0012b230
CMP AL,0x0
JZ 0x0012b1be
MOV byte ptr [RBP + -0x2b1],0x1
LAB_0012b1be:
JMP 0x0012b1c0
LAB_0012b1c0:
JMP 0x0012b1c2
LAB_0012b1c2:
MOV RAX,qword ptr [RBP + -0x2a8]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x2a8],RAX
JMP 0x0012b125
LAB_0012b1d9:
CMP qword ptr [RBP + -0x2b0],0x0
JZ 0x0012b1ef
MOV RDI,qword ptr [RBP + -0x2b0]
CALL 0x0012d3c0
LAB_0012b1ef:
JMP 0x0012b1f1
LAB_0012b1f1:
MOVSX EAX,byte ptr [RBP + -0x2b1]
MOV dword ptr [RBP + -0x274],EAX
LAB_0012b1fe:
MOV EAX,dword ptr [RBP + -0x274]
MOV dword ptr [RBP + -0x2d4],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0012b22b
MOV EAX,dword ptr [RBP + -0x2d4]
ADD RSP,0x2e0
POP RBP
RET
LAB_0012b22b:
CALL 0x001272b0
|
int s3_rename_directory(int8 param_1,int8 param_2,int8 param_3,char *param_4,
ulong param_5)
{
char cVar1;
char *pcVar2;
char *pcVar3;
long in_FS_OFFSET;
long local_2d0;
char local_2b9;
int8 *local_2b8;
int8 *local_2b0;
ulong local_2a8;
char *local_2a0;
int8 local_298;
int8 local_290;
int8 local_288;
int local_27c;
char local_278 [616];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_2b8 = (int8 *)0x0;
local_2a8 = param_5;
local_2a0 = param_4;
local_298 = param_3;
local_290 = param_2;
local_288 = param_1;
cVar1 = ms3_list(param_1,param_2,param_3,&local_2b8);
if (cVar1 == '\0') {
pcVar2 = stpcpy(local_278,local_2a0);
local_2b9 = '\0';
for (local_2b0 = local_2b8; local_2b0 != (int8 *)0x0;
local_2b0 = (int8 *)local_2b0[3]) {
pcVar3 = strrchr((char *)*local_2b0,0x2f);
if (pcVar3 != (char *)0x0) {
strmake(pcVar2,pcVar3,0x25d - ((long)pcVar2 - (long)local_278));
cVar1 = s3_rename_object(local_288,local_290,*local_2b0,local_278,local_2a8);
if (cVar1 != '\0') {
local_2b9 = '\x01';
}
}
}
if (local_2b8 != (int8 *)0x0) {
ms3_list_free(local_2b8);
}
local_27c = (int)local_2b9;
}
else {
local_2d0 = ms3_server_error(local_288);
if (local_2d0 == 0) {
local_2d0 = ms3_error(cVar1);
}
my_printf_error(0x1d,"Can\'t get list of files from %s. Error: %d %s",local_2a8 & 0xffffffef,
local_298,(int)cVar1,local_2d0);
local_27c = 0x1d;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_27c;
}
| |
50,656 | nglog::TruncateStdoutStderr() | ng-log[P]ng-log/src/logging.cc | static uint32 MaxLogSize() {
return (FLAGS_max_log_size > 0 && FLAGS_max_log_size < 4096
? FLAGS_max_log_size
: 1);
} | O3 | cpp | nglog::TruncateStdoutStderr():
pushq %rbx
leaq 0x2243f(%rip), %rax # 0x2fbfc
movl (%rax), %eax
leal -0x1(%rax), %ecx
shll $0x14, %eax
cmpl $0xfff, %ecx # imm = 0xFFF
movl $0x100000, %ebx # imm = 0x100000
cmovbl %eax, %ebx
leaq 0x14ff5(%rip), %rdi # 0x227cf
movl $0x100000, %edx # imm = 0x100000
movq %rbx, %rsi
callq 0xd03c
leaq 0x14ff1(%rip), %rdi # 0x227df
movl $0x100000, %edx # imm = 0x100000
movq %rbx, %rsi
popq %rbx
jmp 0xd03c
| _ZN5nglog20TruncateStdoutStderrEv:
push rbx
lea rax, _ZN3fLU18FLAGS_max_log_sizeE; fLU::FLAGS_max_log_size
mov eax, [rax]
lea ecx, [rax-1]; unsigned __int64
shl eax, 14h
cmp ecx, 0FFFh
mov ebx, 100000h
cmovb ebx, eax
lea rdi, aProcSelfFd1; "/proc/self/fd/1"
mov edx, 100000h; unsigned __int64
mov rsi, rbx; char *
call _ZN5nglog15TruncateLogFileEPKcmm; nglog::TruncateLogFile(char const*,ulong,ulong)
lea rdi, aProcSelfFd2; "/proc/self/fd/2"
mov edx, 100000h; unsigned __int64
mov rsi, rbx; char *
pop rbx
jmp _ZN5nglog15TruncateLogFileEPKcmm; nglog::TruncateLogFile(char const*,ulong,ulong)
| void nglog::TruncateStdoutStderr(nglog *this)
{
long long v1; // rbx
v1 = 0x100000LL;
if ( (unsigned int)(fLU::FLAGS_max_log_size - 1) < 0xFFF )
v1 = (unsigned int)(fLU::FLAGS_max_log_size << 20);
nglog::TruncateLogFile((nglog *)"/proc/self/fd/1", (const char *)v1, 0x100000LL);
nglog::TruncateLogFile((nglog *)"/proc/self/fd/2", (const char *)v1, 0x100000LL);
}
| TruncateStdoutStderr:
PUSH RBX
LEA RAX,[0x12fbfc]
MOV EAX,dword ptr [RAX]
LEA ECX,[RAX + -0x1]
SHL EAX,0x14
CMP ECX,0xfff
MOV EBX,0x100000
CMOVC EBX,EAX
LEA RDI,[0x1227cf]
MOV EDX,0x100000
MOV RSI,RBX
CALL 0x0010d03c
LEA RDI,[0x1227df]
MOV EDX,0x100000
MOV RSI,RBX
POP RBX
JMP 0x0010d03c
|
/* nglog::TruncateStdoutStderr() */
void nglog::TruncateStdoutStderr(void)
{
ulong uVar1;
uVar1 = 0x100000;
if (fLU::FLAGS_max_log_size - 1U < 0xfff) {
uVar1 = (ulong)(uint)(fLU::FLAGS_max_log_size << 0x14);
}
TruncateLogFile("/proc/self/fd/1",uVar1,0x100000);
TruncateLogFile("/proc/self/fd/2",uVar1,0x100000);
return;
}
| |
50,657 | my_printf_error | eloqsql/mysys/my_error.c | void my_printf_error(uint error, const char *format, myf MyFlags, ...)
{
va_list args;
char ebuff[ERRMSGSIZE];
DBUG_ENTER("my_printf_error");
DBUG_PRINT("my", ("nr: %d MyFlags: %lu errno: %d format: %s",
error, MyFlags, errno, format));
va_start(args,MyFlags);
(void) my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, ebuff,
sizeof(ebuff), format, args);
va_end(args);
(*error_handler_hook)(error, ebuff, MyFlags);
DBUG_VOID_RETURN;
} | O3 | c | my_printf_error:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2d8, %rsp # imm = 0x2D8
movq %rdx, %rbx
movq %rsi, %r10
movl %edi, %r14d
leaq -0x2f0(%rbp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x2a845
movaps %xmm0, -0x2c0(%rbp)
movaps %xmm1, -0x2b0(%rbp)
movaps %xmm2, -0x2a0(%rbp)
movaps %xmm3, -0x290(%rbp)
movaps %xmm4, -0x280(%rbp)
movaps %xmm5, -0x270(%rbp)
movaps %xmm6, -0x260(%rbp)
movaps %xmm7, -0x250(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
movabsq $0x3000000018, %rax # imm = 0x3000000018
leaq -0x240(%rbp), %r8
movq %rax, (%r8)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r8)
movq %rdx, 0x10(%r8)
leaq 0x337037(%rip), %rdi # 0x3618b0
leaq -0x220(%rbp), %r15
movl $0x200, %edx # imm = 0x200
movq %r15, %rsi
movq %r10, %rcx
callq 0x58b70
leaq 0x2c3ae9(%rip), %rax # 0x2ee380
movl %r14d, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *(%rax)
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x2a8bf
addq $0x2d8, %rsp # imm = 0x2D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x24330
| my_printf_error:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 2D8h
mov rbx, rdx
mov r10, rsi
mov r14d, edi
lea rdx, [rbp+var_2F0]
mov [rdx+18h], rcx
mov [rdx+20h], r8
mov [rdx+28h], r9
test al, al
jz short loc_2A845
movaps [rbp+var_2C0], xmm0
movaps [rbp+var_2B0], xmm1
movaps [rbp+var_2A0], xmm2
movaps [rbp+var_290], xmm3
movaps [rbp+var_280], xmm4
movaps [rbp+var_270], xmm5
movaps [rbp+var_260], xmm6
movaps [rbp+var_250], xmm7
loc_2A845:
mov rax, fs:28h
mov [rbp+var_20], rax
mov rax, 3000000018h
lea r8, [rbp+var_240]
mov [r8], rax
lea rax, [rbp+arg_0]
mov [r8+8], rax
mov [r8+10h], rdx
lea rdi, my_charset_utf8mb3_general_ci
lea r15, [rbp+var_220]
mov edx, 200h
mov rsi, r15
mov rcx, r10
call my_vsnprintf_ex
lea rax, error_handler_hook
mov edi, r14d
mov rsi, r15
mov rdx, rbx
call qword ptr [rax]
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_2A8BF
add rsp, 2D8h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_2A8BF:
call ___stack_chk_fail
| unsigned long long my_printf_error(
unsigned int a1,
long long a2,
__int16 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 v17; // [rsp+0h] [rbp-2F0h] BYREF
long long v18; // [rsp+18h] [rbp-2D8h]
long long v19; // [rsp+20h] [rbp-2D0h]
long long v20; // [rsp+28h] [rbp-2C8h]
__m128 v21; // [rsp+30h] [rbp-2C0h]
__m128 v22; // [rsp+40h] [rbp-2B0h]
__m128 v23; // [rsp+50h] [rbp-2A0h]
__m128 v24; // [rsp+60h] [rbp-290h]
__m128 v25; // [rsp+70h] [rbp-280h]
__m128 v26; // [rsp+80h] [rbp-270h]
__m128 v27; // [rsp+90h] [rbp-260h]
__m128 v28; // [rsp+A0h] [rbp-250h]
_QWORD v29[4]; // [rsp+B0h] [rbp-240h] BYREF
_BYTE v30[512]; // [rsp+D0h] [rbp-220h] BYREF
unsigned long long v31; // [rsp+2D0h] [rbp-20h]
v21 = a7;
v22 = a8;
v23 = a9;
v24 = a10;
v25 = a11;
v26 = a12;
v27 = a13;
v28 = a14;
v18 = a4;
v19 = a5;
v20 = a6;
v31 = __readfsqword(0x28u);
v29[0] = 0x3000000018LL;
v29[1] = &a15;
v29[2] = &v17;
my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, v30, 512LL, a2, v29);
error_handler_hook(a1, (long long)v30, a3);
return __readfsqword(0x28u);
}
| my_printf_error:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x2d8
MOV RBX,RDX
MOV R10,RSI
MOV R14D,EDI
LEA RDX,[RBP + -0x2f0]
MOV qword ptr [RDX + 0x18],RCX
MOV qword ptr [RDX + 0x20],R8
MOV qword ptr [RDX + 0x28],R9
TEST AL,AL
JZ 0x0012a845
MOVAPS xmmword ptr [RBP + -0x2c0],XMM0
MOVAPS xmmword ptr [RBP + -0x2b0],XMM1
MOVAPS xmmword ptr [RBP + -0x2a0],XMM2
MOVAPS xmmword ptr [RBP + -0x290],XMM3
MOVAPS xmmword ptr [RBP + -0x280],XMM4
MOVAPS xmmword ptr [RBP + -0x270],XMM5
MOVAPS xmmword ptr [RBP + -0x260],XMM6
MOVAPS xmmword ptr [RBP + -0x250],XMM7
LAB_0012a845:
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,0x3000000018
LEA R8,[RBP + -0x240]
MOV qword ptr [R8],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [R8 + 0x8],RAX
MOV qword ptr [R8 + 0x10],RDX
LEA RDI,[0x4618b0]
LEA R15,[RBP + -0x220]
MOV EDX,0x200
MOV RSI,R15
MOV RCX,R10
CALL 0x00158b70
LEA RAX,[0x3ee380]
MOV EDI,R14D
MOV RSI,R15
MOV RDX,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0012a8bf
ADD RSP,0x2d8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0012a8bf:
CALL 0x00124330
|
void my_printf_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
long in_FS_OFFSET;
int1 local_2f8 [24];
int8 local_2e0;
int8 local_2d8;
int8 local_2d0;
int8 local_2c8;
int8 local_2b8;
int8 local_2a8;
int8 local_298;
int8 local_288;
int8 local_278;
int8 local_268;
int8 local_258;
int8 local_248;
int1 *local_240;
int1 *local_238;
int1 local_228 [512];
long local_28;
local_238 = local_2f8;
if (in_AL != '\0') {
local_2c8 = param_1;
local_2b8 = param_2;
local_2a8 = param_3;
local_298 = param_4;
local_288 = param_5;
local_278 = param_6;
local_268 = param_7;
local_258 = param_8;
}
local_28 = *(long *)(in_FS_OFFSET + 0x28);
local_248 = 0x3000000018;
local_240 = &stack0x00000008;
local_2e0 = param_12;
local_2d8 = param_13;
local_2d0 = param_14;
my_vsnprintf_ex(my_charset_utf8mb3_general_ci,local_228,0x200,param_10);
(*(code *)error_handler_hook)(param_9,local_228,param_11);
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
50,658 | SchemaConverter::_visit_pattern(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/common/json-schema-to-grammar.cpp | std::string _visit_pattern(const std::string & pattern, const std::string & name) {
if (!(pattern.front() == '^' && pattern.back() == '$')) {
_errors.push_back("Pattern must start with '^' and end with '$'");
return "";
}
std::string sub_pattern = pattern.substr(1, pattern.length() - 2);
std::unordered_map<std::string, std::string> sub_rule_ids;
size_t i = 0;
size_t length = sub_pattern.length();
using literal_or_rule = std::pair<std::string, bool>;
auto to_rule = [&](const literal_or_rule & ls) {
auto is_literal = ls.second;
auto s = ls.first;
return is_literal ? "\"" + s + "\"" : s;
};
std::function<literal_or_rule()> transform = [&]() -> literal_or_rule {
size_t start = i;
std::vector<literal_or_rule> seq;
auto get_dot = [&]() {
std::string rule;
if (_dotall) {
rule = "[\\U00000000-\\U0010FFFF]";
} else {
rule = "[^\\x0A\\x0D]";
}
return _add_rule("dot", rule);
};
// Joins the sequence, merging consecutive literals together.
auto join_seq = [&]() {
std::vector<literal_or_rule> ret;
std::string literal;
auto flush_literal = [&]() {
if (literal.empty()) {
return false;
}
ret.emplace_back(literal, true);
literal.clear();
return true;
};
for (const auto & item : seq) {
auto is_literal = item.second;
if (is_literal) {
literal += item.first;
} else {
flush_literal();
ret.push_back(item);
}
}
flush_literal();
std::vector<std::string> results;
for (const auto & item : ret) {
results.push_back(to_rule(item));
}
return std::make_pair(string_join(results, " "), false);
};
while (i < length) {
char c = sub_pattern[i];
if (c == '.') {
seq.emplace_back(get_dot(), false);
i++;
} else if (c == '(') {
i++;
if (i < length) {
if (sub_pattern[i] == '?') {
_warnings.push_back("Unsupported pattern syntax");
}
}
seq.emplace_back("(" + to_rule(transform()) + ")", false);
} else if (c == ')') {
i++;
if (start > 0 && sub_pattern[start - 1] != '(') {
_errors.push_back("Unbalanced parentheses");
}
return join_seq();
} else if (c == '[') {
std::string square_brackets = std::string(1, c);
i++;
while (i < length && sub_pattern[i] != ']') {
if (sub_pattern[i] == '\\') {
square_brackets += sub_pattern.substr(i, 2);
i += 2;
} else {
square_brackets += sub_pattern[i];
i++;
}
}
if (i >= length) {
_errors.push_back("Unbalanced square brackets");
}
square_brackets += ']';
i++;
seq.emplace_back(square_brackets, false);
} else if (c == '|') {
seq.emplace_back("|", false);
i++;
} else if (c == '*' || c == '+' || c == '?') {
seq.back() = std::make_pair(to_rule(seq.back()) + c, false);
i++;
} else if (c == '{') {
std::string curly_brackets = std::string(1, c);
i++;
while (i < length && sub_pattern[i] != '}') {
curly_brackets += sub_pattern[i];
i++;
}
if (i >= length) {
_errors.push_back("Unbalanced curly brackets");
}
curly_brackets += '}';
i++;
auto nums = string_split(curly_brackets.substr(1, curly_brackets.length() - 2), ",");
int min_times = 0;
int max_times = std::numeric_limits<int>::max();
try {
if (nums.size() == 1) {
min_times = max_times = std::stoi(nums[0]);
} else if (nums.size() != 2) {
_errors.push_back("Wrong number of values in curly brackets");
} else {
if (!nums[0].empty()) {
min_times = std::stoi(nums[0]);
}
if (!nums[1].empty()) {
max_times = std::stoi(nums[1]);
}
}
} catch (const std::invalid_argument & e) {
_errors.push_back("Invalid number in curly brackets");
return std::make_pair("", false);
}
auto &last = seq.back();
auto &sub = last.first;
auto sub_is_literal = last.second;
if (!sub_is_literal) {
std::string & sub_id = sub_rule_ids[sub];
if (sub_id.empty()) {
sub_id = _add_rule(name + "-" + std::to_string(sub_rule_ids.size()), sub);
}
sub = sub_id;
}
seq.back().first = build_repetition(
sub_is_literal ? "\"" + sub + "\"" : sub,
min_times,
max_times,
""
);
seq.back().second = false;
} else {
std::string literal;
auto is_non_literal = [&](char c) {
return NON_LITERAL_SET.find(c) != NON_LITERAL_SET.end();
};
while (i < length) {
if (sub_pattern[i] == '\\' && i < length - 1) {
char next = sub_pattern[i + 1];
if (ESCAPED_IN_REGEXPS_BUT_NOT_IN_LITERALS.find(next) != ESCAPED_IN_REGEXPS_BUT_NOT_IN_LITERALS.end()) {
i++;
literal += sub_pattern[i];
i++;
} else {
literal += sub_pattern.substr(i, 2);
i += 2;
}
} else if (sub_pattern[i] == '"') {
literal += "\\\"";
i++;
} else if (!is_non_literal(sub_pattern[i]) &&
(i == length - 1 || literal.empty() || sub_pattern[i + 1] == '.' || !is_non_literal(sub_pattern[i + 1]))) {
literal += sub_pattern[i];
i++;
} else {
break;
}
}
if (!literal.empty()) {
seq.emplace_back(literal, true);
}
}
}
return join_seq();
};
return _add_rule(name, "\"\\\"\" (" + to_rule(transform()) + ") \"\\\"\" space");
} | O2 | cpp | SchemaConverter::_visit_pattern(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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
cmpb $0x5e, (%rax)
jne 0x9183c
movq %rcx, %r15
movq 0x8(%rdx), %rcx
cmpb $0x24, -0x1(%rax,%rcx)
jne 0x9183c
addq $-0x2, %rcx
leaq 0xe0(%rsp), %r12
pushq $0x1
popq %rax
movq %r12, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x23970
leaq 0x130(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
leaq 0xd8(%rsp), %rcx
andq $0x0, (%rcx)
movups %xmm0, -0x8(%rax)
movq 0x8(%r12), %rax
leaq 0xd0(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
movq %r14, 0x8(%rsi)
leaq 0xf(%rsp), %rax
movq %rax, 0x10(%rsi)
movq %rdx, 0x18(%rsi)
movq %r12, 0x20(%rsi)
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x28(%rsi)
leaq 0x100(%rsp), %rax
movq %rax, 0x30(%rsi)
movq %r15, 0x38(%rsi)
callq 0x9428e
leaq 0x10(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x94374
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x942d6
leaq 0x2742b(%rip), %rsi # 0xb8bd5
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x2730b
leaq 0x2741c(%rip), %rdx # 0xb8bdc
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x27285
leaq 0x90(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8e5f4
leaq 0x90(%rsp), %rdi
callq 0x24218
leaq 0x70(%rsp), %rdi
callq 0x24218
leaq 0x50(%rsp), %rdi
callq 0x24218
leaq 0x10(%rsp), %rdi
callq 0x24218
leaq 0xb0(%rsp), %rdi
callq 0x47dfa
leaq 0x100(%rsp), %rdi
callq 0x93e20
leaq 0xe0(%rsp), %rdi
callq 0x24218
jmp 0x91887
leaq 0x27365(%rip), %rsi # 0xb8ba8
leaq 0x10(%rsp), %rdi
leaq 0x100(%rsp), %rdx
callq 0x2724a
addq $0xc8, %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x3adee
leaq 0x10(%rsp), %rdi
callq 0x24218
leaq 0x1e4bf(%rip), %rsi # 0xafd39
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2724a
movq %rbx, %rax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x24218
jmp 0x918ae
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x24218
jmp 0x918bd
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x24218
jmp 0x918cc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x24218
jmp 0x918db
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x47dfa
leaq 0x100(%rsp), %rdi
callq 0x93e20
leaq 0xe0(%rsp), %rdi
jmp 0x9190c
movq %rax, %rbx
jmp 0x918e8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x24218
jmp 0x91916
movq %rax, %rbx
movq %rbx, %rdi
callq 0x23fd0
| _ZN15SchemaConverter14_visit_patternERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_:
push r15
push r14
push r12
push rbx
sub rsp, 138h
mov r14, rsi
mov rbx, rdi
mov rax, [rdx]
cmp byte ptr [rax], 5Eh ; '^'
jnz loc_9183C
mov r15, rcx
mov rcx, [rdx+8]
cmp byte ptr [rax+rcx-1], 24h ; '$'
jnz loc_9183C
add rcx, 0FFFFFFFFFFFFFFFEh
lea r12, [rsp+158h+var_78]
push 1
pop rax
mov rdi, r12
mov rsi, rdx
mov rdx, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rax, [rsp+158h+var_28]
mov [rax-30h], rax
mov qword ptr [rax-28h], 1
xorps xmm0, xmm0
movups xmmword ptr [rax-20h], xmm0
mov dword ptr [rax-10h], 3F800000h
lea rcx, [rsp+158h+var_80]
and qword ptr [rcx], 0
movups xmmword ptr [rax-8], xmm0
mov rax, [r12+8]
lea rdx, [rsp+158h+var_88]
mov [rdx], rax
lea rsi, [rsp+158h+var_148]
mov [rsi], rcx
mov [rsi+8], r14
lea rax, [rsp+158h+var_149]
mov [rsi+10h], rax
mov [rsi+18h], rdx
mov [rsi+20h], r12
lea rdi, [rsp+158h+var_A8]
mov [rsi+28h], rdi
lea rax, [rsp+158h+var_58]
mov [rsi+30h], rax
mov [rsi+38h], r15
call _ZNSt8functionIFSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbEvEEC2IZN15SchemaConverter14_visit_patternERKS6_SD_EUlvE_vEEOT_; std::function<std::pair<std::string,bool> ()(void)>::function<SchemaConverter::_visit_pattern(std::string const&,std::string const&)::{lambda(void)#1},void>(SchemaConverter::_visit_pattern(std::string const&,std::string const&)::{lambda(void)#1} &&)
lea rdi, [rsp+158h+var_148]
lea rsi, [rsp+158h+var_A8]
call _ZNKSt8functionIFSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbEvEEclEv; std::function<std::pair<std::string,bool> ()(void)>::operator()(void)
lea rdi, [rsp+158h+var_108]
lea rsi, [rsp+158h+var_149]
lea rdx, [rsp+158h+var_148]
call _ZZN15SchemaConverter14_visit_patternERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_ENKUlRKSt4pairIS5_bEE_clB5cxx11ESB_; SchemaConverter::_visit_pattern(std::string const&,std::string const&)::{lambda(std::pair<std::string,bool> const&)#1}::operator()(std::pair<std::string,bool> const&)
lea rsi, asc_B8BD5; "\"\\\"\" ("
lea rdi, [rsp+158h+var_E8]
lea rdx, [rsp+158h+var_108]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
lea rdx, aSpace; ") \"\\\"\" space"
lea rdi, [rsp+158h+var_C8]
lea rsi, [rsp+158h+var_E8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rcx, [rsp+158h+var_C8]
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call _ZN15SchemaConverter9_add_ruleERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_; SchemaConverter::_add_rule(std::string const&,std::string const&)
lea rdi, [rsp+158h+var_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+158h+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+158h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+158h+var_148]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+158h+var_A8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+158h+var_58]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESaIS8_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSA_18_Mod_range_hashingENSA_20_Default_ranged_hashENSA_20_Prime_rehash_policyENSA_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,std::string>,std::allocator<std::pair<std::string const,std::string>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable()
lea rdi, [rsp+158h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_91887
loc_9183C:
lea rsi, aPatternMustSta; "Pattern must start with '^' and end wit"...
lea rdi, [rsp+158h+var_148]
lea rdx, [rsp+158h+var_58]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
add r14, 0C8h
lea rsi, [rsp+158h+var_148]
mov rdi, r14
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
lea rdi, [rsp+158h+var_148]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rsi, aErrorWhileHand_0+34h; ""
lea rdx, [rsp+158h+var_148]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
loc_91887:
mov rax, rbx
add rsp, 138h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_918AE
mov rbx, rax
loc_918AE:
lea rdi, [rsp+arg_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_918BD
mov rbx, rax
loc_918BD:
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_918CC
mov rbx, rax
loc_918CC:
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_918DB
mov rbx, rax
loc_918DB:
lea rdi, [rsp+arg_A8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
loc_918E8:
lea rdi, [rsp+arg_F8]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESaIS8_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSA_18_Mod_range_hashingENSA_20_Default_ranged_hashENSA_20_Prime_rehash_policyENSA_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,std::string>,std::allocator<std::pair<std::string const,std::string>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable()
lea rdi, [rsp+arg_D8]
jmp short loc_9190C
mov rbx, rax
jmp short loc_918E8
mov rbx, rax
lea rdi, [rsp+arg_8]; void *
loc_9190C:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_91916
mov rbx, rax
loc_91916:
mov rdi, rbx
call __Unwind_Resume
| _QWORD * SchemaConverter::_visit_pattern(_QWORD *a1, long long a2, long long a3, _QWORD *a4)
{
long long v5; // rcx
int v6; // ecx
int v7; // r8d
int v8; // r9d
char v10; // [rsp+Fh] [rbp-149h] BYREF
_QWORD v11[8]; // [rsp+10h] [rbp-148h] BYREF
_BYTE v12[32]; // [rsp+50h] [rbp-108h] BYREF
_BYTE v13[32]; // [rsp+70h] [rbp-E8h] BYREF
_QWORD v14[4]; // [rsp+90h] [rbp-C8h] BYREF
_BYTE v15[32]; // [rsp+B0h] [rbp-A8h] BYREF
long long v16; // [rsp+D0h] [rbp-88h] BYREF
long long v17; // [rsp+D8h] [rbp-80h] BYREF
_BYTE v18[8]; // [rsp+E0h] [rbp-78h] BYREF
long long v19; // [rsp+E8h] [rbp-70h]
_QWORD v20[2]; // [rsp+100h] [rbp-58h] BYREF
__int128 v21; // [rsp+110h] [rbp-48h]
int v22; // [rsp+120h] [rbp-38h]
__int128 v23; // [rsp+128h] [rbp-30h] BYREF
if ( **(_BYTE **)a3 == 94 && (v5 = *(_QWORD *)(a3 + 8), *(_BYTE *)(*(_QWORD *)a3 + v5 - 1) == 36) )
{
std::string::substr(v18, a3, 1LL, v5 - 2);
v20[0] = (char *)&v23 + 8;
v20[1] = 1LL;
v21 = 0LL;
v22 = 1065353216;
v17 = 0LL;
v23 = 0LL;
v16 = v19;
v11[0] = &v17;
v11[1] = a2;
v11[2] = &v10;
v11[3] = &v16;
v11[4] = v18;
v11[5] = v15;
v11[6] = v20;
v11[7] = a4;
std::function<std::pair<std::string,bool> ()(void)>::function<SchemaConverter::_visit_pattern(std::string const&,std::string const&)::{lambda(void)#1},void>(
v15,
v11,
&v16,
&v17);
std::function<std::pair<std::string,bool> ()(void)>::operator()(v11, v15);
SchemaConverter::_visit_pattern(std::string const&,std::string const&)::{lambda(std::pair<std::string,bool> const&)#1}::operator()[abi:cxx11](
(unsigned int)v12,
(unsigned int)&v10,
(unsigned int)v11,
v6,
v7,
v8);
std::operator+<char>((long long)v13, (long long)"\"\\\"\" (", (long long)v12);
std::operator+<char>((long long)v14, (long long)v13, (long long)") \"\\\"\" space");
SchemaConverter::_add_rule((long long)a1, a2, a4, v14);
std::string::~string(v14);
std::string::~string(v13);
std::string::~string(v12);
std::string::~string(v11);
std::_Function_base::~_Function_base((std::_Function_base *)v15);
std::_Hashtable<std::string,std::pair<std::string const,std::string>,std::allocator<std::pair<std::string const,std::string>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable(v20);
std::string::~string(v18);
}
else
{
std::string::basic_string<std::allocator<char>>(v11, (long long)"Pattern must start with '^' and end with '$'");
std::vector<std::string>::emplace_back<std::string>(a2 + 200, (long long)v11);
std::string::~string(v11);
std::string::basic_string<std::allocator<char>>(a1, (long long)"");
}
return a1;
}
| _visit_pattern:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x138
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDX]
CMP byte ptr [RAX],0x5e
JNZ 0x0019183c
MOV R15,RCX
MOV RCX,qword ptr [RDX + 0x8]
CMP byte ptr [RAX + RCX*0x1 + -0x1],0x24
JNZ 0x0019183c
ADD RCX,-0x2
LEA R12,[RSP + 0xe0]
PUSH 0x1
POP RAX
MOV RDI,R12
MOV RSI,RDX
MOV RDX,RAX
CALL 0x00123970
LEA RAX,[RSP + 0x130]
MOV qword ptr [RAX + -0x30],RAX
MOV qword ptr [RAX + -0x28],0x1
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + -0x20],XMM0
MOV dword ptr [RAX + -0x10],0x3f800000
LEA RCX,[RSP + 0xd8]
AND qword ptr [RCX],0x0
MOVUPS xmmword ptr [RAX + -0x8],XMM0
MOV RAX,qword ptr [R12 + 0x8]
LEA RDX,[RSP + 0xd0]
MOV qword ptr [RDX],RAX
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],RCX
MOV qword ptr [RSI + 0x8],R14
LEA RAX,[RSP + 0xf]
MOV qword ptr [RSI + 0x10],RAX
MOV qword ptr [RSI + 0x18],RDX
MOV qword ptr [RSI + 0x20],R12
LEA RDI,[RSP + 0xb0]
MOV qword ptr [RSI + 0x28],RDI
LEA RAX,[RSP + 0x100]
MOV qword ptr [RSI + 0x30],RAX
MOV qword ptr [RSI + 0x38],R15
LAB_00191778:
CALL 0x0019428e
LAB_0019177d:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0xb0]
CALL 0x00194374
LAB_0019178f:
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0xf]
LEA RDX,[RSP + 0x10]
CALL 0x001942d6
LAB_001917a3:
LEA RSI,[0x1b8bd5]
LEA RDI,[RSP + 0x70]
LEA RDX,[RSP + 0x50]
CALL 0x0012730b
LAB_001917b9:
LEA RDX,[0x1b8bdc]
LEA RDI,[RSP + 0x90]
LEA RSI,[RSP + 0x70]
CALL 0x00127285
LAB_001917d2:
LEA RCX,[RSP + 0x90]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x0018e5f4
LEA RDI,[RSP + 0x90]
CALL 0x00124218
LEA RDI,[RSP + 0x70]
CALL 0x00124218
LEA RDI,[RSP + 0x50]
CALL 0x00124218
LEA RDI,[RSP + 0x10]
CALL 0x00124218
LEA RDI,[RSP + 0xb0]
CALL 0x00147dfa
LEA RDI,[RSP + 0x100]
CALL 0x00193e20
LEA RDI,[RSP + 0xe0]
CALL 0x00124218
JMP 0x00191887
LAB_0019183c:
LEA RSI,[0x1b8ba8]
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x100]
CALL 0x0012724a
ADD R14,0xc8
LAB_0019185c:
LEA RSI,[RSP + 0x10]
MOV RDI,R14
CALL 0x0013adee
LAB_00191869:
LEA RDI,[RSP + 0x10]
CALL 0x00124218
LEA RSI,[0x1afd39]
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
CALL 0x0012724a
LAB_00191887:
MOV RAX,RBX
ADD RSP,0x138
POP RBX
POP R12
POP R14
POP R15
RET
|
/* SchemaConverter::_visit_pattern(std::__cxx11::string const&, std::__cxx11::string const&) */
string * SchemaConverter::_visit_pattern(string *param_1,string *param_2)
{
int8 *in_RDX;
int1 local_149;
int8 *local_148;
string *local_140;
int1 *local_138;
int8 *local_130;
string *local_128;
_lambda___1_ *local_120;
int8 **local_118;
string local_108 [32];
string local_e8 [32];
string local_c8 [32];
_lambda___1_ local_a8 [32];
int8 local_88;
int8 local_80;
string local_78 [8];
int8 local_70;
int8 *local_58;
int8 local_50;
int8 local_48;
int8 uStack_40;
int4 local_38;
int8 local_30;
int8 uStack_28;
if ((*(char *)*in_RDX == '^') && (((char *)*in_RDX)[in_RDX[1] + -1] == '$')) {
std::__cxx11::string::substr((ulong)local_78,(ulong)in_RDX);
local_58 = &uStack_28;
local_50 = 1;
local_48 = 0;
uStack_40 = 0;
local_38 = 0x3f800000;
local_148 = &local_80;
local_80 = 0;
local_30 = 0;
uStack_28 = 0;
local_130 = &local_88;
local_88 = local_70;
local_138 = &local_149;
local_120 = local_a8;
local_118 = &local_58;
local_140 = param_2;
local_128 = local_78;
/* try { // try from 00191778 to 0019177c has its CatchHandler @ 001918ff */
std::function<std::pair<std::__cxx11::string,bool>()>::
function<SchemaConverter::_visit_pattern(std::__cxx11::string_const&,std::__cxx11::string_const&)::_lambda()_1_,void>
(local_120);
/* try { // try from 0019177d to 0019178e has its CatchHandler @ 001918d8 */
std::function<std::pair<std::__cxx11::string,bool>()>::operator()
((function<std::pair<std::__cxx11::string,bool>()> *)&local_148);
/* try { // try from 0019178f to 001917a2 has its CatchHandler @ 001918c9 */
_visit_pattern(std::__cxx11::string_const&,std::__cxx11::string_const&)::
{lambda(std::pair<std::__cxx11::string,bool>const&)#1}::operator()::string_bool>_const___const
(local_108,&local_149,&local_148);
/* try { // try from 001917a3 to 001917b8 has its CatchHandler @ 001918ba */
std::operator+((char *)local_e8,(string *)&DAT_001b8bd5);
/* try { // try from 001917b9 to 001917d1 has its CatchHandler @ 001918ab */
std::operator+(local_c8,(char *)local_e8);
/* try { // try from 001917d2 to 001917e7 has its CatchHandler @ 00191899 */
_add_rule(param_1,param_2);
std::__cxx11::string::~string(local_c8);
std::__cxx11::string::~string(local_e8);
std::__cxx11::string::~string(local_108);
std::__cxx11::string::~string((string *)&local_148);
std::_Function_base::~_Function_base((_Function_base *)local_a8);
std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::~_Hashtable((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)&local_58);
std::__cxx11::string::~string(local_78);
}
else {
/* try { // try from 0019183c to 00191854 has its CatchHandler @ 00191913 */
std::__cxx11::string::string<std::allocator<char>>
((string *)&local_148,"Pattern must start with \'^\' and end with \'$\'",
(allocator *)&local_58);
/* try { // try from 0019185c to 00191868 has its CatchHandler @ 00191904 */
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_2 + 200),
(string *)&local_148);
std::__cxx11::string::~string((string *)&local_148);
std::__cxx11::string::string<std::allocator<char>>(param_1,"",(allocator *)&local_148);
}
return param_1;
}
| |
50,659 | ggml_can_repeat | monkey531[P]llama/ggml/src/ggml.c | bool ggml_can_repeat(const struct ggml_tensor * t0, const struct ggml_tensor * t1) {
static_assert(GGML_MAX_DIMS == 4, "GGML_MAX_DIMS is not 4 - update this function");
return ggml_is_empty(t0) ? ggml_is_empty(t1) :
(t1->ne[0]%t0->ne[0] == 0) &&
(t1->ne[1]%t0->ne[1] == 0) &&
(t1->ne[2]%t0->ne[2] == 0) &&
(t1->ne[3]%t0->ne[3] == 0);
} | O1 | c | ggml_can_repeat:
cmpq $0x0, 0x10(%rdi)
je 0x1990c
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x3, %rcx
je 0x19906
leaq 0x1(%rax), %rcx
cmpq $0x0, 0x18(%rdi,%rax,8)
jne 0x198f1
cmpq $0x2, %rax
ja 0x19932
cmpq $0x0, 0x10(%rsi)
je 0x19962
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x3, %rcx
je 0x1992a
leaq 0x1(%rax), %rcx
cmpq $0x0, 0x18(%rsi,%rax,8)
jne 0x19915
cmpq $0x3, %rax
setb %al
retq
movq 0x10(%rsi), %rax
cqto
idivq 0x10(%rdi)
testq %rdx, %rdx
jne 0x1995f
movq 0x18(%rsi), %rax
cqto
idivq 0x18(%rdi)
testq %rdx, %rdx
jne 0x1995f
movq 0x20(%rsi), %rax
cqto
idivq 0x20(%rdi)
testq %rdx, %rdx
je 0x19965
xorl %eax, %eax
retq
movb $0x1, %al
retq
movq 0x28(%rsi), %rax
cqto
idivq 0x28(%rdi)
testq %rdx, %rdx
sete %al
retq
| ggml_can_repeat:
cmp qword ptr [rdi+10h], 0
jz short loc_1990C
xor ecx, ecx
loc_198F1:
mov rax, rcx
cmp rcx, 3
jz short loc_19906
lea rcx, [rax+1]
cmp qword ptr [rdi+rax*8+18h], 0
jnz short loc_198F1
loc_19906:
cmp rax, 2
ja short loc_19932
loc_1990C:
cmp qword ptr [rsi+10h], 0
jz short loc_19962
xor ecx, ecx
loc_19915:
mov rax, rcx
cmp rcx, 3
jz short loc_1992A
lea rcx, [rax+1]
cmp qword ptr [rsi+rax*8+18h], 0
jnz short loc_19915
loc_1992A:
cmp rax, 3
setb al
retn
loc_19932:
mov rax, [rsi+10h]
cqo
idiv qword ptr [rdi+10h]
test rdx, rdx
jnz short loc_1995F
mov rax, [rsi+18h]
cqo
idiv qword ptr [rdi+18h]
test rdx, rdx
jnz short loc_1995F
mov rax, [rsi+20h]
cqo
idiv qword ptr [rdi+20h]
test rdx, rdx
jz short loc_19965
loc_1995F:
xor eax, eax
retn
loc_19962:
mov al, 1
retn
loc_19965:
mov rax, [rsi+28h]
cqo
idiv qword ptr [rdi+28h]
test rdx, rdx
setz al
retn
| char ggml_can_repeat(_QWORD *a1, long long *a2)
{
unsigned long long v2; // rcx
unsigned long long v3; // rax
unsigned long long v4; // rcx
unsigned long long v5; // rax
if ( !a1[2] )
goto LABEL_19;
v2 = 0LL;
do
{
v3 = v2;
if ( v2 == 3 )
break;
++v2;
}
while ( a1[v3 + 3] );
if ( v3 > 2 )
return !(a2[2] % a1[2]) && !(a2[3] % a1[3]) && !(a2[4] % a1[4]) && a2[5] % a1[5] == 0;
LABEL_19:
if ( a2[2] )
{
v4 = 0LL;
do
{
v5 = v4;
if ( v4 == 3 )
break;
++v4;
}
while ( a2[v5 + 3] );
return v5 < 3;
}
else
{
return 1;
}
}
| ggml_can_repeat:
CMP qword ptr [RDI + 0x10],0x0
JZ 0x0011990c
XOR ECX,ECX
LAB_001198f1:
MOV RAX,RCX
CMP RCX,0x3
JZ 0x00119906
LEA RCX,[RAX + 0x1]
CMP qword ptr [RDI + RAX*0x8 + 0x18],0x0
JNZ 0x001198f1
LAB_00119906:
CMP RAX,0x2
JA 0x00119932
LAB_0011990c:
CMP qword ptr [RSI + 0x10],0x0
JZ 0x00119962
XOR ECX,ECX
LAB_00119915:
MOV RAX,RCX
CMP RCX,0x3
JZ 0x0011992a
LEA RCX,[RAX + 0x1]
CMP qword ptr [RSI + RAX*0x8 + 0x18],0x0
JNZ 0x00119915
LAB_0011992a:
CMP RAX,0x3
SETC AL
RET
LAB_00119932:
MOV RAX,qword ptr [RSI + 0x10]
CQO
IDIV qword ptr [RDI + 0x10]
TEST RDX,RDX
JNZ 0x0011995f
MOV RAX,qword ptr [RSI + 0x18]
CQO
IDIV qword ptr [RDI + 0x18]
TEST RDX,RDX
JNZ 0x0011995f
MOV RAX,qword ptr [RSI + 0x20]
CQO
IDIV qword ptr [RDI + 0x20]
TEST RDX,RDX
JZ 0x00119965
LAB_0011995f:
XOR EAX,EAX
RET
LAB_00119962:
MOV AL,0x1
RET
LAB_00119965:
MOV RAX,qword ptr [RSI + 0x28]
CQO
IDIV qword ptr [RDI + 0x28]
TEST RDX,RDX
SETZ AL
RET
|
bool ggml_can_repeat(long param_1,long param_2)
{
ulong uVar1;
ulong uVar2;
if (*(long *)(param_1 + 0x10) != 0) {
uVar1 = 0;
do {
uVar2 = uVar1;
if (uVar2 == 3) break;
uVar1 = uVar2 + 1;
} while (*(long *)(param_1 + 0x18 + uVar2 * 8) != 0);
if (2 < uVar2) {
if (((*(long *)(param_2 + 0x10) % *(long *)(param_1 + 0x10) == 0) &&
(*(long *)(param_2 + 0x18) % *(long *)(param_1 + 0x18) == 0)) &&
(*(long *)(param_2 + 0x20) % *(long *)(param_1 + 0x20) == 0)) {
return *(long *)(param_2 + 0x28) % *(long *)(param_1 + 0x28) == 0;
}
return false;
}
}
if (*(long *)(param_2 + 0x10) == 0) {
return true;
}
uVar1 = 0;
do {
uVar2 = uVar1;
if (uVar2 == 3) break;
uVar1 = uVar2 + 1;
} while (*(long *)(param_2 + 0x18 + uVar2 * 8) != 0);
return uVar2 < 3;
}
| |
50,660 | init_io_cache_share | eloqsql/mysys/mf_iocache.c | void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
IO_CACHE *write_cache, uint num_threads)
{
DBUG_ENTER("init_io_cache_share");
DBUG_PRINT("io_cache_share", ("read_cache: %p share: %p "
"write_cache: %p threads: %u",
read_cache, cshare,
write_cache, num_threads));
DBUG_ASSERT(num_threads > 1);
DBUG_ASSERT(read_cache->type == READ_CACHE);
DBUG_ASSERT(!write_cache || (write_cache->type == WRITE_CACHE));
mysql_mutex_init(key_IO_CACHE_SHARE_mutex,
&cshare->mutex, MY_MUTEX_INIT_FAST);
mysql_cond_init(key_IO_CACHE_SHARE_cond, &cshare->cond, 0);
mysql_cond_init(key_IO_CACHE_SHARE_cond_writer, &cshare->cond_writer, 0);
cshare->running_threads= num_threads;
cshare->total_threads= num_threads;
cshare->error= 0; /* Initialize. */
cshare->buffer= read_cache->buffer;
cshare->read_end= NULL; /* See function comment of lock_io_cache(). */
cshare->pos_in_file= 0; /* See function comment of lock_io_cache(). */
cshare->source_cache= write_cache; /* Can be NULL. */
read_cache->share= cshare;
read_cache->read_function= _my_b_cache_read_r;
if (write_cache)
{
write_cache->share= cshare;
write_cache->write_function= _my_b_cache_write_r;
}
DBUG_VOID_RETURN;
} | O0 | c | init_io_cache_share:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
jmp 0xb0259
jmp 0xb025b
jmp 0xb025d
jmp 0xb025f
jmp 0xb0261
jmp 0xb0263
jmp 0xb0265
leaq 0xb9b3cc(%rip), %rax # 0xc4b638
movl (%rax), %edi
movq -0x10(%rbp), %rsi
leaq 0xb9c0d7(%rip), %rdx # 0xc4c350
callq 0xaf510
leaq 0xb9b3ff(%rip), %rax # 0xc4b684
movl (%rax), %edi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb0370
leaq 0xb9b3e9(%rip), %rax # 0xc4b688
movl (%rax), %edi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb0370
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xd8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xdc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xe0(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xd0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xb8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc0(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x8(%rbp), %rax
leaq 0x89(%rip), %rcx # 0xb03c0
movq %rcx, 0xa0(%rax)
cmpq $0x0, -0x18(%rbp)
je 0xb0366
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x18(%rbp), %rax
leaq 0x491(%rip), %rcx # 0xb07f0
movq %rcx, 0xa8(%rax)
jmp 0xb0368
jmp 0xb036a
addq $0x20, %rsp
popq %rbp
retq
| init_io_cache_share:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
jmp short $+2
loc_B0259:
jmp short $+2
loc_B025B:
jmp short $+2
loc_B025D:
jmp short $+2
loc_B025F:
jmp short $+2
loc_B0261:
jmp short $+2
loc_B0263:
jmp short $+2
loc_B0265:
lea rax, key_IO_CACHE_SHARE_mutex
mov edi, [rax]
mov rsi, [rbp+var_10]
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init_6
lea rax, key_IO_CACHE_SHARE_cond
mov edi, [rax]
mov rsi, [rbp+var_10]
add rsi, 48h ; 'H'
xor eax, eax
mov edx, eax
call inline_mysql_cond_init_3
lea rax, key_IO_CACHE_SHARE_cond_writer
mov edi, [rax]
mov rsi, [rbp+var_10]
add rsi, 80h
xor eax, eax
mov edx, eax
call inline_mysql_cond_init_3
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_10]
mov [rax+0D8h], ecx
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_10]
mov [rax+0DCh], ecx
mov rax, [rbp+var_10]
mov dword ptr [rax+0E0h], 0
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
mov rax, [rbp+var_10]
mov [rax+0C8h], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+0D0h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+0B8h], 0
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax+0C0h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax+98h], rcx
mov rax, [rbp+var_8]
lea rcx, _my_b_cache_read_r
mov [rax+0A0h], rcx
cmp [rbp+var_18], 0
jz short loc_B0366
mov rcx, [rbp+var_10]
mov rax, [rbp+var_18]
mov [rax+98h], rcx
mov rax, [rbp+var_18]
lea rcx, _my_b_cache_write_r
mov [rax+0A8h], rcx
loc_B0366:
jmp short $+2
loc_B0368:
jmp short $+2
loc_B036A:
add rsp, 20h
pop rbp
retn
| _QWORD * init_io_cache_share(_QWORD *a1, long long a2, _QWORD *a3, int a4)
{
_QWORD *result; // rax
inline_mysql_mutex_init_6(key_IO_CACHE_SHARE_mutex, (_QWORD *)a2, (long long)&my_fast_mutexattr);
inline_mysql_cond_init_3(key_IO_CACHE_SHARE_cond, a2 + 72, 0LL);
inline_mysql_cond_init_3(key_IO_CACHE_SHARE_cond_writer, a2 + 128, 0LL);
*(_DWORD *)(a2 + 216) = a4;
*(_DWORD *)(a2 + 220) = a4;
*(_DWORD *)(a2 + 224) = 0;
*(_QWORD *)(a2 + 200) = a1[4];
*(_QWORD *)(a2 + 208) = 0LL;
*(_QWORD *)(a2 + 184) = 0LL;
*(_QWORD *)(a2 + 192) = a3;
a1[19] = a2;
result = a1;
a1[20] = my_b_cache_read_r;
if ( a3 )
{
a3[19] = a2;
result = a3;
a3[21] = my_b_cache_write_r;
}
return result;
}
| init_io_cache_share:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
JMP 0x001b0259
LAB_001b0259:
JMP 0x001b025b
LAB_001b025b:
JMP 0x001b025d
LAB_001b025d:
JMP 0x001b025f
LAB_001b025f:
JMP 0x001b0261
LAB_001b0261:
JMP 0x001b0263
LAB_001b0263:
JMP 0x001b0265
LAB_001b0265:
LEA RAX,[0xd4b638]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[0xd4c350]
CALL 0x001af510
LEA RAX,[0xd4b684]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x48
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001b0370
LEA RAX,[0xd4b688]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x80
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001b0370
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xd8],ECX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xdc],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xc8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xd0],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xb8],0x0
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xc0],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x98],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x1b03c0]
MOV qword ptr [RAX + 0xa0],RCX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001b0366
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x98],RCX
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x1b07f0]
MOV qword ptr [RAX + 0xa8],RCX
LAB_001b0366:
JMP 0x001b0368
LAB_001b0368:
JMP 0x001b036a
LAB_001b036a:
ADD RSP,0x20
POP RBP
RET
|
void init_io_cache_share(long param_1,long param_2,long param_3,int4 param_4)
{
inline_mysql_mutex_init(key_IO_CACHE_SHARE_mutex,param_2,&my_fast_mutexattr);
inline_mysql_cond_init(key_IO_CACHE_SHARE_cond,param_2 + 0x48,0);
inline_mysql_cond_init(key_IO_CACHE_SHARE_cond_writer,param_2 + 0x80,0);
*(int4 *)(param_2 + 0xd8) = param_4;
*(int4 *)(param_2 + 0xdc) = param_4;
*(int4 *)(param_2 + 0xe0) = 0;
*(int8 *)(param_2 + 200) = *(int8 *)(param_1 + 0x20);
*(int8 *)(param_2 + 0xd0) = 0;
*(int8 *)(param_2 + 0xb8) = 0;
*(long *)(param_2 + 0xc0) = param_3;
*(long *)(param_1 + 0x98) = param_2;
*(code **)(param_1 + 0xa0) = _my_b_cache_read_r;
if (param_3 != 0) {
*(long *)(param_3 + 0x98) = param_2;
*(code **)(param_3 + 0xa8) = _my_b_cache_write_r;
}
return;
}
| |
50,661 | nlohmann::json_abi_v3_11_3::detail::lexer<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>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan_comment() | llama.cpp/common/./json.hpp | bool scan_comment()
{
switch (get())
{
// single-line comments skip input until a newline or EOF is read
case '/':
{
while (true)
{
switch (get())
{
case '\n':
case '\r':
case char_traits<char_type>::eof():
case '\0':
return true;
default:
break;
}
}
}
// multi-line comments skip input until */ is read
case '*':
{
while (true)
{
switch (get())
{
case char_traits<char_type>::eof():
case '\0':
{
error_message = "invalid comment; missing closing '*/'";
return false;
}
case '*':
{
switch (get())
{
case '/':
return true;
default:
{
unget();
continue;
}
}
}
default:
continue;
}
}
}
// unexpected character after reading '/'
default:
{
error_message = "invalid comment; expecting '/' or '*' after '/'";
return false;
}
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<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>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan_comment():
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x26974
cmpl $0x2f, %eax
je 0x8240d
cmpl $0x2a, %eax
jne 0x8242a
movq %rbx, %rdi
callq 0x26974
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x82433
cmpl $0x2a, %eax
jne 0x823e1
movq %rbx, %rdi
callq 0x26974
cmpl $0x2f, %eax
je 0x82426
movq %rbx, %rdi
callq 0x82c9c
jmp 0x823e1
movl $0x4803, %ebp # imm = 0x4803
movq %rbx, %rdi
callq 0x26974
incl %eax
cmpl $0xf, %eax
jae 0x82412
btl %eax, %ebp
jae 0x82412
movb $0x1, %al
jmp 0x82440
leaq 0xf318c(%rip), %rax # 0x1755bd
jmp 0x8243a
leaq 0xf315d(%rip), %rax # 0x175597
movq %rax, 0x70(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE12scan_commentEv:
push rbp
push rbx
push rax
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 2Fh ; '/'
jz short loc_8240D
cmp eax, 2Ah ; '*'
jnz short loc_8242A
loc_823E1:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
lea ecx, [rax+1]
cmp ecx, 2
jb short loc_82433
cmp eax, 2Ah ; '*'
jnz short loc_823E1
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 2Fh ; '/'
jz short loc_82426
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv; nlohmann::json_abi_v3_11_3::detail::lexer<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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(void)
jmp short loc_823E1
loc_8240D:
mov ebp, 4803h
loc_82412:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
inc eax
cmp eax, 0Fh
jnb short loc_82412
bt ebp, eax
jnb short loc_82412
loc_82426:
mov al, 1
jmp short loc_82440
loc_8242A:
lea rax, aInvalidComment; "invalid comment; expecting '/' or '*' a"...
jmp short loc_8243A
loc_82433:
lea rax, aInvalidComment_0; "invalid comment; missing closing '*/'"
loc_8243A:
mov [rbx+70h], rax
xor eax, eax
loc_82440:
add rsp, 8
pop rbx
pop rbp
retn
| char nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_comment(
__m128i *a1)
{
int v1; // eax
int v2; // eax
int v3; // ebp
unsigned int v4; // eax
const char *v6; // rax
v1 = nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
if ( v1 == 47 )
{
v3 = 18435;
do
{
do
v4 = nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1)
+ 1;
while ( v4 >= 0xF );
}
while ( !_bittest(&v3, v4) );
return 1;
}
else
{
if ( v1 == 42 )
{
while ( 1 )
{
v2 = nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
if ( (unsigned int)(v2 + 1) < 2 )
break;
if ( v2 == 42 )
{
if ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) == 47 )
return 1;
nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(a1);
}
}
v6 = "invalid comment; missing closing '*/'";
}
else
{
v6 = "invalid comment; expecting '/' or '*' after '/'";
}
a1[7].m128i_i64[0] = (long long)v6;
return 0;
}
}
| scan_comment:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00126974
CMP EAX,0x2f
JZ 0x0018240d
CMP EAX,0x2a
JNZ 0x0018242a
LAB_001823e1:
MOV RDI,RBX
CALL 0x00126974
LEA ECX,[RAX + 0x1]
CMP ECX,0x2
JC 0x00182433
CMP EAX,0x2a
JNZ 0x001823e1
MOV RDI,RBX
CALL 0x00126974
CMP EAX,0x2f
JZ 0x00182426
MOV RDI,RBX
CALL 0x00182c9c
JMP 0x001823e1
LAB_0018240d:
MOV EBP,0x4803
LAB_00182412:
MOV RDI,RBX
CALL 0x00126974
INC EAX
CMP EAX,0xf
JNC 0x00182412
BT EBP,EAX
JNC 0x00182412
LAB_00182426:
MOV AL,0x1
JMP 0x00182440
LAB_0018242a:
LEA RAX,[0x2755bd]
JMP 0x0018243a
LAB_00182433:
LEA RAX,[0x275597]
LAB_0018243a:
MOV qword ptr [RBX + 0x70],RAX
XOR EAX,EAX
LAB_00182440:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<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>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::scan_comment() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::scan_comment(lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
int iVar1;
int8 uVar2;
char *pcVar3;
iVar1 = get(this);
if (iVar1 == 0x2f) {
do {
do {
iVar1 = get(this);
} while (0xe < iVar1 + 1U);
} while ((0x4803U >> (iVar1 + 1U & 0x1f) & 1) == 0);
LAB_00182426:
uVar2 = 1;
}
else {
if (iVar1 == 0x2a) {
while (iVar1 = get(this), 1 < iVar1 + 1U) {
if (iVar1 == 0x2a) {
iVar1 = get(this);
if (iVar1 == 0x2f) goto LAB_00182426;
unget(this);
}
}
pcVar3 = "invalid comment; missing closing \'*/\'";
}
else {
pcVar3 = "invalid comment; expecting \'/\' or \'*\' after \'/\'";
}
*(char **)(this + 0x70) = pcVar3;
uVar2 = 0;
}
return uVar2;
}
| |
50,662 | ggml_hash_find(ggml_hash_set const*, ggml_tensor const*) | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-impl.h | static size_t ggml_hash_find(const struct ggml_hash_set * hash_set, const struct ggml_tensor * key) {
size_t h = ggml_hash(key) % hash_set->size;
// linear probing
size_t i = h;
while (ggml_bitset_get(hash_set->used, i) && hash_set->keys[i] != key) {
i = (i + 1) % hash_set->size;
if (i == h) {
// visited all hash table entries -> not found
return GGML_HASHSET_FULL;
}
}
return i;
} | O0 | c | ggml_hash_find(ggml_hash_set const*, ggml_tensor const*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x63e60
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq (%rcx)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x63e80
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x62f9d
jmp 0x62fb7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x62fc0
jmp 0x62feb
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq (%rcx)
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x62fe9
movq $-0x1, -0x8(%rbp)
jmp 0x62ff3
jmp 0x62f7e
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| _ZL14ggml_hash_findPK13ggml_hash_setPK11ggml_tensor:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_18]
call _ZL9ggml_hashPK11ggml_tensor; ggml_hash(ggml_tensor const*)
mov rcx, [rbp+var_10]
xor edx, edx
div qword ptr [rcx]
mov [rbp+var_20], rdx
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
loc_62F7E:
mov rax, [rbp+var_10]
mov rdi, [rax+8]; unsigned int *
mov rsi, [rbp+var_28]; unsigned __int64
call _ZL15ggml_bitset_getPKjm; ggml_bitset_get(uint const*,ulong)
mov cl, al
xor eax, eax
test cl, 1
mov [rbp+var_29], al
jnz short loc_62F9D
jmp short loc_62FB7
loc_62F9D:
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rcx, [rbp+var_28]
mov rax, [rax+rcx*8]
cmp rax, [rbp+var_18]
setnz al
mov [rbp+var_29], al
loc_62FB7:
mov al, [rbp+var_29]
test al, 1
jnz short loc_62FC0
jmp short loc_62FEB
loc_62FC0:
mov rax, [rbp+var_28]
add rax, 1
mov rcx, [rbp+var_10]
xor edx, edx
div qword ptr [rcx]
mov [rbp+var_28], rdx
mov rax, [rbp+var_28]
cmp rax, [rbp+var_20]
jnz short loc_62FE9
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_62FF3
loc_62FE9:
jmp short loc_62F7E
loc_62FEB:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_62FF3:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long ggml_hash_find(long long a1, long long a2)
{
bool v3; // [rsp+7h] [rbp-29h]
unsigned long long v4; // [rsp+8h] [rbp-28h]
unsigned long long v5; // [rsp+10h] [rbp-20h]
v5 = (unsigned long long)ggml_hash(a2) % *(_QWORD *)a1;
v4 = v5;
while ( 1 )
{
v3 = 0;
if ( (ggml_bitset_get(*(const unsigned int **)(a1 + 8), v4) & 1) != 0 )
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 16) + 8 * v4) != a2;
if ( !v3 )
break;
v4 = (v4 + 1) % *(_QWORD *)a1;
if ( v4 == v5 )
return -1LL;
}
return v4;
}
| ggml_hash_find:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00163e60
MOV RCX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV qword ptr [RCX]
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
LAB_00162f7e:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00163e80
MOV CL,AL
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RBP + -0x29],AL
JNZ 0x00162f9d
JMP 0x00162fb7
LAB_00162f9d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + RCX*0x8]
CMP RAX,qword ptr [RBP + -0x18]
SETNZ AL
MOV byte ptr [RBP + -0x29],AL
LAB_00162fb7:
MOV AL,byte ptr [RBP + -0x29]
TEST AL,0x1
JNZ 0x00162fc0
JMP 0x00162feb
LAB_00162fc0:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV RCX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV qword ptr [RCX]
MOV qword ptr [RBP + -0x28],RDX
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00162fe9
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x00162ff3
LAB_00162fe9:
JMP 0x00162f7e
LAB_00162feb:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_00162ff3:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
/* ggml_hash_find(ggml_hash_set const*, ggml_tensor const*) */
ulong ggml_hash_find(ggml_hash_set *param_1,ggml_tensor *param_2)
{
ulong uVar1;
uint uVar2;
ulong uVar3;
bool bVar4;
ulong local_30;
uVar3 = ggml_hash(param_2);
uVar1 = *(ulong *)param_1;
local_30 = uVar3 % uVar1;
while( true ) {
uVar2 = ggml_bitset_get(*(uint **)(param_1 + 8),local_30);
bVar4 = false;
if ((uVar2 & 1) != 0) {
bVar4 = *(ggml_tensor **)(*(long *)(param_1 + 0x10) + local_30 * 8) != param_2;
}
if (!bVar4) break;
local_30 = (local_30 + 1) % *(ulong *)param_1;
if (local_30 == uVar3 % uVar1) {
return 0xffffffffffffffff;
}
}
return local_30;
}
| |
50,663 | ggml_hash_find(ggml_hash_set const*, ggml_tensor const*) | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-impl.h | static size_t ggml_hash_find(const struct ggml_hash_set * hash_set, const struct ggml_tensor * key) {
size_t h = ggml_hash(key) % hash_set->size;
// linear probing
size_t i = h;
while (ggml_bitset_get(hash_set->used, i) && hash_set->keys[i] != key) {
i = (i + 1) % hash_set->size;
if (i == h) {
// visited all hash table entries -> not found
return GGML_HASHSET_FULL;
}
}
return i;
} | O1 | c | ggml_hash_find(ggml_hash_set const*, ggml_tensor const*):
movq %rsi, %rax
shrq $0x4, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %r8
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movq %rax, %r9
shrq $0x5, %r9
movl (%r8,%r9,4), %r9d
btl %eax, %r9d
jae 0x233ea
movq 0x10(%rdi), %r9
cmpq %rsi, (%r9,%rax,8)
je 0x233ea
incq %rax
cmpq %rcx, %rax
movl $0x0, %r9d
cmoveq %r9, %rax
cmpq %rdx, %rax
jne 0x233b3
movq $-0x1, %rax
retq
| ggml_hash_find:
mov rax, rsi
shr rax, 4
mov rcx, [rdi]
mov r8, [rdi+8]
xor edx, edx
div rcx
mov rax, rdx
loc_233B3:
mov r9, rax
shr r9, 5
mov r9d, [r8+r9*4]
bt r9d, eax
jnb short locret_233EA
mov r9, [rdi+10h]
cmp [r9+rax*8], rsi
jz short locret_233EA
inc rax
cmp rax, rcx
mov r9d, 0
cmovz rax, r9
cmp rax, rdx
jnz short loc_233B3
mov rax, 0FFFFFFFFFFFFFFFFh
locret_233EA:
retn
| unsigned long long ggml_hash_find(_QWORD *a1, unsigned long long a2)
{
unsigned long long result; // rax
int v3; // r9d
result = (a2 >> 4) % *a1;
while ( 1 )
{
v3 = *(_DWORD *)(a1[1] + 4 * (result >> 5));
if ( !_bittest(&v3, result) || *(_QWORD *)(a1[2] + 8 * result) == a2 )
break;
if ( ++result == *a1 )
result = 0LL;
if ( result == (a2 >> 4) % *a1 )
return -1LL;
}
return result;
}
| ggml_hash_find:
MOV RAX,RSI
SHR RAX,0x4
MOV RCX,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x8]
XOR EDX,EDX
DIV RCX
MOV RAX,RDX
LAB_001233b3:
MOV R9,RAX
SHR R9,0x5
MOV R9D,dword ptr [R8 + R9*0x4]
BT R9D,EAX
JNC 0x001233ea
MOV R9,qword ptr [RDI + 0x10]
CMP qword ptr [R9 + RAX*0x8],RSI
JZ 0x001233ea
INC RAX
CMP RAX,RCX
MOV R9D,0x0
CMOVZ RAX,R9
CMP RAX,RDX
JNZ 0x001233b3
MOV RAX,-0x1
LAB_001233ea:
RET
|
ulong ggml_hash_find(ulong *param_1,ulong param_2)
{
ulong uVar1;
ulong uVar2;
uVar2 = (param_2 >> 4) % *param_1;
uVar1 = uVar2;
while( true ) {
if ((*(uint *)(param_1[1] + (uVar1 >> 5) * 4) >> ((uint)uVar1 & 0x1f) & 1) == 0) {
return uVar1;
}
if (*(ulong *)(param_1[2] + uVar1 * 8) == param_2) break;
uVar1 = uVar1 + 1;
if (uVar1 == *param_1) {
uVar1 = 0;
}
if (uVar1 == uVar2) {
return 0xffffffffffffffff;
}
}
return uVar1;
}
| |
50,664 | ggml_hash_find(ggml_hash_set const*, ggml_tensor const*) | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-impl.h | static size_t ggml_hash_find(const struct ggml_hash_set * hash_set, const struct ggml_tensor * key) {
size_t h = ggml_hash(key) % hash_set->size;
// linear probing
size_t i = h;
while (ggml_bitset_get(hash_set->used, i) && hash_set->keys[i] != key) {
i = (i + 1) % hash_set->size;
if (i == h) {
// visited all hash table entries -> not found
return GGML_HASHSET_FULL;
}
}
return i;
} | O2 | c | ggml_hash_find(ggml_hash_set const*, ggml_tensor const*):
movq %rsi, %rax
shrq $0x4, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %r8
xorl %edx, %edx
divq %rcx
pushq $-0x1
popq %r9
movq %rdx, %rax
movq %rax, %r10
shrq $0x5, %r10
movl (%r8,%r10,4), %r10d
btl %eax, %r10d
jae 0x27ef7
movq 0x10(%rdi), %r10
cmpq %rsi, (%r10,%rax,8)
je 0x27ef7
incq %rax
cmpq %rcx, %rax
movl $0x0, %r10d
cmoveq %r10, %rax
cmpq %rdx, %rax
jne 0x27ec4
movq %r9, %rax
retq
| ggml_hash_find:
mov rax, rsi
shr rax, 4
mov rcx, [rdi]
mov r8, [rdi+8]
xor edx, edx
div rcx
push 0FFFFFFFFFFFFFFFFh
pop r9
mov rax, rdx
loc_27EC4:
mov r10, rax
shr r10, 5
mov r10d, [r8+r10*4]
bt r10d, eax
jnb short locret_27EF7
mov r10, [rdi+10h]
cmp [r10+rax*8], rsi
jz short locret_27EF7
inc rax
cmp rax, rcx
mov r10d, 0
cmovz rax, r10
cmp rax, rdx
jnz short loc_27EC4
mov rax, r9
locret_27EF7:
retn
| unsigned long long ggml_hash_find(_QWORD *a1, unsigned long long a2)
{
unsigned long long result; // rax
int v3; // r10d
result = (a2 >> 4) % *a1;
while ( 1 )
{
v3 = *(_DWORD *)(a1[1] + 4 * (result >> 5));
if ( !_bittest(&v3, result) || *(_QWORD *)(a1[2] + 8 * result) == a2 )
break;
if ( ++result == *a1 )
result = 0LL;
if ( result == (a2 >> 4) % *a1 )
return -1LL;
}
return result;
}
| ggml_hash_find:
MOV RAX,RSI
SHR RAX,0x4
MOV RCX,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x8]
XOR EDX,EDX
DIV RCX
PUSH -0x1
POP R9
MOV RAX,RDX
LAB_00127ec4:
MOV R10,RAX
SHR R10,0x5
MOV R10D,dword ptr [R8 + R10*0x4]
BT R10D,EAX
JNC 0x00127ef7
MOV R10,qword ptr [RDI + 0x10]
CMP qword ptr [R10 + RAX*0x8],RSI
JZ 0x00127ef7
INC RAX
CMP RAX,RCX
MOV R10D,0x0
CMOVZ RAX,R10
CMP RAX,RDX
JNZ 0x00127ec4
MOV RAX,R9
LAB_00127ef7:
RET
|
ulong ggml_hash_find(ulong *param_1,ulong param_2)
{
ulong uVar1;
ulong uVar2;
uVar2 = (param_2 >> 4) % *param_1;
uVar1 = uVar2;
while( true ) {
if ((*(uint *)(param_1[1] + (uVar1 >> 5) * 4) >> ((uint)uVar1 & 0x1f) & 1) == 0) {
return uVar1;
}
if (*(ulong *)(param_1[2] + uVar1 * 8) == param_2) break;
uVar1 = uVar1 + 1;
if (uVar1 == *param_1) {
uVar1 = 0;
}
if (uVar1 == uVar2) {
return 0xffffffffffffffff;
}
}
return uVar1;
}
| |
50,665 | ggml_hash_find(ggml_hash_set const*, ggml_tensor const*) | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-impl.h | static size_t ggml_hash_find(const struct ggml_hash_set * hash_set, const struct ggml_tensor * key) {
size_t h = ggml_hash(key) % hash_set->size;
// linear probing
size_t i = h;
while (ggml_bitset_get(hash_set->used, i) && hash_set->keys[i] != key) {
i = (i + 1) % hash_set->size;
if (i == h) {
// visited all hash table entries -> not found
return GGML_HASHSET_FULL;
}
}
return i;
} | O3 | c | ggml_hash_find(ggml_hash_set const*, ggml_tensor const*):
movq %rsi, %rax
shrq $0x4, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %r8
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movq %rax, %r9
shrq $0x5, %r9
movl (%r8,%r9,4), %r9d
btl %eax, %r9d
jae 0x22101
movq 0x10(%rdi), %r9
cmpq %rsi, (%r9,%rax,8)
je 0x22101
incq %rax
cmpq %rcx, %rax
movl $0x0, %r9d
cmoveq %r9, %rax
cmpq %rdx, %rax
jne 0x220ca
movq $-0x1, %rax
retq
| ggml_hash_find:
mov rax, rsi
shr rax, 4
mov rcx, [rdi]
mov r8, [rdi+8]
xor edx, edx
div rcx
mov rax, rdx
loc_220CA:
mov r9, rax
shr r9, 5
mov r9d, [r8+r9*4]
bt r9d, eax
jnb short locret_22101
mov r9, [rdi+10h]
cmp [r9+rax*8], rsi
jz short locret_22101
inc rax
cmp rax, rcx
mov r9d, 0
cmovz rax, r9
cmp rax, rdx
jnz short loc_220CA
mov rax, 0FFFFFFFFFFFFFFFFh
locret_22101:
retn
| unsigned long long ggml_hash_find(_QWORD *a1, unsigned long long a2)
{
unsigned long long result; // rax
int v3; // r9d
result = (a2 >> 4) % *a1;
while ( 1 )
{
v3 = *(_DWORD *)(a1[1] + 4 * (result >> 5));
if ( !_bittest(&v3, result) || *(_QWORD *)(a1[2] + 8 * result) == a2 )
break;
if ( ++result == *a1 )
result = 0LL;
if ( result == (a2 >> 4) % *a1 )
return -1LL;
}
return result;
}
| ggml_hash_find:
MOV RAX,RSI
SHR RAX,0x4
MOV RCX,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x8]
XOR EDX,EDX
DIV RCX
MOV RAX,RDX
LAB_001220ca:
MOV R9,RAX
SHR R9,0x5
MOV R9D,dword ptr [R8 + R9*0x4]
BT R9D,EAX
JNC 0x00122101
MOV R9,qword ptr [RDI + 0x10]
CMP qword ptr [R9 + RAX*0x8],RSI
JZ 0x00122101
INC RAX
CMP RAX,RCX
MOV R9D,0x0
CMOVZ RAX,R9
CMP RAX,RDX
JNZ 0x001220ca
MOV RAX,-0x1
LAB_00122101:
RET
|
ulong ggml_hash_find(ulong *param_1,ulong param_2)
{
ulong uVar1;
ulong uVar2;
uVar2 = (param_2 >> 4) % *param_1;
uVar1 = uVar2;
while( true ) {
if ((*(uint *)(param_1[1] + (uVar1 >> 5) * 4) >> ((uint)uVar1 & 0x1f) & 1) == 0) {
return uVar1;
}
if (*(ulong *)(param_1[2] + uVar1 * 8) == param_2) break;
uVar1 = uVar1 + 1;
if (uVar1 == *param_1) {
uVar1 = 0;
}
if (uVar1 == uVar2) {
return 0xffffffffffffffff;
}
}
return uVar1;
}
| |
50,666 | psi_mutex_trylock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD int psi_mutex_trylock(mysql_mutex_t *that,
const char *file, uint line)
{
PSI_mutex_locker_state state;
PSI_mutex_locker *locker= PSI_MUTEX_CALL(start_mutex_wait)
(&state, that->m_psi, PSI_MUTEX_TRYLOCK, file, line);
# ifdef SAFE_MUTEX
int result= safe_mutex_lock(&that->m_mutex, TRUE, file, line);
# else
int result= pthread_mutex_trylock(&that->m_mutex);
# endif
if (locker)
PSI_MUTEX_CALL(end_mutex_wait)(locker, result);
return result;
} | O3 | c | psi_mutex_trylock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %r14
leaq 0x357424(%rip), %r15 # 0x386010
movq (%r15), %rax
movq 0x40(%rdi), %rsi
leaq -0x48(%rbp), %rdi
pushq $0x1
popq %rdx
callq *0x190(%rax)
movq %rax, %rbx
movq %r14, %rdi
callq 0x293c0
movl %eax, %r14d
testq %rbx, %rbx
je 0x2ec22
movq (%r15), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x198(%rax)
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| psi_mutex_trylock:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 38h
mov r8d, edx
mov rcx, rsi
mov r14, rdi
lea r15, PSI_server
mov rax, [r15]
mov rsi, [rdi+40h]
lea rdi, [rbp+var_48]
push 1
pop rdx
call qword ptr [rax+190h]
mov rbx, rax
mov rdi, r14
call _pthread_mutex_trylock
mov r14d, eax
test rbx, rbx
jz short loc_2EC22
mov rax, [r15]
mov rdi, rbx
mov esi, r14d
call qword ptr [rax+198h]
loc_2EC22:
mov eax, r14d
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long psi_mutex_trylock(long long a1, long long a2, unsigned int a3)
{
long long v3; // rbx
unsigned int v4; // r14d
_BYTE v6[72]; // [rsp+8h] [rbp-48h] BYREF
v3 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server[50])(
v6,
*(_QWORD *)(a1 + 64),
1LL,
a2,
a3);
v4 = pthread_mutex_trylock(a1);
if ( v3 )
((void ( *)(long long, _QWORD))PSI_server[51])(v3, v4);
return v4;
}
| psi_mutex_trylock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R8D,EDX
MOV RCX,RSI
MOV R14,RDI
LEA R15,[0x486010]
MOV RAX,qword ptr [R15]
MOV RSI,qword ptr [RDI + 0x40]
LEA RDI,[RBP + -0x48]
PUSH 0x1
POP RDX
CALL qword ptr [RAX + 0x190]
MOV RBX,RAX
MOV RDI,R14
CALL 0x001293c0
MOV R14D,EAX
TEST RBX,RBX
JZ 0x0012ec22
MOV RAX,qword ptr [R15]
MOV RDI,RBX
MOV ESI,R14D
CALL qword ptr [RAX + 0x198]
LAB_0012ec22:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
int psi_mutex_trylock(pthread_mutex_t *param_1,int8 param_2,int4 param_3)
{
int iVar1;
long lVar2;
int1 local_50 [48];
lVar2 = (**(code **)(PSI_server + 400))
(local_50,*(int8 *)((long)param_1 + 0x40),1,param_2,param_3);
iVar1 = pthread_mutex_trylock(param_1);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x198))(lVar2,iVar1);
}
return iVar1;
}
| |
50,667 | quantize_row_q6_K_ref | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void quantize_row_q6_K_ref(const float * restrict x, block_q6_K * restrict y, int64_t k) {
assert(k % QK_K == 0);
const int64_t nb = k / QK_K;
int8_t L[QK_K];
float scales[QK_K/16];
for (int i = 0; i < nb; i++) {
float max_scale = 0;
float max_abs_scale = 0;
for (int ib = 0; ib < QK_K/16; ++ib) {
const float scale = make_qx_quants(16, 32, x + 16*ib, L + 16*ib, 1, NULL);
scales[ib] = scale;
const float abs_scale = fabsf(scale);
if (abs_scale > max_abs_scale) {
max_abs_scale = abs_scale;
max_scale = scale;
}
}
if (max_abs_scale < GROUP_MAX_EPS) {
memset(&y[i], 0, sizeof(block_q6_K));
y[i].d = GGML_FP32_TO_FP16(0.f);
x += QK_K;
continue;
}
float iscale = -128.f/max_scale;
y[i].d = GGML_FP32_TO_FP16(1/iscale);
for (int ib = 0; ib < QK_K/16; ++ib) {
y[i].scales[ib] = MIN(127, nearest_int(iscale*scales[ib]));
}
for (int j = 0; j < QK_K/16; ++j) {
float d = GGML_FP16_TO_FP32(y[i].d) * y[i].scales[j];
if (!d) {
continue;
}
for (int ii = 0; ii < 16; ++ii) {
int l = nearest_int(x[16*j + ii]/d);
l = MAX(-32, MIN(31, l));
L[16*j + ii] = l + 32;
}
}
uint8_t * restrict ql = y[i].ql;
uint8_t * restrict qh = y[i].qh;
for (int j = 0; j < QK_K; j += 128) {
for (int l = 0; l < 32; ++l) {
const uint8_t q1 = L[j + l + 0] & 0xF;
const uint8_t q2 = L[j + l + 32] & 0xF;
const uint8_t q3 = L[j + l + 64] & 0xF;
const uint8_t q4 = L[j + l + 96] & 0xF;
ql[l+ 0] = q1 | (q3 << 4);
ql[l+32] = q2 | (q4 << 4);
qh[l] = (L[j + l] >> 4) | ((L[j + l + 32] >> 4) << 2) | ((L[j + l + 64] >> 4) << 4) | ((L[j + l + 96] >> 4) << 6);
}
ql += 64;
qh += 32;
}
x += QK_K;
}
} | O1 | c | quantize_row_q6_K_ref:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, 0x8(%rsp)
testb %dl, %dl
jne 0x32391
sarq $0x8, %rdx
testq %rdx, %rdx
jle 0x32360
movq %rdi, %r12
movq 0x8(%rsp), %rax
leaq 0xc0(%rax), %rbp
xorl %ebx, %ebx
movl $0x80, %r14d
movq %rdx, 0x18(%rsp)
movq %r12, 0x10(%rsp)
leaq 0x80(%rsp), %r13
xorl %r15d, %r15d
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movaps %xmm0, 0x20(%rsp)
movaps %xmm1, 0x30(%rsp)
movl $0x10, %edi
movl $0x20, %esi
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0x323b0
movaps 0x19f8f(%rip), %xmm4 # 0x4c020
movss %xmm0, 0x40(%rsp,%r15,4)
movaps %xmm0, %xmm2
andps %xmm4, %xmm2
movaps %xmm2, %xmm1
movaps 0x30(%rsp), %xmm3
maxss %xmm3, %xmm1
cmpltss %xmm2, %xmm3
movaps %xmm3, %xmm2
andps %xmm3, %xmm0
andnps 0x20(%rsp), %xmm2
orps %xmm0, %xmm2
incq %r15
addq $0x10, %r13
addq $0x40, %r12
movaps %xmm2, %xmm0
cmpq $0x10, %r15
jne 0x32068
movss 0x1ecff(%rip), %xmm0 # 0x50dd8
ucomiss %xmm1, %xmm0
jbe 0x320fb
imulq $0xd2, %rbx, %rdi
addq 0x8(%rsp), %rdi
movl $0xd2, %edx
xorl %esi, %esi
callq 0x178f0
jmp 0x3233c
movss 0x1eced(%rip), %xmm0 # 0x50df0
divss %xmm2, %xmm0
movss 0x19f49(%rip), %xmm1 # 0x4c058
divss %xmm0, %xmm1
movd %xmm1, %eax
andps %xmm4, %xmm1
mulss 0x19f26(%rip), %xmm1 # 0x4c048
mulss 0x19f22(%rip), %xmm1 # 0x4c04c
leal (%rax,%rax), %ecx
movl %eax, %edx
andl $0x7f800000, %edx # imm = 0x7F800000
addl $0x7800000, %edx # imm = 0x7800000
cmpl $0x71000000, %ecx # imm = 0x71000000
movl $0x40000000, %esi # imm = 0x40000000
cmovbl %esi, %edx
movd %edx, %xmm2
addss %xmm1, %xmm2
movd %xmm2, %edx
movl %edx, %esi
shrl $0xd, %esi
andl $0x7c00, %esi # imm = 0x7C00
andl $0xfff, %edx # imm = 0xFFF
addl %esi, %edx
shrl $0x10, %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0xff000001, %ecx # imm = 0xFF000001
movl $0x7e00, %ecx # imm = 0x7E00
cmovael %ecx, %edx
orl %eax, %edx
imulq $0xd2, %rbx, %rcx
movq 0x8(%rsp), %rsi
leaq (%rsi,%rcx), %rax
movw %dx, 0xd0(%rsi,%rcx)
xorl %ecx, %ecx
movq 0x10(%rsp), %r8
movss 0x1ec21(%rip), %xmm5 # 0x50dc8
movss 0x1ec1d(%rip), %xmm6 # 0x50dcc
xorps %xmm7, %xmm7
movss 0x40(%rsp,%rcx,4), %xmm1
mulss %xmm0, %xmm1
movaps %xmm1, %xmm2
andps %xmm4, %xmm2
ucomiss %xmm2, %xmm5
jb 0x32372
addss %xmm6, %xmm1
movd %xmm1, %edx
movl %edx, %edi
andl $0x7fff80, %edi # imm = 0x7FFF80
movl $0x7f, %esi
cmpl $0x400080, %edi # imm = 0x400080
jae 0x321ea
movl %edx, %esi
movb %sil, (%rbp,%rcx)
incq %rcx
cmpq $0x10, %rcx
jne 0x321b2
movzwl 0xd0(%rax), %ecx
movq 0x3bda2(%rip), %rdx # 0x6dfa8
movss (%rdx,%rcx,4), %xmm0
movq %r8, %rcx
leaq 0x80(%rsp), %rdx
xorl %esi, %esi
movsbl 0xc0(%rax,%rsi), %edi
xorps %xmm1, %xmm1
cvtsi2ss %edi, %xmm1
mulss %xmm0, %xmm1
ucomiss %xmm7, %xmm1
jne 0x32232
jnp 0x3228d
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm2
divss %xmm1, %xmm2
movaps %xmm2, %xmm3
andps %xmm4, %xmm3
ucomiss %xmm3, %xmm5
jb 0x32372
addss %xmm6, %xmm2
movd %xmm2, %r8d
andl $0x7fffff, %r8d # imm = 0x7FFFFF
movl $0x40001f, %r9d # imm = 0x40001F
cmpl %r9d, %r8d
jl 0x3226d
movl $0x40001f, %r8d # imm = 0x40001F
cmpl $0x3fffe1, %r8d # imm = 0x3FFFE1
jge 0x3227c
movl $0x3fffe0, %r8d # imm = 0x3FFFE0
addb $0x20, %r8b
movb %r8b, (%rdx,%rdi)
incq %rdi
cmpq $0x10, %rdi
jne 0x32234
incq %rsi
addq $0x10, %rdx
addq $0x40, %rcx
cmpq $0x10, %rsi
jne 0x32218
leaq 0x80(%rax), %rcx
leaq 0xe0(%rsp), %rdx
xorl %esi, %esi
xorl %edi, %edi
movb -0x60(%rdx,%rdi), %r8b
movb -0x40(%rdx,%rdi), %r9b
movl %r8d, %r10d
andb $0xf, %r10b
movl %r9d, %r11d
andb $0xf, %r11b
movb -0x20(%rdx,%rdi), %r15b
movb (%rdx,%rdi), %r12b
movl %r15d, %r13d
shlb $0x4, %r13b
orb %r10b, %r13b
movb %r13b, (%rax,%rdi)
movl %r12d, %r10d
shlb $0x4, %r10b
orb %r11b, %r10b
movb %r10b, 0x20(%rax,%rdi)
sarb $0x4, %r8b
sarb $0x2, %r9b
andb $-0x4, %r9b
andb $-0x10, %r15b
orb %r8b, %r15b
orb %r9b, %r15b
shlb $0x2, %r12b
andb $-0x40, %r12b
orb %r15b, %r12b
movb %r12b, (%rcx,%rdi)
incq %rdi
cmpq $0x20, %rdi
jne 0x322b5
addq $0x40, %rax
addq $0x20, %rcx
leaq (%rsi,%r14), %rdi
addq %r14, %rdx
testq %rsi, %rsi
movq %rdi, %rsi
je 0x322b3
movq 0x10(%rsp), %r12
addq $0x400, %r12 # imm = 0x400
incq %rbx
addq $0xd2, %rbp
movq 0x18(%rsp), %rdx
cmpq %rdx, %rbx
jne 0x32052
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a376(%rip), %rdi # 0x5c6ef
leaq 0x29484(%rip), %rsi # 0x5b804
leaq 0x2a381(%rip), %rcx # 0x5c708
movl $0x175, %edx # imm = 0x175
callq 0x17b00
leaq 0x29854(%rip), %rdi # 0x5bbec
leaq 0x29465(%rip), %rsi # 0x5b804
leaq 0x29ad4(%rip), %rcx # 0x5be7a
movl $0x655, %edx # imm = 0x655
callq 0x17b00
| quantize_row_q6_K_ref:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 188h
mov [rsp+1B8h+var_1B0], rsi
test dl, dl
jnz loc_32391
sar rdx, 8
test rdx, rdx
jle loc_32360
mov r12, rdi
mov rax, [rsp+1B8h+var_1B0]
lea rbp, [rax+0C0h]
xor ebx, ebx
mov r14d, 80h
mov [rsp+1B8h+var_1A0], rdx
loc_32052:
mov [rsp+1B8h+var_1A8], r12
lea r13, [rsp+1B8h+var_138]
xor r15d, r15d
xorps xmm0, xmm0
xorps xmm1, xmm1
loc_32068:
movaps [rsp+1B8h+var_198], xmm0
movaps [rsp+1B8h+var_188], xmm1
mov edi, 10h
mov esi, 20h ; ' '
mov rdx, r12
mov rcx, r13
xor r8d, r8d
call make_qx_quants
movaps xmm4, cs:xmmword_4C020
movss [rsp+r15*4+1B8h+var_178], xmm0
movaps xmm2, xmm0
andps xmm2, xmm4
movaps xmm1, xmm2
movaps xmm3, [rsp+1B8h+var_188]
maxss xmm1, xmm3
cmpltss xmm3, xmm2
movaps xmm2, xmm3
andps xmm0, xmm3
andnps xmm2, [rsp+1B8h+var_198]
orps xmm2, xmm0
inc r15
add r13, 10h
add r12, 40h ; '@'
movaps xmm0, xmm2
cmp r15, 10h
jnz short loc_32068
movss xmm0, cs:dword_50DD8
ucomiss xmm0, xmm1
jbe short loc_320FB
imul rdi, rbx, 0D2h
add rdi, [rsp+1B8h+var_1B0]
mov edx, 0D2h
xor esi, esi
call _memset
jmp loc_3233C
loc_320FB:
movss xmm0, cs:dword_50DF0
divss xmm0, xmm2
movss xmm1, cs:dword_4C058
divss xmm1, xmm0
movd eax, xmm1
andps xmm1, xmm4
mulss xmm1, cs:dword_4C048
mulss xmm1, cs:dword_4C04C
lea ecx, [rax+rax]
mov edx, eax
and edx, 7F800000h
add edx, 7800000h
cmp ecx, 71000000h
mov esi, 40000000h
cmovb edx, esi
movd xmm2, edx
addss xmm2, xmm1
movd edx, xmm2
mov esi, edx
shr esi, 0Dh
and esi, 7C00h
and edx, 0FFFh
add edx, esi
shr eax, 10h
and eax, 8000h
cmp ecx, 0FF000001h
mov ecx, 7E00h
cmovnb edx, ecx
or edx, eax
imul rcx, rbx, 0D2h
mov rsi, [rsp+1B8h+var_1B0]
lea rax, [rsi+rcx]
mov [rsi+rcx+0D0h], dx
xor ecx, ecx
mov r8, [rsp+1B8h+var_1A8]
movss xmm5, cs:dword_50DC8
movss xmm6, cs:dword_50DCC
xorps xmm7, xmm7
loc_321B2:
movss xmm1, [rsp+rcx*4+1B8h+var_178]
mulss xmm1, xmm0
movaps xmm2, xmm1
andps xmm2, xmm4
ucomiss xmm5, xmm2
jb loc_32372
addss xmm1, xmm6
movd edx, xmm1
mov edi, edx
and edi, 7FFF80h
mov esi, 7Fh
cmp edi, 400080h
jnb short loc_321EA
mov esi, edx
loc_321EA:
mov [rbp+rcx+0], sil
inc rcx
cmp rcx, 10h
jnz short loc_321B2
movzx ecx, word ptr [rax+0D0h]
mov rdx, cs:ggml_table_f32_f16_ptr
movss xmm0, dword ptr [rdx+rcx*4]
mov rcx, r8
lea rdx, [rsp+1B8h+var_138]
xor esi, esi
loc_32218:
movsx edi, byte ptr [rax+rsi+0C0h]
xorps xmm1, xmm1
cvtsi2ss xmm1, edi
mulss xmm1, xmm0
ucomiss xmm1, xmm7
jnz short loc_32232
jnp short loc_3228D
loc_32232:
xor edi, edi
loc_32234:
movss xmm2, dword ptr [rcx+rdi*4]
divss xmm2, xmm1
movaps xmm3, xmm2
andps xmm3, xmm4
ucomiss xmm5, xmm3
jb loc_32372
addss xmm2, xmm6
movd r8d, xmm2
and r8d, 7FFFFFh
mov r9d, 40001Fh
cmp r8d, r9d
jl short loc_3226D
mov r8d, 40001Fh
loc_3226D:
cmp r8d, 3FFFE1h
jge short loc_3227C
mov r8d, 3FFFE0h
loc_3227C:
add r8b, 20h ; ' '
mov [rdx+rdi], r8b
inc rdi
cmp rdi, 10h
jnz short loc_32234
loc_3228D:
inc rsi
add rdx, 10h
add rcx, 40h ; '@'
cmp rsi, 10h
jnz loc_32218
lea rcx, [rax+80h]
lea rdx, [rsp+1B8h+var_D8]
xor esi, esi
loc_322B3:
xor edi, edi
loc_322B5:
mov r8b, [rdx+rdi-60h]
mov r9b, [rdx+rdi-40h]
mov r10d, r8d
and r10b, 0Fh
mov r11d, r9d
and r11b, 0Fh
mov r15b, [rdx+rdi-20h]
mov r12b, [rdx+rdi]
mov r13d, r15d
shl r13b, 4
or r13b, r10b
mov [rax+rdi], r13b
mov r10d, r12d
shl r10b, 4
or r10b, r11b
mov [rax+rdi+20h], r10b
sar r8b, 4
sar r9b, 2
and r9b, 0FCh
and r15b, 0F0h
or r15b, r8b
or r15b, r9b
shl r12b, 2
and r12b, 0C0h
or r12b, r15b
mov [rcx+rdi], r12b
inc rdi
cmp rdi, 20h ; ' '
jnz short loc_322B5
add rax, 40h ; '@'
add rcx, 20h ; ' '
lea rdi, [rsi+r14]
add rdx, r14
test rsi, rsi
mov rsi, rdi
jz loc_322B3
loc_3233C:
mov r12, [rsp+1B8h+var_1A8]
add r12, 400h
inc rbx
add rbp, 0D2h
mov rdx, [rsp+1B8h+var_1A0]
cmp rbx, rdx
jnz loc_32052
loc_32360:
add rsp, 188h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_32372:
lea rdi, aFabsfFval41943; "fabsf(fval) <= 4194303.f"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aIntNearestIntF; "int nearest_int(float)"
mov edx, 175h
call ___assert_fail
loc_32391:
lea rdi, aKQkK0; "k % QK_K == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidQuantizeRo_13; "void quantize_row_q6_K_ref(const float "...
mov edx, 655h
call ___assert_fail
| void quantize_row_q6_K_ref(long long a1, long long a2, long long a3)
{
long long v3; // rdx
long long v5; // rbp
long long v6; // rbx
_BYTE *v7; // r13
long long v8; // r15
__m128 v9; // xmm0
__m128 v10; // xmm1
__m128 v11; // xmm2
__m128 v12; // xmm3
__m128 v13; // xmm2
float v14; // xmm0_4
__m128i v15; // xmm1
unsigned int v16; // eax
float v17; // xmm1_4
unsigned int v18; // ecx
unsigned int v19; // edx
__m128i v20; // xmm2
unsigned int v21; // edx
int v22; // edx
int v23; // eax
__int16 v24; // dx
long long v25; // rax
long long v26; // rcx
long long v27; // r8
__m128i v28; // xmm1
int v29; // edx
char v30; // si
float v31; // xmm0_4
long long v32; // rcx
_BYTE *v33; // rdx
long long i; // rsi
float v35; // xmm1_4
long long v36; // rdi
__m128i v37; // xmm2
long long v38; // rcx
char *v39; // rdx
long long v40; // rsi
long long j; // rdi
char v42; // r8
char v43; // r9
char v44; // r15
char v45; // r12
bool v46; // zf
long long v48; // [rsp+10h] [rbp-1A8h]
long long v49; // [rsp+18h] [rbp-1A0h]
__m128 v50; // [rsp+20h] [rbp-198h]
__m128 v51; // [rsp+30h] [rbp-188h]
_DWORD v52[16]; // [rsp+40h] [rbp-178h]
_BYTE v53[96]; // [rsp+80h] [rbp-138h] BYREF
char v54; // [rsp+E0h] [rbp-D8h] BYREF
if ( (_BYTE)a3 )
__assert_fail(
"k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
1621LL,
"void quantize_row_q6_K_ref(const float *restrict, block_q6_K *restrict, int64_t)");
v3 = a3 >> 8;
if ( v3 <= 0 )
return;
v5 = a2 + 192;
v6 = 0LL;
v49 = v3;
do
{
v48 = a1;
v7 = v53;
v8 = 0LL;
v9 = 0LL;
v10 = 0LL;
do
{
v50 = v9;
v51 = v10;
v9.m128_f32[0] = make_qx_quants(16LL, 32LL, a1, v7, 0LL, v9.m128_f32[0], *(double *)v10.m128_u64);
v52[v8] = v9.m128_i32[0];
v11 = _mm_and_ps(v9, (__m128)xmmword_4C020);
v10 = v11;
v10.m128_f32[0] = fmaxf(v11.m128_f32[0], v51.m128_f32[0]);
v12 = _mm_cmplt_ss(v51, v11);
v13 = _mm_or_ps(_mm_andnot_ps(v12, v50), _mm_and_ps(v9, v12));
++v8;
v7 += 16;
a1 += 64LL;
v9 = v13;
}
while ( v8 != 16 );
if ( v10.m128_f32[0] < 1.0e-15 )
{
memset(a2 + 210 * v6, 0LL, 210LL);
goto LABEL_31;
}
v14 = -128.0 / v13.m128_f32[0];
v15 = (__m128i)0x3F800000u;
*(float *)v15.m128i_i32 = 1.0 / (float)(-128.0 / v13.m128_f32[0]);
v16 = _mm_cvtsi128_si32(v15);
v17 = (float)(fabs(*(float *)v15.m128i_i32) * 5.1922969e33) * 7.7037198e-34;
v18 = 2 * v16;
v19 = (v16 & 0x7F800000) + 125829120;
if ( 2 * v16 < 0x71000000 )
v19 = 0x40000000;
v20 = _mm_cvtsi32_si128(v19);
*(float *)v20.m128i_i32 = *(float *)v20.m128i_i32 + v17;
v21 = _mm_cvtsi128_si32(v20);
v22 = ((v21 >> 13) & 0x7C00) + (v21 & 0xFFF);
v23 = HIWORD(v16) & 0x8000;
if ( v18 >= 0xFF000001 )
LOWORD(v22) = 32256;
v24 = v23 | v22;
v25 = a2 + 210 * v6;
*(_WORD *)(v25 + 208) = v24;
v26 = 0LL;
v27 = v48;
do
{
v28 = (__m128i)(unsigned int)v52[v26];
*(float *)v28.m128i_i32 = *(float *)v28.m128i_i32 * v14;
if ( fabs(*(float *)v28.m128i_i32) > 4194303.0 )
goto LABEL_33;
*(float *)v28.m128i_i32 = *(float *)v28.m128i_i32 + 12582912.0;
v29 = _mm_cvtsi128_si32(v28);
v30 = 127;
if ( (v29 & 0x7FFF80u) < 0x400080 )
v30 = v29;
*(_BYTE *)(v5 + v26++) = v30;
}
while ( v26 != 16 );
v31 = ggml_table_f32_f16[*(unsigned __int16 *)(v25 + 208)];
v32 = v48;
v33 = v53;
for ( i = 0LL; i != 16; ++i )
{
v35 = (float)*(char *)(v25 + i + 192) * v31;
if ( v35 != 0.0 )
{
v36 = 0LL;
while ( 1 )
{
v37 = (__m128i)*(unsigned int *)(v32 + 4 * v36);
*(float *)v37.m128i_i32 = *(float *)v37.m128i_i32 / v35;
if ( fabs(*(float *)v37.m128i_i32) > 4194303.0 )
break;
*(float *)v37.m128i_i32 = *(float *)v37.m128i_i32 + 12582912.0;
v27 = _mm_cvtsi128_si32(v37) & 0x7FFFFF;
if ( (int)v27 >= 4194335 )
v27 = 4194335LL;
if ( (int)v27 < 4194273 )
v27 = 4194272LL;
LOBYTE(v27) = v27 + 32;
v33[v36++] = v27;
if ( v36 == 16 )
goto LABEL_26;
}
LABEL_33:
__assert_fail(
"fabsf(fval) <= 4194303.f",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
373LL,
"int nearest_int(float)",
v27);
}
LABEL_26:
v33 += 16;
v32 += 64LL;
}
v38 = v25 + 128;
v39 = &v54;
v40 = 0LL;
do
{
for ( j = 0LL; j != 32; ++j )
{
v42 = v39[j - 96];
v43 = v39[j - 64];
v44 = v39[j - 32];
v45 = v39[j];
*(_BYTE *)(v25 + j) = v42 & 0xF | (16 * v44);
*(_BYTE *)(v25 + j + 32) = v43 & 0xF | (16 * v45);
*(_BYTE *)(v38 + j) = (v43 >> 2) & 0xFC | (v42 >> 4) | v44 & 0xF0 | (4 * v45) & 0xC0;
}
v25 += 64LL;
v38 += 32LL;
v39 += 128;
v46 = v40 == 0;
v40 += 128LL;
}
while ( v46 );
LABEL_31:
a1 = v48 + 1024;
++v6;
v5 += 210LL;
}
while ( v6 != v49 );
}
| quantize_row_q6_K_ref:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x188
MOV qword ptr [RSP + 0x8],RSI
TEST DL,DL
JNZ 0x00132391
SAR RDX,0x8
TEST RDX,RDX
JLE 0x00132360
MOV R12,RDI
MOV RAX,qword ptr [RSP + 0x8]
LEA RBP,[RAX + 0xc0]
XOR EBX,EBX
MOV R14D,0x80
MOV qword ptr [RSP + 0x18],RDX
LAB_00132052:
MOV qword ptr [RSP + 0x10],R12
LEA R13,[RSP + 0x80]
XOR R15D,R15D
XORPS XMM0,XMM0
XORPS XMM1,XMM1
LAB_00132068:
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM1
MOV EDI,0x10
MOV ESI,0x20
MOV RDX,R12
MOV RCX,R13
XOR R8D,R8D
CALL 0x001323b0
MOVAPS XMM4,xmmword ptr [0x0014c020]
MOVSS dword ptr [RSP + R15*0x4 + 0x40],XMM0
MOVAPS XMM2,XMM0
ANDPS XMM2,XMM4
MOVAPS XMM1,XMM2
MOVAPS XMM3,xmmword ptr [RSP + 0x30]
MAXSS XMM1,XMM3
CMPLTSS XMM3,XMM2
MOVAPS XMM2,XMM3
ANDPS XMM0,XMM3
ANDNPS XMM2,xmmword ptr [RSP + 0x20]
ORPS XMM2,XMM0
INC R15
ADD R13,0x10
ADD R12,0x40
MOVAPS XMM0,XMM2
CMP R15,0x10
JNZ 0x00132068
MOVSS XMM0,dword ptr [0x00150dd8]
UCOMISS XMM0,XMM1
JBE 0x001320fb
IMUL RDI,RBX,0xd2
ADD RDI,qword ptr [RSP + 0x8]
MOV EDX,0xd2
XOR ESI,ESI
CALL 0x001178f0
JMP 0x0013233c
LAB_001320fb:
MOVSS XMM0,dword ptr [0x00150df0]
DIVSS XMM0,XMM2
MOVSS XMM1,dword ptr [0x0014c058]
DIVSS XMM1,XMM0
MOVD EAX,XMM1
ANDPS XMM1,XMM4
MULSS XMM1,dword ptr [0x0014c048]
MULSS XMM1,dword ptr [0x0014c04c]
LEA ECX,[RAX + RAX*0x1]
MOV EDX,EAX
AND EDX,0x7f800000
ADD EDX,0x7800000
CMP ECX,0x71000000
MOV ESI,0x40000000
CMOVC EDX,ESI
MOVD XMM2,EDX
ADDSS XMM2,XMM1
MOVD EDX,XMM2
MOV ESI,EDX
SHR ESI,0xd
AND ESI,0x7c00
AND EDX,0xfff
ADD EDX,ESI
SHR EAX,0x10
AND EAX,0x8000
CMP ECX,0xff000001
MOV ECX,0x7e00
CMOVNC EDX,ECX
OR EDX,EAX
IMUL RCX,RBX,0xd2
MOV RSI,qword ptr [RSP + 0x8]
LEA RAX,[RSI + RCX*0x1]
MOV word ptr [RSI + RCX*0x1 + 0xd0],DX
XOR ECX,ECX
MOV R8,qword ptr [RSP + 0x10]
MOVSS XMM5,dword ptr [0x00150dc8]
MOVSS XMM6,dword ptr [0x00150dcc]
XORPS XMM7,XMM7
LAB_001321b2:
MOVSS XMM1,dword ptr [RSP + RCX*0x4 + 0x40]
MULSS XMM1,XMM0
MOVAPS XMM2,XMM1
ANDPS XMM2,XMM4
UCOMISS XMM5,XMM2
JC 0x00132372
ADDSS XMM1,XMM6
MOVD EDX,XMM1
MOV EDI,EDX
AND EDI,0x7fff80
MOV ESI,0x7f
CMP EDI,0x400080
JNC 0x001321ea
MOV ESI,EDX
LAB_001321ea:
MOV byte ptr [RBP + RCX*0x1],SIL
INC RCX
CMP RCX,0x10
JNZ 0x001321b2
MOVZX ECX,word ptr [RAX + 0xd0]
MOV RDX,qword ptr [0x0016dfa8]
MOVSS XMM0,dword ptr [RDX + RCX*0x4]
MOV RCX,R8
LEA RDX,[RSP + 0x80]
XOR ESI,ESI
LAB_00132218:
MOVSX EDI,byte ptr [RAX + RSI*0x1 + 0xc0]
XORPS XMM1,XMM1
CVTSI2SS XMM1,EDI
MULSS XMM1,XMM0
UCOMISS XMM1,XMM7
JNZ 0x00132232
JNP 0x0013228d
LAB_00132232:
XOR EDI,EDI
LAB_00132234:
MOVSS XMM2,dword ptr [RCX + RDI*0x4]
DIVSS XMM2,XMM1
MOVAPS XMM3,XMM2
ANDPS XMM3,XMM4
UCOMISS XMM5,XMM3
JC 0x00132372
ADDSS XMM2,XMM6
MOVD R8D,XMM2
AND R8D,0x7fffff
MOV R9D,0x40001f
CMP R8D,R9D
JL 0x0013226d
MOV R8D,0x40001f
LAB_0013226d:
CMP R8D,0x3fffe1
JGE 0x0013227c
MOV R8D,0x3fffe0
LAB_0013227c:
ADD R8B,0x20
MOV byte ptr [RDX + RDI*0x1],R8B
INC RDI
CMP RDI,0x10
JNZ 0x00132234
LAB_0013228d:
INC RSI
ADD RDX,0x10
ADD RCX,0x40
CMP RSI,0x10
JNZ 0x00132218
LEA RCX,[RAX + 0x80]
LEA RDX,[RSP + 0xe0]
XOR ESI,ESI
LAB_001322b3:
XOR EDI,EDI
LAB_001322b5:
MOV R8B,byte ptr [RDX + RDI*0x1 + -0x60]
MOV R9B,byte ptr [RDX + RDI*0x1 + -0x40]
MOV R10D,R8D
AND R10B,0xf
MOV R11D,R9D
AND R11B,0xf
MOV R15B,byte ptr [RDX + RDI*0x1 + -0x20]
MOV R12B,byte ptr [RDX + RDI*0x1]
MOV R13D,R15D
SHL R13B,0x4
OR R13B,R10B
MOV byte ptr [RAX + RDI*0x1],R13B
MOV R10D,R12D
SHL R10B,0x4
OR R10B,R11B
MOV byte ptr [RAX + RDI*0x1 + 0x20],R10B
SAR R8B,0x4
SAR R9B,0x2
AND R9B,0xfc
AND R15B,0xf0
OR R15B,R8B
OR R15B,R9B
SHL R12B,0x2
AND R12B,0xc0
OR R12B,R15B
MOV byte ptr [RCX + RDI*0x1],R12B
INC RDI
CMP RDI,0x20
JNZ 0x001322b5
ADD RAX,0x40
ADD RCX,0x20
LEA RDI,[RSI + R14*0x1]
ADD RDX,R14
TEST RSI,RSI
MOV RSI,RDI
JZ 0x001322b3
LAB_0013233c:
MOV R12,qword ptr [RSP + 0x10]
ADD R12,0x400
INC RBX
ADD RBP,0xd2
MOV RDX,qword ptr [RSP + 0x18]
CMP RBX,RDX
JNZ 0x00132052
LAB_00132360:
ADD RSP,0x188
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00132372:
LEA RDI,[0x15c6ef]
LEA RSI,[0x15b804]
LEA RCX,[0x15c708]
MOV EDX,0x175
CALL 0x00117b00
LAB_00132391:
LEA RDI,[0x15bbec]
LEA RSI,[0x15b804]
LEA RCX,[0x15be7a]
MOV EDX,0x655
CALL 0x00117b00
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void quantize_row_q6_K_ref(long param_1,long param_2,long param_3)
{
byte bVar1;
byte bVar2;
byte bVar3;
byte bVar4;
uint uVar5;
ushort uVar6;
float fVar7;
long lVar8;
long lVar9;
long lVar10;
long lVar11;
uint uVar12;
long lVar13;
int1 *puVar14;
long lVar15;
bool bVar16;
float fVar17;
float fVar18;
float fVar19;
float fVar20;
float afStack_178 [16];
int1 local_138 [96];
int1 local_d8 [168];
if ((char)param_3 != '\0') {
/* WARNING: Subroutine does not return */
__assert_fail("k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x655,
"void quantize_row_q6_K_ref(const float *restrict, block_q6_K *restrict, int64_t)"
);
}
if (0 < param_3 >> 8) {
lVar9 = param_2 + 0xc0;
lVar8 = 0;
do {
puVar14 = local_138;
lVar15 = 0;
fVar17 = 0.0;
lVar13 = param_1;
fVar7 = 0.0;
do {
fVar18 = (float)make_qx_quants(0x10,0x20,lVar13,puVar14,0);
uVar5 = _DAT_0014c020;
afStack_178[lVar15] = fVar18;
fVar20 = (float)((uint)fVar18 & _DAT_0014c020);
fVar19 = fVar20;
if (fVar20 <= fVar7) {
fVar19 = fVar7;
}
fVar17 = (float)(~-(uint)(fVar7 < fVar20) & (uint)fVar17 |
(uint)fVar18 & -(uint)(fVar7 < fVar20));
lVar15 = lVar15 + 1;
puVar14 = puVar14 + 0x10;
lVar13 = lVar13 + 0x40;
fVar7 = fVar19;
} while (lVar15 != 0x10);
if (DAT_00150dd8 <= fVar19) {
fVar17 = DAT_00150df0 / fVar17;
fVar19 = DAT_0014c058 / fVar17;
fVar7 = (float)(((uint)fVar19 & 0x7f800000) + 0x7800000);
if ((uint)((int)fVar19 * 2) < 0x71000000) {
fVar7 = 2.0;
}
fVar7 = fVar7 + (float)((uint)fVar19 & _DAT_0014c020) * DAT_0014c048 * DAT_0014c04c;
uVar6 = (SUB42(fVar7,0) & 0xfff) + ((ushort)((uint)fVar7 >> 0xd) & 0x7c00);
if (0xff000000 < (uint)((int)fVar19 * 2)) {
uVar6 = 0x7e00;
}
lVar13 = param_2 + lVar8 * 0xd2;
*(ushort *)(param_2 + 0xd0 + lVar8 * 0xd2) = uVar6 | (ushort)((uint)fVar19 >> 0x10) & 0x8000
;
fVar19 = DAT_00150dcc;
fVar7 = DAT_00150dc8;
lVar15 = 0;
do {
fVar18 = afStack_178[lVar15] * fVar17;
if (fVar7 < (float)((uint)fVar18 & uVar5)) {
LAB_00132372:
/* WARNING: Subroutine does not return */
__assert_fail("fabsf(fval) <= 4194303.f",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x175,"int nearest_int(float)");
}
fVar18 = fVar18 + fVar19;
fVar20 = 1.77965e-43;
if (((uint)fVar18 & 0x7fff80) < 0x400080) {
fVar20 = fVar18;
}
*(char *)(lVar9 + lVar15) = SUB41(fVar20,0);
lVar15 = lVar15 + 1;
} while (lVar15 != 0x10);
fVar17 = *(float *)(PTR_ggml_table_f32_f16_0016dfa8 + (ulong)*(ushort *)(lVar13 + 0xd0) * 4)
;
puVar14 = local_138;
lVar10 = 0;
lVar15 = param_1;
do {
fVar18 = (float)(int)*(char *)(lVar13 + 0xc0 + lVar10) * fVar17;
if ((fVar18 != 0.0) || (NAN(fVar18))) {
lVar11 = 0;
do {
fVar20 = *(float *)(lVar15 + lVar11 * 4) / fVar18;
if (fVar7 < (float)((uint)fVar20 & uVar5)) goto LAB_00132372;
uVar12 = (uint)(fVar20 + fVar19) & 0x7fffff;
if (0x40001e < uVar12) {
uVar12 = 0x40001f;
}
if (uVar12 < 0x3fffe1) {
uVar12 = 0x3fffe0;
}
puVar14[lVar11] = (char)uVar12 + ' ';
lVar11 = lVar11 + 1;
} while (lVar11 != 0x10);
}
lVar10 = lVar10 + 1;
puVar14 = puVar14 + 0x10;
lVar15 = lVar15 + 0x40;
} while (lVar10 != 0x10);
lVar15 = lVar13 + 0x80;
puVar14 = local_d8;
lVar10 = 0;
do {
lVar11 = 0;
do {
bVar1 = puVar14[lVar11 + -0x60];
bVar2 = puVar14[lVar11 + -0x40];
bVar3 = puVar14[lVar11 + -0x20];
bVar4 = puVar14[lVar11];
*(byte *)(lVar13 + lVar11) = bVar3 << 4 | bVar1 & 0xf;
*(byte *)(lVar13 + 0x20 + lVar11) = bVar4 << 4 | bVar2 & 0xf;
*(byte *)(lVar15 + lVar11) =
(bVar4 & 0x30) << 2 | bVar3 & 0xf0 | (char)bVar1 >> 4 | (char)bVar2 >> 2 & 0xfcU;
lVar11 = lVar11 + 1;
} while (lVar11 != 0x20);
lVar13 = lVar13 + 0x40;
lVar15 = lVar15 + 0x20;
puVar14 = puVar14 + 0x80;
bVar16 = lVar10 == 0;
lVar10 = lVar10 + 0x80;
} while (bVar16);
}
else {
memset((void *)(lVar8 * 0xd2 + param_2),0,0xd2);
}
param_1 = param_1 + 0x400;
lVar8 = lVar8 + 1;
lVar9 = lVar9 + 0xd2;
} while (lVar8 != param_3 >> 8);
}
return;
}
| |
50,668 | quantize_row_q6_K_ref | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void quantize_row_q6_K_ref(const float * restrict x, block_q6_K * restrict y, int64_t k) {
assert(k % QK_K == 0);
const int64_t nb = k / QK_K;
int8_t L[QK_K];
float scales[QK_K/16];
for (int i = 0; i < nb; i++) {
float max_scale = 0;
float max_abs_scale = 0;
for (int ib = 0; ib < QK_K/16; ++ib) {
const float scale = make_qx_quants(16, 32, x + 16*ib, L + 16*ib, 1, NULL);
scales[ib] = scale;
const float abs_scale = fabsf(scale);
if (abs_scale > max_abs_scale) {
max_abs_scale = abs_scale;
max_scale = scale;
}
}
if (max_abs_scale < GROUP_MAX_EPS) {
memset(&y[i], 0, sizeof(block_q6_K));
y[i].d = GGML_FP32_TO_FP16(0.f);
x += QK_K;
continue;
}
float iscale = -128.f/max_scale;
y[i].d = GGML_FP32_TO_FP16(1/iscale);
for (int ib = 0; ib < QK_K/16; ++ib) {
y[i].scales[ib] = MIN(127, nearest_int(iscale*scales[ib]));
}
for (int j = 0; j < QK_K/16; ++j) {
float d = GGML_FP16_TO_FP32(y[i].d) * y[i].scales[j];
if (!d) {
continue;
}
for (int ii = 0; ii < 16; ++ii) {
int l = nearest_int(x[16*j + ii]/d);
l = MAX(-32, MIN(31, l));
L[16*j + ii] = l + 32;
}
}
uint8_t * restrict ql = y[i].ql;
uint8_t * restrict qh = y[i].qh;
for (int j = 0; j < QK_K; j += 128) {
for (int l = 0; l < 32; ++l) {
const uint8_t q1 = L[j + l + 0] & 0xF;
const uint8_t q2 = L[j + l + 32] & 0xF;
const uint8_t q3 = L[j + l + 64] & 0xF;
const uint8_t q4 = L[j + l + 96] & 0xF;
ql[l+ 0] = q1 | (q3 << 4);
ql[l+32] = q2 | (q4 << 4);
qh[l] = (L[j + l] >> 4) | ((L[j + l + 32] >> 4) << 2) | ((L[j + l + 64] >> 4) << 4) | ((L[j + l + 96] >> 4) << 6);
}
ql += 64;
qh += 32;
}
x += QK_K;
}
} | O2 | c | quantize_row_q6_K_ref:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r12
testb %r12b, %r12b
jne 0x35dba
movq %rsi, %r14
sarq $0x8, %r12
xorl %eax, %eax
testq %r12, %r12
cmovleq %rax, %r12
leaq 0xc0(%rsi), %rcx
pushq $-0x20
popq %rbp
movq %rsi, 0x48(%rsp)
movq %r12, 0x40(%rsp)
cmpq %r12, %rax
je 0x35da8
movq %rcx, 0x38(%rsp)
movq %rax, 0x18(%rsp)
xorps %xmm2, %xmm2
movq %rdi, 0x10(%rsp)
movq %rdi, %r13
leaq 0x90(%rsp), %rbx
xorl %r15d, %r15d
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
cmpq $0x10, %r15
je 0x35b9a
pushq $0x10
popq %rdi
pushq $0x20
popq %rsi
movq %r13, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
movaps %xmm2, 0x20(%rsp)
callq 0x35dd9
movss %xmm0, 0x50(%rsp,%r15,4)
movaps %xmm0, %xmm1
andps 0x184b2(%rip), %xmm1 # 0x4e020
movaps %xmm1, %xmm2
movaps 0x20(%rsp), %xmm3
maxss %xmm3, %xmm2
cmpltss %xmm1, %xmm3
andps %xmm3, %xmm0
andnps (%rsp), %xmm3
orps %xmm0, %xmm3
movaps %xmm3, (%rsp)
incq %r15
addq $0x10, %rbx
addq $0x40, %r13
jmp 0x35b3e
movss 0x1d4b6(%rip), %xmm0 # 0x53058
ucomiss %xmm2, %xmm0
jbe 0x35be9
imulq $0xd2, 0x18(%rsp), %rdi
addq %r14, %rdi
movl $0xd2, %edx
xorl %esi, %esi
callq 0x1dcc0
movq 0x10(%rsp), %rdi
addq $0x400, %rdi # imm = 0x400
movq 0x18(%rsp), %rax
incq %rax
movq 0x38(%rsp), %rcx
addq $0xd2, %rcx
movq 0x48(%rsp), %r14
jmp 0x35b0e
movss 0x1d47f(%rip), %xmm1 # 0x53070
divss (%rsp), %xmm1
movss 0x18462(%rip), %xmm0 # 0x4e060
movss %xmm1, 0x20(%rsp)
divss %xmm1, %xmm0
callq 0x31de9
imulq $0xd2, 0x18(%rsp), %rcx
leaq (%r14,%rcx), %rbx
movw %ax, 0xd0(%r14,%rcx)
xorl %r14d, %r14d
movq 0x10(%rsp), %r15
movq 0x38(%rsp), %r13
cmpq $0x10, %r14
je 0x35c6a
movss 0x50(%rsp,%r14,4), %xmm0
mulss 0x20(%rsp), %xmm0
movss %xmm0, (%rsp)
callq 0x33171
movl %eax, %ecx
movb $0x7f, %al
cmpl $0x7f, %ecx
jg 0x35c60
movss (%rsp), %xmm0
callq 0x33171
movb %al, (%r13,%r14)
incq %r14
jmp 0x35c30
movzwl 0xd0(%rbx), %eax
movq %rax, 0x20(%rsp)
movq %r15, %r12
leaq 0x90(%rsp), %r15
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0x35cf8
movsbl 0xc0(%rbx,%r13), %eax
cvtsi2ss %eax, %xmm0
movq 0x3d30a(%rip), %rax # 0x72fa8
movq 0x20(%rsp), %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rsp)
ucomiss 0x1d374(%rip), %xmm0 # 0x53028
jne 0x35cb8
jnp 0x35ceb
xorl %r14d, %r14d
cmpq $0x10, %r14
je 0x35ceb
movss (%r12,%r14,4), %xmm0
divss (%rsp), %xmm0
callq 0x33171
cmpl $0x1f, %eax
jl 0x35cd9
pushq $0x1f
popq %rax
cmpl $-0x1f, %eax
jge 0x35ce0
movl %ebp, %eax
addb $0x20, %al
movb %al, (%r15,%r14)
incq %r14
jmp 0x35cbb
incq %r13
addq $0x10, %r15
addq $0x40, %r12
jmp 0x35c84
leaq 0x80(%rbx), %rax
leaq 0xf0(%rsp), %rcx
xorl %edx, %edx
movq 0x40(%rsp), %r12
movq 0x10(%rsp), %rdi
cmpq $0xff, %rdx
ja 0x35bc4
xorl %esi, %esi
cmpq $0x20, %rsi
je 0x35d90
movb -0x60(%rcx,%rsi), %r13b
movb -0x40(%rcx,%rsi), %r8b
movl %r13d, %r9d
andb $0xf, %r9b
movl %r8d, %r10d
andb $0xf, %r10b
movb -0x20(%rcx,%rsi), %r11b
movb (%rcx,%rsi), %r14b
movl %r11d, %r15d
shlb $0x4, %r15b
orb %r9b, %r15b
movb %r15b, (%rbx,%rsi)
movl %r14d, %r9d
shlb $0x4, %r9b
orb %r10b, %r9b
movb %r9b, 0x20(%rbx,%rsi)
sarb $0x4, %r13b
sarb $0x2, %r8b
andb $-0x4, %r8b
andb $-0x10, %r11b
orb %r13b, %r11b
orb %r8b, %r11b
shlb $0x2, %r14b
andb $-0x40, %r14b
orb %r11b, %r14b
movb %r14b, (%rax,%rsi)
incq %rsi
jmp 0x35d22
addq $0x40, %rbx
addq $0x20, %rax
movl $0x80, %esi
addq %rsi, %rdx
addq %rsi, %rcx
jmp 0x35d13
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2808b(%rip), %rdi # 0x5de4c
leaq 0x27c9c(%rip), %rsi # 0x5da64
leaq 0x2830b(%rip), %rcx # 0x5e0da
movl $0x655, %edx # imm = 0x655
callq 0x1dfb0
| quantize_row_q6_K_ref:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 198h
mov r12, rdx
test r12b, r12b
jnz loc_35DBA
mov r14, rsi
sar r12, 8
xor eax, eax
test r12, r12
cmovle r12, rax
lea rcx, [rsi+0C0h]
push 0FFFFFFFFFFFFFFE0h
pop rbp
mov [rsp+1C8h+var_180], rsi
mov [rsp+1C8h+var_188], r12
loc_35B0E:
cmp rax, r12
jz loc_35DA8
mov [rsp+1C8h+var_190], rcx
mov [rsp+1C8h+var_1B0], rax
xorps xmm2, xmm2
mov [rsp+1C8h+var_1B8], rdi
mov r13, rdi
lea rbx, [rsp+1C8h+var_138]
xor r15d, r15d
xorps xmm0, xmm0
movaps [rsp+1C8h+var_1C8], xmm0
loc_35B3E:
cmp r15, 10h
jz short loc_35B9A
push 10h
pop rdi
push 20h ; ' '
pop rsi
mov rdx, r13
mov rcx, rbx
xor r8d, r8d
movaps [rsp+1C8h+var_1A8], xmm2
call make_qx_quants
movss [rsp+r15*4+1C8h+var_178], xmm0
movaps xmm1, xmm0
andps xmm1, cs:xmmword_4E020
movaps xmm2, xmm1
movaps xmm3, [rsp+1C8h+var_1A8]
maxss xmm2, xmm3
cmpltss xmm3, xmm1
andps xmm0, xmm3
andnps xmm3, [rsp+1C8h+var_1C8]
orps xmm3, xmm0
movaps [rsp+1C8h+var_1C8], xmm3
inc r15
add rbx, 10h
add r13, 40h ; '@'
jmp short loc_35B3E
loc_35B9A:
movss xmm0, cs:dword_53058
ucomiss xmm0, xmm2
jbe short loc_35BE9
imul rdi, [rsp+1C8h+var_1B0], 0D2h
add rdi, r14
mov edx, 0D2h
xor esi, esi
call _memset
mov rdi, [rsp+1C8h+var_1B8]
loc_35BC4:
add rdi, 400h
mov rax, [rsp+1C8h+var_1B0]
inc rax
mov rcx, [rsp+1C8h+var_190]
add rcx, 0D2h
mov r14, [rsp+1C8h+var_180]
jmp loc_35B0E
loc_35BE9:
movss xmm1, cs:dword_53070
divss xmm1, dword ptr [rsp+1C8h+var_1C8]
movss xmm0, cs:dword_4E060
movss dword ptr [rsp+1C8h+var_1A8], xmm1
divss xmm0, xmm1
call ggml_compute_fp32_to_fp16_0
imul rcx, [rsp+1C8h+var_1B0], 0D2h
lea rbx, [r14+rcx]
mov [r14+rcx+0D0h], ax
xor r14d, r14d
mov r15, [rsp+1C8h+var_1B8]
mov r13, [rsp+1C8h+var_190]
loc_35C30:
cmp r14, 10h
jz short loc_35C6A
movss xmm0, [rsp+r14*4+1C8h+var_178]
mulss xmm0, dword ptr [rsp+1C8h+var_1A8]
movss dword ptr [rsp+1C8h+var_1C8], xmm0
call nearest_int
mov ecx, eax
mov al, 7Fh
cmp ecx, 7Fh
jg short loc_35C60
movss xmm0, dword ptr [rsp+1C8h+var_1C8]
call nearest_int
loc_35C60:
mov [r13+r14+0], al
inc r14
jmp short loc_35C30
loc_35C6A:
movzx eax, word ptr [rbx+0D0h]
mov qword ptr [rsp+1C8h+var_1A8], rax
mov r12, r15
lea r15, [rsp+1C8h+var_138]
xor r13d, r13d
loc_35C84:
cmp r13, 10h
jz short loc_35CF8
movsx eax, byte ptr [rbx+r13+0C0h]
cvtsi2ss xmm0, eax
mov rax, cs:ggml_table_f32_f16_ptr
mov rcx, qword ptr [rsp+1C8h+var_1A8]
mulss xmm0, dword ptr [rax+rcx*4]
movss dword ptr [rsp+1C8h+var_1C8], xmm0
ucomiss xmm0, cs:dword_53028
jnz short loc_35CB8
jnp short loc_35CEB
loc_35CB8:
xor r14d, r14d
loc_35CBB:
cmp r14, 10h
jz short loc_35CEB
movss xmm0, dword ptr [r12+r14*4]
divss xmm0, dword ptr [rsp+1C8h+var_1C8]
call nearest_int
cmp eax, 1Fh
jl short loc_35CD9
push 1Fh
pop rax
loc_35CD9:
cmp eax, 0FFFFFFE1h
jge short loc_35CE0
mov eax, ebp
loc_35CE0:
add al, 20h ; ' '
mov [r15+r14], al
inc r14
jmp short loc_35CBB
loc_35CEB:
inc r13
add r15, 10h
add r12, 40h ; '@'
jmp short loc_35C84
loc_35CF8:
lea rax, [rbx+80h]
lea rcx, [rsp+1C8h+var_D8]
xor edx, edx
mov r12, [rsp+1C8h+var_188]
mov rdi, [rsp+1C8h+var_1B8]
loc_35D13:
cmp rdx, 0FFh
ja loc_35BC4
xor esi, esi
loc_35D22:
cmp rsi, 20h ; ' '
jz short loc_35D90
mov r13b, [rcx+rsi-60h]
mov r8b, [rcx+rsi-40h]
mov r9d, r13d
and r9b, 0Fh
mov r10d, r8d
and r10b, 0Fh
mov r11b, [rcx+rsi-20h]
mov r14b, [rcx+rsi]
mov r15d, r11d
shl r15b, 4
or r15b, r9b
mov [rbx+rsi], r15b
mov r9d, r14d
shl r9b, 4
or r9b, r10b
mov [rbx+rsi+20h], r9b
sar r13b, 4
sar r8b, 2
and r8b, 0FCh
and r11b, 0F0h
or r11b, r13b
or r11b, r8b
shl r14b, 2
and r14b, 0C0h
or r14b, r11b
mov [rax+rsi], r14b
inc rsi
jmp short loc_35D22
loc_35D90:
add rbx, 40h ; '@'
add rax, 20h ; ' '
mov esi, 80h
add rdx, rsi
add rcx, rsi
jmp loc_35D13
loc_35DA8:
add rsp, 198h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_35DBA:
lea rdi, aKQkK0; "k % QK_K == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidQuantizeRo_13; "void quantize_row_q6_K_ref(const float "...
mov edx, 655h
call ___assert_fail
| long long quantize_row_q6_K_ref(long long a1, long long a2, long long a3, double a4, __m128 a5)
{
long long v5; // r14
long long v6; // r12
long long result; // rax
long long v8; // rcx
__m128 v9; // xmm2
long long v10; // r13
_BYTE *v11; // rbx
long long v12; // r15
__m128 v13; // xmm0
__m128 v14; // xmm3
__m128i v15; // xmm0
long long v16; // rbx
long long i; // r14
__m128i v18; // xmm0
int v19; // ecx
char v20; // al
long long v21; // r12
_BYTE *v22; // r15
long long j; // r13
long long k; // r14
__m128i v25; // xmm0
int v26; // eax
long long v27; // rax
char *v28; // rcx
unsigned long long v29; // rdx
long long m; // rsi
char v31; // r13
char v32; // r8
char v33; // r11
char v34; // r14
__m128 v35; // [rsp+0h] [rbp-1C8h]
float v36; // [rsp+0h] [rbp-1C8h]
long long v37; // [rsp+18h] [rbp-1B0h]
__m128 v38; // [rsp+20h] [rbp-1A8h]
long long v39; // [rsp+20h] [rbp-1A8h]
long long v40; // [rsp+38h] [rbp-190h]
long long v41; // [rsp+40h] [rbp-188h]
_DWORD v43[16]; // [rsp+50h] [rbp-178h]
_BYTE v44[96]; // [rsp+90h] [rbp-138h] BYREF
char v45; // [rsp+F0h] [rbp-D8h] BYREF
if ( (_BYTE)a3 )
__assert_fail(
"k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
1621LL,
"void quantize_row_q6_K_ref(const float *restrict, block_q6_K *restrict, int64_t)");
v5 = a2;
v6 = a3 >> 8;
result = 0LL;
if ( a3 >> 8 <= 0 )
v6 = 0LL;
v8 = a2 + 192;
v41 = v6;
while ( result != v6 )
{
v40 = v8;
v37 = result;
v9 = 0LL;
v10 = a1;
v11 = v44;
v12 = 0LL;
v13 = 0LL;
v35 = 0LL;
while ( v12 != 16 )
{
v38 = v9;
*(double *)v13.m128_u64 = make_qx_quants(
16LL,
32LL,
v10,
v11,
0LL,
*(double *)v13.m128_u64,
*(double *)a5.m128_u64);
v43[v12] = v13.m128_i32[0];
a5 = _mm_and_ps(v13, (__m128)xmmword_4E020);
v9 = a5;
v9.m128_f32[0] = fmaxf(a5.m128_f32[0], v38.m128_f32[0]);
v14 = _mm_cmplt_ss(v38, a5);
v13 = _mm_and_ps(v13, v14);
v35 = _mm_or_ps(_mm_andnot_ps(v14, v35), v13);
++v12;
v11 += 16;
v10 += 64LL;
}
if ( v9.m128_f32[0] >= 1.0e-15 )
{
a5.m128_i32[1] = 0;
a5.m128_f32[0] = -128.0 / v35.m128_f32[0];
v15 = (__m128i)0x3F800000u;
*(float *)v15.m128i_i32 = 1.0 / (float)(-128.0 / v35.m128_f32[0]);
v16 = v5 + 210 * v37;
*(_WORD *)(v16 + 208) = ggml_compute_fp32_to_fp16_0(v15);
for ( i = 0LL; i != 16; ++i )
{
v18 = (__m128i)(unsigned int)v43[i];
*(float *)v18.m128i_i32 = *(float *)v18.m128i_i32 * (float)(-128.0 / v35.m128_f32[0]);
v19 = nearest_int(v18);
v20 = 127;
if ( v19 <= 127 )
v20 = nearest_int((__m128i)v18.m128i_u32[0]);
*(_BYTE *)(v40 + i) = v20;
}
v39 = *(unsigned __int16 *)(v16 + 208);
v21 = a1;
v22 = v44;
for ( j = 0LL; j != 16; ++j )
{
v36 = (float)*(char *)(v16 + j + 192) * ggml_table_f32_f16[v39];
if ( v36 != 0.0 )
{
for ( k = 0LL; k != 16; ++k )
{
v25 = (__m128i)*(unsigned int *)(v21 + 4 * k);
*(float *)v25.m128i_i32 = *(float *)v25.m128i_i32 / v36;
v26 = nearest_int(v25);
if ( v26 >= 31 )
v26 = 31;
if ( v26 < -31 )
LOBYTE(v26) = -32;
v22[k] = v26 + 32;
}
}
v22 += 16;
v21 += 64LL;
}
v27 = v16 + 128;
v28 = &v45;
v29 = 0LL;
v6 = v41;
while ( v29 <= 0xFF )
{
for ( m = 0LL; m != 32; ++m )
{
v31 = v28[m - 96];
v32 = v28[m - 64];
v33 = v28[m - 32];
v34 = v28[m];
*(_BYTE *)(v16 + m) = v31 & 0xF | (16 * v33);
*(_BYTE *)(v16 + m + 32) = v32 & 0xF | (16 * v34);
*(_BYTE *)(v27 + m) = (v32 >> 2) & 0xFC | (v31 >> 4) | v33 & 0xF0 | (4 * v34) & 0xC0;
}
v16 += 64LL;
v27 += 32LL;
v29 += 128LL;
v28 += 128;
}
}
else
{
memset(v5 + 210 * v37, 0LL, 210LL);
}
a1 += 1024LL;
result = v37 + 1;
v8 = v40 + 210;
v5 = a2;
}
return result;
}
| quantize_row_q6_K_ref:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x198
MOV R12,RDX
TEST R12B,R12B
JNZ 0x00135dba
MOV R14,RSI
SAR R12,0x8
XOR EAX,EAX
TEST R12,R12
CMOVLE R12,RAX
LEA RCX,[RSI + 0xc0]
PUSH -0x20
POP RBP
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x40],R12
LAB_00135b0e:
CMP RAX,R12
JZ 0x00135da8
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x18],RAX
XORPS XMM2,XMM2
MOV qword ptr [RSP + 0x10],RDI
MOV R13,RDI
LEA RBX,[RSP + 0x90]
XOR R15D,R15D
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
LAB_00135b3e:
CMP R15,0x10
JZ 0x00135b9a
PUSH 0x10
POP RDI
PUSH 0x20
POP RSI
MOV RDX,R13
MOV RCX,RBX
XOR R8D,R8D
MOVAPS xmmword ptr [RSP + 0x20],XMM2
CALL 0x00135dd9
MOVSS dword ptr [RSP + R15*0x4 + 0x50],XMM0
MOVAPS XMM1,XMM0
ANDPS XMM1,xmmword ptr [0x0014e020]
MOVAPS XMM2,XMM1
MOVAPS XMM3,xmmword ptr [RSP + 0x20]
MAXSS XMM2,XMM3
CMPLTSS XMM3,XMM1
ANDPS XMM0,XMM3
ANDNPS XMM3,xmmword ptr [RSP]
ORPS XMM3,XMM0
MOVAPS xmmword ptr [RSP],XMM3
INC R15
ADD RBX,0x10
ADD R13,0x40
JMP 0x00135b3e
LAB_00135b9a:
MOVSS XMM0,dword ptr [0x00153058]
UCOMISS XMM0,XMM2
JBE 0x00135be9
IMUL RDI,qword ptr [RSP + 0x18],0xd2
ADD RDI,R14
MOV EDX,0xd2
XOR ESI,ESI
CALL 0x0011dcc0
MOV RDI,qword ptr [RSP + 0x10]
LAB_00135bc4:
ADD RDI,0x400
MOV RAX,qword ptr [RSP + 0x18]
INC RAX
MOV RCX,qword ptr [RSP + 0x38]
ADD RCX,0xd2
MOV R14,qword ptr [RSP + 0x48]
JMP 0x00135b0e
LAB_00135be9:
MOVSS XMM1,dword ptr [0x00153070]
DIVSS XMM1,dword ptr [RSP]
MOVSS XMM0,dword ptr [0x0014e060]
MOVSS dword ptr [RSP + 0x20],XMM1
DIVSS XMM0,XMM1
CALL 0x00131de9
IMUL RCX,qword ptr [RSP + 0x18],0xd2
LEA RBX,[R14 + RCX*0x1]
MOV word ptr [R14 + RCX*0x1 + 0xd0],AX
XOR R14D,R14D
MOV R15,qword ptr [RSP + 0x10]
MOV R13,qword ptr [RSP + 0x38]
LAB_00135c30:
CMP R14,0x10
JZ 0x00135c6a
MOVSS XMM0,dword ptr [RSP + R14*0x4 + 0x50]
MULSS XMM0,dword ptr [RSP + 0x20]
MOVSS dword ptr [RSP],XMM0
CALL 0x00133171
MOV ECX,EAX
MOV AL,0x7f
CMP ECX,0x7f
JG 0x00135c60
MOVSS XMM0,dword ptr [RSP]
CALL 0x00133171
LAB_00135c60:
MOV byte ptr [R13 + R14*0x1],AL
INC R14
JMP 0x00135c30
LAB_00135c6a:
MOVZX EAX,word ptr [RBX + 0xd0]
MOV qword ptr [RSP + 0x20],RAX
MOV R12,R15
LEA R15,[RSP + 0x90]
XOR R13D,R13D
LAB_00135c84:
CMP R13,0x10
JZ 0x00135cf8
MOVSX EAX,byte ptr [RBX + R13*0x1 + 0xc0]
CVTSI2SS XMM0,EAX
MOV RAX,qword ptr [0x00172fa8]
MOV RCX,qword ptr [RSP + 0x20]
MULSS XMM0,dword ptr [RAX + RCX*0x4]
MOVSS dword ptr [RSP],XMM0
UCOMISS XMM0,dword ptr [0x00153028]
JNZ 0x00135cb8
JNP 0x00135ceb
LAB_00135cb8:
XOR R14D,R14D
LAB_00135cbb:
CMP R14,0x10
JZ 0x00135ceb
MOVSS XMM0,dword ptr [R12 + R14*0x4]
DIVSS XMM0,dword ptr [RSP]
CALL 0x00133171
CMP EAX,0x1f
JL 0x00135cd9
PUSH 0x1f
POP RAX
LAB_00135cd9:
CMP EAX,-0x1f
JGE 0x00135ce0
MOV EAX,EBP
LAB_00135ce0:
ADD AL,0x20
MOV byte ptr [R15 + R14*0x1],AL
INC R14
JMP 0x00135cbb
LAB_00135ceb:
INC R13
ADD R15,0x10
ADD R12,0x40
JMP 0x00135c84
LAB_00135cf8:
LEA RAX,[RBX + 0x80]
LEA RCX,[RSP + 0xf0]
XOR EDX,EDX
MOV R12,qword ptr [RSP + 0x40]
MOV RDI,qword ptr [RSP + 0x10]
LAB_00135d13:
CMP RDX,0xff
JA 0x00135bc4
XOR ESI,ESI
LAB_00135d22:
CMP RSI,0x20
JZ 0x00135d90
MOV R13B,byte ptr [RCX + RSI*0x1 + -0x60]
MOV R8B,byte ptr [RCX + RSI*0x1 + -0x40]
MOV R9D,R13D
AND R9B,0xf
MOV R10D,R8D
AND R10B,0xf
MOV R11B,byte ptr [RCX + RSI*0x1 + -0x20]
MOV R14B,byte ptr [RCX + RSI*0x1]
MOV R15D,R11D
SHL R15B,0x4
OR R15B,R9B
MOV byte ptr [RBX + RSI*0x1],R15B
MOV R9D,R14D
SHL R9B,0x4
OR R9B,R10B
MOV byte ptr [RBX + RSI*0x1 + 0x20],R9B
SAR R13B,0x4
SAR R8B,0x2
AND R8B,0xfc
AND R11B,0xf0
OR R11B,R13B
OR R11B,R8B
SHL R14B,0x2
AND R14B,0xc0
OR R14B,R11B
MOV byte ptr [RAX + RSI*0x1],R14B
INC RSI
JMP 0x00135d22
LAB_00135d90:
ADD RBX,0x40
ADD RAX,0x20
MOV ESI,0x80
ADD RDX,RSI
ADD RCX,RSI
JMP 0x00135d13
LAB_00135da8:
ADD RSP,0x198
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00135dba:
LEA RDI,[0x15de4c]
LEA RSI,[0x15da64]
LEA RCX,[0x15e0da]
MOV EDX,0x655
CALL 0x0011dfb0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void quantize_row_q6_K_ref(long param_1,long param_2,long param_3)
{
byte bVar1;
byte bVar2;
byte bVar3;
byte bVar4;
ushort uVar5;
int1 uVar6;
int2 uVar7;
int iVar8;
long lVar9;
long lVar10;
ulong uVar11;
int1 *puVar12;
long lVar13;
long lVar14;
long lVar15;
long lVar16;
long lVar17;
float fVar18;
float fVar19;
float fVar20;
float fVar21;
float local_1c8;
float afStack_178 [16];
int1 local_138 [96];
int1 local_d8 [168];
if ((char)param_3 == '\0') {
lVar9 = 0;
lVar13 = param_3 >> 8;
if (param_3 >> 8 < 1) {
lVar13 = lVar9;
}
lVar10 = param_2 + 0xc0;
for (; lVar9 != lVar13; lVar9 = lVar9 + 1) {
puVar12 = local_138;
local_1c8 = 0.0;
lVar14 = param_1;
fVar19 = 0.0;
for (lVar17 = 0; lVar17 != 0x10; lVar17 = lVar17 + 1) {
fVar18 = (float)make_qx_quants(0x10,0x20,lVar14,puVar12,0);
afStack_178[lVar17] = fVar18;
fVar20 = (float)((uint)fVar18 & _DAT_0014e020);
fVar21 = fVar20;
if (fVar20 <= fVar19) {
fVar21 = fVar19;
}
local_1c8 = (float)(~-(uint)(fVar19 < fVar20) & (uint)local_1c8 |
(uint)fVar18 & -(uint)(fVar19 < fVar20));
puVar12 = puVar12 + 0x10;
lVar14 = lVar14 + 0x40;
fVar19 = fVar21;
}
if (DAT_00153058 <= fVar19) {
local_1c8 = DAT_00153070 / local_1c8;
uVar7 = ggml_compute_fp32_to_fp16(DAT_0014e060 / local_1c8);
lVar14 = param_2 + lVar9 * 0xd2;
*(int2 *)(param_2 + 0xd0 + lVar9 * 0xd2) = uVar7;
for (lVar17 = 0; lVar17 != 0x10; lVar17 = lVar17 + 1) {
fVar19 = afStack_178[lVar17];
iVar8 = nearest_int();
uVar6 = 0x7f;
if (iVar8 < 0x80) {
uVar6 = nearest_int(fVar19 * local_1c8);
}
*(int1 *)(lVar10 + lVar17) = uVar6;
}
uVar5 = *(ushort *)(lVar14 + 0xd0);
puVar12 = local_138;
lVar17 = param_1;
for (lVar15 = 0; lVar15 != 0x10; lVar15 = lVar15 + 1) {
fVar19 = (float)(int)*(char *)(lVar14 + 0xc0 + lVar15) *
*(float *)(PTR_ggml_table_f32_f16_00172fa8 + (ulong)uVar5 * 4);
if ((fVar19 != DAT_00153028) || (NAN(fVar19) || NAN(DAT_00153028))) {
for (lVar16 = 0; lVar16 != 0x10; lVar16 = lVar16 + 1) {
iVar8 = nearest_int(*(float *)(lVar17 + lVar16 * 4) / fVar19);
if (0x1e < iVar8) {
iVar8 = 0x1f;
}
if (iVar8 < -0x1f) {
iVar8 = -0x20;
}
puVar12[lVar16] = (char)iVar8 + ' ';
}
}
puVar12 = puVar12 + 0x10;
lVar17 = lVar17 + 0x40;
}
lVar17 = lVar14 + 0x80;
puVar12 = local_d8;
for (uVar11 = 0; uVar11 < 0x100; uVar11 = uVar11 + 0x80) {
for (lVar15 = 0; lVar15 != 0x20; lVar15 = lVar15 + 1) {
bVar1 = puVar12[lVar15 + -0x60];
bVar2 = puVar12[lVar15 + -0x40];
bVar3 = puVar12[lVar15 + -0x20];
bVar4 = puVar12[lVar15];
*(byte *)(lVar14 + lVar15) = bVar3 << 4 | bVar1 & 0xf;
*(byte *)(lVar14 + 0x20 + lVar15) = bVar4 << 4 | bVar2 & 0xf;
*(byte *)(lVar17 + lVar15) =
(bVar4 & 0x30) << 2 | bVar3 & 0xf0 | (char)bVar1 >> 4 | (char)bVar2 >> 2 & 0xfcU;
}
lVar14 = lVar14 + 0x40;
lVar17 = lVar17 + 0x20;
puVar12 = puVar12 + 0x80;
}
}
else {
memset((void *)(lVar9 * 0xd2 + param_2),0,0xd2);
}
param_1 = param_1 + 0x400;
lVar10 = lVar10 + 0xd2;
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x655,
"void quantize_row_q6_K_ref(const float *restrict, block_q6_K *restrict, int64_t)");
}
| |
50,669 | quantize_row_q6_K_ref | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void quantize_row_q6_K_ref(const float * restrict x, block_q6_K * restrict y, int64_t k) {
assert(k % QK_K == 0);
const int64_t nb = k / QK_K;
int8_t L[QK_K];
float scales[QK_K/16];
for (int i = 0; i < nb; i++) {
float max_scale = 0;
float max_abs_scale = 0;
for (int ib = 0; ib < QK_K/16; ++ib) {
const float scale = make_qx_quants(16, 32, x + 16*ib, L + 16*ib, 1, NULL);
scales[ib] = scale;
const float abs_scale = fabsf(scale);
if (abs_scale > max_abs_scale) {
max_abs_scale = abs_scale;
max_scale = scale;
}
}
if (max_abs_scale < GROUP_MAX_EPS) {
memset(&y[i], 0, sizeof(block_q6_K));
y[i].d = GGML_FP32_TO_FP16(0.f);
x += QK_K;
continue;
}
float iscale = -128.f/max_scale;
y[i].d = GGML_FP32_TO_FP16(1/iscale);
for (int ib = 0; ib < QK_K/16; ++ib) {
y[i].scales[ib] = MIN(127, nearest_int(iscale*scales[ib]));
}
for (int j = 0; j < QK_K/16; ++j) {
float d = GGML_FP16_TO_FP32(y[i].d) * y[i].scales[j];
if (!d) {
continue;
}
for (int ii = 0; ii < 16; ++ii) {
int l = nearest_int(x[16*j + ii]/d);
l = MAX(-32, MIN(31, l));
L[16*j + ii] = l + 32;
}
}
uint8_t * restrict ql = y[i].ql;
uint8_t * restrict qh = y[i].qh;
for (int j = 0; j < QK_K; j += 128) {
for (int l = 0; l < 32; ++l) {
const uint8_t q1 = L[j + l + 0] & 0xF;
const uint8_t q2 = L[j + l + 32] & 0xF;
const uint8_t q3 = L[j + l + 64] & 0xF;
const uint8_t q4 = L[j + l + 96] & 0xF;
ql[l+ 0] = q1 | (q3 << 4);
ql[l+32] = q2 | (q4 << 4);
qh[l] = (L[j + l] >> 4) | ((L[j + l + 32] >> 4) << 2) | ((L[j + l + 64] >> 4) << 4) | ((L[j + l + 96] >> 4) << 6);
}
ql += 64;
qh += 32;
}
x += QK_K;
}
} | O3 | c | quantize_row_q6_K_ref:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, 0x8(%rsp)
testb %dl, %dl
jne 0x312f1
sarq $0x8, %rdx
testq %rdx, %rdx
jle 0x312c0
movq %rdi, %r12
movq 0x8(%rsp), %rax
leaq 0xc0(%rax), %rbp
leaq 0xe0(%rsp), %rbx
xorl %r14d, %r14d
movq %rdx, 0x18(%rsp)
movq %r12, 0x10(%rsp)
leaq 0x80(%rsp), %r13
xorl %r15d, %r15d
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movaps %xmm0, 0x20(%rsp)
movaps %xmm1, 0x30(%rsp)
movl $0x10, %edi
movl $0x20, %esi
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0x31310
movaps 0x1b0b9(%rip), %xmm4 # 0x4c020
movss %xmm0, 0x40(%rsp,%r15,4)
movaps %xmm0, %xmm2
andps %xmm4, %xmm2
movaps %xmm2, %xmm1
movaps 0x30(%rsp), %xmm3
maxss %xmm3, %xmm1
cmpltss %xmm2, %xmm3
movaps %xmm3, %xmm2
andps %xmm3, %xmm0
andnps 0x20(%rsp), %xmm2
orps %xmm0, %xmm2
incq %r15
addq $0x10, %r13
addq $0x40, %r12
movaps %xmm2, %xmm0
cmpq $0x10, %r15
jne 0x30f3e
movss 0x20335(%rip), %xmm0 # 0x512e4
ucomiss %xmm1, %xmm0
jbe 0x30fd6
imulq $0xd2, %r14, %rdi
addq 0x8(%rsp), %rdi
movl $0xd2, %edx
xorl %esi, %esi
callq 0x168f0
movq 0x10(%rsp), %r12
jmp 0x312a1
movss 0x2031e(%rip), %xmm0 # 0x512fc
divss %xmm2, %xmm0
movss 0x1b106(%rip), %xmm1 # 0x4c0f0
divss %xmm0, %xmm1
movd %xmm1, %eax
andps %xmm4, %xmm1
mulss 0x1b0eb(%rip), %xmm1 # 0x4c0e8
mulss 0x1b0e7(%rip), %xmm1 # 0x4c0ec
leal (%rax,%rax), %ecx
movl %eax, %edx
andl $0x7f800000, %edx # imm = 0x7F800000
addl $0x7800000, %edx # imm = 0x7800000
cmpl $0x71000000, %ecx # imm = 0x71000000
movl $0x40000000, %esi # imm = 0x40000000
cmovbl %esi, %edx
movd %edx, %xmm2
addss %xmm1, %xmm2
movd %xmm2, %edx
movl %edx, %esi
shrl $0xd, %esi
andl $0x7c00, %esi # imm = 0x7C00
andl $0xfff, %edx # imm = 0xFFF
addl %esi, %edx
shrl $0x10, %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0xff000001, %ecx # imm = 0xFF000001
movl $0x7e00, %ecx # imm = 0x7E00
cmovael %ecx, %edx
orl %eax, %edx
imulq $0xd2, %r14, %rcx
movq 0x8(%rsp), %rsi
leaq (%rsi,%rcx), %rax
movw %dx, 0xd0(%rsi,%rcx)
xorl %ecx, %ecx
movq 0x10(%rsp), %r12
movss 0x20252(%rip), %xmm5 # 0x512d4
movss 0x2024e(%rip), %xmm6 # 0x512d8
xorps %xmm7, %xmm7
movdqa 0x1ff6a(%rip), %xmm8 # 0x51000
movdqa 0x1ff71(%rip), %xmm9 # 0x51010
movdqa 0x1ff78(%rip), %xmm10 # 0x51020
movdqa 0x1feef(%rip), %xmm11 # 0x50fa0
movdqa 0x1fef6(%rip), %xmm12 # 0x50fb0
movss 0x40(%rsp,%rcx,4), %xmm1
mulss %xmm0, %xmm1
movaps %xmm1, %xmm2
andps %xmm4, %xmm2
ucomiss %xmm2, %xmm5
jb 0x312d2
addss %xmm6, %xmm1
movd %xmm1, %edx
movl %edx, %r8d
andl $0x7fff80, %r8d # imm = 0x7FFF80
movl $0x7f, %esi
cmpl $0x400080, %r8d # imm = 0x400080
jae 0x310f5
movl %edx, %esi
movb %sil, (%rbp,%rcx)
incq %rcx
cmpq $0x10, %rcx
jne 0x310ba
movzwl 0xd0(%rax), %ecx
movq 0x3ce97(%rip), %rdx # 0x6dfa8
movss (%rdx,%rcx,4), %xmm0
movq %r12, %rcx
leaq 0x80(%rsp), %rdx
xorl %esi, %esi
movsbl 0xc0(%rax,%rsi), %r8d
xorps %xmm1, %xmm1
cvtsi2ss %r8d, %xmm1
mulss %xmm0, %xmm1
ucomiss %xmm7, %xmm1
jne 0x3113f
jnp 0x3119c
xorl %r10d, %r10d
movss (%rcx,%r10,4), %xmm2
divss %xmm1, %xmm2
movaps %xmm2, %xmm3
andps %xmm4, %xmm3
ucomiss %xmm3, %xmm5
jb 0x312d2
addss %xmm6, %xmm2
movd %xmm2, %r8d
andl $0x7fffff, %r8d # imm = 0x7FFFFF
movl $0x40001f, %r9d # imm = 0x40001F
cmpl %r9d, %r8d
jb 0x3117c
movl $0x40001f, %r8d # imm = 0x40001F
cmpl $0x3fffe1, %r8d # imm = 0x3FFFE1
jae 0x3118b
movl $0x3fffe0, %r8d # imm = 0x3FFFE0
addb $0x20, %r8b
movb %r8b, (%rdx,%r10)
incq %r10
cmpq $0x10, %r10
jne 0x31142
incq %rsi
addq $0x10, %rdx
addq $0x40, %rcx
cmpq $0x10, %rsi
jne 0x31123
leaq 0x80(%rax), %rcx
movb $0x1, %dl
xorl %esi, %esi
movdqa 0x1fc8c(%rip), %xmm6 # 0x50e50
movdqa 0x1fe24(%rip), %xmm7 # 0x50ff0
addq %rbx, %rsi
xorl %r8d, %r8d
movdqa -0x60(%rsi,%r8), %xmm3
movdqa -0x40(%rsi,%r8), %xmm0
movdqa -0x20(%rsi,%r8), %xmm2
movdqa (%rsi,%r8), %xmm1
movdqa %xmm2, %xmm4
psllw $0x4, %xmm4
pand %xmm6, %xmm4
movdqa %xmm6, %xmm5
pandn %xmm3, %xmm5
por %xmm4, %xmm5
movdqu %xmm5, (%rax,%r8)
movdqa %xmm1, %xmm4
psllw $0x4, %xmm4
pand %xmm6, %xmm4
movdqa %xmm6, %xmm5
pandn %xmm0, %xmm5
por %xmm4, %xmm5
movdqu %xmm5, 0x20(%rax,%r8)
psrlw $0x4, %xmm3
pand %xmm7, %xmm3
pxor %xmm8, %xmm3
psubb %xmm8, %xmm3
psrlw $0x2, %xmm0
pand %xmm9, %xmm0
pxor %xmm10, %xmm0
psubb %xmm10, %xmm0
pand %xmm11, %xmm0
pand %xmm6, %xmm2
por %xmm3, %xmm2
psllw $0x2, %xmm1
pand %xmm12, %xmm1
por %xmm2, %xmm1
por %xmm0, %xmm1
movdqu %xmm1, (%rcx,%r8)
addq $0x10, %r8
cmpq $0x20, %r8
jne 0x311d2
addq $0x40, %rax
addq $0x20, %rcx
movl $0x80, %esi
testb $0x1, %dl
movl $0x0, %edx
jne 0x311cc
addq $0x400, %r12 # imm = 0x400
incq %r14
addq $0xd2, %rbp
movq 0x18(%rsp), %rdx
cmpq %rdx, %r14
jne 0x30f28
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b906(%rip), %rdi # 0x5cbdf
leaq 0x2aa14(%rip), %rsi # 0x5bcf4
leaq 0x2b911(%rip), %rcx # 0x5cbf8
movl $0x175, %edx # imm = 0x175
callq 0x16b00
leaq 0x2ade4(%rip), %rdi # 0x5c0dc
leaq 0x2a9f5(%rip), %rsi # 0x5bcf4
leaq 0x2b064(%rip), %rcx # 0x5c36a
movl $0x655, %edx # imm = 0x655
callq 0x16b00
| quantize_row_q6_K_ref:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 188h
mov [rsp+1B8h+var_1B0], rsi
test dl, dl
jnz loc_312F1
sar rdx, 8
test rdx, rdx
jle loc_312C0
mov r12, rdi
mov rax, [rsp+1B8h+var_1B0]
lea rbp, [rax+0C0h]
lea rbx, [rsp+1B8h+var_D8]
xor r14d, r14d
mov [rsp+1B8h+var_1A0], rdx
loc_30F28:
mov [rsp+1B8h+var_1A8], r12
lea r13, [rsp+1B8h+var_138]
xor r15d, r15d
xorps xmm0, xmm0
xorps xmm1, xmm1
loc_30F3E:
movaps [rsp+1B8h+var_198], xmm0
movaps [rsp+1B8h+var_188], xmm1
mov edi, 10h
mov esi, 20h ; ' '
mov rdx, r12
mov rcx, r13
xor r8d, r8d
call make_qx_quants
movaps xmm4, cs:xmmword_4C020
movss [rsp+r15*4+1B8h+var_178], xmm0
movaps xmm2, xmm0
andps xmm2, xmm4
movaps xmm1, xmm2
movaps xmm3, [rsp+1B8h+var_188]
maxss xmm1, xmm3
cmpltss xmm3, xmm2
movaps xmm2, xmm3
andps xmm0, xmm3
andnps xmm2, [rsp+1B8h+var_198]
orps xmm2, xmm0
inc r15
add r13, 10h
add r12, 40h ; '@'
movaps xmm0, xmm2
cmp r15, 10h
jnz short loc_30F3E
movss xmm0, cs:dword_512E4
ucomiss xmm0, xmm1
jbe short loc_30FD6
imul rdi, r14, 0D2h
add rdi, [rsp+1B8h+var_1B0]
mov edx, 0D2h
xor esi, esi
call _memset
mov r12, [rsp+1B8h+var_1A8]
jmp loc_312A1
loc_30FD6:
movss xmm0, cs:dword_512FC
divss xmm0, xmm2
movss xmm1, cs:dword_4C0F0
divss xmm1, xmm0
movd eax, xmm1
andps xmm1, xmm4
mulss xmm1, cs:dword_4C0E8
mulss xmm1, cs:dword_4C0EC
lea ecx, [rax+rax]
mov edx, eax
and edx, 7F800000h
add edx, 7800000h
cmp ecx, 71000000h
mov esi, 40000000h
cmovb edx, esi
movd xmm2, edx
addss xmm2, xmm1
movd edx, xmm2
mov esi, edx
shr esi, 0Dh
and esi, 7C00h
and edx, 0FFFh
add edx, esi
shr eax, 10h
and eax, 8000h
cmp ecx, 0FF000001h
mov ecx, 7E00h
cmovnb edx, ecx
or edx, eax
imul rcx, r14, 0D2h
mov rsi, [rsp+1B8h+var_1B0]
lea rax, [rsi+rcx]
mov [rsi+rcx+0D0h], dx
xor ecx, ecx
mov r12, [rsp+1B8h+var_1A8]
movss xmm5, cs:dword_512D4
movss xmm6, cs:dword_512D8
xorps xmm7, xmm7
movdqa xmm8, cs:xmmword_51000
movdqa xmm9, cs:xmmword_51010
movdqa xmm10, cs:xmmword_51020
movdqa xmm11, cs:xmmword_50FA0
movdqa xmm12, cs:xmmword_50FB0
loc_310BA:
movss xmm1, [rsp+rcx*4+1B8h+var_178]
mulss xmm1, xmm0
movaps xmm2, xmm1
andps xmm2, xmm4
ucomiss xmm5, xmm2
jb loc_312D2
addss xmm1, xmm6
movd edx, xmm1
mov r8d, edx
and r8d, 7FFF80h
mov esi, 7Fh
cmp r8d, 400080h
jnb short loc_310F5
mov esi, edx
loc_310F5:
mov [rbp+rcx+0], sil
inc rcx
cmp rcx, 10h
jnz short loc_310BA
movzx ecx, word ptr [rax+0D0h]
mov rdx, cs:ggml_table_f32_f16_ptr
movss xmm0, dword ptr [rdx+rcx*4]
mov rcx, r12
lea rdx, [rsp+1B8h+var_138]
xor esi, esi
loc_31123:
movsx r8d, byte ptr [rax+rsi+0C0h]
xorps xmm1, xmm1
cvtsi2ss xmm1, r8d
mulss xmm1, xmm0
ucomiss xmm1, xmm7
jnz short loc_3113F
jnp short loc_3119C
loc_3113F:
xor r10d, r10d
loc_31142:
movss xmm2, dword ptr [rcx+r10*4]
divss xmm2, xmm1
movaps xmm3, xmm2
andps xmm3, xmm4
ucomiss xmm5, xmm3
jb loc_312D2
addss xmm2, xmm6
movd r8d, xmm2
and r8d, 7FFFFFh
mov r9d, 40001Fh
cmp r8d, r9d
jb short loc_3117C
mov r8d, 40001Fh
loc_3117C:
cmp r8d, 3FFFE1h
jnb short loc_3118B
mov r8d, 3FFFE0h
loc_3118B:
add r8b, 20h ; ' '
mov [rdx+r10], r8b
inc r10
cmp r10, 10h
jnz short loc_31142
loc_3119C:
inc rsi
add rdx, 10h
add rcx, 40h ; '@'
cmp rsi, 10h
jnz loc_31123
lea rcx, [rax+80h]
mov dl, 1
xor esi, esi
movdqa xmm6, cs:xmmword_50E50
movdqa xmm7, cs:xmmword_50FF0
loc_311CC:
add rsi, rbx
xor r8d, r8d
loc_311D2:
movdqa xmm3, xmmword ptr [rsi+r8-60h]
movdqa xmm0, xmmword ptr [rsi+r8-40h]
movdqa xmm2, xmmword ptr [rsi+r8-20h]
movdqa xmm1, xmmword ptr [rsi+r8]
movdqa xmm4, xmm2
psllw xmm4, 4
pand xmm4, xmm6
movdqa xmm5, xmm6
pandn xmm5, xmm3
por xmm5, xmm4
movdqu xmmword ptr [rax+r8], xmm5
movdqa xmm4, xmm1
psllw xmm4, 4
pand xmm4, xmm6
movdqa xmm5, xmm6
pandn xmm5, xmm0
por xmm5, xmm4
movdqu xmmword ptr [rax+r8+20h], xmm5
psrlw xmm3, 4
pand xmm3, xmm7
pxor xmm3, xmm8
psubb xmm3, xmm8
psrlw xmm0, 2
pand xmm0, xmm9
pxor xmm0, xmm10
psubb xmm0, xmm10
pand xmm0, xmm11
pand xmm2, xmm6
por xmm2, xmm3
psllw xmm1, 2
pand xmm1, xmm12
por xmm1, xmm2
por xmm1, xmm0
movdqu xmmword ptr [rcx+r8], xmm1
add r8, 10h
cmp r8, 20h ; ' '
jnz loc_311D2
add rax, 40h ; '@'
add rcx, 20h ; ' '
mov esi, 80h
test dl, 1
mov edx, 0
jnz loc_311CC
loc_312A1:
add r12, 400h
inc r14
add rbp, 0D2h
mov rdx, [rsp+1B8h+var_1A0]
cmp r14, rdx
jnz loc_30F28
loc_312C0:
add rsp, 188h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_312D2:
lea rdi, aFabsfFval41943; "fabsf(fval) <= 4194303.f"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aIntNearestIntF; "int nearest_int(float)"
mov edx, 175h
call ___assert_fail
loc_312F1:
lea rdi, aKQkK0; "k % QK_K == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidQuantizeRo_13; "void quantize_row_q6_K_ref(const float "...
mov edx, 655h
call ___assert_fail
| void quantize_row_q6_K_ref(long long a1, long long a2, long long a3)
{
long long v3; // rdx
long long v5; // rbp
long long v6; // r14
_BYTE *v7; // r13
long long v8; // r15
__m128 v9; // xmm0
__m128 v10; // xmm1
__m128 v11; // xmm2
__m128 v12; // xmm3
__m128 v13; // xmm2
long long v14; // r12
float v15; // xmm0_4
__m128i v16; // xmm1
unsigned int v17; // eax
float v18; // xmm1_4
unsigned int v19; // ecx
unsigned int v20; // edx
__m128i v21; // xmm2
unsigned int v22; // edx
int v23; // edx
int v24; // eax
__int16 v25; // dx
long long v26; // rax
long long v27; // rcx
__m128i si128; // xmm8
__m128i v29; // xmm9
__m128i v30; // xmm10
__m128i v31; // xmm11
__m128i v32; // xmm12
__m128i v33; // xmm1
int v34; // edx
char v35; // si
float v36; // xmm0_4
long long v37; // rcx
_BYTE *v38; // rdx
long long i; // rsi
float v40; // xmm1_4
long long v41; // r10
__m128i v42; // xmm2
unsigned int v43; // r8d
long long v44; // rcx
char v45; // dl
long long v46; // rsi
__m128i v47; // xmm6
__m128i v48; // xmm7
_BYTE *v49; // rsi
long long j; // r8
__m128i v51; // xmm3
__m128i v52; // xmm0
__m128i v53; // xmm2
__m128i v54; // xmm1
bool v55; // zf
long long v57; // [rsp+10h] [rbp-1A8h]
long long v58; // [rsp+18h] [rbp-1A0h]
__m128 v59; // [rsp+20h] [rbp-198h]
__m128 v60; // [rsp+30h] [rbp-188h]
_DWORD v61[16]; // [rsp+40h] [rbp-178h]
_BYTE v62[312]; // [rsp+80h] [rbp-138h] BYREF
if ( (_BYTE)a3 )
__assert_fail(
"k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
1621LL,
"void quantize_row_q6_K_ref(const float *restrict, block_q6_K *restrict, int64_t)");
v3 = a3 >> 8;
if ( v3 <= 0 )
return;
v5 = a2 + 192;
v6 = 0LL;
v58 = v3;
do
{
v57 = a1;
v7 = v62;
v8 = 0LL;
v9 = 0LL;
v10 = 0LL;
do
{
v59 = v9;
v60 = v10;
v9.m128_f32[0] = make_qx_quants(16LL, 32LL, a1, v7, 0LL, v9.m128_f32[0], *(double *)v10.m128_u64);
v61[v8] = v9.m128_i32[0];
v11 = _mm_and_ps(v9, (__m128)xmmword_4C020);
v10 = v11;
v10.m128_f32[0] = fmaxf(v11.m128_f32[0], v60.m128_f32[0]);
v12 = _mm_cmplt_ss(v60, v11);
v13 = _mm_or_ps(_mm_andnot_ps(v12, v59), _mm_and_ps(v9, v12));
++v8;
v7 += 16;
a1 += 64LL;
v9 = v13;
}
while ( v8 != 16 );
if ( v10.m128_f32[0] < 1.0e-15 )
{
memset(a2 + 210 * v6, 0LL, 210LL);
v14 = v57;
goto LABEL_31;
}
v15 = -128.0 / v13.m128_f32[0];
v16 = (__m128i)0x3F800000u;
*(float *)v16.m128i_i32 = 1.0 / (float)(-128.0 / v13.m128_f32[0]);
v17 = _mm_cvtsi128_si32(v16);
v18 = (float)(fabs(*(float *)v16.m128i_i32) * 5.1922969e33) * 7.7037198e-34;
v19 = 2 * v17;
v20 = (v17 & 0x7F800000) + 125829120;
if ( 2 * v17 < 0x71000000 )
v20 = 0x40000000;
v21 = _mm_cvtsi32_si128(v20);
*(float *)v21.m128i_i32 = *(float *)v21.m128i_i32 + v18;
v22 = _mm_cvtsi128_si32(v21);
v23 = ((v22 >> 13) & 0x7C00) + (v22 & 0xFFF);
v24 = HIWORD(v17) & 0x8000;
if ( v19 >= 0xFF000001 )
LOWORD(v23) = 32256;
v25 = v24 | v23;
v26 = a2 + 210 * v6;
*(_WORD *)(v26 + 208) = v25;
v27 = 0LL;
v14 = v57;
si128 = _mm_load_si128((const __m128i *)&xmmword_51000);
v29 = _mm_load_si128((const __m128i *)&xmmword_51010);
v30 = _mm_load_si128((const __m128i *)&xmmword_51020);
v31 = _mm_load_si128((const __m128i *)&xmmword_50FA0);
v32 = _mm_load_si128((const __m128i *)&xmmword_50FB0);
do
{
v33 = (__m128i)(unsigned int)v61[v27];
*(float *)v33.m128i_i32 = *(float *)v33.m128i_i32 * v15;
if ( fabs(*(float *)v33.m128i_i32) > 4194303.0 )
goto LABEL_33;
*(float *)v33.m128i_i32 = *(float *)v33.m128i_i32 + 12582912.0;
v34 = _mm_cvtsi128_si32(v33);
v35 = 127;
if ( (v34 & 0x7FFF80u) < 0x400080 )
v35 = v34;
*(_BYTE *)(v5 + v27++) = v35;
}
while ( v27 != 16 );
v36 = ggml_table_f32_f16[*(unsigned __int16 *)(v26 + 208)];
v37 = v57;
v38 = v62;
for ( i = 0LL; i != 16; ++i )
{
v40 = (float)*(char *)(v26 + i + 192) * v36;
if ( v40 != 0.0 )
{
v41 = 0LL;
while ( 1 )
{
v42 = (__m128i)*(unsigned int *)(v37 + 4 * v41);
*(float *)v42.m128i_i32 = *(float *)v42.m128i_i32 / v40;
if ( fabs(*(float *)v42.m128i_i32) > 4194303.0 )
break;
*(float *)v42.m128i_i32 = *(float *)v42.m128i_i32 + 12582912.0;
v43 = _mm_cvtsi128_si32(v42) & 0x7FFFFF;
if ( v43 >= 0x40001F )
v43 = 4194335;
if ( v43 < 0x3FFFE1 )
LOBYTE(v43) = -32;
v38[v41++] = v43 + 32;
if ( v41 == 16 )
goto LABEL_26;
}
LABEL_33:
__assert_fail(
"fabsf(fval) <= 4194303.f",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
373LL,
"int nearest_int(float)");
}
LABEL_26:
v38 += 16;
v37 += 64LL;
}
v44 = v26 + 128;
v45 = 1;
v46 = 0LL;
v47 = _mm_load_si128((const __m128i *)&xmmword_50E50);
v48 = _mm_load_si128((const __m128i *)&xmmword_50FF0);
do
{
v49 = &v62[v46 + 96];
for ( j = 0LL; j != 32; j += 16LL )
{
v51 = _mm_load_si128((const __m128i *)&v49[j - 96]);
v52 = _mm_load_si128((const __m128i *)&v49[j - 64]);
v53 = _mm_load_si128((const __m128i *)&v49[j - 32]);
v54 = _mm_load_si128((const __m128i *)&v49[j]);
*(__m128i *)(v26 + j) = _mm_or_si128(_mm_andnot_si128(v47, v51), _mm_and_si128(_mm_slli_epi16(v53, 4u), v47));
*(__m128i *)(v26 + j + 32) = _mm_or_si128(
_mm_andnot_si128(v47, v52),
_mm_and_si128(_mm_slli_epi16(v54, 4u), v47));
*(__m128i *)(v44 + j) = _mm_or_si128(
_mm_or_si128(
_mm_and_si128(_mm_slli_epi16(v54, 2u), v32),
_mm_or_si128(
_mm_and_si128(v53, v47),
_mm_sub_epi8(
_mm_xor_si128(_mm_and_si128(_mm_srli_epi16(v51, 4u), v48), si128),
si128))),
_mm_and_si128(
_mm_sub_epi8(_mm_xor_si128(_mm_and_si128(_mm_srli_epi16(v52, 2u), v29), v30), v30),
v31));
}
v26 += 64LL;
v44 += 32LL;
v46 = 128LL;
v55 = (v45 & 1) == 0;
v45 = 0;
}
while ( !v55 );
LABEL_31:
a1 = v14 + 1024;
++v6;
v5 += 210LL;
}
while ( v6 != v58 );
}
| quantize_row_q6_K_ref:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x188
MOV qword ptr [RSP + 0x8],RSI
TEST DL,DL
JNZ 0x001312f1
SAR RDX,0x8
TEST RDX,RDX
JLE 0x001312c0
MOV R12,RDI
MOV RAX,qword ptr [RSP + 0x8]
LEA RBP,[RAX + 0xc0]
LEA RBX,[RSP + 0xe0]
XOR R14D,R14D
MOV qword ptr [RSP + 0x18],RDX
LAB_00130f28:
MOV qword ptr [RSP + 0x10],R12
LEA R13,[RSP + 0x80]
XOR R15D,R15D
XORPS XMM0,XMM0
XORPS XMM1,XMM1
LAB_00130f3e:
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM1
MOV EDI,0x10
MOV ESI,0x20
MOV RDX,R12
MOV RCX,R13
XOR R8D,R8D
CALL 0x00131310
MOVAPS XMM4,xmmword ptr [0x0014c020]
MOVSS dword ptr [RSP + R15*0x4 + 0x40],XMM0
MOVAPS XMM2,XMM0
ANDPS XMM2,XMM4
MOVAPS XMM1,XMM2
MOVAPS XMM3,xmmword ptr [RSP + 0x30]
MAXSS XMM1,XMM3
CMPLTSS XMM3,XMM2
MOVAPS XMM2,XMM3
ANDPS XMM0,XMM3
ANDNPS XMM2,xmmword ptr [RSP + 0x20]
ORPS XMM2,XMM0
INC R15
ADD R13,0x10
ADD R12,0x40
MOVAPS XMM0,XMM2
CMP R15,0x10
JNZ 0x00130f3e
MOVSS XMM0,dword ptr [0x001512e4]
UCOMISS XMM0,XMM1
JBE 0x00130fd6
IMUL RDI,R14,0xd2
ADD RDI,qword ptr [RSP + 0x8]
MOV EDX,0xd2
XOR ESI,ESI
CALL 0x001168f0
MOV R12,qword ptr [RSP + 0x10]
JMP 0x001312a1
LAB_00130fd6:
MOVSS XMM0,dword ptr [0x001512fc]
DIVSS XMM0,XMM2
MOVSS XMM1,dword ptr [0x0014c0f0]
DIVSS XMM1,XMM0
MOVD EAX,XMM1
ANDPS XMM1,XMM4
MULSS XMM1,dword ptr [0x0014c0e8]
MULSS XMM1,dword ptr [0x0014c0ec]
LEA ECX,[RAX + RAX*0x1]
MOV EDX,EAX
AND EDX,0x7f800000
ADD EDX,0x7800000
CMP ECX,0x71000000
MOV ESI,0x40000000
CMOVC EDX,ESI
MOVD XMM2,EDX
ADDSS XMM2,XMM1
MOVD EDX,XMM2
MOV ESI,EDX
SHR ESI,0xd
AND ESI,0x7c00
AND EDX,0xfff
ADD EDX,ESI
SHR EAX,0x10
AND EAX,0x8000
CMP ECX,0xff000001
MOV ECX,0x7e00
CMOVNC EDX,ECX
OR EDX,EAX
IMUL RCX,R14,0xd2
MOV RSI,qword ptr [RSP + 0x8]
LEA RAX,[RSI + RCX*0x1]
MOV word ptr [RSI + RCX*0x1 + 0xd0],DX
XOR ECX,ECX
MOV R12,qword ptr [RSP + 0x10]
MOVSS XMM5,dword ptr [0x001512d4]
MOVSS XMM6,dword ptr [0x001512d8]
XORPS XMM7,XMM7
MOVDQA XMM8,xmmword ptr [0x00151000]
MOVDQA XMM9,xmmword ptr [0x00151010]
MOVDQA XMM10,xmmword ptr [0x00151020]
MOVDQA XMM11,xmmword ptr [0x00150fa0]
MOVDQA XMM12,xmmword ptr [0x00150fb0]
LAB_001310ba:
MOVSS XMM1,dword ptr [RSP + RCX*0x4 + 0x40]
MULSS XMM1,XMM0
MOVAPS XMM2,XMM1
ANDPS XMM2,XMM4
UCOMISS XMM5,XMM2
JC 0x001312d2
ADDSS XMM1,XMM6
MOVD EDX,XMM1
MOV R8D,EDX
AND R8D,0x7fff80
MOV ESI,0x7f
CMP R8D,0x400080
JNC 0x001310f5
MOV ESI,EDX
LAB_001310f5:
MOV byte ptr [RBP + RCX*0x1],SIL
INC RCX
CMP RCX,0x10
JNZ 0x001310ba
MOVZX ECX,word ptr [RAX + 0xd0]
MOV RDX,qword ptr [0x0016dfa8]
MOVSS XMM0,dword ptr [RDX + RCX*0x4]
MOV RCX,R12
LEA RDX,[RSP + 0x80]
XOR ESI,ESI
LAB_00131123:
MOVSX R8D,byte ptr [RAX + RSI*0x1 + 0xc0]
XORPS XMM1,XMM1
CVTSI2SS XMM1,R8D
MULSS XMM1,XMM0
UCOMISS XMM1,XMM7
JNZ 0x0013113f
JNP 0x0013119c
LAB_0013113f:
XOR R10D,R10D
LAB_00131142:
MOVSS XMM2,dword ptr [RCX + R10*0x4]
DIVSS XMM2,XMM1
MOVAPS XMM3,XMM2
ANDPS XMM3,XMM4
UCOMISS XMM5,XMM3
JC 0x001312d2
ADDSS XMM2,XMM6
MOVD R8D,XMM2
AND R8D,0x7fffff
MOV R9D,0x40001f
CMP R8D,R9D
JC 0x0013117c
MOV R8D,0x40001f
LAB_0013117c:
CMP R8D,0x3fffe1
JNC 0x0013118b
MOV R8D,0x3fffe0
LAB_0013118b:
ADD R8B,0x20
MOV byte ptr [RDX + R10*0x1],R8B
INC R10
CMP R10,0x10
JNZ 0x00131142
LAB_0013119c:
INC RSI
ADD RDX,0x10
ADD RCX,0x40
CMP RSI,0x10
JNZ 0x00131123
LEA RCX,[RAX + 0x80]
MOV DL,0x1
XOR ESI,ESI
MOVDQA XMM6,xmmword ptr [0x00150e50]
MOVDQA XMM7,xmmword ptr [0x00150ff0]
LAB_001311cc:
ADD RSI,RBX
XOR R8D,R8D
LAB_001311d2:
MOVDQA XMM3,xmmword ptr [RSI + R8*0x1 + -0x60]
MOVDQA XMM0,xmmword ptr [RSI + R8*0x1 + -0x40]
MOVDQA XMM2,xmmword ptr [RSI + R8*0x1 + -0x20]
MOVDQA XMM1,xmmword ptr [RSI + R8*0x1]
MOVDQA XMM4,XMM2
PSLLW XMM4,0x4
PAND XMM4,XMM6
MOVDQA XMM5,XMM6
PANDN XMM5,XMM3
POR XMM5,XMM4
MOVDQU xmmword ptr [RAX + R8*0x1],XMM5
MOVDQA XMM4,XMM1
PSLLW XMM4,0x4
PAND XMM4,XMM6
MOVDQA XMM5,XMM6
PANDN XMM5,XMM0
POR XMM5,XMM4
MOVDQU xmmword ptr [RAX + R8*0x1 + 0x20],XMM5
PSRLW XMM3,0x4
PAND XMM3,XMM7
PXOR XMM3,XMM8
PSUBB XMM3,XMM8
PSRLW XMM0,0x2
PAND XMM0,XMM9
PXOR XMM0,XMM10
PSUBB XMM0,XMM10
PAND XMM0,XMM11
PAND XMM2,XMM6
POR XMM2,XMM3
PSLLW XMM1,0x2
PAND XMM1,XMM12
POR XMM1,XMM2
POR XMM1,XMM0
MOVDQU xmmword ptr [RCX + R8*0x1],XMM1
ADD R8,0x10
CMP R8,0x20
JNZ 0x001311d2
ADD RAX,0x40
ADD RCX,0x20
MOV ESI,0x80
TEST DL,0x1
MOV EDX,0x0
JNZ 0x001311cc
LAB_001312a1:
ADD R12,0x400
INC R14
ADD RBP,0xd2
MOV RDX,qword ptr [RSP + 0x18]
CMP R14,RDX
JNZ 0x00130f28
LAB_001312c0:
ADD RSP,0x188
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001312d2:
LEA RDI,[0x15cbdf]
LEA RSI,[0x15bcf4]
LEA RCX,[0x15cbf8]
MOV EDX,0x175
CALL 0x00116b00
LAB_001312f1:
LEA RDI,[0x15c0dc]
LEA RSI,[0x15bcf4]
LEA RCX,[0x15c36a]
MOV EDX,0x655
CALL 0x00116b00
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void quantize_row_q6_K_ref(long param_1,long param_2,long param_3)
{
int1 auVar1 [16];
int1 auVar2 [16];
uint uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
int1 auVar9 [16];
int1 auVar10 [16];
bool bVar11;
bool bVar12;
ushort uVar13;
float fVar14;
long lVar15;
long lVar16;
uint uVar17;
long lVar18;
long lVar19;
int1 *puVar20;
long lVar21;
long lVar22;
float fVar23;
float fVar24;
int1 auVar25 [16];
float fVar26;
float fVar27;
int1 auVar28 [16];
int1 auVar29 [16];
int1 auVar30 [16];
float afStack_178 [16];
int1 local_138 [32];
int1 auStack_118 [32];
int1 auStack_f8 [32];
int1 local_d8 [168];
if ((char)param_3 != '\0') {
/* WARNING: Subroutine does not return */
__assert_fail("k % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x655,
"void quantize_row_q6_K_ref(const float *restrict, block_q6_K *restrict, int64_t)"
);
}
if (0 < param_3 >> 8) {
lVar15 = param_2 + 0xc0;
lVar21 = 0;
do {
puVar20 = local_138;
lVar22 = 0;
fVar24 = 0.0;
lVar19 = param_1;
fVar14 = 0.0;
do {
fVar23 = (float)make_qx_quants(0x10,0x20,lVar19,puVar20,0);
uVar3 = _DAT_0014c020;
afStack_178[lVar22] = fVar23;
fVar27 = (float)((uint)fVar23 & _DAT_0014c020);
fVar26 = fVar27;
if (fVar27 <= fVar14) {
fVar26 = fVar14;
}
fVar24 = (float)(~-(uint)(fVar14 < fVar27) & (uint)fVar24 |
(uint)fVar23 & -(uint)(fVar14 < fVar27));
lVar22 = lVar22 + 1;
puVar20 = puVar20 + 0x10;
lVar19 = lVar19 + 0x40;
fVar14 = fVar26;
} while (lVar22 != 0x10);
if (DAT_001512e4 <= fVar26) {
fVar24 = DAT_001512fc / fVar24;
fVar26 = DAT_0014c0f0 / fVar24;
fVar14 = (float)(((uint)fVar26 & 0x7f800000) + 0x7800000);
if ((uint)((int)fVar26 * 2) < 0x71000000) {
fVar14 = 2.0;
}
fVar14 = fVar14 + (float)((uint)fVar26 & _DAT_0014c020) * DAT_0014c0e8 * DAT_0014c0ec;
uVar13 = (SUB42(fVar14,0) & 0xfff) + ((ushort)((uint)fVar14 >> 0xd) & 0x7c00);
if (0xff000000 < (uint)((int)fVar26 * 2)) {
uVar13 = 0x7e00;
}
lVar19 = param_2 + lVar21 * 0xd2;
*(ushort *)(param_2 + 0xd0 + lVar21 * 0xd2) =
uVar13 | (ushort)((uint)fVar26 >> 0x10) & 0x8000;
fVar26 = DAT_001512d8;
fVar14 = DAT_001512d4;
auVar10 = _DAT_00151020;
auVar9 = _DAT_00151010;
auVar8 = _DAT_00151000;
auVar6 = _DAT_00150fb0;
auVar5 = _DAT_00150fa0;
lVar22 = 0;
do {
fVar23 = afStack_178[lVar22] * fVar24;
if (fVar14 < (float)((uint)fVar23 & uVar3)) {
LAB_001312d2:
/* WARNING: Subroutine does not return */
__assert_fail("fabsf(fval) <= 4194303.f",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x175,"int nearest_int(float)");
}
fVar23 = fVar23 + fVar26;
fVar27 = 1.77965e-43;
if (((uint)fVar23 & 0x7fff80) < 0x400080) {
fVar27 = fVar23;
}
*(char *)(lVar15 + lVar22) = SUB41(fVar27,0);
auVar7 = _DAT_00150ff0;
auVar4 = _DAT_00150e50;
lVar22 = lVar22 + 1;
} while (lVar22 != 0x10);
fVar24 = *(float *)(PTR_ggml_table_f32_f16_0016dfa8 + (ulong)*(ushort *)(lVar19 + 0xd0) * 4)
;
puVar20 = local_138;
lVar16 = 0;
lVar22 = param_1;
do {
fVar23 = (float)(int)*(char *)(lVar19 + 0xc0 + lVar16) * fVar24;
if ((fVar23 != 0.0) || (NAN(fVar23))) {
lVar18 = 0;
do {
fVar27 = *(float *)(lVar22 + lVar18 * 4) / fVar23;
if (fVar14 < (float)((uint)fVar27 & uVar3)) goto LAB_001312d2;
uVar17 = (uint)(fVar27 + fVar26) & 0x7fffff;
if (0x40001e < uVar17) {
uVar17 = 0x40001f;
}
if (uVar17 < 0x3fffe1) {
uVar17 = 0x3fffe0;
}
puVar20[lVar18] = (char)uVar17 + ' ';
lVar18 = lVar18 + 1;
} while (lVar18 != 0x10);
}
lVar16 = lVar16 + 1;
puVar20 = puVar20 + 0x10;
lVar22 = lVar22 + 0x40;
} while (lVar16 != 0x10);
lVar22 = lVar19 + 0x80;
lVar16 = 0;
bVar11 = true;
do {
bVar12 = bVar11;
lVar18 = 0;
do {
auVar28 = *(int1 (*) [16])(local_138 + lVar18 + lVar16);
auVar25 = *(int1 (*) [16])(auStack_118 + lVar18 + lVar16);
auVar1 = *(int1 (*) [16])(auStack_f8 + lVar18 + lVar16);
auVar2 = *(int1 (*) [16])(local_d8 + lVar18 + lVar16);
auVar30 = psllw(auVar1,4);
*(int1 (*) [16])(lVar19 + lVar18) = ~auVar4 & auVar28 | auVar30 & auVar4;
auVar30 = psllw(auVar2,4);
*(int1 (*) [16])(lVar19 + 0x20 + lVar18) = ~auVar4 & auVar25 | auVar30 & auVar4;
auVar30._0_2_ = auVar28._0_2_ >> 4;
auVar30._2_2_ = auVar28._2_2_ >> 4;
auVar30._4_2_ = auVar28._4_2_ >> 4;
auVar30._6_2_ = auVar28._6_2_ >> 4;
auVar30._8_2_ = auVar28._8_2_ >> 4;
auVar30._10_2_ = auVar28._10_2_ >> 4;
auVar30._12_2_ = auVar28._12_2_ >> 4;
auVar30._14_2_ = auVar28._14_2_ >> 4;
auVar28 = auVar30 & auVar7 ^ auVar8;
auVar29[0] = auVar28[0] - auVar8[0];
auVar29[1] = auVar28[1] - auVar8[1];
auVar29[2] = auVar28[2] - auVar8[2];
auVar29[3] = auVar28[3] - auVar8[3];
auVar29[4] = auVar28[4] - auVar8[4];
auVar29[5] = auVar28[5] - auVar8[5];
auVar29[6] = auVar28[6] - auVar8[6];
auVar29[7] = auVar28[7] - auVar8[7];
auVar29[8] = auVar28[8] - auVar8[8];
auVar29[9] = auVar28[9] - auVar8[9];
auVar29[10] = auVar28[10] - auVar8[10];
auVar29[0xb] = auVar28[0xb] - auVar8[0xb];
auVar29[0xc] = auVar28[0xc] - auVar8[0xc];
auVar29[0xd] = auVar28[0xd] - auVar8[0xd];
auVar29[0xe] = auVar28[0xe] - auVar8[0xe];
auVar29[0xf] = auVar28[0xf] - auVar8[0xf];
auVar28._0_2_ = auVar25._0_2_ >> 2;
auVar28._2_2_ = auVar25._2_2_ >> 2;
auVar28._4_2_ = auVar25._4_2_ >> 2;
auVar28._6_2_ = auVar25._6_2_ >> 2;
auVar28._8_2_ = auVar25._8_2_ >> 2;
auVar28._10_2_ = auVar25._10_2_ >> 2;
auVar28._12_2_ = auVar25._12_2_ >> 2;
auVar28._14_2_ = auVar25._14_2_ >> 2;
auVar28 = auVar28 & auVar9 ^ auVar10;
auVar25[0] = auVar28[0] - auVar10[0];
auVar25[1] = auVar28[1] - auVar10[1];
auVar25[2] = auVar28[2] - auVar10[2];
auVar25[3] = auVar28[3] - auVar10[3];
auVar25[4] = auVar28[4] - auVar10[4];
auVar25[5] = auVar28[5] - auVar10[5];
auVar25[6] = auVar28[6] - auVar10[6];
auVar25[7] = auVar28[7] - auVar10[7];
auVar25[8] = auVar28[8] - auVar10[8];
auVar25[9] = auVar28[9] - auVar10[9];
auVar25[10] = auVar28[10] - auVar10[10];
auVar25[0xb] = auVar28[0xb] - auVar10[0xb];
auVar25[0xc] = auVar28[0xc] - auVar10[0xc];
auVar25[0xd] = auVar28[0xd] - auVar10[0xd];
auVar25[0xe] = auVar28[0xe] - auVar10[0xe];
auVar25[0xf] = auVar28[0xf] - auVar10[0xf];
auVar28 = psllw(auVar2,2);
*(int1 (*) [16])(lVar22 + lVar18) =
auVar28 & auVar6 | auVar1 & auVar4 | auVar29 | auVar25 & auVar5;
lVar18 = lVar18 + 0x10;
} while (lVar18 != 0x20);
lVar19 = lVar19 + 0x40;
lVar22 = lVar22 + 0x20;
lVar16 = 0x80;
bVar11 = false;
} while (bVar12);
}
else {
memset((void *)(lVar21 * 0xd2 + param_2),0,0xd2);
}
param_1 = param_1 + 0x400;
lVar21 = lVar21 + 1;
lVar15 = lVar15 + 0xd2;
} while (lVar21 != param_3 >> 8);
}
return;
}
| |
50,670 | find_or_create_user(PFS_thread*, char const*, unsigned int) | eloqsql/storage/perfschema/pfs_user.cc | PFS_user *
find_or_create_user(PFS_thread *thread,
const char *username, uint username_length)
{
LF_PINS *pins= get_user_hash_pins(thread);
if (unlikely(pins == NULL))
{
global_user_container.m_lost++;
return NULL;
}
PFS_user_key key;
set_user_key(&key, username, username_length);
PFS_user **entry;
PFS_user *pfs;
uint retry_count= 0;
const uint retry_max= 3;
pfs_dirty_state dirty_state;
search:
entry= reinterpret_cast<PFS_user**>
(lf_hash_search(&user_hash, pins,
key.m_hash_key, key.m_key_length));
if (entry && (entry != MY_ERRPTR))
{
pfs= *entry;
pfs->inc_refcount();
lf_hash_search_unpin(pins);
return pfs;
}
lf_hash_search_unpin(pins);
pfs= global_user_container.allocate(& dirty_state);
if (pfs != NULL)
{
pfs->m_key= key;
if (username_length > 0)
pfs->m_username= &pfs->m_key.m_hash_key[0];
else
pfs->m_username= NULL;
pfs->m_username_length= username_length;
pfs->init_refcount();
pfs->reset_stats();
pfs->m_disconnected_count= 0;
int res;
pfs->m_lock.dirty_to_allocated(& dirty_state);
res= lf_hash_insert(&user_hash, pins, &pfs);
if (likely(res == 0))
{
return pfs;
}
global_user_container.deallocate(pfs);
if (res > 0)
{
if (++retry_count > retry_max)
{
global_user_container.m_lost++;
return NULL;
}
goto search;
}
global_user_container.m_lost++;
return NULL;
}
return NULL;
} | O3 | cpp | find_or_create_user(PFS_thread*, char const*, unsigned int):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movl %edx, %r13d
movq %rsi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x830(%rdi), %r14
testq %r14, %r14
je 0x40da9
testl %r13d, %r13d
je 0x40bfa
movl %r13d, %r12d
leaq -0x1b8(%rbp), %rdi
movl $0x188, %ecx # imm = 0x188
movq %r15, %rsi
movq %r12, %rdx
callq 0x265e0
leaq (%r12,%rbp), %rax
addq $-0x1b8, %rax # imm = 0xFE48
jmp 0x40c01
leaq -0x1b8(%rbp), %rax
movb $0x0, (%rax)
leaq -0x1b8(%rbp), %r12
subl %r12d, %eax
incl %eax
movl %eax, 0x184(%r12)
movl $0x4, %ebx
leaq 0x394d3c(%rip), %rdi # 0x3d5960
xorl %r15d, %r15d
movl -0x34(%rbp), %ecx
movq %r14, %rsi
movq %r12, %rdx
callq 0x2c452
cmpq $0x2, %rax
jae 0x40d89
movl %r13d, -0x1c4(%rbp)
xorl %eax, %eax
xchgq %rax, 0x10(%r14)
leaq 0x38b525(%rip), %rdi # 0x3cc178
leaq -0x1c8(%rbp), %rsi
callq 0x4111a
movq %rax, -0x1c0(%rbp)
testq %rax, %rax
je 0x40d65
movq %rax, %r13
movq %r12, %r15
leaq 0x7e4(%rax), %r12
movl $0x188, %edx # imm = 0x188
movq %r12, %rdi
movq %r15, %rsi
callq 0x26290
movl -0x1c4(%rbp), %ecx
testl %ecx, %ecx
movl $0x0, %eax
cmovneq %r12, %rax
movq %rax, 0x970(%r13)
movl %ecx, 0x978(%r13)
movl $0x1, %eax
xchgl %eax, 0x988(%r13)
movq %r13, %rdi
addq $0x30, %rdi
movb $0x0, 0x4(%r13)
movl $0x0, (%r13)
callq 0x402d8
movq -0x1c0(%rbp), %rax
movq $0x0, 0x980(%rax)
movl -0x1c8(%rbp), %ecx
andl $-0x4, %ecx
addl $0x6, %ecx
xchgl %ecx, 0x7e0(%rax)
leaq 0x394c65(%rip), %rdi # 0x3d5960
movq %r14, %rsi
leaq -0x1c0(%rbp), %rdx
callq 0x2bbf3
movq -0x1c0(%rbp), %rcx
testl %eax, %eax
je 0x40d62
movq 0x7d8(%rcx), %rdx
movl 0x7e0(%rcx), %esi
andl $-0x4, %esi
xchgl %esi, 0x7e0(%rcx)
xorl %ecx, %ecx
movb %cl, (%rdx)
leaq 0x38b442(%rip), %rdx # 0x3cc178
movb %cl, 0x9(%rdx)
testl %eax, %eax
jle 0x40dce
decl %ebx
movq %r15, %r12
movl $0x0, %r15d
movl -0x1c4(%rbp), %r13d
leaq 0x394c06(%rip), %rdi # 0x3d5960
jne 0x40c27
jmp 0x40dce
movq %rcx, %r15
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x40ddd
movq %r15, %rax
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rax), %rax
movq %rax, -0x1c0(%rbp)
lock
incl 0x988(%rax)
xorl %eax, %eax
xchgq %rax, 0x10(%r14)
movq -0x1c0(%rbp), %r15
jmp 0x40d65
cmpb $0x1, 0x394c78(%rip) # 0x3d5a28
jne 0x40dce
movq %rdi, %r12
leaq 0x394bcc(%rip), %rdi # 0x3d5988
callq 0x2ba18
movq %rax, 0x830(%r12)
testq %rax, %rax
jne 0x40de2
leaq 0x38b3a3(%rip), %rax # 0x3cc178
incq (%rax)
xorl %r15d, %r15d
jmp 0x40d65
callq 0x263a0
movq %rax, %r14
jmp 0x40bcf
| _Z19find_or_create_userP10PFS_threadPKcj:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1A8h
mov r13d, edx
mov r15, rsi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r14, [rdi+830h]
test r14, r14
jz loc_40DA9
loc_40BCF:
test r13d, r13d
jz short loc_40BFA
mov r12d, r13d
lea rdi, [rbp+var_1B8]
mov ecx, 188h
mov rsi, r15
mov rdx, r12
call ___memcpy_chk
lea rax, [r12+rbp]
add rax, 0FFFFFFFFFFFFFE48h
jmp short loc_40C01
loc_40BFA:
lea rax, [rbp+var_1B8]
loc_40C01:
mov byte ptr [rax], 0
lea r12, [rbp+var_1B8]
sub eax, r12d
inc eax
mov [r12+184h], eax
mov ebx, 4
lea rdi, user_hash
xor r15d, r15d
loc_40C27:
mov ecx, [rbp+var_34]
mov rsi, r14
mov rdx, r12
call lf_hash_search
cmp rax, 2
jnb loc_40D89
mov [rbp+var_1C4], r13d
xor eax, eax
xchg rax, [r14+10h]
lea rdi, global_user_container
lea rsi, [rbp+var_1C8]
call _ZN29PFS_buffer_scalable_containerI8PFS_userLi128ELi128E14PFS_user_array18PFS_user_allocatorE8allocateEP15pfs_dirty_state; PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator>::allocate(pfs_dirty_state *)
mov [rbp+var_1C0], rax
test rax, rax
jz loc_40D65
mov r13, rax
mov r15, r12
lea r12, [rax+7E4h]
mov edx, 188h
mov rdi, r12
mov rsi, r15
call _memcpy
mov ecx, [rbp+var_1C4]
test ecx, ecx
mov eax, 0
cmovnz rax, r12
mov [r13+970h], rax
mov [r13+978h], ecx
mov eax, 1
xchg eax, [r13+988h]
mov rdi, r13
add rdi, 30h ; '0'; this
mov byte ptr [r13+4], 0
mov dword ptr [r13+0], 0
call _ZN16PFS_status_stats5resetEv; PFS_status_stats::reset(void)
mov rax, [rbp+var_1C0]
mov qword ptr [rax+980h], 0
mov ecx, [rbp+var_1C8]
and ecx, 0FFFFFFFCh
add ecx, 6
xchg ecx, [rax+7E0h]
lea rdi, user_hash
mov rsi, r14
lea rdx, [rbp+var_1C0]
call lf_hash_insert
mov rcx, [rbp+var_1C0]
test eax, eax
jz short loc_40D62
mov rdx, [rcx+7D8h]
mov esi, [rcx+7E0h]
and esi, 0FFFFFFFCh
xchg esi, [rcx+7E0h]
xor ecx, ecx
mov [rdx], cl
lea rdx, global_user_container
mov [rdx+9], cl
test eax, eax
jle loc_40DCE
dec ebx
mov r12, r15
mov r15d, 0
mov r13d, [rbp+var_1C4]
lea rdi, user_hash
jnz loc_40C27
jmp short loc_40DCE
loc_40D62:
mov r15, rcx
loc_40D65:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_40DDD
mov rax, r15
add rsp, 1A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_40D89:
mov rax, [rax]
mov [rbp+var_1C0], rax
lock inc dword ptr [rax+988h]
xor eax, eax
xchg rax, [r14+10h]
mov r15, [rbp+var_1C0]
jmp short loc_40D65
loc_40DA9:
cmp cs:_ZL16user_hash_inited, 1; user_hash_inited
jnz short loc_40DCE
mov r12, rdi
lea rdi, unk_3D5988
call lf_pinbox_get_pins
mov [r12+830h], rax
test rax, rax
jnz short loc_40DE2
loc_40DCE:
lea rax, global_user_container
inc qword ptr [rax]
xor r15d, r15d
jmp short loc_40D65
loc_40DDD:
call ___stack_chk_fail
loc_40DE2:
mov r14, rax
jmp loc_40BCF
| long long find_or_create_user(PFS_thread *a1, const char *a2, unsigned int a3)
{
volatile long long *v4; // r14
_BYTE *v5; // rax
_BYTE *v6; // r12
int v7; // ebx
long long v8; // r15
long long *v9; // rax
long long v10; // rax
long long v11; // r13
_BYTE *v12; // r15
long long v13; // r12
int v14; // ecx
long long v15; // rax
long long v16; // rax
int v17; // eax
_BYTE *v18; // rdx
long long pins; // rax
int v21; // [rsp+8h] [rbp-1C8h] BYREF
int v22; // [rsp+Ch] [rbp-1C4h]
long long v23; // [rsp+10h] [rbp-1C0h] BYREF
_BYTE v24[388]; // [rsp+18h] [rbp-1B8h] BYREF
unsigned int v25; // [rsp+19Ch] [rbp-34h]
unsigned long long v26; // [rsp+1A0h] [rbp-30h]
v26 = __readfsqword(0x28u);
v4 = (volatile long long *)*((_QWORD *)a1 + 262);
if ( !v4 )
{
if ( user_hash_inited != 1
|| (pins = lf_pinbox_get_pins((long long)&unk_3D5988), (*((_QWORD *)a1 + 262) = pins) == 0LL) )
{
LABEL_19:
++global_user_container[0];
return 0LL;
}
v4 = (volatile long long *)pins;
}
if ( a3 )
{
__memcpy_chk(v24, a2, a3, 392LL);
v5 = &v24[a3];
}
else
{
v5 = v24;
}
*v5 = 0;
v6 = v24;
v25 = (_DWORD)v5 - (unsigned int)v24 + 1;
v7 = 4;
v8 = 0LL;
while ( 1 )
{
v9 = (long long *)lf_hash_search((long long)&user_hash, v4, (long long)v6, v25);
if ( (unsigned long long)v9 >= 2 )
break;
v22 = a3;
_InterlockedExchange64(v4 + 2, 0LL);
v10 = PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator>::allocate(
global_user_container,
&v21);
v23 = v10;
if ( !v10 )
return v8;
v11 = v10;
v12 = v6;
v13 = v10 + 2020;
memcpy(v10 + 2020, v12, 392LL);
v14 = v22;
v15 = 0LL;
if ( v22 )
v15 = v13;
*(_QWORD *)(v11 + 2416) = v15;
*(_DWORD *)(v11 + 2424) = v14;
_InterlockedExchange((volatile __int32 *)(v11 + 2440), 1);
*(_BYTE *)(v11 + 4) = 0;
*(_DWORD *)v11 = 0;
PFS_status_stats::reset((PFS_status_stats *)(v11 + 48));
v16 = v23;
*(_QWORD *)(v23 + 2432) = 0LL;
_InterlockedExchange((volatile __int32 *)(v16 + 2016), (v21 & 0xFFFFFFFC) + 6);
v17 = lf_hash_insert((long long)&user_hash, (long long)v4, (long long)&v23);
if ( !v17 )
return v23;
v18 = *(_BYTE **)(v23 + 2008);
_InterlockedExchange((volatile __int32 *)(v23 + 2016), *(_DWORD *)(v23 + 2016) & 0xFFFFFFFC);
*v18 = 0;
BYTE1(global_user_container[1]) = 0;
if ( v17 > 0 )
{
--v7;
v6 = v12;
v8 = 0LL;
a3 = v22;
if ( v7 )
continue;
}
goto LABEL_19;
}
v23 = *v9;
_InterlockedIncrement((volatile signed __int32 *)(v23 + 2440));
_InterlockedExchange64(v4 + 2, 0LL);
return v23;
}
| find_or_create_user:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1a8
MOV R13D,EDX
MOV R15,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R14,qword ptr [RDI + 0x830]
TEST R14,R14
JZ 0x00140da9
LAB_00140bcf:
TEST R13D,R13D
JZ 0x00140bfa
MOV R12D,R13D
LEA RDI,[RBP + -0x1b8]
MOV ECX,0x188
MOV RSI,R15
MOV RDX,R12
CALL 0x001265e0
LEA RAX,[R12 + RBP*0x1]
ADD RAX,-0x1b8
JMP 0x00140c01
LAB_00140bfa:
LEA RAX,[RBP + -0x1b8]
LAB_00140c01:
MOV byte ptr [RAX],0x0
LEA R12,[RBP + -0x1b8]
SUB EAX,R12D
INC EAX
MOV dword ptr [R12 + 0x184],EAX
MOV EBX,0x4
LEA RDI,[0x4d5960]
XOR R15D,R15D
LAB_00140c27:
MOV ECX,dword ptr [RBP + -0x34]
MOV RSI,R14
MOV RDX,R12
CALL 0x0012c452
CMP RAX,0x2
JNC 0x00140d89
MOV dword ptr [RBP + -0x1c4],R13D
XOR EAX,EAX
XCHG qword ptr [R14 + 0x10],RAX
LEA RDI,[0x4cc178]
LEA RSI,[RBP + -0x1c8]
CALL 0x0014111a
MOV qword ptr [RBP + -0x1c0],RAX
TEST RAX,RAX
JZ 0x00140d65
MOV R13,RAX
MOV R15,R12
LEA R12,[RAX + 0x7e4]
MOV EDX,0x188
MOV RDI,R12
MOV RSI,R15
CALL 0x00126290
MOV ECX,dword ptr [RBP + -0x1c4]
TEST ECX,ECX
MOV EAX,0x0
CMOVNZ RAX,R12
MOV qword ptr [R13 + 0x970],RAX
MOV dword ptr [R13 + 0x978],ECX
MOV EAX,0x1
XCHG dword ptr [R13 + 0x988],EAX
MOV RDI,R13
ADD RDI,0x30
MOV byte ptr [R13 + 0x4],0x0
MOV dword ptr [R13],0x0
CALL 0x001402d8
MOV RAX,qword ptr [RBP + -0x1c0]
MOV qword ptr [RAX + 0x980],0x0
MOV ECX,dword ptr [RBP + -0x1c8]
AND ECX,0xfffffffc
ADD ECX,0x6
XCHG dword ptr [RAX + 0x7e0],ECX
LEA RDI,[0x4d5960]
MOV RSI,R14
LEA RDX,[RBP + -0x1c0]
CALL 0x0012bbf3
MOV RCX,qword ptr [RBP + -0x1c0]
TEST EAX,EAX
JZ 0x00140d62
MOV RDX,qword ptr [RCX + 0x7d8]
MOV ESI,dword ptr [RCX + 0x7e0]
AND ESI,0xfffffffc
XCHG dword ptr [RCX + 0x7e0],ESI
XOR ECX,ECX
MOV byte ptr [RDX],CL
LEA RDX,[0x4cc178]
MOV byte ptr [RDX + 0x9],CL
TEST EAX,EAX
JLE 0x00140dce
DEC EBX
MOV R12,R15
MOV R15D,0x0
MOV R13D,dword ptr [RBP + -0x1c4]
LEA RDI,[0x4d5960]
JNZ 0x00140c27
JMP 0x00140dce
LAB_00140d62:
MOV R15,RCX
LAB_00140d65:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00140ddd
MOV RAX,R15
ADD RSP,0x1a8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00140d89:
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x1c0],RAX
INC.LOCK dword ptr [RAX + 0x988]
XOR EAX,EAX
XCHG qword ptr [R14 + 0x10],RAX
MOV R15,qword ptr [RBP + -0x1c0]
JMP 0x00140d65
LAB_00140da9:
CMP byte ptr [0x004d5a28],0x1
JNZ 0x00140dce
MOV R12,RDI
LEA RDI,[0x4d5988]
CALL 0x0012ba18
MOV qword ptr [R12 + 0x830],RAX
TEST RAX,RAX
JNZ 0x00140de2
LAB_00140dce:
LEA RAX,[0x4cc178]
INC qword ptr [RAX]
XOR R15D,R15D
JMP 0x00140d65
LAB_00140ddd:
CALL 0x001263a0
LAB_00140de2:
MOV R14,RAX
JMP 0x00140bcf
|
/* find_or_create_user(PFS_thread*, char const*, unsigned int) */
int4 * find_or_create_user(PFS_thread *param_1,char *param_2,uint param_3)
{
int iVar1;
int1 *puVar2;
int8 *puVar3;
int4 *puVar4;
int4 *puVar5;
long lVar6;
int iVar7;
long in_FS_OFFSET;
uint local_1d0;
uint local_1cc;
int4 *local_1c8;
int1 local_1c0 [388];
int local_3c;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar6 = *(long *)(param_1 + 0x830);
if (lVar6 == 0) {
if (user_hash_inited != '\x01') goto LAB_00140dce;
lVar6 = lf_pinbox_get_pins(0x4d5988);
*(long *)(param_1 + 0x830) = lVar6;
if (lVar6 == 0) goto LAB_00140dce;
}
if (param_3 == 0) {
puVar2 = local_1c0;
}
else {
__memcpy_chk(local_1c0,param_2,(ulong)param_3,0x188);
puVar2 = local_1c0 + param_3;
}
*puVar2 = 0;
local_3c = ((int)puVar2 - (int)local_1c0) + 1;
iVar7 = 4;
do {
puVar3 = (int8 *)lf_hash_search(user_hash,lVar6,local_1c0,local_3c);
if ((int8 *)0x1 < puVar3) {
local_1c8 = (int4 *)*puVar3;
LOCK();
local_1c8[0x262] = local_1c8[0x262] + 1;
UNLOCK();
LOCK();
*(int8 *)(lVar6 + 0x10) = 0;
UNLOCK();
puVar5 = local_1c8;
goto LAB_00140d65;
}
LOCK();
*(int8 *)(lVar6 + 0x10) = 0;
UNLOCK();
local_1cc = param_3;
puVar4 = (int4 *)
PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator>::
allocate((PFS_buffer_scalable_container<PFS_user,128,128,PFS_user_array,PFS_user_allocator>
*)&global_user_container,(pfs_dirty_state *)&local_1d0);
puVar5 = (int4 *)0x0;
local_1c8 = puVar4;
if (puVar4 == (int4 *)0x0) goto LAB_00140d65;
memcpy(puVar4 + 0x1f9,local_1c0,0x188);
puVar5 = (int4 *)0x0;
if (local_1cc != 0) {
puVar5 = puVar4 + 0x1f9;
}
*(int4 **)(puVar4 + 0x25c) = puVar5;
puVar4[0x25e] = local_1cc;
LOCK();
puVar4[0x262] = 1;
UNLOCK();
*(int1 *)(puVar4 + 1) = 0;
*puVar4 = 0;
PFS_status_stats::reset((PFS_status_stats *)(puVar4 + 0xc));
*(int8 *)(local_1c8 + 0x260) = 0;
LOCK();
iVar1 = local_1c8[0x1f8];
local_1c8[0x1f8] = (local_1d0 & 0xfffffffc) + 6;
UNLOCK();
iVar1 = lf_hash_insert(user_hash,lVar6,&local_1c8,iVar1);
puVar5 = local_1c8;
if (iVar1 == 0) goto LAB_00140d65;
LOCK();
local_1c8[0x1f8] = local_1c8[0x1f8] & 0xfffffffc;
UNLOCK();
**(int1 **)(local_1c8 + 0x1f6) = 0;
DAT_004cc181 = 0;
} while ((0 < iVar1) && (iVar7 = iVar7 + -1, param_3 = local_1cc, iVar7 != 0));
LAB_00140dce:
global_user_container = global_user_container + 1;
puVar5 = (int4 *)0x0;
LAB_00140d65:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return puVar5;
}
| |
50,671 | init_simple_key_cache | eloqsql/mysys/mf_keycache.c | static
int init_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)
{
size_t blocks, hash_links;
size_t length;
int error;
DBUG_ENTER("init_simple_key_cache");
DBUG_ASSERT(key_cache_block_size >= 512);
KEYCACHE_DEBUG_OPEN;
if (keycache->key_cache_inited && keycache->disk_blocks > 0)
{
DBUG_PRINT("warning",("key cache already in use"));
DBUG_RETURN(0);
}
keycache->blocks_used= keycache->blocks_unused= 0;
keycache->global_blocks_changed= 0;
keycache->global_cache_w_requests= keycache->global_cache_r_requests= 0;
keycache->global_cache_read= keycache->global_cache_write= 0;
keycache->disk_blocks= -1;
if (! keycache->key_cache_inited)
{
keycache->key_cache_inited= 1;
keycache->hash_factor= 1;
/*
Initialize these variables once only.
Their value must survive re-initialization during resizing.
*/
keycache->in_resize= 0;
keycache->resize_in_flush= 0;
keycache->cnt_for_resize_op= 0;
keycache->waiting_for_resize_cnt.last_thread= NULL;
keycache->in_init= 0;
mysql_mutex_init(key_KEY_CACHE_cache_lock,
&keycache->cache_lock, MY_MUTEX_INIT_FAST);
keycache->resize_queue.last_thread= NULL;
}
keycache->key_cache_mem_size= use_mem;
keycache->key_cache_block_size= key_cache_block_size;
DBUG_PRINT("info", ("key_cache_block_size: %u",
key_cache_block_size));
blocks= use_mem / (sizeof(BLOCK_LINK) + 2 * sizeof(HASH_LINK) +
sizeof(HASH_LINK*) * 5/4 + key_cache_block_size);
/* Changed blocks hash needs to be a power of 2 */
changed_blocks_hash_size= my_round_up_to_next_power(MY_MAX(changed_blocks_hash_size,
MIN_CHANGED_BLOCKS_HASH_SIZE));
/* It doesn't make sense to have too few blocks (less than 8) */
if (blocks >= 8)
{
for ( ; ; )
{
/* Set my_hash_entries to the next bigger 2 power */
if ((keycache->hash_entries= next_power((uint)blocks)) < blocks * 5/4)
keycache->hash_entries<<= 1;
hash_links= 2 * blocks;
#if defined(MAX_THREADS)
if (hash_links < MAX_THREADS + blocks - 1)
hash_links= MAX_THREADS + blocks - 1;
#endif
while ((length= (ALIGN_SIZE(blocks * sizeof(BLOCK_LINK)) +
ALIGN_SIZE(hash_links * sizeof(HASH_LINK)) +
ALIGN_SIZE(sizeof(HASH_LINK*) *
keycache->hash_entries) +
sizeof(BLOCK_LINK*)* ((size_t)changed_blocks_hash_size*2))) +
(blocks * keycache->key_cache_block_size) > use_mem && blocks > 8)
blocks--;
keycache->allocated_mem_size= blocks * keycache->key_cache_block_size;
if ((keycache->block_mem= my_large_malloc(&keycache->allocated_mem_size,
MYF(0))))
{
/*
Allocate memory for blocks, hash_links and hash entries;
For each block 2 hash links are allocated
*/
if (my_multi_malloc_large(key_memory_KEY_CACHE, MYF(MY_ZEROFILL),
&keycache->block_root,
(ulonglong) (blocks * sizeof(BLOCK_LINK)),
&keycache->hash_root,
(ulonglong) (sizeof(HASH_LINK*) *
keycache->hash_entries),
&keycache->hash_link_root,
(ulonglong) (hash_links * sizeof(HASH_LINK)),
&keycache->changed_blocks,
(ulonglong) (sizeof(BLOCK_LINK*) *
changed_blocks_hash_size),
&keycache->file_blocks,
(ulonglong) (sizeof(BLOCK_LINK*) *
changed_blocks_hash_size),
NullS))
break;
my_large_free(keycache->block_mem, keycache->allocated_mem_size);
keycache->block_mem= 0;
}
if (blocks < 8)
{
my_errno= ENOMEM;
my_error(EE_OUTOFMEMORY, MYF(ME_FATAL),
blocks * keycache->key_cache_block_size);
goto err;
}
blocks= blocks / 4*3;
}
keycache->blocks_unused= blocks;
keycache->disk_blocks= (int) blocks;
keycache->hash_links= (int)hash_links;
keycache->hash_links_used= 0;
keycache->free_hash_list= NULL;
keycache->blocks_used= keycache->blocks_changed= 0;
keycache->global_blocks_changed= 0;
keycache->blocks_available=0; /* For debugging */
/* The LRU chain is empty after initialization */
keycache->used_last= NULL;
keycache->used_ins= NULL;
keycache->free_block_list= NULL;
keycache->keycache_time= 0;
keycache->warm_blocks= 0;
keycache->min_warm_blocks= (division_limit ?
blocks * division_limit / 100 + 1 :
blocks);
keycache->age_threshold= (age_threshold ?
blocks * age_threshold / 100 :
blocks);
keycache->changed_blocks_hash_size= changed_blocks_hash_size;
keycache->can_be_used= 1;
keycache->waiting_for_hash_link.last_thread= NULL;
keycache->waiting_for_block.last_thread= NULL;
DBUG_PRINT("exit",
("disk_blocks: %d block_root: %p hash_entries: %d\
hash_root: %p hash_links: %d hash_link_root: %p",
keycache->disk_blocks, keycache->block_root,
keycache->hash_entries, keycache->hash_root,
keycache->hash_links, keycache->hash_link_root));
}
else
{
/* key_buffer_size is specified too small. Disable the cache. */
keycache->can_be_used= 0;
}
keycache->blocks= keycache->disk_blocks > 0 ? keycache->disk_blocks : 0;
DBUG_RETURN((int) keycache->disk_blocks);
err:
error= my_errno;
keycache->disk_blocks= 0;
keycache->blocks= 0;
if (keycache->block_mem)
{
my_large_free((uchar*) keycache->block_mem, keycache->allocated_mem_size);
keycache->block_mem= NULL;
}
if (keycache->block_root)
{
my_free(keycache->block_root);
keycache->block_root= NULL;
}
my_errno= error;
keycache->can_be_used= 0;
DBUG_RETURN(0);
} | O3 | c | init_simple_key_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r9d, %ebx
movq %rdx, %r9
movl %esi, %r13d
movq %rdi, %r10
movb (%rdi), %al
testb %al, %al
je 0xa03ae
xorl %r14d, %r14d
cmpl $0x0, 0x48(%r10)
jg 0xa081a
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r10)
movups %xmm0, 0x138(%r10)
movups %xmm0, 0x148(%r10)
movq $0x0, 0x158(%r10)
movl $0xffffffff, 0x48(%r10) # imm = 0xFFFFFFFF
testb %al, %al
movq %r10, -0x30(%rbp)
movq %r9, -0x50(%rbp)
jne 0xa0481
movw $0x1, (%r10)
movl $0x1, 0x164(%r10)
xorl %r15d, %r15d
movb %r15b, 0x2(%r10)
movq %r15, 0x70(%r10)
movq %r15, 0x110(%r10)
movb %r15b, 0x168(%r10)
leaq 0xb753f2(%rip), %rax # 0xc1580c
movl (%rax), %edi
leaq 0xc0(%r10), %r14
leaq 0x2f362e(%rip), %rax # 0x393a58
movq (%rax), %rax
movq %r14, %rsi
movl %ecx, -0x34(%rbp)
movl %r8d, %r12d
callq *0x40(%rax)
movq -0x30(%rbp), %rcx
movq %rax, 0x100(%rcx)
movq -0x30(%rbp), %rax
movq %r14, 0xf8(%rax)
movq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rax)
leaq 0xb760bc(%rip), %rsi # 0xc16520
movq %r14, %rdi
callq 0x2a320
movl %r12d, %r8d
movq -0x50(%rbp), %r9
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %r10
movq %r15, 0x108(%r10)
movq %r9, 0x8(%r10)
movl %r13d, 0x18(%r10)
movl %r13d, %esi
addq $0xda, %rsi
movq %r9, %rax
xorl %edx, %edx
divq %rsi
movq %rax, %rdi
cmpl $0x81, %ebx
movl $0x80, %eax
cmovael %ebx, %eax
cmpq $0x8, %rdi
jb 0xa06c2
decl %eax
movl %eax, %edx
shrl %edx
orl %eax, %edx
movl %edx, %eax
shrl $0x2, %eax
orl %edx, %eax
movl %eax, %edx
shrl $0x4, %edx
orl %eax, %edx
movl %edx, %eax
shrl $0x8, %eax
orl %edx, %eax
movl %eax, %edx
shrl $0x10, %edx
orl %eax, %edx
incl %edx
movl %edx, -0x38(%rbp)
movl %edx, %edx
movq %rdx, %rax
shlq $0x4, %rax
movq %rax, -0x98(%rbp)
leaq 0x10(%r10), %rax
movq %rax, -0x90(%rbp)
leaq 0xa0(%r10), %rax
movq %rax, -0x48(%rbp)
leaq 0x80(%r10), %rax
movq %rax, -0x70(%rbp)
leaq 0x88(%r10), %rax
movq %rax, -0x68(%rbp)
leaq 0x128(%r10), %rax
movq %rax, -0x60(%rbp)
shlq $0x3, %rdx
movq %rdx, -0x78(%rbp)
leaq 0x130(%r10), %rax
movq %rax, -0x58(%rbp)
movl %r8d, -0x3c(%rbp)
movl %r8d, %r11d
movl %ecx, -0x34(%rbp)
movl %ecx, %r12d
movq %r10, %r8
movq %r11, -0x80(%rbp)
leal -0x1(%rdi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10, %ecx
orl %eax, %ecx
leal 0x2(,%rcx,2), %edx
movq %rdi, %rax
shrq $0x2, %rax
addq %rdi, %rax
cmpq %rdx, %rax
seta %cl
shll %cl, %edx
movl %edx, 0x38(%r8)
movq %rdi, %rax
shlq $0x5, %rax
leaq (%rax,%rax,2), %rax
movq %rax, -0xa0(%rbp)
movl %r13d, %eax
leaq 0x1(%rdi), %r14
movq %r11, %r13
imulq %r14, %r13
movq %r12, %rbx
imulq %r14, %rbx
movq %r14, %rcx
imulq %rax, %rcx
leaq 0xd0(%rax), %rsi
imulq %rdi, %rsi
addq -0x98(%rbp), %rsi
leaq (%rsi,%rdx,8), %rsi
movq $-0x70, %rdx
subq %rax, %rdx
movq %rdi, -0x88(%rbp)
imulq $0x70, %rdi, %r15
addq $0x70, %r15
decq %r14
subq %r11, %r13
subq %r12, %rbx
subq %rax, %rcx
addq $-0x70, %r15
cmpq $0x9, %r14
jb 0xa060e
leaq (%rsi,%rdx), %rdi
cmpq %r9, %rsi
movq %rdi, %rsi
ja 0xa05ec
movq %rcx, 0x10(%r8)
movq -0x90(%rbp), %rdi
xorl %esi, %esi
callq 0xb2844
movq -0x30(%rbp), %r8
movq %rax, 0xa8(%r8)
testq %rax, %rax
je 0xa06a3
leaq 0xb75b71(%rip), %rax # 0xc161a8
movl (%rax), %edi
movl 0x38(%r8), %r9d
shlq $0x3, %r9
subq $0x8, %rsp
movl $0x20, %esi
movq -0x48(%rbp), %rdx
movq %r15, %rcx
movq %r8, %r15
movq -0x70(%rbp), %r8
xorl %eax, %eax
pushq $0x0
movq -0x78(%rbp), %r10
pushq %r10
pushq -0x58(%rbp)
pushq %r10
pushq -0x60(%rbp)
pushq -0xa0(%rbp)
pushq -0x68(%rbp)
callq 0xa4165
addq $0x40, %rsp
testq %rax, %rax
jne 0xa0766
movq 0x10(%r15), %rsi
movq 0xa8(%r15), %rdi
callq 0xb2cf3
movq $0x0, 0xa8(%r15)
movq %r15, %r8
cmpq $0x7, %r14
jbe 0xa06d0
shrq $0x2, %r14
leaq (%r14,%r14,2), %rdi
movl 0x18(%r8), %r13d
movq -0x50(%rbp), %r9
movq -0x80(%rbp), %r11
jmp 0xa054d
movb $0x0, 0x3(%r10)
movl 0x48(%r10), %r14d
jmp 0xa080a
callq 0xac2be
movl $0xc, (%rax)
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
imulq %rax, %r14
xorl %r15d, %r15d
movl $0x1000, %esi # imm = 0x1000
movl $0x5, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0xa5c33
callq 0xac2be
movq -0x30(%rbp), %rcx
movl (%rax), %ebx
movl %r15d, 0x48(%rcx)
movl %r15d, 0x160(%rcx)
movq 0xa8(%rcx), %rdi
testq %rdi, %rdi
je 0xa0737
movq 0x10(%rcx), %rsi
callq 0xb2cf3
movq -0x30(%rbp), %rax
movq $0x0, 0xa8(%rax)
movq -0x48(%rbp), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa074f
callq 0xaa406
movq $0x0, (%r14)
callq 0xac2be
movl %ebx, (%rax)
movq -0x30(%rbp), %rax
movb $0x0, 0x3(%rax)
xorl %r14d, %r14d
jmp 0xa081a
movq %r14, 0x58(%r15)
movl %r14d, 0x48(%r15)
movq -0x88(%rbp), %rax
addl %eax, %eax
movl %eax, 0x40(%r15)
movl $0x0, 0x44(%r15)
xorl %eax, %eax
movq %rax, 0x50(%r15)
movq %rax, 0x138(%r15)
movq %rax, 0x78(%r15)
movq %rax, 0x30(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r15)
movups %xmm0, 0x90(%r15)
movups %xmm0, 0xb0(%r15)
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
movq %r14, %rdx
cmpl $0x0, -0x34(%rbp)
movq %r15, %r10
je 0xa07d7
shrq $0x2, %rbx
movq %rbx, %rax
mulq %rcx
shrq $0x2, %rdx
incq %rdx
movq %rdx, 0x20(%r10)
movq %r14, %rdx
cmpl $0x0, -0x3c(%rbp)
je 0xa07f2
shrq $0x2, %r13
movq %r13, %rax
mulq %rcx
shrq $0x2, %rdx
movq %rdx, 0x28(%r10)
movl -0x38(%rbp), %eax
movl %eax, 0x3c(%r10)
movb $0x1, 0x3(%r10)
movups %xmm0, 0x118(%r10)
xorl %eax, %eax
testl %r14d, %r14d
cmovgl %r14d, %eax
movl %eax, 0x160(%r10)
movl %r14d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| init_simple_key_cache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov ebx, r9d
mov r9, rdx
mov r13d, esi
mov r10, rdi
mov al, [rdi]
test al, al
jz short loc_A03AE
xor r14d, r14d
cmp dword ptr [r10+48h], 0
jg loc_A081A
loc_A03AE:
xorps xmm0, xmm0
movups xmmword ptr [r10+50h], xmm0
movups xmmword ptr [r10+138h], xmm0
movups xmmword ptr [r10+148h], xmm0
mov qword ptr [r10+158h], 0
mov dword ptr [r10+48h], 0FFFFFFFFh
test al, al
mov [rbp+var_30], r10
mov [rbp+var_50], r9
jnz loc_A0481
mov word ptr [r10], 1
mov dword ptr [r10+164h], 1
xor r15d, r15d
mov [r10+2], r15b
mov [r10+70h], r15
mov [r10+110h], r15
mov [r10+168h], r15b
lea rax, key_KEY_CACHE_cache_lock
mov edi, [rax]
lea r14, [r10+0C0h]
lea rax, PSI_server
mov rax, [rax]
mov rsi, r14
mov [rbp+var_34], ecx
mov r12d, r8d
call qword ptr [rax+40h]
mov rcx, [rbp+var_30]
mov [rcx+100h], rax
mov rax, [rbp+var_30]
mov [rax+0F8h], r14
mov rax, [rbp+var_30]
xorps xmm0, xmm0
movups xmmword ptr [rax+0E8h], xmm0
lea rsi, my_fast_mutexattr
mov rdi, r14
call _pthread_mutex_init
mov r8d, r12d
mov r9, [rbp+var_50]
mov ecx, [rbp+var_34]
mov r10, [rbp+var_30]
mov [r10+108h], r15
loc_A0481:
mov [r10+8], r9
mov [r10+18h], r13d
mov esi, r13d
add rsi, 0DAh
mov rax, r9
xor edx, edx
div rsi
mov rdi, rax
cmp ebx, 81h
mov eax, 80h
cmovnb eax, ebx
cmp rdi, 8
jb loc_A06C2
dec eax
mov edx, eax
shr edx, 1
or edx, eax
mov eax, edx
shr eax, 2
or eax, edx
mov edx, eax
shr edx, 4
or edx, eax
mov eax, edx
shr eax, 8
or eax, edx
mov edx, eax
shr edx, 10h
or edx, eax
inc edx
mov [rbp+var_38], edx
mov edx, edx
mov rax, rdx
shl rax, 4
mov [rbp+var_98], rax
lea rax, [r10+10h]
mov [rbp+var_90], rax
lea rax, [r10+0A0h]
mov [rbp+var_48], rax
lea rax, [r10+80h]
mov [rbp+var_70], rax
lea rax, [r10+88h]
mov [rbp+var_68], rax
lea rax, [r10+128h]
mov [rbp+var_60], rax
shl rdx, 3
mov [rbp+var_78], rdx
lea rax, [r10+130h]
mov [rbp+var_58], rax
mov [rbp+var_3C], r8d
mov r11d, r8d
mov [rbp+var_34], ecx
mov r12d, ecx
mov r8, r10
mov [rbp+var_80], r11
loc_A054D:
lea eax, [rdi-1]
mov ecx, eax
shr ecx, 1
or ecx, eax
mov eax, ecx
shr eax, 2
or eax, ecx
mov ecx, eax
shr ecx, 4
or ecx, eax
mov eax, ecx
shr eax, 8
or eax, ecx
mov ecx, eax
shr ecx, 10h
or ecx, eax
lea edx, ds:2[rcx*2]
mov rax, rdi
shr rax, 2
add rax, rdi
cmp rax, rdx
setnbe cl
shl edx, cl
mov [r8+38h], edx
mov rax, rdi
shl rax, 5
lea rax, [rax+rax*2]
mov [rbp+var_A0], rax
mov eax, r13d
lea r14, [rdi+1]
mov r13, r11
imul r13, r14
mov rbx, r12
imul rbx, r14
mov rcx, r14
imul rcx, rax
lea rsi, [rax+0D0h]
imul rsi, rdi
add rsi, [rbp+var_98]
lea rsi, [rsi+rdx*8]
mov rdx, 0FFFFFFFFFFFFFF90h
sub rdx, rax
mov [rbp+var_88], rdi
imul r15, rdi, 70h ; 'p'
add r15, 70h ; 'p'
loc_A05EC:
dec r14
sub r13, r11
sub rbx, r12
sub rcx, rax
add r15, 0FFFFFFFFFFFFFF90h
cmp r14, 9
jb short loc_A060E
lea rdi, [rsi+rdx]
cmp rsi, r9
mov rsi, rdi
ja short loc_A05EC
loc_A060E:
mov [r8+10h], rcx
mov rdi, [rbp+var_90]
xor esi, esi
call my_large_malloc
mov r8, [rbp+var_30]
mov [r8+0A8h], rax
test rax, rax
jz short loc_A06A3
lea rax, key_memory_KEY_CACHE
mov edi, [rax]
mov r9d, [r8+38h]
shl r9, 3
sub rsp, 8
mov esi, 20h ; ' '
mov rdx, [rbp+var_48]
mov rcx, r15
mov r15, r8
mov r8, [rbp+var_70]
xor eax, eax
push 0
mov r10, [rbp+var_78]
push r10
push [rbp+var_58]
push r10
push [rbp+var_60]
push [rbp+var_A0]
push [rbp+var_68]
call my_multi_malloc_large
add rsp, 40h
test rax, rax
jnz loc_A0766
mov rsi, [r15+10h]
mov rdi, [r15+0A8h]
call my_large_free
mov qword ptr [r15+0A8h], 0
mov r8, r15
loc_A06A3:
cmp r14, 7
jbe short loc_A06D0
shr r14, 2
lea rdi, [r14+r14*2]
mov r13d, [r8+18h]
mov r9, [rbp+var_50]
mov r11, [rbp+var_80]
jmp loc_A054D
loc_A06C2:
mov byte ptr [r10+3], 0
mov r14d, [r10+48h]
jmp loc_A080A
loc_A06D0:
call _my_thread_var
mov dword ptr [rax], 0Ch
mov rax, [rbp+var_30]
mov eax, [rax+18h]
imul r14, rax
xor r15d, r15d
mov esi, 1000h
mov edi, 5
mov rdx, r14
xor eax, eax
call my_error
call _my_thread_var
mov rcx, [rbp+var_30]
mov ebx, [rax]
mov [rcx+48h], r15d
mov [rcx+160h], r15d
mov rdi, [rcx+0A8h]
test rdi, rdi
jz short loc_A0737
mov rsi, [rcx+10h]
call my_large_free
mov rax, [rbp+var_30]
mov qword ptr [rax+0A8h], 0
loc_A0737:
mov r14, [rbp+var_48]
mov rdi, [r14]
test rdi, rdi
jz short loc_A074F
call my_free
mov qword ptr [r14], 0
loc_A074F:
call _my_thread_var
mov [rax], ebx
mov rax, [rbp+var_30]
mov byte ptr [rax+3], 0
xor r14d, r14d
jmp loc_A081A
loc_A0766:
mov [r15+58h], r14
mov [r15+48h], r14d
mov rax, [rbp+var_88]
add eax, eax
mov [r15+40h], eax
mov dword ptr [r15+44h], 0
xor eax, eax
mov [r15+50h], rax
mov [r15+138h], rax
mov [r15+78h], rax
mov [r15+30h], rax
xorps xmm0, xmm0
movups xmmword ptr [r15+60h], xmm0
movups xmmword ptr [r15+90h], xmm0
movups xmmword ptr [r15+0B0h], xmm0
mov rcx, 28F5C28F5C28F5C3h
mov rdx, r14
cmp [rbp+var_34], 0
mov r10, r15
jz short loc_A07D7
shr rbx, 2
mov rax, rbx
mul rcx
shr rdx, 2
inc rdx
loc_A07D7:
mov [r10+20h], rdx
mov rdx, r14
cmp [rbp+var_3C], 0
jz short loc_A07F2
shr r13, 2
mov rax, r13
mul rcx
shr rdx, 2
loc_A07F2:
mov [r10+28h], rdx
mov eax, [rbp+var_38]
mov [r10+3Ch], eax
mov byte ptr [r10+3], 1
movups xmmword ptr [r10+118h], xmm0
loc_A080A:
xor eax, eax
test r14d, r14d
cmovg eax, r14d
mov [r10+160h], eax
loc_A081A:
mov eax, r14d
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long init_simple_key_cache(
char *a1,
unsigned int a2,
unsigned long long a3,
long long a4,
long long a5,
unsigned int a6)
{
unsigned long long v7; // r9
unsigned int v8; // r13d
char *v9; // r10
char v10; // al
unsigned long long v11; // r14
int v12; // r12d
unsigned long long v13; // rdi
int v14; // eax
unsigned int v15; // eax
unsigned int v16; // eax
long long v17; // r11
long long v18; // r12
char *v19; // r8
unsigned long long v20; // rdx
long long v21; // rdx
long long v22; // rax
unsigned long long v23; // r13
unsigned long long v24; // rbx
long long v25; // rcx
unsigned long long v26; // rsi
long long v27; // rdx
int v28; // r15d
bool v29; // cc
char *v30; // rdi
long long v31; // rax
int v32; // ecx
int v33; // r8d
int v34; // r9d
int v35; // ebx
long long v36; // rdi
long long v37; // rdi
unsigned long long v38; // rdx
unsigned long long v39; // rdx
int v40; // eax
long long v42; // [rsp+0h] [rbp-A0h]
char *v43; // [rsp+10h] [rbp-90h]
int v44; // [rsp+18h] [rbp-88h]
long long i; // [rsp+20h] [rbp-80h]
int v46; // [rsp+30h] [rbp-70h]
long long v47; // [rsp+38h] [rbp-68h]
long long v48; // [rsp+40h] [rbp-60h]
long long v49; // [rsp+48h] [rbp-58h]
long long *v51; // [rsp+58h] [rbp-48h]
int v52; // [rsp+64h] [rbp-3Ch]
unsigned int v53; // [rsp+68h] [rbp-38h]
int v54; // [rsp+6Ch] [rbp-34h]
int v55; // [rsp+6Ch] [rbp-34h]
v7 = a3;
v8 = a2;
v9 = a1;
v10 = *a1;
if ( *a1 )
{
LODWORD(v11) = 0;
if ( *((int *)a1 + 18) > 0 )
return (unsigned int)v11;
}
*((_OWORD *)a1 + 5) = 0LL;
*(_OWORD *)(a1 + 312) = 0LL;
*(_OWORD *)(a1 + 328) = 0LL;
*((_QWORD *)a1 + 43) = 0LL;
*((_DWORD *)a1 + 18) = -1;
if ( !v10 )
{
*(_WORD *)a1 = 1;
*((_DWORD *)a1 + 89) = 1;
a1[2] = 0;
*((_QWORD *)a1 + 14) = 0LL;
*((_QWORD *)a1 + 34) = 0LL;
a1[360] = 0;
v54 = a4;
v12 = a5;
*((_QWORD *)a1 + 32) = ((long long ( *)(_QWORD, char *, unsigned long long, long long, long long, unsigned long long))PSI_server[8])(
key_KEY_CACHE_cache_lock,
a1 + 192,
a3,
a4,
a5,
a3);
*((_QWORD *)a1 + 31) = a1 + 192;
*(_OWORD *)(a1 + 232) = 0LL;
pthread_mutex_init(a1 + 192, &my_fast_mutexattr);
LODWORD(a5) = v12;
v7 = a3;
LODWORD(a4) = v54;
v9 = a1;
*((_QWORD *)a1 + 33) = 0LL;
}
*((_QWORD *)v9 + 1) = v7;
*((_DWORD *)v9 + 6) = a2;
v13 = v7 / ((unsigned long long)a2 + 218);
v14 = 128;
if ( a6 >= 0x81 )
v14 = a6;
if ( v13 < 8 )
{
v9[3] = 0;
LODWORD(v11) = *((_DWORD *)v9 + 18);
goto LABEL_28;
}
v15 = (v14 - 1) | ((unsigned int)(v14 - 1) >> 1) | (((v14 - 1) | ((unsigned int)(v14 - 1) >> 1)) >> 2);
v16 = v15 | (v15 >> 4) | ((v15 | (v15 >> 4)) >> 8);
v53 = (v16 | HIWORD(v16)) + 1;
v43 = v9 + 16;
v51 = (long long *)(v9 + 160);
v46 = (_DWORD)v9 + 128;
v47 = (long long)(v9 + 136);
v48 = (long long)(v9 + 296);
v49 = (long long)(v9 + 304);
v52 = a5;
v17 = (unsigned int)a5;
v55 = a4;
v18 = (unsigned int)a4;
v19 = v9;
for ( i = v17; ; v17 = i )
{
v20 = 2
* (((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2)) >> 4) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2)) >> 4)) >> 8) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2)) >> 4) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1) | ((((_DWORD)v13 - 1) | ((unsigned int)(v13 - 1) >> 1)) >> 2)) >> 4)) >> 8)) >> 16))
+ 2;
v21 = (unsigned int)((_DWORD)v20 << (v13 + (v13 >> 2) > v20));
*((_DWORD *)v19 + 14) = v21;
v42 = 96 * v13;
v22 = v8;
v11 = v13 + 1;
v23 = (v13 + 1) * v17;
v24 = (v13 + 1) * v18;
v25 = v22 * (v13 + 1);
v26 = 16LL * v53 + v13 * (v22 + 208) + 8 * v21;
v27 = -112 - v22;
v44 = v13;
v28 = 112 * v13 + 112;
do
{
--v11;
v23 -= v17;
v24 -= v18;
v25 -= v22;
v28 -= 112;
if ( v11 < 9 )
break;
v29 = v26 <= v7;
v26 += v27;
}
while ( !v29 );
*((_QWORD *)v19 + 2) = v25;
v30 = v43;
v31 = my_large_malloc(v43, 0LL, v27);
v19 = a1;
*((_QWORD *)a1 + 21) = v31;
if ( v31 )
break;
LABEL_15:
if ( v11 <= 7 )
{
*(_DWORD *)my_thread_var(v30) = 12;
my_error(5, 4096, *((_DWORD *)a1 + 6) * v11, v32, v33, v34);
v35 = *(_DWORD *)my_thread_var(5LL);
*((_DWORD *)a1 + 18) = 0;
*((_DWORD *)a1 + 88) = 0;
v36 = *((_QWORD *)a1 + 21);
if ( v36 )
{
my_large_free(v36, *((_QWORD *)a1 + 2));
*((_QWORD *)a1 + 21) = 0LL;
}
v37 = *v51;
if ( *v51 )
{
my_free(v37);
*v51 = 0LL;
}
*(_DWORD *)my_thread_var(v37) = v35;
a1[3] = 0;
LODWORD(v11) = 0;
return (unsigned int)v11;
}
v13 = 3 * (v11 >> 2);
v8 = *((_DWORD *)v19 + 6);
v7 = a3;
}
if ( !my_multi_malloc_large(
key_memory_KEY_CACHE,
32,
(_DWORD)v51,
v28,
v46,
8 * *((_DWORD *)a1 + 14),
v47,
v42,
v48,
8LL * v53,
v49,
8LL * v53,
0LL) )
{
v30 = (char *)*((_QWORD *)a1 + 21);
my_large_free(v30, *((_QWORD *)a1 + 2));
*((_QWORD *)a1 + 21) = 0LL;
v19 = a1;
goto LABEL_15;
}
*((_QWORD *)a1 + 11) = v11;
*((_DWORD *)a1 + 18) = v11;
*((_DWORD *)a1 + 16) = 2 * v44;
*((_DWORD *)a1 + 17) = 0;
*((_QWORD *)a1 + 10) = 0LL;
*((_QWORD *)a1 + 39) = 0LL;
*((_QWORD *)a1 + 15) = 0LL;
*((_QWORD *)a1 + 6) = 0LL;
*((_OWORD *)a1 + 6) = 0LL;
*((_OWORD *)a1 + 9) = 0LL;
*((_OWORD *)a1 + 11) = 0LL;
v38 = v11;
v9 = a1;
if ( v55 )
v38 = v24 / 0x64 + 1;
*((_QWORD *)a1 + 4) = v38;
v39 = v11;
if ( v52 )
v39 = v23 / 0x64;
*((_QWORD *)a1 + 5) = v39;
*((_DWORD *)a1 + 15) = v53;
a1[3] = 1;
*(_OWORD *)(a1 + 280) = 0LL;
LABEL_28:
v40 = 0;
if ( (int)v11 > 0 )
v40 = v11;
*((_DWORD *)v9 + 88) = v40;
return (unsigned int)v11;
}
| init_simple_key_cache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV EBX,R9D
MOV R9,RDX
MOV R13D,ESI
MOV R10,RDI
MOV AL,byte ptr [RDI]
TEST AL,AL
JZ 0x001a03ae
XOR R14D,R14D
CMP dword ptr [R10 + 0x48],0x0
JG 0x001a081a
LAB_001a03ae:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R10 + 0x50],XMM0
MOVUPS xmmword ptr [R10 + 0x138],XMM0
MOVUPS xmmword ptr [R10 + 0x148],XMM0
MOV qword ptr [R10 + 0x158],0x0
MOV dword ptr [R10 + 0x48],0xffffffff
TEST AL,AL
MOV qword ptr [RBP + -0x30],R10
MOV qword ptr [RBP + -0x50],R9
JNZ 0x001a0481
MOV word ptr [R10],0x1
MOV dword ptr [R10 + 0x164],0x1
XOR R15D,R15D
MOV byte ptr [R10 + 0x2],R15B
MOV qword ptr [R10 + 0x70],R15
MOV qword ptr [R10 + 0x110],R15
MOV byte ptr [R10 + 0x168],R15B
LEA RAX,[0xd1580c]
MOV EDI,dword ptr [RAX]
LEA R14,[R10 + 0xc0]
LEA RAX,[0x493a58]
MOV RAX,qword ptr [RAX]
MOV RSI,R14
MOV dword ptr [RBP + -0x34],ECX
MOV R12D,R8D
CALL qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RCX + 0x100],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0xf8],R14
MOV RAX,qword ptr [RBP + -0x30]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0xe8],XMM0
LEA RSI,[0xd16520]
MOV RDI,R14
CALL 0x0012a320
MOV R8D,R12D
MOV R9,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x34]
MOV R10,qword ptr [RBP + -0x30]
MOV qword ptr [R10 + 0x108],R15
LAB_001a0481:
MOV qword ptr [R10 + 0x8],R9
MOV dword ptr [R10 + 0x18],R13D
MOV ESI,R13D
ADD RSI,0xda
MOV RAX,R9
XOR EDX,EDX
DIV RSI
MOV RDI,RAX
CMP EBX,0x81
MOV EAX,0x80
CMOVNC EAX,EBX
CMP RDI,0x8
JC 0x001a06c2
DEC EAX
MOV EDX,EAX
SHR EDX,0x1
OR EDX,EAX
MOV EAX,EDX
SHR EAX,0x2
OR EAX,EDX
MOV EDX,EAX
SHR EDX,0x4
OR EDX,EAX
MOV EAX,EDX
SHR EAX,0x8
OR EAX,EDX
MOV EDX,EAX
SHR EDX,0x10
OR EDX,EAX
INC EDX
MOV dword ptr [RBP + -0x38],EDX
MOV EDX,EDX
MOV RAX,RDX
SHL RAX,0x4
MOV qword ptr [RBP + -0x98],RAX
LEA RAX,[R10 + 0x10]
MOV qword ptr [RBP + -0x90],RAX
LEA RAX,[R10 + 0xa0]
MOV qword ptr [RBP + -0x48],RAX
LEA RAX,[R10 + 0x80]
MOV qword ptr [RBP + -0x70],RAX
LEA RAX,[R10 + 0x88]
MOV qword ptr [RBP + -0x68],RAX
LEA RAX,[R10 + 0x128]
MOV qword ptr [RBP + -0x60],RAX
SHL RDX,0x3
MOV qword ptr [RBP + -0x78],RDX
LEA RAX,[R10 + 0x130]
MOV qword ptr [RBP + -0x58],RAX
MOV dword ptr [RBP + -0x3c],R8D
MOV R11D,R8D
MOV dword ptr [RBP + -0x34],ECX
MOV R12D,ECX
MOV R8,R10
MOV qword ptr [RBP + -0x80],R11
LAB_001a054d:
LEA EAX,[RDI + -0x1]
MOV ECX,EAX
SHR ECX,0x1
OR ECX,EAX
MOV EAX,ECX
SHR EAX,0x2
OR EAX,ECX
MOV ECX,EAX
SHR ECX,0x4
OR ECX,EAX
MOV EAX,ECX
SHR EAX,0x8
OR EAX,ECX
MOV ECX,EAX
SHR ECX,0x10
OR ECX,EAX
LEA EDX,[0x2 + RCX*0x2]
MOV RAX,RDI
SHR RAX,0x2
ADD RAX,RDI
CMP RAX,RDX
SETA CL
SHL EDX,CL
MOV dword ptr [R8 + 0x38],EDX
MOV RAX,RDI
SHL RAX,0x5
LEA RAX,[RAX + RAX*0x2]
MOV qword ptr [RBP + -0xa0],RAX
MOV EAX,R13D
LEA R14,[RDI + 0x1]
MOV R13,R11
IMUL R13,R14
MOV RBX,R12
IMUL RBX,R14
MOV RCX,R14
IMUL RCX,RAX
LEA RSI,[RAX + 0xd0]
IMUL RSI,RDI
ADD RSI,qword ptr [RBP + -0x98]
LEA RSI,[RSI + RDX*0x8]
MOV RDX,-0x70
SUB RDX,RAX
MOV qword ptr [RBP + -0x88],RDI
IMUL R15,RDI,0x70
ADD R15,0x70
LAB_001a05ec:
DEC R14
SUB R13,R11
SUB RBX,R12
SUB RCX,RAX
ADD R15,-0x70
CMP R14,0x9
JC 0x001a060e
LEA RDI,[RSI + RDX*0x1]
CMP RSI,R9
MOV RSI,RDI
JA 0x001a05ec
LAB_001a060e:
MOV qword ptr [R8 + 0x10],RCX
MOV RDI,qword ptr [RBP + -0x90]
XOR ESI,ESI
CALL 0x001b2844
MOV R8,qword ptr [RBP + -0x30]
MOV qword ptr [R8 + 0xa8],RAX
TEST RAX,RAX
JZ 0x001a06a3
LEA RAX,[0xd161a8]
MOV EDI,dword ptr [RAX]
MOV R9D,dword ptr [R8 + 0x38]
SHL R9,0x3
SUB RSP,0x8
MOV ESI,0x20
MOV RDX,qword ptr [RBP + -0x48]
MOV RCX,R15
MOV R15,R8
MOV R8,qword ptr [RBP + -0x70]
XOR EAX,EAX
PUSH 0x0
MOV R10,qword ptr [RBP + -0x78]
PUSH R10
PUSH qword ptr [RBP + -0x58]
PUSH R10
PUSH qword ptr [RBP + -0x60]
PUSH qword ptr [RBP + -0xa0]
PUSH qword ptr [RBP + -0x68]
CALL 0x001a4165
ADD RSP,0x40
TEST RAX,RAX
JNZ 0x001a0766
MOV RSI,qword ptr [R15 + 0x10]
MOV RDI,qword ptr [R15 + 0xa8]
CALL 0x001b2cf3
MOV qword ptr [R15 + 0xa8],0x0
MOV R8,R15
LAB_001a06a3:
CMP R14,0x7
JBE 0x001a06d0
SHR R14,0x2
LEA RDI,[R14 + R14*0x2]
MOV R13D,dword ptr [R8 + 0x18]
MOV R9,qword ptr [RBP + -0x50]
MOV R11,qword ptr [RBP + -0x80]
JMP 0x001a054d
LAB_001a06c2:
MOV byte ptr [R10 + 0x3],0x0
MOV R14D,dword ptr [R10 + 0x48]
JMP 0x001a080a
LAB_001a06d0:
CALL 0x001ac2be
MOV dword ptr [RAX],0xc
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x18]
IMUL R14,RAX
XOR R15D,R15D
MOV ESI,0x1000
MOV EDI,0x5
MOV RDX,R14
XOR EAX,EAX
CALL 0x001a5c33
CALL 0x001ac2be
MOV RCX,qword ptr [RBP + -0x30]
MOV EBX,dword ptr [RAX]
MOV dword ptr [RCX + 0x48],R15D
MOV dword ptr [RCX + 0x160],R15D
MOV RDI,qword ptr [RCX + 0xa8]
TEST RDI,RDI
JZ 0x001a0737
MOV RSI,qword ptr [RCX + 0x10]
CALL 0x001b2cf3
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0xa8],0x0
LAB_001a0737:
MOV R14,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [R14]
TEST RDI,RDI
JZ 0x001a074f
CALL 0x001aa406
MOV qword ptr [R14],0x0
LAB_001a074f:
CALL 0x001ac2be
MOV dword ptr [RAX],EBX
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX + 0x3],0x0
XOR R14D,R14D
JMP 0x001a081a
LAB_001a0766:
MOV qword ptr [R15 + 0x58],R14
MOV dword ptr [R15 + 0x48],R14D
MOV RAX,qword ptr [RBP + -0x88]
ADD EAX,EAX
MOV dword ptr [R15 + 0x40],EAX
MOV dword ptr [R15 + 0x44],0x0
XOR EAX,EAX
MOV qword ptr [R15 + 0x50],RAX
MOV qword ptr [R15 + 0x138],RAX
MOV qword ptr [R15 + 0x78],RAX
MOV qword ptr [R15 + 0x30],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + 0x60],XMM0
MOVUPS xmmword ptr [R15 + 0x90],XMM0
MOVUPS xmmword ptr [R15 + 0xb0],XMM0
MOV RCX,0x28f5c28f5c28f5c3
MOV RDX,R14
CMP dword ptr [RBP + -0x34],0x0
MOV R10,R15
JZ 0x001a07d7
SHR RBX,0x2
MOV RAX,RBX
MUL RCX
SHR RDX,0x2
INC RDX
LAB_001a07d7:
MOV qword ptr [R10 + 0x20],RDX
MOV RDX,R14
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x001a07f2
SHR R13,0x2
MOV RAX,R13
MUL RCX
SHR RDX,0x2
LAB_001a07f2:
MOV qword ptr [R10 + 0x28],RDX
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [R10 + 0x3c],EAX
MOV byte ptr [R10 + 0x3],0x1
MOVUPS xmmword ptr [R10 + 0x118],XMM0
LAB_001a080a:
XOR EAX,EAX
TEST R14D,R14D
CMOVG EAX,R14D
MOV dword ptr [R10 + 0x160],EAX
LAB_001a081a:
MOV EAX,R14D
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong init_simple_key_cache
(char *param_1,uint param_2,ulong param_3,uint param_4,uint param_5,uint param_6)
{
pthread_mutex_t *__mutex;
long *plVar1;
int4 uVar2;
bool bVar3;
uint uVar4;
int iVar5;
int8 uVar6;
ulong uVar7;
int4 *puVar8;
long lVar9;
uint uVar10;
long lVar11;
ulong uVar12;
ulong uVar13;
ulong uVar14;
ulong uVar15;
ulong uVar16;
long lVar17;
uVar12 = (ulong)param_2;
if ((*param_1 == '\0') || (uVar16 = 0, *(int *)(param_1 + 0x48) < 1)) {
param_1[0x50] = '\0';
param_1[0x51] = '\0';
param_1[0x52] = '\0';
param_1[0x53] = '\0';
param_1[0x54] = '\0';
param_1[0x55] = '\0';
param_1[0x56] = '\0';
param_1[0x57] = '\0';
param_1[0x58] = '\0';
param_1[0x59] = '\0';
param_1[0x5a] = '\0';
param_1[0x5b] = '\0';
param_1[0x5c] = '\0';
param_1[0x5d] = '\0';
param_1[0x5e] = '\0';
param_1[0x5f] = '\0';
param_1[0x138] = '\0';
param_1[0x139] = '\0';
param_1[0x13a] = '\0';
param_1[0x13b] = '\0';
param_1[0x13c] = '\0';
param_1[0x13d] = '\0';
param_1[0x13e] = '\0';
param_1[0x13f] = '\0';
param_1[0x140] = '\0';
param_1[0x141] = '\0';
param_1[0x142] = '\0';
param_1[0x143] = '\0';
param_1[0x144] = '\0';
param_1[0x145] = '\0';
param_1[0x146] = '\0';
param_1[0x147] = '\0';
param_1[0x148] = '\0';
param_1[0x149] = '\0';
param_1[0x14a] = '\0';
param_1[0x14b] = '\0';
param_1[0x14c] = '\0';
param_1[0x14d] = '\0';
param_1[0x14e] = '\0';
param_1[0x14f] = '\0';
param_1[0x150] = '\0';
param_1[0x151] = '\0';
param_1[0x152] = '\0';
param_1[0x153] = '\0';
param_1[0x154] = '\0';
param_1[0x155] = '\0';
param_1[0x156] = '\0';
param_1[0x157] = '\0';
param_1[0x158] = '\0';
param_1[0x159] = '\0';
param_1[0x15a] = '\0';
param_1[0x15b] = '\0';
param_1[0x15c] = '\0';
param_1[0x15d] = '\0';
param_1[0x15e] = '\0';
param_1[0x15f] = '\0';
param_1[0x48] = -1;
param_1[0x49] = -1;
param_1[0x4a] = -1;
param_1[0x4b] = -1;
if (*param_1 == '\0') {
param_1[0] = '\x01';
param_1[1] = '\0';
param_1[0x164] = '\x01';
param_1[0x165] = '\0';
param_1[0x166] = '\0';
param_1[0x167] = '\0';
param_1[2] = '\0';
param_1[0x70] = '\0';
param_1[0x71] = '\0';
param_1[0x72] = '\0';
param_1[0x73] = '\0';
param_1[0x74] = '\0';
param_1[0x75] = '\0';
param_1[0x76] = '\0';
param_1[0x77] = '\0';
param_1[0x110] = '\0';
param_1[0x111] = '\0';
param_1[0x112] = '\0';
param_1[0x113] = '\0';
param_1[0x114] = '\0';
param_1[0x115] = '\0';
param_1[0x116] = '\0';
param_1[0x117] = '\0';
param_1[0x168] = '\0';
__mutex = (pthread_mutex_t *)(param_1 + 0xc0);
uVar6 = (**(code **)(PSI_server + 0x40))(key_KEY_CACHE_cache_lock,__mutex);
*(int8 *)(param_1 + 0x100) = uVar6;
*(pthread_mutex_t **)(param_1 + 0xf8) = __mutex;
param_1[0xe8] = '\0';
param_1[0xe9] = '\0';
param_1[0xea] = '\0';
param_1[0xeb] = '\0';
param_1[0xec] = '\0';
param_1[0xed] = '\0';
param_1[0xee] = '\0';
param_1[0xef] = '\0';
param_1[0xf0] = '\0';
param_1[0xf1] = '\0';
param_1[0xf2] = '\0';
param_1[0xf3] = '\0';
param_1[0xf4] = '\0';
param_1[0xf5] = '\0';
param_1[0xf6] = '\0';
param_1[0xf7] = '\0';
pthread_mutex_init(__mutex,(pthread_mutexattr_t *)&my_fast_mutexattr);
param_1[0x108] = '\0';
param_1[0x109] = '\0';
param_1[0x10a] = '\0';
param_1[0x10b] = '\0';
param_1[0x10c] = '\0';
param_1[0x10d] = '\0';
param_1[0x10e] = '\0';
param_1[0x10f] = '\0';
}
*(ulong *)(param_1 + 8) = param_3;
*(uint *)(param_1 + 0x18) = param_2;
uVar7 = param_3 / ((ulong)param_2 + 0xda);
uVar10 = 0x80;
if (0x80 < param_6) {
uVar10 = param_6;
}
if (7 < uVar7) {
uVar10 = uVar10 - 1 >> 1 | uVar10 - 1;
uVar10 = uVar10 >> 2 | uVar10;
uVar10 = uVar10 >> 4 | uVar10;
uVar10 = uVar10 >> 8 | uVar10;
uVar10 = (uVar10 >> 0x10 | uVar10) + 1;
plVar1 = (long *)(param_1 + 0xa0);
lVar11 = (ulong)uVar10 << 3;
do {
uVar4 = (int)uVar7 - 1;
uVar4 = uVar4 >> 1 | uVar4;
uVar4 = uVar4 >> 2 | uVar4;
uVar4 = uVar4 >> 4 | uVar4;
uVar4 = uVar4 >> 8 | uVar4;
uVar4 = (uVar4 >> 0x10 | uVar4) * 2 + 2;
uVar4 = uVar4 << ((ulong)uVar4 < (uVar7 >> 2) + uVar7);
*(uint *)(param_1 + 0x38) = uVar4;
uVar16 = uVar7 + 1;
uVar15 = param_5 * uVar16;
uVar13 = param_4 * uVar16;
lVar9 = uVar16 * uVar12;
lVar17 = uVar7 * 0x70 + 0x70;
uVar14 = (uVar12 + 0xd0) * uVar7 + (ulong)uVar10 * 0x10 + (ulong)uVar4 * 8;
do {
uVar16 = uVar16 - 1;
uVar15 = uVar15 - param_5;
uVar13 = uVar13 - param_4;
lVar9 = lVar9 - uVar12;
lVar17 = lVar17 + -0x70;
if (uVar16 < 9) break;
bVar3 = param_3 < uVar14;
uVar14 = uVar14 + (-0x70 - uVar12);
} while (bVar3);
*(long *)(param_1 + 0x10) = lVar9;
lVar9 = my_large_malloc(param_1 + 0x10,0);
*(long *)(param_1 + 0xa8) = lVar9;
if (lVar9 != 0) {
lVar9 = my_multi_malloc_large
(key_memory_KEY_CACHE,0x20,plVar1,lVar17,param_1 + 0x80,
(ulong)*(uint *)(param_1 + 0x38) << 3,param_1 + 0x88,uVar7 * 0x60,
param_1 + 0x128,lVar11,param_1 + 0x130,lVar11,0);
if (lVar9 != 0) {
*(ulong *)(param_1 + 0x58) = uVar16;
*(int *)(param_1 + 0x48) = (int)uVar16;
*(int *)(param_1 + 0x40) = (int)uVar7 * 2;
param_1[0x44] = '\0';
param_1[0x45] = '\0';
param_1[0x46] = '\0';
param_1[0x47] = '\0';
param_1[0x50] = '\0';
param_1[0x51] = '\0';
param_1[0x52] = '\0';
param_1[0x53] = '\0';
param_1[0x54] = '\0';
param_1[0x55] = '\0';
param_1[0x56] = '\0';
param_1[0x57] = '\0';
param_1[0x138] = '\0';
param_1[0x139] = '\0';
param_1[0x13a] = '\0';
param_1[0x13b] = '\0';
param_1[0x13c] = '\0';
param_1[0x13d] = '\0';
param_1[0x13e] = '\0';
param_1[0x13f] = '\0';
param_1[0x78] = '\0';
param_1[0x79] = '\0';
param_1[0x7a] = '\0';
param_1[0x7b] = '\0';
param_1[0x7c] = '\0';
param_1[0x7d] = '\0';
param_1[0x7e] = '\0';
param_1[0x7f] = '\0';
param_1[0x30] = '\0';
param_1[0x31] = '\0';
param_1[0x32] = '\0';
param_1[0x33] = '\0';
param_1[0x34] = '\0';
param_1[0x35] = '\0';
param_1[0x36] = '\0';
param_1[0x37] = '\0';
param_1[0x60] = '\0';
param_1[0x61] = '\0';
param_1[0x62] = '\0';
param_1[99] = '\0';
param_1[100] = '\0';
param_1[0x65] = '\0';
param_1[0x66] = '\0';
param_1[0x67] = '\0';
param_1[0x68] = '\0';
param_1[0x69] = '\0';
param_1[0x6a] = '\0';
param_1[0x6b] = '\0';
param_1[0x6c] = '\0';
param_1[0x6d] = '\0';
param_1[0x6e] = '\0';
param_1[0x6f] = '\0';
param_1[0x90] = '\0';
param_1[0x91] = '\0';
param_1[0x92] = '\0';
param_1[0x93] = '\0';
param_1[0x94] = '\0';
param_1[0x95] = '\0';
param_1[0x96] = '\0';
param_1[0x97] = '\0';
param_1[0x98] = '\0';
param_1[0x99] = '\0';
param_1[0x9a] = '\0';
param_1[0x9b] = '\0';
param_1[0x9c] = '\0';
param_1[0x9d] = '\0';
param_1[0x9e] = '\0';
param_1[0x9f] = '\0';
param_1[0xb0] = '\0';
param_1[0xb1] = '\0';
param_1[0xb2] = '\0';
param_1[0xb3] = '\0';
param_1[0xb4] = '\0';
param_1[0xb5] = '\0';
param_1[0xb6] = '\0';
param_1[0xb7] = '\0';
param_1[0xb8] = '\0';
param_1[0xb9] = '\0';
param_1[0xba] = '\0';
param_1[0xbb] = '\0';
param_1[0xbc] = '\0';
param_1[0xbd] = '\0';
param_1[0xbe] = '\0';
param_1[0xbf] = '\0';
uVar12 = uVar16;
if (param_4 != 0) {
uVar12 = uVar13 / 100 + 1;
}
*(ulong *)(param_1 + 0x20) = uVar12;
uVar12 = uVar16;
if (param_5 != 0) {
uVar12 = uVar15 / 100;
}
*(ulong *)(param_1 + 0x28) = uVar12;
*(uint *)(param_1 + 0x3c) = uVar10;
param_1[3] = '\x01';
param_1[0x118] = '\0';
param_1[0x119] = '\0';
param_1[0x11a] = '\0';
param_1[0x11b] = '\0';
param_1[0x11c] = '\0';
param_1[0x11d] = '\0';
param_1[0x11e] = '\0';
param_1[0x11f] = '\0';
param_1[0x120] = '\0';
param_1[0x121] = '\0';
param_1[0x122] = '\0';
param_1[0x123] = '\0';
param_1[0x124] = '\0';
param_1[0x125] = '\0';
param_1[0x126] = '\0';
param_1[0x127] = '\0';
goto LAB_001a080a;
}
my_large_free(*(int8 *)(param_1 + 0xa8),*(int8 *)(param_1 + 0x10));
param_1[0xa8] = '\0';
param_1[0xa9] = '\0';
param_1[0xaa] = '\0';
param_1[0xab] = '\0';
param_1[0xac] = '\0';
param_1[0xad] = '\0';
param_1[0xae] = '\0';
param_1[0xaf] = '\0';
}
if (uVar16 < 8) goto LAB_001a06d0;
uVar7 = (uVar16 >> 2) * 3;
uVar12 = (ulong)*(uint *)(param_1 + 0x18);
} while( true );
}
param_1[3] = '\0';
uVar16 = (ulong)*(uint *)(param_1 + 0x48);
LAB_001a080a:
iVar5 = 0;
if (0 < (int)uVar16) {
iVar5 = (int)uVar16;
}
*(int *)(param_1 + 0x160) = iVar5;
}
LAB_001a081a:
return uVar16 & 0xffffffff;
LAB_001a06d0:
puVar8 = (int4 *)_my_thread_var();
*puVar8 = 0xc;
my_error(5,0x1000,uVar16 * *(uint *)(param_1 + 0x18));
puVar8 = (int4 *)_my_thread_var();
uVar2 = *puVar8;
param_1[0x48] = '\0';
param_1[0x49] = '\0';
param_1[0x4a] = '\0';
param_1[0x4b] = '\0';
param_1[0x160] = '\0';
param_1[0x161] = '\0';
param_1[0x162] = '\0';
param_1[0x163] = '\0';
if (*(long *)(param_1 + 0xa8) != 0) {
my_large_free(*(long *)(param_1 + 0xa8),*(int8 *)(param_1 + 0x10));
param_1[0xa8] = '\0';
param_1[0xa9] = '\0';
param_1[0xaa] = '\0';
param_1[0xab] = '\0';
param_1[0xac] = '\0';
param_1[0xad] = '\0';
param_1[0xae] = '\0';
param_1[0xaf] = '\0';
}
if (*plVar1 != 0) {
my_free();
*plVar1 = 0;
}
puVar8 = (int4 *)_my_thread_var();
*puVar8 = uVar2;
param_1[3] = '\0';
uVar16 = 0;
goto LAB_001a081a;
}
| |
50,672 | nlohmann::json_abi_v3_11_3::detail::json_ref<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>>::moved_or_copied() const | monkey531[P]llama/common/json.hpp | value_type moved_or_copied() const
{
if (value_ref == nullptr)
{
return std::move(owned_value);
}
return *value_ref;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::json_ref<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>>::moved_or_copied() const:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0xa6689
movq %rbx, %rdi
callq 0x706e0
jmp 0xa66b3
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x6b800
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6b800
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rsi, [rsi+10h]
test rsi, rsi
jz short loc_A6689
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
jmp short loc_A66B3
loc_A6689:
movups xmm0, xmmword ptr [r14]
movups xmmword ptr [rbx], xmm0
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 byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, rbx
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_A66B3:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| unsigned __int8 * nlohmann::json_abi_v3_11_3::detail::json_ref<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>>::moved_or_copied(
unsigned __int8 *a1,
long long a2)
{
unsigned __int8 *v3; // rsi
v3 = *(unsigned __int8 **)(a2 + 16);
if ( 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>::basic_json(
a1,
v3);
}
else
{
*(_OWORD *)a1 = *(_OWORD *)a2;
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 *)a2);
*(_BYTE *)a2 = 0;
*(_QWORD *)(a2 + 8) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
}
return a1;
}
| moved_or_copied:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RSI + 0x10]
TEST RSI,RSI
JZ 0x001a6689
MOV RDI,RBX
CALL 0x001706e0
JMP 0x001a66b3
LAB_001a6689:
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RBX],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x0016b800
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,RBX
MOV ESI,0x1
CALL 0x0016b800
LAB_001a66b3:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_ref<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> >::moved_or_copied() const */
void nlohmann::json_abi_v3_11_3::detail::
json_ref<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>>
::moved_or_copied(void)
{
int8 uVar1;
int8 *in_RSI;
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>
*in_RDI;
if ((basic_json *)in_RSI[2] == (basic_json *)0x0) {
uVar1 = in_RSI[1];
*(int8 *)in_RDI = *in_RSI;
*(int8 *)(in_RDI + 8) = uVar1;
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(in_RSI,0));
*(int1 *)in_RSI = 0;
in_RSI[1] = 0;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(in_RDI,0));
}
else {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(in_RDI,(basic_json *)in_RSI[2]);
}
return;
}
| |
50,673 | write_full_pages | eloqsql/storage/maria/ma_blockrec.c | static my_bool write_full_pages(MARIA_HA *info,
LSN lsn,
MARIA_BITMAP_BLOCK *block,
uchar *data, ulong length)
{
pgcache_page_no_t page;
MARIA_SHARE *share= info->s;
uint block_size= share->block_size;
uint data_size= FULL_PAGE_SIZE(share);
uchar *buff= info->keyread_buff;
uint page_count, sub_blocks;
my_off_t position, max_position;
DBUG_ENTER("write_full_pages");
DBUG_PRINT("enter", ("length: %lu page: %lu page_count: %lu",
(ulong) length, (ulong) block->page,
(ulong) block->page_count));
DBUG_ASSERT((block->page_count & TAIL_BIT) == 0);
info->keyread_buff_used= 1;
page= block->page;
page_count= block->page_count;
sub_blocks= block->sub_blocks;
max_position= (my_off_t) (page + page_count) * block_size;
/* Increase data file size, if extended */
for (; length; data+= data_size)
{
uint copy_length;
if (!page_count--)
{
if (!--sub_blocks)
{
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
DBUG_RETURN(1);
}
block++;
page= block->page;
page_count= block->page_count - 1;
DBUG_PRINT("info", ("page: %lu page_count: %lu",
(ulong) block->page, (ulong) block->page_count));
position= (page + page_count + 1) * block_size;
set_if_bigger(max_position, position);
}
lsn_store(buff, lsn);
buff[PAGE_TYPE_OFFSET]= (uchar) BLOB_PAGE;
bzero(buff + LSN_SIZE + PAGE_TYPE_SIZE,
FULL_PAGE_HEADER_SIZE(share) - (LSN_SIZE + PAGE_TYPE_SIZE));
copy_length= MY_MIN(data_size, length);
memcpy(buff + FULL_PAGE_HEADER_SIZE(share), data, copy_length);
length-= copy_length;
/*
Zero out old information from the block. This removes possible
sensitive information from the block and also makes the file
easier to compress and easier to compare after recovery.
*/
if (copy_length != data_size)
bzero(buff + block_size - PAGE_SUFFIX_SIZE - (data_size - copy_length),
(data_size - copy_length) + PAGE_SUFFIX_SIZE);
if (pagecache_write(share->pagecache,
&info->dfile, page, 0,
buff, share->page_type,
PAGECACHE_LOCK_LEFT_UNLOCKED,
PAGECACHE_PIN_LEFT_UNPINNED,
PAGECACHE_WRITE_DELAY,
0, info->trn->rec_lsn))
DBUG_RETURN(1);
page++;
DBUG_ASSERT(block->used & BLOCKUSED_USED);
}
if (share->state.state.data_file_length < max_position)
_ma_set_share_data_file_length(share, max_position);
DBUG_RETURN(0);
} | O0 | c | write_full_pages:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movl 0x7bc(%rax), %eax
movq -0x40(%rbp), %rcx
movl 0xc18(%rcx), %ecx
addl $0x8, %ecx
subl %ecx, %eax
subl $0x4, %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x380(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x813a7
jmp 0x813a9
jmp 0x813ab
movq -0x10(%rbp), %rax
movb $0x1, 0x685(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movl -0x54(%rbp), %ecx
addq %rcx, %rax
movl -0x44(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x81656
movl -0x54(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x54(%rbp)
cmpl $0x0, %eax
jne 0x8147f
movl -0x58(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x58(%rbp)
cmpl $0x0, %eax
jne 0x8142a
movq -0x10(%rbp), %rdi
movl $0x7f, %esi
callq 0x33880
movb $0x1, -0x1(%rbp)
jmp 0x81677
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x81450
movq -0x38(%rbp), %rax
movl -0x54(%rbp), %ecx
addq %rcx, %rax
addq $0x1, %rax
movl -0x44(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x60(%rbp), %rax
jae 0x8147b
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x8147d
jmp 0x8147f
jmp 0x81481
jmp 0x81483
movq -0x18(%rbp), %rax
sarq $0x20, %rax
movb %al, %cl
movq -0x50(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
sarq $0x20, %rax
shrl $0x8, %eax
movb %al, %cl
movq -0x50(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
sarq $0x20, %rax
shrl $0x10, %eax
movb %al, %cl
movq -0x50(%rbp), %rax
movb %cl, 0x2(%rax)
jmp 0x814bd
movq -0x50(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x78(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x78(%rbp), %rax
movl %ecx, (%rax)
jmp 0x814e1
movq -0x50(%rbp), %rax
movb $0x3, 0x7(%rax)
movq -0x50(%rbp), %rdi
addq $0x7, %rdi
addq $0x1, %rdi
movq -0x40(%rbp), %rax
movl 0xc18(%rax), %eax
addl $0x8, %eax
subl $0x8, %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2c0
movl -0x48(%rbp), %eax
cmpq -0x30(%rbp), %rax
jae 0x81522
movl -0x48(%rbp), %eax
movq %rax, -0x80(%rbp)
jmp 0x8152a
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movl %eax, -0x6c(%rbp)
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
movl 0xc18(%rax), %eax
addl $0x8, %eax
movl %eax, %eax
addq %rax, %rdi
movq -0x28(%rbp), %rsi
movl -0x6c(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movl -0x6c(%rbp), %eax
movl %eax, %ecx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x6c(%rbp), %eax
cmpl -0x48(%rbp), %eax
je 0x815a1
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %eax
addq %rax, %rdi
addq $-0x4, %rdi
movl -0x48(%rbp), %eax
subl -0x6c(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movl -0x48(%rbp), %eax
subl -0x6c(%rbp), %eax
addl $0x4, %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2c0
movq -0x40(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x470, %rsi # imm = 0x470
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %r8
movq -0x40(%rbp), %rax
movl 0x7d4(%rax), %r9d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x90(%rax), %r10
movq -0x40(%rbp), %rax
movq 0x600(%rax), %rax
movl 0x80(%rax), %eax
xorl %ecx, %ecx
xorl %r11d, %r11d
movl $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movl %eax, 0x30(%rsp)
callq 0x2f040
cmpb $0x0, %al
je 0x81631
jmp 0x8162b
movb $0x1, -0x1(%rbp)
jmp 0x81677
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x8163f
jmp 0x81641
movl -0x48(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x813ea
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rax
cmpq -0x68(%rbp), %rax
jae 0x81671
movq -0x40(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x372d0
jmp 0x81673
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| write_full_pages:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov eax, [rax+7BCh]
mov [rbp+var_44], eax
mov rax, [rbp+var_40]
mov eax, [rax+7BCh]
mov rcx, [rbp+var_40]
mov ecx, [rcx+0C18h]
add ecx, 8
sub eax, ecx
sub eax, 4
mov [rbp+var_48], eax
mov rax, [rbp+var_10]
mov rax, [rax+380h]
mov [rbp+var_50], rax
jmp short $+2
loc_813A7:
jmp short $+2
loc_813A9:
jmp short $+2
loc_813AB:
mov rax, [rbp+var_10]
mov byte ptr [rax+685h], 1
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
mov eax, [rax+8]
mov [rbp+var_54], eax
mov rax, [rbp+var_20]
mov eax, [rax+10h]
mov [rbp+var_58], eax
mov rax, [rbp+var_38]
mov ecx, [rbp+var_54]
add rax, rcx
mov ecx, [rbp+var_44]
imul rax, rcx
mov [rbp+var_68], rax
loc_813EA:
cmp [rbp+var_30], 0
jz loc_81656
mov eax, [rbp+var_54]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_54], ecx
cmp eax, 0
jnz short loc_8147F
mov eax, [rbp+var_58]
add eax, 0FFFFFFFFh
mov [rbp+var_58], eax
cmp eax, 0
jnz short loc_8142A
mov rdi, [rbp+var_10]
mov esi, 7Fh
call _ma_set_fatal_error
mov [rbp+var_1], 1
jmp loc_81677
loc_8142A:
mov rax, [rbp+var_20]
add rax, 18h
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
mov eax, [rax+8]
sub eax, 1
mov [rbp+var_54], eax
jmp short $+2
loc_81450:
mov rax, [rbp+var_38]
mov ecx, [rbp+var_54]
add rax, rcx
add rax, 1
mov ecx, [rbp+var_44]
imul rax, rcx
mov [rbp+var_60], rax
mov rax, [rbp+var_68]
cmp rax, [rbp+var_60]
jnb short loc_8147B
mov rax, [rbp+var_60]
mov [rbp+var_68], rax
loc_8147B:
jmp short $+2
loc_8147D:
jmp short $+2
loc_8147F:
jmp short $+2
loc_81481:
jmp short $+2
loc_81483:
mov rax, [rbp+var_18]
sar rax, 20h
mov cl, al
mov rax, [rbp+var_50]
mov [rax], cl
mov rax, [rbp+var_18]
sar rax, 20h
shr eax, 8
mov cl, al
mov rax, [rbp+var_50]
mov [rax+1], cl
mov rax, [rbp+var_18]
sar rax, 20h
shr eax, 10h
mov cl, al
mov rax, [rbp+var_50]
mov [rax+2], cl
jmp short $+2
loc_814BD:
mov rax, [rbp+var_50]
add rax, 3
mov [rbp+var_78], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_18]
mov ecx, eax
mov rax, [rbp+var_78]
mov [rax], ecx
jmp short $+2
loc_814E1:
mov rax, [rbp+var_50]
mov byte ptr [rax+7], 3
mov rdi, [rbp+var_50]
add rdi, 7
add rdi, 1
mov rax, [rbp+var_40]
mov eax, [rax+0C18h]
add eax, 8
sub eax, 8
mov eax, eax
mov edx, eax
xor esi, esi
call _memset
mov eax, [rbp+var_48]
cmp rax, [rbp+var_30]
jnb short loc_81522
mov eax, [rbp+var_48]
mov [rbp+var_80], rax
jmp short loc_8152A
loc_81522:
mov rax, [rbp+var_30]
mov [rbp+var_80], rax
loc_8152A:
mov rax, [rbp+var_80]
mov [rbp+var_6C], eax
mov rdi, [rbp+var_50]
mov rax, [rbp+var_40]
mov eax, [rax+0C18h]
add eax, 8
mov eax, eax
add rdi, rax
mov rsi, [rbp+var_28]
mov eax, [rbp+var_6C]
mov edx, eax
call _memcpy
mov eax, [rbp+var_6C]
mov ecx, eax
mov rax, [rbp+var_30]
sub rax, rcx
mov [rbp+var_30], rax
mov eax, [rbp+var_6C]
cmp eax, [rbp+var_48]
jz short loc_815A1
mov rdi, [rbp+var_50]
mov eax, [rbp+var_44]
add rdi, rax
add rdi, 0FFFFFFFFFFFFFFFCh
mov eax, [rbp+var_48]
sub eax, [rbp+var_6C]
mov eax, eax
mov ecx, eax
xor eax, eax
sub rax, rcx
add rdi, rax
mov eax, [rbp+var_48]
sub eax, [rbp+var_6C]
add eax, 4
mov eax, eax
mov edx, eax
xor esi, esi
call _memset
loc_815A1:
mov rax, [rbp+var_40]
mov rdi, [rax+600h]
mov rsi, [rbp+var_10]
add rsi, 470h
mov rdx, [rbp+var_38]
mov r8, [rbp+var_50]
mov rax, [rbp+var_40]
mov r9d, [rax+7D4h]
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov r10, [rax+90h]
mov rax, [rbp+var_40]
mov rax, [rax+600h]
mov eax, [rax+80h]
xor ecx, ecx
xor r11d, r11d
mov [rsp+0C0h+var_C0], 0
mov [rsp+0C0h+var_B8], 1
mov [rsp+0C0h+var_B0], 0
mov [rsp+0C0h+var_A8], 0
mov [rsp+0C0h+var_A0], r10
mov [rsp+0C0h+var_98], 0
mov [rsp+0C0h+var_90], eax
call pagecache_write_part
cmp al, 0
jz short loc_81631
jmp short $+2
loc_8162B:
mov [rbp+var_1], 1
jmp short loc_81677
loc_81631:
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
jmp short $+2
loc_8163F:
jmp short $+2
loc_81641:
mov ecx, [rbp+var_48]
mov rax, [rbp+var_28]
mov ecx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp loc_813EA
loc_81656:
mov rax, [rbp+var_40]
mov rax, [rax+40h]
cmp rax, [rbp+var_68]
jnb short loc_81671
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_68]
call _ma_set_share_data_file_length
loc_81671:
jmp short $+2
loc_81673:
mov [rbp+var_1], 0
loc_81677:
mov al, [rbp+var_1]
add rsp, 0C0h
pop rbp
retn
| char write_full_pages(long long a1, long long a2, long long a3, long long a4, long long a5, int a6)
{
unsigned int v6; // eax
long long v7; // rcx
unsigned int v9; // [rsp+40h] [rbp-80h]
unsigned long long v10; // [rsp+58h] [rbp-68h]
int v11; // [rsp+68h] [rbp-58h]
unsigned int v12; // [rsp+6Ch] [rbp-54h]
long long v13; // [rsp+70h] [rbp-50h]
unsigned int v14; // [rsp+78h] [rbp-48h]
unsigned int v15; // [rsp+7Ch] [rbp-44h]
long long v16; // [rsp+80h] [rbp-40h]
long long v17; // [rsp+88h] [rbp-38h]
unsigned long long v18; // [rsp+90h] [rbp-30h]
long long v20; // [rsp+A0h] [rbp-20h]
v20 = a3;
v18 = a5;
v16 = *(_QWORD *)a1;
v15 = *(_DWORD *)(*(_QWORD *)a1 + 1980LL);
v14 = *(_DWORD *)(v16 + 1980) - (*(_DWORD *)(v16 + 3096) + 8) - 4;
v13 = *(_QWORD *)(a1 + 896);
*(_BYTE *)(a1 + 1669) = 1;
v17 = *(_QWORD *)a3;
v12 = *(_DWORD *)(a3 + 8);
v11 = *(_DWORD *)(a3 + 16);
v10 = v15 * (v12 + *(_QWORD *)a3);
while ( v18 )
{
v6 = v12;
v7 = --v12;
if ( !v6 )
{
if ( !--v11 )
{
ma_set_fatal_error((_DWORD *)a1, 127, a3, v7, a5, a6);
return 1;
}
v20 += 24LL;
v17 = *(_QWORD *)v20;
v12 = *(_DWORD *)(v20 + 8) - 1;
if ( v10 < v15 * ((unsigned long long)v12 + *(_QWORD *)v20 + 1) )
v10 = v15 * (v12 + *(_QWORD *)v20 + 1LL);
}
*(_WORD *)v13 = WORD2(a2);
*(_BYTE *)(v13 + 2) = BYTE6(a2);
*(_DWORD *)(v13 + 3) = a2;
*(_BYTE *)(v13 + 7) = 3;
memset(v13 + 8, 0LL, *(unsigned int *)(v16 + 3096));
if ( v14 >= v18 )
v9 = v18;
else
v9 = v14;
memcpy((unsigned int)(*(_DWORD *)(v16 + 3096) + 8) + v13, a4, v9);
v18 -= v9;
if ( v9 != v14 )
memset(v15 + v13 - 4 - (v14 - v9), 0LL, v14 - v9 + 4);
if ( pagecache_write_part(
*(_QWORD **)(v16 + 1536),
a1 + 1136,
v17,
0,
v13,
*(_DWORD *)(v16 + 2004),
0,
1u,
0,
0LL,
*(_QWORD *)(*(_QWORD *)(a1 + 8) + 144LL),
0,
*(_DWORD *)(*(_QWORD *)(v16 + 1536) + 128LL)) )
{
return 1;
}
++v17;
a4 += v14;
}
if ( *(_QWORD *)(v16 + 64) < v10 )
ma_set_share_data_file_length(v16, v10);
return 0;
}
| write_full_pages:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
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 qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV RCX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RCX + 0xc18]
ADD ECX,0x8
SUB EAX,ECX
SUB EAX,0x4
MOV dword ptr [RBP + -0x48],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x380]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001813a7
LAB_001813a7:
JMP 0x001813a9
LAB_001813a9:
JMP 0x001813ab
LAB_001813ab:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x685],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x54],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x58],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x54]
ADD RAX,RCX
MOV ECX,dword ptr [RBP + -0x44]
IMUL RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
LAB_001813ea:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00181656
MOV EAX,dword ptr [RBP + -0x54]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x54],ECX
CMP EAX,0x0
JNZ 0x0018147f
MOV EAX,dword ptr [RBP + -0x58]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x58],EAX
CMP EAX,0x0
JNZ 0x0018142a
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x7f
CALL 0x00133880
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00181677
LAB_0018142a:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x8]
SUB EAX,0x1
MOV dword ptr [RBP + -0x54],EAX
JMP 0x00181450
LAB_00181450:
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x54]
ADD RAX,RCX
ADD RAX,0x1
MOV ECX,dword ptr [RBP + -0x44]
IMUL RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x68]
CMP RAX,qword ptr [RBP + -0x60]
JNC 0x0018147b
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x68],RAX
LAB_0018147b:
JMP 0x0018147d
LAB_0018147d:
JMP 0x0018147f
LAB_0018147f:
JMP 0x00181481
LAB_00181481:
JMP 0x00181483
LAB_00181483:
MOV RAX,qword ptr [RBP + -0x18]
SAR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x50]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
SAR RAX,0x20
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x50]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x18]
SAR RAX,0x20
SHR EAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x50]
MOV byte ptr [RAX + 0x2],CL
JMP 0x001814bd
LAB_001814bd:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x3
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x18]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV dword ptr [RAX],ECX
JMP 0x001814e1
LAB_001814e1:
MOV RAX,qword ptr [RBP + -0x50]
MOV byte ptr [RAX + 0x7],0x3
MOV RDI,qword ptr [RBP + -0x50]
ADD RDI,0x7
ADD RDI,0x1
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0xc18]
ADD EAX,0x8
SUB EAX,0x8
MOV EAX,EAX
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2c0
MOV EAX,dword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00181522
MOV EAX,dword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x80],RAX
JMP 0x0018152a
LAB_00181522:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x80],RAX
LAB_0018152a:
MOV RAX,qword ptr [RBP + -0x80]
MOV dword ptr [RBP + -0x6c],EAX
MOV RDI,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX + 0xc18]
ADD EAX,0x8
MOV EAX,EAX
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x6c]
MOV EDX,EAX
CALL 0x0012a090
MOV EAX,dword ptr [RBP + -0x6c]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBP + -0x6c]
CMP EAX,dword ptr [RBP + -0x48]
JZ 0x001815a1
MOV RDI,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RBP + -0x44]
ADD RDI,RAX
ADD RDI,-0x4
MOV EAX,dword ptr [RBP + -0x48]
SUB EAX,dword ptr [RBP + -0x6c]
MOV EAX,EAX
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RDI,RAX
MOV EAX,dword ptr [RBP + -0x48]
SUB EAX,dword ptr [RBP + -0x6c]
ADD EAX,0x4
MOV EAX,EAX
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2c0
LAB_001815a1:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x470
MOV RDX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x40]
MOV R9D,dword ptr [RAX + 0x7d4]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV R10,qword ptr [RAX + 0x90]
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x600]
MOV EAX,dword ptr [RAX + 0x80]
XOR ECX,ECX
XOR R11D,R11D
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x1
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],R10
MOV dword ptr [RSP + 0x28],0x0
MOV dword ptr [RSP + 0x30],EAX
CALL 0x0012f040
CMP AL,0x0
JZ 0x00181631
JMP 0x0018162b
LAB_0018162b:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00181677
LAB_00181631:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0018163f
LAB_0018163f:
JMP 0x00181641
LAB_00181641:
MOV ECX,dword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001813ea
LAB_00181656:
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x40]
CMP RAX,qword ptr [RBP + -0x68]
JNC 0x00181671
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x68]
CALL 0x001372d0
LAB_00181671:
JMP 0x00181673
LAB_00181673:
MOV byte ptr [RBP + -0x1],0x0
LAB_00181677:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0xc0
POP RBP
RET
|
int1
write_full_pages(long *param_1,int8 param_2,long *param_3,void *param_4,ulong param_5)
{
uint uVar1;
long lVar2;
int1 *puVar3;
char cVar4;
uint uVar5;
uint uVar6;
long *plVar7;
ulong uVar8;
bool bVar9;
ulong local_88;
ulong local_70;
int local_60;
uint local_5c;
long local_40;
ulong local_38;
void *local_30;
long *local_28;
lVar2 = *param_1;
uVar1 = *(uint *)(lVar2 + 0x7bc);
uVar5 = (*(int *)(lVar2 + 0x7bc) - (*(int *)(lVar2 + 0xc18) + 8)) - 4;
puVar3 = (int1 *)param_1[0x70];
*(int1 *)((long)param_1 + 0x685) = 1;
local_40 = *param_3;
local_5c = *(uint *)(param_3 + 1);
local_60 = (int)param_3[2];
local_70 = (local_40 + (ulong)local_5c) * (ulong)uVar1;
local_38 = param_5;
local_30 = param_4;
local_28 = param_3;
while( true ) {
if (local_38 == 0) {
if (*(ulong *)(lVar2 + 0x40) < local_70) {
_ma_set_share_data_file_length(lVar2,local_70);
}
return 0;
}
bVar9 = local_5c == 0;
local_5c = local_5c - 1;
if (bVar9) {
local_60 = local_60 + -1;
if (local_60 == 0) {
_ma_set_fatal_error(param_1,0x7f);
return 1;
}
plVar7 = local_28 + 3;
local_40 = *plVar7;
local_5c = (int)local_28[4] - 1;
uVar8 = (local_40 + (ulong)local_5c + 1) * (ulong)uVar1;
local_28 = plVar7;
if (local_70 < uVar8) {
local_70 = uVar8;
}
}
*puVar3 = (char)((ulong)param_2 >> 0x20);
puVar3[1] = (char)((ulong)param_2 >> 0x28);
puVar3[2] = (char)((ulong)param_2 >> 0x30);
*(int *)(puVar3 + 3) = (int)param_2;
puVar3[7] = 3;
memset(puVar3 + 8,0,(ulong)*(uint *)(lVar2 + 0xc18));
if (uVar5 < local_38) {
local_88 = (ulong)uVar5;
}
else {
local_88 = local_38;
}
uVar6 = (uint)local_88;
memcpy(puVar3 + (*(int *)(lVar2 + 0xc18) + 8),local_30,local_88 & 0xffffffff);
local_38 = local_38 - (local_88 & 0xffffffff);
if (uVar6 != uVar5) {
memset(puVar3 + (((ulong)uVar1 - 4) - (ulong)(uVar5 - uVar6)),0,(ulong)((uVar5 - uVar6) + 4));
}
cVar4 = pagecache_write_part
(*(int8 *)(lVar2 + 0x600),param_1 + 0x8e,local_40,0,puVar3,
*(int4 *)(lVar2 + 0x7d4),0,1,0,0,*(int8 *)(param_1[1] + 0x90),0,
*(int4 *)(*(long *)(lVar2 + 0x600) + 0x80));
if (cVar4 != '\0') break;
local_40 = local_40 + 1;
local_30 = (void *)((long)local_30 + (ulong)uVar5);
}
return 1;
}
| |
50,674 | write_full_pages | eloqsql/storage/maria/ma_blockrec.c | static my_bool write_full_pages(MARIA_HA *info,
LSN lsn,
MARIA_BITMAP_BLOCK *block,
uchar *data, ulong length)
{
pgcache_page_no_t page;
MARIA_SHARE *share= info->s;
uint block_size= share->block_size;
uint data_size= FULL_PAGE_SIZE(share);
uchar *buff= info->keyread_buff;
uint page_count, sub_blocks;
my_off_t position, max_position;
DBUG_ENTER("write_full_pages");
DBUG_PRINT("enter", ("length: %lu page: %lu page_count: %lu",
(ulong) length, (ulong) block->page,
(ulong) block->page_count));
DBUG_ASSERT((block->page_count & TAIL_BIT) == 0);
info->keyread_buff_used= 1;
page= block->page;
page_count= block->page_count;
sub_blocks= block->sub_blocks;
max_position= (my_off_t) (page + page_count) * block_size;
/* Increase data file size, if extended */
for (; length; data+= data_size)
{
uint copy_length;
if (!page_count--)
{
if (!--sub_blocks)
{
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
DBUG_RETURN(1);
}
block++;
page= block->page;
page_count= block->page_count - 1;
DBUG_PRINT("info", ("page: %lu page_count: %lu",
(ulong) block->page, (ulong) block->page_count));
position= (page + page_count + 1) * block_size;
set_if_bigger(max_position, position);
}
lsn_store(buff, lsn);
buff[PAGE_TYPE_OFFSET]= (uchar) BLOB_PAGE;
bzero(buff + LSN_SIZE + PAGE_TYPE_SIZE,
FULL_PAGE_HEADER_SIZE(share) - (LSN_SIZE + PAGE_TYPE_SIZE));
copy_length= MY_MIN(data_size, length);
memcpy(buff + FULL_PAGE_HEADER_SIZE(share), data, copy_length);
length-= copy_length;
/*
Zero out old information from the block. This removes possible
sensitive information from the block and also makes the file
easier to compress and easier to compare after recovery.
*/
if (copy_length != data_size)
bzero(buff + block_size - PAGE_SUFFIX_SIZE - (data_size - copy_length),
(data_size - copy_length) + PAGE_SUFFIX_SIZE);
if (pagecache_write(share->pagecache,
&info->dfile, page, 0,
buff, share->page_type,
PAGECACHE_LOCK_LEFT_UNLOCKED,
PAGECACHE_PIN_LEFT_UNPINNED,
PAGECACHE_WRITE_DELAY,
0, info->trn->rec_lsn))
DBUG_RETURN(1);
page++;
DBUG_ASSERT(block->used & BLOCKUSED_USED);
}
if (share->state.state.data_file_length < max_position)
_ma_set_share_data_file_length(share, max_position);
DBUG_RETURN(0);
} | O3 | c | write_full_pages:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r14
movq %rcx, %r15
movq (%rdi), %rax
movl 0x7bc(%rax), %r8d
movq %rax, -0x40(%rbp)
movl 0xc18(%rax), %eax
movl %r8d, %ecx
subl %eax, %ecx
movq 0x380(%rdi), %r12
movb $0x1, 0x685(%rdi)
movq (%rdx), %r13
movl 0x8(%rdx), %r9d
leaq (%r9,%r13), %rax
imulq %r8, %rax
movq %rax, -0x38(%rbp)
testq %r14, %r14
je 0x63b6e
addl $-0xc, %ecx
movl %ecx, -0x44(%rbp)
movl 0x10(%rdx), %eax
movl %eax, -0x2c(%rbp)
movq %rsi, %rax
shrq $0x20, %rax
movq %rax, -0xa8(%rbp)
movq %rsi, %rax
shrq $0x28, %rax
movq %rax, -0xa0(%rbp)
movq %rsi, %rax
shrq $0x30, %rax
movq %rax, -0x98(%rbp)
leaq 0x8(%r12), %rax
movq %rax, -0x90(%rbp)
movl %ecx, %ebx
leaq -0x4(%r12,%r8), %rax
movq %rax, -0x68(%rbp)
leaq 0x470(%rdi), %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x60(%rbp)
movq %r8, -0x78(%rbp)
movq %rsi, -0x80(%rbp)
movq %rbx, -0x70(%rbp)
subl $0x1, %r9d
movq %r15, -0xb0(%rbp)
jae 0x63a5f
movl -0x2c(%rbp), %eax
decl %eax
je 0x63b85
movl %eax, -0x2c(%rbp)
movq 0x18(%rdx), %r13
movl 0x20(%rdx), %ecx
leaq 0x18(%rdx), %rax
decl %ecx
movq %rcx, -0x50(%rbp)
addq %r13, %rcx
incq %rcx
imulq %r8, %rcx
movq -0x38(%rbp), %rdx
cmpq %rcx, %rdx
cmovbeq %rcx, %rdx
movq %rdx, -0x38(%rbp)
movq %rax, -0x58(%rbp)
jmp 0x63a67
movq %r9, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq -0xa8(%rbp), %rax
movb %al, (%r12)
movq -0xa0(%rbp), %rax
movb %al, 0x1(%r12)
movq -0x98(%rbp), %rax
movb %al, 0x2(%r12)
movl %esi, 0x3(%r12)
movb $0x3, 0x7(%r12)
movq -0x40(%rbp), %r15
movl 0xc18(%r15), %edx
movq -0x90(%rbp), %rdi
xorl %esi, %esi
callq 0x292c0
cmpq %rbx, %r14
cmovbq %r14, %rbx
movl 0xc18(%r15), %edi
addl $0x8, %edi
addq %r12, %rdi
movq -0xb0(%rbp), %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x29080
movl -0x44(%rbp), %eax
movl %eax, %edx
subl %ebx, %edx
je 0x63aee
movq -0x68(%rbp), %rdi
subq %rdx, %rdi
addl $0x4, %edx
xorl %esi, %esi
callq 0x292c0
movq -0x40(%rbp), %rax
movq 0x600(%rax), %rdi
movl 0x7d4(%rax), %r9d
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x80(%rdi), %r10d
subq $0x8, %rsp
movq -0x88(%rbp), %rsi
movq %r13, %rdx
xorl %ecx, %ecx
movq %r12, %r8
pushq %r10
xorl %r10d, %r10d
pushq %r10
pushq 0x90(%rax)
pushq $0x0
pushq %r10
pushq $0x1
pushq %r10
callq 0x33982
addq $0x40, %rsp
testb %al, %al
jne 0x63b8f
subq %rbx, %r14
incq %r13
movq -0x70(%rbp), %rbx
addq %rbx, %r15
testq %r14, %r14
movq -0x60(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %r8
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %r9
jne 0x63a14
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
cmpq %rsi, 0x40(%rdi)
jae 0x63b81
callq 0x38c08
xorl %eax, %eax
jmp 0x63b91
movl $0x7f, %esi
callq 0x36930
movb $0x1, %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| write_full_pages:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov r14, r8
mov r15, rcx
mov rax, [rdi]
mov r8d, [rax+7BCh]
mov [rbp+var_40], rax
mov eax, [rax+0C18h]
mov ecx, r8d
sub ecx, eax
mov r12, [rdi+380h]
mov byte ptr [rdi+685h], 1
mov r13, [rdx]
mov r9d, [rdx+8]
lea rax, [r9+r13]
imul rax, r8
mov [rbp+var_38], rax
test r14, r14
jz loc_63B6E
add ecx, 0FFFFFFF4h
mov [rbp+var_44], ecx
mov eax, [rdx+10h]
mov [rbp+var_2C], eax
mov rax, rsi
shr rax, 20h
mov [rbp+var_A8], rax
mov rax, rsi
shr rax, 28h
mov [rbp+var_A0], rax
mov rax, rsi
shr rax, 30h
mov [rbp+var_98], rax
lea rax, [r12+8]
mov [rbp+var_90], rax
mov ebx, ecx
lea rax, [r12+r8-4]
mov [rbp+var_68], rax
lea rax, [rdi+470h]
mov [rbp+var_88], rax
mov [rbp+var_60], rdi
mov [rbp+var_78], r8
mov [rbp+var_80], rsi
mov [rbp+var_70], rbx
loc_63A14:
sub r9d, 1
mov [rbp+var_B0], r15
jnb short loc_63A5F
mov eax, [rbp+var_2C]
dec eax
jz loc_63B85
mov [rbp+var_2C], eax
mov r13, [rdx+18h]
mov ecx, [rdx+20h]
lea rax, [rdx+18h]
dec ecx
mov [rbp+var_50], rcx
add rcx, r13
inc rcx
imul rcx, r8
mov rdx, [rbp+var_38]
cmp rdx, rcx
cmovbe rdx, rcx
mov [rbp+var_38], rdx
mov [rbp+var_58], rax
jmp short loc_63A67
loc_63A5F:
mov [rbp+var_50], r9
mov [rbp+var_58], rdx
loc_63A67:
mov rax, [rbp+var_A8]
mov [r12], al
mov rax, [rbp+var_A0]
mov [r12+1], al
mov rax, [rbp+var_98]
mov [r12+2], al
mov [r12+3], esi
mov byte ptr [r12+7], 3
mov r15, [rbp+var_40]
mov edx, [r15+0C18h]
mov rdi, [rbp+var_90]
xor esi, esi
call _memset
cmp r14, rbx
cmovb rbx, r14
mov edi, [r15+0C18h]
add edi, 8
add rdi, r12
mov r15, [rbp+var_B0]
mov rsi, r15
mov rdx, rbx
call _memcpy
mov eax, [rbp+var_44]
mov edx, eax
sub edx, ebx
jz short loc_63AEE
mov rdi, [rbp+var_68]
sub rdi, rdx
add edx, 4
xor esi, esi
call _memset
loc_63AEE:
mov rax, [rbp+var_40]
mov rdi, [rax+600h]
mov r9d, [rax+7D4h]
mov rax, [rbp+var_60]
mov rax, [rax+8]
mov r10d, [rdi+80h]
sub rsp, 8
mov rsi, [rbp+var_88]
mov rdx, r13
xor ecx, ecx
mov r8, r12
push r10
xor r10d, r10d
push r10
push qword ptr [rax+90h]
push 0
push r10
push 1
push r10
call pagecache_write_part
add rsp, 40h
test al, al
jnz short loc_63B8F
sub r14, rbx
inc r13
mov rbx, [rbp+var_70]
add r15, rbx
test r14, r14
mov rdi, [rbp+var_60]
mov rsi, [rbp+var_80]
mov r8, [rbp+var_78]
mov rdx, [rbp+var_58]
mov r9, [rbp+var_50]
jnz loc_63A14
loc_63B6E:
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_38]
cmp [rdi+40h], rsi
jnb short loc_63B81
call _ma_set_share_data_file_length
loc_63B81:
xor eax, eax
jmp short loc_63B91
loc_63B85:
mov esi, 7Fh
call _ma_set_fatal_error
loc_63B8F:
mov al, 1
loc_63B91:
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char write_full_pages(_DWORD *a1, unsigned long long a2, long long a3, long long a4, unsigned long long a5)
{
long long v7; // r8
int v8; // ecx
long long v9; // r12
long long v10; // r13
long long v11; // r9
long long v12; // rcx
unsigned long long v13; // rbx
bool v14; // cf
int v15; // r9d
long long v16; // rax
long long v17; // rdx
unsigned long long v19; // [rsp+8h] [rbp-A8h]
unsigned long long v20; // [rsp+10h] [rbp-A0h]
unsigned long long v21; // [rsp+18h] [rbp-98h]
char *v22; // [rsp+28h] [rbp-88h]
int v23; // [rsp+30h] [rbp-80h]
long long v24; // [rsp+38h] [rbp-78h]
unsigned long long v25; // [rsp+40h] [rbp-70h]
long long v26; // [rsp+48h] [rbp-68h]
_DWORD *v27; // [rsp+50h] [rbp-60h]
long long v28; // [rsp+58h] [rbp-58h]
long long v29; // [rsp+60h] [rbp-50h]
int v30; // [rsp+6Ch] [rbp-44h]
long long v31; // [rsp+70h] [rbp-40h]
unsigned long long v32; // [rsp+78h] [rbp-38h]
int v33; // [rsp+84h] [rbp-2Ch]
v7 = *(unsigned int *)(*(_QWORD *)a1 + 1980LL);
v31 = *(_QWORD *)a1;
v8 = v7 - *(_DWORD *)(*(_QWORD *)a1 + 3096LL);
v9 = *((_QWORD *)a1 + 112);
*((_BYTE *)a1 + 1669) = 1;
v10 = *(_QWORD *)a3;
v11 = *(unsigned int *)(a3 + 8);
v32 = v7 * (v11 + *(_QWORD *)a3);
if ( !a5 )
{
LABEL_15:
if ( *(_QWORD *)(v31 + 64) < v32 )
ma_set_share_data_file_length(v31, v32);
return 0;
}
v12 = (unsigned int)(v8 - 12);
v30 = v12;
v33 = *(_DWORD *)(a3 + 16);
v19 = HIDWORD(a2);
v20 = a2 >> 40;
v21 = HIWORD(a2);
v13 = (unsigned int)v12;
v26 = v9 + v7 - 4;
v22 = (char *)(a1 + 284);
v27 = a1;
v24 = v7;
v23 = a2;
v25 = (unsigned int)v12;
while ( 1 )
{
v14 = (_DWORD)v11 == 0;
v15 = v11 - 1;
if ( !v14 )
{
LODWORD(v29) = v15;
v28 = a3;
goto LABEL_9;
}
if ( v33 == 1 )
break;
--v33;
v10 = *(_QWORD *)(a3 + 24);
v16 = a3 + 24;
v29 = (unsigned int)(*(_DWORD *)(a3 + 32) - 1);
v17 = v32;
if ( v32 <= v7 * (v10 + v29 + 1) )
v17 = v7 * (v10 + v29 + 1);
v32 = v17;
v28 = v16;
LABEL_9:
*(_BYTE *)v9 = v19;
*(_BYTE *)(v9 + 1) = v20;
*(_BYTE *)(v9 + 2) = v21;
*(_DWORD *)(v9 + 3) = a2;
*(_BYTE *)(v9 + 7) = 3;
memset(v9 + 8, 0LL, *(unsigned int *)(v31 + 3096));
if ( a5 < v13 )
v13 = a5;
memcpy(v9 + (unsigned int)(*(_DWORD *)(v31 + 3096) + 8), a4, v13);
if ( v30 != (_DWORD)v13 )
memset(v26 - (unsigned int)(v30 - v13), 0LL, (unsigned int)(v30 - v13 + 4));
if ( (unsigned __int8)pagecache_write_part(
*(__m128i **)(v31 + 1536),
v22,
v10,
0,
(char *)v9,
*(_DWORD *)(v31 + 2004),
0,
1u,
0,
0LL,
*(_QWORD *)(*((_QWORD *)v27 + 1) + 144LL),
0,
*(_DWORD *)(*(_QWORD *)(v31 + 1536) + 128LL)) )
return 1;
a5 -= v13;
++v10;
v13 = v25;
a4 += v25;
a1 = v27;
LODWORD(a2) = v23;
v7 = v24;
a3 = v28;
LODWORD(v11) = v29;
if ( !a5 )
goto LABEL_15;
}
ma_set_fatal_error(a1, 127LL, a3, v12, v7, v15);
return 1;
}
| write_full_pages:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,R8
MOV R15,RCX
MOV RAX,qword ptr [RDI]
MOV R8D,dword ptr [RAX + 0x7bc]
MOV qword ptr [RBP + -0x40],RAX
MOV EAX,dword ptr [RAX + 0xc18]
MOV ECX,R8D
SUB ECX,EAX
MOV R12,qword ptr [RDI + 0x380]
MOV byte ptr [RDI + 0x685],0x1
MOV R13,qword ptr [RDX]
MOV R9D,dword ptr [RDX + 0x8]
LEA RAX,[R9 + R13*0x1]
IMUL RAX,R8
MOV qword ptr [RBP + -0x38],RAX
TEST R14,R14
JZ 0x00163b6e
ADD ECX,-0xc
MOV dword ptr [RBP + -0x44],ECX
MOV EAX,dword ptr [RDX + 0x10]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,RSI
SHR RAX,0x20
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,RSI
SHR RAX,0x28
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,RSI
SHR RAX,0x30
MOV qword ptr [RBP + -0x98],RAX
LEA RAX,[R12 + 0x8]
MOV qword ptr [RBP + -0x90],RAX
MOV EBX,ECX
LEA RAX,[R12 + R8*0x1 + -0x4]
MOV qword ptr [RBP + -0x68],RAX
LEA RAX,[RDI + 0x470]
MOV qword ptr [RBP + -0x88],RAX
MOV qword ptr [RBP + -0x60],RDI
MOV qword ptr [RBP + -0x78],R8
MOV qword ptr [RBP + -0x80],RSI
MOV qword ptr [RBP + -0x70],RBX
LAB_00163a14:
SUB R9D,0x1
MOV qword ptr [RBP + -0xb0],R15
JNC 0x00163a5f
MOV EAX,dword ptr [RBP + -0x2c]
DEC EAX
JZ 0x00163b85
MOV dword ptr [RBP + -0x2c],EAX
MOV R13,qword ptr [RDX + 0x18]
MOV ECX,dword ptr [RDX + 0x20]
LEA RAX,[RDX + 0x18]
DEC ECX
MOV qword ptr [RBP + -0x50],RCX
ADD RCX,R13
INC RCX
IMUL RCX,R8
MOV RDX,qword ptr [RBP + -0x38]
CMP RDX,RCX
CMOVBE RDX,RCX
MOV qword ptr [RBP + -0x38],RDX
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00163a67
LAB_00163a5f:
MOV qword ptr [RBP + -0x50],R9
MOV qword ptr [RBP + -0x58],RDX
LAB_00163a67:
MOV RAX,qword ptr [RBP + -0xa8]
MOV byte ptr [R12],AL
MOV RAX,qword ptr [RBP + -0xa0]
MOV byte ptr [R12 + 0x1],AL
MOV RAX,qword ptr [RBP + -0x98]
MOV byte ptr [R12 + 0x2],AL
MOV dword ptr [R12 + 0x3],ESI
MOV byte ptr [R12 + 0x7],0x3
MOV R15,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [R15 + 0xc18]
MOV RDI,qword ptr [RBP + -0x90]
XOR ESI,ESI
CALL 0x001292c0
CMP R14,RBX
CMOVC RBX,R14
MOV EDI,dword ptr [R15 + 0xc18]
ADD EDI,0x8
ADD RDI,R12
MOV R15,qword ptr [RBP + -0xb0]
MOV RSI,R15
MOV RDX,RBX
CALL 0x00129080
MOV EAX,dword ptr [RBP + -0x44]
MOV EDX,EAX
SUB EDX,EBX
JZ 0x00163aee
MOV RDI,qword ptr [RBP + -0x68]
SUB RDI,RDX
ADD EDX,0x4
XOR ESI,ESI
CALL 0x001292c0
LAB_00163aee:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0x600]
MOV R9D,dword ptr [RAX + 0x7d4]
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x8]
MOV R10D,dword ptr [RDI + 0x80]
SUB RSP,0x8
MOV RSI,qword ptr [RBP + -0x88]
MOV RDX,R13
XOR ECX,ECX
MOV R8,R12
PUSH R10
XOR R10D,R10D
PUSH R10
PUSH qword ptr [RAX + 0x90]
PUSH 0x0
PUSH R10
PUSH 0x1
PUSH R10
CALL 0x00133982
ADD RSP,0x40
TEST AL,AL
JNZ 0x00163b8f
SUB R14,RBX
INC R13
MOV RBX,qword ptr [RBP + -0x70]
ADD R15,RBX
TEST R14,R14
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x80]
MOV R8,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x58]
MOV R9,qword ptr [RBP + -0x50]
JNZ 0x00163a14
LAB_00163b6e:
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x38]
CMP qword ptr [RDI + 0x40],RSI
JNC 0x00163b81
CALL 0x00138c08
LAB_00163b81:
XOR EAX,EAX
JMP 0x00163b91
LAB_00163b85:
MOV ESI,0x7f
CALL 0x00136930
LAB_00163b8f:
MOV AL,0x1
LAB_00163b91:
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
write_full_pages(long *param_1,int8 param_2,long *param_3,void *param_4,ulong param_5)
{
long lVar1;
int1 *puVar2;
char cVar3;
uint uVar4;
ulong uVar5;
uint uVar6;
ulong uVar7;
ulong uVar8;
int iVar9;
long lVar10;
long *local_60;
ulong local_58;
ulong local_40;
int local_34;
lVar1 = *param_1;
uVar4 = *(uint *)(lVar1 + 0x7bc);
uVar8 = (ulong)uVar4;
iVar9 = *(int *)(lVar1 + 0xc18);
puVar2 = (int1 *)param_1[0x70];
*(int1 *)((long)param_1 + 0x685) = 1;
lVar10 = *param_3;
local_58 = (ulong)*(uint *)(param_3 + 1);
local_40 = (local_58 + lVar10) * uVar8;
if (param_5 != 0) {
uVar4 = (uVar4 - iVar9) - 0xc;
local_34 = (int)param_3[2];
uVar7 = (ulong)uVar4;
do {
iVar9 = (int)local_58;
local_58 = (ulong)(iVar9 - 1);
local_60 = param_3;
if (iVar9 == 0) {
local_34 = local_34 + -1;
if (local_34 == 0) {
_ma_set_fatal_error(param_1,0x7f);
return 1;
}
lVar10 = param_3[3];
local_60 = param_3 + 3;
local_58 = (ulong)((int)param_3[4] - 1);
uVar5 = (local_58 + lVar10 + 1) * uVar8;
if (local_40 <= uVar5) {
local_40 = uVar5;
}
}
*puVar2 = (char)((ulong)param_2 >> 0x20);
puVar2[1] = (char)((ulong)param_2 >> 0x28);
puVar2[2] = (char)((ulong)param_2 >> 0x30);
*(int *)(puVar2 + 3) = (int)param_2;
puVar2[7] = 3;
memset(puVar2 + 8,0,(ulong)*(uint *)(lVar1 + 0xc18));
uVar5 = uVar7;
if (param_5 < uVar7) {
uVar5 = param_5;
}
memcpy(puVar2 + (*(int *)(lVar1 + 0xc18) + 8),param_4,uVar5);
uVar6 = uVar4 - (int)uVar5;
if (uVar6 != 0) {
memset(puVar2 + ((uVar8 - 4) - (ulong)uVar6),0,(ulong)(uVar6 + 4));
}
cVar3 = pagecache_write_part
(*(long *)(lVar1 + 0x600),param_1 + 0x8e,lVar10,0,puVar2,
*(int4 *)(lVar1 + 0x7d4),0,1,0,0,*(int8 *)(param_1[1] + 0x90),0
,*(int4 *)(*(long *)(lVar1 + 0x600) + 0x80));
if (cVar3 != '\0') {
return 1;
}
param_5 = param_5 - uVar5;
lVar10 = lVar10 + 1;
param_4 = (void *)((long)param_4 + uVar7);
param_3 = local_60;
} while (param_5 != 0);
}
if (*(ulong *)(lVar1 + 0x40) < local_40) {
_ma_set_share_data_file_length();
}
return 0;
}
| |
50,675 | add_compiled_extra_collation | eloqsql/mysys/charset.c | void add_compiled_extra_collation(struct charset_info_st *cs)
{
DBUG_ASSERT(cs->number < array_elements(all_charsets));
all_charsets[cs->number]= cs;
cs->state|= MY_CS_AVAILABLE;
if ((my_hash_insert(&charset_name_hash, (uchar*) cs)))
{
CHARSET_INFO *org= (CHARSET_INFO*) my_hash_search(&charset_name_hash,
(uchar*) cs->cs_name.str,
cs->cs_name.length);
cs->cs_name= org->cs_name;
}
} | O0 | c | add_compiled_extra_collation:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0xfedee
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0xbb0d3f(%rip), %rax # 0xcafb40
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x200, %ecx # imm = 0x200
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rsi
leaq 0xbb4d20(%rip), %rdi # 0xcb3b40
callq 0x103f50
cmpb $0x0, %al
je 0xfee61
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0xbb4d00(%rip), %rdi # 0xcb3b40
callq 0x103b60
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| add_compiled_extra_collation:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_FEDEE:
mov rdx, [rbp+var_8]
mov rax, [rbp+var_8]
mov eax, [rax]
mov ecx, eax
lea rax, all_charsets
mov [rax+rcx*8], rdx
mov rax, [rbp+var_8]
mov ecx, [rax+0Ch]
or ecx, 200h
mov [rax+0Ch], ecx
mov rsi, [rbp+var_8]
lea rdi, charset_name_hash
call my_hash_insert
cmp al, 0
jz short loc_FEE61
mov rax, [rbp+var_8]
mov rsi, [rax+10h]
mov rax, [rbp+var_8]
mov rdx, [rax+18h]
lea rdi, charset_name_hash
call my_hash_search
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rcx, [rbp+var_10]
mov rdx, [rcx+10h]
mov [rax+10h], rdx
mov rcx, [rcx+18h]
mov [rax+18h], rcx
loc_FEE61:
add rsp, 10h
pop rbp
retn
| long long add_compiled_extra_collation(unsigned int *a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-10h]
all_charsets[*a1] = a1;
a1[3] |= 0x200u;
result = my_hash_insert(&charset_name_hash, a1);
if ( (_BYTE)result )
{
v2 = my_hash_search(&charset_name_hash, *((_QWORD *)a1 + 2), *((_QWORD *)a1 + 3));
result = (long long)a1;
*((_QWORD *)a1 + 2) = *(_QWORD *)(v2 + 16);
*((_QWORD *)a1 + 3) = *(_QWORD *)(v2 + 24);
}
return result;
}
| add_compiled_extra_collation:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x001fedee
LAB_001fedee:
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
MOV ECX,EAX
LEA RAX,[0xdafb40]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0xc]
OR ECX,0x200
MOV dword ptr [RAX + 0xc],ECX
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[0xdb3b40]
CALL 0x00203f50
CMP AL,0x0
JZ 0x001fee61
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RAX + 0x18]
LEA RDI,[0xdb3b40]
CALL 0x00203b60
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX + 0x10]
MOV qword ptr [RAX + 0x10],RDX
MOV RCX,qword ptr [RCX + 0x18]
MOV qword ptr [RAX + 0x18],RCX
LAB_001fee61:
ADD RSP,0x10
POP RBP
RET
|
void add_compiled_extra_collation(uint *param_1)
{
char cVar1;
long lVar2;
(&all_charsets)[*param_1] = param_1;
param_1[3] = param_1[3] | 0x200;
cVar1 = my_hash_insert(charset_name_hash,param_1);
if (cVar1 != '\0') {
lVar2 = my_hash_search(charset_name_hash,*(int8 *)(param_1 + 4),
*(int8 *)(param_1 + 6));
*(int8 *)(param_1 + 4) = *(int8 *)(lVar2 + 0x10);
*(int8 *)(param_1 + 6) = *(int8 *)(lVar2 + 0x18);
}
return;
}
| |
50,676 | init_extent | eloqsql/storage/maria/ma_blockrec.c | static void init_extent(MARIA_EXTENT_CURSOR *extent, uchar *extent_info,
uint extents, MARIA_RECORD_POS *tail_positions)
{
uint page_count;
extent->extent= extent_info;
extent->extent_count= extents;
extent->page= page_korr(extent_info); /* First extent */
page_count= (uint2korr(extent_info + ROW_EXTENT_PAGE_SIZE) &
~START_EXTENT_BIT);
extent->tail= page_count & TAIL_BIT;
if (extent->tail)
{
extent->page_count= 1;
extent->tail_row_nr= page_count & ~TAIL_BIT;
}
else
extent->page_count= page_count;
extent->tail_positions= tail_positions;
extent->lock_for_tail_pages= PAGECACHE_LOCK_LEFT_UNLOCKED;
} | O0 | c | init_extent:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x58b40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movzwl 0x5(%rax), %eax
andl $0xffffbfff, %eax # imm = 0xFFFFBFFF
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
andl $0x8000, %ecx # imm = 0x8000
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x56c77
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
movl -0x24(%rbp), %ecx
andl $0xffff7fff, %ecx # imm = 0xFFFF7FFF
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
jmp 0x56c81
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
| init_extent:
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_20], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax], rcx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_8]
mov [rax+28h], ecx
mov rdi, [rbp+var_10]
call uint5korr_0
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+18h], rcx
mov rax, [rbp+var_10]
movzx eax, word ptr [rax+5]
and eax, 0FFFFBFFFh
mov [rbp+var_24], eax
mov ecx, [rbp+var_24]
and ecx, 8000h
mov rax, [rbp+var_8]
mov [rax+2Ch], ecx
mov rax, [rbp+var_8]
cmp dword ptr [rax+2Ch], 0
jz short loc_56C77
mov rax, [rbp+var_8]
mov dword ptr [rax+20h], 1
mov ecx, [rbp+var_24]
and ecx, 0FFFF7FFFh
mov rax, [rbp+var_8]
mov [rax+30h], ecx
jmp short loc_56C81
loc_56C77:
mov ecx, [rbp+var_24]
mov rax, [rbp+var_8]
mov [rax+20h], ecx
loc_56C81:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
mov rax, [rbp+var_8]
mov dword ptr [rax+24h], 0
add rsp, 30h
pop rbp
retn
| long long init_extent(long long a1, long long a2, int a3, long long a4)
{
long long result; // rax
int v5; // [rsp+Ch] [rbp-24h]
*(_QWORD *)a1 = a2;
*(_DWORD *)(a1 + 40) = a3;
*(_QWORD *)(a1 + 24) = uint5korr_0(a2);
v5 = *(_WORD *)(a2 + 5) & 0xBFFF;
*(_DWORD *)(a1 + 44) = *(_WORD *)(a2 + 5) & 0x8000;
if ( *(_DWORD *)(a1 + 44) )
{
*(_DWORD *)(a1 + 32) = 1;
*(_DWORD *)(a1 + 48) = v5 & 0xFFFF7FFF;
}
else
{
*(_DWORD *)(a1 + 32) = v5;
}
*(_QWORD *)(a1 + 16) = a4;
result = a1;
*(_DWORD *)(a1 + 36) = 0;
return result;
}
| init_extent:
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 qword ptr [RBP + -0x20],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x28],ECX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00158b40
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX + 0x5]
AND EAX,0xffffbfff
MOV dword ptr [RBP + -0x24],EAX
MOV ECX,dword ptr [RBP + -0x24]
AND ECX,0x8000
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2c],ECX
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x2c],0x0
JZ 0x00156c77
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x20],0x1
MOV ECX,dword ptr [RBP + -0x24]
AND ECX,0xffff7fff
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x30],ECX
JMP 0x00156c81
LAB_00156c77:
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x20],ECX
LAB_00156c81:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x24],0x0
ADD RSP,0x30
POP RBP
RET
|
void init_extent(long *param_1,long param_2,int4 param_3,long param_4)
{
uint uVar1;
long lVar2;
*param_1 = param_2;
*(int4 *)(param_1 + 5) = param_3;
lVar2 = uint5korr(param_2);
param_1[3] = lVar2;
uVar1 = (uint)*(ushort *)(param_2 + 5);
*(uint *)((long)param_1 + 0x2c) = uVar1 & 0x8000;
if (*(int *)((long)param_1 + 0x2c) == 0) {
*(uint *)(param_1 + 4) = uVar1 & 0xffffbfff;
}
else {
*(int4 *)(param_1 + 4) = 1;
*(uint *)(param_1 + 6) = uVar1 & 0xffff3fff;
}
param_1[2] = param_4;
*(int4 *)((long)param_1 + 0x24) = 0;
return;
}
| |
50,677 | trnman_exists_active_transactions | eloqsql/storage/maria/trnman.c | my_bool trnman_exists_active_transactions(TrID min_id, TrID max_id,
my_bool trnman_is_locked)
{
TRN *trn;
my_bool ret= 0;
if (!trnman_is_locked)
mysql_mutex_lock(&LOCK_trn_list);
mysql_mutex_assert_owner(&LOCK_trn_list);
for (trn= active_list_min.next; trn != &active_list_max; trn= trn->next)
{
/*
We use <= for max_id as max_id is a commit_trid and trn->trid
is transaction id. When calculating commit_trid we use the
current value of global_trid_generator. global_trid_generator is
incremented for each new transaction.
For example, assuming we have
min_id = 5
max_id = 10
A trid of value 5 can't see the history event between 5 & 10
at it vas started before min_id 5 was committed.
A trid of value 10 can't see the next history event (max_id = 10)
as it started before this was committed. In this case it must use
the this event.
*/
if (trn->trid > min_id && trn->trid <= max_id)
{
ret= 1;
break;
}
}
if (!trnman_is_locked)
mysql_mutex_unlock(&LOCK_trn_list);
return ret;
} | O0 | c | trnman_exists_active_transactions:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x21(%rbp)
cmpb $0x0, -0x11(%rbp)
jne 0x4da27
leaq 0x42a70a(%rip), %rdi # 0x478120
leaq 0x103e08(%rip), %rsi # 0x151825
movl $0x3a8, %edx # imm = 0x3A8
callq 0x4c9e0
jmp 0x4da29
jmp 0x4da2b
movq 0x42a3ae(%rip), %rax # 0x477de0
movq %rax, -0x20(%rbp)
leaq 0x42a3eb(%rip), %rax # 0x477e28
cmpq %rax, -0x20(%rbp)
je 0x4da75
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rax
cmpq -0x8(%rbp), %rax
jbe 0x4da65
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rax
cmpq -0x10(%rbp), %rax
ja 0x4da65
movb $0x1, -0x21(%rbp)
jmp 0x4da75
jmp 0x4da67
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4da36
cmpb $0x0, -0x11(%rbp)
jne 0x4da87
leaq 0x42a69e(%rip), %rdi # 0x478120
callq 0x4ca50
movb -0x21(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
| trnman_exists_active_transactions:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, dl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_11], al
mov [rbp+var_21], 0
cmp [rbp+var_11], 0
jnz short loc_4DA27
lea rdi, LOCK_trn_list
lea rsi, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 3A8h
call inline_mysql_mutex_lock_7
loc_4DA27:
jmp short $+2
loc_4DA29:
jmp short $+2
loc_4DA2B:
mov rax, cs:qword_477DE0
mov [rbp+var_20], rax
loc_4DA36:
lea rax, active_list_max
cmp [rbp+var_20], rax
jz short loc_4DA75
mov rax, [rbp+var_20]
mov rax, [rax+78h]
cmp rax, [rbp+var_8]
jbe short loc_4DA65
mov rax, [rbp+var_20]
mov rax, [rax+78h]
cmp rax, [rbp+var_10]
ja short loc_4DA65
mov [rbp+var_21], 1
jmp short loc_4DA75
loc_4DA65:
jmp short $+2
loc_4DA67:
mov rax, [rbp+var_20]
mov rax, [rax+68h]
mov [rbp+var_20], rax
jmp short loc_4DA36
loc_4DA75:
cmp [rbp+var_11], 0
jnz short loc_4DA87
lea rdi, LOCK_trn_list
call inline_mysql_mutex_unlock_7
loc_4DA87:
mov al, [rbp+var_21]
add rsp, 30h
pop rbp
retn
| char trnman_exists_active_transactions(unsigned long long a1, unsigned long long a2, char a3)
{
char v4; // [rsp+Fh] [rbp-21h]
long long i; // [rsp+10h] [rbp-20h]
v4 = 0;
if ( !a3 )
inline_mysql_mutex_lock_7(
(long long)&LOCK_trn_list,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",
0x3A8u);
for ( i = qword_477DE0; (_UNKNOWN *)i != &active_list_max; i = *(_QWORD *)(i + 104) )
{
if ( *(_QWORD *)(i + 120) > a1 && *(_QWORD *)(i + 120) <= a2 )
{
v4 = 1;
break;
}
}
if ( !a3 )
inline_mysql_mutex_unlock_7((long long)&LOCK_trn_list);
return v4;
}
| trnman_exists_active_transactions:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,DL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x11],AL
MOV byte ptr [RBP + -0x21],0x0
CMP byte ptr [RBP + -0x11],0x0
JNZ 0x0014da27
LEA RDI,[0x578120]
LEA RSI,[0x251825]
MOV EDX,0x3a8
CALL 0x0014c9e0
LAB_0014da27:
JMP 0x0014da29
LAB_0014da29:
JMP 0x0014da2b
LAB_0014da2b:
MOV RAX,qword ptr [0x00577de0]
MOV qword ptr [RBP + -0x20],RAX
LAB_0014da36:
LEA RAX,[0x577e28]
CMP qword ptr [RBP + -0x20],RAX
JZ 0x0014da75
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x78]
CMP RAX,qword ptr [RBP + -0x8]
JBE 0x0014da65
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x78]
CMP RAX,qword ptr [RBP + -0x10]
JA 0x0014da65
MOV byte ptr [RBP + -0x21],0x1
JMP 0x0014da75
LAB_0014da65:
JMP 0x0014da67
LAB_0014da67:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x68]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0014da36
LAB_0014da75:
CMP byte ptr [RBP + -0x11],0x0
JNZ 0x0014da87
LEA RDI,[0x578120]
CALL 0x0014ca50
LAB_0014da87:
MOV AL,byte ptr [RBP + -0x21]
ADD RSP,0x30
POP RBP
RET
|
int1 trnman_exists_active_transactions(ulong param_1,ulong param_2,char param_3)
{
int1 local_29;
int1 *local_28;
local_29 = 0;
if (param_3 == '\0') {
inline_mysql_mutex_lock
(LOCK_trn_list,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x3a8
);
}
local_28 = (int1 *)active_list_min._104_8_;
do {
if (local_28 == active_list_max) {
LAB_0014da75:
if (param_3 == '\0') {
inline_mysql_mutex_unlock(LOCK_trn_list);
}
return local_29;
}
if ((param_1 < *(ulong *)(local_28 + 0x78)) && (*(ulong *)(local_28 + 0x78) <= param_2)) {
local_29 = 1;
goto LAB_0014da75;
}
local_28 = *(int1 **)(local_28 + 0x68);
} while( true );
}
| |
50,678 | trnman_exists_active_transactions | eloqsql/storage/maria/trnman.c | my_bool trnman_exists_active_transactions(TrID min_id, TrID max_id,
my_bool trnman_is_locked)
{
TRN *trn;
my_bool ret= 0;
if (!trnman_is_locked)
mysql_mutex_lock(&LOCK_trn_list);
mysql_mutex_assert_owner(&LOCK_trn_list);
for (trn= active_list_min.next; trn != &active_list_max; trn= trn->next)
{
/*
We use <= for max_id as max_id is a commit_trid and trn->trid
is transaction id. When calculating commit_trid we use the
current value of global_trid_generator. global_trid_generator is
incremented for each new transaction.
For example, assuming we have
min_id = 5
max_id = 10
A trid of value 5 can't see the history event between 5 & 10
at it vas started before min_id 5 was committed.
A trid of value 10 can't see the next history event (max_id = 10)
as it started before this was committed. In this case it must use
the this event.
*/
if (trn->trid > min_id && trn->trid <= max_id)
{
ret= 1;
break;
}
}
if (!trnman_is_locked)
mysql_mutex_unlock(&LOCK_trn_list);
return ret;
} | O3 | c | trnman_exists_active_transactions:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testb %bl, %bl
jne 0x4766d
cmpq $0x0, 0x3b5f01(%rip) # 0x3fd560
jne 0x476ce
leaq 0x3b5eb8(%rip), %rdi # 0x3fd520
callq 0x29220
movq 0x3b5b6c(%rip), %rax # 0x3fd1e0
leaq 0x3b5bad(%rip), %rcx # 0x3fd228
cmpq %rcx, %rax
je 0x4769c
movq 0x78(%rax), %rdx
cmpq %r15, %rdx
setbe %sil
cmpq %r14, %rdx
seta %dl
orb %sil, %dl
je 0x476a1
movq 0x68(%rax), %rax
jmp 0x4767b
xorl %r14d, %r14d
jmp 0x476a4
movb $0x1, %r14b
testb %bl, %bl
jne 0x476c0
movq 0x3b5eb1(%rip), %rdi # 0x3fd560
testq %rdi, %rdi
jne 0x476d5
leaq 0x3b5e65(%rip), %rdi # 0x3fd520
callq 0x291e0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a5ee
jmp 0x4766d
leaq 0x33e934(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x476b4
| trnman_exists_active_transactions:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov ebx, edx
mov r14, rsi
mov r15, rdi
test bl, bl
jnz short loc_4766D
cmp cs:qword_3FD560, 0
jnz short loc_476CE
lea rdi, LOCK_trn_list
call _pthread_mutex_lock
loc_4766D:
mov rax, cs:qword_3FD1E0
lea rcx, active_list_max
loc_4767B:
cmp rax, rcx
jz short loc_4769C
mov rdx, [rax+78h]
cmp rdx, r15
setbe sil
cmp rdx, r14
setnbe dl
or dl, sil
jz short loc_476A1
mov rax, [rax+68h]
jmp short loc_4767B
loc_4769C:
xor r14d, r14d
jmp short loc_476A4
loc_476A1:
mov r14b, 1
loc_476A4:
test bl, bl
jnz short loc_476C0
mov rdi, cs:qword_3FD560
test rdi, rdi
jnz short loc_476D5
loc_476B4:
lea rdi, LOCK_trn_list
call _pthread_mutex_unlock
loc_476C0:
mov eax, r14d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_476CE:
call trnman_exists_active_transactions_cold_1
jmp short loc_4766D
loc_476D5:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_476B4
| long long trnman_exists_active_transactions(unsigned long long a1, unsigned long long a2, unsigned long long a3)
{
char v3; // bl
unsigned long long v4; // r14
long long i; // rax
v3 = a3;
v4 = a2;
if ( !(_BYTE)a3 )
{
if ( qword_3FD560 )
trnman_exists_active_transactions_cold_1(a1);
else
pthread_mutex_lock(&LOCK_trn_list);
}
for ( i = qword_3FD1E0; ; i = *(_QWORD *)(i + 104) )
{
if ( (_UNKNOWN *)i == &active_list_max )
{
LODWORD(v4) = 0;
goto LABEL_10;
}
a3 = *(_QWORD *)(i + 120);
LOBYTE(a2) = a3 <= a1;
LOBYTE(a3) = a3 <= a1 || a3 > v4;
if ( !(_BYTE)a3 )
break;
}
LOBYTE(v4) = 1;
LABEL_10:
if ( !v3 )
{
if ( qword_3FD560 )
((void ( *)(long long, unsigned long long, unsigned long long, void *))PSI_server[44])(
qword_3FD560,
a2,
a3,
&active_list_max);
pthread_mutex_unlock(&LOCK_trn_list);
}
return (unsigned int)v4;
}
| trnman_exists_active_transactions:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,EDX
MOV R14,RSI
MOV R15,RDI
TEST BL,BL
JNZ 0x0014766d
CMP qword ptr [0x004fd560],0x0
JNZ 0x001476ce
LEA RDI,[0x4fd520]
CALL 0x00129220
LAB_0014766d:
MOV RAX,qword ptr [0x004fd1e0]
LEA RCX,[0x4fd228]
LAB_0014767b:
CMP RAX,RCX
JZ 0x0014769c
MOV RDX,qword ptr [RAX + 0x78]
CMP RDX,R15
SETBE SIL
CMP RDX,R14
SETA DL
OR DL,SIL
JZ 0x001476a1
MOV RAX,qword ptr [RAX + 0x68]
JMP 0x0014767b
LAB_0014769c:
XOR R14D,R14D
JMP 0x001476a4
LAB_001476a1:
MOV R14B,0x1
LAB_001476a4:
TEST BL,BL
JNZ 0x001476c0
MOV RDI,qword ptr [0x004fd560]
TEST RDI,RDI
JNZ 0x001476d5
LAB_001476b4:
LEA RDI,[0x4fd520]
CALL 0x001291e0
LAB_001476c0:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001476ce:
CALL 0x0012a5ee
JMP 0x0014766d
LAB_001476d5:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001476b4
|
ulong trnman_exists_active_transactions(ulong param_1,ulong param_2,char param_3)
{
int1 *puVar1;
ulong uVar2;
puVar1 = (int1 *)active_list_min._104_8_;
if (param_3 == '\0') {
if (LOCK_trn_list._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)LOCK_trn_list);
puVar1 = (int1 *)active_list_min._104_8_;
}
else {
trnman_exists_active_transactions_cold_1();
puVar1 = (int1 *)active_list_min._104_8_;
}
}
do {
if (puVar1 == active_list_max) {
uVar2 = 0;
LAB_001476a4:
if (param_3 == '\0') {
if (LOCK_trn_list._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)LOCK_trn_list);
}
return uVar2 & 0xffffffff;
}
if (*(ulong *)(puVar1 + 0x78) <= param_2 && param_1 < *(ulong *)(puVar1 + 0x78)) {
uVar2 = CONCAT71((int7)(param_2 >> 8),1);
goto LAB_001476a4;
}
puVar1 = *(int1 **)(puVar1 + 0x68);
} while( true );
}
| |
50,679 | rw_pr_init | eloqsql/mysys/thr_rwlock.c | int rw_pr_init(rw_pr_lock_t *rwlock)
{
pthread_mutex_init(&rwlock->lock, NULL);
pthread_cond_init(&rwlock->no_active_readers, NULL);
rwlock->active_readers= 0;
rwlock->writers_waiting_readers= 0;
rwlock->active_writer= FALSE;
#ifdef SAFE_MUTEX
rwlock->writer_thread= 0;
#endif
return 0;
} | O3 | c | rw_pr_init:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x2a370
leaq 0x28(%rbx), %rdi
xorl %esi, %esi
callq 0x2a3b0
movq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| rw_pr_init:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
xor esi, esi
call _pthread_mutex_init
lea rdi, [rbx+28h]
xor esi, esi
call _pthread_cond_init
mov qword ptr [rbx+58h], 0
mov byte ptr [rbx+60h], 0
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
| long long rw_pr_init(long long a1)
{
pthread_mutex_init(a1, 0LL);
pthread_cond_init(a1 + 40, 0LL);
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
return 0LL;
}
| rw_pr_init:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
XOR ESI,ESI
CALL 0x0012a370
LEA RDI,[RBX + 0x28]
XOR ESI,ESI
CALL 0x0012a3b0
MOV qword ptr [RBX + 0x58],0x0
MOV byte ptr [RBX + 0x60],0x0
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 rw_pr_init(pthread_mutex_t *param_1)
{
pthread_mutex_init(param_1,(pthread_mutexattr_t *)0x0);
pthread_cond_init((pthread_cond_t *)(param_1 + 1),(pthread_condattr_t *)0x0);
*(int8 *)((long)param_1 + 0x58) = 0;
*(int1 *)((long)param_1 + 0x60) = 0;
return 0;
}
| |
50,680 | inline_mysql_mutex_init | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_mutex_init(
#ifdef HAVE_PSI_MUTEX_INTERFACE
PSI_mutex_key key,
#endif
mysql_mutex_t *that,
const pthread_mutexattr_t *attr
#ifdef SAFE_MUTEX
, const char *src_name, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_MUTEX_INTERFACE
that->m_psi= PSI_MUTEX_CALL(init_mutex)(key, &that->m_mutex);
#else
that->m_psi= NULL;
#endif
#ifdef COROUTINE_ENABLED
that->l.data= that;
that->l.prev= that->l.next= NULL;
#endif
#ifdef SAFE_MUTEX
return safe_mutex_init(&that->m_mutex, attr, src_name, src_file, src_line);
#else
return pthread_mutex_init(&that->m_mutex, attr);
#endif
} | O0 | c | inline_mysql_mutex_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x23104e(%rip), %rax # 0x2c1238
movq (%rax), %rax
movq 0x40(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a330
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| inline_mysql_mutex_init_5:
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+40h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+40h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_10]
mov [rax+38h], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+28h], 0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_mutex_init
add rsp, 20h
pop rbp
retn
| long long inline_mysql_mutex_init_5(unsigned int a1, _QWORD *a2, long long a3)
{
a2[8] = ((long long ( *)(_QWORD, _QWORD *))PSI_server[8])(a1, a2);
a2[7] = a2;
a2[6] = 0LL;
a2[5] = 0LL;
return pthread_mutex_init(a2, a3);
}
| inline_mysql_mutex_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,[0x3c1238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x40]
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 + 0x40],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012a330
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_mutex_init
(int4 param_1,pthread_mutex_t *param_2,pthread_mutexattr_t *param_3)
{
int8 uVar1;
uVar1 = (**(code **)(PSI_server + 0x40))(param_1,param_2);
*(int8 *)((long)param_2 + 0x40) = uVar1;
*(pthread_mutex_t **)((long)param_2 + 0x38) = param_2;
*(int8 *)((long)param_2 + 0x30) = 0;
param_2[1].__align = 0;
pthread_mutex_init(param_2,param_3);
return;
}
| |
50,681 | hi0bits | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static int hi0bits(register ULong x)
{
register int k= 0;
if (!(x & 0xffff0000))
{
k= 16;
x<<= 16;
}
if (!(x & 0xff000000))
{
k+= 8;
x<<= 8;
}
if (!(x & 0xf0000000))
{
k+= 4;
x<<= 4;
}
if (!(x & 0xc0000000))
{
k+= 2;
x<<= 2;
}
if (!(x & 0x80000000))
{
k++;
if (!(x & 0x40000000))
return 32;
}
return k;
} | O3 | c | hi0bits:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
shll $0x10, %eax
xorl %ecx, %ecx
cmpl $0x10000, %edi # imm = 0x10000
setb %cl
cmovael %edi, %eax
shll $0x4, %ecx
movl %eax, %edx
shll $0x8, %edx
cmpl $0x1000000, %eax # imm = 0x1000000
cmovael %eax, %edx
leal 0x8(%rcx), %eax
cmovael %ecx, %eax
movl %edx, %ecx
shll $0x4, %ecx
cmpl $0x10000000, %edx # imm = 0x10000000
cmovael %edx, %ecx
leal 0x4(%rax), %edx
cmovael %eax, %edx
leal (,%rcx,4), %esi
movl $0x40000000, %eax # imm = 0x40000000
cmpl %eax, %ecx
cmovael %ecx, %esi
leal 0x2(%rdx), %ecx
cmovael %edx, %ecx
leal 0x1(%rcx), %edx
cmpl %eax, %esi
movl $0x20, %eax
cmovael %edx, %eax
testl %esi, %esi
cmovsl %ecx, %eax
popq %rbp
retq
| hi0bits:
push rbp
mov rbp, rsp
mov eax, edi
shl eax, 10h
xor ecx, ecx
cmp edi, 10000h
setb cl
cmovnb eax, edi
shl ecx, 4
mov edx, eax
shl edx, 8
cmp eax, 1000000h
cmovnb edx, eax
lea eax, [rcx+8]
cmovnb eax, ecx
mov ecx, edx
shl ecx, 4
cmp edx, 10000000h
cmovnb ecx, edx
lea edx, [rax+4]
cmovnb edx, eax
lea esi, ds:0[rcx*4]
mov eax, 40000000h
cmp ecx, eax
cmovnb esi, ecx
lea ecx, [rdx+2]
cmovnb ecx, edx
lea edx, [rcx+1]
cmp esi, eax
mov eax, 20h ; ' '
cmovnb eax, edx
test esi, esi
cmovs eax, ecx
pop rbp
retn
| long long hi0bits(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // edx
bool v3; // cf
int v4; // eax
unsigned int v5; // ecx
bool v6; // cf
int v7; // edx
int v8; // esi
bool v9; // cf
unsigned int v10; // ecx
long long result; // rax
v1 = a1 << 16;
if ( a1 >= 0x10000 )
v1 = a1;
v2 = v1 << 8;
v3 = v1 < 0x1000000;
if ( v1 >= 0x1000000 )
v2 = v1;
v4 = 16 * (a1 < 0x10000) + 8;
if ( !v3 )
v4 = 16 * (a1 < 0x10000);
v5 = 16 * v2;
v6 = v2 < 0x10000000;
if ( v2 >= 0x10000000 )
v5 = v2;
v7 = v4 + 4;
if ( !v6 )
v7 = v4;
v8 = 4 * v5;
v9 = v5 < 0x40000000;
if ( v5 >= 0x40000000 )
v8 = v5;
v10 = v7 + 2;
if ( !v9 )
v10 = v7;
result = 32LL;
if ( (unsigned int)v8 >= 0x40000000 )
result = v10 + 1;
if ( v8 < 0 )
return v10;
return result;
}
| hi0bits:
PUSH RBP
MOV RBP,RSP
MOV EAX,EDI
SHL EAX,0x10
XOR ECX,ECX
CMP EDI,0x10000
SETC CL
CMOVNC EAX,EDI
SHL ECX,0x4
MOV EDX,EAX
SHL EDX,0x8
CMP EAX,0x1000000
CMOVNC EDX,EAX
LEA EAX,[RCX + 0x8]
CMOVNC EAX,ECX
MOV ECX,EDX
SHL ECX,0x4
CMP EDX,0x10000000
CMOVNC ECX,EDX
LEA EDX,[RAX + 0x4]
CMOVNC EDX,EAX
LEA ESI,[RCX*0x4]
MOV EAX,0x40000000
CMP ECX,EAX
CMOVNC ESI,ECX
LEA ECX,[RDX + 0x2]
CMOVNC ECX,EDX
LEA EDX,[RCX + 0x1]
CMP ESI,EAX
MOV EAX,0x20
CMOVNC EAX,EDX
TEST ESI,ESI
CMOVS EAX,ECX
POP RBP
RET
|
int hi0bits(uint param_1)
{
uint uVar1;
uint uVar2;
int iVar3;
int iVar4;
uVar2 = param_1 << 0x10;
if (param_1 >= 0x10000) {
uVar2 = param_1;
}
iVar4 = (uint)(param_1 < 0x10000) * 0x10;
uVar1 = uVar2 << 8;
if (0xffffff < uVar2) {
uVar1 = uVar2;
}
iVar3 = iVar4 + 8;
if (0xffffff < uVar2) {
iVar3 = iVar4;
}
uVar2 = uVar1 << 4;
if (0xfffffff < uVar1) {
uVar2 = uVar1;
}
iVar4 = iVar3 + 4;
if (0xfffffff < uVar1) {
iVar4 = iVar3;
}
uVar1 = uVar2 * 4;
if (0x3fffffff < uVar2) {
uVar1 = uVar2;
}
iVar3 = iVar4 + 2;
if (0x3fffffff < uVar2) {
iVar3 = iVar4;
}
iVar4 = 0x20;
if (0x3fffffff < uVar1) {
iVar4 = iVar3 + 1;
}
if ((int)uVar1 < 0) {
iVar4 = iVar3;
}
return iVar4;
}
| |
50,682 | init_dynamic_array2 | eloqsql/mysys/array.c | my_bool init_dynamic_array2(PSI_memory_key psi_key, DYNAMIC_ARRAY *array,
uint element_size, void *init_buffer,
uint init_alloc, uint alloc_increment, myf my_flags)
{
DBUG_ENTER("init_dynamic_array2");
if (!alloc_increment)
{
alloc_increment=MY_MAX((8192-MALLOC_OVERHEAD)/element_size,16);
if (init_alloc > 8 && alloc_increment > init_alloc * 2)
alloc_increment=init_alloc*2;
}
array->elements=0;
array->max_element=init_alloc;
array->alloc_increment=alloc_increment;
array->size_of_element=element_size;
array->m_psi_key= psi_key;
array->malloc_flags= my_flags;
DBUG_ASSERT((my_flags & MY_INIT_BUFFER_USED) == 0);
if ((array->buffer= init_buffer))
{
array->malloc_flags|= MY_INIT_BUFFER_USED;
DBUG_RETURN(FALSE);
}
/*
Since the dynamic array is usable even if allocation fails here malloc
should not throw an error
*/
if (init_alloc &&
!(array->buffer= (uchar*) my_malloc(psi_key, element_size*init_alloc,
MYF(my_flags))))
array->max_element=0;
DBUG_RETURN(FALSE);
} | O3 | c | init_dynamic_array2:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %r11d
movq %rsi, %rbx
movq 0x10(%rbp), %r10
testl %r9d, %r9d
jne 0x91b6b
movl $0x10, %r9d
cmpl $0x1e1, %r11d # imm = 0x1E1
ja 0x91b5a
movw $0x1ff8, %ax # imm = 0x1FF8
xorl %edx, %edx
divw %r11w
movzwl %ax, %r9d
cmpl $0x9, %r8d
jb 0x91b6b
leal (%r8,%r8), %eax
cmpl %eax, %r9d
cmovael %eax, %r9d
movl $0x0, 0x8(%rbx)
movl %r8d, 0xc(%rbx)
movl %r9d, 0x10(%rbx)
movl %r11d, 0x14(%rbx)
movl %edi, 0x18(%rbx)
movq %r10, 0x20(%rbx)
movq %rcx, (%rbx)
testq %rcx, %rcx
je 0x91ba1
orq $0x100, %r10 # imm = 0x100
movq %r10, 0x20(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
testl %r8d, %r8d
je 0x91b98
imull %r11d, %r8d
movq %r8, %rsi
movq %r10, %rdx
callq 0x9fdb1
movq %rax, (%rbx)
testq %rax, %rax
jne 0x91b98
movl $0x0, 0xc(%rbx)
jmp 0x91b98
| init_dynamic_array2:
push rbp
mov rbp, rsp
push rbx
push rax
mov r11d, edx
mov rbx, rsi
mov r10, [rbp+arg_0]
test r9d, r9d
jnz short loc_91B6B
mov r9d, 10h
cmp r11d, 1E1h
ja short loc_91B5A
mov ax, 1FF8h
xor edx, edx
div r11w
movzx r9d, ax
loc_91B5A:
cmp r8d, 9
jb short loc_91B6B
lea eax, [r8+r8]
cmp r9d, eax
cmovnb r9d, eax
loc_91B6B:
mov dword ptr [rbx+8], 0
mov [rbx+0Ch], r8d
mov [rbx+10h], r9d
mov [rbx+14h], r11d
mov [rbx+18h], edi
mov [rbx+20h], r10
mov [rbx], rcx
test rcx, rcx
jz short loc_91BA1
or r10, 100h
mov [rbx+20h], r10
loc_91B98:
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
loc_91BA1:
test r8d, r8d
jz short loc_91B98
imul r8d, r11d
mov rsi, r8
mov rdx, r10
call my_malloc
mov [rbx], rax
test rax, rax
jnz short loc_91B98
mov dword ptr [rbx+0Ch], 0
jmp short loc_91B98
| long long init_dynamic_array2(
long long a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
unsigned int a6,
long long a7)
{
long long v8; // rax
if ( !a6 )
{
a6 = 16;
if ( a3 <= 0x1E1 )
a6 = 0x1FF8u / (unsigned __int16)a3;
if ( a5 >= 9 && a6 >= 2 * a5 )
a6 = 2 * a5;
}
*(_DWORD *)(a2 + 8) = 0;
*(_DWORD *)(a2 + 12) = a5;
*(_DWORD *)(a2 + 16) = a6;
*(_DWORD *)(a2 + 20) = a3;
*(_DWORD *)(a2 + 24) = a1;
*(_QWORD *)(a2 + 32) = a7;
*(_QWORD *)a2 = a4;
if ( a4 )
{
*(_QWORD *)(a2 + 32) = a7 | 0x100;
}
else if ( a5 )
{
v8 = my_malloc(a1, a3 * a5, a7);
*(_QWORD *)a2 = v8;
if ( !v8 )
*(_DWORD *)(a2 + 12) = 0;
}
return 0LL;
}
| init_dynamic_array2:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV R11D,EDX
MOV RBX,RSI
MOV R10,qword ptr [RBP + 0x10]
TEST R9D,R9D
JNZ 0x00191b6b
MOV R9D,0x10
CMP R11D,0x1e1
JA 0x00191b5a
MOV AX,0x1ff8
XOR EDX,EDX
DIV R11W
MOVZX R9D,AX
LAB_00191b5a:
CMP R8D,0x9
JC 0x00191b6b
LEA EAX,[R8 + R8*0x1]
CMP R9D,EAX
CMOVNC R9D,EAX
LAB_00191b6b:
MOV dword ptr [RBX + 0x8],0x0
MOV dword ptr [RBX + 0xc],R8D
MOV dword ptr [RBX + 0x10],R9D
MOV dword ptr [RBX + 0x14],R11D
MOV dword ptr [RBX + 0x18],EDI
MOV qword ptr [RBX + 0x20],R10
MOV qword ptr [RBX],RCX
TEST RCX,RCX
JZ 0x00191ba1
OR R10,0x100
MOV qword ptr [RBX + 0x20],R10
LAB_00191b98:
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_00191ba1:
TEST R8D,R8D
JZ 0x00191b98
IMUL R8D,R11D
MOV RSI,R8
MOV RDX,R10
CALL 0x0019fdb1
MOV qword ptr [RBX],RAX
TEST RAX,RAX
JNZ 0x00191b98
MOV dword ptr [RBX + 0xc],0x0
JMP 0x00191b98
|
int8
init_dynamic_array2(int4 param_1,long *param_2,uint param_3,long param_4,uint param_5,
uint param_6,ulong param_7)
{
long lVar1;
if (param_6 == 0) {
param_6 = 0x10;
if (param_3 < 0x1e2) {
param_6 = 0x1ff8 / (param_3 & 0xffff);
}
if ((8 < param_5) && (param_5 * 2 <= param_6)) {
param_6 = param_5 * 2;
}
}
*(int4 *)(param_2 + 1) = 0;
*(uint *)((long)param_2 + 0xc) = param_5;
*(uint *)(param_2 + 2) = param_6;
*(uint *)((long)param_2 + 0x14) = param_3;
*(int4 *)(param_2 + 3) = param_1;
param_2[4] = param_7;
*param_2 = param_4;
if (param_4 == 0) {
if (param_5 != 0) {
lVar1 = my_malloc(param_1,param_5 * param_3,param_7);
*param_2 = lVar1;
if (lVar1 == 0) {
*(int4 *)((long)param_2 + 0xc) = 0;
}
}
}
else {
param_2[4] = param_7 | 0x100;
}
return 0;
}
| |
50,683 | js_symbol_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_symbol_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue str;
JSString *p;
if (!JS_IsUndefined(new_target))
return JS_ThrowTypeError(ctx, "not a constructor");
if (argc == 0 || JS_IsUndefined(argv[0])) {
p = NULL;
} else {
str = JS_ToString(ctx, argv[0]);
if (JS_IsException(str))
return JS_EXCEPTION;
p = JS_VALUE_GET_STRING(str);
}
return JS_NewSymbolInternal(ctx, p, JS_ATOM_TYPE_SYMBOL);
} | O1 | c | js_symbol_constructor:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, %edx
jne 0x38b70
testl %ecx, %ecx
je 0x38b4f
movq 0x8(%r8), %rdx
cmpl $0x3, %edx
jne 0x38b99
xorl %esi, %esi
movq %rbx, %rdi
movl $0x3, %edx
callq 0x3bc1f
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %r14d
jmp 0x38b8b
leaq 0x66b69(%rip), %rsi # 0x9f6e0
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22567
movl $0x6, %edx
xorl %ecx, %ecx
orq %rcx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r8), %rsi
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x27add
movq %rax, (%rsp)
cmpl $0x6, %edx
je 0x38b84
movq (%rsp), %rsi
jmp 0x38b51
| js_symbol_constructor:
push r14
push rbx
push rax
mov rbx, rdi
cmp edx, 3
jnz short loc_38B70
test ecx, ecx
jz short loc_38B4F
mov rdx, [r8+8]
cmp edx, 3
jnz short loc_38B99
loc_38B4F:
xor esi, esi
loc_38B51:
mov rdi, rbx
mov edx, 3
call JS_NewSymbolInternal
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov r14d, eax
jmp short loc_38B8B
loc_38B70:
lea rsi, aNotAConstructo; "not a constructor"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
loc_38B84:
mov edx, 6
xor ecx, ecx
loc_38B8B:
or r14, rcx
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
loc_38B99:
mov rsi, [r8]
xor r14d, r14d
mov rdi, rbx
xor ecx, ecx
call JS_ToStringInternal
mov [rsp+18h+var_18], rax
cmp edx, 6
jz short loc_38B84
mov rsi, [rsp+18h+var_18]
jmp short loc_38B51
| unsigned long long js_symbol_constructor(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long *a13,
long long a14)
{
char v14; // al
long long v15; // rdx
unsigned long long v16; // rsi
long long v17; // rax
unsigned long long v18; // rcx
long long v19; // r14
int v21; // edx
unsigned long long v22; // [rsp+0h] [rbp-18h]
if ( (_DWORD)a11 != 3 )
{
v19 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"not a constructor",
a11,
a12,
(long long)a13,
a14,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
v14);
goto LABEL_7;
}
if ( (_DWORD)a12 )
{
v15 = a13[1];
if ( (_DWORD)v15 != 3 )
{
v19 = 0LL;
v22 = JS_ToStringInternal(a1, *a13, v15, 0, (long long)a13, a14, a2, a3, a4, a5, a6, a7, a8, a9);
if ( v21 != 6 )
{
v16 = v22;
goto LABEL_5;
}
LABEL_7:
v18 = 0LL;
return v18 | v19;
}
}
v16 = 0LL;
LABEL_5:
v17 = JS_NewSymbolInternal(a1, v16, 3LL);
v18 = v17 & 0xFFFFFFFF00000000LL;
v19 = (unsigned int)v17;
return v18 | v19;
}
| |||
50,684 | js_symbol_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_symbol_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue str;
JSString *p;
if (!JS_IsUndefined(new_target))
return JS_ThrowTypeError(ctx, "not a constructor");
if (argc == 0 || JS_IsUndefined(argv[0])) {
p = NULL;
} else {
str = JS_ToString(ctx, argv[0]);
if (JS_IsException(str))
return JS_EXCEPTION;
p = JS_VALUE_GET_STRING(str);
}
return JS_NewSymbolInternal(ctx, p, JS_ATOM_TYPE_SYMBOL);
} | O2 | c | js_symbol_constructor:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, %edx
jne 0x31d0d
testl %ecx, %ecx
je 0x31cee
movq 0x8(%r8), %rdx
cmpl $0x3, %edx
jne 0x31d34
xorl %esi, %esi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x34a2a
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %r14d
jmp 0x31d26
leaq 0x5491c(%rip), %rsi # 0x86630
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1c64d
pushq $0x6
popq %rdx
xorl %ecx, %ecx
orq %rcx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r8), %rsi
movq %rbx, %rdi
callq 0x1b03c
cmpl $0x6, %edx
jne 0x31d4c
pushq $0x6
popq %rdx
xorl %r14d, %r14d
jmp 0x31d24
movq %rax, %rsi
jmp 0x31cf0
| js_symbol_constructor:
push r14
push rbx
push rax
mov rbx, rdi
cmp edx, 3
jnz short loc_31D0D
test ecx, ecx
jz short loc_31CEE
mov rdx, [r8+8]
cmp edx, 3
jnz short loc_31D34
loc_31CEE:
xor esi, esi
loc_31CF0:
push 3
pop rdx
mov rdi, rbx
call JS_NewSymbolInternal
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov r14d, eax
jmp short loc_31D26
loc_31D0D:
lea rsi, aNotAConstructo; "not a constructor"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
push 6
pop rdx
loc_31D24:
xor ecx, ecx
loc_31D26:
or r14, rcx
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
loc_31D34:
mov rsi, [r8]
mov rdi, rbx
call JS_ToString
cmp edx, 6
jnz short loc_31D4C
push 6
pop rdx
xor r14d, r14d
jmp short loc_31D24
loc_31D4C:
mov rsi, rax
jmp short loc_31CF0
| unsigned long long js_symbol_constructor(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long *a13,
long long a14)
{
char v14; // al
long long v15; // rdx
long long v16; // rsi
long long v17; // rax
unsigned long long v18; // rcx
long long v19; // r14
long long v21; // rax
int v22; // edx
if ( (_DWORD)a11 != 3 )
{
v19 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"not a constructor",
a11,
a12,
(long long)a13,
a14,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
v14);
goto LABEL_7;
}
if ( (_DWORD)a12 )
{
v15 = a13[1];
if ( (_DWORD)v15 != 3 )
{
v21 = JS_ToString(a1, *a13, v15);
if ( v22 != 6 )
{
v16 = v21;
goto LABEL_5;
}
v19 = 0LL;
LABEL_7:
v18 = 0LL;
return v18 | v19;
}
}
v16 = 0LL;
LABEL_5:
v17 = JS_NewSymbolInternal(a1, v16, 3LL);
v18 = v17 & 0xFFFFFFFF00000000LL;
v19 = (unsigned int)v17;
return v18 | v19;
}
| js_symbol_constructor:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP EDX,0x3
JNZ 0x00131d0d
TEST ECX,ECX
JZ 0x00131cee
MOV RDX,qword ptr [R8 + 0x8]
CMP EDX,0x3
JNZ 0x00131d34
LAB_00131cee:
XOR ESI,ESI
LAB_00131cf0:
PUSH 0x3
POP RDX
MOV RDI,RBX
CALL 0x00134a2a
MOV RCX,-0x100000000
AND RCX,RAX
MOV R14D,EAX
JMP 0x00131d26
LAB_00131d0d:
LEA RSI,[0x186630]
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0011c64d
PUSH 0x6
POP RDX
LAB_00131d24:
XOR ECX,ECX
LAB_00131d26:
OR R14,RCX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00131d34:
MOV RSI,qword ptr [R8]
MOV RDI,RBX
CALL 0x0011b03c
CMP EDX,0x6
JNZ 0x00131d4c
PUSH 0x6
POP RDX
XOR R14D,R14D
JMP 0x00131d24
LAB_00131d4c:
MOV RSI,RAX
JMP 0x00131cf0
|
ulong js_symbol_constructor
(int8 param_1,int8 param_2,int param_3,int param_4,int8 *param_5)
{
ulong uVar1;
ulong uVar2;
int8 uVar3;
int1 auVar4 [12];
if (param_3 == 3) {
if ((param_4 == 0) || ((int)param_5[1] == 3)) {
uVar3 = 0;
}
else {
auVar4 = JS_ToString(param_1,*param_5);
uVar3 = auVar4._0_8_;
if (auVar4._8_4_ == 6) goto LAB_00131d24;
}
uVar1 = JS_NewSymbolInternal(param_1,uVar3,3);
uVar2 = uVar1 & 0xffffffff00000000;
uVar1 = uVar1 & 0xffffffff;
}
else {
JS_ThrowTypeError(param_1,"not a constructor");
LAB_00131d24:
uVar1 = 0;
uVar2 = 0;
}
return uVar1 | uVar2;
}
| |
50,685 | my_once_alloc | eloqsql/mysys/my_once.c | void* my_once_alloc(size_t Size, myf MyFlags)
{
size_t get_size, max_left;
uchar* point;
reg1 USED_MEM *next;
reg2 USED_MEM **prev;
Size= ALIGN_SIZE(Size);
prev= &my_once_root_block;
max_left=0;
for (next=my_once_root_block ; next && next->left < Size ; next= next->next)
{
if (next->left > max_left)
max_left=next->left;
prev= &next->next;
}
if (! next)
{ /* Time to alloc new block */
get_size= Size+ALIGN_SIZE(sizeof(USED_MEM));
if (max_left*4 < my_once_extra && get_size < my_once_extra)
get_size=my_once_extra; /* Normal alloc */
if ((next = (USED_MEM*) malloc(get_size)) == 0)
{
my_errno=errno;
if (MyFlags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_FATAL), get_size);
return((uchar*) 0);
}
DBUG_PRINT("test",("my_once_malloc %lu byte malloced", (ulong) get_size));
next->next= 0;
next->size= get_size;
next->left= get_size-ALIGN_SIZE(sizeof(USED_MEM));
*prev=next;
}
point= (uchar*) ((char*) next+ (next->size-next->left));
next->left-= Size;
if (MyFlags & MY_ZEROFILL)
bzero(point, Size);
return((void*) point);
} | O3 | c | my_once_alloc:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x7, %r14
andq $-0x8, %r14
leaq 0x340191(%rip), %r13 # 0x367e30
movq (%r13), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x27cca
movq %rcx, %r13
movq 0x8(%rcx), %rcx
cmpq %r14, %rcx
jae 0x27d13
cmpq %rax, %rcx
cmovaq %rcx, %rax
movq (%r13), %rcx
testq %rcx, %rcx
jne 0x27caa
shlq $0x2, %rax
leaq 0x18(%r14), %rcx
leaq 0x2c88db(%rip), %rdx # 0x2f05b0
movl (%rdx), %edx
cmpq %rdx, %rcx
movq %rdx, %r15
cmovaq %rcx, %r15
cmpq %rdx, %rax
cmovaeq %rcx, %r15
movq %r15, %rdi
callq 0x243e0
testq %rax, %rax
je 0x27d44
movq $0x0, (%rax)
movq %r15, 0x10(%rax)
addq $-0x18, %r15
movq %r15, 0x8(%rax)
movq %rax, (%r13)
movq 0x8(%rax), %rcx
movq %rax, %r13
movq 0x10(%r13), %r12
subq %rcx, %r12
addq %r13, %r12
subq %r14, %rcx
movq %rcx, 0x8(%r13)
testb $0x20, %bl
je 0x27d70
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24170
callq 0x24050
movl (%rax), %r14d
callq 0x282b6
movl %r14d, (%rax)
xorl %r12d, %r12d
testb $0x18, %bl
je 0x27d70
movl $0x1004, %esi # imm = 0x1004
movl $0x5, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2c0f7
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_once_alloc:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
add r14, 7
and r14, 0FFFFFFFFFFFFFFF8h
lea r13, my_once_root_block
mov rcx, [r13+0]
xor eax, eax
test rcx, rcx
jz short loc_27CCA
loc_27CAA:
mov r13, rcx
mov rcx, [rcx+8]
cmp rcx, r14
jnb short loc_27D13
cmp rcx, rax
cmova rax, rcx
mov rcx, [r13+0]
test rcx, rcx
jnz short loc_27CAA
shl rax, 2
loc_27CCA:
lea rcx, [r14+18h]
lea rdx, my_once_extra
mov edx, [rdx]
cmp rcx, rdx
mov r15, rdx
cmova r15, rcx
cmp rax, rdx
cmovnb r15, rcx
mov rdi, r15
call _malloc
test rax, rax
jz short loc_27D44
mov qword ptr [rax], 0
mov [rax+10h], r15
add r15, 0FFFFFFFFFFFFFFE8h
mov [rax+8], r15
mov [r13+0], rax
mov rcx, [rax+8]
mov r13, rax
loc_27D13:
mov r12, [r13+10h]
sub r12, rcx
add r12, r13
sub rcx, r14
mov [r13+8], rcx
test bl, 20h
jz short loc_27D70
mov rdi, r12
xor esi, esi
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memset
loc_27D44:
call ___errno_location
mov r14d, [rax]
call _my_thread_var
mov [rax], r14d
xor r12d, r12d
test bl, 18h
jz short loc_27D70
mov esi, 1004h
mov edi, 5
mov rdx, r15
xor eax, eax
call my_error
loc_27D70:
mov rax, r12
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_once_alloc(long long a1, char a2)
{
unsigned long long v2; // r14
_QWORD *v3; // r13
_QWORD *v4; // rcx
unsigned long long v5; // rax
unsigned long long v6; // rcx
unsigned long long v7; // r15
_QWORD *v8; // rax
char *v9; // r12
int v11; // r14d
int v12; // ecx
int v13; // r8d
int v14; // r9d
v2 = (a1 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v3 = &my_once_root_block;
v4 = (_QWORD *)my_once_root_block;
v5 = 0LL;
if ( my_once_root_block )
{
while ( 1 )
{
v3 = v4;
v6 = v4[1];
if ( v6 >= v2 )
break;
if ( v6 > v5 )
v5 = v6;
v4 = (_QWORD *)*v3;
if ( !*v3 )
{
v5 *= 4LL;
goto LABEL_7;
}
}
}
else
{
LABEL_7:
v7 = my_once_extra;
if ( v2 + 24 > my_once_extra )
v7 = v2 + 24;
if ( v5 >= my_once_extra )
v7 = v2 + 24;
v8 = (_QWORD *)malloc(v7);
if ( !v8 )
{
v11 = *(_DWORD *)__errno_location(v7);
*(_DWORD *)my_thread_var(v7) = v11;
v9 = 0LL;
if ( (a2 & 0x18) != 0 )
my_error(5, 4100, v7, v12, v13, v14);
return (long long)v9;
}
*v8 = 0LL;
v8[2] = v7;
v8[1] = v7 - 24;
*v3 = v8;
v6 = v8[1];
v3 = v8;
}
v9 = (char *)v3 + v3[2] - v6;
v3[1] = v6 - v2;
if ( (a2 & 0x20) != 0 )
return memset(v9, 0LL, v2);
return (long long)v9;
}
| my_once_alloc:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
ADD R14,0x7
AND R14,-0x8
LEA R13,[0x467e30]
MOV RCX,qword ptr [R13]
XOR EAX,EAX
TEST RCX,RCX
JZ 0x00127cca
LAB_00127caa:
MOV R13,RCX
MOV RCX,qword ptr [RCX + 0x8]
CMP RCX,R14
JNC 0x00127d13
CMP RCX,RAX
CMOVA RAX,RCX
MOV RCX,qword ptr [R13]
TEST RCX,RCX
JNZ 0x00127caa
SHL RAX,0x2
LAB_00127cca:
LEA RCX,[R14 + 0x18]
LEA RDX,[0x3f05b0]
MOV EDX,dword ptr [RDX]
CMP RCX,RDX
MOV R15,RDX
CMOVA R15,RCX
CMP RAX,RDX
CMOVNC R15,RCX
MOV RDI,R15
CALL 0x001243e0
TEST RAX,RAX
JZ 0x00127d44
MOV qword ptr [RAX],0x0
MOV qword ptr [RAX + 0x10],R15
ADD R15,-0x18
MOV qword ptr [RAX + 0x8],R15
MOV qword ptr [R13],RAX
MOV RCX,qword ptr [RAX + 0x8]
MOV R13,RAX
LAB_00127d13:
MOV R12,qword ptr [R13 + 0x10]
SUB R12,RCX
ADD R12,R13
SUB RCX,R14
MOV qword ptr [R13 + 0x8],RCX
TEST BL,0x20
JZ 0x00127d70
MOV RDI,R12
XOR ESI,ESI
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00124170
LAB_00127d44:
CALL 0x00124050
MOV R14D,dword ptr [RAX]
CALL 0x001282b6
MOV dword ptr [RAX],R14D
XOR R12D,R12D
TEST BL,0x18
JZ 0x00127d70
MOV ESI,0x1004
MOV EDI,0x5
MOV RDX,R15
XOR EAX,EAX
CALL 0x0012c0f7
LAB_00127d70:
MOV RAX,R12
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void * my_once_alloc(long param_1,ulong param_2)
{
int iVar1;
int8 *puVar2;
ulong uVar3;
int8 *puVar4;
int *piVar5;
ulong uVar6;
ulong uVar7;
void *pvVar8;
int8 *puVar9;
ulong __n;
ulong __size;
__n = param_1 + 7U & 0xfffffffffffffff8;
uVar3 = 0;
puVar2 = my_once_root_block;
puVar9 = &my_once_root_block;
if (my_once_root_block != (int8 *)0x0) {
do {
puVar4 = puVar2;
uVar6 = puVar4[1];
if (__n <= uVar6) goto LAB_00127d13;
if (uVar3 < uVar6) {
uVar3 = uVar6;
}
puVar2 = (int8 *)*puVar4;
} while ((int8 *)*puVar4 != (int8 *)0x0);
uVar3 = uVar3 << 2;
puVar9 = puVar4;
}
uVar6 = __n + 0x18;
uVar7 = (ulong)my_once_extra;
__size = uVar7;
if (uVar7 < uVar6) {
__size = uVar6;
}
if (uVar7 <= uVar3) {
__size = uVar6;
}
puVar4 = (int8 *)malloc(__size);
if (puVar4 == (int8 *)0x0) {
piVar5 = __errno_location();
iVar1 = *piVar5;
piVar5 = (int *)_my_thread_var();
*piVar5 = iVar1;
pvVar8 = (void *)0x0;
if ((param_2 & 0x18) != 0) {
my_error(5,0x1004,__size);
}
}
else {
*puVar4 = 0;
puVar4[2] = __size;
puVar4[1] = __size - 0x18;
*puVar9 = puVar4;
uVar6 = puVar4[1];
LAB_00127d13:
pvVar8 = (void *)((puVar4[2] - uVar6) + (long)puVar4);
puVar4[1] = uVar6 - __n;
if ((param_2 & 0x20) != 0) {
pvVar8 = memset(pvVar8,0,__n);
return pvVar8;
}
}
return pvVar8;
}
| |
50,686 | glfwChooseVisualEGL | untodesu[P]riteg/build_O3/_deps/glfw-src/src/egl_context.c | GLFWbool _glfwChooseVisualEGL(const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig,
Visual** visual, int* depth)
{
XVisualInfo* result;
XVisualInfo desired;
EGLConfig native;
EGLint visualID = 0, count = 0;
const long vimask = VisualScreenMask | VisualIDMask;
if (!chooseEGLConfig(ctxconfig, fbconfig, &native))
{
_glfwInputError(GLFW_FORMAT_UNAVAILABLE,
"EGL: Failed to find a suitable EGLConfig");
return GLFW_FALSE;
}
eglGetConfigAttrib(_glfw.egl.display, native,
EGL_NATIVE_VISUAL_ID, &visualID);
desired.screen = _glfw.x11.screen;
desired.visualid = visualID;
result = XGetVisualInfo(_glfw.x11.display, vimask, &desired, &count);
if (!result)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to retrieve Visual for EGLConfig");
return GLFW_FALSE;
}
*visual = result->visual;
*depth = result->depth;
XFree(result);
return GLFW_TRUE;
} | O3 | c | glfwChooseVisualEGL:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %rdi
xorl %ebp, %ebp
movl %ebp, 0x4(%rsp)
movl %ebp, (%rsp)
leaq 0x8(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x27957
testl %eax, %eax
je 0x27f73
leaq 0x80732(%rip), %r12 # 0xa8638
movq 0x208a0(%r12), %rdi
movq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %r15
movl $0x302e, %edx # imm = 0x302E
movq %r15, %rcx
callq *0x208d0(%r12)
movl 0x1fec8(%r12), %eax
leaq 0x10(%rsp), %rdx
movl %eax, 0x10(%rdx)
movslq (%r15), %rax
movq %rax, 0x8(%rdx)
movq 0x1fec0(%r12), %rdi
movq %rsp, %rcx
movl $0x3, %esi
callq 0xc6c0
testq %rax, %rax
je 0x27f81
movq (%rax), %rcx
movq %rcx, (%r14)
movl 0x14(%rax), %ecx
movl %ecx, (%rbx)
movq %rax, %rdi
callq 0xcac0
movl $0x1, %ebp
jmp 0x27f96
leaq 0x5f6dd(%rip), %rsi # 0x87657
movl $0x10009, %edi # imm = 0x10009
jmp 0x27f8f
leaq 0x5f7d8(%rip), %rsi # 0x87760
xorl %ebp, %ebp
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x18e91
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _glfwChooseVisualEGL:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 50h
mov rbx, r8
mov r14, rcx
mov rdi, rsi
xor ebp, ebp
mov [rsp+78h+var_74], ebp
mov [rsp+78h+var_78], ebp
lea rax, [rsp+78h+var_70]
mov rsi, rdx
mov rdx, rax
call chooseEGLConfig
test eax, eax
jz short loc_27F73
lea r12, _glfw
mov rdi, [r12+208A0h]
mov rsi, [rsp+78h+var_70]
lea r15, [rsp+78h+var_74]
mov edx, 302Eh
mov rcx, r15
call qword ptr [r12+208D0h]
mov eax, [r12+1FEC8h]
lea rdx, [rsp+78h+var_68]
mov [rdx+10h], eax
movsxd rax, dword ptr [r15]
mov [rdx+8], rax
mov rdi, [r12+1FEC0h]
mov rcx, rsp
mov esi, 3
call _XGetVisualInfo
test rax, rax
jz short loc_27F81
mov rcx, [rax]
mov [r14], rcx
mov ecx, [rax+14h]
mov [rbx], ecx
mov rdi, rax
call _XFree
mov ebp, 1
jmp short loc_27F96
loc_27F73:
lea rsi, aEglFailedToFin; "EGL: Failed to find a suitable EGLConfi"...
mov edi, 10009h
jmp short loc_27F8F
loc_27F81:
lea rsi, aEglFailedToRet; "EGL: Failed to retrieve Visual for EGLC"...
xor ebp, ebp
mov edi, 10008h
loc_27F8F:
xor eax, eax
call _glfwInputError
loc_27F96:
mov eax, ebp
add rsp, 50h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long glfwChooseVisualEGL(long long a1, _DWORD *a2, _DWORD *a3, _QWORD *a4, _DWORD *a5)
{
unsigned int v7; // ebp
long long v8; // rax
int v10; // [rsp+0h] [rbp-78h] BYREF
int v11; // [rsp+4h] [rbp-74h] BYREF
long long v12; // [rsp+8h] [rbp-70h] BYREF
_BYTE v13[8]; // [rsp+10h] [rbp-68h] BYREF
long long v14; // [rsp+18h] [rbp-60h]
int v15; // [rsp+20h] [rbp-58h]
v7 = 0;
v11 = 0;
v10 = 0;
if ( chooseEGLConfig(a2, a3, &v12) )
{
(*(void ( **)(_QWORD, long long, long long, int *))&glfw[33332])(*(_QWORD *)&glfw[33320], v12, 12334LL, &v11);
v15 = glfw[32690];
v14 = v11;
v8 = XGetVisualInfo(*(_QWORD *)&glfw[32688], 3LL, v13, &v10);
if ( v8 )
{
*a4 = *(_QWORD *)v8;
*a5 = *(_DWORD *)(v8 + 20);
XFree(v8);
return 1;
}
else
{
v7 = 0;
glfwInputError(0x10008u, (long long)"EGL: Failed to retrieve Visual for EGLConfig");
}
}
else
{
glfwInputError(0x10009u, (long long)"EGL: Failed to find a suitable EGLConfig");
}
return v7;
}
| _glfwChooseVisualEGL:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV RBX,R8
MOV R14,RCX
MOV RDI,RSI
XOR EBP,EBP
MOV dword ptr [RSP + 0x4],EBP
MOV dword ptr [RSP],EBP
LEA RAX,[RSP + 0x8]
MOV RSI,RDX
MOV RDX,RAX
CALL 0x00127957
TEST EAX,EAX
JZ 0x00127f73
LEA R12,[0x1a8638]
MOV RDI,qword ptr [R12 + 0x208a0]
MOV RSI,qword ptr [RSP + 0x8]
LEA R15,[RSP + 0x4]
MOV EDX,0x302e
MOV RCX,R15
CALL qword ptr [R12 + 0x208d0]
MOV EAX,dword ptr [R12 + 0x1fec8]
LEA RDX,[RSP + 0x10]
MOV dword ptr [RDX + 0x10],EAX
MOVSXD RAX,dword ptr [R15]
MOV qword ptr [RDX + 0x8],RAX
MOV RDI,qword ptr [R12 + 0x1fec0]
MOV RCX,RSP
MOV ESI,0x3
CALL 0x0010c6c0
TEST RAX,RAX
JZ 0x00127f81
MOV RCX,qword ptr [RAX]
MOV qword ptr [R14],RCX
MOV ECX,dword ptr [RAX + 0x14]
MOV dword ptr [RBX],ECX
MOV RDI,RAX
CALL 0x0010cac0
MOV EBP,0x1
JMP 0x00127f96
LAB_00127f73:
LEA RSI,[0x187657]
MOV EDI,0x10009
JMP 0x00127f8f
LAB_00127f81:
LEA RSI,[0x187760]
XOR EBP,EBP
MOV EDI,0x10008
LAB_00127f8f:
XOR EAX,EAX
CALL 0x00118e91
LAB_00127f96:
MOV EAX,EBP
ADD RSP,0x50
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int4
_glfwChooseVisualEGL
(int8 param_1,int8 param_2,int8 param_3,int8 *param_4,
int4 *param_5)
{
int iVar1;
int8 *puVar2;
char *pcVar3;
int8 uVar4;
int4 local_78;
int local_74;
int8 local_70;
int1 local_68 [8];
long local_60;
int4 local_58;
local_74 = 0;
local_78 = 0;
iVar1 = chooseEGLConfig(param_2,param_3,&local_70);
if (iVar1 == 0) {
pcVar3 = "EGL: Failed to find a suitable EGLConfig";
uVar4 = 0x10009;
}
else {
(*DAT_001c8f08)(DAT_001c8ed8,local_70,0x302e,&local_74);
local_58 = DAT_001c8500;
local_60 = (long)local_74;
puVar2 = (int8 *)XGetVisualInfo(DAT_001c84f8,3,local_68,&local_78);
if (puVar2 != (int8 *)0x0) {
*param_4 = *puVar2;
*param_5 = *(int4 *)((long)puVar2 + 0x14);
XFree(puVar2);
return 1;
}
pcVar3 = "EGL: Failed to retrieve Visual for EGLConfig";
uVar4 = 0x10008;
}
_glfwInputError(uVar4,pcVar3);
return 0;
}
| |
50,687 | my_b_seq_read | eloqsql/mysys/mf_iocache.c | static int _my_b_seq_read(IO_CACHE *info, uchar *Buffer, size_t Count)
{
size_t length, diff_length, save_count, max_length;
my_off_t pos_in_file;
save_count=Count;
lock_append_buffer(info);
/* pos_in_file always point on where info->buffer was read */
if ((pos_in_file=info->pos_in_file +
(size_t) (info->read_end - info->buffer)) >= info->end_of_file)
goto read_append_buffer;
/*
With read-append cache we must always do a seek before we read,
because the write could have moved the file pointer astray
*/
if (mysql_file_seek(info->file, pos_in_file, MY_SEEK_SET, MYF(0)) == MY_FILEPOS_ERROR)
{
info->error= -1;
unlock_append_buffer(info);
return (1);
}
info->seek_not_done=0;
diff_length= (size_t) (pos_in_file & (IO_SIZE-1));
/* now the second stage begins - read from file descriptor */
if (Count >= (size_t) (IO_SIZE+(IO_SIZE-diff_length)))
{
/* Fill first intern buffer */
size_t read_length;
length= IO_ROUND_DN(Count) - diff_length;
if ((read_length= mysql_file_read(info->file,Buffer, length,
info->myflags)) == (size_t) -1)
{
info->error= -1;
unlock_append_buffer(info);
return 1;
}
Count-=read_length;
Buffer+=read_length;
pos_in_file+=read_length;
if (read_length != length)
{
/*
We only got part of data; Read the rest of the data from the
write buffer
*/
goto read_append_buffer;
}
diff_length=0;
}
max_length= info->read_length-diff_length;
if (max_length > (info->end_of_file - pos_in_file))
max_length= (size_t) (info->end_of_file - pos_in_file);
if (!max_length)
{
if (Count)
goto read_append_buffer;
length=0; /* Didn't read any more chars */
}
else
{
length= mysql_file_read(info->file,info->buffer, max_length, info->myflags);
if (length == (size_t) -1)
{
info->error= -1;
unlock_append_buffer(info);
return 1;
}
if (length < Count)
{
memcpy(Buffer, info->buffer, length);
Count -= length;
Buffer += length;
/*
added the line below to make
DBUG_ASSERT(pos_in_file==info->end_of_file) pass.
otherwise this does not appear to be needed
*/
pos_in_file += length;
goto read_append_buffer;
}
}
unlock_append_buffer(info);
info->read_pos=info->buffer+Count;
info->read_end=info->buffer+length;
info->pos_in_file=pos_in_file;
memcpy(Buffer,info->buffer,(size_t) Count);
return 0;
read_append_buffer:
/*
Read data from the current write buffer.
Count should never be == 0 here (The code will work even if count is 0)
*/
{
/* First copy the data to Count */
size_t len_in_buff = (size_t) (info->write_pos - info->append_read_pos);
size_t copy_len;
size_t transfer_len;
DBUG_ASSERT(info->append_read_pos <= info->write_pos);
copy_len=MY_MIN(Count, len_in_buff);
memcpy(Buffer, info->append_read_pos, copy_len);
info->append_read_pos += copy_len;
Count -= copy_len;
if (Count)
info->error= (int) (save_count - Count);
/* Fill read buffer with data from write buffer */
memcpy(info->buffer, info->append_read_pos,
(size_t) (transfer_len=len_in_buff - copy_len));
info->read_pos= info->buffer;
info->read_end= info->buffer+transfer_len;
info->append_read_pos=info->write_pos;
info->pos_in_file=pos_in_file+copy_len;
info->end_of_file+=len_in_buff;
}
unlock_append_buffer(info);
return Count ? 1 : 0;
} | O0 | c | my_b_seq_read:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
leaq 0x71e2a(%rip), %rsi # 0x155495
movl $0x54c, %edx # imm = 0x54C
callq 0xe2b40
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0xe36a5
jmp 0xe394c
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x48(%rbp), %rcx
leaq 0x71ddb(%rip), %rdi # 0x155495
movl $0x557, %esi # imm = 0x557
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0xe15e0
cmpq $-0x1, %rax
jne 0xe36f9
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe2c70
movl $0x1, -0x4(%rbp)
jmp 0xe3a6e
movq -0x10(%rbp), %rax
movl $0x0, 0xe0(%rax)
movq -0x48(%rbp), %rax
andq $0xfff, %rax # imm = 0xFFF
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl $0x1000, %ecx # imm = 0x1000
subq -0x30(%rbp), %rcx
addq $0x1000, %rcx # imm = 0x1000
cmpq %rcx, %rax
jb 0xe37e5
movabsq $0xfffff000, %rax # imm = 0xFFFFF000
andq -0x20(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %r9
leaq 0x71d29(%rip), %rdi # 0x155495
movl $0x569, %esi # imm = 0x569
callq 0xe3ff0
movq %rax, -0x50(%rbp)
cmpq $-0x1, %rax
jne 0xe37a7
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe2c70
movl $0x1, -0x4(%rbp)
jmp 0xe3a6e
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x50(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xe37dd
jmp 0xe394c
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq -0x48(%rbp), %rcx
cmpq %rcx, %rax
jbe 0xe381d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xe383d
cmpq $0x0, -0x20(%rbp)
je 0xe3830
jmp 0xe394c
movq $0x0, -0x28(%rbp)
jmp 0xe38eb
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x40(%rbp), %r8
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %r9
leaq 0x71c30(%rip), %rdi # 0x155495
movl $0x589, %esi # imm = 0x589
callq 0xe3ff0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0xe38a1
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe2c70
movl $0x1, -0x4(%rbp)
jmp 0xe3a6e
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xe38e9
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x2a090
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0xe394c
jmp 0xe38eb
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe2c70
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a090
movl $0x0, -0x4(%rbp)
jmp 0xe3a6e
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x58(%rbp)
jmp 0xe3965
movq -0x20(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0xe3979
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0xe3981
movq -0x58(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x60(%rbp), %rdx
callq 0x2a090
movq -0x60(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe39d8
movq -0x38(%rbp), %rax
subq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe4(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x58(%rbp), %rdx
subq -0x60(%rbp), %rdx
movq %rdx, -0x68(%rbp)
callq 0x2a090
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq -0x68(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x48(%rbp), %rcx
addq -0x60(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe2c70
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _my_b_seq_read:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_20]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
lea rsi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 54Ch
call inline_mysql_mutex_lock_23
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
mov rcx, [rcx+18h]
mov rdx, [rbp+var_10]
mov rdx, [rdx+20h]
sub rcx, rdx
add rax, rcx
mov [rbp+var_48], rax
mov rcx, [rbp+var_10]
cmp rax, [rcx+8]
jb short loc_E36A5
jmp loc_E394C
loc_E36A5:
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rcx, [rbp+var_48]
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 557h
xor r8d, r8d
xor eax, eax
mov r9d, eax
call inline_mysql_file_seek_6
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_E36F9
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_24
mov [rbp+var_4], 1
jmp loc_E3A6E
loc_E36F9:
mov rax, [rbp+var_10]
mov dword ptr [rax+0E0h], 0
mov rax, [rbp+var_48]
and rax, 0FFFh
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
mov ecx, 1000h
sub rcx, [rbp+var_30]
add rcx, 1000h
cmp rax, rcx
jb loc_E37E5
mov rax, 0FFFFF000h
and rax, [rbp+var_20]
sub rax, [rbp+var_30]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_28]
mov rax, [rbp+var_10]
mov r9, [rax+0F8h]
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 569h
call inline_mysql_file_read_5
mov [rbp+var_50], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_E37A7
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_24
mov [rbp+var_4], 1
jmp loc_E3A6E
loc_E37A7:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_50]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rax, [rbp+var_50]
add rax, [rbp+var_48]
mov [rbp+var_48], rax
mov rax, [rbp+var_50]
cmp rax, [rbp+var_28]
jz short loc_E37DD
jmp loc_E394C
loc_E37DD:
mov [rbp+var_30], 0
loc_E37E5:
mov rax, [rbp+var_10]
mov rax, [rax+0F0h]
sub rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
sub rcx, [rbp+var_48]
cmp rax, rcx
jbe short loc_E381D
mov rax, [rbp+var_10]
mov rax, [rax+8]
sub rax, [rbp+var_48]
mov [rbp+var_40], rax
loc_E381D:
cmp [rbp+var_40], 0
jnz short loc_E383D
cmp [rbp+var_20], 0
jz short loc_E3830
jmp loc_E394C
loc_E3830:
mov [rbp+var_28], 0
jmp loc_E38EB
loc_E383D:
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov r8, [rbp+var_40]
mov rax, [rbp+var_10]
mov r9, [rax+0F8h]
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 589h
call inline_mysql_file_read_5
mov [rbp+var_28], rax
cmp [rbp+var_28], 0FFFFFFFFFFFFFFFFh
jnz short loc_E38A1
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_24
mov [rbp+var_4], 1
jmp loc_E3A6E
loc_E38A1:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_20]
jnb short loc_E38E9
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+20h]
mov rdx, [rbp+var_28]
call _memcpy
mov rcx, [rbp+var_28]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_48]
mov [rbp+var_48], rax
jmp short loc_E394C
loc_E38E9:
jmp short $+2
loc_E38EB:
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_24
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
add rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
add rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rcx, [rbp+var_48]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+20h]
mov rdx, [rbp+var_20]
call _memcpy
mov [rbp+var_4], 0
jmp loc_E3A6E
loc_E394C:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+38h]
sub rax, rcx
mov [rbp+var_58], rax
jmp short $+2
loc_E3965:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_58]
jnb short loc_E3979
mov rax, [rbp+var_20]
mov [rbp+var_70], rax
jmp short loc_E3981
loc_E3979:
mov rax, [rbp+var_58]
mov [rbp+var_70], rax
loc_E3981:
mov rax, [rbp+var_70]
mov [rbp+var_60], rax
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+38h]
mov rdx, [rbp+var_60]
call _memcpy
mov rcx, [rbp+var_60]
mov rax, [rbp+var_10]
add rcx, [rax+38h]
mov [rax+38h], rcx
mov rcx, [rbp+var_60]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_E39D8
mov rax, [rbp+var_38]
sub rax, [rbp+var_20]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax+0E4h], ecx
loc_E39D8:
mov rax, [rbp+var_10]
mov rdi, [rax+20h]
mov rax, [rbp+var_10]
mov rsi, [rax+38h]
mov rdx, [rbp+var_58]
sub rdx, [rbp+var_60]
mov [rbp+var_68], rdx
call _memcpy
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
add rcx, [rbp+var_68]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+40h]
mov rax, [rbp+var_10]
mov [rax+38h], rcx
mov rcx, [rbp+var_48]
add rcx, [rbp+var_60]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_58]
mov rax, [rbp+var_10]
add rcx, [rax+8]
mov [rax+8], rcx
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_24
mov rdx, [rbp+var_20]
xor eax, eax
mov ecx, 1
cmp rdx, 0
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_E3A6E:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
| _BOOL8 my_b_seq_read(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v4; // [rsp+0h] [rbp-70h]
unsigned long long v5; // [rsp+18h] [rbp-58h]
long long v6; // [rsp+20h] [rbp-50h]
unsigned long long v7; // [rsp+28h] [rbp-48h]
unsigned long long v8; // [rsp+30h] [rbp-40h]
int v9; // [rsp+38h] [rbp-38h]
unsigned long long v10; // [rsp+40h] [rbp-30h]
unsigned long long v11; // [rsp+48h] [rbp-28h]
unsigned long long v12; // [rsp+48h] [rbp-28h]
unsigned long long v13; // [rsp+50h] [rbp-20h]
unsigned long long v14; // [rsp+50h] [rbp-20h]
long long v15; // [rsp+58h] [rbp-18h]
v15 = a2;
v13 = a3;
v9 = a3;
inline_mysql_mutex_lock_23(a1 + 80, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c", 0x54Cu);
v7 = *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 32) + *(_QWORD *)a1;
if ( v7 >= *(_QWORD *)(a1 + 8) )
goto LABEL_18;
if ( inline_mysql_file_seek_6(
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
0x557u,
*(_DWORD *)(a1 + 212),
v7,
0,
0LL) == -1 )
goto LABEL_14;
*(_DWORD *)(a1 + 224) = 0;
v10 = v7 & 0xFFF;
if ( v13 >= 4096 - v10 + 4096 )
{
v11 = ((unsigned int)v13 & 0xFFFFF000) - v10;
v6 = inline_mysql_file_read_5(
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1385LL,
*(unsigned int *)(a1 + 212),
a2,
v11,
*(_QWORD *)(a1 + 248));
if ( v6 == -1 )
goto LABEL_14;
v13 -= v6;
v15 = a2 + v6;
v7 += v6;
if ( v6 != v11 )
goto LABEL_18;
v10 = 0LL;
}
v8 = *(_QWORD *)(a1 + 240) - v10;
if ( v8 > *(_QWORD *)(a1 + 8) - v7 )
v8 = *(_QWORD *)(a1 + 8) - v7;
if ( v8 )
{
v12 = inline_mysql_file_read_5(
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1417LL,
*(unsigned int *)(a1 + 212),
*(_QWORD *)(a1 + 32),
v8,
*(_QWORD *)(a1 + 248));
if ( v12 == -1LL )
{
LABEL_14:
*(_DWORD *)(a1 + 228) = -1;
inline_mysql_mutex_unlock_24(a1 + 80);
return 1;
}
if ( v12 >= v13 )
{
LABEL_17:
inline_mysql_mutex_unlock_24(a1 + 80);
*(_QWORD *)(a1 + 16) = v13 + *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 24) = v12 + *(_QWORD *)(a1 + 32);
*(_QWORD *)a1 = v7;
memcpy(v15, *(_QWORD *)(a1 + 32), v13);
return 0;
}
memcpy(v15, *(_QWORD *)(a1 + 32), v12);
v13 -= v12;
v15 += v12;
v7 += v12;
}
else if ( !v13 )
{
v12 = 0LL;
goto LABEL_17;
}
LABEL_18:
v5 = *(_QWORD *)(a1 + 64) - *(_QWORD *)(a1 + 56);
if ( v13 >= v5 )
v4 = *(_QWORD *)(a1 + 64) - *(_QWORD *)(a1 + 56);
else
v4 = v13;
memcpy(v15, *(_QWORD *)(a1 + 56), v4);
*(_QWORD *)(a1 + 56) += v4;
v14 = v13 - v4;
if ( v14 )
*(_DWORD *)(a1 + 228) = v9 - v14;
memcpy(*(_QWORD *)(a1 + 32), *(_QWORD *)(a1 + 56), v5 - v4);
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 24) = v5 - v4 + *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 56) = *(_QWORD *)(a1 + 64);
*(_QWORD *)a1 = v4 + v7;
*(_QWORD *)(a1 + 8) += v5;
inline_mysql_mutex_unlock_24(a1 + 80);
return v14 != 0;
}
| _my_b_seq_read:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
LEA RSI,[0x255495]
MOV EDX,0x54c
CALL 0x001e2b40
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x18]
MOV RDX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RDX + 0x20]
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x8]
JC 0x001e36a5
JMP 0x001e394c
LAB_001e36a5:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RCX,qword ptr [RBP + -0x48]
LEA RDI,[0x255495]
MOV ESI,0x557
XOR R8D,R8D
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001e15e0
CMP RAX,-0x1
JNZ 0x001e36f9
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e2c70
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e3a6e
LAB_001e36f9:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],0x0
MOV RAX,qword ptr [RBP + -0x48]
AND RAX,0xfff
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,0x1000
SUB RCX,qword ptr [RBP + -0x30]
ADD RCX,0x1000
CMP RAX,RCX
JC 0x001e37e5
MOV RAX,0xfffff000
AND RAX,qword ptr [RBP + -0x20]
SUB RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0xf8]
LEA RDI,[0x255495]
MOV ESI,0x569
CALL 0x001e3ff0
MOV qword ptr [RBP + -0x50],RAX
CMP RAX,-0x1
JNZ 0x001e37a7
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e2c70
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e3a6e
LAB_001e37a7:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x28]
JZ 0x001e37dd
JMP 0x001e394c
LAB_001e37dd:
MOV qword ptr [RBP + -0x30],0x0
LAB_001e37e5:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xf0]
SUB RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,qword ptr [RBP + -0x48]
CMP RAX,RCX
JBE 0x001e381d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
SUB RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x40],RAX
LAB_001e381d:
CMP qword ptr [RBP + -0x40],0x0
JNZ 0x001e383d
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e3830
JMP 0x001e394c
LAB_001e3830:
MOV qword ptr [RBP + -0x28],0x0
JMP 0x001e38eb
LAB_001e383d:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV R8,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0xf8]
LEA RDI,[0x255495]
MOV ESI,0x589
CALL 0x001e3ff0
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],-0x1
JNZ 0x001e38a1
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e2c70
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e3a6e
LAB_001e38a1:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x001e38e9
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x0012a090
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001e394c
LAB_001e38e9:
JMP 0x001e38eb
LAB_001e38eb:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e2c70
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
ADD RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
ADD RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0012a090
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001e3a6e
LAB_001e394c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x38]
SUB RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001e3965
LAB_001e3965:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x58]
JNC 0x001e3979
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001e3981
LAB_001e3979:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x70],RAX
LAB_001e3981:
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x38]
MOV RDX,qword ptr [RBP + -0x60]
CALL 0x0012a090
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x38]
MOV qword ptr [RAX + 0x38],RCX
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e39d8
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr [RBP + -0x20]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],ECX
LAB_001e39d8:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x38]
MOV RDX,qword ptr [RBP + -0x58]
SUB RDX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x68],RDX
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
ADD RCX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],RCX
MOV RCX,qword ptr [RBP + -0x48]
ADD RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e2c70
MOV RDX,qword ptr [RBP + -0x20]
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,0x0
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_001e3a6e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
bool _my_b_seq_read(ulong *param_1,void *param_2,ulong param_3)
{
long lVar1;
ulong uVar2;
long lVar3;
size_t local_78;
ulong local_50;
ulong local_48;
ulong local_38;
ulong local_30;
ulong local_28;
void *local_20;
inline_mysql_mutex_lock
(param_1 + 10,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x54c);
local_50 = *param_1 + (param_1[3] - param_1[4]);
local_28 = param_3;
local_20 = param_2;
if (local_50 < param_1[1]) {
lVar3 = inline_mysql_file_seek
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x557,
*(int4 *)((long)param_1 + 0xd4),local_50,0,0);
if (lVar3 == -1) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
inline_mysql_mutex_unlock(param_1 + 10);
return true;
}
*(int4 *)(param_1 + 0x1c) = 0;
local_38 = local_50 & 0xfff;
if (0x2000 - local_38 <= param_3) {
lVar3 = (param_3 & 0xfffff000) - local_38;
lVar1 = inline_mysql_file_read
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x569,
*(int4 *)((long)param_1 + 0xd4),param_2,lVar3,param_1[0x1f]);
if (lVar1 == -1) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
inline_mysql_mutex_unlock(param_1 + 10);
return true;
}
local_28 = param_3 - lVar1;
local_20 = (void *)(lVar1 + (long)param_2);
local_50 = lVar1 + local_50;
if (lVar1 != lVar3) goto LAB_001e394c;
local_38 = 0;
}
local_48 = param_1[0x1e] - local_38;
if (param_1[1] - local_50 < local_48) {
local_48 = param_1[1] - local_50;
}
if (local_48 == 0) {
if (local_28 == 0) {
local_30 = 0;
LAB_001e38eb:
inline_mysql_mutex_unlock(param_1 + 10);
param_1[2] = param_1[4] + local_28;
param_1[3] = param_1[4] + local_30;
*param_1 = local_50;
memcpy(local_20,(void *)param_1[4],local_28);
return false;
}
}
else {
local_30 = inline_mysql_file_read
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x589,
*(int4 *)((long)param_1 + 0xd4),param_1[4],local_48,param_1[0x1f])
;
if (local_30 == 0xffffffffffffffff) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
inline_mysql_mutex_unlock(param_1 + 10);
return true;
}
if (local_28 <= local_30) goto LAB_001e38eb;
memcpy(local_20,(void *)param_1[4],local_30);
local_28 = local_28 - local_30;
local_20 = (void *)(local_30 + (long)local_20);
local_50 = local_30 + local_50;
}
}
LAB_001e394c:
uVar2 = param_1[8] - param_1[7];
local_78 = uVar2;
if (local_28 < uVar2) {
local_78 = local_28;
}
memcpy(local_20,(void *)param_1[7],local_78);
param_1[7] = local_78 + param_1[7];
lVar3 = local_28 - local_78;
if (lVar3 != 0) {
*(int *)((long)param_1 + 0xe4) = (int)param_3 - (int)lVar3;
}
memcpy((void *)param_1[4],(void *)param_1[7],uVar2 - local_78);
param_1[2] = param_1[4];
param_1[3] = param_1[4] + (uVar2 - local_78);
param_1[7] = param_1[8];
*param_1 = local_50 + local_78;
param_1[1] = uVar2 + param_1[1];
inline_mysql_mutex_unlock(param_1 + 10);
return lVar3 != 0;
}
| |
50,688 | 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=(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>) | monkey531[P]llama/common/json.hpp | basic_json& operator=(basic_json other) noexcept (
std::is_nothrow_move_constructible<value_t>::value&&
std::is_nothrow_move_assignable<value_t>::value&&
std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value&&
std::is_nothrow_move_assignable<json_base_class_t>::value
)
{
// check that passed value is valid
other.assert_invariant();
using std::swap;
swap(m_data.m_type, other.m_data.m_type);
swap(m_data.m_value, other.m_data.m_value);
json_base_class_t::operator=(std::move(other));
set_parents();
assert_invariant();
return *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=(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>):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x5cc1e
movb (%r14), %al
movb (%rbx), %cl
movb %cl, (%r14)
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x5cc1e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rdi, rsi
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 al, [r14]
mov cl, [rbx]
mov [r14], cl
mov [rbx], al
mov rax, [r14+8]
mov rcx, [rbx+8]
mov [r14+8], rcx
mov [rbx+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)
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
| 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,
long long a2)
{
char v2; // al
long long v3; // rax
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 *)a2);
v2 = *(_BYTE *)a1;
*(_BYTE *)a1 = *(_BYTE *)a2;
*(_BYTE *)a2 = v2;
v3 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = *(_QWORD *)(a2 + 8);
*(_QWORD *)(a2 + 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);
return a1;
}
| operator=:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,RSI
MOV ESI,0x1
CALL 0x0015cc1e
MOV AL,byte ptr [R14]
MOV CL,byte ptr [RBX]
MOV byte ptr [R14],CL
MOV byte ptr [RBX],AL
MOV RAX,qword ptr [R14 + 0x8]
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [R14 + 0x8],RCX
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x0015cc1e
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* 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>::TEMPNAMEPLACEHOLDERVALUE(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>) */
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>
* __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,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>
*param_2)
{
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
int8 uVar2;
assert_invariant(SUB81(param_2,0));
bVar1 = *this;
*this = *param_2;
*param_2 = bVar1;
uVar2 = *(int8 *)(this + 8);
*(int8 *)(this + 8) = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = uVar2;
assert_invariant(SUB81(this,0));
return this;
}
| |
50,689 | 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=(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>) | monkey531[P]llama/common/json.hpp | basic_json& operator=(basic_json other) noexcept (
std::is_nothrow_move_constructible<value_t>::value&&
std::is_nothrow_move_assignable<value_t>::value&&
std::is_nothrow_move_constructible<json_value>::value&&
std::is_nothrow_move_assignable<json_value>::value&&
std::is_nothrow_move_assignable<json_base_class_t>::value
)
{
// check that passed value is valid
other.assert_invariant();
using std::swap;
swap(m_data.m_type, other.m_data.m_type);
swap(m_data.m_value, other.m_data.m_value);
json_base_class_t::operator=(std::move(other));
set_parents();
assert_invariant();
return *this;
} | O3 | 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=(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>):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x5d774
movb (%r14), %al
movb (%rbx), %cl
movb %cl, (%r14)
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x5d774
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rdi, rsi
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 al, [r14]
mov cl, [rbx]
mov [r14], cl
mov [rbx], al
mov rax, [r14+8]
mov rcx, [rbx+8]
mov [r14+8], rcx
mov [rbx+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)
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
| 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,
long long a2)
{
char v2; // al
long long v3; // rax
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 *)a2);
v2 = *(_BYTE *)a1;
*(_BYTE *)a1 = *(_BYTE *)a2;
*(_BYTE *)a2 = v2;
v3 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = *(_QWORD *)(a2 + 8);
*(_QWORD *)(a2 + 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);
return a1;
}
| operator=:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,RSI
MOV ESI,0x1
CALL 0x0015d774
MOV AL,byte ptr [R14]
MOV CL,byte ptr [RBX]
MOV byte ptr [R14],CL
MOV byte ptr [RBX],AL
MOV RAX,qword ptr [R14 + 0x8]
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [R14 + 0x8],RCX
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x0015d774
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* 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>::TEMPNAMEPLACEHOLDERVALUE(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>) */
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>
* __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,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>
*param_2)
{
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
int8 uVar2;
assert_invariant(SUB81(param_2,0));
bVar1 = *this;
*this = *param_2;
*param_2 = bVar1;
uVar2 = *(int8 *)(this + 8);
*(int8 *)(this + 8) = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = uVar2;
assert_invariant(SUB81(this,0));
return this;
}
| |
50,690 | my_wildcmp_8bit_impl | eloqsql/strings/ctype-simple.c | static
int my_wildcmp_8bit_impl(CHARSET_INFO *cs,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many, int recurse_level)
{
int result= -1; /* Not found, using wildcards */
if (my_string_stack_guard && my_string_stack_guard(recurse_level))
return 1;
while (wildstr != wildend)
{
while (*wildstr != w_many && *wildstr != w_one)
{
if (*wildstr == escape && wildstr+1 != wildend)
wildstr++;
if (str == str_end || likeconv(cs,*wildstr++) != likeconv(cs,*str++))
return(1); /* No match */
if (wildstr == wildend)
return(str != str_end); /* Match if both are at end */
result=1; /* Found an anchor char */
}
if (*wildstr == w_one)
{
do
{
if (str == str_end) /* Skip one char if possible */
return(result);
INC_PTR(cs,str,str_end);
} while (++wildstr < wildend && *wildstr == w_one);
if (wildstr == wildend)
break;
}
if (*wildstr == w_many)
{ /* Found w_many */
uchar cmp;
wildstr++;
/* Remove any '%' and '_' from the wild search string */
for (; wildstr != wildend ; wildstr++)
{
if (*wildstr == w_many)
continue;
if (*wildstr == w_one)
{
if (str == str_end)
return(-1);
INC_PTR(cs,str,str_end);
continue;
}
break; /* Not a wild character */
}
if (wildstr == wildend)
return(0); /* Ok if w_many is last */
if (str == str_end)
return(-1);
if ((cmp= *wildstr) == escape && wildstr+1 != wildend)
cmp= *++wildstr;
INC_PTR(cs,wildstr,wildend); /* This is compared trough cmp */
cmp=likeconv(cs,cmp);
do
{
/*
Find the next character in the subject string equal to 'cmp', then
check recursively my_wildcmp_8bit_impl() for the pattern remainder.
*/
while (str != str_end && (uchar) likeconv(cs,*str) != cmp)
str++;
if (str++ == str_end)
return(-1); /* 'cmp' was not found in the subject string */
{
int tmp=my_wildcmp_8bit_impl(cs,str,str_end,
wildstr,wildend,escape,w_one,
w_many, recurse_level+1);
if (tmp <= 0)
return(tmp);
}
/*
The recursion call did not match. But it returned 1, which means
the pattern remainder has some non-special characters.
Continue, there is a chance that we'll find another 'cmp'
at a different position in the subject string.
*/
} while (str != str_end);
return(-1);
}
}
return(str != str_end ? 1 : 0);
} | O0 | c | my_wildcmp_8bit_impl:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
leaq 0x3491e1(%rip), %rax # 0x38c4b8
cmpq $0x0, (%rax)
je 0x432fd
leaq 0x3491d4(%rip), %rax # 0x38c4b8
movq (%rax), %rax
movl 0x20(%rbp), %edi
callq *%rax
cmpl $0x0, %eax
je 0x432fd
movl $0x1, -0x4(%rbp)
jmp 0x4362a
jmp 0x432ff
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x43612
jmp 0x4330f
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl 0x18(%rbp), %ecx
movb %al, -0x41(%rbp)
je 0x43330
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x4333c
jmp 0x433e6
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x34(%rbp), %eax
jne 0x43362
movq -0x28(%rbp), %rax
addq $0x1, %rax
cmpq -0x30(%rbp), %rax
je 0x43362
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x433ac
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x433b8
movl $0x1, -0x4(%rbp)
jmp 0x4362a
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x433da
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x4362a
movl $0x1, -0x38(%rbp)
jmp 0x4330f
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
jne 0x43454
jmp 0x433f4
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x43409
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4362a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x42(%rbp)
jae 0x4343c
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
sete %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x433f4
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x43452
jmp 0x43612
jmp 0x43454
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x18(%rbp), %eax
jne 0x4360d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x434c8
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x18(%rbp), %eax
jne 0x43488
jmp 0x434ba
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
jne 0x434b8
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x434aa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4362a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x434ba
jmp 0x434c8
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x43470
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x434de
movl $0x0, -0x4(%rbp)
jmp 0x4362a
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x434f4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4362a
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x39(%rbp)
movzbl %al, %eax
cmpl -0x34(%rbp), %eax
jne 0x43528
movq -0x28(%rbp), %rax
addq $0x1, %rax
cmpq -0x30(%rbp), %rax
je 0x43528
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb 0x1(%rax), %al
movb %al, -0x39(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movzbl -0x39(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x39(%rbp)
jmp 0x43548
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x43(%rbp)
je 0x43576
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movzbl -0x39(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x43(%rbp)
movb -0x43(%rbp), %al
testb $0x1, %al
jne 0x4357f
jmp 0x4358d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x43548
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x435ab
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4362a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl -0x34(%rbp), %r9d
movl 0x10(%rbp), %r11d
movl 0x18(%rbp), %r10d
movl 0x20(%rbp), %eax
addl $0x1, %eax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x432a0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jg 0x435f4
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4362a
jmp 0x435f6
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x43546
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4362a
jmp 0x432ff
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_wildcmp_8bit_impl:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_10]
mov eax, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_34], r9d
mov [rbp+var_38], 0FFFFFFFFh
lea rax, my_string_stack_guard
cmp qword ptr [rax], 0
jz short loc_432FD
lea rax, my_string_stack_guard
mov rax, [rax]
mov edi, [rbp+arg_10]
call rax
cmp eax, 0
jz short loc_432FD
mov [rbp+var_4], 1
jmp loc_4362A
loc_432FD:
jmp short $+2
loc_432FF:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jz loc_43612
jmp short $+2
loc_4330F:
mov rax, [rbp+var_28]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, [rbp+arg_8]
mov [rbp+var_41], al
jz short loc_43330
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
setnz al
mov [rbp+var_41], al
loc_43330:
mov al, [rbp+var_41]
test al, 1
jnz short loc_4333C
jmp loc_433E6
loc_4333C:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+var_34]
jnz short loc_43362
mov rax, [rbp+var_28]
add rax, 1
cmp rax, [rbp+var_30]
jz short loc_43362
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
loc_43362:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jz short loc_433AC
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_28]
mov rdx, rcx
add rdx, 1
mov [rbp+var_28], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_10]
mov rcx, [rcx+58h]
mov rdx, [rbp+var_18]
mov rsi, rdx
add rsi, 1
mov [rbp+var_18], rsi
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_433B8
loc_433AC:
mov [rbp+var_4], 1
jmp loc_4362A
loc_433B8:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnz short loc_433DA
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
setnz al
and al, 1
movzx eax, al
mov [rbp+var_4], eax
jmp loc_4362A
loc_433DA:
mov [rbp+var_38], 1
jmp loc_4330F
loc_433E6:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
jnz short loc_43454
jmp short $+2
loc_433F4:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz short loc_43409
mov eax, [rbp+var_38]
mov [rbp+var_4], eax
jmp loc_4362A
loc_43409:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
mov rcx, [rbp+var_28]
add rcx, 1
mov [rbp+var_28], rcx
xor eax, eax
cmp rcx, [rbp+var_30]
mov [rbp+var_42], al
jnb short loc_4343C
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
setz al
mov [rbp+var_42], al
loc_4343C:
mov al, [rbp+var_42]
test al, 1
jnz short loc_433F4
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnz short loc_43452
jmp loc_43612
loc_43452:
jmp short $+2
loc_43454:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_8]
jnz loc_4360D
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
loc_43470:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jz short loc_434C8
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_8]
jnz short loc_43488
jmp short loc_434BA
loc_43488:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
jnz short loc_434B8
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz short loc_434AA
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_4362A
loc_434AA:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_434BA
loc_434B8:
jmp short loc_434C8
loc_434BA:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_43470
loc_434C8:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnz short loc_434DE
mov [rbp+var_4], 0
jmp loc_4362A
loc_434DE:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz short loc_434F4
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_4362A
loc_434F4:
mov rax, [rbp+var_28]
mov al, [rax]
mov [rbp+var_39], al
movzx eax, al
cmp eax, [rbp+var_34]
jnz short loc_43528
mov rax, [rbp+var_28]
add rax, 1
cmp rax, [rbp+var_30]
jz short loc_43528
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 1
mov [rbp+var_28], rcx
mov al, [rax+1]
mov [rbp+var_39], al
loc_43528:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rax, [rax+58h]
movzx ecx, [rbp+var_39]
mov al, [rax+rcx]
mov [rbp+var_39], al
loc_43546:
jmp short $+2
loc_43548:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_20]
mov [rbp+var_43], al
jz short loc_43576
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
movzx ecx, [rbp+var_39]
cmp eax, ecx
setnz al
mov [rbp+var_43], al
loc_43576:
mov al, [rbp+var_43]
test al, 1
jnz short loc_4357F
jmp short loc_4358D
loc_4357F:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_43548
loc_4358D:
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
cmp rax, [rbp+var_20]
jnz short loc_435AB
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_4362A
loc_435AB:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9d, [rbp+var_34]
mov r11d, [rbp+arg_0]
mov r10d, [rbp+arg_8]
mov eax, [rbp+arg_10]
add eax, 1
mov [rsp+60h+var_60], r11d
mov [rsp+60h+var_58], r10d
mov [rsp+60h+var_50], eax
call my_wildcmp_8bit_impl
mov [rbp+var_40], eax
cmp [rbp+var_40], 0
jg short loc_435F4
mov eax, [rbp+var_40]
mov [rbp+var_4], eax
jmp short loc_4362A
loc_435F4:
jmp short $+2
loc_435F6:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz loc_43546
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_4362A
loc_4360D:
jmp loc_432FF
loc_43612:
mov rdx, [rbp+var_18]
mov rsi, [rbp+var_20]
xor eax, eax
mov ecx, 1
cmp rdx, rsi
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_4362A:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
| long long my_wildcmp_8bit_impl(
long long a1,
unsigned __int8 *a2,
unsigned __int8 *a3,
char *a4,
char *a5,
int a6,
int a7,
int a8,
unsigned int a9)
{
char *v9; // rcx
unsigned __int8 *v10; // rdx
char *v11; // rax
unsigned __int8 *v12; // rax
bool v14; // [rsp+1Dh] [rbp-43h]
bool v15; // [rsp+1Eh] [rbp-42h]
bool v16; // [rsp+1Fh] [rbp-41h]
int v17; // [rsp+20h] [rbp-40h]
unsigned __int8 v18; // [rsp+27h] [rbp-39h]
unsigned __int8 v19; // [rsp+27h] [rbp-39h]
unsigned int v20; // [rsp+28h] [rbp-38h]
char *i; // [rsp+38h] [rbp-28h]
int v25; // [rsp+38h] [rbp-28h]
v20 = -1;
if ( my_string_stack_guard && (unsigned int)my_string_stack_guard(a9) )
{
return 1;
}
else
{
do
{
if ( a4 != a5 )
{
while ( 1 )
{
v16 = 0;
if ( *a4 != a8 )
v16 = *a4 != a7;
if ( !v16 )
break;
if ( *a4 == a6 && a4 + 1 != a5 )
++a4;
if ( a2 == a3 )
return 1;
v9 = a4++;
v10 = a2++;
if ( *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + (unsigned __int8)*v9) != *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v10) )
return 1;
if ( a4 == a5 )
return a2 != a3;
v20 = 1;
}
if ( *a4 != a7 )
continue;
do
{
if ( a2 == a3 )
return v20;
++a2;
++a4;
v15 = 0;
if ( a4 < a5 )
v15 = *a4 == a7;
}
while ( v15 );
if ( a4 != a5 )
continue;
}
return a2 != a3;
}
while ( *a4 != a8 );
for ( i = a4 + 1; i != a5; ++i )
{
if ( *i != a8 )
{
if ( *i != a7 )
break;
if ( a2 == a3 )
return (unsigned int)-1;
++a2;
}
}
if ( i == a5 )
{
return 0;
}
else if ( a2 == a3 )
{
return (unsigned int)-1;
}
else
{
v18 = *i;
if ( (unsigned __int8)*i == a6 && i + 1 != a5 )
{
v11 = i;
LODWORD(i) = (_DWORD)i + 1;
v18 = v11[1];
}
v25 = (_DWORD)i + 1;
v19 = *(_BYTE *)(*(_QWORD *)(a1 + 88) + v18);
do
{
while ( 1 )
{
v14 = 0;
if ( a2 != a3 )
v14 = *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *a2) != v19;
if ( !v14 )
break;
++a2;
}
v12 = a2++;
if ( v12 == a3 )
return (unsigned int)-1;
v17 = my_wildcmp_8bit_impl(a1, (_DWORD)a2, (_DWORD)a3, v25, (_DWORD)a5, a6, a7, a8, a9 + 1);
if ( v17 <= 0 )
return (unsigned int)v17;
}
while ( a2 != a3 );
return (unsigned int)-1;
}
}
}
| my_wildcmp_8bit_impl:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
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 qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x34],R9D
MOV dword ptr [RBP + -0x38],0xffffffff
LEA RAX,[0x48c4b8]
CMP qword ptr [RAX],0x0
JZ 0x001432fd
LEA RAX,[0x48c4b8]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RBP + 0x20]
CALL RAX
CMP EAX,0x0
JZ 0x001432fd
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014362a
LAB_001432fd:
JMP 0x001432ff
LAB_001432ff:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x00143612
JMP 0x0014330f
LAB_0014330f:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,dword ptr [RBP + 0x18]
MOV byte ptr [RBP + -0x41],AL
JZ 0x00143330
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
SETNZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_00143330:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x0014333c
JMP 0x001433e6
LAB_0014333c:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + -0x34]
JNZ 0x00143362
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x00143362
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_00143362:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001433ac
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x58]
MOV RDX,qword ptr [RBP + -0x18]
MOV RSI,RDX
ADD RSI,0x1
MOV qword ptr [RBP + -0x18],RSI
MOVZX EDX,byte ptr [RDX]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x001433b8
LAB_001433ac:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014362a
LAB_001433b8:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001433da
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014362a
LAB_001433da:
MOV dword ptr [RBP + -0x38],0x1
JMP 0x0014330f
LAB_001433e6:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
JNZ 0x00143454
JMP 0x001433f4
LAB_001433f4:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00143409
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014362a
LAB_00143409:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x30]
MOV byte ptr [RBP + -0x42],AL
JNC 0x0014343c
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
SETZ AL
MOV byte ptr [RBP + -0x42],AL
LAB_0014343c:
MOV AL,byte ptr [RBP + -0x42]
TEST AL,0x1
JNZ 0x001433f4
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00143452
JMP 0x00143612
LAB_00143452:
JMP 0x00143454
LAB_00143454:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x18]
JNZ 0x0014360d
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_00143470:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x001434c8
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x18]
JNZ 0x00143488
JMP 0x001434ba
LAB_00143488:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
JNZ 0x001434b8
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x001434aa
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0014362a
LAB_001434aa:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001434ba
LAB_001434b8:
JMP 0x001434c8
LAB_001434ba:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00143470
LAB_001434c8:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001434de
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014362a
LAB_001434de:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x001434f4
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0014362a
LAB_001434f4:
MOV RAX,qword ptr [RBP + -0x28]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x39],AL
MOVZX EAX,AL
CMP EAX,dword ptr [RBP + -0x34]
JNZ 0x00143528
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x00143528
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
MOV AL,byte ptr [RAX + 0x1]
MOV byte ptr [RBP + -0x39],AL
LAB_00143528:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOVZX ECX,byte ptr [RBP + -0x39]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x39],AL
LAB_00143546:
JMP 0x00143548
LAB_00143548:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x20]
MOV byte ptr [RBP + -0x43],AL
JZ 0x00143576
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOVZX ECX,byte ptr [RBP + -0x39]
CMP EAX,ECX
SETNZ AL
MOV byte ptr [RBP + -0x43],AL
LAB_00143576:
MOV AL,byte ptr [RBP + -0x43]
TEST AL,0x1
JNZ 0x0014357f
JMP 0x0014358d
LAB_0014357f:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00143548
LAB_0014358d:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x001435ab
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0014362a
LAB_001435ab:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9D,dword ptr [RBP + -0x34]
MOV R11D,dword ptr [RBP + 0x10]
MOV R10D,dword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x20]
ADD EAX,0x1
MOV dword ptr [RSP],R11D
MOV dword ptr [RSP + 0x8],R10D
MOV dword ptr [RSP + 0x10],EAX
CALL 0x001432a0
MOV dword ptr [RBP + -0x40],EAX
CMP dword ptr [RBP + -0x40],0x0
JG 0x001435f4
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014362a
LAB_001435f4:
JMP 0x001435f6
LAB_001435f6:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00143546
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0014362a
LAB_0014360d:
JMP 0x001432ff
LAB_00143612:
MOV RDX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,RSI
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_0014362a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
uint my_wildcmp_8bit_impl
(long param_1,byte *param_2,byte *param_3,byte *param_4,byte *param_5,uint param_6,
int param_7,int param_8,int param_9)
{
char cVar1;
int iVar2;
uint uVar3;
byte *pbVar4;
bool bVar5;
byte local_41;
uint local_40;
byte *local_30;
byte *local_20;
uint local_c;
local_40 = 0xffffffff;
local_30 = param_4;
local_20 = param_2;
if ((my_string_stack_guard == (code *)0x0) ||
(iVar2 = (*my_string_stack_guard)(param_9), iVar2 == 0)) {
do {
if (local_30 == param_5) {
LAB_00143612:
return (uint)(local_20 != param_3);
}
while( true ) {
bVar5 = false;
if ((char)*local_30 != param_8) {
bVar5 = (char)*local_30 != param_7;
}
if (!bVar5) break;
if (((int)(char)*local_30 == param_6) && (local_30 + 1 != param_5)) {
local_30 = local_30 + 1;
}
if (local_20 == param_3) {
return 1;
}
if (*(char *)(*(long *)(param_1 + 0x58) + (ulong)*local_30) !=
*(char *)(*(long *)(param_1 + 0x58) + (ulong)*local_20)) {
return 1;
}
if (local_30 + 1 == param_5) {
return (uint)(local_20 + 1 != param_3);
}
local_40 = 1;
local_30 = local_30 + 1;
local_20 = local_20 + 1;
}
if ((char)*local_30 == param_7) {
do {
if (local_20 == param_3) {
return local_40;
}
local_20 = local_20 + 1;
local_30 = local_30 + 1;
bVar5 = false;
if (local_30 < param_5) {
bVar5 = (char)*local_30 == param_7;
}
} while (bVar5);
if (local_30 == param_5) goto LAB_00143612;
}
} while ((char)*local_30 != param_8);
while (pbVar4 = local_30, local_30 = pbVar4 + 1, local_30 != param_5) {
if ((char)*local_30 != param_8) {
if ((char)*local_30 != param_7) break;
if (local_20 == param_3) {
return 0xffffffff;
}
local_20 = local_20 + 1;
}
}
if (local_30 == param_5) {
local_c = 0;
}
else if (local_20 == param_3) {
local_c = 0xffffffff;
}
else {
local_41 = *local_30;
if ((local_41 == param_6) && (pbVar4 + 2 != param_5)) {
local_30 = pbVar4 + 2;
local_41 = pbVar4[2];
}
cVar1 = *(char *)(*(long *)(param_1 + 0x58) + (ulong)local_41);
do {
while( true ) {
bVar5 = false;
if (local_20 != param_3) {
bVar5 = *(char *)(*(long *)(param_1 + 0x58) + (ulong)*local_20) != cVar1;
}
if (!bVar5) break;
local_20 = local_20 + 1;
}
pbVar4 = local_20 + 1;
if (local_20 == param_3) {
return 0xffffffff;
}
uVar3 = my_wildcmp_8bit_impl
(param_1,pbVar4,param_3,local_30 + 1,param_5,param_6,param_7,param_8,
param_9 + 1);
if ((int)uVar3 < 1) {
return uVar3;
}
local_20 = pbVar4;
} while (pbVar4 != param_3);
local_c = 0xffffffff;
}
}
else {
local_c = 1;
}
return local_c;
}
| |
50,691 | 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 0x59780
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 0x59644
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_59780
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_59780:
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 0x00159780
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_00159780:
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 0x00159644
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;
}
| |
50,692 | mi_ft_update | eloqsql/storage/myisam/ft_update.c | int _mi_ft_update(MI_INFO *info, uint keynr, uchar *keybuf,
const uchar *oldrec, const uchar *newrec, my_off_t pos)
{
int error= -1;
FT_WORD *oldlist,*newlist, *old_word, *new_word;
CHARSET_INFO *cs=info->s->keyinfo[keynr].seg->charset;
uint key_length;
int cmp, cmp2;
DBUG_ENTER("_mi_ft_update");
if (!(old_word=oldlist=_mi_ft_parserecord(info, keynr, oldrec,
&info->ft_memroot)) ||
!(new_word=newlist=_mi_ft_parserecord(info, keynr, newrec,
&info->ft_memroot)))
goto err;
error=0;
while(old_word->pos && new_word->pos)
{
cmp= ha_compare_text(cs, (uchar*) old_word->pos,old_word->len,
(uchar*) new_word->pos,new_word->len,0);
cmp2= cmp ? 0 : (fabs(old_word->weight - new_word->weight) > 1.e-5);
if (cmp < 0 || cmp2)
{
key_length=_ft_make_key(info,keynr,keybuf,old_word,pos);
if ((error=_mi_ck_delete(info,keynr,(uchar*) keybuf,key_length)))
goto err;
}
if (cmp > 0 || cmp2)
{
key_length=_ft_make_key(info,keynr,keybuf,new_word,pos);
if ((error=_mi_ck_write(info,keynr,(uchar*) keybuf,key_length)))
goto err;
}
if (cmp<=0) old_word++;
if (cmp>=0) new_word++;
}
if (old_word->pos)
error=_mi_ft_erase(info,keynr,keybuf,old_word,pos);
else if (new_word->pos)
error=_mi_ft_store(info,keynr,keybuf,new_word,pos);
err:
free_root(&info->ft_memroot, MYF(MY_MARK_BLOCKS_FREE));
DBUG_RETURN(error);
} | O0 | c | mi_ft_update:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rcx
addq $0x90, %rcx
callq 0xa41f0
movq %rax, -0x40(%rbp)
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xa444e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rcx
addq $0x90, %rcx
callq 0xa41f0
movq %rax, -0x48(%rbp)
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
jne 0xa4453
jmp 0xa45ff
movl $0x0, -0x34(%rbp)
movq -0x50(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x6d(%rbp)
je 0xa4477
movq -0x58(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x6d(%rbp)
movb -0x6d(%rbp), %al
testb $0x1, %al
jne 0xa4483
jmp 0xa45af
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rax
movq (%rax), %rsi
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x58(%rbp), %rax
movq (%rax), %rcx
movq -0x58(%rbp), %rax
movq 0x10(%rax), %r8
xorl %r9d, %r9d
callq 0xf1830
movl %eax, -0x68(%rbp)
cmpl $0x0, -0x68(%rbp)
je 0xa44bd
xorl %eax, %eax
movl %eax, -0x74(%rbp)
jmp 0xa44f1
movq -0x50(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x58(%rbp), %rax
subsd 0x8(%rax), %xmm0
movaps 0xb5eba(%rip), %xmm1 # 0x15a390
pand %xmm1, %xmm0
movsd 0xb5a6e(%rip), %xmm1 # 0x159f50
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x68(%rbp)
jl 0xa4503
cmpl $0x0, -0x6c(%rbp)
je 0xa4540
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xa4630
movl %eax, -0x64(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x64(%rbp), %ecx
callq 0xa5270
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0xa453e
jmp 0xa45ff
jmp 0xa4540
cmpl $0x0, -0x68(%rbp)
jg 0xa454c
cmpl $0x0, -0x6c(%rbp)
je 0xa4586
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x58(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xa4630
movl %eax, -0x64(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x64(%rbp), %ecx
callq 0xc6ff0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0xa4584
jmp 0xa45ff
jmp 0xa4586
cmpl $0x0, -0x68(%rbp)
jg 0xa4598
movq -0x50(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x68(%rbp)
jl 0xa45aa
movq -0x58(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x58(%rbp)
jmp 0xa445a
movq -0x50(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa45d6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xa4780
movl %eax, -0x34(%rbp)
jmp 0xa45fd
movq -0x58(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa45fb
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x58(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xa4810
movl %eax, -0x34(%rbp)
jmp 0xa45fd
jmp 0xa45ff
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
movl $0x2, %esi
callq 0xeed90
movl -0x34(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0x78(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _mi_ft_update:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov [rbp+var_34], 0FFFFFFFFh
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_C]
imul rcx, 70h ; 'p'
add rax, rcx
mov rax, [rax+28h]
mov rax, [rax]
mov [rbp+var_60], rax
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_8]
add rcx, 90h
call _mi_ft_parserecord
mov [rbp+var_40], rax
mov [rbp+var_50], rax
cmp rax, 0
jz short loc_A444E
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_8]
add rcx, 90h
call _mi_ft_parserecord
mov [rbp+var_48], rax
mov [rbp+var_58], rax
cmp rax, 0
jnz short loc_A4453
loc_A444E:
jmp loc_A45FF
loc_A4453:
mov [rbp+var_34], 0
loc_A445A:
mov rcx, [rbp+var_50]
xor eax, eax
cmp qword ptr [rcx], 0
mov [rbp+var_6D], al
jz short loc_A4477
mov rax, [rbp+var_58]
cmp qword ptr [rax], 0
setnz al
mov [rbp+var_6D], al
loc_A4477:
mov al, [rbp+var_6D]
test al, 1
jnz short loc_A4483
jmp loc_A45AF
loc_A4483:
mov rdi, [rbp+var_60]
mov rax, [rbp+var_50]
mov rsi, [rax]
mov rax, [rbp+var_50]
mov rdx, [rax+10h]
mov rax, [rbp+var_58]
mov rcx, [rax]
mov rax, [rbp+var_58]
mov r8, [rax+10h]
xor r9d, r9d
call ha_compare_text
mov [rbp+var_68], eax
cmp [rbp+var_68], 0
jz short loc_A44BD
xor eax, eax
mov [rbp+var_74], eax
jmp short loc_A44F1
loc_A44BD:
mov rax, [rbp+var_50]
movsd xmm0, qword ptr [rax+8]
mov rax, [rbp+var_58]
subsd xmm0, qword ptr [rax+8]
movaps xmm1, cs:xmmword_15A390
pand xmm0, xmm1
movsd xmm1, cs:qword_159F50
ucomisd xmm0, xmm1
setnbe al
and al, 1
movzx eax, al
mov [rbp+var_74], eax
loc_A44F1:
mov eax, [rbp+var_74]
mov [rbp+var_6C], eax
cmp [rbp+var_68], 0
jl short loc_A4503
cmp [rbp+var_6C], 0
jz short loc_A4540
loc_A4503:
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_50]
mov r8, [rbp+var_30]
call _ft_make_key
mov [rbp+var_64], eax
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov ecx, [rbp+var_64]
call _mi_ck_delete
mov [rbp+var_34], eax
cmp eax, 0
jz short loc_A453E
jmp loc_A45FF
loc_A453E:
jmp short $+2
loc_A4540:
cmp [rbp+var_68], 0
jg short loc_A454C
cmp [rbp+var_6C], 0
jz short loc_A4586
loc_A454C:
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_58]
mov r8, [rbp+var_30]
call _ft_make_key
mov [rbp+var_64], eax
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov ecx, [rbp+var_64]
call _mi_ck_write
mov [rbp+var_34], eax
cmp eax, 0
jz short loc_A4584
jmp short loc_A45FF
loc_A4584:
jmp short $+2
loc_A4586:
cmp [rbp+var_68], 0
jg short loc_A4598
mov rax, [rbp+var_50]
add rax, 18h
mov [rbp+var_50], rax
loc_A4598:
cmp [rbp+var_68], 0
jl short loc_A45AA
mov rax, [rbp+var_58]
add rax, 18h
mov [rbp+var_58], rax
loc_A45AA:
jmp loc_A445A
loc_A45AF:
mov rax, [rbp+var_50]
cmp qword ptr [rax], 0
jz short loc_A45D6
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_50]
mov r8, [rbp+var_30]
call _mi_ft_erase
mov [rbp+var_34], eax
jmp short loc_A45FD
loc_A45D6:
mov rax, [rbp+var_58]
cmp qword ptr [rax], 0
jz short loc_A45FB
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_58]
mov r8, [rbp+var_30]
call _mi_ft_store
mov [rbp+var_34], eax
loc_A45FB:
jmp short $+2
loc_A45FD:
jmp short $+2
loc_A45FF:
mov rdi, [rbp+var_8]
add rdi, 90h
mov esi, 2
call free_root
mov eax, [rbp+var_34]
mov [rbp+var_78], eax
mov eax, [rbp+var_78]
add rsp, 80h
pop rbp
retn
| long long mi_ft_update(_QWORD *a1, unsigned int a2, long long a3, long long a4, long long a5, long long a6)
{
__m128i v6; // xmm0
BOOL v8; // [rsp+Ch] [rbp-74h]
bool v9; // [rsp+13h] [rbp-6Dh]
int v10; // [rsp+18h] [rbp-68h]
unsigned int key; // [rsp+1Ch] [rbp-64h]
unsigned int v12; // [rsp+1Ch] [rbp-64h]
long long v13; // [rsp+20h] [rbp-60h]
long long v14; // [rsp+28h] [rbp-58h]
_QWORD *v15; // [rsp+30h] [rbp-50h]
unsigned int v16; // [rsp+4Ch] [rbp-34h]
v16 = -1;
v13 = **(_QWORD **)(112LL * a2 + *(_QWORD *)(*a1 + 536LL) + 40);
v15 = (_QWORD *)mi_ft_parserecord(a1, a2, a4, (long long)(a1 + 18));
if ( v15 )
{
v14 = mi_ft_parserecord(a1, a2, a5, (long long)(a1 + 18));
if ( v14 )
{
v16 = 0;
while ( 1 )
{
v9 = 0;
if ( *v15 )
v9 = *(_QWORD *)v14 != 0LL;
if ( !v9 )
break;
v10 = ha_compare_text(v13, *v15, v15[2], *(_QWORD *)v14, *(_QWORD *)(v14 + 16), 0LL);
if ( v10 )
{
v8 = 0;
}
else
{
v6 = (__m128i)(unsigned long long)v15[1];
*(double *)v6.m128i_i64 = *(double *)v6.m128i_i64 - *(double *)(v14 + 8);
v8 = *(double *)_mm_and_si128(v6, (__m128i)xmmword_15A390).m128i_i64 > 0.00001;
}
if ( v10 < 0 || v8 )
{
key = ft_make_key(a1, a2, a3, v15, a6);
v16 = mi_ck_delete(a1, a2, a3, key);
if ( v16 )
goto LABEL_26;
}
if ( v10 > 0 || v8 )
{
v12 = ft_make_key(a1, a2, a3, v14, a6);
v16 = mi_ck_write(a1, a2, a3, v12);
if ( v16 )
goto LABEL_26;
}
if ( v10 <= 0 )
v15 += 3;
if ( v10 >= 0 )
v14 += 24LL;
}
if ( *v15 )
{
v16 = mi_ft_erase(a1, a2, a3, v15, a6);
}
else if ( *(_QWORD *)v14 )
{
v16 = mi_ft_store(a1, a2, a3, v14, a6);
}
}
}
LABEL_26:
free_root(a1 + 18, 2LL);
return v16;
}
| _mi_ft_update:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV dword ptr [RBP + -0x34],0xffffffff
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0xc]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x90
CALL 0x001a41f0
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x50],RAX
CMP RAX,0x0
JZ 0x001a444e
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x90
CALL 0x001a41f0
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x58],RAX
CMP RAX,0x0
JNZ 0x001a4453
LAB_001a444e:
JMP 0x001a45ff
LAB_001a4453:
MOV dword ptr [RBP + -0x34],0x0
LAB_001a445a:
MOV RCX,qword ptr [RBP + -0x50]
XOR EAX,EAX
CMP qword ptr [RCX],0x0
MOV byte ptr [RBP + -0x6d],AL
JZ 0x001a4477
MOV RAX,qword ptr [RBP + -0x58]
CMP qword ptr [RAX],0x0
SETNZ AL
MOV byte ptr [RBP + -0x6d],AL
LAB_001a4477:
MOV AL,byte ptr [RBP + -0x6d]
TEST AL,0x1
JNZ 0x001a4483
JMP 0x001a45af
LAB_001a4483:
MOV RDI,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x58]
MOV R8,qword ptr [RAX + 0x10]
XOR R9D,R9D
CALL 0x001f1830
MOV dword ptr [RBP + -0x68],EAX
CMP dword ptr [RBP + -0x68],0x0
JZ 0x001a44bd
XOR EAX,EAX
MOV dword ptr [RBP + -0x74],EAX
JMP 0x001a44f1
LAB_001a44bd:
MOV RAX,qword ptr [RBP + -0x50]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x58]
SUBSD XMM0,qword ptr [RAX + 0x8]
MOVAPS XMM1,xmmword ptr [0x0025a390]
PAND XMM0,XMM1
MOVSD XMM1,qword ptr [0x00259f50]
UCOMISD XMM0,XMM1
SETA AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x74],EAX
LAB_001a44f1:
MOV EAX,dword ptr [RBP + -0x74]
MOV dword ptr [RBP + -0x6c],EAX
CMP dword ptr [RBP + -0x68],0x0
JL 0x001a4503
CMP dword ptr [RBP + -0x6c],0x0
JZ 0x001a4540
LAB_001a4503:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x50]
MOV R8,qword ptr [RBP + -0x30]
CALL 0x001a4630
MOV dword ptr [RBP + -0x64],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x64]
CALL 0x001a5270
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JZ 0x001a453e
JMP 0x001a45ff
LAB_001a453e:
JMP 0x001a4540
LAB_001a4540:
CMP dword ptr [RBP + -0x68],0x0
JG 0x001a454c
CMP dword ptr [RBP + -0x6c],0x0
JZ 0x001a4586
LAB_001a454c:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x58]
MOV R8,qword ptr [RBP + -0x30]
CALL 0x001a4630
MOV dword ptr [RBP + -0x64],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x64]
CALL 0x001c6ff0
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JZ 0x001a4584
JMP 0x001a45ff
LAB_001a4584:
JMP 0x001a4586
LAB_001a4586:
CMP dword ptr [RBP + -0x68],0x0
JG 0x001a4598
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x18
MOV qword ptr [RBP + -0x50],RAX
LAB_001a4598:
CMP dword ptr [RBP + -0x68],0x0
JL 0x001a45aa
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x18
MOV qword ptr [RBP + -0x58],RAX
LAB_001a45aa:
JMP 0x001a445a
LAB_001a45af:
MOV RAX,qword ptr [RBP + -0x50]
CMP qword ptr [RAX],0x0
JZ 0x001a45d6
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x50]
MOV R8,qword ptr [RBP + -0x30]
CALL 0x001a4780
MOV dword ptr [RBP + -0x34],EAX
JMP 0x001a45fd
LAB_001a45d6:
MOV RAX,qword ptr [RBP + -0x58]
CMP qword ptr [RAX],0x0
JZ 0x001a45fb
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x58]
MOV R8,qword ptr [RBP + -0x30]
CALL 0x001a4810
MOV dword ptr [RBP + -0x34],EAX
LAB_001a45fb:
JMP 0x001a45fd
LAB_001a45fd:
JMP 0x001a45ff
LAB_001a45ff:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x90
MOV ESI,0x2
CALL 0x001eed90
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x78],EAX
MOV EAX,dword ptr [RBP + -0x78]
ADD RSP,0x80
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int _mi_ft_update(long *param_1,uint param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6)
{
int8 uVar1;
int iVar2;
int4 uVar3;
bool bVar4;
long *local_60;
long *local_58;
int local_3c;
local_3c = -1;
uVar1 = **(int8 **)(*(long *)(*param_1 + 0x218) + (ulong)param_2 * 0x70 + 0x28);
local_58 = (long *)_mi_ft_parserecord(param_1,param_2,param_4,param_1 + 0x12);
if ((local_58 != (long *)0x0) &&
(local_60 = (long *)_mi_ft_parserecord(param_1,param_2,param_5,param_1 + 0x12),
local_60 != (long *)0x0)) {
local_3c = 0;
while( true ) {
bVar4 = false;
if (*local_58 != 0) {
bVar4 = *local_60 != 0;
}
if (!bVar4) break;
iVar2 = ha_compare_text(uVar1,*local_58,local_58[2],*local_60,local_60[2],0);
if (iVar2 == 0) {
bVar4 = DAT_00259f50 <
(double)((ulong)((double)local_58[1] - (double)local_60[1]) & _DAT_0025a390);
}
else {
bVar4 = false;
}
if ((iVar2 < 0) || (bVar4)) {
uVar3 = _ft_make_key(param_1,param_2,param_3,local_58,param_6);
local_3c = _mi_ck_delete(param_1,param_2,param_3,uVar3);
if (local_3c != 0) goto LAB_001a45ff;
}
if ((0 < iVar2) || (bVar4)) {
uVar3 = _ft_make_key(param_1,param_2,param_3,local_60,param_6);
local_3c = _mi_ck_write(param_1,param_2,param_3,uVar3);
if (local_3c != 0) goto LAB_001a45ff;
}
if (iVar2 < 1) {
local_58 = local_58 + 3;
}
if (-1 < iVar2) {
local_60 = local_60 + 3;
}
}
if (*local_58 == 0) {
if (*local_60 != 0) {
local_3c = _mi_ft_store(param_1,param_2,param_3,local_60,param_6);
}
}
else {
local_3c = _mi_ft_erase(param_1,param_2,param_3,local_58,param_6);
}
}
LAB_001a45ff:
free_root(param_1 + 0x12,2);
return local_3c;
}
| |
50,693 | ps_fetch_int8 | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | static
void ps_fetch_int8(MYSQL_BIND *r_param, const MYSQL_FIELD * const field,
unsigned char **row)
{
switch(r_param->buffer_type) {
case MYSQL_TYPE_TINY:
ps_fetch_from_1_to_8_bytes(r_param, field, row, 1);
break;
default:
{
uchar val= **row;
longlong lval= field->flags & UNSIGNED_FLAG ? (longlong) val : (longlong)(signed char)val;
convert_from_long(r_param, field, lval, field->flags & UNSIGNED_FLAG);
(*row) += 1;
}
break;
}
} | O0 | c | ps_fetch_int8:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
subl $0x1, %eax
jne 0x3338a
jmp 0x33372
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x32190
jmp 0x333ec
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x333af
movzbl -0x19(%rbp), %eax
movq %rax, -0x30(%rbp)
jmp 0x333b8
movsbq -0x19(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
andl $0x20, %eax
movsbl %al, %ecx
callq 0x33ea0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ps_fetch_int8:
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 eax, [rax+60h]
sub eax, 1
jnz short loc_3338A
jmp short $+2
loc_33372:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov ecx, 1
call ps_fetch_from_1_to_8_bytes
jmp short loc_333EC
loc_3338A:
mov rax, [rbp+var_18]
mov rax, [rax]
mov al, [rax]
mov [rbp+var_19], al
mov rax, [rbp+var_10]
mov eax, [rax+64h]
and eax, 20h
cmp eax, 0
jz short loc_333AF
movzx eax, [rbp+var_19]
mov [rbp+var_30], rax
jmp short loc_333B8
loc_333AF:
movsx rax, [rbp+var_19]
mov [rbp+var_30], rax
loc_333B8:
mov rax, [rbp+var_30]
mov [rbp+var_28], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_28]
mov rax, [rbp+var_10]
mov eax, [rax+64h]
and eax, 20h
movsx ecx, al
call convert_from_long
mov rax, [rbp+var_18]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
loc_333EC:
add rsp, 30h
pop rbp
retn
| unsigned __int8 ** ps_fetch_int8(long long a1, long long a2, unsigned __int8 **a3)
{
unsigned __int8 **result; // rax
long long v4; // [rsp+0h] [rbp-30h]
unsigned __int8 v5; // [rsp+17h] [rbp-19h]
if ( *(_DWORD *)(a1 + 96) == 1 )
return ps_fetch_from_1_to_8_bytes(a1, a2, a3, 1u);
v5 = **a3;
if ( (*(_DWORD *)(a2 + 100) & 0x20) != 0 )
v4 = v5;
else
v4 = (char)v5;
convert_from_long(a1, a2, v4, *(_BYTE *)(a2 + 100) & 0x20);
result = a3;
++*a3;
return result;
}
| ps_fetch_int8:
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 EAX,dword ptr [RAX + 0x60]
SUB EAX,0x1
JNZ 0x0013338a
JMP 0x00133372
LAB_00133372:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,0x1
CALL 0x00132190
JMP 0x001333ec
LAB_0013338a:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x64]
AND EAX,0x20
CMP EAX,0x0
JZ 0x001333af
MOVZX EAX,byte ptr [RBP + -0x19]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001333b8
LAB_001333af:
MOVSX RAX,byte ptr [RBP + -0x19]
MOV qword ptr [RBP + -0x30],RAX
LAB_001333b8:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x64]
AND EAX,0x20
MOVSX ECX,AL
CALL 0x00133ea0
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
LAB_001333ec:
ADD RSP,0x30
POP RBP
RET
|
void ps_fetch_int8(long param_1,long param_2,long *param_3)
{
int8 local_38;
if (*(int *)(param_1 + 0x60) == 1) {
ps_fetch_from_1_to_8_bytes(param_1,param_2,param_3,1);
}
else {
if ((*(uint *)(param_2 + 100) & 0x20) == 0) {
local_38 = (ulong)(char)*(byte *)*param_3;
}
else {
local_38 = (ulong)*(byte *)*param_3;
}
convert_from_long(param_1,param_2,local_38,(byte)*(int4 *)(param_2 + 100) & 0x20);
*param_3 = *param_3 + 1;
}
return;
}
| |
50,694 | nglog::internal::CheckOpMessageBuilder::CheckOpMessageBuilder(char const*) | ng-log[P]ng-log/src/logging.cc | CheckOpMessageBuilder::CheckOpMessageBuilder(const char* exprtext)
: stream_(new ostringstream) {
*stream_ << exprtext << " (";
} | O3 | cpp | nglog::internal::CheckOpMessageBuilder::CheckOpMessageBuilder(char const*):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x178, %edi # imm = 0x178
callq 0x8eb0
movq %rax, %rbx
movq %rax, %rdi
callq 0x7760
movq %rbx, (%r15)
testq %r14, %r14
je 0xeeec
movq %r14, %rdi
callq 0x71f0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7600
jmp 0xef05
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x7970
leaq 0x14bd8(%rip), %rsi # 0x23ae4
movl $0x2, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7600
movq %rax, %r14
movl $0x178, %esi # imm = 0x178
movq %rbx, %rdi
callq 0x8efc
movq %r14, %rdi
callq 0x79b0
| _ZN5nglog8internal21CheckOpMessageBuilderC2EPKc:
push r15; Alternative name is 'nglog::internal::CheckOpMessageBuilder::CheckOpMessageBuilder(char const*)'
push r14
push rbx
mov r14, rsi
mov r15, rdi
mov edi, 178h; unsigned __int64
call _Znwm; operator new(ulong)
mov rbx, rax
mov rdi, rax
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov [r15], rbx
test r14, r14
jz short loc_EEEC
mov rdi, r14
call _strlen
mov rdi, rbx
mov rsi, r14
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_EF05
loc_EEEC:
mov rax, [rbx]
mov rax, [rax-18h]
mov rdi, rbx
add rdi, rax
mov esi, [rbx+rax+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_EF05:
lea rsi, asc_23AE4; " ("
mov edx, 2
mov rdi, rbx
pop rbx
pop r14
pop r15
jmp __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r14, rax
mov esi, 178h; unsigned __int64
mov rdi, rbx; void *
call _ZdlPvm; operator delete(void *,ulong)
mov rdi, r14
call __Unwind_Resume
| long long nglog::internal::CheckOpMessageBuilder::CheckOpMessageBuilder(
nglog::internal::CheckOpMessageBuilder *this,
const char *a2)
{
_QWORD *v2; // rbx
long long v3; // rax
v2 = (_QWORD *)operator new(376LL);
std::ostringstream::basic_ostringstream(v2);
*(_QWORD *)this = v2;
if ( a2 )
{
v3 = strlen(a2);
std::__ostream_insert<char,std::char_traits<char>>(v2, a2, v3);
}
else
{
std::ios::clear((char *)v2 + *(_QWORD *)(*v2 - 24LL), *(_DWORD *)((char *)v2 + *(_QWORD *)(*v2 - 24LL) + 32) | 1u);
}
return std::__ostream_insert<char,std::char_traits<char>>(v2, " (", 2LL);
}
| CheckOpMessageBuilder:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV R15,RDI
MOV EDI,0x178
CALL 0x00108eb0
MOV RBX,RAX
LAB_0010eec4:
MOV RDI,RAX
CALL 0x00107760
LAB_0010eecc:
MOV qword ptr [R15],RBX
TEST R14,R14
JZ 0x0010eeec
MOV RDI,R14
CALL 0x001071f0
MOV RDI,RBX
MOV RSI,R14
MOV RDX,RAX
CALL 0x00107600
JMP 0x0010ef05
LAB_0010eeec:
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + -0x18]
MOV RDI,RBX
ADD RDI,RAX
MOV ESI,dword ptr [RBX + RAX*0x1 + 0x20]
OR ESI,0x1
CALL 0x00107970
LAB_0010ef05:
LEA RSI,[0x123ae4]
MOV EDX,0x2
MOV RDI,RBX
POP RBX
POP R14
POP R15
JMP 0x00107600
|
/* nglog::internal::CheckOpMessageBuilder::CheckOpMessageBuilder(char const*) */
void __thiscall
nglog::internal::CheckOpMessageBuilder::CheckOpMessageBuilder
(CheckOpMessageBuilder *this,char *param_1)
{
ostringstream *this_00;
size_t sVar1;
this_00 = (ostringstream *)operator_new(0x178);
/* try { // try from 0010eec4 to 0010eecb has its CatchHandler @ 0010ef1e */
std::__cxx11::ostringstream::ostringstream(this_00);
*(ostringstream **)this = this_00;
if (param_1 == (char *)0x0) {
std::ios::clear(this_00 + *(long *)(*(long *)this_00 + -0x18),
*(uint *)(this_00 + *(long *)(*(long *)this_00 + -0x18) + 0x20) | 1);
}
else {
sVar1 = strlen(param_1);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)this_00,param_1,sVar1);
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)this_00," (",2);
return;
}
| |
50,695 | analyze_environment_chain | tsotchke[P]eshkol/src/backend/codegen/debug.c | static char* analyze_environment_chain(BindingSystem* binding_system, uint64_t lambda_id) {
assert(binding_system != NULL);
assert(lambda_id != 0);
// Allocate a buffer for the analysis results
char* buffer = malloc(4096);
if (!buffer) {
return NULL;
}
buffer[0] = '\0';
// Get the lambda's scope ID
uint64_t scope_id = binding_system_get_lambda_scope(binding_system, lambda_id);
if (scope_id == 0) {
snprintf(buffer, 4096, "Error: Lambda %llu not found in binding system\n", (unsigned long long)lambda_id);
return buffer;
}
// Get the captured bindings
uint64_t* binding_ids = NULL;
size_t capture_count = 0;
if (!binding_system_get_lambda_captures(binding_system, lambda_id, &binding_ids, &capture_count)) {
snprintf(buffer, 4096, "Error: Failed to get captures for lambda %llu\n", (unsigned long long)lambda_id);
return buffer;
}
// Format the environment chain
int offset = 0;
offset += snprintf(buffer + offset, 4096 - offset,
"Environment Chain for Lambda %llu (Scope %llu):\n"
"---------------------------------------------\n"
"Captured bindings: %zu\n\n",
(unsigned long long)lambda_id, (unsigned long long)scope_id, capture_count);
// Print each captured binding
for (size_t i = 0; i < capture_count; i++) {
uint64_t binding_id = binding_ids[i];
StringId name = binding_system_get_binding_name(binding_system, binding_id);
uint64_t binding_scope = binding_system_get_binding_scope(binding_system, binding_id);
int env_index = binding_system_get_binding_env_index(binding_system, binding_id);
// Calculate the depth of the binding in the environment chain
uint64_t depth = 0;
uint64_t current_scope = scope_id;
while (current_scope != binding_scope && current_scope != 0) {
depth++;
current_scope = binding_system_get_parent_scope(binding_system, current_scope);
}
offset += snprintf(buffer + offset, 4096 - offset,
" Binding %llu: %s (Scope %llu, Depth %llu, Index %d)\n",
(unsigned long long)binding_id, name,
(unsigned long long)binding_scope,
(unsigned long long)depth, env_index);
}
return buffer;
} | O2 | c | analyze_environment_chain:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r12
movq %rdi, %r14
movl $0x1000, %edi # imm = 0x1000
callq 0x2240
movq %rax, %rbx
testq %rax, %rax
je 0xe11c
movb $0x0, (%rbx)
movq %r14, %rdi
callq 0x7366
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xe0e4
leaq 0x30(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x10(%rsp), %rcx
andq $0x0, (%rcx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x13b76
testb %al, %al
movq %rbx, (%rsp)
je 0xe0ff
movq 0x10(%rsp), %r9
leaq 0xdef4(%rip), %rdx # 0x1bf0d
movl $0x1000, %esi # imm = 0x1000
movq %rbx, %rdi
movq %r12, %rcx
movq 0x8(%rsp), %r8
xorl %eax, %eax
callq 0x2160
movl %eax, %ebp
xorl %ecx, %ecx
cmpq 0x10(%rsp), %rcx
jae 0xe118
movq 0x30(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq (%rax,%rcx,8), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x77b4
movq %rax, 0x20(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x77fd
movq %rax, %r15
movq %r14, %rdi
movq %r13, %rsi
callq 0x13b26
movq %rax, 0x18(%rsp)
xorl %ebx, %ebx
movq 0x8(%rsp), %rax
cmpq %r15, %rax
je 0xe09c
testq %rax, %rax
je 0xe09c
incq %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x747e
jmp 0xe082
movslq %ebp, %r12
movq (%rsp), %rax
leaq (%rax,%r12), %rdi
movl $0x1000, %eax # imm = 0x1000
subl %r12d, %eax
movslq %eax, %rsi
leaq 0xdecb(%rip), %rdx # 0x1bf84
movq %r13, %rcx
movq 0x20(%rsp), %r8
movq %r15, %r9
xorl %eax, %eax
pushq 0x18(%rsp)
pushq %rbx
callq 0x2160
popq %rcx
popq %rdx
movl %eax, %ebp
addl %r12d, %ebp
movq 0x28(%rsp), %rcx
incq %rcx
jmp 0xe034
leaq 0xddc3(%rip), %rdx # 0x1beae
movl $0x1000, %esi # imm = 0x1000
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x2160
jmp 0xe11c
leaq 0xddd8(%rip), %rdx # 0x1bede
movl $0x1000, %esi # imm = 0x1000
movq %rbx, %rdi
movq %r12, %rcx
xorl %eax, %eax
callq 0x2160
movq (%rsp), %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| analyze_environment_chain:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r12, rsi
mov r14, rdi
mov edi, 1000h
call _malloc
mov rbx, rax
test rax, rax
jz loc_E11C
mov byte ptr [rbx], 0
mov rdi, r14
call binding_system_enter_lambda_scope
mov [rsp+68h+var_60], rax
test rax, rax
jz loc_E0E4
lea rdx, [rsp+68h+var_38]
and qword ptr [rdx], 0
lea rcx, [rsp+68h+var_58]
and qword ptr [rcx], 0
mov rdi, r14
mov rsi, r12
call binding_system_get_lambda_captures
test al, al
mov [rsp+68h+var_68], rbx
jz loc_E0FF
mov r9, [rsp+68h+var_58]
lea rdx, aEnvironmentCha; "Environment Chain for Lambda %llu (Scop"...
mov esi, 1000h
mov rdi, rbx
mov rcx, r12
mov r8, [rsp+68h+var_60]
xor eax, eax
call _snprintf
mov ebp, eax
xor ecx, ecx
loc_E034:
cmp rcx, [rsp+68h+var_58]
jnb loc_E118
mov rax, [rsp+68h+var_38]
mov [rsp+68h+var_40], rcx
mov r13, [rax+rcx*8]
mov rdi, r14
mov rsi, r13
call binding_system_get_binding_name
mov [rsp+68h+var_48], rax
mov rdi, r14
mov rsi, r13
call binding_system_get_binding_scope
mov r15, rax
mov rdi, r14
mov rsi, r13
call binding_system_get_binding_env_index
mov [rsp+68h+var_50], rax
xor ebx, ebx
mov rax, [rsp+68h+var_60]
loc_E082:
cmp rax, r15
jz short loc_E09C
test rax, rax
jz short loc_E09C
inc rbx
mov rdi, r14
mov rsi, rax
call binding_system_get_parent_scope
jmp short loc_E082
loc_E09C:
movsxd r12, ebp
mov rax, [rsp+68h+var_68]
lea rdi, [rax+r12]
mov eax, 1000h
sub eax, r12d
movsxd rsi, eax
lea rdx, aBindingLluSSco; " Binding %llu: %s (Scope %llu, Depth %"...
mov rcx, r13
mov r8, [rsp+68h+var_48]
mov r9, r15
xor eax, eax
push [rsp+68h+var_50]
push rbx
call _snprintf
pop rcx
pop rdx
mov ebp, eax
add ebp, r12d
mov rcx, [rsp+68h+var_40]
inc rcx
jmp loc_E034
loc_E0E4:
lea rdx, aErrorLambdaLlu; "Error: Lambda %llu not found in binding"...
mov esi, 1000h
mov rdi, rbx
mov rcx, r12
xor eax, eax
call _snprintf
jmp short loc_E11C
loc_E0FF:
lea rdx, aErrorFailedToG_0; "Error: Failed to get captures for lambd"...
mov esi, 1000h
mov rdi, rbx
mov rcx, r12
xor eax, eax
call _snprintf
loc_E118:
mov rbx, [rsp+68h+var_68]
loc_E11C:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _BYTE * analyze_environment_chain(long long *a1, long long a2)
{
_BYTE *v2; // rax
_BYTE *v3; // rbx
int v4; // ebp
size_t i; // rcx
long long v6; // r13
long long binding_scope; // r15
long long v8; // rbx
long long j; // rax
_BYTE *v11; // [rsp+0h] [rbp-68h]
long long v12; // [rsp+8h] [rbp-60h]
size_t v13; // [rsp+10h] [rbp-58h] BYREF
long long binding_env_index; // [rsp+18h] [rbp-50h]
const char *binding_name; // [rsp+20h] [rbp-48h]
size_t v16; // [rsp+28h] [rbp-40h]
long long v17[7]; // [rsp+30h] [rbp-38h] BYREF
v2 = (_BYTE *)malloc(4096LL);
v3 = v2;
if ( v2 )
{
*v2 = 0;
v12 = binding_system_enter_lambda_scope(a1);
if ( v12 )
{
v17[0] = 0LL;
v13 = 0LL;
v11 = v3;
if ( (unsigned __int8)binding_system_get_lambda_captures(a1, a2, v17, &v13) )
{
v4 = snprintf(
v3,
4096LL,
"Environment Chain for Lambda %llu (Scope %llu):\n"
"---------------------------------------------\n"
"Captured bindings: %zu\n"
"\n",
a2,
v12,
v13);
for ( i = 0LL; i < v13; i = v16 + 1 )
{
v16 = i;
v6 = *(_QWORD *)(v17[0] + 8 * i);
binding_name = (const char *)binding_system_get_binding_name(a1, v6);
binding_scope = binding_system_get_binding_scope(a1, v6);
binding_env_index = binding_system_get_binding_env_index(a1, v6);
v8 = 0LL;
for ( j = v12; j != binding_scope && j; j = binding_system_get_parent_scope(a1, j) )
++v8;
v4 += snprintf(
&v11[v4],
4096 - v4,
" Binding %llu: %s (Scope %llu, Depth %llu, Index %d)\n",
v6,
binding_name,
binding_scope,
v8,
binding_env_index);
}
}
else
{
snprintf(v3, 4096LL, "Error: Failed to get captures for lambda %llu\n", a2);
}
return v11;
}
else
{
snprintf(v3, 4096LL, "Error: Lambda %llu not found in binding system\n", a2);
}
}
return v3;
}
| analyze_environment_chain:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R12,RSI
MOV R14,RDI
MOV EDI,0x1000
CALL 0x00102240
MOV RBX,RAX
TEST RAX,RAX
JZ 0x0010e11c
MOV byte ptr [RBX],0x0
MOV RDI,R14
CALL 0x00107366
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JZ 0x0010e0e4
LEA RDX,[RSP + 0x30]
AND qword ptr [RDX],0x0
LEA RCX,[RSP + 0x10]
AND qword ptr [RCX],0x0
MOV RDI,R14
MOV RSI,R12
CALL 0x00113b76
TEST AL,AL
MOV qword ptr [RSP],RBX
JZ 0x0010e0ff
MOV R9,qword ptr [RSP + 0x10]
LEA RDX,[0x11bf0d]
MOV ESI,0x1000
MOV RDI,RBX
MOV RCX,R12
MOV R8,qword ptr [RSP + 0x8]
XOR EAX,EAX
CALL 0x00102160
MOV EBP,EAX
XOR ECX,ECX
LAB_0010e034:
CMP RCX,qword ptr [RSP + 0x10]
JNC 0x0010e118
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x28],RCX
MOV R13,qword ptr [RAX + RCX*0x8]
MOV RDI,R14
MOV RSI,R13
CALL 0x001077b4
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,R14
MOV RSI,R13
CALL 0x001077fd
MOV R15,RAX
MOV RDI,R14
MOV RSI,R13
CALL 0x00113b26
MOV qword ptr [RSP + 0x18],RAX
XOR EBX,EBX
MOV RAX,qword ptr [RSP + 0x8]
LAB_0010e082:
CMP RAX,R15
JZ 0x0010e09c
TEST RAX,RAX
JZ 0x0010e09c
INC RBX
MOV RDI,R14
MOV RSI,RAX
CALL 0x0010747e
JMP 0x0010e082
LAB_0010e09c:
MOVSXD R12,EBP
MOV RAX,qword ptr [RSP]
LEA RDI,[RAX + R12*0x1]
MOV EAX,0x1000
SUB EAX,R12D
MOVSXD RSI,EAX
LEA RDX,[0x11bf84]
MOV RCX,R13
MOV R8,qword ptr [RSP + 0x20]
MOV R9,R15
XOR EAX,EAX
PUSH qword ptr [RSP + 0x18]
PUSH RBX
CALL 0x00102160
POP RCX
POP RDX
MOV EBP,EAX
ADD EBP,R12D
MOV RCX,qword ptr [RSP + 0x28]
INC RCX
JMP 0x0010e034
LAB_0010e0e4:
LEA RDX,[0x11beae]
MOV ESI,0x1000
MOV RDI,RBX
MOV RCX,R12
XOR EAX,EAX
CALL 0x00102160
JMP 0x0010e11c
LAB_0010e0ff:
LEA RDX,[0x11bede]
MOV ESI,0x1000
MOV RDI,RBX
MOV RCX,R12
XOR EAX,EAX
CALL 0x00102160
LAB_0010e118:
MOV RBX,qword ptr [RSP]
LAB_0010e11c:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x0010e03f) */
/* WARNING: Removing unreachable block (ram,0x0010e082) */
/* WARNING: Removing unreachable block (ram,0x0010e087) */
/* WARNING: Removing unreachable block (ram,0x0010e08c) */
/* WARNING: Removing unreachable block (ram,0x0010e09c) */
char * analyze_environment_chain(int8 param_1,int8 param_2)
{
char cVar1;
char *__s;
long lVar2;
__s = (char *)malloc(0x1000);
if (__s != (char *)0x0) {
*__s = '\0';
lVar2 = binding_system_enter_lambda_scope(param_1);
if (lVar2 == 0) {
snprintf(__s,0x1000,"Error: Lambda %llu not found in binding system\n",param_2);
}
else {
cVar1 = binding_system_get_lambda_captures(param_1,param_2);
if (cVar1 == '\0') {
snprintf(__s,0x1000,"Error: Failed to get captures for lambda %llu\n",param_2);
}
else {
snprintf(__s,0x1000,
"Environment Chain for Lambda %llu (Scope %llu):\n---------------------------------------------\nCaptured bindings: %zu\n\n"
,param_2,lVar2,0);
}
}
}
return __s;
}
| |
50,696 | my_wc_mb_cp932 | eloqsql/strings/ctype-cp932.c | static int
my_wc_mb_cp932(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if ((int) wc < 0x80) /* ASCII: [U+0000..U+007F] -> [00-7F] */
{
/*
This branch is for performance purposes on ASCII range,
to avoid using unicode_to_cp932[]: about 10% improvement.
*/
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= (uchar) wc;
return 1;
}
if (wc > 0xFFFF ||
!(code= unicode_to_cp932[wc])) /* Bad Unicode code point */
return MY_CS_ILUNI;
if (code <= 0xFF)
{
/* JIS-X-0201 HALF WIDTH KATAKANA [U+FF61..U+FF9F] -> [A1..DF] */
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= code;
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, code); /* JIS-X-0208(MS) */
return 2;
} | O0 | c | my_wc_mb_cp932:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jge 0x494bd
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x494a5
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x49554
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x49554
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
ja 0x494de
movq -0x18(%rbp), %rcx
leaq 0x806ee(%rip), %rax # 0xc9bc0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x494e7
movl $0x0, -0x4(%rbp)
jmp 0x49554
cmpl $0xff, -0x2c(%rbp)
jg 0x49517
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x49503
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x49554
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x49554
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x4952e
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x49554
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
popq %rbp
retq
nopl (%rax)
| my_wc_mb_cp932:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_18]
cmp eax, 80h
jge short loc_494BD
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_494A5
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_49554
loc_494A5:
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp loc_49554
loc_494BD:
cmp [rbp+var_18], 0FFFFh
ja short loc_494DE
mov rcx, [rbp+var_18]
lea rax, unicode_to_cp932
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_494E7
loc_494DE:
mov [rbp+var_4], 0
jmp short loc_49554
loc_494E7:
cmp [rbp+var_2C], 0FFh
jg short loc_49517
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_49503
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_49554
loc_49503:
mov eax, [rbp+var_2C]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp short loc_49554
loc_49517:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_4952E
mov [rbp+var_4], 0FFFFFF9Ah
jmp short loc_49554
loc_4952E:
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_49554:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_wc_mb_cp932(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
unsigned __int16 v5; // [rsp+0h] [rbp-2Ch]
if ( (int)a2 >= 128 )
{
if ( a2 <= 0xFFFF && (v5 = unicode_to_cp932[a2]) != 0 )
{
if ( unicode_to_cp932[a2] > 0xFFu )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = HIBYTE(v5);
a3[1] = v5;
return 2;
}
else
{
return (unsigned int)-102;
}
}
else if ( (unsigned long long)a3 < a4 )
{
*a3 = v5;
return 1;
}
else
{
return (unsigned int)-101;
}
}
else
{
return 0;
}
}
else if ( (unsigned long long)a3 < a4 )
{
*a3 = a2;
return 1;
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_cp932:
PUSH RBP
MOV RBP,RSP
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 + -0x18]
CMP EAX,0x80
JGE 0x001494bd
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x001494a5
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x00149554
LAB_001494a5:
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 0x00149554
LAB_001494bd:
CMP qword ptr [RBP + -0x18],0xffff
JA 0x001494de
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x1c9bc0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x001494e7
LAB_001494de:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00149554
LAB_001494e7:
CMP dword ptr [RBP + -0x2c],0xff
JG 0x00149517
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x00149503
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x00149554
LAB_00149503:
MOV EAX,dword ptr [RBP + -0x2c]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00149554
LAB_00149517:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0014952e
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x00149554
LAB_0014952e:
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_00149554:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_wc_mb_cp932(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
ushort uVar1;
int4 local_c;
if ((int)param_2 < 0x80) {
if (param_3 < param_4) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
local_c = 0xffffff9b;
}
}
else if ((param_2 < 0x10000) && (uVar1 = *(ushort *)(unicode_to_cp932 + param_2 * 2), uVar1 != 0))
{
if (uVar1 < 0x100) {
if (param_3 < param_4) {
*param_3 = (char)uVar1;
local_c = 1;
}
else {
local_c = 0xffffff9b;
}
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = (char)(uVar1 >> 8);
param_3[1] = (char)uVar1;
local_c = 2;
}
}
else {
local_c = 0;
}
return local_c;
}
| |
50,697 | fmt::v10::appender fmt::v10::detail::write<char, fmt::v10::appender>(fmt::v10::appender, char, fmt::v10::format_specs<char> const&, fmt::v10::detail::locale_ref) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format.h | FMT_CONSTEXPR auto write(OutputIt out, Char value,
const format_specs<Char>& specs, locale_ref loc = {})
-> OutputIt {
// char is formatted as unsigned char for consistency across platforms.
using unsigned_type =
conditional_t<std::is_same<Char, char>::value, unsigned char, unsigned>;
return check_char_specs(specs)
? write_char(out, value, specs)
: write(out, static_cast<unsigned_type>(value), specs, loc);
} | O3 | c | fmt::v10::appender fmt::v10::detail::write<char, fmt::v10::appender>(fmt::v10::appender, char, fmt::v10::format_specs<char> const&, fmt::v10::detail::locale_ref):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x31bc1
testb %al, %al
je 0x31b3d
cmpb $0x12, 0x8(%r14)
leaq 0x20(%rsp), %r8
sete (%r8)
movb %bpl, 0x1(%r8)
movl $0x1, %edx
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27c1b
jmp 0x31bae
movzwl 0x9(%r14), %eax
btl $0x8, %eax
jb 0x31b4e
movzbl %bpl, %r12d
jmp 0x31b89
movl $0x2, 0x30(%rsp)
movzbl %bpl, %r12d
movq %r12, 0x20(%rsp)
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x25e18
testb %al, %al
jne 0x31bb1
movzwl 0x9(%r14), %eax
shrl $0x4, %eax
andl $0x7, %eax
leaq 0x5151a(%rip), %rcx # 0x830b0
movl (%rcx,%rax,4), %esi
shlq $0x20, %rsi
orq %r12, %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x25f70
movq %rax, %rbx
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _ZN3fmt3v106detail5writeIcNS0_8appenderEEET0_S4_T_RKNS0_12format_specsIS5_EENS1_10locale_refE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov r15, rcx
mov r14, rdx
mov ebp, esi
mov rbx, rdi
mov rdi, rdx
call _ZN3fmt3v106detail16check_char_specsIcEEbRKNS0_12format_specsIT_EE; fmt::v10::detail::check_char_specs<char>(fmt::v10::format_specs<char> const&)
test al, al
jz short loc_31B3D
cmp byte ptr [r14+8], 12h
lea r8, [rsp+68h+var_48]
setz byte ptr [r8]
mov [r8+1], bpl
mov edx, 1
mov ecx, 1
mov rdi, rbx
mov rsi, r14
call _ZN3fmt3v106detail12write_paddedILNS0_5align4typeE1ENS0_8appenderEcRZNS1_10write_charIcS5_EET0_S7_T_RKNS0_12format_specsIS8_EEEUlS5_E_EES7_S7_RKNS9_IT1_EEmmOT2_; fmt::v10::detail::write_padded<(fmt::v10::align::type)1,fmt::v10::appender,char,fmt::v10::detail::write_char<char,fmt::v10::appender>(fmt::v10::appender,char,fmt::v10::format_specs<char> const&)::{lambda(fmt::v10::appender)#1} &>(fmt::v10::appender,fmt::v10::format_specs<char> const&,ulong,ulong,fmt::v10::detail::write_char<char,fmt::v10::appender>(fmt::v10::appender,char,fmt::v10::format_specs<char> const&)::{lambda(fmt::v10::appender)#1} &)
jmp short loc_31BAE
loc_31B3D:
movzx eax, word ptr [r14+9]
bt eax, 8
jb short loc_31B4E
movzx r12d, bpl
jmp short loc_31B89
loc_31B4E:
mov dword ptr [rsp+68h+var_38], 2
movzx r12d, bpl
mov qword ptr [rsp+68h+var_48], r12
movaps xmm0, [rsp+68h+var_48]
movaps xmm1, [rsp+68h+var_38]
movaps [rsp+68h+var_58], xmm1
movaps [rsp+68h+var_68], xmm0
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call _ZN3fmt3v106detail9write_locENS0_8appenderENS0_9loc_valueERKNS0_12format_specsIcEENS1_10locale_refE; fmt::v10::detail::write_loc(fmt::v10::appender,fmt::v10::loc_value,fmt::v10::format_specs<char> const&,fmt::v10::detail::locale_ref)
test al, al
jnz short loc_31BB1
movzx eax, word ptr [r14+9]
loc_31B89:
shr eax, 4
and eax, 7
lea rcx, dword_830B0
mov esi, [rcx+rax*4]
shl rsi, 20h
or rsi, r12
mov rdi, rbx
mov rdx, r14
mov rcx, r15
call _ZN3fmt3v106detail18write_int_noinlineIcNS0_8appenderEjEET0_S4_NS1_13write_int_argIT1_EERKNS0_12format_specsIT_EENS1_10locale_refE; fmt::v10::detail::write_int_noinline<char,fmt::v10::appender,uint>(fmt::v10::appender,fmt::v10::detail::write_int_arg<uint>,fmt::v10::format_specs<char> const&,fmt::v10::detail::locale_ref)
loc_31BAE:
mov rbx, rax
loc_31BB1:
mov rax, rbx
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long fmt::v10::detail::write<char,fmt::v10::appender>(
long long a1,
unsigned __int8 a2,
long long a3,
const std::locale *a4)
{
long long v6; // rbx
long long v7; // rcx
long long v8; // r8
long long v9; // r9
unsigned int v11; // eax
long long v12; // r12
_QWORD v14[2]; // [rsp+20h] [rbp-48h] BYREF
long long v15; // [rsp+30h] [rbp-38h]
long long v16; // [rsp+38h] [rbp-30h]
v6 = a1;
if ( (unsigned __int8)fmt::v10::detail::check_char_specs<char>(a3) )
{
LOBYTE(v14[0]) = *(_BYTE *)(a3 + 8) == 18;
BYTE1(v14[0]) = a2;
return fmt::v10::detail::write_padded<(fmt::v10::align::type)1,fmt::v10::appender,char,fmt::v10::appender fmt::v10::detail::write_char<char,fmt::v10::appender>(fmt::v10::appender,char,fmt::v10::format_specs<char> const&)::{lambda(fmt::v10::appender)#1} &>(
a1,
(unsigned int *)a3,
1LL,
1uLL,
v14);
}
v11 = *(unsigned __int16 *)(a3 + 9);
if ( (v11 & 0x100) == 0 )
{
v12 = a2;
return fmt::v10::detail::write_int_noinline<char,fmt::v10::appender,unsigned int>(
a1,
(const char *)(v12 | ((unsigned long long)dword_830B0[(v11 >> 4) & 7] << 32)),
(unsigned int *)a3);
}
LODWORD(v15) = 2;
v12 = a2;
v14[0] = a2;
if ( !(unsigned __int8)fmt::v10::detail::write_loc(a1, a3, a4, v7, v8, v9, a2, v14[1], v15, v16) )
{
v11 = *(unsigned __int16 *)(a3 + 9);
return fmt::v10::detail::write_int_noinline<char,fmt::v10::appender,unsigned int>(
a1,
(const char *)(v12 | ((unsigned long long)dword_830B0[(v11 >> 4) & 7] << 32)),
(unsigned int *)a3);
}
return v6;
}
| write<char,fmt::v10::appender>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R15,RCX
MOV R14,RDX
MOV EBP,ESI
MOV RBX,RDI
MOV RDI,RDX
CALL 0x00131bc1
TEST AL,AL
JZ 0x00131b3d
CMP byte ptr [R14 + 0x8],0x12
LEA R8,[RSP + 0x20]
SETZ byte ptr [R8]
MOV byte ptr [R8 + 0x1],BPL
MOV EDX,0x1
MOV ECX,0x1
MOV RDI,RBX
MOV RSI,R14
CALL 0x00127c1b
JMP 0x00131bae
LAB_00131b3d:
MOVZX EAX,word ptr [R14 + 0x9]
BT EAX,0x8
JC 0x00131b4e
MOVZX R12D,BPL
JMP 0x00131b89
LAB_00131b4e:
MOV dword ptr [RSP + 0x30],0x2
MOVZX R12D,BPL
MOV qword ptr [RSP + 0x20],R12
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOVAPS XMM1,xmmword ptr [RSP + 0x30]
MOVAPS xmmword ptr [RSP + 0x10],XMM1
MOVAPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x00125e18
TEST AL,AL
JNZ 0x00131bb1
MOVZX EAX,word ptr [R14 + 0x9]
LAB_00131b89:
SHR EAX,0x4
AND EAX,0x7
LEA RCX,[0x1830b0]
MOV ESI,dword ptr [RCX + RAX*0x4]
SHL RSI,0x20
OR RSI,R12
MOV RDI,RBX
MOV RDX,R14
MOV RCX,R15
CALL 0x00125f70
LAB_00131bae:
MOV RBX,RAX
LAB_00131bb1:
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* fmt::v10::appender fmt::v10::detail::write<char, fmt::v10::appender>(fmt::v10::appender, char,
fmt::v10::format_specs<char> const&, fmt::v10::detail::locale_ref) */
int8
fmt::v10::detail::write<char,fmt::v10::appender>
(int8 param_1,byte param_2,format_specs *param_3,int8 param_4)
{
ushort uVar1;
bool bVar2;
char cVar3;
int8 uVar4;
bVar2 = check_char_specs<char>(param_3);
if (bVar2) {
uVar4 = write_padded<(fmt::v10::align::type)1,fmt::v10::appender,char,fmt::v10::detail::write_char<char,fmt::v10::appender>(fmt::v10::appender,char,fmt::v10::format_specs<char>const&)::_lambda(fmt::v10::appender)_1_&>
(param_1,param_3,1,1);
}
else {
uVar1 = *(ushort *)(param_3 + 9);
if ((uVar1 >> 8 & 1) != 0) {
cVar3 = write_loc(param_1,param_3,param_4);
if (cVar3 != '\0') {
return param_1;
}
uVar1 = *(ushort *)(param_3 + 9);
}
uVar4 = write_int_noinline<char,fmt::v10::appender,unsigned_int>
(param_1,(ulong)*(uint *)(&DAT_001830b0 + (ulong)(uVar1 >> 4 & 7) * 4) << 0x20
| (ulong)param_2,param_3,param_4);
}
return uVar4;
}
| |
50,698 | js_string_delete_property | bluesky950520[P]quickjs/quickjs.c | static int js_string_delete_property(JSContext *ctx,
JSValue obj, JSAtom prop)
{
uint32_t idx;
if (__JS_AtomIsTaggedInt(prop)) {
idx = __JS_AtomToUInt32(prop);
if (idx < js_string_obj_get_length(ctx, obj)) {
return FALSE;
}
}
return TRUE;
} | O0 | c | js_string_delete_property:
subq $0x38, %rsp
movq %rsi, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %rdi, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0x34e00
cmpl $0x0, %eax
je 0x7d1d4
movl 0x14(%rsp), %edi
callq 0x34e20
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x5f6e0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0x7d1d2
movl $0x0, 0x34(%rsp)
jmp 0x7d1dc
jmp 0x7d1d4
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| js_string_delete_property:
sub rsp, 38h
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_10], rdx
mov [rsp+38h+var_20], rdi
mov [rsp+38h+var_24], ecx
mov edi, [rsp+38h+var_24]
call __JS_AtomIsTaggedInt
cmp eax, 0
jz short loc_7D1D4
mov edi, [rsp+38h+var_24]
call __JS_AtomToUInt32
mov [rsp+38h+var_28], eax
mov eax, [rsp+38h+var_28]
mov [rsp+38h+var_2C], eax
mov rdi, [rsp+38h+var_20]
mov rsi, [rsp+38h+var_18]
mov rdx, [rsp+38h+var_10]
call js_string_obj_get_length
mov ecx, eax
mov eax, [rsp+38h+var_2C]
cmp eax, ecx
jnb short loc_7D1D2
mov [rsp+38h+var_4], 0
jmp short loc_7D1DC
loc_7D1D2:
jmp short $+2
loc_7D1D4:
mov [rsp+38h+var_4], 1
loc_7D1DC:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| _BOOL8 js_string_delete_property(long long a1, long long a2, long long a3, int a4)
{
unsigned int v5; // [rsp+Ch] [rbp-2Ch]
BOOL v7; // [rsp+34h] [rbp-4h]
v7 = 1;
if ( _JS_AtomIsTaggedInt(a4) )
{
v5 = _JS_AtomToUInt32(a4);
if ( v5 < (unsigned int)js_string_obj_get_length(a1, a2) )
return 0;
}
return v7;
}
| js_string_delete_property:
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x28],RDX
MOV qword ptr [RSP + 0x18],RDI
MOV dword ptr [RSP + 0x14],ECX
MOV EDI,dword ptr [RSP + 0x14]
CALL 0x00134e00
CMP EAX,0x0
JZ 0x0017d1d4
MOV EDI,dword ptr [RSP + 0x14]
CALL 0x00134e20
MOV dword ptr [RSP + 0x10],EAX
MOV EAX,dword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0xc],EAX
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x0015f6e0
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0xc]
CMP EAX,ECX
JNC 0x0017d1d2
MOV dword ptr [RSP + 0x34],0x0
JMP 0x0017d1dc
LAB_0017d1d2:
JMP 0x0017d1d4
LAB_0017d1d4:
MOV dword ptr [RSP + 0x34],0x1
LAB_0017d1dc:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int4
js_string_delete_property
(int8 param_1,int8 param_2,int8 param_3,int4 param_4)
{
int iVar1;
uint uVar2;
uint uVar3;
iVar1 = __JS_AtomIsTaggedInt(param_4);
if (iVar1 != 0) {
uVar2 = __JS_AtomToUInt32(param_4);
uVar3 = js_string_obj_get_length(param_1,param_2,param_3);
if (uVar2 < uVar3) {
return 0;
}
}
return 1;
}
| |
50,699 | js_string_delete_property | bluesky950520[P]quickjs/quickjs.c | static int js_string_delete_property(JSContext *ctx,
JSValue obj, JSAtom prop)
{
uint32_t idx;
if (__JS_AtomIsTaggedInt(prop)) {
idx = __JS_AtomToUInt32(prop);
if (idx < js_string_obj_get_length(ctx, obj)) {
return FALSE;
}
}
return TRUE;
} | O1 | c | js_string_delete_property:
testl %ecx, %ecx
jns 0x46aa6
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
xorl %eax, %eax
cmpl $-0x7, 0x38(%rsi)
movl $0x0, %edx
jne 0x46aa2
movq 0x30(%rsi), %rsi
movl $0x7fffffff, %edx # imm = 0x7FFFFFFF
andl 0x4(%rsi), %edx
cmpl %edx, %ecx
jb 0x46aab
movl $0x1, %eax
retq
| js_string_delete_property:
test ecx, ecx
jns short loc_46AA6
and ecx, 7FFFFFFFh
xor eax, eax
cmp dword ptr [rsi+38h], 0FFFFFFF9h
mov edx, 0
jnz short loc_46AA2
mov rsi, [rsi+30h]
mov edx, 7FFFFFFFh
and edx, [rsi+4]
loc_46AA2:
cmp ecx, edx
jb short locret_46AAB
loc_46AA6:
mov eax, 1
locret_46AAB:
retn
| long long js_string_delete_property(long long a1, long long a2, long long a3, int a4)
{
unsigned int v4; // ecx
long long result; // rax
unsigned int v6; // edx
if ( a4 >= 0 )
return 1LL;
v4 = a4 & 0x7FFFFFFF;
result = 0LL;
v6 = 0;
if ( *(_DWORD *)(a2 + 56) == -7 )
v6 = *(_DWORD *)(*(_QWORD *)(a2 + 48) + 4LL) & 0x7FFFFFFF;
if ( v4 >= v6 )
return 1LL;
return result;
}
| js_string_delete_property:
TEST ECX,ECX
JNS 0x00146aa6
AND ECX,0x7fffffff
XOR EAX,EAX
CMP dword ptr [RSI + 0x38],-0x7
MOV EDX,0x0
JNZ 0x00146aa2
MOV RSI,qword ptr [RSI + 0x30]
MOV EDX,0x7fffffff
AND EDX,dword ptr [RSI + 0x4]
LAB_00146aa2:
CMP ECX,EDX
JC 0x00146aab
LAB_00146aa6:
MOV EAX,0x1
LAB_00146aab:
RET
|
int8
js_string_delete_property(int8 param_1,long param_2,int8 param_3,uint param_4)
{
uint uVar1;
if ((int)param_4 < 0) {
uVar1 = 0;
if (*(int *)(param_2 + 0x38) == -7) {
uVar1 = *(uint *)(*(long *)(param_2 + 0x30) + 4) & 0x7fffffff;
}
if ((param_4 & 0x7fffffff) < uVar1) {
return 0;
}
}
return 1;
}
|
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.