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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
24,100 | fs_get_cache_directory[abi:cxx11]() | monkey531[P]llama/common/common.cpp | std::string fs_get_cache_directory() {
std::string cache_directory = "";
auto ensure_trailing_slash = [](std::string p) {
// Make sure to add trailing slash
if (p.back() != DIRECTORY_SEPARATOR) {
p += DIRECTORY_SEPARATOR;
}
return p;
};
if (getenv("LLAMA_CACHE")) {
cache_directory = std::getenv("LLAMA_CACHE");
} else {
#ifdef __linux__
if (std::getenv("XDG_CACHE_HOME")) {
cache_directory = std::getenv("XDG_CACHE_HOME");
} else {
cache_directory = std::getenv("HOME") + std::string("/.cache/");
}
#elif defined(__APPLE__)
cache_directory = std::getenv("HOME") + std::string("/Library/Caches/");
#elif defined(_WIN32)
cache_directory = std::getenv("LOCALAPPDATA");
#endif // __linux__
cache_directory = ensure_trailing_slash(cache_directory);
cache_directory += "llama.cpp";
}
return ensure_trailing_slash(cache_directory);
} | O3 | cpp | fs_get_cache_directory[abi:cxx11]():
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x87bd6(%rip), %rdx # 0xa8ea5
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x1ded4
leaq 0x87e12(%rip), %rdi # 0xa90f5
callq 0x187f0
testq %rax, %rax
je 0x21319
movq %rax, %r14
leaq 0x20(%rsp), %r15
movq 0x8(%r15), %r12
movq %rax, %rdi
callq 0x18300
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x18a40
jmp 0x21507
leaq 0x87de1(%rip), %rdi # 0xa9101
callq 0x187f0
testq %rax, %rax
je 0x21356
movq %rax, %r14
leaq 0x20(%rsp), %r15
movq 0x8(%r15), %r12
movq %rax, %rdi
callq 0x18300
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x18a40
jmp 0x21436
leaq 0x87dae(%rip), %rdi # 0xa910b
callq 0x187f0
movq %rax, %r14
leaq 0x90(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x87d98(%rip), %rsi # 0xa9110
leaq 0x87d99(%rip), %rdx # 0xa9118
leaq 0x80(%rsp), %rdi
callq 0x1ded4
movq %r14, %rdi
callq 0x18300
leaq 0x80(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
callq 0x18750
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x213d3
movq %rdx, 0x60(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x70(%rsp)
jmp 0x213db
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x60(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x18800
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x21419
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x186a0
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x21436
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x1dbce
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x21475
movq %rsp, %rdi
movl $0x2f, %esi
callq 0x18590
movq (%rsp), %rax
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
cmpq %r15, %rax
je 0x21495
movq %rax, 0x60(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x2149e
movups (%r15), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rsp), %rax
leaq 0x60(%rsp), %r14
movq %rax, 0x8(%r14)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x18800
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x214e0
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x186a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x214f6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x87c1c(%rip), %rsi # 0xa9119
leaq 0x20(%rsp), %rdi
callq 0x18ce0
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %rdi
callq 0x1dbce
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x2154c
leaq 0x40(%rsp), %rdi
movl $0x2f, %esi
callq 0x18590
movq 0x40(%rsp), %rax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
cmpq %r14, %rax
je 0x21566
movq %rax, (%rbx)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x2156d
movups (%r14), %xmm0
movups %xmm0, (%rcx)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r14, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movb $0x0, 0x50(%rsp)
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x215a0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186a0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x21604
movq 0x90(%rsp), %rsi
jmp 0x215f7
jmp 0x21601
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x21604
movq 0x10(%rsp), %rsi
jmp 0x215f7
jmp 0x21601
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x21604
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x21604
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x2161b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186a0
movq %rbx, %rdi
callq 0x18bc0
| _Z22fs_get_cache_directoryB5cxx11v:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A0h
mov rbx, rdi
lea r13, [rsp+0C8h+var_98]
mov [r13-10h], r13
lea rdx, aEndIndexOutOfB+19h; ""
lea rdi, [rsp+0C8h+var_A8]
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, aLlamaCache; "LLAMA_CACHE"
call _getenv
test rax, rax
jz short loc_21319
mov r14, rax
lea r15, [rsp+0C8h+var_A8]
mov r12, [r15+8]
mov rdi, rax
call _strlen
mov rdi, r15
xor esi, esi
mov rdx, r12
mov rcx, r14
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_21507
loc_21319:
lea rdi, aXdgCacheHome; "XDG_CACHE_HOME"
call _getenv
test rax, rax
jz short loc_21356
mov r14, rax
lea r15, [rsp+0C8h+var_A8]
mov r12, [r15+8]
mov rdi, rax
call _strlen
mov rdi, r15
xor esi, esi
mov rdx, r12
mov rcx, r14
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
jmp loc_21436
loc_21356:
lea rdi, aXdgCacheHome+0Ah; "HOME"
call _getenv
mov r14, rax
lea r15, [rsp+0C8h+var_38]
mov [r15-10h], r15
lea rsi, aCache; "/.cache/"
lea rdx, aCache+8; ""
lea rdi, [rsp+0C8h+var_48]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, r14
call _strlen
lea rdi, [rsp+0C8h+var_48]
xor esi, esi
xor edx, edx
mov rcx, r14
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
lea r12, [rsp+0C8h+var_58]
mov [r12-10h], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_213D3
mov [rsp+0C8h+var_68], rdx
mov rdx, [rcx]
mov [rsp+0C8h+var_58], rdx
jmp short loc_213DB
loc_213D3:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
loc_213DB:
mov rdx, [rax+8]
lea r14, [rsp+0C8h+var_68]
mov [r14+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rdi, [rsp+0C8h+var_A8]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r14]; void *
cmp rdi, r12
jz short loc_21419
mov rsi, [rsp+0C8h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_21419:
mov rdi, [rsp+0C8h+var_48]; void *
cmp rdi, r15
jz short loc_21436
mov rsi, [rsp+0C8h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_21436:
lea r15, [rsp+0C8h+var_B8]
mov [r15-10h], r15
mov rsi, [rsp+0C8h+var_A8]
mov rdx, [rsp+0C8h+var_A0]
add rdx, rsi
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rax, [rsp+0C8h+var_C8]
mov rcx, [rsp+0C8h+var_C0]
cmp byte ptr [rax+rcx-1], 2Fh ; '/'
jz short loc_21475
mov rdi, rsp
mov esi, 2Fh ; '/'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rax, [rsp+0C8h+var_C8]
loc_21475:
lea r12, [rsp+0C8h+var_58]
mov [r12-10h], r12
cmp rax, r15
jz short loc_21495
mov [rsp+0C8h+var_68], rax
mov rax, [rsp+0C8h+var_B8]
mov [rsp+0C8h+var_58], rax
jmp short loc_2149E
loc_21495:
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [r12], xmm0
loc_2149E:
mov rax, [rsp+0C8h+var_C0]
lea r14, [rsp+0C8h+var_68]
mov [r14+8], rax
mov [rsp+0C8h+var_C8], r15
mov [rsp+0C8h+var_C0], 0
mov byte ptr [rsp+0C8h+var_B8], 0
lea rdi, [rsp+0C8h+var_A8]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r14]; void *
cmp rdi, r12
jz short loc_214E0
mov rsi, [rsp+0C8h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_214E0:
mov rdi, [rsp+0C8h+var_C8]; void *
cmp rdi, r15
jz short loc_214F6
mov rsi, [rsp+0C8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_214F6:
lea rsi, aLlamaCpp; "llama.cpp"
lea rdi, [rsp+0C8h+var_A8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
loc_21507:
lea r14, [rsp+0C8h+var_78]
mov [r14-10h], r14
mov rsi, [rsp+0C8h+var_A8]
mov rdx, [rsp+0C8h+var_A0]
add rdx, rsi
lea rdi, [rsp+0C8h+var_88]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rax, [rsp+0C8h+var_88]
mov rcx, [rsp+0C8h+var_80]
cmp byte ptr [rax+rcx-1], 2Fh ; '/'
jz short loc_2154C
lea rdi, [rsp+0C8h+var_88]
mov esi, 2Fh ; '/'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rax, [rsp+0C8h+var_88]
loc_2154C:
lea rcx, [rbx+10h]
mov [rbx], rcx
cmp rax, r14
jz short loc_21566
mov [rbx], rax
mov rax, [rsp+0C8h+var_78]
mov [rbx+10h], rax
jmp short loc_2156D
loc_21566:
movups xmm0, xmmword ptr [r14]
movups xmmword ptr [rcx], xmm0
loc_2156D:
mov rax, [rsp+0C8h+var_80]
mov [rbx+8], rax
mov [rsp+0C8h+var_88], r14
mov [rsp+0C8h+var_80], 0
mov byte ptr [rsp+0C8h+var_78], 0
mov rdi, [rsp+0C8h+var_A8]; void *
cmp rdi, r13
jz short loc_215A0
mov rsi, [rsp+0C8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_215A0:
mov rax, rbx
add rsp, 0A0h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_78]
cmp rdi, r15
jz short loc_21604
mov rsi, [rsp+arg_88]
jmp short loc_215F7
jmp short loc_21601
mov rbx, rax
mov rdi, [rsp+0]
cmp rdi, r15
jz short loc_21604
mov rsi, [rsp+arg_8]
jmp short loc_215F7
jmp short loc_21601
mov rbx, rax
mov rdi, [rsp+arg_38]; void *
cmp rdi, r14
jz short loc_21604
mov rsi, [rsp+arg_48]
loc_215F7:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_21604
loc_21601:
mov rbx, rax
loc_21604:
mov rdi, [rsp+arg_18]; void *
cmp rdi, r13
jz short loc_2161B
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2161B:
mov rdi, rbx
call __Unwind_Resume
| long long fs_get_cache_directory[abi:cxx11](long long a1)
{
long long v1; // rax
long long v2; // r14
long long v3; // r12
long long v4; // rax
long long v5; // rax
long long v6; // r14
long long v7; // r12
long long v8; // rax
long long v9; // r14
long long v10; // rax
long long v11; // rax
__int128 *v12; // rcx
__int128 *v13; // rax
__int128 *v14; // rax
void *v16; // [rsp+0h] [rbp-C8h] BYREF
long long v17; // [rsp+8h] [rbp-C0h]
__int128 v18; // [rsp+10h] [rbp-B8h] BYREF
void *v19; // [rsp+20h] [rbp-A8h] BYREF
long long v20; // [rsp+28h] [rbp-A0h]
_QWORD v21[2]; // [rsp+30h] [rbp-98h] BYREF
__int128 *v22; // [rsp+40h] [rbp-88h] BYREF
long long v23; // [rsp+48h] [rbp-80h]
__int128 v24; // [rsp+50h] [rbp-78h] BYREF
__int128 *v25; // [rsp+60h] [rbp-68h]
long long v26; // [rsp+68h] [rbp-60h]
__int128 v27; // [rsp+70h] [rbp-58h] BYREF
void *v28[2]; // [rsp+80h] [rbp-48h] BYREF
_QWORD v29[7]; // [rsp+90h] [rbp-38h] BYREF
v19 = v21;
std::string::_M_construct<char const*>((long long)&v19, "", (long long)"");
v1 = getenv("LLAMA_CACHE");
if ( v1 )
{
v2 = v1;
v3 = v20;
v4 = strlen(v1);
std::string::_M_replace(&v19, 0LL, v3, v2, v4);
}
else
{
v5 = getenv("XDG_CACHE_HOME");
if ( v5 )
{
v6 = v5;
v7 = v20;
v8 = strlen(v5);
std::string::_M_replace(&v19, 0LL, v7, v6, v8);
}
else
{
v9 = getenv("HOME");
v28[0] = v29;
std::string::_M_construct<char const*>((long long)v28, "/.cache/", (long long)"");
v10 = strlen(v9);
v11 = std::string::replace(v28, 0LL, 0LL, v9, v10);
v25 = &v27;
v12 = (__int128 *)(v11 + 16);
if ( *(_QWORD *)v11 == v11 + 16 )
{
v27 = *v12;
}
else
{
v25 = *(__int128 **)v11;
*(_QWORD *)&v27 = *(_QWORD *)v12;
}
v26 = *(_QWORD *)(v11 + 8);
*(_QWORD *)v11 = v12;
*(_QWORD *)(v11 + 8) = 0LL;
*(_BYTE *)(v11 + 16) = 0;
std::string::operator=(&v19);
if ( v25 != &v27 )
operator delete(v25, v27 + 1);
if ( v28[0] != v29 )
operator delete(v28[0], v29[0] + 1LL);
}
v16 = &v18;
std::string::_M_construct<char *>((long long)&v16, v19, (long long)v19 + v20);
v13 = (__int128 *)v16;
if ( *((char *)v16 + v17 - 1) != 47 )
{
std::string::push_back(&v16, 47LL);
v13 = (__int128 *)v16;
}
v25 = &v27;
if ( v13 == &v18 )
{
v27 = v18;
}
else
{
v25 = v13;
*(_QWORD *)&v27 = v18;
}
v26 = v17;
v16 = &v18;
v17 = 0LL;
LOBYTE(v18) = 0;
std::string::operator=(&v19);
if ( v25 != &v27 )
operator delete(v25, v27 + 1);
if ( v16 != &v18 )
operator delete(v16, v18 + 1);
std::string::append(&v19, "llama.cpp");
}
v22 = &v24;
std::string::_M_construct<char *>((long long)&v22, v19, (long long)v19 + v20);
v14 = v22;
if ( *((_BYTE *)v22 + v23 - 1) != 47 )
{
std::string::push_back(&v22, 47LL);
v14 = v22;
}
*(_QWORD *)a1 = a1 + 16;
if ( v14 == &v24 )
{
*(_OWORD *)(a1 + 16) = v24;
}
else
{
*(_QWORD *)a1 = v14;
*(_QWORD *)(a1 + 16) = v24;
}
*(_QWORD *)(a1 + 8) = v23;
v22 = &v24;
v23 = 0LL;
LOBYTE(v24) = 0;
if ( v19 != v21 )
operator delete(v19, v21[0] + 1LL);
return a1;
}
| fs_get_cache_directory[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa0
MOV RBX,RDI
LEA R13,[RSP + 0x30]
MOV qword ptr [R13 + -0x10],R13
LEA RDX,[0x1a8ea5]
LEA RDI,[RSP + 0x20]
MOV RSI,RDX
CALL 0x0011ded4
LEA RDI,[0x1a90f5]
CALL 0x001187f0
TEST RAX,RAX
JZ 0x00121319
MOV R14,RAX
LEA R15,[RSP + 0x20]
MOV R12,qword ptr [R15 + 0x8]
MOV RDI,RAX
CALL 0x00118300
LAB_00121301:
MOV RDI,R15
XOR ESI,ESI
MOV RDX,R12
MOV RCX,R14
MOV R8,RAX
CALL 0x00118a40
JMP 0x00121507
LAB_00121319:
LEA RDI,[0x1a9101]
CALL 0x001187f0
TEST RAX,RAX
JZ 0x00121356
MOV R14,RAX
LEA R15,[RSP + 0x20]
MOV R12,qword ptr [R15 + 0x8]
MOV RDI,RAX
CALL 0x00118300
MOV RDI,R15
XOR ESI,ESI
MOV RDX,R12
MOV RCX,R14
MOV R8,RAX
CALL 0x00118a40
JMP 0x00121436
LAB_00121356:
LEA RDI,[0x1a910b]
CALL 0x001187f0
MOV R14,RAX
LEA R15,[RSP + 0x90]
MOV qword ptr [R15 + -0x10],R15
LAB_00121371:
LEA RSI,[0x1a9110]
LEA RDX,[0x1a9118]
LEA RDI,[RSP + 0x80]
CALL 0x0011ded4
MOV RDI,R14
CALL 0x00118300
LAB_00121394:
LEA RDI,[RSP + 0x80]
XOR ESI,ESI
XOR EDX,EDX
MOV RCX,R14
MOV R8,RAX
CALL 0x00118750
LEA R12,[RSP + 0x70]
MOV qword ptr [R12 + -0x10],R12
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001213d3
MOV qword ptr [RSP + 0x60],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x70],RDX
JMP 0x001213db
LAB_001213d3:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
LAB_001213db:
MOV RDX,qword ptr [RAX + 0x8]
LEA R14,[RSP + 0x60]
MOV qword ptr [R14 + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LEA RDI,[RSP + 0x20]
MOV RSI,R14
CALL 0x00118800
MOV RDI,qword ptr [R14]
CMP RDI,R12
JZ 0x00121419
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x001186a0
LAB_00121419:
MOV RDI,qword ptr [RSP + 0x80]
CMP RDI,R15
JZ 0x00121436
MOV RSI,qword ptr [RSP + 0x90]
INC RSI
CALL 0x001186a0
LAB_00121436:
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
ADD RDX,RSI
LAB_0012144c:
MOV RDI,RSP
CALL 0x0011dbce
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
CMP byte ptr [RAX + RCX*0x1 + -0x1],0x2f
JZ 0x00121475
LAB_00121464:
MOV RDI,RSP
MOV ESI,0x2f
CALL 0x00118590
MOV RAX,qword ptr [RSP]
LAB_00121475:
LEA R12,[RSP + 0x70]
MOV qword ptr [R12 + -0x10],R12
CMP RAX,R15
JZ 0x00121495
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x70],RAX
JMP 0x0012149e
LAB_00121495:
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [R12],XMM0
LAB_0012149e:
MOV RAX,qword ptr [RSP + 0x8]
LEA R14,[RSP + 0x60]
MOV qword ptr [R14 + 0x8],RAX
MOV qword ptr [RSP],R15
MOV qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x10],0x0
LEA RDI,[RSP + 0x20]
MOV RSI,R14
CALL 0x00118800
MOV RDI,qword ptr [R14]
CMP RDI,R12
JZ 0x001214e0
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x001186a0
LAB_001214e0:
MOV RDI,qword ptr [RSP]
CMP RDI,R15
JZ 0x001214f6
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001186a0
LAB_001214f6:
LEA RSI,[0x1a9119]
LEA RDI,[RSP + 0x20]
CALL 0x00118ce0
LAB_00121507:
LEA R14,[RSP + 0x50]
MOV qword ptr [R14 + -0x10],R14
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
ADD RDX,RSI
LEA RDI,[RSP + 0x40]
CALL 0x0011dbce
MOV RAX,qword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x48]
CMP byte ptr [RAX + RCX*0x1 + -0x1],0x2f
JZ 0x0012154c
LAB_00121538:
LEA RDI,[RSP + 0x40]
MOV ESI,0x2f
CALL 0x00118590
LAB_00121547:
MOV RAX,qword ptr [RSP + 0x40]
LAB_0012154c:
LEA RCX,[RBX + 0x10]
MOV qword ptr [RBX],RCX
CMP RAX,R14
JZ 0x00121566
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RBX + 0x10],RAX
JMP 0x0012156d
LAB_00121566:
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RCX],XMM0
LAB_0012156d:
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RBX + 0x8],RAX
MOV qword ptr [RSP + 0x40],R14
MOV qword ptr [RSP + 0x48],0x0
MOV byte ptr [RSP + 0x50],0x0
MOV RDI,qword ptr [RSP + 0x20]
CMP RDI,R13
JZ 0x001215a0
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x001186a0
LAB_001215a0:
MOV RAX,RBX
ADD RSP,0xa0
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* fs_get_cache_directory[abi:cxx11]() */
void fs_get_cache_directory_abi_cxx11_(void)
{
char *pcVar1;
char *pcVar2;
long *plVar3;
long *plVar4;
long *in_RDI;
long *local_c8;
long local_c0;
int1 local_b8;
int7 uStack_b7;
long lStack_b0;
long *local_a8;
char *local_a0;
long local_98 [2];
int1 *local_88;
long local_80;
int1 local_78;
int7 uStack_77;
long lStack_70;
long *local_68;
long local_60;
long local_58;
long lStack_50;
long *local_48 [2];
long local_38 [2];
local_a8 = local_98;
std::__cxx11::string::_M_construct<char_const*>(&local_a8);
pcVar1 = getenv("LLAMA_CACHE");
pcVar2 = local_a0;
if (pcVar1 == (char *)0x0) {
pcVar1 = getenv("XDG_CACHE_HOME");
pcVar2 = local_a0;
if (pcVar1 == (char *)0x0) {
pcVar2 = getenv("HOME");
/* try { // try from 00121371 to 0012138b has its CatchHandler @ 001215ce */
local_48[0] = local_38;
std::__cxx11::string::_M_construct<char_const*>(local_48,"/.cache/","");
strlen(pcVar2);
/* try { // try from 00121394 to 001213aa has its CatchHandler @ 001215b4 */
plVar3 = (long *)std::__cxx11::string::replace((ulong)local_48,0,(char *)0x0,(ulong)pcVar2);
plVar4 = plVar3 + 2;
if ((long *)*plVar3 == plVar4) {
local_58 = *plVar4;
lStack_50 = plVar3[3];
local_68 = &local_58;
}
else {
local_58 = *plVar4;
local_68 = (long *)*plVar3;
}
local_60 = plVar3[1];
*plVar3 = (long)plVar4;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
std::__cxx11::string::operator=((string *)&local_a8,(string *)&local_68);
if (local_68 != &local_58) {
operator_delete(local_68,local_58 + 1);
}
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
}
else {
strlen(pcVar1);
std::__cxx11::string::_M_replace((ulong)&local_a8,0,pcVar2,(ulong)pcVar1);
}
local_c8 = (long *)&local_b8;
/* try { // try from 0012144c to 00121453 has its CatchHandler @ 001215e3 */
std::__cxx11::string::_M_construct<char*>(&local_c8,local_a8,local_a0 + (long)local_a8);
if (*(char *)((long)local_c8 + local_c0 + -1) != '/') {
/* try { // try from 00121464 to 00121470 has its CatchHandler @ 001215d0 */
std::__cxx11::string::push_back((char)&local_c8);
}
local_68 = local_c8;
if (local_c8 == (long *)&local_b8) {
lStack_50 = lStack_b0;
local_68 = &local_58;
}
local_58 = CONCAT71(uStack_b7,local_b8);
local_60 = local_c0;
local_c0 = 0;
local_b8 = 0;
local_c8 = (long *)&local_b8;
std::__cxx11::string::operator=((string *)&local_a8,(string *)&local_68);
if (local_68 != &local_58) {
operator_delete(local_68,local_58 + 1);
}
if (local_c8 != (long *)&local_b8) {
operator_delete(local_c8,CONCAT71(uStack_b7,local_b8) + 1);
}
/* try { // try from 001214f6 to 00121526 has its CatchHandler @ 00121601 */
std::__cxx11::string::append((char *)&local_a8);
}
else {
strlen(pcVar1);
/* try { // try from 00121301 to 00121350 has its CatchHandler @ 00121601 */
std::__cxx11::string::_M_replace((ulong)&local_a8,0,pcVar2,(ulong)pcVar1);
}
local_88 = &local_78;
std::__cxx11::string::_M_construct<char*>(&local_88,local_a8,local_a0 + (long)local_a8);
if (local_88[local_80 + -1] != '/') {
/* try { // try from 00121538 to 00121546 has its CatchHandler @ 001215e5 */
std::__cxx11::string::push_back((char)&local_88);
}
*in_RDI = (long)(in_RDI + 2);
if (local_88 == &local_78) {
in_RDI[2] = CONCAT71(uStack_77,local_78);
in_RDI[3] = lStack_70;
}
else {
*in_RDI = (long)local_88;
in_RDI[2] = CONCAT71(uStack_77,local_78);
}
in_RDI[1] = local_80;
local_80 = 0;
local_78 = 0;
if (local_a8 != local_98) {
local_88 = &local_78;
operator_delete(local_a8,local_98[0] + 1);
}
return;
}
| |
24,101 | bytes_dup | corpus-core[P]colibri-stateless/src/util/bytes.c | bytes_t bytes_dup(bytes_t data) {
bytes_t result = {.data = safe_malloc(data.len), .len = data.len};
if (!result.data && data.len > 0) {
// This case should technically not be reached if safe_malloc exits on failure,
// but kept for conceptual completeness or if safe_malloc behaviour changes.
return NULL_BYTES; // Indicate failure if malloc fails
}
memcpy(result.data, data.data, data.len);
return result;
} | O0 | c | bytes_dup:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %edi
callq 0x9c400
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9d101
cmpl $0x0, -0x20(%rbp)
jbe 0x9d101
movl $0x0, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0x9d123
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x231c0
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
| bytes_dup:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_20], edi
mov [rbp+var_18], rsi
mov eax, [rbp+var_20]
mov dword ptr [rbp+var_30], eax
mov eax, [rbp+var_20]
mov edi, eax
call safe_malloc
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jnz short loc_9D101
cmp [rbp+var_20], 0
jbe short loc_9D101
mov dword ptr [rbp+var_10], 0
mov [rbp+var_8], 0
jmp short loc_9D123
loc_9D101:
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_18]
mov eax, [rbp+var_20]
mov edx, eax
call _memcpy
mov rax, [rbp+var_30]
mov [rbp+var_10], rax
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_9D123:
mov eax, dword ptr [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long bytes_dup(unsigned int a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-28h]
v3 = safe_malloc(a1);
if ( v3 || !a1 )
{
memcpy(v3, a2, a1);
return a1;
}
else
{
return 0;
}
}
| bytes_dup:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x20],EDI
MOV qword ptr [RBP + -0x18],RSI
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x20]
MOV EDI,EAX
CALL 0x0019c400
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x0019d101
CMP dword ptr [RBP + -0x20],0x0
JBE 0x0019d101
MOV dword ptr [RBP + -0x10],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0019d123
LAB_0019d101:
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x20]
MOV EDX,EAX
CALL 0x001231c0
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_0019d123:
MOV EAX,dword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
int1 [16] bytes_dup(uint param_1,void *param_2)
{
int1 auVar1 [16];
int8 local_10;
local_10 = (void *)safe_malloc(param_1);
if ((local_10 == (void *)0x0) && (param_1 != 0)) {
param_1 = 0;
local_10 = (void *)0x0;
}
else {
memcpy(local_10,param_2,(ulong)param_1);
}
auVar1._4_4_ = 0;
auVar1._0_4_ = param_1;
auVar1._8_8_ = local_10;
return auVar1;
}
| |
24,102 | clip_encode_float_image | monkey531[P]llama/examples/llava/clip.cpp | bool clip_encode_float_image (struct clip_ctx * ctx, int n_threads, float * img, int h, int w, float * vec) {
clip_image_f32 clip_img;
clip_img.buf.resize(h * w * 3);
for (int i = 0; i < h*w*3; i++)
{
clip_img.buf[i] = img[i];
}
clip_img.nx = w;
clip_img.ny = h;
clip_image_encode(ctx, n_threads, &clip_img, vec);
return true;
} | O1 | cpp | clip_encode_float_image:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, (%rsp)
movl %r8d, %r12d
movl %ecx, %r15d
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl %ecx, %eax
imull %r8d, %eax
leal (%rax,%rax,2), %ebx
movslq %ebx, %rsi
callq 0x2855c
testl %ebx, %ebx
jle 0x35b6b
movq 0x10(%rsp), %rax
movl %ebx, %ecx
xorl %edx, %edx
movss (%r13,%rdx,4), %xmm0
movss %xmm0, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x35b57
leaq 0x8(%rsp), %rdx
movl %r12d, (%rdx)
movl %r15d, 0x4(%rdx)
movq %r14, %rdi
movl %ebp, %esi
movq (%rsp), %rcx
callq 0x33d60
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x35b9c
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1dc40
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x35bc7
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1dc40
movq %rbx, %rdi
callq 0x1e650
| clip_encode_float_image:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_58], r9
mov r12d, r8d
mov r15d, ecx
mov r13, rdx
mov ebp, esi
mov r14, rdi
lea rdi, [rsp+58h+var_48]
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov eax, ecx
imul eax, r8d
lea ebx, [rax+rax*2]
movsxd rsi, ebx
call _ZNSt6vectorIfSaIfEE6resizeEm; std::vector<float>::resize(ulong)
test ebx, ebx
jle short loc_35B6B
mov rax, [rsp+58h+var_48]
mov ecx, ebx
xor edx, edx
loc_35B57:
movss xmm0, dword ptr [r13+rdx*4+0]
movss dword ptr [rax+rdx*4], xmm0
inc rdx
cmp rcx, rdx
jnz short loc_35B57
loc_35B6B:
lea rdx, [rsp+58h+var_50]
mov [rdx], r12d
mov [rdx+4], r15d
mov rdi, r14
mov esi, ebp
mov rcx, [rsp+58h+var_58]
call clip_image_encode
mov rdi, [rsp+58h+var_48]; void *
test rdi, rdi
jz short loc_35B9C
mov rsi, [rsp+58h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_35B9C:
mov al, 1
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_8]; void *
test rdi, rdi
jz short loc_35BC7
mov rsi, [rsp+arg_18]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_35BC7:
mov rdi, rbx
call __Unwind_Resume
| char clip_encode_float_image(long long a1, unsigned int a2, long long a3, int a4, int a5)
{
int v8; // ebx
long long v9; // rax
long long i; // rdx
_DWORD v12[2]; // [rsp+8h] [rbp-50h] BYREF
__int128 v13; // [rsp+10h] [rbp-48h] BYREF
long long v14; // [rsp+20h] [rbp-38h]
v13 = 0LL;
v14 = 0LL;
v8 = 3 * a5 * a4;
std::vector<float>::resize(&v13, v8);
if ( v8 > 0 )
{
v9 = v13;
for ( i = 0LL; i != v8; ++i )
*(_DWORD *)(v9 + 4 * i) = *(_DWORD *)(a3 + 4 * i);
}
v12[0] = a5;
v12[1] = a4;
clip_image_encode(a1, a2, (long long)v12);
if ( (_QWORD)v13 )
operator delete((void *)v13, v14 - v13);
return 1;
}
| clip_encode_float_image:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP],R9
MOV R12D,R8D
MOV R15D,ECX
MOV R13,RDX
MOV EBP,ESI
MOV R14,RDI
LEA RDI,[RSP + 0x10]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV EAX,ECX
IMUL EAX,R8D
LEA EBX,[RAX + RAX*0x2]
MOVSXD RSI,EBX
LAB_00135b45:
CALL 0x0012855c
TEST EBX,EBX
JLE 0x00135b6b
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,EBX
XOR EDX,EDX
LAB_00135b57:
MOVSS XMM0,dword ptr [R13 + RDX*0x4]
MOVSS dword ptr [RAX + RDX*0x4],XMM0
INC RDX
CMP RCX,RDX
JNZ 0x00135b57
LAB_00135b6b:
LEA RDX,[RSP + 0x8]
MOV dword ptr [RDX],R12D
MOV dword ptr [RDX + 0x4],R15D
MOV RDI,R14
MOV ESI,EBP
MOV RCX,qword ptr [RSP]
CALL 0x00133d60
LAB_00135b85:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x00135b9c
MOV RSI,qword ptr [RSP + 0x20]
SUB RSI,RDI
CALL 0x0011dc40
LAB_00135b9c:
MOV AL,0x1
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
clip_encode_float_image
(int8 param_1,int4 param_2,long param_3,int param_4,int param_5,
int8 param_6)
{
uint uVar1;
ulong uVar2;
int local_50;
int local_4c;
void *local_48;
int8 uStack_40;
long local_38;
local_48 = (void *)0x0;
uStack_40 = 0;
local_38 = 0;
uVar1 = param_4 * param_5 * 3;
/* try { // try from 00135b45 to 00135b84 has its CatchHandler @ 00135bad */
std::vector<float,std::allocator<float>>::resize
((vector<float,std::allocator<float>> *)&local_48,(long)(int)uVar1);
if (0 < (int)uVar1) {
uVar2 = 0;
do {
*(int4 *)((long)local_48 + uVar2 * 4) = *(int4 *)(param_3 + uVar2 * 4);
uVar2 = uVar2 + 1;
} while (uVar1 != uVar2);
}
local_50 = param_5;
local_4c = param_4;
clip_image_encode(param_1,param_2,&local_50,param_6);
if (local_48 != (void *)0x0) {
operator_delete(local_48,local_38 - (long)local_48);
}
return 1;
}
| |
24,103 | clip_encode_float_image | monkey531[P]llama/examples/llava/clip.cpp | bool clip_encode_float_image (struct clip_ctx * ctx, int n_threads, float * img, int h, int w, float * vec) {
clip_image_f32 clip_img;
clip_img.buf.resize(h * w * 3);
for (int i = 0; i < h*w*3; i++)
{
clip_img.buf[i] = img[i];
}
clip_img.nx = w;
clip_img.ny = h;
clip_image_encode(ctx, n_threads, &clip_img, vec);
return true;
} | O2 | cpp | clip_encode_float_image:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, %r13d
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, 0xc(%rsp)
movq %rdi, %r15
leaq 0x20(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movl %ecx, %eax
imull %r8d, %eax
leal (%rax,%rax,2), %ebp
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x2dbd6
movq 0x20(%rsp), %rax
xorl %ecx, %ecx
testl %ebp, %ebp
cmovlel %ecx, %ebp
cmpq %rcx, %rbp
je 0x391f8
movss (%r14,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
incq %rcx
jmp 0x391e3
leaq 0x18(%rsp), %rdx
movl %r13d, (%rdx)
movl %r12d, 0x4(%rdx)
movq %r15, %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rcx
callq 0x37c17
movq %rbx, %rdi
callq 0x2d9d2
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d9d2
movq %r14, %rdi
callq 0x27660
| clip_encode_float_image:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rsp+68h+var_58], r9
mov r13d, r8d
mov r12d, ecx
mov r14, rdx
mov [rsp+68h+var_5C], esi
mov r15, rdi
lea rbx, [rsp+68h+var_48]
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
and qword ptr [rbx+10h], 0
mov eax, ecx
imul eax, r8d
lea ebp, [rax+rax*2]
movsxd rsi, ebp
mov rdi, rbx
call _ZNSt6vectorIfSaIfEE6resizeEm; std::vector<float>::resize(ulong)
mov rax, [rsp+68h+var_48]
xor ecx, ecx
test ebp, ebp
cmovle ebp, ecx
loc_391E3:
cmp rbp, rcx
jz short loc_391F8
movss xmm0, dword ptr [r14+rcx*4]
movss dword ptr [rax+rcx*4], xmm0
inc rcx
jmp short loc_391E3
loc_391F8:
lea rdx, [rsp+68h+var_50]
mov [rdx], r13d
mov [rdx+4], r12d
mov rdi, r15
mov esi, [rsp+68h+var_5C]
mov rcx, [rsp+68h+var_58]
call clip_image_encode
mov rdi, rbx
call _ZNSt12_Vector_baseIfSaIfEED2Ev; std::_Vector_base<float>::~_Vector_base()
mov al, 1
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, rbx
call _ZNSt12_Vector_baseIfSaIfEED2Ev; std::_Vector_base<float>::~_Vector_base()
mov rdi, r14
call __Unwind_Resume
| char clip_encode_float_image(long long a1, unsigned int a2, long long a3, int a4, int a5)
{
long long v8; // rbp
long long v9; // rax
long long v10; // rcx
_DWORD v12[2]; // [rsp+18h] [rbp-50h] BYREF
__int128 v13; // [rsp+20h] [rbp-48h] BYREF
long long v14; // [rsp+30h] [rbp-38h]
v13 = 0LL;
v14 = 0LL;
v8 = (unsigned int)(3 * a5 * a4);
std::vector<float>::resize(&v13, (int)v8);
v9 = v13;
v10 = 0LL;
if ( (int)v8 <= 0 )
v8 = 0LL;
while ( v8 != v10 )
{
*(_DWORD *)(v9 + 4 * v10) = *(_DWORD *)(a3 + 4 * v10);
++v10;
}
v12[0] = a5;
v12[1] = a4;
clip_image_encode(a1, a2, (long long)v12);
std::_Vector_base<float>::~_Vector_base(&v13);
return 1;
}
| clip_encode_float_image:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x10],R9
MOV R13D,R8D
MOV R12D,ECX
MOV R14,RDX
MOV dword ptr [RSP + 0xc],ESI
MOV R15,RDI
LEA RBX,[RSP + 0x20]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
AND qword ptr [RBX + 0x10],0x0
MOV EAX,ECX
IMUL EAX,R8D
LEA EBP,[RAX + RAX*0x2]
MOVSXD RSI,EBP
LAB_001391cf:
MOV RDI,RBX
CALL 0x0012dbd6
MOV RAX,qword ptr [RSP + 0x20]
XOR ECX,ECX
TEST EBP,EBP
CMOVLE EBP,ECX
LAB_001391e3:
CMP RBP,RCX
JZ 0x001391f8
MOVSS XMM0,dword ptr [R14 + RCX*0x4]
MOVSS dword ptr [RAX + RCX*0x4],XMM0
INC RCX
JMP 0x001391e3
LAB_001391f8:
LEA RDX,[RSP + 0x18]
MOV dword ptr [RDX],R13D
MOV dword ptr [RDX + 0x4],R12D
MOV RDI,R15
MOV ESI,dword ptr [RSP + 0xc]
MOV RCX,qword ptr [RSP + 0x10]
CALL 0x00137c17
LAB_00139215:
MOV RDI,RBX
CALL 0x0012d9d2
MOV AL,0x1
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
clip_encode_float_image
(int8 param_1,int4 param_2,long param_3,int param_4,int param_5,
int8 param_6)
{
uint uVar1;
ulong uVar2;
ulong uVar3;
int local_50;
int local_4c;
long local_48 [3];
local_48[0] = 0;
local_48[1] = 0;
local_48[2] = 0;
uVar1 = param_4 * param_5 * 3;
/* try { // try from 001391cf to 00139214 has its CatchHandler @ 0013922e */
std::vector<float,std::allocator<float>>::resize
((vector<float,std::allocator<float>> *)local_48,(long)(int)uVar1);
uVar2 = 0;
uVar3 = (ulong)uVar1;
if ((int)uVar1 < 1) {
uVar3 = uVar2;
}
for (; uVar3 != uVar2; uVar2 = uVar2 + 1) {
*(int4 *)(local_48[0] + uVar2 * 4) = *(int4 *)(param_3 + uVar2 * 4);
}
local_50 = param_5;
local_4c = param_4;
clip_image_encode(param_1,param_2,&local_50,param_6);
std::_Vector_base<float,std::allocator<float>>::~_Vector_base
((_Vector_base<float,std::allocator<float>> *)local_48);
return 1;
}
| |
24,104 | start_transaction | eloqsql/client/mysqldump.c | static int start_transaction(MYSQL *mysql_con)
{
verbose_msg("-- Starting transaction...\n");
/*
We use BEGIN for old servers. --single-transaction --master-data will fail
on old servers, but that's ok as it was already silently broken (it didn't
do a consistent read, so better tell people frankly, with the error).
We want the first consistent read to be used for all tables to dump so we
need the REPEATABLE READ level (not anything lower, for example READ
COMMITTED would give one new consistent read per dumped table).
*/
if ((mysql_get_server_version(mysql_con) < 40100) && opt_master_data)
{
fprintf(stderr, "-- %s: the combination of --single-transaction and "
"--master-data requires a MariaDB server version of at least 4.1 "
"(current server's version is %s). %s\n",
ignore_errors ? "Warning" : "Error",
mysql_con->server_version ? mysql_con->server_version : "unknown",
ignore_errors ? "Continuing due to --force, backup may not be consistent across all tables!" : "Aborting.");
if (!ignore_errors)
exit(EX_MYSQLERR);
}
return (mysql_query_with_error_report(mysql_con, 0,
"SET SESSION TRANSACTION ISOLATION "
"LEVEL REPEATABLE READ") ||
mysql_query_with_error_report(mysql_con, 0,
"START TRANSACTION "
"/*!40100 WITH CONSISTENT SNAPSHOT */"));
} | O0 | c | start_transaction:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xa07eb(%rip), %rdi # 0xdb92e
movb $0x0, %al
callq 0x393f0
movq -0x8(%rbp), %rdi
callq 0x523b0
cmpq $0x9ca4, %rax # imm = 0x9CA4
jae 0x3b211
cmpl $0x0, 0x3c64c6(%rip) # 0x40162c
je 0x3b211
movq 0x209e6d(%rip), %rax # 0x244fe0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movsbl 0x3c64f3(%rip), %edx # 0x401674
leaq 0xa0863(%rip), %rax # 0xdb9eb
leaq 0xa0854(%rip), %rcx # 0xdb9e3
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2d0(%rax)
je 0x3b1b9
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3b1c6
leaq 0xa0831(%rip), %rax # 0xdb9f1
movq %rax, -0x20(%rbp)
jmp 0x3b1c6
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movsbl 0x3c649b(%rip), %esi # 0x401674
leaq 0xa0864(%rip), %r8 # 0xdba44
leaq 0xa0812(%rip), %rax # 0xdb9f9
cmpl $0x0, %esi
cmovneq %rax, %r8
leaq 0xa0755(%rip), %rsi # 0xdb94a
movb $0x0, %al
callq 0x381d0
cmpb $0x0, 0x3c6471(%rip) # 0x401674
jne 0x3b20f
movl $0x2, %edi
callq 0x38680
jmp 0x3b211
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xa082e(%rip), %rdx # 0xdba4e
callq 0x39350
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jne 0x3b24e
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xa0846(%rip), %rdx # 0xdba86
callq 0x39350
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| start_transaction:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
lea rdi, aStartingTransa; "-- Starting transaction...\n"
mov al, 0
call verbose_msg
mov rdi, [rbp+var_8]
call mysql_get_server_version
cmp rax, 9CA4h
jnb loc_3B211
cmp cs:opt_master_data, 0
jz loc_3B211
mov rax, cs:stderr_ptr
mov rax, [rax]
mov [rbp+var_18], rax
movsx edx, cs:ignore_errors
lea rax, aError; "Error"
lea rcx, aWarning; "Warning"
cmp edx, 0
cmovnz rax, rcx
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
cmp qword ptr [rax+2D0h], 0
jz short loc_3B1B9
mov rax, [rbp+var_8]
mov rax, [rax+2D0h]
mov [rbp+var_20], rax
jmp short loc_3B1C6
loc_3B1B9:
lea rax, aUnknown; "unknown"
mov [rbp+var_20], rax
jmp short $+2
loc_3B1C6:
mov rdx, [rbp+var_10]
mov rdi, [rbp+var_18]
mov rcx, [rbp+var_20]
movsx esi, cs:ignore_errors
lea r8, aAborting; "Aborting."
lea rax, aContinuingDueT; "Continuing due to --force, backup may n"...
cmp esi, 0
cmovnz r8, rax
lea rsi, aSTheCombinatio; "-- %s: the combination of --single-tran"...
mov al, 0
call _fprintf
cmp cs:ignore_errors, 0
jnz short loc_3B20F
mov edi, 2
call _exit
loc_3B20F:
jmp short $+2
loc_3B211:
mov rdi, [rbp+var_8]
xor eax, eax
mov esi, eax
lea rdx, aSetSessionTran; "SET SESSION TRANSACTION ISOLATION LEVEL"...
call mysql_query_with_error_report
mov ecx, eax
mov al, 1
cmp ecx, 0
mov [rbp+var_21], al
jnz short loc_3B24E
mov rdi, [rbp+var_8]
xor eax, eax
mov esi, eax
lea rdx, aStartTransacti; "START TRANSACTION /*!40100 WITH CONSIST"...
call mysql_query_with_error_report
cmp eax, 0
setnz al
mov [rbp+var_21], al
loc_3B24E:
mov al, [rbp+var_21]
and al, 1
movzx eax, al
add rsp, 30h
pop rbp
retn
| _BOOL8 start_transaction(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
const char *v14; // rax
const char *v15; // r8
char v17; // [rsp+0h] [rbp-30h]
bool v18; // [rsp+Fh] [rbp-21h]
const char *v19; // [rsp+10h] [rbp-20h]
verbose_msg((long long)"-- Starting transaction...\n", a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v17);
if ( (unsigned long long)mysql_get_server_version(a1, *(double *)a7.m128_u64) < 0x9CA4 && opt_master_data )
{
v14 = "Error";
if ( ignore_errors )
v14 = "Warning";
if ( *(_QWORD *)(a1 + 720) )
v19 = *(const char **)(a1 + 720);
else
v19 = "unknown";
v15 = "Aborting.";
if ( ignore_errors )
v15 = "Continuing due to --force, backup may not be consistent across all tables!";
fprintf(
stderr,
"-- %s: the combination of --single-transaction and --master-data requires a MariaDB server version of at least 4.1"
" (current server's version is %s). %s\n",
v14,
v19,
v15);
if ( !ignore_errors )
exit(2LL);
}
v18 = 1;
if ( !(unsigned int)mysql_query_with_error_report(
a1,
0LL,
(long long)"SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ") )
return (unsigned int)mysql_query_with_error_report(
a1,
0LL,
(long long)"START TRANSACTION /*!40100 WITH CONSISTENT SNAPSHOT */") != 0;
return v18;
}
| start_transaction:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
LEA RDI,[0x1db92e]
MOV AL,0x0
CALL 0x001393f0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001523b0
CMP RAX,0x9ca4
JNC 0x0013b211
CMP dword ptr [0x0050162c],0x0
JZ 0x0013b211
MOV RAX,qword ptr [0x00344fe0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOVSX EDX,byte ptr [0x00501674]
LEA RAX,[0x1db9eb]
LEA RCX,[0x1db9e3]
CMP EDX,0x0
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x2d0],0x0
JZ 0x0013b1b9
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2d0]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0013b1c6
LAB_0013b1b9:
LEA RAX,[0x1db9f1]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0013b1c6
LAB_0013b1c6:
MOV RDX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOVSX ESI,byte ptr [0x00501674]
LEA R8,[0x1dba44]
LEA RAX,[0x1db9f9]
CMP ESI,0x0
CMOVNZ R8,RAX
LEA RSI,[0x1db94a]
MOV AL,0x0
CALL 0x001381d0
CMP byte ptr [0x00501674],0x0
JNZ 0x0013b20f
MOV EDI,0x2
CALL 0x00138680
LAB_0013b20f:
JMP 0x0013b211
LAB_0013b211:
MOV RDI,qword ptr [RBP + -0x8]
XOR EAX,EAX
MOV ESI,EAX
LEA RDX,[0x1dba4e]
CALL 0x00139350
MOV ECX,EAX
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x21],AL
JNZ 0x0013b24e
MOV RDI,qword ptr [RBP + -0x8]
XOR EAX,EAX
MOV ESI,EAX
LEA RDX,[0x1dba86]
CALL 0x00139350
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x21],AL
LAB_0013b24e:
MOV AL,byte ptr [RBP + -0x21]
AND AL,0x1
MOVZX EAX,AL
ADD RSP,0x30
POP RBP
RET
|
bool start_transaction(long param_1)
{
int iVar1;
ulong uVar2;
char *pcVar3;
char *pcVar4;
bool local_29;
char *local_28;
verbose_msg("-- Starting transaction...\n");
uVar2 = mysql_get_server_version(param_1);
if ((uVar2 < 0x9ca4) && (opt_master_data != 0)) {
pcVar3 = "Error";
if (ignore_errors != '\0') {
pcVar3 = "Warning";
}
if (*(long *)(param_1 + 0x2d0) == 0) {
local_28 = "unknown";
}
else {
local_28 = *(char **)(param_1 + 0x2d0);
}
pcVar4 = "Aborting.";
if (ignore_errors != '\0') {
pcVar4 = "Continuing due to --force, backup may not be consistent across all tables!";
}
fprintf(*(FILE **)PTR_stderr_00344fe0,
"-- %s: the combination of --single-transaction and --master-data requires a MariaDB server version of at least 4.1 (current server\'s version is %s). %s\n"
,pcVar3,local_28,pcVar4);
if (ignore_errors == '\0') {
/* WARNING: Subroutine does not return */
exit(2);
}
}
iVar1 = mysql_query_with_error_report
(param_1,0,"SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ");
local_29 = true;
if (iVar1 == 0) {
iVar1 = mysql_query_with_error_report
(param_1,0,"START TRANSACTION /*!40100 WITH CONSISTENT SNAPSHOT */");
local_29 = iVar1 != 0;
}
return local_29;
}
| |
24,105 | mi_calc_total_blob_length | eloqsql/storage/myisam/mi_dynrec.c | ulong _mi_calc_total_blob_length(MI_INFO *info, const uchar *record)
{
ulong length;
MI_BLOB *blob,*end;
for (length=0, blob= info->blobs, end=blob+info->s->base.blobs ;
blob != end;
blob++)
{
blob->length=_mi_calc_blob_length(blob->pack_length,record + blob->offset);
length+=blob->length;
}
return length;
} | O0 | c | mi_calc_total_blob_length:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x188(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xa830a
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
addq (%rax), %rsi
callq 0xaaaa0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0xa82c0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _mi_calc_total_blob_length:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], 0
mov rax, [rbp+var_8]
mov rax, [rax+48h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
mov rcx, [rcx]
mov ecx, [rcx+188h]
imul rcx, 18h
add rax, rcx
mov [rbp+var_28], rax
loc_A82C0:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jz short loc_A830A
mov rax, [rbp+var_20]
mov edi, [rax+8]
mov rsi, [rbp+var_10]
mov rax, [rbp+var_20]
add rsi, [rax]
call _mi_calc_blob_length
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax+10h], rcx
mov rax, [rbp+var_20]
mov rax, [rax+10h]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
add rax, 18h
mov [rbp+var_20], rax
jmp short loc_A82C0
loc_A830A:
mov rax, [rbp+var_18]
add rsp, 30h
pop rbp
retn
| long long mi_calc_total_blob_length(_QWORD *a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-28h]
long long v4; // [rsp+10h] [rbp-20h]
long long v5; // [rsp+18h] [rbp-18h]
v5 = 0LL;
v4 = a1[9];
v3 = 24LL * *(unsigned int *)(*a1 + 392LL) + v4;
while ( v4 != v3 )
{
*(_QWORD *)(v4 + 16) = mi_calc_blob_length(*(unsigned int *)(v4 + 8), *(_QWORD *)v4 + a2);
v5 += *(_QWORD *)(v4 + 16);
v4 += 24LL;
}
return v5;
}
| _mi_calc_total_blob_length:
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],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x188]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
LAB_001a82c0:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JZ 0x001a830a
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX + 0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
ADD RSI,qword ptr [RAX]
CALL 0x001aaaa0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001a82c0
LAB_001a830a:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x30
POP RBP
RET
|
long _mi_calc_total_blob_length(long *param_1,long param_2)
{
long *plVar1;
long lVar2;
long *local_28;
long local_20;
local_20 = 0;
local_28 = (long *)param_1[9];
plVar1 = local_28 + (ulong)*(uint *)(*param_1 + 0x188) * 3;
for (; local_28 != plVar1; local_28 = local_28 + 3) {
lVar2 = _mi_calc_blob_length((int)local_28[1],param_2 + *local_28);
local_28[2] = lVar2;
local_20 = local_28[2] + local_20;
}
return local_20;
}
| |
24,106 | mi_calc_total_blob_length | eloqsql/storage/myisam/mi_dynrec.c | ulong _mi_calc_total_blob_length(MI_INFO *info, const uchar *record)
{
ulong length;
MI_BLOB *blob,*end;
for (length=0, blob= info->blobs, end=blob+info->s->base.blobs ;
blob != end;
blob++)
{
blob->length=_mi_calc_blob_length(blob->pack_length,record + blob->offset);
length+=blob->length;
}
return length;
} | O3 | c | mi_calc_total_blob_length:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movl 0x188(%rax), %eax
testq %rax, %rax
je 0x775ff
movq 0x48(%rdi), %rcx
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
xorl %edi, %edi
leaq 0x6a105(%rip), %r8 # 0xe16a8
xorl %eax, %eax
movl 0x8(%rcx,%rdi), %r10d
decl %r10d
cmpl $0x3, %r10d
ja 0x775e9
movq (%rcx,%rdi), %r9
movslq (%r8,%r10,4), %r10
addq %r8, %r10
jmpq *%r10
movzbl (%rsi,%r9), %r9d
jmp 0x775ec
movzwl (%rsi,%r9), %r10d
movzbl 0x2(%rsi,%r9), %r9d
shll $0x10, %r9d
orq %r10, %r9
jmp 0x775ec
movl (%rsi,%r9), %r9d
jmp 0x775ec
movzwl (%rsi,%r9), %r9d
jmp 0x775ec
xorl %r9d, %r9d
movq %r9, 0x10(%rcx,%rdi)
addq %r9, %rax
addq $0x18, %rdi
cmpq %rdi, %rdx
jne 0x775a5
jmp 0x77601
xorl %eax, %eax
popq %rbp
retq
| _mi_calc_total_blob_length:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov eax, [rax+188h]
test rax, rax
jz short loc_775FF
mov rcx, [rdi+48h]
shl rax, 3
lea rdx, [rax+rax*2]
xor edi, edi
lea r8, jpt_775BE
xor eax, eax
loc_775A5:
mov r10d, [rcx+rdi+8]
dec r10d; switch 4 cases
cmp r10d, 3
ja short def_775BE; jumptable 00000000000775BE default case
mov r9, [rcx+rdi]
movsxd r10, ds:(jpt_775BE - 0E16A8h)[r8+r10*4]
add r10, r8
jmp r10; switch jump
loc_775C1:
movzx r9d, byte ptr [rsi+r9]; jumptable 00000000000775BE case 1
jmp short loc_775EC
loc_775C8:
movzx r10d, word ptr [rsi+r9]; jumptable 00000000000775BE case 3
movzx r9d, byte ptr [rsi+r9+2]
shl r9d, 10h
or r9, r10
jmp short loc_775EC
loc_775DC:
mov r9d, [rsi+r9]; jumptable 00000000000775BE case 4
jmp short loc_775EC
loc_775E2:
movzx r9d, word ptr [rsi+r9]; jumptable 00000000000775BE case 2
jmp short loc_775EC
def_775BE:
xor r9d, r9d; jumptable 00000000000775BE default case
loc_775EC:
mov [rcx+rdi+10h], r9
add rax, r9
add rdi, 18h
cmp rdx, rdi
jnz short loc_775A5
jmp short loc_77601
loc_775FF:
xor eax, eax
loc_77601:
pop rbp
retn
| long long mi_calc_total_blob_length(_QWORD *a1, long long a2)
{
long long v2; // rcx
long long v3; // rdx
long long v4; // rdi
long long result; // rax
long long v6; // r9
unsigned long long v7; // r9
if ( !*(_DWORD *)(*a1 + 392LL) )
return 0LL;
v2 = a1[9];
v3 = 24LL * *(unsigned int *)(*a1 + 392LL);
v4 = 0LL;
result = 0LL;
do
{
v6 = *(_QWORD *)(v2 + v4);
switch ( *(_DWORD *)(v2 + v4 + 8) )
{
case 1:
v7 = *(unsigned __int8 *)(a2 + v6);
break;
case 2:
v7 = *(unsigned __int16 *)(a2 + v6);
break;
case 3:
v7 = *(unsigned __int16 *)(a2 + v6) | (unsigned long long)(*(unsigned __int8 *)(a2 + v6 + 2) << 16);
break;
case 4:
v7 = *(unsigned int *)(a2 + v6);
break;
default:
v7 = 0LL;
break;
}
*(_QWORD *)(v2 + v4 + 16) = v7;
result += v7;
v4 += 24LL;
}
while ( v3 != v4 );
return result;
}
| _mi_calc_total_blob_length:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX + 0x188]
TEST RAX,RAX
JZ 0x001775ff
MOV RCX,qword ptr [RDI + 0x48]
SHL RAX,0x3
LEA RDX,[RAX + RAX*0x2]
XOR EDI,EDI
LEA R8,[0x1e16a8]
XOR EAX,EAX
LAB_001775a5:
MOV R10D,dword ptr [RCX + RDI*0x1 + 0x8]
DEC R10D
CMP R10D,0x3
JA 0x001775e9
MOV R9,qword ptr [RCX + RDI*0x1]
MOVSXD R10,dword ptr [R8 + R10*0x4]
ADD R10,R8
switchD:
JMP R10
caseD_1:
MOVZX R9D,byte ptr [RSI + R9*0x1]
JMP 0x001775ec
caseD_3:
MOVZX R10D,word ptr [RSI + R9*0x1]
MOVZX R9D,byte ptr [RSI + R9*0x1 + 0x2]
SHL R9D,0x10
OR R9,R10
JMP 0x001775ec
caseD_4:
MOV R9D,dword ptr [RSI + R9*0x1]
JMP 0x001775ec
caseD_2:
MOVZX R9D,word ptr [RSI + R9*0x1]
JMP 0x001775ec
LAB_001775e9:
XOR R9D,R9D
LAB_001775ec:
MOV qword ptr [RCX + RDI*0x1 + 0x10],R9
ADD RAX,R9
ADD RDI,0x18
CMP RDX,RDI
JNZ 0x001775a5
JMP 0x00177601
LAB_001775ff:
XOR EAX,EAX
LAB_00177601:
POP RBP
RET
|
long _mi_calc_total_blob_length(long *param_1,long param_2)
{
uint uVar1;
int iVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
ulong uVar7;
uVar1 = *(uint *)(*param_1 + 0x188);
if ((ulong)uVar1 == 0) {
lVar5 = 0;
}
else {
lVar3 = param_1[9];
lVar6 = 0;
lVar5 = 0;
do {
iVar2 = *(int *)(lVar3 + 8 + lVar6);
if (iVar2 - 1U < 4) {
lVar4 = *(long *)(lVar3 + lVar6);
switch(iVar2) {
case 1:
uVar7 = (ulong)*(byte *)(param_2 + lVar4);
break;
case 2:
uVar7 = (ulong)*(ushort *)(param_2 + lVar4);
break;
case 3:
uVar7 = (ulong)CONCAT12(*(int1 *)(param_2 + 2 + lVar4),
*(int2 *)(param_2 + lVar4));
break;
case 4:
uVar7 = (ulong)*(uint *)(param_2 + lVar4);
}
}
else {
uVar7 = 0;
}
*(ulong *)(lVar3 + 0x10 + lVar6) = uVar7;
lVar5 = lVar5 + uVar7;
lVar6 = lVar6 + 0x18;
} while ((ulong)uVar1 * 0x18 != lVar6);
}
return lVar5;
}
| |
24,107 | ma_remove_table_from_trnman | eloqsql/storage/maria/ma_state.c | void _ma_remove_table_from_trnman(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
TRN *trn= info->trn;
MARIA_USED_TABLES *tables, **prev;
DBUG_ENTER("_ma_remove_table_from_trnman");
DBUG_PRINT("enter", ("trn: %p used_tables: %p share: %p in_trans: %d",
trn, trn->used_tables, share, share->in_trans));
mysql_mutex_assert_owner(&share->intern_lock);
if (trn == &dummy_transaction_object)
DBUG_VOID_RETURN;
/* First remove share from used_tables */
for (prev= (MARIA_USED_TABLES**) (char*) &trn->used_tables;
(tables= *prev);
prev= &tables->next)
{
if (tables->share == share)
{
*prev= tables->next;
/*
We don't have to and can't call decrement_share_in_trans(share) here
as we know there is an active MARIA_HA handler around.
*/
share->in_trans--;
my_free(tables);
break;
}
}
if (!tables)
{
/*
This can only happens in case of rename of intermediate table as
part of alter table
*/
DBUG_PRINT("warning", ("share: %p where not in used_tables_list", share));
}
/* Reset trn and remove table from used_instances */
_ma_reset_trn_for_table(info);
DBUG_VOID_RETURN;
} | O3 | c | ma_remove_table_from_trnman:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
cmpq 0x346b6e(%rip), %rdi # 0x38cf60
je 0x46454
movq (%rbx), %rax
addq $0x58, %rdi
movq %rdi, %rcx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4641d
cmpq %rax, 0x8(%rdi)
jne 0x463fb
movq (%rdi), %rdx
movq %rdx, (%rcx)
decl 0x7ac(%rax)
callq 0xa65fa
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x4644c
leaq 0x10(%rbx), %rcx
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x46441
movq %rax, 0x18(%rdx)
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rax
jmp 0x46443
xorl %edx, %edx
movq %rdx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| _ma_remove_table_from_trnman:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+8]
cmp rdi, cs:dummy_transaction_object_ptr
jz short loc_46454
mov rax, [rbx]
add rdi, 58h ; 'X'
loc_463FB:
mov rcx, rdi
mov rdi, [rdi]
test rdi, rdi
jz short loc_4641D
cmp [rdi+8], rax
jnz short loc_463FB
mov rdx, [rdi]
mov [rcx], rdx
dec dword ptr [rax+7ACh]
call my_free
loc_4641D:
mov rax, [rbx+18h]
test rax, rax
jz short loc_4644C
lea rcx, [rbx+10h]
mov rdx, [rbx+10h]
test rdx, rdx
jz short loc_46441
mov [rdx+18h], rax
mov rdx, [rbx+10h]
mov rax, [rbx+18h]
jmp short loc_46443
loc_46441:
xor edx, edx
loc_46443:
mov [rax], rdx
xorps xmm0, xmm0
movups xmmword ptr [rcx], xmm0
loc_4644C:
mov qword ptr [rbx+8], 0
loc_46454:
add rsp, 8
pop rbx
pop rbp
retn
| _QWORD * ma_remove_table_from_trnman(_QWORD *a1)
{
_QWORD *result; // rax
_QWORD *v3; // rdi
long long v4; // rax
_QWORD *v5; // rdi
_QWORD *v6; // rcx
long long v7; // rdx
long long v8; // rdx
v3 = (_QWORD *)a1[1];
if ( v3 != dummy_transaction_object )
{
v4 = *a1;
v5 = v3 + 11;
while ( 1 )
{
v6 = v5;
v5 = (_QWORD *)*v5;
if ( !v5 )
break;
if ( v5[1] == v4 )
{
*v6 = *v5;
--*(_DWORD *)(v4 + 1964);
my_free(v5);
break;
}
}
result = (_QWORD *)a1[3];
if ( result )
{
v7 = a1[2];
if ( v7 )
{
*(_QWORD *)(v7 + 24) = result;
v8 = a1[2];
result = (_QWORD *)a1[3];
}
else
{
v8 = 0LL;
}
*result = v8;
*((_OWORD *)a1 + 1) = 0LL;
}
a1[1] = 0LL;
}
return result;
}
| _ma_remove_table_from_trnman:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,qword ptr [0x0048cf60]
JZ 0x00146454
MOV RAX,qword ptr [RBX]
ADD RDI,0x58
LAB_001463fb:
MOV RCX,RDI
MOV RDI,qword ptr [RDI]
TEST RDI,RDI
JZ 0x0014641d
CMP qword ptr [RDI + 0x8],RAX
JNZ 0x001463fb
MOV RDX,qword ptr [RDI]
MOV qword ptr [RCX],RDX
DEC dword ptr [RAX + 0x7ac]
CALL 0x001a65fa
LAB_0014641d:
MOV RAX,qword ptr [RBX + 0x18]
TEST RAX,RAX
JZ 0x0014644c
LEA RCX,[RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x10]
TEST RDX,RDX
JZ 0x00146441
MOV qword ptr [RDX + 0x18],RAX
MOV RDX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RBX + 0x18]
JMP 0x00146443
LAB_00146441:
XOR EDX,EDX
LAB_00146443:
MOV qword ptr [RAX],RDX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RCX],XMM0
LAB_0014644c:
MOV qword ptr [RBX + 0x8],0x0
LAB_00146454:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void _ma_remove_table_from_trnman(long *param_1)
{
int *piVar1;
long *plVar2;
long lVar3;
long *plVar4;
if ((int *)param_1[1] != PTR_dummy_transaction_object_0048cf60) {
lVar3 = *param_1;
plVar2 = (long *)((int *)param_1[1] + 0x58);
do {
plVar4 = plVar2;
plVar2 = (long *)*plVar4;
if (plVar2 == (long *)0x0) goto LAB_0014641d;
} while (plVar2[1] != lVar3);
*plVar4 = *plVar2;
piVar1 = (int *)(lVar3 + 0x7ac);
*piVar1 = *piVar1 + -1;
my_free();
LAB_0014641d:
plVar2 = (long *)param_1[3];
if (plVar2 != (long *)0x0) {
if (param_1[2] == 0) {
lVar3 = 0;
}
else {
*(long **)(param_1[2] + 0x18) = plVar2;
lVar3 = param_1[2];
plVar2 = (long *)param_1[3];
}
*plVar2 = lVar3;
param_1[2] = 0;
param_1[3] = 0;
}
param_1[1] = 0;
}
return;
}
| |
24,108 | blst_miller_loop_n | corpus-core[P]colibri-stateless/build_O1/_deps/blst-src/src/pairing.c | void blst_miller_loop_n(vec384fp12 out, const POINTonE2_affine *const Qs[],
const POINTonE1_affine *const Ps[],
size_t n)
{ /* ~10KB of stack storage */
POINTonE2 T[MILLER_LOOP_N_MAX];
POINTonE2_affine Q[MILLER_LOOP_N_MAX];
POINTonE1_affine Px2[MILLER_LOOP_N_MAX];
const POINTonE2_affine *Qptr = NULL;
const POINTonE1_affine *Pptr = NULL;
size_t i, j;
for (i = 0, j = 0; j < n; j++) {
Qptr = *Qs ? *Qs++ : Qptr+1;
Pptr = *Ps ? *Ps++ : Pptr+1;
/* Move common expression from line evaluation to line_by_Px2. */
add_fp(Px2[i].X, Pptr->X, Pptr->X);
neg_fp(Px2[i].X, Px2[i].X);
add_fp(Px2[i].Y, Pptr->Y, Pptr->Y);
vec_copy(Q[i].X, Qptr->X, 2*sizeof(Q[i].X));
vec_copy(T[i].X, Qptr->X, 2*sizeof(T[i].X));
vec_copy(T[i].Z, BLS12_381_Rx.p2, sizeof(T[i].Z));
if (++i == MILLER_LOOP_N_MAX || j == n-1) {
vec384fp12 tmp;
vec384fp6 *ret = j < MILLER_LOOP_N_MAX ? out : tmp;
/* first step is ret = 1^2*line, which is just ret = line */
start_dbl_n(ret, T, Px2, i); /* 0x2 */
add_n_dbl_n(ret, T, Q, Px2, i, 2); /* ..0xc */
add_n_dbl_n(ret, T, Q, Px2, i, 3); /* ..0x68 */
add_n_dbl_n(ret, T, Q, Px2, i, 9); /* ..0xd200 */
add_n_dbl_n(ret, T, Q, Px2, i, 32); /* ..0xd20100000000 */
add_n_dbl_n(ret, T, Q, Px2, i, 16); /* ..0xd201000000010000 */
conjugate_fp12(ret); /* account for z being negative */
if (j >= MILLER_LOOP_N_MAX)
mul_fp12(out, out, ret);
i = 0;
}
}
} | O1 | c | blst_miller_loop_n:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2698, %rsp # imm = 0x2698
movq %rdi, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
testq %rcx, %rcx
je 0x62fba
movq -0x48(%rbp), %rax
decq %rax
movq %rax, -0x60(%rbp)
xorl %r14d, %r14d
xorl %r8d, %r8d
movq $0x0, -0x50(%rbp)
movq $0x0, -0x38(%rbp)
movq %r8, -0x58(%rbp)
movq %r14, -0x68(%rbp)
movq %rsi, -0x70(%rbp)
movq (%rsi), %rax
movl $0xc0, %ecx
movq -0x38(%rbp), %r13
addq %rcx, %r13
testq %rax, %rax
cmovneq %rax, %r13
setne -0x2a(%rbp)
movq %rdx, -0x78(%rbp)
movq (%rdx), %rax
movq -0x50(%rbp), %rbx
addq $0x60, %rbx
testq %rax, %rax
setne -0x29(%rbp)
cmovneq %rax, %rbx
leaq (%r8,%r8,2), %r15
movq %r15, -0x38(%rbp)
shlq $0x5, %r15
leaq (%r15,%rbp), %r12
addq $-0x680, %r12 # imm = 0xF980
movq %r12, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
leaq 0x2bade(%rip), %r14 # 0x8e8b0
movq %r14, %rcx
callq 0x71a40
movl $0x1, %edx
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x720c0
leaq (%r15,%rbp), %rdi
addq $-0x650, %rdi # imm = 0xF9B0
movq %rbx, -0x50(%rbp)
leaq 0x30(%rbx), %rdx
movq %rdx, %rsi
movq %r14, %rcx
movq -0x68(%rbp), %r14
callq 0x71a40
movq -0x38(%rbp), %rax
shlq $0x6, %rax
leaq (%rax,%rbp), %rdi
addq $-0x14c0, %rdi # imm = 0xEB40
movl $0xc0, %edx
movq %r13, %rsi
callq 0x211a0
movq -0x58(%rbp), %rax
leaq (%rax,%rax,8), %rax
shlq $0x5, %rax
leaq (%rax,%rbp), %r12
addq $-0x26c0, %r12 # imm = 0xD940
movl $0xc0, %edx
movq %r12, %rdi
movq %r13, -0x38(%rbp)
movq %r13, %rsi
callq 0x211a0
movq -0x58(%rbp), %r8
movl $0xc0, %eax
addq %rax, %r12
movl $0xc, %ecx
movq %r12, %rdi
leaq 0x2ba73(%rip), %rsi # 0x8e8e8
rep movsq (%rsi), %es:(%rdi)
incq %r8
cmpq $0x10, %r8
setne %al
cmpq %r14, -0x60(%rbp)
setne %cl
testb %cl, %al
jne 0x62f8f
cmpq $0x10, %r14
leaq -0x8c0(%rbp), %r12
cmovbq -0x40(%rbp), %r12
movq %r12, %rdi
leaq -0x26c0(%rbp), %rbx
movq %rbx, %rsi
leaq -0x680(%rbp), %rdx
movq %r8, %rcx
movq %r8, %r15
callq 0x62fcc
movl $0x2, %r9d
movq %r12, %rdi
movq %rbx, %rsi
leaq -0x14c0(%rbp), %rdx
leaq -0x680(%rbp), %r13
movq %r13, %rcx
movq %r15, %r8
callq 0x630ab
movl $0x3, %r9d
movq %r12, %rdi
movq %rbx, %rsi
leaq -0x14c0(%rbp), %rdx
movq %r13, %rcx
movq %r15, %r8
callq 0x630ab
movl $0x9, %r9d
movq %r12, %rdi
movq %rbx, %rsi
movq %rbx, %r13
leaq -0x14c0(%rbp), %rdx
movq %rdx, %rbx
leaq -0x680(%rbp), %rcx
movq %r15, %r8
callq 0x630ab
movl $0x20, %r9d
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
leaq -0x680(%rbp), %rcx
movq %r15, %r8
callq 0x630ab
movl $0x10, %r9d
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
leaq -0x680(%rbp), %rcx
movq %r15, %r8
callq 0x630ab
leaq 0x120(%r12), %rdi
movq %rdi, %rsi
callq 0x6a819
cmpq $0x10, %r14
jb 0x62f8c
movq -0x40(%rbp), %rdi
movq %rdi, %rsi
movq %r12, %rdx
callq 0x61d42
xorl %r8d, %r8d
xorl %eax, %eax
movb -0x2a(%rbp), %cl
movb %cl, %al
movq -0x70(%rbp), %rsi
leaq (%rsi,%rax,8), %rsi
xorl %eax, %eax
movb -0x29(%rbp), %cl
movb %cl, %al
movq -0x78(%rbp), %rdx
leaq (%rdx,%rax,8), %rdx
incq %r14
cmpq %r14, -0x48(%rbp)
jne 0x62d6b
addq $0x2698, %rsp # imm = 0x2698
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| blst_miller_loop_n:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2698h
mov [rbp+var_40], rdi
mov [rbp+var_48], rcx
test rcx, rcx
jz loc_62FBA
mov rax, [rbp+var_48]
dec rax
mov [rbp+var_60], rax
xor r14d, r14d
xor r8d, r8d
mov [rbp+var_50], 0
mov [rbp+var_38], 0
loc_62D6B:
mov [rbp+var_58], r8
mov [rbp+var_68], r14
mov [rbp+var_70], rsi
mov rax, [rsi]
mov ecx, 0C0h
mov r13, [rbp+var_38]
add r13, rcx
test rax, rax
cmovnz r13, rax
setnz [rbp+var_2A]
mov [rbp+var_78], rdx
mov rax, [rdx]
mov rbx, [rbp+var_50]
add rbx, 60h ; '`'
test rax, rax
setnz [rbp+var_29]
cmovnz rbx, rax
lea r15, [r8+r8*2]
mov [rbp+var_38], r15
shl r15, 5
lea r12, [r15+rbp]
add r12, 0FFFFFFFFFFFFF980h
mov rdi, r12
mov rsi, rbx
mov rdx, rbx
lea r14, BLS12_381_P
mov rcx, r14
call add_mod_384
mov edx, 1
mov rdi, r12
mov rsi, r12
mov rcx, r14
call cneg_mod_384
lea rdi, [r15+rbp]
add rdi, 0FFFFFFFFFFFFF9B0h
mov [rbp+var_50], rbx
lea rdx, [rbx+30h]
mov rsi, rdx
mov rcx, r14
mov r14, [rbp+var_68]
call add_mod_384
mov rax, [rbp+var_38]
shl rax, 6
lea rdi, [rax+rbp]
add rdi, 0FFFFFFFFFFFFEB40h
mov edx, 0C0h
mov rsi, r13
call _memcpy
mov rax, [rbp+var_58]
lea rax, [rax+rax*8]
shl rax, 5
lea r12, [rax+rbp]
add r12, 0FFFFFFFFFFFFD940h
mov edx, 0C0h
mov rdi, r12
mov [rbp+var_38], r13
mov rsi, r13
call _memcpy
mov r8, [rbp+var_58]
mov eax, 0C0h
add r12, rax
mov ecx, 0Ch
mov rdi, r12
lea rsi, BLS12_381_Rx
rep movsq
inc r8
cmp r8, 10h
setnz al
cmp [rbp+var_60], r14
setnz cl
test al, cl
jnz loc_62F8F
cmp r14, 10h
lea r12, [rbp+var_8C0]
cmovb r12, [rbp+var_40]
mov rdi, r12
lea rbx, [rbp+var_26C0]
mov rsi, rbx
lea rdx, [rbp+var_680]
mov rcx, r8
mov r15, r8
call start_dbl_n
mov r9d, 2
mov rdi, r12
mov rsi, rbx
lea rdx, [rbp+var_14C0]
lea r13, [rbp+var_680]
mov rcx, r13
mov r8, r15
call add_n_dbl_n
mov r9d, 3
mov rdi, r12
mov rsi, rbx
lea rdx, [rbp+var_14C0]
mov rcx, r13
mov r8, r15
call add_n_dbl_n
mov r9d, 9
mov rdi, r12
mov rsi, rbx
mov r13, rbx
lea rdx, [rbp+var_14C0]
mov rbx, rdx
lea rcx, [rbp+var_680]
mov r8, r15
call add_n_dbl_n
mov r9d, 20h ; ' '
mov rdi, r12
mov rsi, r13
mov rdx, rbx
lea rcx, [rbp+var_680]
mov r8, r15
call add_n_dbl_n
mov r9d, 10h
mov rdi, r12
mov rsi, r13
mov rdx, rbx
lea rcx, [rbp+var_680]
mov r8, r15
call add_n_dbl_n
lea rdi, [r12+120h]
mov rsi, rdi
call neg_fp6
cmp r14, 10h
jb short loc_62F8C
mov rdi, [rbp+var_40]
mov rsi, rdi
mov rdx, r12
call mul_fp12
loc_62F8C:
xor r8d, r8d
loc_62F8F:
xor eax, eax
mov cl, [rbp+var_2A]
mov al, cl
mov rsi, [rbp+var_70]
lea rsi, [rsi+rax*8]
xor eax, eax
mov cl, [rbp+var_29]
mov al, cl
mov rdx, [rbp+var_78]
lea rdx, [rdx+rax*8]
inc r14
cmp [rbp+var_48], r14
jnz loc_62D6B
loc_62FBA:
add rsp, 2698h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| void blst_miller_loop_n(long long a1, long long *a2, _QWORD *a3, long long a4)
{
unsigned long long v4; // r14
long long v5; // r8
long long v6; // r13
long long v7; // rax
long long v8; // rbx
bool v9; // zf
long long v10; // r15
_OWORD *v11; // r12
unsigned long long v12; // r14
_OWORD *v13; // r12
long long v14; // r8
char *v15; // r12
long long v16; // r15
_OWORD v17[288]; // [rsp+0h] [rbp-26C0h] BYREF
_BYTE v18[3072]; // [rsp+1200h] [rbp-14C0h] BYREF
char v19; // [rsp+1E00h] [rbp-8C0h] BYREF
_OWORD v20[96]; // [rsp+2040h] [rbp-680h] BYREF
_QWORD *v21; // [rsp+2648h] [rbp-78h]
long long *v22; // [rsp+2650h] [rbp-70h]
unsigned long long v23; // [rsp+2658h] [rbp-68h]
long long v24; // [rsp+2660h] [rbp-60h]
long long v25; // [rsp+2668h] [rbp-58h]
long long v26; // [rsp+2670h] [rbp-50h]
long long v27; // [rsp+2678h] [rbp-48h]
char *v28; // [rsp+2680h] [rbp-40h]
long long v29; // [rsp+2688h] [rbp-38h]
bool v30; // [rsp+2696h] [rbp-2Ah]
bool v31; // [rsp+2697h] [rbp-29h]
v28 = (char *)a1;
v27 = a4;
if ( a4 )
{
v24 = v27 - 1;
v4 = 0LL;
v5 = 0LL;
v26 = 0LL;
v29 = 0LL;
do
{
v25 = v5;
v23 = v4;
v22 = a2;
v6 = v29 + 192;
if ( *a2 )
v6 = *a2;
v30 = *a2 != 0;
v21 = a3;
v7 = *a3;
v8 = v26 + 96;
v9 = *a3 == 0LL;
v31 = *a3 != 0LL;
if ( !v9 )
v8 = v7;
v29 = 3 * v5;
v10 = 6 * v5;
v11 = &v20[6 * v5];
add_mod_384(v11, v8, v8, &BLS12_381_P);
cneg_mod_384(v11, v11, 1LL, &BLS12_381_P);
v26 = v8;
v12 = v23;
add_mod_384(&v20[v10 + 3], v8 + 48, v8 + 48, &BLS12_381_P);
memcpy(&v18[64 * v29]);
v13 = &v17[18 * v25];
v29 = v6;
memcpy(v13);
v14 = v25;
qmemcpy(v13 + 12, &BLS12_381_Rx, 0x60uLL);
v5 = v14 + 1;
if ( v24 == v12 || v5 == 16 )
{
v15 = &v19;
if ( v12 < 0x10 )
v15 = v28;
v16 = v5;
start_dbl_n(v15, v17, v20, v5);
add_n_dbl_n(v15, v17, v18, v20, v16, 2LL);
add_n_dbl_n(v15, v17, v18, v20, v16, 3LL);
add_n_dbl_n(v15, v17, v18, v20, v16, 9LL);
add_n_dbl_n(v15, v17, v18, v20, v16, 32LL);
add_n_dbl_n(v15, v17, v18, v20, v16, 16LL);
neg_fp6(v15 + 288, v15 + 288);
if ( v12 >= 0x10 )
mul_fp12((long long)v28, (long long)v28, (long long)v15);
v5 = 0LL;
}
a2 = &v22[v30];
a3 = &v21[v31];
v4 = v12 + 1;
}
while ( v27 != v4 );
}
}
| blst_miller_loop_n:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x2698
MOV qword ptr [RBP + -0x40],RDI
MOV qword ptr [RBP + -0x48],RCX
TEST RCX,RCX
JZ 0x00162fba
MOV RAX,qword ptr [RBP + -0x48]
DEC RAX
MOV qword ptr [RBP + -0x60],RAX
XOR R14D,R14D
XOR R8D,R8D
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x38],0x0
LAB_00162d6b:
MOV qword ptr [RBP + -0x58],R8
MOV qword ptr [RBP + -0x68],R14
MOV qword ptr [RBP + -0x70],RSI
MOV RAX,qword ptr [RSI]
MOV ECX,0xc0
MOV R13,qword ptr [RBP + -0x38]
ADD R13,RCX
TEST RAX,RAX
CMOVNZ R13,RAX
SETNZ byte ptr [RBP + -0x2a]
MOV qword ptr [RBP + -0x78],RDX
MOV RAX,qword ptr [RDX]
MOV RBX,qword ptr [RBP + -0x50]
ADD RBX,0x60
TEST RAX,RAX
SETNZ byte ptr [RBP + -0x29]
CMOVNZ RBX,RAX
LEA R15,[R8 + R8*0x2]
MOV qword ptr [RBP + -0x38],R15
SHL R15,0x5
LEA R12,[R15 + RBP*0x1]
ADD R12,-0x680
MOV RDI,R12
MOV RSI,RBX
MOV RDX,RBX
LEA R14,[0x18e8b0]
MOV RCX,R14
CALL 0x00171a40
MOV EDX,0x1
MOV RDI,R12
MOV RSI,R12
MOV RCX,R14
CALL 0x001720c0
LEA RDI,[R15 + RBP*0x1]
ADD RDI,-0x650
MOV qword ptr [RBP + -0x50],RBX
LEA RDX,[RBX + 0x30]
MOV RSI,RDX
MOV RCX,R14
MOV R14,qword ptr [RBP + -0x68]
CALL 0x00171a40
MOV RAX,qword ptr [RBP + -0x38]
SHL RAX,0x6
LEA RDI,[RAX + RBP*0x1]
ADD RDI,-0x14c0
MOV EDX,0xc0
MOV RSI,R13
CALL 0x001211a0
MOV RAX,qword ptr [RBP + -0x58]
LEA RAX,[RAX + RAX*0x8]
SHL RAX,0x5
LEA R12,[RAX + RBP*0x1]
ADD R12,-0x26c0
MOV EDX,0xc0
MOV RDI,R12
MOV qword ptr [RBP + -0x38],R13
MOV RSI,R13
CALL 0x001211a0
MOV R8,qword ptr [RBP + -0x58]
MOV EAX,0xc0
ADD R12,RAX
MOV ECX,0xc
MOV RDI,R12
LEA RSI,[0x18e8e8]
MOVSQ.REP RDI,RSI
INC R8
CMP R8,0x10
SETNZ AL
CMP qword ptr [RBP + -0x60],R14
SETNZ CL
TEST AL,CL
JNZ 0x00162f8f
CMP R14,0x10
LEA R12,[RBP + -0x8c0]
CMOVC R12,qword ptr [RBP + -0x40]
MOV RDI,R12
LEA RBX,[RBP + -0x26c0]
MOV RSI,RBX
LEA RDX,[RBP + -0x680]
MOV RCX,R8
MOV R15,R8
CALL 0x00162fcc
MOV R9D,0x2
MOV RDI,R12
MOV RSI,RBX
LEA RDX,[RBP + -0x14c0]
LEA R13,[RBP + -0x680]
MOV RCX,R13
MOV R8,R15
CALL 0x001630ab
MOV R9D,0x3
MOV RDI,R12
MOV RSI,RBX
LEA RDX,[RBP + -0x14c0]
MOV RCX,R13
MOV R8,R15
CALL 0x001630ab
MOV R9D,0x9
MOV RDI,R12
MOV RSI,RBX
MOV R13,RBX
LEA RDX,[RBP + -0x14c0]
MOV RBX,RDX
LEA RCX,[RBP + -0x680]
MOV R8,R15
CALL 0x001630ab
MOV R9D,0x20
MOV RDI,R12
MOV RSI,R13
MOV RDX,RBX
LEA RCX,[RBP + -0x680]
MOV R8,R15
CALL 0x001630ab
MOV R9D,0x10
MOV RDI,R12
MOV RSI,R13
MOV RDX,RBX
LEA RCX,[RBP + -0x680]
MOV R8,R15
CALL 0x001630ab
LEA RDI,[R12 + 0x120]
MOV RSI,RDI
CALL 0x0016a819
CMP R14,0x10
JC 0x00162f8c
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,RDI
MOV RDX,R12
CALL 0x00161d42
LAB_00162f8c:
XOR R8D,R8D
LAB_00162f8f:
XOR EAX,EAX
MOV CL,byte ptr [RBP + -0x2a]
MOV AL,CL
MOV RSI,qword ptr [RBP + -0x70]
LEA RSI,[RSI + RAX*0x8]
XOR EAX,EAX
MOV CL,byte ptr [RBP + -0x29]
MOV AL,CL
MOV RDX,qword ptr [RBP + -0x78]
LEA RDX,[RDX + RAX*0x8]
INC R14
CMP qword ptr [RBP + -0x48],R14
JNZ 0x00162d6b
LAB_00162fba:
ADD RSP,0x2698
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void blst_miller_loop_n(int1 *param_1,long *param_2,long *param_3,ulong param_4)
{
ulong uVar1;
long lVar2;
int8 *puVar3;
int8 *puVar4;
long lVar5;
int1 *puVar6;
void *__src;
byte bVar7;
int1 local_26c8 [192];
int8 auStack_2608 [552];
int1 local_14c8 [3072];
int1 local_8c8 [576];
int1 local_688 [48];
int1 auStack_658 [1496];
long *local_80;
long *local_78;
ulong local_70;
ulong local_68;
long local_60;
long local_58;
ulong local_50;
int1 *local_48;
void *local_40;
byte local_32;
byte local_31;
bVar7 = 0;
if (param_4 != 0) {
local_68 = param_4 - 1;
local_70 = 0;
lVar5 = 0;
local_58 = 0;
local_40 = (void *)0x0;
local_50 = param_4;
local_48 = param_1;
do {
local_32 = (void *)*param_2 != (void *)0x0;
__src = (void *)((long)local_40 + 0xc0);
if ((bool)local_32) {
__src = (void *)*param_2;
}
local_31 = *param_3 != 0;
lVar2 = local_58 + 0x60;
if ((bool)local_31) {
lVar2 = *param_3;
}
local_40 = (void *)(lVar5 * 3);
puVar6 = local_688 + lVar5 * 0x60;
local_80 = param_3;
local_78 = param_2;
local_60 = lVar5;
add_mod_384(puVar6,lVar2,lVar2,BLS12_381_P);
cneg_mod_384(puVar6,puVar6,1,BLS12_381_P);
uVar1 = local_70;
local_58 = lVar2;
add_mod_384(auStack_658 + lVar5 * 0x60,lVar2 + 0x30,lVar2 + 0x30,BLS12_381_P);
memcpy(local_14c8 + (long)local_40 * 0x40,__src,0xc0);
lVar5 = local_60;
local_40 = __src;
memcpy(local_26c8 + local_60 * 0x120,__src,0xc0);
puVar3 = &BLS12_381_Rx;
puVar4 = auStack_2608 + lVar5 * 0x24;
for (lVar2 = 0xc; lVar2 != 0; lVar2 = lVar2 + -1) {
*puVar4 = *puVar3;
puVar3 = puVar3 + (ulong)bVar7 * -2 + 1;
puVar4 = puVar4 + (ulong)bVar7 * -2 + 1;
}
lVar5 = local_60 + 1;
if (lVar5 == 0x10 || local_68 == uVar1) {
puVar6 = local_8c8;
if (uVar1 < 0x10) {
puVar6 = local_48;
}
start_dbl_n(puVar6,local_26c8,local_688,lVar5);
add_n_dbl_n(puVar6,local_26c8,local_14c8,local_688,lVar5,2);
add_n_dbl_n(puVar6,local_26c8,local_14c8,local_688,lVar5,3);
add_n_dbl_n(puVar6,local_26c8,local_14c8,local_688,lVar5,9);
add_n_dbl_n(puVar6,local_26c8,local_14c8,local_688,lVar5,0x20);
add_n_dbl_n(puVar6,local_26c8,local_14c8,local_688,lVar5,0x10);
neg_fp6(puVar6 + 0x120,puVar6 + 0x120);
if (0xf < uVar1) {
mul_fp12(local_48,local_48,puVar6);
}
lVar5 = 0;
}
param_2 = local_78 + local_32;
param_3 = local_80 + local_31;
local_70 = uVar1 + 1;
} while (local_50 != local_70);
}
return;
}
| |
24,109 | glfwInitVulkan | untodesu[P]riteg/build_O1/_deps/glfw-src/src/vulkan.c | GLFWbool _glfwInitVulkan(int mode)
{
VkResult err;
VkExtensionProperties* ep;
uint32_t i, count;
if (_glfw.vk.available)
return GLFW_TRUE;
#if !defined(_GLFW_VULKAN_STATIC)
#if defined(_GLFW_VULKAN_LIBRARY)
_glfw.vk.handle = _glfw_dlopen(_GLFW_VULKAN_LIBRARY);
#elif defined(_GLFW_WIN32)
_glfw.vk.handle = _glfw_dlopen("vulkan-1.dll");
#elif defined(_GLFW_COCOA)
_glfw.vk.handle = _glfw_dlopen("libvulkan.1.dylib");
#else
_glfw.vk.handle = _glfw_dlopen("libvulkan.so.1");
#endif
if (!_glfw.vk.handle)
{
if (mode == _GLFW_REQUIRE_LOADER)
_glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: Loader not found");
return GLFW_FALSE;
}
_glfw.vk.GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)
_glfw_dlsym(_glfw.vk.handle, "vkGetInstanceProcAddr");
if (!_glfw.vk.GetInstanceProcAddr)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Loader does not export vkGetInstanceProcAddr");
_glfwTerminateVulkan();
return GLFW_FALSE;
}
_glfw.vk.EnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties)
vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceExtensionProperties");
if (!_glfw.vk.EnumerateInstanceExtensionProperties)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Failed to retrieve vkEnumerateInstanceExtensionProperties");
_glfwTerminateVulkan();
return GLFW_FALSE;
}
#endif // _GLFW_VULKAN_STATIC
err = vkEnumerateInstanceExtensionProperties(NULL, &count, NULL);
if (err)
{
// NOTE: This happens on systems with a loader but without any Vulkan ICD
if (mode == _GLFW_REQUIRE_LOADER)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Failed to query instance extension count: %s",
_glfwGetVulkanResultString(err));
}
_glfwTerminateVulkan();
return GLFW_FALSE;
}
ep = calloc(count, sizeof(VkExtensionProperties));
err = vkEnumerateInstanceExtensionProperties(NULL, &count, ep);
if (err)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Failed to query instance extensions: %s",
_glfwGetVulkanResultString(err));
free(ep);
_glfwTerminateVulkan();
return GLFW_FALSE;
}
for (i = 0; i < count; i++)
{
if (strcmp(ep[i].extensionName, "VK_KHR_surface") == 0)
_glfw.vk.KHR_surface = GLFW_TRUE;
#if defined(_GLFW_WIN32)
else if (strcmp(ep[i].extensionName, "VK_KHR_win32_surface") == 0)
_glfw.vk.KHR_win32_surface = GLFW_TRUE;
#elif defined(_GLFW_COCOA)
else if (strcmp(ep[i].extensionName, "VK_MVK_macos_surface") == 0)
_glfw.vk.MVK_macos_surface = GLFW_TRUE;
#elif defined(_GLFW_X11)
else if (strcmp(ep[i].extensionName, "VK_KHR_xlib_surface") == 0)
_glfw.vk.KHR_xlib_surface = GLFW_TRUE;
else if (strcmp(ep[i].extensionName, "VK_KHR_xcb_surface") == 0)
_glfw.vk.KHR_xcb_surface = GLFW_TRUE;
#elif defined(_GLFW_WAYLAND)
else if (strcmp(ep[i].extensionName, "VK_KHR_wayland_surface") == 0)
_glfw.vk.KHR_wayland_surface = GLFW_TRUE;
#endif
}
free(ep);
_glfw.vk.available = GLFW_TRUE;
_glfwPlatformGetRequiredInstanceExtensions(_glfw.vk.extensions);
return GLFW_TRUE;
} | O1 | c | glfwInitVulkan:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x880da(%rip), %rbx # 0xa4638
movl $0x1, %r14d
cmpl $0x0, 0x1fe70(%rbx)
je 0x1c57f
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %ebp
leaq 0x632f4(%rip), %rdi # 0x7f87c
movl $0x1, %esi
callq 0xcb30
movq %rax, 0x1fe78(%rbx)
testq %rax, %rax
je 0x1c618
leaq 0x6331e(%rip), %rsi # 0x7f8c3
movq %rax, %rdi
callq 0xc820
movq %rax, 0x1fe98(%rbx)
testq %rax, %rax
je 0x1c63f
leaq 0x63330(%rip), %rsi # 0x7f8f4
xorl %r14d, %r14d
xorl %edi, %edi
callq *%rax
movq %rax, 0x1fe90(%rbx)
testq %rax, %rax
je 0x1c64b
leaq 0x4(%rsp), %rsi
xorl %edi, %edi
xorl %edx, %edx
callq *%rax
testl %eax, %eax
je 0x1c678
cmpl $0x2, %ebp
jne 0x1c60c
movl %eax, %edi
callq 0x1c788
leaq 0x6331e(%rip), %rsi # 0x7f91b
movl $0x10006, %edi # imm = 0x10006
movq %rax, %rdx
xorl %eax, %eax
callq 0x19081
movq 0x1fe78(%rbx), %rdi
xorl %r14d, %r14d
jmp 0x1c665
xorl %r14d, %r14d
cmpl $0x2, %ebp
jne 0x1c56d
leaq 0x63260(%rip), %rsi # 0x7f88b
xorl %r14d, %r14d
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x19081
jmp 0x1c56d
leaq 0x6325e(%rip), %rsi # 0x7f8a4
xorl %r14d, %r14d
jmp 0x1c652
leaq 0x63287(%rip), %rsi # 0x7f8d9
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x19081
movq 0x1fe78(%rbx), %rdi
testq %rdi, %rdi
je 0x1c56d
callq 0xc670
jmp 0x1c56d
leaq 0x4(%rsp), %r12
movl (%r12), %edi
movl $0x104, %esi # imm = 0x104
callq 0xc550
movq %rax, %r15
xorl %r14d, %r14d
xorl %edi, %edi
movq %r12, %rsi
movq %rax, %rdx
callq *0x1fe90(%rbx)
testl %eax, %eax
je 0x1c6ca
movl %eax, %edi
callq 0x1c788
leaq 0x6329f(%rip), %rsi # 0x7f950
movl $0x10006, %edi # imm = 0x10006
movq %rax, %rdx
xorl %eax, %eax
callq 0x19081
movq %r15, %rdi
callq 0xca50
jmp 0x1c65e
movl 0x4(%rsp), %r13d
testq %r13, %r13
je 0x1c744
leaq 0x632a5(%rip), %r14 # 0x7f980
leaq 0x632ad(%rip), %r12 # 0x7f98f
movq %r15, %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0xcb50
testl %eax, %eax
je 0x1c722
movq %rbp, %rdi
movq %r12, %rsi
callq 0xcb50
testl %eax, %eax
je 0x1c72e
movq %rbp, %rdi
leaq 0x63296(%rip), %rsi # 0x7f9a3
callq 0xcb50
testl %eax, %eax
jne 0x1c738
movl $0x1, 0x1fea8(%rbx)
jmp 0x1c738
movl $0x1, 0x1fea0(%rbx)
jmp 0x1c738
movl $0x1, 0x1fea4(%rbx)
addq $0x104, %rbp # imm = 0x104
decq %r13
jne 0x1c6e5
movq %r15, %rdi
callq 0xca50
movl $0x1, 0x1fe70(%rbx)
addq $0x1fe80, %rbx # imm = 0x1FE80
movq %rbx, %rdi
callq 0x258e3
movl $0x1, %r14d
jmp 0x1c56d
| _glfwInitVulkan:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
lea rbx, _glfw
mov r14d, 1
cmp dword ptr [rbx+1FE70h], 0
jz short loc_1C57F
loc_1C56D:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1C57F:
mov ebp, edi
lea rdi, aLibvulkanSo1; "libvulkan.so.1"
mov esi, 1
call _dlopen
mov qword ptr ds:loc_1FE78[rbx], rax
test rax, rax
jz short loc_1C618
lea rsi, aVulkanLoaderDo+1Fh; "vkGetInstanceProcAddr"
mov rdi, rax
call _dlsym
mov [rbx+1FE98h], rax
test rax, rax
jz loc_1C63F
lea rsi, aVulkanFailedTo_0+1Bh; "vkEnumerateInstanceExtensionProperties"
xor r14d, r14d
xor edi, edi
call rax
mov qword ptr ds:loc_1FE90[rbx], rax
test rax, rax
jz short loc_1C64B
lea rsi, [rsp+38h+var_34]
xor edi, edi
xor edx, edx
call rax
test eax, eax
jz loc_1C678
cmp ebp, 2
jnz short loc_1C60C
mov edi, eax
call _glfwGetVulkanResultString
lea rsi, aVulkanFailedTo; "Vulkan: Failed to query instance extens"...
mov edi, 10006h
mov rdx, rax
xor eax, eax
call _glfwInputError
loc_1C60C:
mov rdi, qword ptr ds:loc_1FE78[rbx]
xor r14d, r14d
jmp short loc_1C665
loc_1C618:
xor r14d, r14d
cmp ebp, 2
jnz loc_1C56D
lea rsi, aVulkanLoaderNo; "Vulkan: Loader not found"
xor r14d, r14d
mov edi, 10006h
xor eax, eax
call _glfwInputError
jmp loc_1C56D
loc_1C63F:
lea rsi, aVulkanLoaderDo; "Vulkan: Loader does not export vkGetIns"...
xor r14d, r14d
jmp short loc_1C652
loc_1C64B:
lea rsi, aVulkanFailedTo_0; "Vulkan: Failed to retrieve vkEnumerateI"...
loc_1C652:
mov edi, 10006h
xor eax, eax
call _glfwInputError
loc_1C65E:
mov rdi, qword ptr ds:loc_1FE78[rbx]
loc_1C665:
test rdi, rdi
jz loc_1C56D
call _dlclose
jmp loc_1C56D
loc_1C678:
lea r12, [rsp+38h+var_34]
mov edi, [r12]
mov esi, 104h
call _calloc
mov r15, rax
xor r14d, r14d
xor edi, edi
mov rsi, r12
mov rdx, rax
call qword ptr ds:loc_1FE90[rbx]
test eax, eax
jz short loc_1C6CA
mov edi, eax
call _glfwGetVulkanResultString
lea rsi, aVulkanFailedTo_1; "Vulkan: Failed to query instance extens"...
mov edi, 10006h
mov rdx, rax
xor eax, eax
call _glfwInputError
mov rdi, r15
call _free
jmp short loc_1C65E
loc_1C6CA:
mov r13d, [rsp+38h+var_34]
test r13, r13
jz short loc_1C744
lea r14, aVkKhrSurface; "VK_KHR_surface"
lea r12, aVkKhrXlibSurfa; "VK_KHR_xlib_surface"
mov rbp, r15
loc_1C6E5:
mov rdi, rbp
mov rsi, r14
call _strcmp
test eax, eax
jz short loc_1C722
mov rdi, rbp
mov rsi, r12
call _strcmp
test eax, eax
jz short loc_1C72E
mov rdi, rbp
lea rsi, aVkKhrXcbSurfac; "VK_KHR_xcb_surface"
call _strcmp
test eax, eax
jnz short loc_1C738
mov dword ptr ds:loc_1FEA8[rbx], 1
jmp short loc_1C738
loc_1C722:
mov dword ptr ds:loc_1FEA0[rbx], 1
jmp short loc_1C738
loc_1C72E:
mov dword ptr [rbx+1FEA4h], 1
loc_1C738:
add rbp, 104h
dec r13
jnz short loc_1C6E5
loc_1C744:
mov rdi, r15
call _free
mov dword ptr [rbx+1FE70h], 1
add rbx, 1FE80h
mov rdi, rbx
call _glfwPlatformGetRequiredInstanceExtensions
mov r14d, 1
jmp loc_1C56D
| long long glfwInitVulkan(int a1)
{
long long v1; // rax
unsigned int v2; // r14d
long long v4; // rax
long long ( *v5)(_QWORD, char *); // rax
long long ( *v6)(_QWORD, _DWORD *, _QWORD); // rax
unsigned int v7; // eax
const char *VulkanResultString; // rax
long long v9; // rdi
long long v10; // r15
unsigned int v11; // eax
const char *v12; // rax
long long v13; // r13
long long v14; // rbp
_DWORD v15[13]; // [rsp+0h] [rbp-34h] BYREF
v15[0] = HIDWORD(v1);
v2 = 1;
if ( glfw[32668] )
return v2;
v4 = dlopen("libvulkan.so.1", 1LL);
*(_QWORD *)((char *)&loc_1FE78 + (_QWORD)glfw) = v4;
if ( !v4 )
{
v2 = 0;
if ( a1 == 2 )
{
v2 = 0;
glfwInputError(0x10006u, (long long)"Vulkan: Loader not found");
}
return v2;
}
v5 = (long long ( *)(_QWORD, char *))dlsym(v4, "vkGetInstanceProcAddr");
*(_QWORD *)&glfw[32678] = v5;
if ( !v5 )
{
v2 = 0;
glfwInputError(0x10006u, (long long)"Vulkan: Loader does not export vkGetInstanceProcAddr");
LABEL_14:
v9 = *(_QWORD *)((char *)&loc_1FE78 + (_QWORD)glfw);
LABEL_15:
if ( v9 )
dlclose(v9);
return v2;
}
v2 = 0;
v6 = (long long ( *)(_QWORD, _DWORD *, _QWORD))v5(0LL, "vkEnumerateInstanceExtensionProperties");
*(_QWORD *)((char *)&loc_1FE90 + (_QWORD)glfw) = v6;
if ( !v6 )
{
glfwInputError(0x10006u, (long long)"Vulkan: Failed to retrieve vkEnumerateInstanceExtensionProperties");
goto LABEL_14;
}
v7 = v6(0LL, v15, 0LL);
if ( v7 )
{
if ( a1 == 2 )
{
VulkanResultString = (const char *)glfwGetVulkanResultString(v7);
glfwInputError(0x10006u, (long long)"Vulkan: Failed to query instance extension count: %s", VulkanResultString);
}
v9 = *(_QWORD *)((char *)&loc_1FE78 + (_QWORD)glfw);
v2 = 0;
goto LABEL_15;
}
v10 = calloc(v15[0], 260LL);
v2 = 0;
v11 = (*(long long ( **)(_QWORD, _DWORD *, long long))((char *)&loc_1FE90 + (_QWORD)glfw))(0LL, v15, v10);
if ( v11 )
{
v12 = (const char *)glfwGetVulkanResultString(v11);
glfwInputError(0x10006u, (long long)"Vulkan: Failed to query instance extensions: %s", v12);
free(v10);
goto LABEL_14;
}
v13 = v15[0];
if ( v15[0] )
{
v14 = v10;
do
{
if ( !(unsigned int)strcmp(v14, "VK_KHR_surface") )
{
*(_DWORD *)((char *)&loc_1FEA0 + (_QWORD)glfw) = 1;
}
else if ( !(unsigned int)strcmp(v14, "VK_KHR_xlib_surface") )
{
glfw[32681] = 1;
}
else if ( !(unsigned int)strcmp(v14, "VK_KHR_xcb_surface") )
{
*(_DWORD *)((char *)&loc_1FEA8 + (_QWORD)glfw) = 1;
}
v14 += 260LL;
--v13;
}
while ( v13 );
}
free(v10);
glfw[32668] = 1;
glfwPlatformGetRequiredInstanceExtensions(&glfw[32672]);
return 1;
}
| _glfwInitVulkan:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
LEA RBX,[0x1a4638]
MOV R14D,0x1
CMP dword ptr [RBX + 0x1fe70],0x0
JZ 0x0011c57f
LAB_0011c56d:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011c57f:
MOV EBP,EDI
LEA RDI,[0x17f87c]
MOV ESI,0x1
CALL 0x0010cb30
MOV qword ptr [RBX + 0x1fe78],RAX
TEST RAX,RAX
JZ 0x0011c618
LEA RSI,[0x17f8c3]
MOV RDI,RAX
CALL 0x0010c820
MOV qword ptr [RBX + 0x1fe98],RAX
TEST RAX,RAX
JZ 0x0011c63f
LEA RSI,[0x17f8f4]
XOR R14D,R14D
XOR EDI,EDI
CALL RAX
MOV qword ptr [RBX + 0x1fe90],RAX
TEST RAX,RAX
JZ 0x0011c64b
LEA RSI,[RSP + 0x4]
XOR EDI,EDI
XOR EDX,EDX
CALL RAX
TEST EAX,EAX
JZ 0x0011c678
CMP EBP,0x2
JNZ 0x0011c60c
MOV EDI,EAX
CALL 0x0011c788
LEA RSI,[0x17f91b]
MOV EDI,0x10006
MOV RDX,RAX
XOR EAX,EAX
CALL 0x00119081
LAB_0011c60c:
MOV RDI,qword ptr [RBX + 0x1fe78]
XOR R14D,R14D
JMP 0x0011c665
LAB_0011c618:
XOR R14D,R14D
CMP EBP,0x2
JNZ 0x0011c56d
LEA RSI,[0x17f88b]
XOR R14D,R14D
MOV EDI,0x10006
XOR EAX,EAX
CALL 0x00119081
JMP 0x0011c56d
LAB_0011c63f:
LEA RSI,[0x17f8a4]
XOR R14D,R14D
JMP 0x0011c652
LAB_0011c64b:
LEA RSI,[0x17f8d9]
LAB_0011c652:
MOV EDI,0x10006
XOR EAX,EAX
CALL 0x00119081
LAB_0011c65e:
MOV RDI,qword ptr [RBX + 0x1fe78]
LAB_0011c665:
TEST RDI,RDI
JZ 0x0011c56d
CALL 0x0010c670
JMP 0x0011c56d
LAB_0011c678:
LEA R12,[RSP + 0x4]
MOV EDI,dword ptr [R12]
MOV ESI,0x104
CALL 0x0010c550
MOV R15,RAX
XOR R14D,R14D
XOR EDI,EDI
MOV RSI,R12
MOV RDX,RAX
CALL qword ptr [RBX + 0x1fe90]
TEST EAX,EAX
JZ 0x0011c6ca
MOV EDI,EAX
CALL 0x0011c788
LEA RSI,[0x17f950]
MOV EDI,0x10006
MOV RDX,RAX
XOR EAX,EAX
CALL 0x00119081
MOV RDI,R15
CALL 0x0010ca50
JMP 0x0011c65e
LAB_0011c6ca:
MOV R13D,dword ptr [RSP + 0x4]
TEST R13,R13
JZ 0x0011c744
LEA R14,[0x17f980]
LEA R12,[0x17f98f]
MOV RBP,R15
LAB_0011c6e5:
MOV RDI,RBP
MOV RSI,R14
CALL 0x0010cb50
TEST EAX,EAX
JZ 0x0011c722
MOV RDI,RBP
MOV RSI,R12
CALL 0x0010cb50
TEST EAX,EAX
JZ 0x0011c72e
MOV RDI,RBP
LEA RSI,[0x17f9a3]
CALL 0x0010cb50
TEST EAX,EAX
JNZ 0x0011c738
MOV dword ptr [RBX + 0x1fea8],0x1
JMP 0x0011c738
LAB_0011c722:
MOV dword ptr [RBX + 0x1fea0],0x1
JMP 0x0011c738
LAB_0011c72e:
MOV dword ptr [RBX + 0x1fea4],0x1
LAB_0011c738:
ADD RBP,0x104
DEC R13
JNZ 0x0011c6e5
LAB_0011c744:
MOV RDI,R15
CALL 0x0010ca50
MOV dword ptr [RBX + 0x1fe70],0x1
ADD RBX,0x1fe80
MOV RDI,RBX
CALL 0x001258e3
MOV R14D,0x1
JMP 0x0011c56d
|
int8 _glfwInitVulkan(int param_1)
{
int iVar1;
ulong in_RAX;
int8 uVar2;
char *pcVar3;
char *__s1;
ulong uVar4;
int8 uStack_38;
if (DAT_001c44a8 != 0) {
return 1;
}
uStack_38 = in_RAX;
DAT_001c44b0 = dlopen("libvulkan.so.1",1);
if (DAT_001c44b0 == 0) {
if (param_1 != 2) {
return 0;
}
_glfwInputError(0x10006,"Vulkan: Loader not found");
return 0;
}
DAT_001c44d0 = (code *)dlsym(DAT_001c44b0,"vkGetInstanceProcAddr");
if (DAT_001c44d0 == (code *)0x0) {
pcVar3 = "Vulkan: Loader does not export vkGetInstanceProcAddr";
}
else {
DAT_001c44c8 = (code *)(*DAT_001c44d0)(0,"vkEnumerateInstanceExtensionProperties");
if (DAT_001c44c8 != (code *)0x0) {
iVar1 = (*DAT_001c44c8)(0,(long)&uStack_38 + 4,0);
if (iVar1 == 0) {
pcVar3 = (char *)calloc(uStack_38 >> 0x20,0x104);
iVar1 = (*DAT_001c44c8)(0,(long)&uStack_38 + 4,pcVar3);
if (iVar1 == 0) {
__s1 = pcVar3;
for (uVar4 = (ulong)uStack_38._4_4_; uVar4 != 0; uVar4 = uVar4 - 1) {
iVar1 = strcmp(__s1,"VK_KHR_surface");
if (iVar1 == 0) {
DAT_001c44d8 = 1;
}
else {
iVar1 = strcmp(__s1,"VK_KHR_xlib_surface");
if (iVar1 == 0) {
DAT_001c44dc = 1;
}
else {
iVar1 = strcmp(__s1,"VK_KHR_xcb_surface");
if (iVar1 == 0) {
DAT_001c44e0 = 1;
}
}
}
__s1 = __s1 + 0x104;
}
free(pcVar3);
DAT_001c44a8 = 1;
_glfwPlatformGetRequiredInstanceExtensions(&DAT_001c44b8);
return 1;
}
uVar2 = _glfwGetVulkanResultString(iVar1);
_glfwInputError(0x10006,"Vulkan: Failed to query instance extensions: %s",uVar2);
free(pcVar3);
}
else if (param_1 == 2) {
uVar2 = _glfwGetVulkanResultString(iVar1);
_glfwInputError(0x10006,"Vulkan: Failed to query instance extension count: %s",uVar2);
}
goto LAB_0011c665;
}
pcVar3 = "Vulkan: Failed to retrieve vkEnumerateInstanceExtensionProperties";
}
_glfwInputError(0x10006,pcVar3);
LAB_0011c665:
if (DAT_001c44b0 != 0) {
dlclose();
}
return 0;
}
| |
24,110 | my_ll10tostr_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static size_t
my_ll10tostr_mb2_or_mb4(CHARSET_INFO *cs,
char *dst, size_t len, int radix, longlong val)
{
char buffer[65];
register char *p, *db, *de;
long long_val;
int sl= 0;
ulonglong uval= (ulonglong) val;
if (radix < 0)
{
if (val < 0)
{
sl= 1;
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (ulonglong)0 - uval;
}
}
p= &buffer[sizeof(buffer)-1];
*p='\0';
if (uval == 0)
{
*--p= '0';
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;
}
cnv:
if (sl)
{
*--p= '-';
}
for ( db= dst, de= dst + len ; (dst < de) && *p ; p++)
{
int cnvres= my_ci_wc_mb(cs, (my_wc_t) p[0], (uchar*) dst, (uchar*) de);
if (cnvres > 0)
dst+= cnvres;
else
break;
}
return (int) (dst -db);
} | O0 | c | my_ll10tostr_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movq %rdx, -0x68(%rbp)
movl %ecx, -0x6c(%rbp)
movq %r8, -0x78(%rbp)
movl $0x0, -0x9c(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpl $0x0, -0x6c(%rbp)
jge 0xeebe9
cmpq $0x0, -0x78(%rbp)
jge 0xeebe7
movl $0x1, -0x9c(%rbp)
xorl %eax, %eax
subq -0xa8(%rbp), %rax
movq %rax, -0xa8(%rbp)
jmp 0xeebe9
leaq -0x50(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0xa8(%rbp)
jne 0xeec1e
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x80(%rbp)
movb $0x30, -0x1(%rax)
jmp 0xeecfc
jmp 0xeec20
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0xa8(%rbp)
jbe 0xeec90
movq -0xa8(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rax
imulq $0xa, -0xb0(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
addl $0x30, %eax
movb %al, %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, -0x1(%rax)
movq -0xb0(%rbp), %rax
movq %rax, -0xa8(%rbp)
jmp 0xeec20
movq -0xa8(%rbp), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0xeecfa
movq -0x98(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0xc0(%rbp)
movq -0x98(%rbp), %rax
imulq $0xa, -0xc0(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rax
movb %al, %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, -0x1(%rax)
movq -0xc0(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0xeec9e
jmp 0xeecfc
cmpl $0x0, -0x9c(%rbp)
je 0xeed18
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x80(%rbp)
movb $0x2d, -0x1(%rax)
movq -0x60(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x60(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x60(%rbp), %rcx
xorl %eax, %eax
cmpq -0x90(%rbp), %rcx
movb %al, -0xc5(%rbp)
jae 0xeed5a
movq -0x80(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xc5(%rbp)
movb -0xc5(%rbp), %al
testb $0x1, %al
jne 0xeed66
jmp 0xeedc8
movq -0x58(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x30(%rax), %rax
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rcx
movsbq (%rcx), %rsi
movq -0x60(%rbp), %rdx
movq -0x90(%rbp), %rcx
callq *%rax
movl %eax, -0xc4(%rbp)
cmpl $0x0, -0xc4(%rbp)
jle 0xeedb3
movl -0xc4(%rbp), %ecx
movq -0x60(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
jmp 0xeedb5
jmp 0xeedc8
jmp 0xeedb7
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0xeed32
movl -0x60(%rbp), %eax
movl -0x88(%rbp), %ecx
subl %ecx, %eax
cltq
movq %rax, -0xd0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xeedfe
movq -0xd0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
callq 0x3b340
nopw %cs:(%rax,%rax)
| my_ll10tostr_mb2_or_mb4:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov [rbp+var_6C], ecx
mov [rbp+var_78], r8
mov [rbp+var_9C], 0
mov rax, [rbp+var_78]
mov [rbp+var_A8], rax
cmp [rbp+var_6C], 0
jge short loc_EEBE9
cmp [rbp+var_78], 0
jge short loc_EEBE7
mov [rbp+var_9C], 1
xor eax, eax
sub rax, [rbp+var_A8]
mov [rbp+var_A8], rax
loc_EEBE7:
jmp short $+2
loc_EEBE9:
lea rax, [rbp+var_50]
add rax, 40h ; '@'
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
mov byte ptr [rax], 0
cmp [rbp+var_A8], 0
jnz short loc_EEC1E
mov rax, [rbp+var_80]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rcx
mov byte ptr [rax-1], 30h ; '0'
jmp loc_EECFC
loc_EEC1E:
jmp short $+2
loc_EEC20:
mov rax, 7FFFFFFFFFFFFFFFh
cmp [rbp+var_A8], rax
jbe short loc_EEC90
mov rax, [rbp+var_A8]
mov ecx, 0Ah
xor edx, edx
div rcx
mov [rbp+var_B0], rax
mov rax, [rbp+var_A8]
imul rcx, [rbp+var_B0], 0Ah
sub rax, rcx
mov [rbp+var_B4], eax
mov eax, [rbp+var_B4]
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_80]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rdx
mov [rax-1], cl
mov rax, [rbp+var_B0]
mov [rbp+var_A8], rax
jmp short loc_EEC20
loc_EEC90:
mov rax, [rbp+var_A8]
mov [rbp+var_98], rax
loc_EEC9E:
cmp [rbp+var_98], 0
jz short loc_EECFA
mov rax, [rbp+var_98]
mov ecx, 0Ah
cqo
idiv rcx
mov [rbp+var_C0], rax
mov rax, [rbp+var_98]
imul rcx, [rbp+var_C0], 0Ah
sub rax, rcx
add rax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_80]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rdx
mov [rax-1], cl
mov rax, [rbp+var_C0]
mov [rbp+var_98], rax
jmp short loc_EEC9E
loc_EECFA:
jmp short $+2
loc_EECFC:
cmp [rbp+var_9C], 0
jz short loc_EED18
mov rax, [rbp+var_80]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rcx
mov byte ptr [rax-1], 2Dh ; '-'
loc_EED18:
mov rax, [rbp+var_60]
mov [rbp+var_88], rax
mov rax, [rbp+var_60]
add rax, [rbp+var_68]
mov [rbp+var_90], rax
loc_EED32:
mov rcx, [rbp+var_60]
xor eax, eax
cmp rcx, [rbp+var_90]
mov [rbp+var_C5], al
jnb short loc_EED5A
mov rax, [rbp+var_80]
movsx eax, byte ptr [rax]
cmp eax, 0
setnz al
mov [rbp+var_C5], al
loc_EED5A:
mov al, [rbp+var_C5]
test al, 1
jnz short loc_EED66
jmp short loc_EEDC8
loc_EED66:
mov rax, [rbp+var_58]
mov rax, [rax+0B8h]
mov rax, [rax+30h]
mov rdi, [rbp+var_58]
mov rcx, [rbp+var_80]
movsx rsi, byte ptr [rcx]
mov rdx, [rbp+var_60]
mov rcx, [rbp+var_90]
call rax
mov [rbp+var_C4], eax
cmp [rbp+var_C4], 0
jle short loc_EEDB3
mov ecx, [rbp+var_C4]
mov rax, [rbp+var_60]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_60], rax
jmp short loc_EEDB5
loc_EEDB3:
jmp short loc_EEDC8
loc_EEDB5:
jmp short $+2
loc_EEDB7:
mov rax, [rbp+var_80]
add rax, 1
mov [rbp+var_80], rax
jmp loc_EED32
loc_EEDC8:
mov eax, dword ptr [rbp+var_60]
mov ecx, dword ptr [rbp+var_88]
sub eax, ecx
cdqe
mov [rbp+var_D0], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_EEDFE
mov rax, [rbp+var_D0]
add rsp, 0D0h
pop rbp
retn
loc_EEDFE:
call ___stack_chk_fail
| long long my_ll10tostr_mb2_or_mb4(long long a1, unsigned long long a2, long long a3, int a4, long long a5)
{
char *v5; // rax
char *v6; // rax
char *v7; // rax
bool v9; // [rsp+Bh] [rbp-C5h]
int v10; // [rsp+Ch] [rbp-C4h]
unsigned long long v11; // [rsp+28h] [rbp-A8h]
int v12; // [rsp+34h] [rbp-9Ch]
signed long long i; // [rsp+38h] [rbp-98h]
unsigned long long v14; // [rsp+40h] [rbp-90h]
char *v15; // [rsp+50h] [rbp-80h]
unsigned long long v16; // [rsp+70h] [rbp-60h]
char v17; // [rsp+BFh] [rbp-11h] BYREF
char v18; // [rsp+C0h] [rbp-10h] BYREF
unsigned long long v19; // [rsp+C8h] [rbp-8h]
v19 = __readfsqword(0x28u);
v16 = a2;
v12 = 0;
v11 = a5;
if ( a4 < 0 && a5 < 0 )
{
v12 = 1;
v11 = -a5;
}
v15 = &v18;
v18 = 0;
if ( v11 )
{
while ( v11 > 0x7FFFFFFFFFFFFFFFLL )
{
v5 = v15--;
*(v5 - 1) = v11 % 0xA + 48;
v11 /= 0xAuLL;
}
for ( i = v11; i; i /= 10LL )
{
v6 = v15--;
*(v6 - 1) = i % 10 + 48;
}
}
else
{
v15 = &v17;
v17 = 48;
}
if ( v12 )
{
v7 = v15--;
*(v7 - 1) = 45;
}
v14 = a3 + a2;
while ( 1 )
{
v9 = 0;
if ( v16 < v14 )
v9 = *v15 != 0;
if ( !v9 )
break;
v10 = (*(long long ( **)(long long, _QWORD, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 48LL))(
a1,
*v15,
v16,
v14);
if ( v10 <= 0 )
break;
v16 += v10;
++v15;
}
return (int)v16 - (int)a2;
}
| my_ll10tostr_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV qword ptr [RBP + -0x68],RDX
MOV dword ptr [RBP + -0x6c],ECX
MOV qword ptr [RBP + -0x78],R8
MOV dword ptr [RBP + -0x9c],0x0
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0xa8],RAX
CMP dword ptr [RBP + -0x6c],0x0
JGE 0x001eebe9
CMP qword ptr [RBP + -0x78],0x0
JGE 0x001eebe7
MOV dword ptr [RBP + -0x9c],0x1
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0xa8],RAX
LAB_001eebe7:
JMP 0x001eebe9
LAB_001eebe9:
LEA RAX,[RBP + -0x50]
ADD RAX,0x40
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV byte ptr [RAX],0x0
CMP qword ptr [RBP + -0xa8],0x0
JNZ 0x001eec1e
MOV RAX,qword ptr [RBP + -0x80]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RBP + -0x80],RCX
MOV byte ptr [RAX + -0x1],0x30
JMP 0x001eecfc
LAB_001eec1e:
JMP 0x001eec20
LAB_001eec20:
MOV RAX,0x7fffffffffffffff
CMP qword ptr [RBP + -0xa8],RAX
JBE 0x001eec90
MOV RAX,qword ptr [RBP + -0xa8]
MOV ECX,0xa
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0xa8]
IMUL RCX,qword ptr [RBP + -0xb0],0xa
SUB RAX,RCX
MOV dword ptr [RBP + -0xb4],EAX
MOV EAX,dword ptr [RBP + -0xb4]
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0xb0]
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x001eec20
LAB_001eec90:
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0x98],RAX
LAB_001eec9e:
CMP qword ptr [RBP + -0x98],0x0
JZ 0x001eecfa
MOV RAX,qword ptr [RBP + -0x98]
MOV ECX,0xa
CQO
IDIV RCX
MOV qword ptr [RBP + -0xc0],RAX
MOV RAX,qword ptr [RBP + -0x98]
IMUL RCX,qword ptr [RBP + -0xc0],0xa
SUB RAX,RCX
ADD RAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0xc0]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001eec9e
LAB_001eecfa:
JMP 0x001eecfc
LAB_001eecfc:
CMP dword ptr [RBP + -0x9c],0x0
JZ 0x001eed18
MOV RAX,qword ptr [RBP + -0x80]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RBP + -0x80],RCX
MOV byte ptr [RAX + -0x1],0x2d
LAB_001eed18:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x90],RAX
LAB_001eed32:
MOV RCX,qword ptr [RBP + -0x60]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x90]
MOV byte ptr [RBP + -0xc5],AL
JNC 0x001eed5a
MOV RAX,qword ptr [RBP + -0x80]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0xc5],AL
LAB_001eed5a:
MOV AL,byte ptr [RBP + -0xc5]
TEST AL,0x1
JNZ 0x001eed66
JMP 0x001eedc8
LAB_001eed66:
MOV RAX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x80]
MOVSX RSI,byte ptr [RCX]
MOV RDX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x90]
CALL RAX
MOV dword ptr [RBP + -0xc4],EAX
CMP dword ptr [RBP + -0xc4],0x0
JLE 0x001eedb3
MOV ECX,dword ptr [RBP + -0xc4]
MOV RAX,qword ptr [RBP + -0x60]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001eedb5
LAB_001eedb3:
JMP 0x001eedc8
LAB_001eedb5:
JMP 0x001eedb7
LAB_001eedb7:
MOV RAX,qword ptr [RBP + -0x80]
ADD RAX,0x1
MOV qword ptr [RBP + -0x80],RAX
JMP 0x001eed32
LAB_001eedc8:
MOV EAX,dword ptr [RBP + -0x60]
MOV ECX,dword ptr [RBP + -0x88]
SUB EAX,ECX
CDQE
MOV qword ptr [RBP + -0xd0],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001eedfe
MOV RAX,qword ptr [RBP + -0xd0]
ADD RSP,0xd0
POP RBP
RET
LAB_001eedfe:
CALL 0x0013b340
|
long my_ll10tostr_mb2_or_mb4(long param_1,ulong param_2,long param_3,int param_4,ulong param_5)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
ulong local_b0;
ulong local_a0;
int local_90;
char *local_88;
ulong local_68;
char local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
bVar2 = false;
local_b0 = param_5;
if ((param_4 < 0) && (bVar2 = (long)param_5 < 0, bVar2)) {
local_b0 = -param_5;
}
local_88 = local_19 + 1;
local_19[1] = 0;
if (local_b0 == 0) {
local_88 = local_19;
local_19[0] = '0';
}
else {
while (0x7fffffffffffffff < local_b0) {
local_88[-1] = (char)local_b0 + (char)(local_b0 / 10) * -10 + '0';
local_b0 = local_b0 / 10;
local_88 = local_88 + -1;
}
local_a0 = local_b0;
while (local_a0 != 0) {
local_88[-1] = (char)local_a0 + (char)((long)local_a0 / 10) * -10 + '0';
local_a0 = (long)local_a0 / 10;
local_88 = local_88 + -1;
}
}
if (bVar2) {
local_88[-1] = '-';
local_88 = local_88 + -1;
}
local_68 = param_2;
while( true ) {
bVar2 = false;
if (local_68 < param_2 + param_3) {
bVar2 = *local_88 != '\0';
}
if ((!bVar2) ||
(iVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x30))
(param_1,(long)*local_88,local_68,param_2 + param_3), iVar1 < 1)) break;
local_68 = local_68 + (long)iVar1;
local_88 = local_88 + 1;
}
local_90 = (int)param_2;
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (long)((int)local_68 - local_90);
}
| |
24,111 | trnman_destroy | eloqsql/storage/maria/trnman.c | void trnman_destroy()
{
DBUG_ENTER("trnman_destroy");
if (short_trid_to_active_trn == NULL) /* trnman already destroyed */
DBUG_VOID_RETURN;
DBUG_ASSERT(trid_to_trn.count == 0);
DBUG_ASSERT(trnman_active_transactions == 0);
DBUG_ASSERT(trnman_committed_transactions == 0);
DBUG_ASSERT(active_list_max.prev == &active_list_min);
DBUG_ASSERT(active_list_min.next == &active_list_max);
DBUG_ASSERT(committed_list_max.prev == &committed_list_min);
DBUG_ASSERT(committed_list_min.next == &committed_list_max);
while (pool)
{
TRN *trn= pool;
pool= pool->next;
DBUG_ASSERT(trn->wt == NULL);
mysql_mutex_destroy(&trn->state_lock);
my_free(trn);
}
lf_hash_destroy(&trid_to_trn);
DBUG_PRINT("info", ("mysql_mutex_destroy LOCK_trn_list"));
mysql_mutex_destroy(&LOCK_trn_list);
my_free(short_trid_to_active_trn+1);
short_trid_to_active_trn= NULL;
DBUG_VOID_RETURN;
} | O0 | c | trnman_destroy:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x42ae20(%rip) # 0x476d70
jne 0x4bf59
jmp 0x4bf54
jmp 0x4bfef
jmp 0x4bf5b
jmp 0x4bf5d
jmp 0x4bf5f
jmp 0x4bf61
jmp 0x4bf63
jmp 0x4bf65
jmp 0x4bf67
jmp 0x4bf69
jmp 0x4bf6b
jmp 0x4bf6d
jmp 0x4bf6f
jmp 0x4bf71
jmp 0x4bf73
jmp 0x4bf75
jmp 0x4bf77
cmpq $0x0, 0x42b0c9(%rip) # 0x477048
je 0x4bfb8
movq 0x42b0c0(%rip), %rax # 0x477048
movq %rax, -0x8(%rbp)
movq 0x42b0b5(%rip), %rax # 0x477048
movq 0x68(%rax), %rax
movq %rax, 0x42b0aa(%rip) # 0x477048
jmp 0x4bfa0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x4c000
movq -0x8(%rbp), %rdi
callq 0xf3590
jmp 0x4bf77
leaq 0x42b099(%rip), %rdi # 0x477058
callq 0xfce60
jmp 0x4bfc6
leaq 0x42b153(%rip), %rdi # 0x477120
callq 0x4c000
movq 0x42ad97(%rip), %rdi # 0x476d70
addq $0x8, %rdi
callq 0xf3590
movq $0x0, 0x42ad83(%rip) # 0x476d70
jmp 0x4bfef
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| trnman_destroy:
push rbp
mov rbp, rsp
sub rsp, 10h
cmp cs:short_trid_to_active_trn, 0
jnz short loc_4BF59
jmp short $+2
loc_4BF54:
jmp loc_4BFEF
loc_4BF59:
jmp short $+2
loc_4BF5B:
jmp short $+2
loc_4BF5D:
jmp short $+2
loc_4BF5F:
jmp short $+2
loc_4BF61:
jmp short $+2
loc_4BF63:
jmp short $+2
loc_4BF65:
jmp short $+2
loc_4BF67:
jmp short $+2
loc_4BF69:
jmp short $+2
loc_4BF6B:
jmp short $+2
loc_4BF6D:
jmp short $+2
loc_4BF6F:
jmp short $+2
loc_4BF71:
jmp short $+2
loc_4BF73:
jmp short $+2
loc_4BF75:
jmp short $+2
loc_4BF77:
cmp cs:pool, 0
jz short loc_4BFB8
mov rax, cs:pool
mov [rbp+var_8], rax
mov rax, cs:pool
mov rax, [rax+68h]
mov cs:pool, rax
jmp short $+2
loc_4BFA0:
mov rdi, [rbp+var_8]
add rdi, 10h
call inline_mysql_mutex_destroy_2
mov rdi, [rbp+var_8]
call my_free
jmp short loc_4BF77
loc_4BFB8:
lea rdi, trid_to_trn
call lf_hash_destroy
jmp short $+2
loc_4BFC6:
lea rdi, LOCK_trn_list
call inline_mysql_mutex_destroy_2
mov rdi, cs:short_trid_to_active_trn
add rdi, 8
call my_free
mov cs:short_trid_to_active_trn, 0
jmp short $+2
loc_4BFEF:
add rsp, 10h
pop rbp
retn
| long long trnman_destroy()
{
long long result; // rax
long long v1; // [rsp+8h] [rbp-8h]
if ( short_trid_to_active_trn )
{
while ( pool )
{
v1 = pool;
pool = *(_QWORD *)(pool + 104);
inline_mysql_mutex_destroy_2(v1 + 16);
my_free(v1);
}
lf_hash_destroy(&trid_to_trn);
inline_mysql_mutex_destroy_2(&LOCK_trn_list);
result = my_free(short_trid_to_active_trn + 8);
short_trid_to_active_trn = 0LL;
}
return result;
}
| trnman_destroy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
CMP qword ptr [0x00576d70],0x0
JNZ 0x0014bf59
JMP 0x0014bf54
LAB_0014bf54:
JMP 0x0014bfef
LAB_0014bf59:
JMP 0x0014bf5b
LAB_0014bf5b:
JMP 0x0014bf5d
LAB_0014bf5d:
JMP 0x0014bf5f
LAB_0014bf5f:
JMP 0x0014bf61
LAB_0014bf61:
JMP 0x0014bf63
LAB_0014bf63:
JMP 0x0014bf65
LAB_0014bf65:
JMP 0x0014bf67
LAB_0014bf67:
JMP 0x0014bf69
LAB_0014bf69:
JMP 0x0014bf6b
LAB_0014bf6b:
JMP 0x0014bf6d
LAB_0014bf6d:
JMP 0x0014bf6f
LAB_0014bf6f:
JMP 0x0014bf71
LAB_0014bf71:
JMP 0x0014bf73
LAB_0014bf73:
JMP 0x0014bf75
LAB_0014bf75:
JMP 0x0014bf77
LAB_0014bf77:
CMP qword ptr [0x00577048],0x0
JZ 0x0014bfb8
MOV RAX,qword ptr [0x00577048]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [0x00577048]
MOV RAX,qword ptr [RAX + 0x68]
MOV qword ptr [0x00577048],RAX
JMP 0x0014bfa0
LAB_0014bfa0:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x10
CALL 0x0014c000
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001f3590
JMP 0x0014bf77
LAB_0014bfb8:
LEA RDI,[0x577058]
CALL 0x001fce60
JMP 0x0014bfc6
LAB_0014bfc6:
LEA RDI,[0x577120]
CALL 0x0014c000
MOV RDI,qword ptr [0x00576d70]
ADD RDI,0x8
CALL 0x001f3590
MOV qword ptr [0x00576d70],0x0
JMP 0x0014bfef
LAB_0014bfef:
ADD RSP,0x10
POP RBP
RET
|
void trnman_destroy(void)
{
long lVar1;
long lVar2;
if (short_trid_to_active_trn != 0) {
while (lVar1 = pool, pool != 0) {
lVar2 = pool + 0x10;
pool = *(long *)(pool + 0x68);
inline_mysql_mutex_destroy(lVar2);
my_free(lVar1);
}
lf_hash_destroy(trid_to_trn);
inline_mysql_mutex_destroy(LOCK_trn_list);
my_free(short_trid_to_active_trn + 8);
short_trid_to_active_trn = 0;
}
return;
}
| |
24,112 | trnman_destroy | eloqsql/storage/maria/trnman.c | void trnman_destroy()
{
DBUG_ENTER("trnman_destroy");
if (short_trid_to_active_trn == NULL) /* trnman already destroyed */
DBUG_VOID_RETURN;
DBUG_ASSERT(trid_to_trn.count == 0);
DBUG_ASSERT(trnman_active_transactions == 0);
DBUG_ASSERT(trnman_committed_transactions == 0);
DBUG_ASSERT(active_list_max.prev == &active_list_min);
DBUG_ASSERT(active_list_min.next == &active_list_max);
DBUG_ASSERT(committed_list_max.prev == &committed_list_min);
DBUG_ASSERT(committed_list_min.next == &committed_list_max);
while (pool)
{
TRN *trn= pool;
pool= pool->next;
DBUG_ASSERT(trn->wt == NULL);
mysql_mutex_destroy(&trn->state_lock);
my_free(trn);
}
lf_hash_destroy(&trid_to_trn);
DBUG_PRINT("info", ("mysql_mutex_destroy LOCK_trn_list"));
mysql_mutex_destroy(&LOCK_trn_list);
my_free(short_trid_to_active_trn+1);
short_trid_to_active_trn= NULL;
DBUG_VOID_RETURN;
} | O3 | c | trnman_destroy:
cmpq $0x0, 0x3b6c8b(%rip) # 0x3fd170
je 0x4659f
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x3b6f4f(%rip), %rbx # 0x3fd448
testq %rbx, %rbx
je 0x46544
leaq 0x33fb0b(%rip), %r14 # 0x386010
movq 0x68(%rbx), %rax
movq %rax, 0x3b6f38(%rip) # 0x3fd448
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x46527
movq (%r14), %rax
callq *0x48(%rax)
movq $0x0, 0x50(%rbx)
leaq 0x10(%rbx), %rdi
callq 0x290c0
movq %rbx, %rdi
callq 0x9fb2e
movq 0x3b6f09(%rip), %rbx # 0x3fd448
testq %rbx, %rbx
jne 0x46505
leaq 0x3b6f0d(%rip), %rdi # 0x3fd458
callq 0xa5876
movq 0x3b7009(%rip), %rdi # 0x3fd560
testq %rdi, %rdi
je 0x46574
leaq 0x33faad(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x3b6fec(%rip) # 0x3fd560
leaq 0x3b6fa5(%rip), %rdi # 0x3fd520
callq 0x290c0
movq 0x3b6be9(%rip), %rdi # 0x3fd170
addq $0x8, %rdi
callq 0x9fb2e
movq $0x0, 0x3b6bd5(%rip) # 0x3fd170
popq %rbx
popq %r14
popq %rbp
retq
| trnman_destroy:
cmp cs:short_trid_to_active_trn, 0
jz locret_4659F
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, cs:pool
test rbx, rbx
jz short loc_46544
lea r14, PSI_server
loc_46505:
mov rax, [rbx+68h]
mov cs:pool, rax
mov rdi, [rbx+50h]
test rdi, rdi
jz short loc_46527
mov rax, [r14]
call qword ptr [rax+48h]
mov qword ptr [rbx+50h], 0
loc_46527:
lea rdi, [rbx+10h]
call _pthread_mutex_destroy
mov rdi, rbx
call my_free
mov rbx, cs:pool
test rbx, rbx
jnz short loc_46505
loc_46544:
lea rdi, trid_to_trn
call lf_hash_destroy
mov rdi, cs:qword_3FD560
test rdi, rdi
jz short loc_46574
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov cs:qword_3FD560, 0
loc_46574:
lea rdi, LOCK_trn_list
call _pthread_mutex_destroy
mov rdi, cs:short_trid_to_active_trn
add rdi, 8
call my_free
mov cs:short_trid_to_active_trn, 0
pop rbx
pop r14
pop rbp
locret_4659F:
retn
| long long trnman_destroy()
{
long long i; // rbx
long long result; // rax
if ( short_trid_to_active_trn )
{
for ( i = pool; pool; i = pool )
{
pool = *(_QWORD *)(i + 104);
if ( *(_QWORD *)(i + 80) )
{
PSI_server[9]();
*(_QWORD *)(i + 80) = 0LL;
}
pthread_mutex_destroy(i + 16);
my_free(i);
}
lf_hash_destroy(&trid_to_trn);
if ( qword_3FD560 )
{
PSI_server[9]();
qword_3FD560 = 0LL;
}
pthread_mutex_destroy(&LOCK_trn_list);
result = my_free(short_trid_to_active_trn + 8);
short_trid_to_active_trn = 0LL;
}
return result;
}
| trnman_destroy:
CMP qword ptr [0x004fd170],0x0
JZ 0x0014659f
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,qword ptr [0x004fd448]
TEST RBX,RBX
JZ 0x00146544
LEA R14,[0x486010]
LAB_00146505:
MOV RAX,qword ptr [RBX + 0x68]
MOV qword ptr [0x004fd448],RAX
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JZ 0x00146527
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x50],0x0
LAB_00146527:
LEA RDI,[RBX + 0x10]
CALL 0x001290c0
MOV RDI,RBX
CALL 0x0019fb2e
MOV RBX,qword ptr [0x004fd448]
TEST RBX,RBX
JNZ 0x00146505
LAB_00146544:
LEA RDI,[0x4fd458]
CALL 0x001a5876
MOV RDI,qword ptr [0x004fd560]
TEST RDI,RDI
JZ 0x00146574
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [0x004fd560],0x0
LAB_00146574:
LEA RDI,[0x4fd520]
CALL 0x001290c0
MOV RDI,qword ptr [0x004fd170]
ADD RDI,0x8
CALL 0x0019fb2e
MOV qword ptr [0x004fd170],0x0
POP RBX
POP R14
POP RBP
LAB_0014659f:
RET
|
void trnman_destroy(void)
{
long lVar1;
if (short_trid_to_active_trn != 0) {
lVar1 = pool;
if (pool != 0) {
do {
pool = *(long *)(lVar1 + 0x68);
if (*(long *)(lVar1 + 0x50) != 0) {
(**(code **)(PSI_server + 0x48))();
*(int8 *)(lVar1 + 0x50) = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)(lVar1 + 0x10));
my_free(lVar1);
lVar1 = pool;
} while (pool != 0);
}
lf_hash_destroy(trid_to_trn);
if (LOCK_trn_list._64_8_ != 0) {
(**(code **)(PSI_server + 0x48))();
LOCK_trn_list._64_8_ = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)LOCK_trn_list);
my_free(short_trid_to_active_trn + 8);
short_trid_to_active_trn = 0;
}
return;
}
| |
24,113 | my_init_mysys_psi_keys | eloqsql/mysys/my_init.c | void my_init_mysys_psi_keys()
{
const char* category= "mysys";
int count;
count= sizeof(all_mysys_mutexes)/sizeof(all_mysys_mutexes[0]);
mysql_mutex_register(category, all_mysys_mutexes, count);
count= sizeof(all_mysys_conds)/sizeof(all_mysys_conds[0]);
mysql_cond_register(category, all_mysys_conds, count);
count= sizeof(all_mysys_rwlocks)/sizeof(all_mysys_rwlocks[0]);
mysql_rwlock_register(category, all_mysys_rwlocks, count);
count= sizeof(all_mysys_threads)/sizeof(all_mysys_threads[0]);
mysql_thread_register(category, all_mysys_threads, count);
count= sizeof(all_mysys_files)/sizeof(all_mysys_files[0]);
mysql_file_register(category, all_mysys_files, count);
count= array_elements(all_mysys_stages);
mysql_stage_register(category, all_mysys_stages, count);
} | O3 | c | my_init_mysys_psi_keys:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x2cc7e7(%rip), %r14 # 0x2f9888
movq (%r14), %rax
leaq 0x378a7(%rip), %rbx # 0x64952
leaq 0x2cbfee(%rip), %rsi # 0x2f90a0
movq %rbx, %rdi
movl $0x13, %edx
callq *(%rax)
movq (%r14), %rax
leaq 0x2cc1aa(%rip), %rsi # 0x2f9270
movq %rbx, %rdi
movl $0x7, %edx
callq *0x10(%rax)
movq (%r14), %rax
leaq 0x2cc245(%rip), %rsi # 0x2f9320
movq %rbx, %rdi
movl $0x1, %edx
callq *0x8(%rax)
movq (%r14), %rax
leaq 0x2cc250(%rip), %rsi # 0x2f9340
movq %rbx, %rdi
movl $0x1, %edx
callq *0x18(%rax)
movq (%r14), %rax
leaq 0x2cc25b(%rip), %rsi # 0x2f9360
movq %rbx, %rdi
movl $0x2, %edx
callq *0x20(%rax)
movq (%r14), %rax
movq 0x28(%rax), %rax
leaq 0x2cbf72(%rip), %rsi # 0x2f9090
movq %rbx, %rdi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
| my_init_mysys_psi_keys:
push rbp
mov rbp, rsp
push r14
push rbx
lea r14, PSI_server
mov rax, [r14]
lea rbx, aMysys; "mysys"
lea rsi, all_mysys_mutexes
mov rdi, rbx
mov edx, 13h
call qword ptr [rax]
mov rax, [r14]
lea rsi, all_mysys_conds
mov rdi, rbx
mov edx, 7
call qword ptr [rax+10h]
mov rax, [r14]
lea rsi, all_mysys_rwlocks
mov rdi, rbx
mov edx, 1
call qword ptr [rax+8]
mov rax, [r14]
lea rsi, all_mysys_threads
mov rdi, rbx
mov edx, 1
call qword ptr [rax+18h]
mov rax, [r14]
lea rsi, all_mysys_files
mov rdi, rbx
mov edx, 2
call qword ptr [rax+20h]
mov rax, [r14]
mov rax, [rax+28h]
lea rsi, all_mysys_stages
mov rdi, rbx
mov edx, 1
pop rbx
pop r14
pop rbp
jmp rax
| long long my_init_mysys_psi_keys()
{
(*(void ( **)(const char *, _UNKNOWN **, long long))PSI_server[0])("mysys", &all_mysys_mutexes, 19LL);
(*((void ( **)(const char *, _UNKNOWN **, long long))PSI_server[0] + 2))("mysys", &all_mysys_conds, 7LL);
(*((void ( **)(const char *, _UNKNOWN **, long long))PSI_server[0] + 1))("mysys", &all_mysys_rwlocks, 1LL);
(*((void ( **)(const char *, _UNKNOWN **, long long))PSI_server[0] + 3))("mysys", &all_mysys_threads, 1LL);
(*((void ( **)(const char *, _UNKNOWN **, long long))PSI_server[0] + 4))("mysys", &all_mysys_files, 2LL);
return (*((long long ( **)(const char *, _UNKNOWN **, long long))PSI_server[0] + 5))(
"mysys",
&all_mysys_stages,
1LL);
}
| my_init_mysys_psi_keys:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
LEA R14,[0x3f9888]
MOV RAX,qword ptr [R14]
LEA RBX,[0x164952]
LEA RSI,[0x3f90a0]
MOV RDI,RBX
MOV EDX,0x13
CALL qword ptr [RAX]
MOV RAX,qword ptr [R14]
LEA RSI,[0x3f9270]
MOV RDI,RBX
MOV EDX,0x7
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R14]
LEA RSI,[0x3f9320]
MOV RDI,RBX
MOV EDX,0x1
CALL qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R14]
LEA RSI,[0x3f9340]
MOV RDI,RBX
MOV EDX,0x1
CALL qword ptr [RAX + 0x18]
MOV RAX,qword ptr [R14]
LEA RSI,[0x3f9360]
MOV RDI,RBX
MOV EDX,0x2
CALL qword ptr [RAX + 0x20]
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x28]
LEA RSI,[0x3f9090]
MOV RDI,RBX
MOV EDX,0x1
POP RBX
POP R14
POP RBP
JMP RAX
|
void my_init_mysys_psi_keys(void)
{
(**(code **)PSI_server)("mysys",all_mysys_mutexes,0x13);
(**(code **)(PSI_server + 0x10))("mysys",all_mysys_conds,7);
(**(code **)(PSI_server + 8))("mysys",all_mysys_rwlocks,1);
(**(code **)(PSI_server + 0x18))("mysys",all_mysys_threads,1);
(**(code **)(PSI_server + 0x20))("mysys",all_mysys_files,2);
/* WARNING: Could not recover jumptable at 0x0012d12a. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(PSI_server + 0x28))("mysys",&all_mysys_stages,1);
return;
}
| |
24,114 | ankerl::nanobench::Bench::title(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | BadAccessGuards/build_O3/_deps/nanobench-src/src/include/nanobench.h | Bench& Bench::title(std::string const& benchmarkTitle) {
if (benchmarkTitle != mConfig.mBenchmarkTitle) {
mResults.clear();
}
mConfig.mBenchmarkTitle = benchmarkTitle;
return *this;
} | O3 | c | ankerl::nanobench::Bench::title(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
cmpq 0x8(%rdi), %rdx
jne 0xb720
testq %rdx, %rdx
je 0xb733
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x3320
testl %eax, %eax
je 0xb733
leaq 0x118(%rbx), %rdi
movq 0x118(%rbx), %rsi
callq 0x1309c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3170
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN6ankerl9nanobench5Bench5titleERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rdx, [rsi+8]
cmp rdx, [rdi+8]
jnz short loc_B720
test rdx, rdx
jz short loc_B733
mov rsi, [rbx]
mov rdi, [r14]
call _bcmp
test eax, eax
jz short loc_B733
loc_B720:
lea rdi, [rbx+118h]
mov rsi, [rbx+118h]
call _ZNSt6vectorIN6ankerl9nanobench6ResultESaIS2_EE15_M_erase_at_endEPS2_; std::vector<ankerl::nanobench::Result>::_M_erase_at_end(ankerl::nanobench::Result*)
loc_B733:
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| _QWORD * ankerl::nanobench::Bench::title(_QWORD *a1, _QWORD *a2)
{
long long v2; // rdx
v2 = a2[1];
if ( v2 != a1[1] || v2 && (unsigned int)bcmp(*a2, *a1) )
std::vector<ankerl::nanobench::Result>::_M_erase_at_end(a1 + 35, a1[35]);
std::string::_M_assign(a1);
return a1;
}
| title:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RDX,qword ptr [RSI + 0x8]
CMP RDX,qword ptr [RDI + 0x8]
JNZ 0x0010b720
TEST RDX,RDX
JZ 0x0010b733
MOV RSI,qword ptr [RBX]
MOV RDI,qword ptr [R14]
CALL 0x00103320
TEST EAX,EAX
JZ 0x0010b733
LAB_0010b720:
LEA RDI,[RBX + 0x118]
MOV RSI,qword ptr [RBX + 0x118]
CALL 0x0011309c
LAB_0010b733:
MOV RDI,RBX
MOV RSI,R14
CALL 0x00103170
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* ankerl::nanobench::Bench::title(std::__cxx11::string const&) */
Bench * __thiscall ankerl::nanobench::Bench::title(Bench *this,string *param_1)
{
size_t __n;
int iVar1;
__n = *(size_t *)(param_1 + 8);
if (__n == *(size_t *)(this + 8)) {
if (__n == 0) goto LAB_0010b733;
iVar1 = bcmp(*(void **)param_1,*(void **)this,__n);
if (iVar1 == 0) goto LAB_0010b733;
}
std::vector<ankerl::nanobench::Result,std::allocator<ankerl::nanobench::Result>>::_M_erase_at_end
((vector<ankerl::nanobench::Result,std::allocator<ankerl::nanobench::Result>> *)
(this + 0x118),*(Result **)(this + 0x118));
LAB_0010b733:
std::__cxx11::string::_M_assign((string *)this);
return this;
}
| |
24,115 | GLOBAL__sub_I_crc32c.cc | eloqsql/mysys/crc32/crc32c.cc | static uint32_t cpuid_ecx()
{
#ifdef __GNUC__
uint32_t reax= 0, rebx= 0, recx= 0, redx= 0;
__cpuid(1, reax, rebx, recx, redx);
return recx;
#elif defined _MSC_VER
int regs[4];
__cpuid(regs, 1);
return regs[2];
#else
# error "unknown compiler"
#endif
} | O3 | cpp | GLOBAL__sub_I_crc32c.cc:
movl $0x1, %eax
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl $0x100002, %edx # imm = 0x100002
andl %edx, %ecx
cmpl $0x100000, %ecx # imm = 0x100000
leaq 0x381ad(%rip), %rsi # 0x62a3b
leaq 0x38287(%rip), %rax # 0x62b1c
cmoveq %rsi, %rax
cmpl %edx, %ecx
jne 0x2a8a9
pushq %rbp
movq %rsp, %rbp
leaq 0x384bc(%rip), %rax # 0x62d64
popq %rbp
movq %rax, 0x386b30(%rip) # 0x3b13e0
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _GLOBAL__sub_I_crc32c_cc:
mov eax, 1
xchg rsi, rbx
cpuid
xchg rsi, rbx
mov edx, offset unk_100002
and ecx, edx
cmp ecx, offset unk_100000
lea rsi, _ZN15mysys_namespace6crc32cL12crc32c_sse42EjPKcm; mysys_namespace::crc32c::crc32c_sse42(uint,char const*,ulong)
lea rax, _ZN15mysys_namespace6crc32cL11crc32c_slowEjPKcm; mysys_namespace::crc32c::crc32c_slow(uint,char const*,ulong)
cmovz rax, rsi
cmp ecx, edx
jnz short loc_2A8A9
push rbp
mov rbp, rsp
lea rax, crc32c_3way
pop rbp
loc_2A8A9:
mov cs:_ZN15mysys_namespace6crc32cL12ChosenExtendE, rax; mysys_namespace::crc32c::ChosenExtend
retn
| long long ( *GLOBAL__sub_I_crc32c_cc())()
{
int v5; // ecx
long long ( *result)(); // rax
_RAX = 1LL;
__asm { cpuid }
v5 = (unsigned int)&unk_100002 & _RCX;
result = (long long ( *)())mysys_namespace::crc32c::crc32c_slow;
if ( v5 == (_DWORD)&unk_100000 )
result = (long long ( *)())mysys_namespace::crc32c::crc32c_sse42;
if ( v5 == (unsigned int)&unk_100002 )
result = crc32c_3way;
mysys_namespace::crc32c::ChosenExtend = (long long)result;
return result;
}
| _GLOBAL__sub_I_crc32c.cc:
MOV EAX,0x1
XCHG RBX,RSI
CPUID
XCHG RBX,RSI
MOV EDX,0x100002
AND ECX,EDX
CMP ECX,0x100000
LEA RSI,[0x162a3b]
LEA RAX,[0x162b1c]
CMOVZ RAX,RSI
CMP ECX,EDX
JNZ 0x0012a8a9
PUSH RBP
MOV RBP,RSP
LEA RAX,[0x162d64]
POP RBP
LAB_0012a8a9:
MOV qword ptr [0x004b13e0],RAX
RET
|
/* WARNING: Removing unreachable block (ram,0x0012a875) */
void _GLOBAL__sub_I_crc32c_cc(void)
{
long lVar1;
uint uVar2;
lVar1 = cpuid_Version_info(1);
uVar2 = *(uint *)(lVar1 + 0xc) & 0x100002;
mysys_namespace::crc32c::ChosenExtend = mysys_namespace::crc32c::crc32c_slow;
if (uVar2 == 0x100000) {
mysys_namespace::crc32c::ChosenExtend = mysys_namespace::crc32c::crc32c_sse42;
}
if (uVar2 == 0x100002) {
mysys_namespace::crc32c::ChosenExtend = crc32c_3way;
}
return;
}
| |
24,116 | copy_typelib | eloqsql/mysys/typelib.c | TYPELIB *copy_typelib(MEM_ROOT *root, const TYPELIB *from)
{
TYPELIB *to;
uint i;
if (!from)
return NULL;
if (!(to= (TYPELIB*) alloc_root(root, sizeof(TYPELIB))))
return NULL;
if (!(to->type_names= (const char **)
alloc_root(root, (sizeof(char *) + sizeof(int)) * (from->count + 1))))
return NULL;
to->type_lengths= (unsigned int *)(to->type_names + from->count + 1);
to->count= from->count;
if (from->name)
{
if (!(to->name= strdup_root(root, from->name)))
return NULL;
}
else
to->name= NULL;
for (i= 0; i < from->count; i++)
{
if (!(to->type_names[i]= strmake_root(root, from->type_names[i],
from->type_lengths[i])))
return NULL;
to->type_lengths[i]= from->type_lengths[i];
}
to->type_names[to->count]= NULL;
to->type_lengths[to->count]= 0;
return to;
} | O0 | c | copy_typelib:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa9474
movq $0x0, -0x8(%rbp)
jmp 0xa95f1
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x96e00
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xa9499
movq $0x0, -0x8(%rbp)
jmp 0xa95f1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, %eax
imulq $0xc, %rax, %rsi
callq 0x96e00
movq -0x20(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0xa94cc
movq $0x0, -0x8(%rbp)
jmp 0xa95f1
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movl (%rax), %eax
shlq $0x3, %rax
addq %rax, %rcx
addq $0x8, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xa9532
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x97670
movq -0x20(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0xa9530
movq $0x0, -0x8(%rbp)
jmp 0xa95f1
jmp 0xa953e
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xa95be
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, %edx
callq 0x976b0
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x24(%rbp), %edx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0xa9597
movq $0x0, -0x8(%rbp)
jmp 0xa95f1
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx,4), %edx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa9545
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movl $0x0, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| copy_typelib:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
cmp [rbp+var_18], 0
jnz short loc_A9474
mov [rbp+var_8], 0
jmp loc_A95F1
loc_A9474:
mov rdi, [rbp+var_10]
mov esi, 20h ; ' '
call alloc_root
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_A9499
mov [rbp+var_8], 0
jmp loc_A95F1
loc_A9499:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov eax, [rax]
add eax, 1
mov eax, eax
imul rsi, rax, 0Ch
call alloc_root
mov rcx, [rbp+var_20]
mov [rcx+10h], rax
cmp rax, 0
jnz short loc_A94CC
mov [rbp+var_8], 0
jmp loc_A95F1
loc_A94CC:
mov rax, [rbp+var_20]
mov rcx, [rax+10h]
mov rax, [rbp+var_18]
mov eax, [rax]
shl rax, 3
add rcx, rax
add rcx, 8
mov rax, [rbp+var_20]
mov [rax+18h], rcx
mov rax, [rbp+var_18]
mov ecx, [rax]
mov rax, [rbp+var_20]
mov [rax], ecx
mov rax, [rbp+var_18]
cmp qword ptr [rax+8], 0
jz short loc_A9532
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rsi, [rax+8]
call strdup_root
mov rcx, [rbp+var_20]
mov [rcx+8], rax
cmp rax, 0
jnz short loc_A9530
mov [rbp+var_8], 0
jmp loc_A95F1
loc_A9530:
jmp short loc_A953E
loc_A9532:
mov rax, [rbp+var_20]
mov qword ptr [rax+8], 0
loc_A953E:
mov [rbp+var_24], 0
loc_A9545:
mov eax, [rbp+var_24]
mov rcx, [rbp+var_18]
cmp eax, [rcx]
jnb short loc_A95BE
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov ecx, [rbp+var_24]
mov rsi, [rax+rcx*8]
mov rax, [rbp+var_18]
mov rax, [rax+18h]
mov ecx, [rbp+var_24]
mov eax, [rax+rcx*4]
mov edx, eax
call strmake_root
mov rcx, [rbp+var_20]
mov rcx, [rcx+10h]
mov edx, [rbp+var_24]
mov [rcx+rdx*8], rax
cmp rax, 0
jnz short loc_A9597
mov [rbp+var_8], 0
jmp short loc_A95F1
loc_A9597:
mov rax, [rbp+var_18]
mov rax, [rax+18h]
mov ecx, [rbp+var_24]
mov edx, [rax+rcx*4]
mov rax, [rbp+var_20]
mov rax, [rax+18h]
mov ecx, [rbp+var_24]
mov [rax+rcx*4], edx
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_A9545
loc_A95BE:
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov rcx, [rbp+var_20]
mov ecx, [rcx]
mov qword ptr [rax+rcx*8], 0
mov rax, [rbp+var_20]
mov rax, [rax+18h]
mov rcx, [rbp+var_20]
mov ecx, [rcx]
mov dword ptr [rax+rcx*4], 0
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_A95F1:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| char * copy_typelib(_QWORD **a1, unsigned int *a2)
{
char *v2; // rax
long long v3; // rax
char *v4; // rax
unsigned int i; // [rsp+Ch] [rbp-24h]
char *v7; // [rsp+10h] [rbp-20h]
if ( !a2 )
return 0LL;
v7 = alloc_root(a1, 32LL);
if ( !v7 )
return 0LL;
v2 = alloc_root(a1, 12LL * (*a2 + 1));
*((_QWORD *)v7 + 2) = v2;
if ( !v2 )
return 0LL;
*((_QWORD *)v7 + 3) = 8LL * *a2 + *((_QWORD *)v7 + 2) + 8;
*(_DWORD *)v7 = *a2;
if ( *((_QWORD *)a2 + 1) )
{
v3 = strdup_root((long long)a1, *((_QWORD *)a2 + 1));
*((_QWORD *)v7 + 1) = v3;
if ( !v3 )
return 0LL;
}
else
{
*((_QWORD *)v7 + 1) = 0LL;
}
for ( i = 0; i < *a2; ++i )
{
v4 = strmake_root(a1, *(_QWORD *)(*((_QWORD *)a2 + 2) + 8LL * i), *(unsigned int *)(*((_QWORD *)a2 + 3) + 4LL * i));
*(_QWORD *)(*((_QWORD *)v7 + 2) + 8LL * i) = v4;
if ( !v4 )
return 0LL;
*(_DWORD *)(*((_QWORD *)v7 + 3) + 4LL * i) = *(_DWORD *)(*((_QWORD *)a2 + 3) + 4LL * i);
}
*(_QWORD *)(*((_QWORD *)v7 + 2) + 8LL * *(unsigned int *)v7) = 0LL;
*(_DWORD *)(*((_QWORD *)v7 + 3) + 4LL * *(unsigned int *)v7) = 0;
return v7;
}
| copy_typelib:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x001a9474
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001a95f1
LAB_001a9474:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x20
CALL 0x00196e00
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x001a9499
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001a95f1
LAB_001a9499:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
ADD EAX,0x1
MOV EAX,EAX
IMUL RSI,RAX,0xc
CALL 0x00196e00
MOV RCX,qword ptr [RBP + -0x20]
MOV qword ptr [RCX + 0x10],RAX
CMP RAX,0x0
JNZ 0x001a94cc
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001a95f1
LAB_001a94cc:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
SHL RAX,0x3
ADD RCX,RAX
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x001a9532
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00197670
MOV RCX,qword ptr [RBP + -0x20]
MOV qword ptr [RCX + 0x8],RAX
CMP RAX,0x0
JNZ 0x001a9530
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001a95f1
LAB_001a9530:
JMP 0x001a953e
LAB_001a9532:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],0x0
LAB_001a953e:
MOV dword ptr [RBP + -0x24],0x0
LAB_001a9545:
MOV EAX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x18]
CMP EAX,dword ptr [RCX]
JNC 0x001a95be
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RBP + -0x24]
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x18]
MOV ECX,dword ptr [RBP + -0x24]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV EDX,EAX
CALL 0x001976b0
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x10]
MOV EDX,dword ptr [RBP + -0x24]
MOV qword ptr [RCX + RDX*0x8],RAX
CMP RAX,0x0
JNZ 0x001a9597
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001a95f1
LAB_001a9597:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x18]
MOV ECX,dword ptr [RBP + -0x24]
MOV EDX,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x18]
MOV ECX,dword ptr [RBP + -0x24]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001a9545
LAB_001a95be:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RCX]
MOV qword ptr [RAX + RCX*0x8],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RCX]
MOV dword ptr [RAX + RCX*0x4],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_001a95f1:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
uint * copy_typelib(int8 param_1,uint *param_2)
{
long lVar1;
uint local_2c;
uint *local_10;
if (param_2 == (uint *)0x0) {
local_10 = (uint *)0x0;
}
else {
local_10 = (uint *)alloc_root(param_1,0x20);
if (local_10 == (uint *)0x0) {
local_10 = (uint *)0x0;
}
else {
lVar1 = alloc_root(param_1,(ulong)(*param_2 + 1) * 0xc);
*(long *)(local_10 + 4) = lVar1;
if (lVar1 == 0) {
local_10 = (uint *)0x0;
}
else {
*(ulong *)(local_10 + 6) = *(long *)(local_10 + 4) + (ulong)*param_2 * 8 + 8;
*local_10 = *param_2;
if (*(long *)(param_2 + 2) == 0) {
local_10[2] = 0;
local_10[3] = 0;
}
else {
lVar1 = strdup_root(param_1,*(int8 *)(param_2 + 2));
*(long *)(local_10 + 2) = lVar1;
if (lVar1 == 0) {
return (uint *)0x0;
}
}
for (local_2c = 0; local_2c < *param_2; local_2c = local_2c + 1) {
lVar1 = strmake_root(param_1,*(int8 *)(*(long *)(param_2 + 4) + (ulong)local_2c * 8)
,*(int4 *)(*(long *)(param_2 + 6) + (ulong)local_2c * 4));
*(long *)(*(long *)(local_10 + 4) + (ulong)local_2c * 8) = lVar1;
if (lVar1 == 0) {
return (uint *)0x0;
}
*(int4 *)(*(long *)(local_10 + 6) + (ulong)local_2c * 4) =
*(int4 *)(*(long *)(param_2 + 6) + (ulong)local_2c * 4);
}
*(int8 *)(*(long *)(local_10 + 4) + (ulong)*local_10 * 8) = 0;
*(int4 *)(*(long *)(local_10 + 6) + (ulong)*local_10 * 4) = 0;
}
}
}
return local_10;
}
| |
24,117 | my_readlink | eloqsql/mysys/my_symlink.c | int my_readlink(char *to, const char *filename, myf MyFlags)
{
#ifndef HAVE_READLINK
strmov(to,filename);
return 1;
#else
int result=0;
int length;
DBUG_ENTER("my_readlink");
if ((length=readlink(filename, to, FN_REFLEN-1)) < 0)
{
/* Don't give an error if this wasn't a symlink */
if ((my_errno=errno) == EINVAL)
{
result= 1;
strmov(to,filename);
}
else
{
if (MyFlags & MY_WME)
my_error(EE_CANT_READLINK, MYF(0), filename, errno);
result= -1;
}
}
else
to[length]=0;
DBUG_PRINT("exit" ,("result: %d", result));
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
} | O0 | c | my_readlink:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x242c0
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jge 0x2fbf1
callq 0x24050
movl (%rax), %eax
movl %eax, -0x24(%rbp)
callq 0x26720
movq %rax, %rcx
movl -0x24(%rbp), %eax
movl %eax, (%rcx)
cmpl $0x16, %eax
jne 0x2fbb7
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x242b0
jmp 0x2fbef
movq -0x18(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x2fbe8
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x24050
movq -0x30(%rbp), %rdx
movl (%rax), %ecx
movl $0x18, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x2e060
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x2fbfd
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x2fbff
jmp 0x2fc01
jmp 0x2fc03
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_readlink:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], 0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_8]
mov edx, 1FFh
call _readlink
mov [rbp+var_20], eax
cmp eax, 0
jge short loc_2FBF1
call ___errno_location
mov eax, [rax]
mov [rbp+var_24], eax
call _my_thread_var
mov rcx, rax
mov eax, [rbp+var_24]
mov [rcx], eax
cmp eax, 16h
jnz short loc_2FBB7
mov [rbp+var_1C], 1
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call _stpcpy
jmp short loc_2FBEF
loc_2FBB7:
mov rax, [rbp+var_18]
and rax, 10h
cmp rax, 0
jz short loc_2FBE8
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
call ___errno_location
mov rdx, [rbp+var_30]
mov ecx, [rax]
mov edi, 18h
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_2FBE8:
mov [rbp+var_1C], 0FFFFFFFFh
loc_2FBEF:
jmp short loc_2FBFD
loc_2FBF1:
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_20]
mov byte ptr [rax+rcx], 0
loc_2FBFD:
jmp short $+2
loc_2FBFF:
jmp short $+2
loc_2FC01:
jmp short $+2
loc_2FC03:
mov eax, [rbp+var_1C]
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
add rsp, 40h
pop rbp
retn
| long long my_readlink(long long a1, long long a2, char a3)
{
unsigned int *v3; // rax
int v5; // [rsp+1Ch] [rbp-24h]
int v6; // [rsp+20h] [rbp-20h]
unsigned int v7; // [rsp+24h] [rbp-1Ch]
v7 = 0;
v6 = readlink(a2, a1, 511LL);
if ( v6 >= 0 )
{
*(_BYTE *)(a1 + v6) = 0;
}
else
{
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var() = v5;
if ( v5 == 22 )
{
v7 = 1;
stpcpy(a1, a2);
}
else
{
if ( (a3 & 0x10) != 0 )
{
v3 = (unsigned int *)__errno_location();
my_error(0x18u, 0LL, a2, *v3);
}
return (unsigned int)-1;
}
}
return v7;
}
| my_readlink:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x8]
MOV EDX,0x1ff
CALL 0x001242c0
MOV dword ptr [RBP + -0x20],EAX
CMP EAX,0x0
JGE 0x0012fbf1
CALL 0x00124050
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
CALL 0x00126720
MOV RCX,RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RCX],EAX
CMP EAX,0x16
JNZ 0x0012fbb7
MOV dword ptr [RBP + -0x1c],0x1
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001242b0
JMP 0x0012fbef
LAB_0012fbb7:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x10
CMP RAX,0x0
JZ 0x0012fbe8
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x00124050
MOV RDX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
MOV EDI,0x18
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x0012e060
LAB_0012fbe8:
MOV dword ptr [RBP + -0x1c],0xffffffff
LAB_0012fbef:
JMP 0x0012fbfd
LAB_0012fbf1:
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x20]
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_0012fbfd:
JMP 0x0012fbff
LAB_0012fbff:
JMP 0x0012fc01
LAB_0012fc01:
JMP 0x0012fc03
LAB_0012fc03:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
ADD RSP,0x40
POP RBP
RET
|
int4 my_readlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
ssize_t sVar2;
int *piVar3;
int4 local_24;
local_24 = 0;
sVar2 = readlink(param_2,param_1,0x1ff);
if ((int)sVar2 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if (iVar1 == 0x16) {
local_24 = 1;
stpcpy(param_1,param_2);
}
else {
if ((param_3 & 0x10) != 0) {
piVar3 = __errno_location();
my_error(0x18,0,param_2,*piVar3);
}
local_24 = 0xffffffff;
}
}
else {
param_1[(int)sVar2] = '\0';
}
return local_24;
}
| |
24,118 | my_readlink | eloqsql/mysys/my_symlink.c | int my_readlink(char *to, const char *filename, myf MyFlags)
{
#ifndef HAVE_READLINK
strmov(to,filename);
return 1;
#else
int result=0;
int length;
DBUG_ENTER("my_readlink");
if ((length=readlink(filename, to, FN_REFLEN-1)) < 0)
{
/* Don't give an error if this wasn't a symlink */
if ((my_errno=errno) == EINVAL)
{
result= 1;
strmov(to,filename);
}
else
{
if (MyFlags & MY_WME)
my_error(EE_CANT_READLINK, MYF(0), filename, errno);
result= -1;
}
}
else
to[length]=0;
DBUG_PRINT("exit" ,("result: %d", result));
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
} | O3 | c | my_readlink:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1ff, %edx # imm = 0x1FF
movq %rsi, %rdi
movq %r14, %rsi
callq 0x24300
testl %eax, %eax
js 0x2b8ee
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movb $0x0, (%r14,%rax)
xorl %r14d, %r14d
jmp 0x2b93b
callq 0x24060
movq %rax, %r12
movl (%rax), %r13d
callq 0x2656a
movl %r13d, (%rax)
cmpl $0x16, %r13d
jne 0x2b91a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x242a0
movl $0x1, %r14d
jmp 0x2b93b
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
testb $0x10, %r15b
je 0x2b93b
movl (%r12), %ecx
movl $0x18, %edi
xorl %esi, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2a6c3
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_readlink:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov rbx, rsi
mov r14, rdi
mov edx, 1FFh
mov rdi, rsi
mov rsi, r14
call _readlink
test eax, eax
js short loc_2B8EE
and eax, 7FFFFFFFh
mov byte ptr [r14+rax], 0
xor r14d, r14d
jmp short loc_2B93B
loc_2B8EE:
call ___errno_location
mov r12, rax
mov r13d, [rax]
call _my_thread_var
mov [rax], r13d
cmp r13d, 16h
jnz short loc_2B91A
mov rdi, r14
mov rsi, rbx
call _strcpy
mov r14d, 1
jmp short loc_2B93B
loc_2B91A:
mov r14d, 0FFFFFFFFh
test r15b, 10h
jz short loc_2B93B
mov ecx, [r12]
mov edi, 18h
xor esi, esi
mov rdx, rbx
xor eax, eax
call my_error
loc_2B93B:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_readlink(long long a1, long long a2, char a3)
{
int v4; // eax
unsigned int v5; // r14d
unsigned int *v6; // r12
unsigned int v7; // r13d
v4 = readlink(a2, a1, 511LL);
if ( v4 < 0 )
{
v6 = (unsigned int *)__errno_location(a2);
v7 = *v6;
*(_DWORD *)my_thread_var() = v7;
if ( v7 == 22 )
{
strcpy(a1, a2);
return 1;
}
else
{
v5 = -1;
if ( (a3 & 0x10) != 0 )
my_error(0x18u, 0, a2, *v6);
}
}
else
{
*(_BYTE *)(a1 + (v4 & 0x7FFFFFFF)) = 0;
return 0;
}
return v5;
}
| my_readlink:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
MOV EDX,0x1ff
MOV RDI,RSI
MOV RSI,R14
CALL 0x00124300
TEST EAX,EAX
JS 0x0012b8ee
AND EAX,0x7fffffff
MOV byte ptr [R14 + RAX*0x1],0x0
XOR R14D,R14D
JMP 0x0012b93b
LAB_0012b8ee:
CALL 0x00124060
MOV R12,RAX
MOV R13D,dword ptr [RAX]
CALL 0x0012656a
MOV dword ptr [RAX],R13D
CMP R13D,0x16
JNZ 0x0012b91a
MOV RDI,R14
MOV RSI,RBX
CALL 0x001242a0
MOV R14D,0x1
JMP 0x0012b93b
LAB_0012b91a:
MOV R14D,0xffffffff
TEST R15B,0x10
JZ 0x0012b93b
MOV ECX,dword ptr [R12]
MOV EDI,0x18
XOR ESI,ESI
MOV RDX,RBX
XOR EAX,EAX
CALL 0x0012a6c3
LAB_0012b93b:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 my_readlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
ssize_t sVar2;
int *piVar3;
int *piVar4;
int8 uVar5;
sVar2 = readlink(param_2,param_1,0x1ff);
if ((int)(uint)sVar2 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if (iVar1 == 0x16) {
strcpy(param_1,param_2);
uVar5 = 1;
}
else {
uVar5 = 0xffffffff;
if ((param_3 & 0x10) != 0) {
my_error(0x18,0,param_2,*piVar3);
}
}
}
else {
param_1[(uint)sVar2 & 0x7fffffff] = '\0';
uVar5 = 0;
}
return uVar5;
}
| |
24,119 | mi_checksum | eloqsql/storage/myisam/mi_checksum.c | ha_checksum mi_checksum(MI_INFO *info, const uchar *buf)
{
ha_checksum crc=0;
const uchar *record= buf;
MI_COLUMNDEF *column= info->s->rec;
MI_COLUMNDEF *column_end= column+ info->s->base.fields;
my_bool skip_null_bits= MY_TEST(info->s->options & HA_OPTION_NULL_FIELDS);
for ( ; column != column_end ; buf+= column++->length)
{
const uchar *pos;
ulong length;
if ((record[column->null_pos] & column->null_bit) &&
skip_null_bits)
continue; /* Null field */
switch (column->type) {
case FIELD_BLOB:
{
length=_mi_calc_blob_length(column->length-
portable_sizeof_char_ptr,
buf);
memcpy((void*) &pos, buf+column->length - portable_sizeof_char_ptr,
sizeof(char*));
break;
}
case FIELD_VARCHAR:
{
uint pack_length= HA_VARCHAR_PACKLENGTH(column->length-1);
if (pack_length == 1)
length= (ulong) *(uchar*) buf;
else
length= uint2korr(buf);
pos= buf+pack_length;
break;
}
default:
length=column->length;
pos=buf;
break;
}
crc=my_checksum(crc, pos ? pos : (uchar*) "", length);
}
return crc;
} | O3 | c | mi_checksum:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rcx
movq 0x168(%rcx), %rax
testq %rax, %rax
je 0x4a3d9
movq 0x230(%rcx), %r12
movq 0x318(%rcx), %rcx
shlq $0x4, %rax
leaq (%rax,%rax,2), %r13
xorl %ebx, %ebx
andl $0x400, %ecx # imm = 0x400
movq %rcx, -0x38(%rbp)
movq %rsi, %r14
xorl %r15d, %r15d
movq %rsi, -0x30(%rbp)
movzwl 0xe(%r12,%rbx), %eax
movb 0xc(%r12,%rbx), %cl
testb %cl, (%rsi,%rax)
je 0x4a34f
cmpq $0x0, -0x38(%rbp)
jne 0x4a3c1
movl (%r12,%rbx), %eax
movzwl 0x4(%r12,%rbx), %edx
cmpl $0x8, %eax
je 0x4a380
cmpl $0x4, %eax
jne 0x4a393
addl $-0x8, %edx
movl %edx, %edi
movq %r14, %rsi
callq 0x31759
movq %rax, %rdx
movzwl 0x4(%r12,%rbx), %eax
movq -0x8(%r14,%rax), %rsi
jmp 0x4a3a4
cmpl $0x100, %edx # imm = 0x100
ja 0x4a398
movzbl (%r14), %edx
movl $0x1, %esi
jmp 0x4a3a1
movq %r14, %rsi
jmp 0x4a3a4
movzwl (%r14), %edx
movl $0x2, %esi
addq %r14, %rsi
testq %rsi, %rsi
leaq 0x4c048(%rip), %rax # 0x963f6
cmoveq %rax, %rsi
movl %r15d, %edi
callq 0x60828
movl %eax, %r15d
movq -0x30(%rbp), %rsi
movzwl 0x4(%r12,%rbx), %eax
addq %rax, %r14
addq $0x30, %rbx
cmpq %rbx, %r13
jne 0x4a338
jmp 0x4a3dc
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| mi_checksum:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rcx, [rdi]
mov rax, [rcx+168h]
test rax, rax
jz loc_4A3D9
mov r12, [rcx+230h]
mov rcx, [rcx+318h]
shl rax, 4
lea r13, [rax+rax*2]
xor ebx, ebx
and ecx, 400h
mov [rbp+var_38], rcx
mov r14, rsi
xor r15d, r15d
mov [rbp+var_30], rsi
loc_4A338:
movzx eax, word ptr [r12+rbx+0Eh]
mov cl, [r12+rbx+0Ch]
test [rsi+rax], cl
jz short loc_4A34F
cmp [rbp+var_38], 0
jnz short loc_4A3C1
loc_4A34F:
mov eax, [r12+rbx]
movzx edx, word ptr [r12+rbx+4]
cmp eax, 8
jz short loc_4A380
cmp eax, 4
jnz short loc_4A393
add edx, 0FFFFFFF8h
mov edi, edx
mov rsi, r14
call _mi_calc_blob_length
mov rdx, rax
movzx eax, word ptr [r12+rbx+4]
mov rsi, [r14+rax-8]
jmp short loc_4A3A4
loc_4A380:
cmp edx, 100h
ja short loc_4A398
movzx edx, byte ptr [r14]
mov esi, 1
jmp short loc_4A3A1
loc_4A393:
mov rsi, r14
jmp short loc_4A3A4
loc_4A398:
movzx edx, word ptr [r14]
mov esi, 2
loc_4A3A1:
add rsi, r14
loc_4A3A4:
test rsi, rsi
lea rax, asc_963F2+4; ""
cmovz rsi, rax
mov edi, r15d
call my_checksum
mov r15d, eax
mov rsi, [rbp+var_30]
loc_4A3C1:
movzx eax, word ptr [r12+rbx+4]
add r14, rax
add rbx, 30h ; '0'
cmp r13, rbx
jnz loc_4A338
jmp short loc_4A3DC
loc_4A3D9:
xor r15d, r15d
loc_4A3DC:
mov eax, r15d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mi_checksum(long long *a1, unsigned __int8 *a2)
{
long long v2; // rcx
long long v3; // rax
long long v4; // r12
long long v5; // r13
long long v6; // rbx
unsigned __int8 *v7; // r14
unsigned int v8; // r15d
int v9; // eax
unsigned long long v10; // rdx
char *v11; // rsi
long long v12; // rsi
long long v14; // [rsp+8h] [rbp-38h]
unsigned __int8 *v15; // [rsp+10h] [rbp-30h]
v2 = *a1;
v3 = *(_QWORD *)(*a1 + 360);
if ( v3 )
{
v4 = *(_QWORD *)(v2 + 560);
v5 = 48 * v3;
v6 = 0LL;
v14 = *(_QWORD *)(v2 + 792) & 0x400LL;
v7 = a2;
v8 = 0;
v15 = a2;
do
{
if ( (*(_BYTE *)(v4 + v6 + 12) & a2[*(unsigned __int16 *)(v4 + v6 + 14)]) == 0 || !v14 )
{
v9 = *(_DWORD *)(v4 + v6);
v10 = *(unsigned __int16 *)(v4 + v6 + 4);
if ( v9 == 8 )
{
if ( (unsigned int)v10 > 0x100 )
{
v10 = *(unsigned __int16 *)v7;
v12 = 2LL;
}
else
{
v10 = *v7;
v12 = 1LL;
}
v11 = (char *)&v7[v12];
}
else if ( v9 == 4 )
{
v10 = mi_calc_blob_length((int)v10 - 8, v7);
v11 = *(char **)&v7[*(unsigned __int16 *)(v4 + v6 + 4) - 8];
}
else
{
v11 = (char *)v7;
}
if ( !v11 )
v11 = "";
v8 = my_checksum(v8, v11, v10);
a2 = v15;
}
v7 += *(unsigned __int16 *)(v4 + v6 + 4);
v6 += 48LL;
}
while ( v5 != v6 );
}
else
{
return 0;
}
return v8;
}
| mi_checksum:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RCX + 0x168]
TEST RAX,RAX
JZ 0x0014a3d9
MOV R12,qword ptr [RCX + 0x230]
MOV RCX,qword ptr [RCX + 0x318]
SHL RAX,0x4
LEA R13,[RAX + RAX*0x2]
XOR EBX,EBX
AND ECX,0x400
MOV qword ptr [RBP + -0x38],RCX
MOV R14,RSI
XOR R15D,R15D
MOV qword ptr [RBP + -0x30],RSI
LAB_0014a338:
MOVZX EAX,word ptr [R12 + RBX*0x1 + 0xe]
MOV CL,byte ptr [R12 + RBX*0x1 + 0xc]
TEST byte ptr [RSI + RAX*0x1],CL
JZ 0x0014a34f
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x0014a3c1
LAB_0014a34f:
MOV EAX,dword ptr [R12 + RBX*0x1]
MOVZX EDX,word ptr [R12 + RBX*0x1 + 0x4]
CMP EAX,0x8
JZ 0x0014a380
CMP EAX,0x4
JNZ 0x0014a393
ADD EDX,-0x8
MOV EDI,EDX
MOV RSI,R14
CALL 0x00131759
MOV RDX,RAX
MOVZX EAX,word ptr [R12 + RBX*0x1 + 0x4]
MOV RSI,qword ptr [R14 + RAX*0x1 + -0x8]
JMP 0x0014a3a4
LAB_0014a380:
CMP EDX,0x100
JA 0x0014a398
MOVZX EDX,byte ptr [R14]
MOV ESI,0x1
JMP 0x0014a3a1
LAB_0014a393:
MOV RSI,R14
JMP 0x0014a3a4
LAB_0014a398:
MOVZX EDX,word ptr [R14]
MOV ESI,0x2
LAB_0014a3a1:
ADD RSI,R14
LAB_0014a3a4:
TEST RSI,RSI
LEA RAX,[0x1963f6]
CMOVZ RSI,RAX
MOV EDI,R15D
CALL 0x00160828
MOV R15D,EAX
MOV RSI,qword ptr [RBP + -0x30]
LAB_0014a3c1:
MOVZX EAX,word ptr [R12 + RBX*0x1 + 0x4]
ADD R14,RAX
ADD RBX,0x30
CMP R13,RBX
JNZ 0x0014a338
JMP 0x0014a3dc
LAB_0014a3d9:
XOR R15D,R15D
LAB_0014a3dc:
MOV EAX,R15D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4 mi_checksum(long *param_1,ushort *param_2)
{
ushort uVar1;
long lVar2;
long lVar3;
ulong uVar4;
int4 uVar5;
ulong uVar6;
long lVar7;
long lVar8;
ushort *puVar9;
ushort *puVar10;
lVar7 = *param_1;
lVar2 = *(long *)(lVar7 + 0x168);
if (lVar2 == 0) {
uVar5 = 0;
}
else {
lVar3 = *(long *)(lVar7 + 0x230);
uVar4 = *(ulong *)(lVar7 + 0x318);
lVar7 = 0;
uVar5 = 0;
puVar10 = param_2;
do {
if (((*(byte *)((long)param_2 + (ulong)*(ushort *)(lVar3 + 0xe + lVar7)) &
*(byte *)(lVar3 + 0xc + lVar7)) == 0) || ((uVar4 & 0x400) == 0)) {
uVar1 = *(ushort *)(lVar3 + 4 + lVar7);
uVar6 = (ulong)uVar1;
if (*(int *)(lVar3 + lVar7) == 8) {
if (uVar1 < 0x101) {
uVar6 = (ulong)(byte)*puVar10;
lVar8 = 1;
}
else {
uVar6 = (ulong)*puVar10;
lVar8 = 2;
}
puVar9 = (ushort *)(lVar8 + (long)puVar10);
}
else {
puVar9 = puVar10;
if (*(int *)(lVar3 + lVar7) == 4) {
uVar6 = _mi_calc_blob_length(uVar1 - 8,puVar10);
puVar9 = *(ushort **)((long)puVar10 + ((ulong)*(ushort *)(lVar3 + 4 + lVar7) - 8));
}
}
if (puVar9 == (ushort *)0x0) {
puVar9 = (ushort *)&DAT_001963f6;
}
uVar5 = my_checksum(uVar5,puVar9,uVar6);
}
puVar10 = (ushort *)((long)puVar10 + (ulong)*(ushort *)(lVar3 + 4 + lVar7));
lVar7 = lVar7 + 0x30;
} while (lVar2 * 0x30 != lVar7);
}
return uVar5;
}
| |
24,120 | minja::Value::operator-(minja::Value const&) const | monkey531[P]llama/common/minja.hpp | Value operator-(const Value& rhs) const {
if (is_number_integer() && rhs.is_number_integer())
return get<int64_t>() - rhs.get<int64_t>();
else
return get<double>() - rhs.get<double>();
} | O3 | cpp | minja::Value::operator-(minja::Value const&) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movb 0x40(%rsi), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0xa4cd3
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0xa4cd3
movq %rsi, %rdi
callq 0x93f62
movq %rax, %r15
movq %r14, %rdi
callq 0x93f62
subq %rax, %r15
leaq 0x40(%rbx), %r14
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movupd %xmm0, 0x10(%rbx)
movupd %xmm0, 0x20(%rbx)
movupd %xmm0, 0x30(%rbx)
movupd %xmm0, 0x40(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6e388
jmp 0xa4d1f
movq %rsi, %rdi
callq 0x940ac
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x940ac
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
leaq 0x40(%rbx), %r14
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movupd %xmm0, 0x10(%rbx)
movupd %xmm0, 0x20(%rbx)
movupd %xmm0, 0x30(%rbx)
movupd %xmm0, 0x40(%rbx)
movq %r14, %rdi
movapd %xmm1, %xmm0
callq 0x6d950
movq %r14, %rdi
movl $0x1, %esi
callq 0x66666
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZNK5minja5ValuemiERKS0_:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rdx
mov rbx, rdi
mov al, [rsi+40h]
add al, 0FBh
cmp al, 1
ja short loc_A4CD3
mov al, [r14+40h]
add al, 0FBh
cmp al, 1
ja short loc_A4CD3
mov rdi, rsi
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov r15, rax
mov rdi, r14
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
sub r15, rax
lea r14, [rbx+40h]
xorpd xmm0, xmm0
movupd xmmword ptr [rbx], xmm0
movupd xmmword ptr [rbx+10h], xmm0
movupd xmmword ptr [rbx+20h], xmm0
movupd xmmword ptr [rbx+30h], xmm0
movupd xmmword ptr [rbx+40h], xmm0
mov rdi, r14
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE5EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_16number_integer_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_integer_t)
jmp short loc_A4D1F
loc_A4CD3:
mov rdi, rsi
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+28h+var_20], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd xmm1, [rsp+28h+var_20]
subsd xmm1, xmm0
lea r14, [rbx+40h]
xorpd xmm0, xmm0
movupd xmmword ptr [rbx], xmm0
movupd xmmword ptr [rbx+10h], xmm0
movupd xmmword ptr [rbx+20h], xmm0
movupd xmmword ptr [rbx+30h], xmm0
movupd xmmword ptr [rbx+40h], xmm0
mov rdi, r14
movapd xmm0, xmm1
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE7EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_14number_float_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_float_t)
loc_A4D1F:
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
| long long minja::Value::operator-(long long a1, long long a2, long long a3)
{
long long v4; // r15
long long v5; // rax
char *v6; // r14
double v7; // xmm1_8
double v9; // [rsp+8h] [rbp-20h]
if ( (unsigned __int8)(*(_BYTE *)(a2 + 64) - 5) > 1u || (unsigned __int8)(*(_BYTE *)(a3 + 64) - 5) > 1u )
{
v9 = minja::Value::get<double>(a2);
v7 = v9 - minja::Value::get<double>(a3);
v6 = (char *)(a1 + 64);
*(_OWORD *)a1 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(unsigned __int8 *)(a1 + 64),
v7);
}
else
{
v4 = minja::Value::get<long>(a2);
v5 = minja::Value::get<long>(a3);
v6 = (char *)(a1 + 64);
*(_OWORD *)a1 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(unsigned __int8 *)(a1 + 64),
v4 - v5);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v6);
return a1;
}
| operator-:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RDX
MOV RBX,RDI
MOV AL,byte ptr [RSI + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x001a4cd3
MOV AL,byte ptr [R14 + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x001a4cd3
MOV RDI,RSI
CALL 0x00193f62
MOV R15,RAX
MOV RDI,R14
CALL 0x00193f62
SUB R15,RAX
LEA R14,[RBX + 0x40]
XORPD XMM0,XMM0
MOVUPD xmmword ptr [RBX],XMM0
MOVUPD xmmword ptr [RBX + 0x10],XMM0
MOVUPD xmmword ptr [RBX + 0x20],XMM0
MOVUPD xmmword ptr [RBX + 0x30],XMM0
MOVUPD xmmword ptr [RBX + 0x40],XMM0
MOV RDI,R14
MOV RSI,R15
CALL 0x0016e388
JMP 0x001a4d1f
LAB_001a4cd3:
MOV RDI,RSI
CALL 0x001940ac
MOVSD qword ptr [RSP + 0x8],XMM0
MOV RDI,R14
CALL 0x001940ac
MOVSD XMM1,qword ptr [RSP + 0x8]
SUBSD XMM1,XMM0
LEA R14,[RBX + 0x40]
XORPD XMM0,XMM0
MOVUPD xmmword ptr [RBX],XMM0
MOVUPD xmmword ptr [RBX + 0x10],XMM0
MOVUPD xmmword ptr [RBX + 0x20],XMM0
MOVUPD xmmword ptr [RBX + 0x30],XMM0
MOVUPD xmmword ptr [RBX + 0x40],XMM0
MOV RDI,R14
MOVAPD XMM0,XMM1
CALL 0x0016d950
LAB_001a4d1f:
MOV RDI,R14
MOV ESI,0x1
CALL 0x00166666
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
Value * __thiscall minja::Value::operator-(Value *this,Value *param_1)
{
long lVar1;
long lVar2;
Value *in_RDX;
double dVar3;
double dVar4;
if (((byte)((char)param_1[0x40] - 5U) < 2) && ((byte)((char)in_RDX[0x40] - 5U) < 2)) {
lVar1 = get<long>(param_1);
lVar2 = get<long>(in_RDX);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(this + 0x40,lVar1 - lVar2);
}
else {
dVar3 = get<double>(param_1);
dVar4 = get<double>(in_RDX);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(dVar3 - dVar4,this + 0x40);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant((bool)((char)this + '@'));
return this;
}
| |
24,121 | uf_prespace_selected | eloqsql/storage/myisam/mi_packrec.c | static void uf_prespace_selected(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
if (get_bit(bit_buff))
{
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
bfill((uchar*) to,spaces,' ');
if (to+spaces != end)
decode_bytes(rec,bit_buff,to+spaces,end);
}
else
decode_bytes(rec,bit_buff,to,end);
} | O0 | c | uf_prespace_selected:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xbeb7a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0xbeba2
jmp 0xbec5a
movq -0x10(%rbp), %rdi
callq 0xbd720
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0xbec5a
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jb 0xbebe5
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %esi
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
subl %esi, %ecx
movl %ecx, 0x4(%rdx)
shrl %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, %edx
leaq 0x201b03(%rip), %rcx # 0x2c06e0
andl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
jmp 0xbebf8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0xbbed0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jbe 0xbec1a
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0xbec6f
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %edx
movl $0x20, %esi
callq 0x2a2c0
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
je 0xbec58
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %eax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0xbde30
jmp 0xbec6f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xbde30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| uf_prespace_selected_0:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_BEB7A
mov rax, [rbp+var_10]
mov eax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
add ecx, 0FFFFFFFFh
mov [rdx+4], ecx
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jnz short loc_BEBA2
jmp loc_BEC5A
loc_BEB7A:
mov rdi, [rbp+var_10]
call fill_buffer_0
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz loc_BEC5A
loc_BEBA2:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+1Ch]
jb short loc_BEBE5
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+1Ch]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
sub ecx, esi
mov [rdx+4], ecx
shr eax, cl
mov rcx, [rbp+var_8]
mov ecx, [rcx+1Ch]
mov edx, ecx
lea rcx, mask_0
and eax, [rcx+rdx*4]
mov [rbp+var_28], eax
jmp short loc_BEBF8
loc_BEBE5:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+1Ch]
call fill_and_get_bits_0
mov [rbp+var_28], eax
loc_BEBF8:
mov ecx, [rbp+var_28]
mov [rbp+var_24], ecx
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
cmp rax, [rbp+var_20]
jbe short loc_BEC1A
mov rax, [rbp+var_10]
mov dword ptr [rax+28h], 1
jmp short loc_BEC6F
loc_BEC1A:
mov rdi, [rbp+var_18]
mov eax, [rbp+var_24]
mov edx, eax
mov esi, 20h ; ' '
call _memset
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
add rax, rcx
cmp rax, [rbp+var_20]
jz short loc_BEC58
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov eax, [rbp+var_24]
add rdx, rax
mov rcx, [rbp+var_20]
call decode_bytes_0
loc_BEC58:
jmp short loc_BEC6F
loc_BEC5A:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call decode_bytes_0
loc_BEC6F:
add rsp, 30h
pop rbp
retn
| long long uf_prespace_selected_0(long long a1, int *a2, _BYTE *a3, _BYTE *a4)
{
int v4; // eax
int v5; // ecx
unsigned int v6; // eax
int v7; // ecx
long long result; // rax
unsigned int bits_0; // [rsp+8h] [rbp-28h]
if ( a2[1] )
{
v4 = *a2;
v5 = a2[1] - 1;
a2[1] = v5;
if ( ((1 << v5) & v4) == 0 )
return decode_bytes_0(a1, (long long)a2, a3, a4);
}
else
{
fill_buffer_0((long long)a2);
a2[1] = 31;
if ( *a2 >= 0 )
return decode_bytes_0(a1, (long long)a2, a3, a4);
}
if ( (unsigned int)a2[1] < *(_DWORD *)(a1 + 28) )
{
bits_0 = fill_and_get_bits_0(a2, *(_DWORD *)(a1 + 28));
}
else
{
v6 = *a2;
v7 = a2[1] - *(_DWORD *)(a1 + 28);
a2[1] = v7;
bits_0 = mask_0[*(unsigned int *)(a1 + 28)] & (v6 >> v7);
}
if ( &a3[bits_0] <= a4 )
{
memset(a3, 32LL, bits_0);
result = (long long)&a3[bits_0];
if ( (_BYTE *)result != a4 )
return decode_bytes_0(a1, (long long)a2, &a3[bits_0], a4);
}
else
{
result = (long long)a2;
a2[10] = 1;
}
return result;
}
| uf_prespace_selected:
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 qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x001beb7a
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x4],ECX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JNZ 0x001beba2
JMP 0x001bec5a
LAB_001beb7a:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001bd720
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x001bec5a
LAB_001beba2:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x1c]
JC 0x001bebe5
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x1c]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
SUB ECX,ESI
MOV dword ptr [RDX + 0x4],ECX
SHR EAX,CL
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x1c]
MOV EDX,ECX
LEA RCX,[0x3c06e0]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001bebf8
LAB_001bebe5:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x1c]
CALL 0x001bbed0
MOV dword ptr [RBP + -0x28],EAX
LAB_001bebf8:
MOV ECX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001bec1a
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],0x1
JMP 0x001bec6f
LAB_001bec1a:
MOV RDI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
MOV ESI,0x20
CALL 0x0012a2c0
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001bec58
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x24]
ADD RDX,RAX
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001bde30
LAB_001bec58:
JMP 0x001bec6f
LAB_001bec5a:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001bde30
LAB_001bec6f:
ADD RSP,0x30
POP RBP
RET
|
void uf_prespace_selected(long param_1,uint *param_2,void *param_3,ulong param_4)
{
uint uVar1;
uint local_30;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar1 = *param_2 & 0x80000000;
}
else {
uVar1 = param_2[1];
param_2[1] = uVar1 - 1;
uVar1 = *param_2 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 == 0) {
decode_bytes(param_1,param_2,param_3,param_4);
}
else {
if (param_2[1] < *(uint *)(param_1 + 0x1c)) {
local_30 = fill_and_get_bits(param_2,*(int4 *)(param_1 + 0x1c));
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x1c);
param_2[1] = uVar1;
local_30 = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x1c) * 4);
}
if (param_4 < (long)param_3 + (ulong)local_30) {
param_2[10] = 1;
}
else {
memset(param_3,0x20,(ulong)local_30);
if ((long)param_3 + (ulong)local_30 != param_4) {
decode_bytes(param_1,param_2,(long)param_3 + (ulong)local_30,param_4);
}
}
}
return;
}
| |
24,122 | nglog::(anonymous namespace)::LogCleaner::Run(std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&, bool, 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&) | ng-log[P]ng-log/src/logging.cc | void LogCleaner::Run(const std::chrono::system_clock::time_point& current_time,
bool base_filename_selected, const string& base_filename,
const string& filename_extension) {
assert(enabled_);
assert(!base_filename_selected || !base_filename.empty());
// avoid scanning logs too frequently
if (current_time < next_cleanup_time_) {
return;
}
next_cleanup_time_ =
current_time +
std::chrono::duration_cast<std::chrono::system_clock::duration>(
std::chrono::duration<int32>{FLAGS_logcleansecs});
vector<string> dirs;
if (!base_filename_selected) {
dirs = GetLoggingDirectories();
} else {
size_t pos = base_filename.find_last_of(possible_dir_delim, string::npos,
sizeof(possible_dir_delim));
if (pos != string::npos) {
string dir = base_filename.substr(0, pos + 1);
dirs.push_back(dir);
} else {
dirs.emplace_back(".");
}
}
for (const std::string& dir : dirs) {
vector<string> logs = GetOverdueLogNames(dir, current_time, base_filename,
filename_extension);
for (const std::string& log : logs) {
// NOTE May fail on Windows if the file is still open
int result = unlink(log.c_str());
if (result != 0) {
perror(("Could not remove overdue log " + log).c_str());
}
}
}
} | O0 | cpp | nglog::(anonymous namespace)::LogCleaner::Run(std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
testb $0x1, (%rax)
je 0x14f14
jmp 0x14f33
leaq 0x38be3(%rip), %rdi # 0x4dafe
leaq 0x387a8(%rip), %rsi # 0x4d6ca
movl $0x51a, %edx # imm = 0x51A
leaq 0x38bd9(%rip), %rcx # 0x4db07
callq 0x94a0
movb $0x1, %al
testb $0x1, -0x11(%rbp)
movb %al, -0x139(%rbp)
je 0x14f52
movq -0x20(%rbp), %rdi
callq 0x9c30
xorb $-0x1, %al
movb %al, -0x139(%rbp)
movb -0x139(%rbp), %al
testb $0x1, %al
jne 0x14f5e
jmp 0x14f60
jmp 0x14f7f
leaq 0x38c28(%rip), %rdi # 0x4db8f
leaq 0x3875c(%rip), %rsi # 0x4d6ca
movl $0x51b, %edx # imm = 0x51B
leaq 0x38b8d(%rip), %rcx # 0x4db07
callq 0x94a0
movq -0x138(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x10, %rsi
callq 0x19700
testb $0x1, %al
jne 0x14f99
jmp 0x14f9e
jmp 0x152c4
movq -0x10(%rbp), %rax
movq %rax, -0x148(%rbp)
leaq -0x3c(%rbp), %rdi
leaq 0x5bc3c(%rip), %rsi # 0x70bf0
callq 0x19650
leaq -0x3c(%rbp), %rdi
callq 0x19820
movq -0x148(%rbp), %rdi
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x197d0
movq %rax, %rcx
movq -0x138(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq -0x58(%rbp), %rdi
callq 0x19940
testb $0x1, -0x11(%rbp)
jne 0x15031
callq 0x110d0
movq %rax, -0x150(%rbp)
jmp 0x15009
movq -0x150(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x19960
jmp 0x1501b
jmp 0x150c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x152cd
movq -0x20(%rbp), %rdi
leaq 0x383fc(%rip), %rsi # 0x4d438
movq $-0x1, %rdx
movl $0x1, %ecx
callq 0x9e90
movq %rax, -0x70(%rbp)
cmpq $-0x1, -0x70(%rbp)
je 0x150b2
movq -0x20(%rbp), %rsi
movq -0x70(%rbp), %rcx
incq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x90(%rbp), %rdi
callq 0x9750
jmp 0x15075
leaq -0x58(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x186a0
jmp 0x15087
leaq -0x90(%rbp), %rdi
callq 0x9ea8
jmp 0x150c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x9ea8
jmp 0x152cd
leaq 0x39e64(%rip), %rsi # 0x4ef1d
leaq -0x58(%rbp), %rdi
callq 0x19bb0
jmp 0x150c4
jmp 0x150c6
jmp 0x150c8
leaq -0x58(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
callq 0x18740
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rdi
callq 0x187b0
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x18770
testb $0x1, %al
jne 0x15115
jmp 0x152bb
leaq -0xa0(%rbp), %rdi
callq 0x19c30
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x92e0
jmp 0x1513d
movq -0x138(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq -0xc8(%rbp), %rdi
leaq -0xe8(%rbp), %rdx
callq 0x152e0
jmp 0x15165
leaq -0xe8(%rbp), %rdi
callq 0x9ea8
leaq -0xc8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rdi
callq 0x18740
movq %rax, -0xf8(%rbp)
movq -0xf0(%rbp), %rdi
callq 0x187b0
movq %rax, -0x100(%rbp)
leaq -0xf8(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x18770
testb $0x1, %al
jne 0x151c1
jmp 0x15290
leaq -0xf8(%rbp), %rdi
callq 0x19c30
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rdi
callq 0x92c0
movq %rax, %rdi
callq 0x9330
movl %eax, -0x10c(%rbp)
cmpl $0x0, -0x10c(%rbp)
je 0x1527d
movq -0x108(%rbp), %rdx
leaq 0x389b8(%rip), %rsi # 0x4dbc1
leaq -0x130(%rbp), %rdi
callq 0x19c50
jmp 0x15217
leaq -0x130(%rbp), %rdi
callq 0x92c0
movq %rax, %rdi
callq 0x95b0
jmp 0x1522d
leaq -0x130(%rbp), %rdi
callq 0x9ea8
jmp 0x1527d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x9ea8
jmp 0x152cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x152ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x9ea8
jmp 0x152ad
jmp 0x1527f
leaq -0xf8(%rbp), %rdi
callq 0x188b0
jmp 0x151a5
leaq -0xc8(%rbp), %rdi
callq 0x19d60
leaq -0xa0(%rbp), %rdi
callq 0x188b0
jmp 0x150f9
leaq -0xc8(%rbp), %rdi
callq 0x19d60
jmp 0x152cd
leaq -0x58(%rbp), %rdi
callq 0x19d60
addq $0x150, %rsp # imm = 0x150
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x19d60
movq -0x60(%rbp), %rdi
callq 0x9d00
nop
| _ZN5nglog12_GLOBAL__N_110LogCleaner3RunERKNSt6chrono10time_pointINS2_3_V212system_clockENS2_8durationIlSt5ratioILl1ELl1000000000EEEEEEbRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESK_:
push rbp
mov rbp, rsp
sub rsp, 150h
mov al, dl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
and al, 1
mov [rbp+var_11], al
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_8]
mov [rbp+var_138], rax
test byte ptr [rax], 1
jz short loc_14F14
jmp short loc_14F33
loc_14F14:
lea rdi, aEnabled; "enabled_"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 51Ah
lea rcx, aVoidNglogAnony; "void nglog::(anonymous namespace)::LogC"...
call ___assert_fail
loc_14F33:
mov al, 1
test [rbp+var_11], 1
mov [rbp+var_139], al
jz short loc_14F52
mov rdi, [rbp+var_20]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
xor al, 0FFh
mov [rbp+var_139], al
loc_14F52:
mov al, [rbp+var_139]
test al, 1
jnz short loc_14F5E
jmp short loc_14F60
loc_14F5E:
jmp short loc_14F7F
loc_14F60:
lea rdi, aBaseFilenameSe; "!base_filename_selected || !base_filena"...
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 51Bh
lea rcx, aVoidNglogAnony; "void nglog::(anonymous namespace)::LogC"...
call ___assert_fail
loc_14F7F:
mov rsi, [rbp+var_138]
mov rdi, [rbp+var_10]
add rsi, 10h
call _ZNSt6chronoltINS_3_V212system_clockENS_8durationIlSt5ratioILl1ELl1000000000EEEES6_EEbRKNS_10time_pointIT_T0_EERKNS7_IS8_T1_EE; std::chrono::operator<<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>,std::chrono::duration<long,std::ratio<1l,1000000000l>>>(std::chrono::time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>> const&,std::chrono::time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>> const&)
test al, 1
jnz short loc_14F99
jmp short loc_14F9E
loc_14F99:
jmp loc_152C4
loc_14F9E:
mov rax, [rbp+var_10]
mov [rbp+var_148], rax
lea rdi, [rbp+var_3C]
lea rsi, _ZN3fLI18FLAGS_logcleansecsE; fLI::FLAGS_logcleansecs
call _ZNSt6chrono8durationIiSt5ratioILl1ELl1EEEC2IivEERKT_; std::chrono::duration<int,std::ratio<1l,1l>>::duration<int,void>(int const&)
lea rdi, [rbp+var_3C]
call _ZNSt6chrono13duration_castINS_8durationIlSt5ratioILl1ELl1000000000EEEEiS2_ILl1ELl1EEEENSt9enable_ifIXsr13__is_durationIT_EE5valueES7_E4typeERKNS1_IT0_T1_EE
mov rdi, [rbp+var_148]
mov [rbp+var_38], rax
lea rsi, [rbp+var_38]
call _ZNSt6chronoplINS_3_V212system_clockENS_8durationIlSt5ratioILl1ELl1000000000EEEElS5_EENS_10time_pointIT_NSt11common_typeIJT0_NS3_IT1_T2_EEEE4typeEEERKNS7_IS8_SA_EERKSD_; std::chrono::operator+<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>,long,std::ratio<1l,1000000000l>>(std::chrono::time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>> const&,std::chrono::duration<long,std::ratio<1l,1000000000l>> const&)
mov rcx, rax
mov rax, [rbp+var_138]
mov [rbp+var_30], rcx
mov rcx, [rbp+var_30]
mov [rax+10h], rcx
lea rdi, [rbp+var_58]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
test [rbp+var_11], 1
jnz short loc_15031
call _ZN5nglog21GetLoggingDirectoriesB5cxx11Ev; nglog::GetLoggingDirectories(void)
mov [rbp+var_150], rax
jmp short $+2
loc_15009:
mov rsi, [rbp+var_150]
lea rdi, [rbp+var_58]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEaSERKS7_; std::vector<std::string>::operator=(std::vector<std::string> const&)
jmp short $+2
loc_1501B:
jmp loc_150C8
mov rcx, rax
mov eax, edx
mov [rbp+var_60], rcx
mov [rbp+var_64], eax
jmp loc_152CD
loc_15031:
mov rdi, [rbp+var_20]
lea rsi, _ZN5nglog12_GLOBAL__N_118possible_dir_delimE; nglog::`anonymous namespace'::possible_dir_delim
mov rdx, 0FFFFFFFFFFFFFFFFh
mov ecx, 1
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12find_last_ofEPKcmm; std::string::find_last_of(char const*,ulong,ulong)
mov [rbp+var_70], rax
cmp [rbp+var_70], 0FFFFFFFFFFFFFFFFh
jz short loc_150B2
mov rsi, [rbp+var_20]
mov rcx, [rbp+var_70]
inc rcx
xor eax, eax
mov edx, eax
lea rdi, [rbp+var_90]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
jmp short $+2
loc_15075:
lea rdi, [rbp+var_58]
lea rsi, [rbp+var_90]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
jmp short $+2
loc_15087:
lea rdi, [rbp+var_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_150C6
mov rcx, rax
mov eax, edx
mov [rbp+var_60], rcx
mov [rbp+var_64], eax
lea rdi, [rbp+var_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_152CD
loc_150B2:
lea rsi, aSectionNameSIs+50h; "."
lea rdi, [rbp+var_58]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJRA2_KcEEERS5_DpOT_; std::vector<std::string>::emplace_back<char const(&)[2]>(char const(&)[2] &&)
jmp short $+2
loc_150C4:
jmp short $+2
loc_150C6:
jmp short $+2
loc_150C8:
lea rax, [rbp+var_58]
mov [rbp+var_98], rax
mov rdi, [rbp+var_98]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5beginEv; std::vector<std::string>::begin(void)
mov [rbp+var_A0], rax
mov rdi, [rbp+var_98]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE3endEv; std::vector<std::string>::end(void)
mov [rbp+var_A8], rax
loc_150F9:
lea rdi, [rbp+var_A0]
lea rsi, [rbp+var_A8]
call _ZN9__gnu_cxxneIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESG_; __gnu_cxx::operator!=<std::string *,std::vector<std::string>>(__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>> const&,__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>> const&)
test al, 1
jnz short loc_15115
jmp loc_152BB
loc_15115:
lea rdi, [rbp+var_A0]
call _ZNK9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEdeEv; __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator*(void)
mov [rbp+var_B0], rax
mov rsi, [rbp+var_B0]
lea rdi, [rbp+var_E8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1ERKS4_; std::string::basic_string(std::string const&)
jmp short $+2
loc_1513D:
mov rsi, [rbp+var_138]
mov rcx, [rbp+var_10]
mov r8, [rbp+var_20]
mov r9, [rbp+var_28]
lea rdi, [rbp+var_C8]
lea rdx, [rbp+var_E8]
call _ZNK5nglog12_GLOBAL__N_110LogCleaner18GetOverdueLogNamesENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNSt6chrono10time_pointINS8_3_V212system_clockENS8_8durationIlSt5ratioILl1ELl1000000000EEEEEERKS7_SK_; nglog::`anonymous namespace'::LogCleaner::GetOverdueLogNames(std::string,std::chrono::time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>> const&,std::string const&,std::string const&)
jmp short $+2
loc_15165:
lea rdi, [rbp+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rax, [rbp+var_C8]
mov [rbp+var_F0], rax
mov rdi, [rbp+var_F0]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5beginEv; std::vector<std::string>::begin(void)
mov [rbp+var_F8], rax
mov rdi, [rbp+var_F0]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE3endEv; std::vector<std::string>::end(void)
mov [rbp+var_100], rax
loc_151A5:
lea rdi, [rbp+var_F8]
lea rsi, [rbp+var_100]
call _ZN9__gnu_cxxneIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESG_; __gnu_cxx::operator!=<std::string *,std::vector<std::string>>(__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>> const&,__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>> const&)
test al, 1
jnz short loc_151C1
jmp loc_15290
loc_151C1:
lea rdi, [rbp+var_F8]
call _ZNK9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEdeEv; __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator*(void)
mov [rbp+var_108], rax
mov rdi, [rbp+var_108]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, rax
call _unlink
mov [rbp+var_10C], eax
cmp [rbp+var_10C], 0
jz loc_1527D
mov rdx, [rbp+var_108]
lea rsi, aCouldNotRemove; "Could not remove overdue log "
lea rdi, [rbp+var_130]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
jmp short $+2
loc_15217:
lea rdi, [rbp+var_130]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, rax
call _perror
jmp short $+2
loc_1522D:
lea rdi, [rbp+var_130]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_1527D
mov rcx, rax
mov eax, edx
mov [rbp+var_60], rcx
mov [rbp+var_64], eax
lea rdi, [rbp+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_152CD
mov rcx, rax
mov eax, edx
mov [rbp+var_60], rcx
mov [rbp+var_64], eax
jmp short loc_152AD
mov rcx, rax
mov eax, edx
mov [rbp+var_60], rcx
mov [rbp+var_64], eax
lea rdi, [rbp+var_130]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_152AD
loc_1527D:
jmp short $+2
loc_1527F:
lea rdi, [rbp+var_F8]
call _ZN9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEppEv; __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator++(void)
jmp loc_151A5
loc_15290:
lea rdi, [rbp+var_C8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rbp+var_A0]
call _ZN9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEppEv; __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator++(void)
jmp loc_150F9
loc_152AD:
lea rdi, [rbp+var_C8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_152CD
loc_152BB:
lea rdi, [rbp+var_58]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_152C4:
add rsp, 150h
pop rbp
retn
loc_152CD:
lea rdi, [rbp+var_58]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rbp+var_60]
call __Unwind_Resume
| long long nglog::`anonymous namespace'::LogCleaner::Run(
long long a1,
long long a2,
char a3,
long long a4,
long long a5)
{
long long result; // rax
long long v6; // rax
long long v7; // rax
long long v8; // [rsp+0h] [rbp-150h]
long long v9; // [rsp+8h] [rbp-148h]
char v10; // [rsp+17h] [rbp-139h]
_BYTE v11[36]; // [rsp+20h] [rbp-130h] BYREF
long long v13; // [rsp+48h] [rbp-108h]
long long v14; // [rsp+50h] [rbp-100h] BYREF
long long v15; // [rsp+58h] [rbp-F8h] BYREF
_BYTE *v16; // [rsp+60h] [rbp-F0h]
_BYTE v17[32]; // [rsp+68h] [rbp-E8h] BYREF
_BYTE v18[24]; // [rsp+88h] [rbp-C8h] BYREF
long long v19; // [rsp+A0h] [rbp-B0h]
long long v20; // [rsp+A8h] [rbp-A8h] BYREF
_QWORD v21[2]; // [rsp+B0h] [rbp-A0h] BYREF
_BYTE v22[32]; // [rsp+C0h] [rbp-90h] BYREF
long long last_of; // [rsp+E0h] [rbp-70h]
_BYTE v24[28]; // [rsp+F8h] [rbp-58h] BYREF
_BYTE v25[4]; // [rsp+114h] [rbp-3Ch] BYREF
long long v26; // [rsp+118h] [rbp-38h] BYREF
long long v27; // [rsp+120h] [rbp-30h]
long long v28; // [rsp+128h] [rbp-28h]
long long v29; // [rsp+130h] [rbp-20h]
char v30; // [rsp+13Fh] [rbp-11h]
long long v31; // [rsp+140h] [rbp-10h]
long long v32; // [rsp+148h] [rbp-8h]
v32 = a1;
v31 = a2;
v30 = a3 & 1;
v29 = a4;
v28 = a5;
if ( (*(_BYTE *)a1 & 1) == 0 )
__assert_fail(
"enabled_",
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",
1306LL,
"void nglog::(anonymous namespace)::LogCleaner::Run(const std::chrono::system_clock::time_point &, bool, const stri"
"ng &, const string &)");
v10 = 1;
if ( (v30 & 1) != 0 )
v10 = ~(unsigned __int8)std::string::empty(v29);
if ( (v10 & 1) == 0 )
__assert_fail(
"!base_filename_selected || !base_filename.empty()",
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",
1307LL,
"void nglog::(anonymous namespace)::LogCleaner::Run(const std::chrono::system_clock::time_point &, bool, const stri"
"ng &, const string &)");
result = std::chrono::operator<<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>,std::chrono::duration<long,std::ratio<1l,1000000000l>>>(
v31,
a1 + 16);
if ( (result & 1) == 0 )
{
v9 = v31;
std::chrono::duration<int,std::ratio<1l,1l>>::duration<int,void>(v25, &fLI::FLAGS_logcleansecs);
v26 = std::chrono::duration_cast<std::chrono::duration<long,std::ratio<1l,1000000000l>>,int,std::ratio<1l,1l>>(v25);
v27 = std::chrono::operator+<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1l,1000000000l>>,long,std::ratio<1l,1000000000l>>(
v9,
&v26);
*(_QWORD *)(a1 + 16) = v27;
std::vector<std::string>::vector(v24);
if ( (v30 & 1) != 0 )
{
last_of = std::string::find_last_of(v29, &nglog::`anonymous namespace'::possible_dir_delim, -1LL, 1LL);
if ( last_of == -1 )
{
std::vector<std::string>::emplace_back<char const(&)[2]>(v24, ".");
}
else
{
std::string::substr(v22, v29, 0LL, last_of + 1);
std::vector<std::string>::push_back(v24, v22);
std::string::~string(v22);
}
}
else
{
v8 = nglog::GetLoggingDirectories[abi:cxx11]();
std::vector<std::string>::operator=(v24, v8);
}
v21[1] = v24;
v21[0] = std::vector<std::string>::begin(v24);
v20 = std::vector<std::string>::end(v24);
while ( (__gnu_cxx::operator!=<std::string *,std::vector<std::string>>(v21, &v20) & 1) != 0 )
{
v19 = __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator*(v21);
std::string::basic_string(v17, v19);
nglog::`anonymous namespace'::LogCleaner::GetOverdueLogNames(v18, a1, v17, v31, v29, v28);
std::string::~string(v17);
v16 = v18;
v15 = std::vector<std::string>::begin(v18);
v14 = std::vector<std::string>::end(v16);
while ( (__gnu_cxx::operator!=<std::string *,std::vector<std::string>>(&v15, &v14) & 1) != 0 )
{
v13 = __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator*(&v15);
v6 = std::string::c_str(v13);
if ( (unsigned int)unlink(v6) )
{
std::operator+<char>(v11, "Could not remove overdue log ", v13);
v7 = std::string::c_str(v11);
perror(v7);
std::string::~string(v11);
}
__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator++(&v15);
}
std::vector<std::string>::~vector(v18);
__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator++(v21);
}
return std::vector<std::string>::~vector(v24);
}
return result;
}
| Run:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x150
MOV AL,DL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
AND AL,0x1
MOV byte ptr [RBP + -0x11],AL
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x138],RAX
TEST byte ptr [RAX],0x1
JZ 0x00114f14
JMP 0x00114f33
LAB_00114f14:
LEA RDI,[0x14dafe]
LEA RSI,[0x14d6ca]
MOV EDX,0x51a
LEA RCX,[0x14db07]
CALL 0x001094a0
LAB_00114f33:
MOV AL,0x1
TEST byte ptr [RBP + -0x11],0x1
MOV byte ptr [RBP + -0x139],AL
JZ 0x00114f52
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00109c30
XOR AL,0xff
MOV byte ptr [RBP + -0x139],AL
LAB_00114f52:
MOV AL,byte ptr [RBP + -0x139]
TEST AL,0x1
JNZ 0x00114f5e
JMP 0x00114f60
LAB_00114f5e:
JMP 0x00114f7f
LAB_00114f60:
LEA RDI,[0x14db8f]
LEA RSI,[0x14d6ca]
MOV EDX,0x51b
LEA RCX,[0x14db07]
CALL 0x001094a0
LAB_00114f7f:
MOV RSI,qword ptr [RBP + -0x138]
MOV RDI,qword ptr [RBP + -0x10]
ADD RSI,0x10
CALL 0x00119700
TEST AL,0x1
JNZ 0x00114f99
JMP 0x00114f9e
LAB_00114f99:
JMP 0x001152c4
LAB_00114f9e:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x148],RAX
LEA RDI,[RBP + -0x3c]
LEA RSI,[0x170bf0]
CALL 0x00119650
LEA RDI,[RBP + -0x3c]
CALL 0x00119820
MOV RDI,qword ptr [RBP + -0x148]
MOV qword ptr [RBP + -0x38],RAX
LEA RSI,[RBP + -0x38]
CALL 0x001197d0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x138]
MOV qword ptr [RBP + -0x30],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x10],RCX
LEA RDI,[RBP + -0x58]
CALL 0x00119940
TEST byte ptr [RBP + -0x11],0x1
JNZ 0x00115031
LAB_00114ffb:
CALL 0x001110d0
MOV qword ptr [RBP + -0x150],RAX
JMP 0x00115009
LAB_00115009:
MOV RSI,qword ptr [RBP + -0x150]
LEA RDI,[RBP + -0x58]
CALL 0x00119960
JMP 0x0011501b
LAB_0011501b:
JMP 0x001150c8
LAB_00115031:
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[0x14d438]
MOV RDX,-0x1
MOV ECX,0x1
CALL 0x00109e90
MOV qword ptr [RBP + -0x70],RAX
CMP qword ptr [RBP + -0x70],-0x1
JZ 0x001150b2
MOV RSI,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x70]
INC RCX
XOR EAX,EAX
MOV EDX,EAX
LEA RDI,[RBP + -0x90]
CALL 0x00109750
JMP 0x00115075
LAB_00115075:
LEA RDI,[RBP + -0x58]
LEA RSI,[RBP + -0x90]
CALL 0x001186a0
JMP 0x00115087
LAB_00115087:
LEA RDI,[RBP + -0x90]
CALL 0x00109ea8
JMP 0x001150c6
LAB_001150b2:
LEA RSI,[0x14ef1d]
LEA RDI,[RBP + -0x58]
CALL 0x00119bb0
JMP 0x001150c4
LAB_001150c4:
JMP 0x001150c6
LAB_001150c6:
JMP 0x001150c8
LAB_001150c8:
LEA RAX,[RBP + -0x58]
MOV qword ptr [RBP + -0x98],RAX
MOV RDI,qword ptr [RBP + -0x98]
CALL 0x00118740
MOV qword ptr [RBP + -0xa0],RAX
MOV RDI,qword ptr [RBP + -0x98]
CALL 0x001187b0
MOV qword ptr [RBP + -0xa8],RAX
LAB_001150f9:
LEA RDI,[RBP + -0xa0]
LEA RSI,[RBP + -0xa8]
CALL 0x00118770
TEST AL,0x1
JNZ 0x00115115
JMP 0x001152bb
LAB_00115115:
LEA RDI,[RBP + -0xa0]
CALL 0x00119c30
MOV qword ptr [RBP + -0xb0],RAX
MOV RSI,qword ptr [RBP + -0xb0]
LEA RDI,[RBP + -0xe8]
CALL 0x001092e0
JMP 0x0011513d
LAB_0011513d:
MOV RSI,qword ptr [RBP + -0x138]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8,qword ptr [RBP + -0x20]
MOV R9,qword ptr [RBP + -0x28]
LAB_00115150:
LEA RDI,[RBP + -0xc8]
LEA RDX,[RBP + -0xe8]
CALL 0x001152e0
JMP 0x00115165
LAB_00115165:
LEA RDI,[RBP + -0xe8]
CALL 0x00109ea8
LEA RAX,[RBP + -0xc8]
MOV qword ptr [RBP + -0xf0],RAX
MOV RDI,qword ptr [RBP + -0xf0]
CALL 0x00118740
MOV qword ptr [RBP + -0xf8],RAX
MOV RDI,qword ptr [RBP + -0xf0]
CALL 0x001187b0
MOV qword ptr [RBP + -0x100],RAX
LAB_001151a5:
LEA RDI,[RBP + -0xf8]
LEA RSI,[RBP + -0x100]
CALL 0x00118770
TEST AL,0x1
JNZ 0x001151c1
JMP 0x00115290
LAB_001151c1:
LEA RDI,[RBP + -0xf8]
CALL 0x00119c30
MOV qword ptr [RBP + -0x108],RAX
MOV RDI,qword ptr [RBP + -0x108]
CALL 0x001092c0
MOV RDI,RAX
CALL 0x00109330
MOV dword ptr [RBP + -0x10c],EAX
CMP dword ptr [RBP + -0x10c],0x0
JZ 0x0011527d
MOV RDX,qword ptr [RBP + -0x108]
LAB_00115202:
LEA RSI,[0x14dbc1]
LEA RDI,[RBP + -0x130]
CALL 0x00119c50
JMP 0x00115217
LAB_00115217:
LEA RDI,[RBP + -0x130]
CALL 0x001092c0
MOV RDI,RAX
LAB_00115226:
CALL 0x001095b0
LAB_0011522b:
JMP 0x0011522d
LAB_0011522d:
LEA RDI,[RBP + -0x130]
CALL 0x00109ea8
JMP 0x0011527d
LAB_0011527d:
JMP 0x0011527f
LAB_0011527f:
LEA RDI,[RBP + -0xf8]
CALL 0x001188b0
JMP 0x001151a5
LAB_00115290:
LEA RDI,[RBP + -0xc8]
CALL 0x00119d60
LEA RDI,[RBP + -0xa0]
CALL 0x001188b0
JMP 0x001150f9
LAB_001152bb:
LEA RDI,[RBP + -0x58]
CALL 0x00119d60
LAB_001152c4:
ADD RSP,0x150
POP RBP
RET
|
/* nglog::(anonymous
namespace)::LogCleaner::Run(std::chrono::time_point<std::chrono::_V2::system_clock,
std::chrono::duration<long, std::ratio<1l, 1000000000l> > > const&, bool, std::__cxx11::string
const&, std::__cxx11::string const&) */
void __thiscall
nglog::(anonymous_namespace)::LogCleaner::Run
(LogCleaner *this,time_point *param_1,bool param_2,string *param_3,string *param_4)
{
time_point *ptVar1;
bool bVar2;
vector *pvVar3;
char *pcVar4;
byte local_141;
string local_138 [36];
int local_114;
int8 local_110;
int8 local_108;
int8 local_100;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_f8;
string local_f0 [32];
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_d0 [24];
string *local_b8;
int8 local_b0;
int8 local_a8;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_a0;
string local_98 [32];
long local_78;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_60 [28];
duration<int,std::ratio<1l,1l>> local_44 [4];
int8 local_40;
int8 local_38;
string *local_30;
string *local_28;
byte local_19;
time_point *local_18;
LogCleaner *local_10;
local_30 = param_4;
local_28 = param_3;
local_19 = param_2;
local_18 = param_1;
local_10 = this;
if (((byte)*this & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("enabled_",
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",0x51a,
"void nglog::(anonymous namespace)::LogCleaner::Run(const std::chrono::system_clock::time_point &, bool, const string &, const string &)"
);
}
local_141 = 1;
if (param_2) {
local_141 = std::__cxx11::string::empty();
local_141 = local_141 ^ 0xff;
}
if ((local_141 & 1) != 0) {
bVar2 = std::chrono::operator<(local_18,this + 0x10);
ptVar1 = local_18;
if (!bVar2) {
std::chrono::duration<int,std::ratio<1l,1l>>::duration<int,void>
(local_44,&fLI::FLAGS_logcleansecs);
local_40 = std::chrono::
duration_cast<std::chrono::duration<long,std::ratio<1l,1000000000l>>,int,std::ratio<1l,1l>>
((duration *)local_44);
local_38 = std::chrono::operator+(ptVar1,(duration *)&local_40);
*(int8 *)(this + 0x10) = local_38;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector(local_60);
if ((local_19 & 1) == 0) {
/* try { // try from 00114ffb to 00115072 has its CatchHandler @ 00115020 */
pvVar3 = (vector *)GetLoggingDirectories_abi_cxx11_();
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator=
(local_60,pvVar3);
}
else {
local_78 = std::__cxx11::string::find_last_of((char *)local_28,0x14d438,0xffffffffffffffff);
if (local_78 == -1) {
/* try { // try from 001150b2 to 0011513a has its CatchHandler @ 00115020 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<char_const(&)[2]>(local_60,".");
}
else {
std::__cxx11::string::substr((ulong)local_98,(ulong)local_28);
/* try { // try from 00115075 to 00115084 has its CatchHandler @ 00115095 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
(local_60,local_98);
std::__cxx11::string::~string(local_98);
}
}
local_a0 = local_60;
local_a8 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::begin
(local_a0);
local_b0 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::end
(local_a0);
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_a8,(__normal_iterator *)&local_b0),
bVar2) {
local_b8 = (string *)
__gnu_cxx::
__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::operator*((__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
*)&local_a8);
std::__cxx11::string::string(local_f0,local_b8);
/* try { // try from 00115150 to 00115162 has its CatchHandler @ 0011523b */
GetOverdueLogNames(local_d0,this,local_f0,local_18,local_28,local_30);
std::__cxx11::string::~string(local_f0);
local_f8 = local_d0;
local_100 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::begin
(local_f8);
local_108 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::end
(local_f8);
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_100,(__normal_iterator *)&local_108),
bVar2) {
local_110 = __gnu_cxx::
__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::operator*((__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
*)&local_100);
pcVar4 = (char *)std::__cxx11::string::c_str();
local_114 = unlink(pcVar4);
if (local_114 != 0) {
/* try { // try from 00115202 to 00115214 has its CatchHandler @ 00115255 */
std::operator+((char *)local_138,(string *)"Could not remove overdue log ");
pcVar4 = (char *)std::__cxx11::string::c_str();
/* try { // try from 00115226 to 0011522a has its CatchHandler @ 00115263 */
perror(pcVar4);
std::__cxx11::string::~string(local_138);
}
__gnu_cxx::
__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::operator++((__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
*)&local_100);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_d0);
__gnu_cxx::
__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::operator++((__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
*)&local_a8);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_60);
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("!base_filename_selected || !base_filename.empty()",
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",0x51b,
"void nglog::(anonymous namespace)::LogCleaner::Run(const std::chrono::system_clock::time_point &, bool, const string &, const string &)"
);
}
| |
24,123 | 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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) | monkey531[P]llama/common/json.hpp | void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
{
//not initialized (e.g. due to exception in the ctor)
return;
}
if (t == value_t::array || t == value_t::object)
{
// flatten the current json_value to a heap-allocated stack
std::vector<basic_json> stack;
// move the top-level items to stack
if (t == value_t::array)
{
stack.reserve(array->size());
std::move(array->begin(), array->end(), std::back_inserter(stack));
}
else
{
stack.reserve(object->size());
for (auto&& it : *object)
{
stack.push_back(std::move(it.second));
}
}
while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
stack.pop_back();
// if current_item is array/object, move
// its children to the stack to be processed later
if (current_item.is_array())
{
std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
current_item.m_data.m_value.array->clear();
}
else if (current_item.is_object())
{
for (auto&& it : *current_item.m_data.m_value.object)
{
stack.push_back(std::move(it.second));
}
current_item.m_data.m_value.object->clear();
}
// it's now safe that current_item get destructed
// since it doesn't have any children
}
}
switch (t)
{
case value_t::object:
{
AllocatorType<object_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
break;
}
case value_t::array:
{
AllocatorType<array_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
break;
}
case value_t::string:
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
break;
}
case value_t::binary:
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
break;
}
case value_t::null:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::discarded:
default:
{
break;
}
}
} | O2 | 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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %esi
sete %al
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testb %dl, %al
jne 0x435ac
movl %esi, %r14d
testq %rcx, %rcx
sete %al
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
testb %al, %sil
jne 0x435ac
movq %rdi, %rbx
leal -0x1(%r14), %eax
cmpb $0x1, %al
ja 0x4351a
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq 0x8(%rcx), %rax
subq (%rcx), %rax
cmpb $0x2, %r14b
jne 0x43543
sarq $0x4, %rax
movq %rsp, %rdi
movq %rax, %rsi
callq 0x435e2
movq (%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %rsp, %rdx
callq 0x436bc
leaq 0x18(%rsp), %r15
movq %rsp, %r12
movq 0x8(%rsp), %rsi
cmpq %rsi, (%rsp)
je 0x43512
addq $-0x10, %rsi
movq %r15, %rdi
callq 0x4249c
movq 0x8(%rsp), %rdi
addq $-0x10, %rdi
movq %rdi, 0x8(%rsp)
callq 0x3dbf2
movzbl 0x18(%rsp), %eax
cmpl $0x1, %eax
je 0x434d5
cmpl $0x2, %eax
jne 0x43505
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %r12, %rdx
callq 0x436bc
movq 0x20(%rsp), %rdi
callq 0x4368a
jmp 0x43505
movq 0x20(%rsp), %rax
movq (%rax), %r13
movq 0x8(%rax), %rbp
cmpq %rbp, %r13
je 0x434fb
addq $0x20, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x424d0
addq $0x10, %r13
jmp 0x434e1
movq 0x20(%rsp), %rdi
callq 0x43692
movq %r15, %rdi
callq 0x3dbf2
jmp 0x43478
movq %rsp, %rdi
callq 0x4369a
movzbl %r14b, %eax
decl %eax
cmpl $0x7, %eax
ja 0x435ac
leaq 0x678c8(%rip), %rcx # 0xaadf8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x43754
jmp 0x43589
pushq $0x30
popq %rcx
cqto
idivq %rcx
movq %rsp, %rdi
movq %rax, %rsi
callq 0x435e2
movq (%rbx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
movq %rsp, %r12
cmpq %r13, %r15
je 0x43470
addq $0x20, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x424d0
addq $0x10, %r15
jmp 0x43563
movq (%rbx), %rdi
callq 0x24158
pushq $0x20
jmp 0x435a3
movq (%rbx), %rdi
callq 0x4369a
pushq $0x18
jmp 0x435a3
movq (%rbx), %rdi
callq 0x4335a
pushq $0x28
popq %rsi
movq (%rbx), %rdi
callq 0x238b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x435bf
jmp 0x435c4
movq %rax, %rbx
jmp 0x435d1
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3dbf2
movq %rsp, %rdi
callq 0x4369a
movq %rbx, %rdi
callq 0x23f20
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
cmp esi, 1
setz al
mov rcx, [rdi]
test rcx, rcx
setz dl
test al, dl
jnz def_43537; jumptable 0000000000043537 default case, cases 4-7
mov r14d, esi
test rcx, rcx
setz al
mov edx, r14d
and dl, 0FEh
cmp dl, 2
setz dl
cmp r14b, 8
setz sil
or sil, dl
test sil, al
jnz def_43537; jumptable 0000000000043537 default case, cases 4-7
mov rbx, rdi
lea eax, [r14-1]
cmp al, 1
ja loc_4351A
xorps xmm0, xmm0
movaps [rsp+58h+var_58], xmm0
and [rsp+58h+var_48], 0
mov rax, [rcx+8]
sub rax, [rcx]
cmp r14b, 2
jnz loc_43543
sar rax, 4
mov rdi, rsp
mov rsi, rax
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov rdi, [rax]
mov rsi, [rax+8]
mov rdx, rsp
call _ZNSt11__copy_moveILb1ELb0ESt26random_access_iterator_tagE8__copy_mIPN8nlohmann16json_abi_v3_11_310basic_jsonINS4_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS4_14adl_serializerES7_IhSaIhEEvEESt20back_insert_iteratorIS7_ISH_SaISH_EEEEET0_T_SO_SN_; std::__copy_move<true,false,std::random_access_iterator_tag>::__copy_m<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
loc_43470:
lea r15, [rsp+58h+var_40]
mov r12, rsp
loc_43478:
mov rsi, qword ptr [rsp+58h+var_58+8]
cmp qword ptr [rsp+58h+var_58], rsi
jz loc_43512
add rsi, 0FFFFFFFFFFFFFFF0h
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; 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>&&)
mov rdi, qword ptr [rsp+58h+var_58+8]
add rdi, 0FFFFFFFFFFFFFFF0h
mov qword ptr [rsp+58h+var_58+8], rdi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; 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()
movzx eax, [rsp+58h+var_40]
cmp eax, 1
jz short loc_434D5
cmp eax, 2
jnz short loc_43505
mov rax, [rsp+58h+var_38]
mov rdi, [rax]
mov rsi, [rax+8]
mov rdx, r12
call _ZNSt11__copy_moveILb1ELb0ESt26random_access_iterator_tagE8__copy_mIPN8nlohmann16json_abi_v3_11_310basic_jsonINS4_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS4_14adl_serializerES7_IhSaIhEEvEESt20back_insert_iteratorIS7_ISH_SaISH_EEEEET0_T_SO_SN_; std::__copy_move<true,false,std::random_access_iterator_tag>::__copy_m<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov rdi, [rsp+58h+var_38]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE5clearEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::clear(void)
jmp short loc_43505
loc_434D5:
mov rax, [rsp+58h+var_38]
mov r13, [rax]
mov rbp, [rax+8]
loc_434E1:
cmp r13, rbp
jz short loc_434FB
add r13, 20h ; ' '
mov rdi, r12
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(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> &&)
add r13, 10h
jmp short loc_434E1
loc_434FB:
mov rdi, [rsp+58h+var_38]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE5clearEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::clear(void)
loc_43505:
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; 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()
jmp loc_43478
loc_43512:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
loc_4351A:
movzx eax, r14b
dec eax; switch 8 cases
cmp eax, 7
ja def_43537; jumptable 0000000000043537 default case, cases 4-7
lea rcx, jpt_43537
movsxd rax, ds:(jpt_43537 - 0AADF8h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_43539:
mov rdi, [rbx]; jumptable 0000000000043537 case 1
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EED2Ev; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::~vector()
jmp short loc_43589
loc_43543:
push 30h ; '0'
pop rcx
cqo
idiv rcx
mov rdi, rsp
mov rsi, rax
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r15, [rax]
mov r13, [rax+8]
mov r12, rsp
loc_43563:
cmp r15, r13
jz loc_43470
add r15, 20h ; ' '
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(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> &&)
add r15, 10h
jmp short loc_43563
loc_43581:
mov rdi, [rbx]; jumptable 0000000000043537 case 3
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_43589:
push 20h ; ' '
jmp short loc_435A3
loc_4358D:
mov rdi, [rbx]; jumptable 0000000000043537 case 2
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
push 18h
jmp short loc_435A3
loc_43599:
mov rdi, [rbx]; jumptable 0000000000043537 case 8
call _ZNSt12_Vector_baseIhSaIhEED2Ev; std::_Vector_base<uchar>::~_Vector_base()
push 28h ; '('
loc_435A3:
pop rsi; unsigned __int64
mov rdi, [rbx]; void *
call __ZdlPvm; operator delete(void *,ulong)
def_43537:
add rsp, 28h; jumptable 0000000000043537 default case, cases 4-7
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_435BF
jmp short loc_435C4
loc_435BF:
mov rbx, rax
jmp short loc_435D1
loc_435C4:
mov rbx, rax
lea rdi, [rsp+arg_10]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; 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()
loc_435D1:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, rbx
call __Unwind_Resume
| void 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>::json_value::destroy(
void **a1,
unsigned int a2)
{
_QWORD *v2; // rcx
long long v3; // rdx
long long v4; // rax
long long v5; // r13
long long v6; // rbp
long long v7; // r15
long long v8; // r13
long long v9; // r15
__int128 v10; // [rsp+0h] [rbp-58h] BYREF
long long v11; // [rsp+10h] [rbp-48h]
char v12[8]; // [rsp+18h] [rbp-40h] BYREF
_QWORD *v13; // [rsp+20h] [rbp-38h]
v2 = *a1;
if ( *a1 != 0LL || a2 != 1 )
{
v3 = a2;
LOBYTE(v3) = (a2 & 0xFE) == 2;
if ( ((v2 == 0LL) & (unsigned __int8)(v3 | ((_BYTE)a2 == 8))) == 0 )
{
if ( (unsigned __int8)(a2 - 1) <= 1u )
{
v10 = 0LL;
v11 = 0LL;
v4 = v2[1] - *v2;
if ( (_BYTE)a2 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v10,
v4 >> 4,
v3);
std::__copy_move<true,false,std::random_access_iterator_tag>::__copy_m<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>(
*(_QWORD *)*a1,
*((_QWORD *)*a1 + 1),
&v10);
}
else
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v10,
v4 / 48,
v4 % 48);
v7 = *(_QWORD *)*a1;
v8 = *((_QWORD *)*a1 + 1);
while ( v7 != v8 )
{
v9 = v7 + 32;
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v10,
v9);
v7 = v9 + 16;
}
}
while ( (_QWORD)v10 != *((_QWORD *)&v10 + 1) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v12,
*((_QWORD *)&v10 + 1) - 16LL);
*((_QWORD *)&v10 + 1) -= 16LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json(*((long long *)&v10 + 1));
if ( v12[0] == 1 )
{
v5 = *v13;
v6 = v13[1];
while ( v5 != v6 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v10,
v5 + 32);
v5 += 48LL;
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::clear(v13);
}
else if ( v12[0] == 2 )
{
std::__copy_move<true,false,std::random_access_iterator_tag>::__copy_m<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>(
*v13,
v13[1],
&v10);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::clear(v13);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v12);
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(&v10);
}
switch ( (char)a2 )
{
case 1:
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::~vector(*a1);
goto LABEL_22;
case 2:
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(*a1);
operator delete(*a1, 0x18uLL);
break;
case 3:
std::string::~string(*a1);
LABEL_22:
operator delete(*a1, 0x20uLL);
break;
case 8:
std::_Vector_base<unsigned char>::~_Vector_base(*a1);
operator delete(*a1, 0x28uLL);
break;
default:
return;
}
}
}
}
| destroy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
CMP ESI,0x1
SETZ AL
MOV RCX,qword ptr [RDI]
TEST RCX,RCX
SETZ DL
TEST AL,DL
JNZ 0x001435ac
MOV R14D,ESI
TEST RCX,RCX
SETZ AL
MOV EDX,R14D
AND DL,0xfe
CMP DL,0x2
SETZ DL
CMP R14B,0x8
SETZ SIL
OR SIL,DL
TEST SIL,AL
JNZ 0x001435ac
MOV RBX,RDI
LEA EAX,[R14 + -0x1]
CMP AL,0x1
JA 0x0014351a
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
AND qword ptr [RSP + 0x10],0x0
MOV RAX,qword ptr [RCX + 0x8]
SUB RAX,qword ptr [RCX]
CMP R14B,0x2
JNZ 0x00143543
SAR RAX,0x4
LAB_00143453:
MOV RDI,RSP
MOV RSI,RAX
CALL 0x001435e2
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
MOV RDX,RSP
CALL 0x001436bc
LAB_00143470:
LEA R15,[RSP + 0x18]
MOV R12,RSP
LAB_00143478:
MOV RSI,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],RSI
JZ 0x00143512
ADD RSI,-0x10
MOV RDI,R15
CALL 0x0014249c
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,-0x10
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0013dbf2
MOVZX EAX,byte ptr [RSP + 0x18]
CMP EAX,0x1
JZ 0x001434d5
CMP EAX,0x2
JNZ 0x00143505
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
LAB_001434c1:
MOV RDX,R12
CALL 0x001436bc
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x0014368a
JMP 0x00143505
LAB_001434d5:
MOV RAX,qword ptr [RSP + 0x20]
MOV R13,qword ptr [RAX]
MOV RBP,qword ptr [RAX + 0x8]
LAB_001434e1:
CMP R13,RBP
JZ 0x001434fb
ADD R13,0x20
LAB_001434ea:
MOV RDI,R12
MOV RSI,R13
CALL 0x001424d0
ADD R13,0x10
JMP 0x001434e1
LAB_001434fb:
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00143692
LAB_00143505:
MOV RDI,R15
CALL 0x0013dbf2
JMP 0x00143478
LAB_00143512:
MOV RDI,RSP
CALL 0x0014369a
LAB_0014351a:
MOVZX EAX,R14B
DEC EAX
CMP EAX,0x7
JA 0x001435ac
LEA RCX,[0x1aadf8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBX]
CALL 0x00143754
JMP 0x00143589
LAB_00143543:
PUSH 0x30
POP RCX
CQO
IDIV RCX
LAB_0014354b:
MOV RDI,RSP
MOV RSI,RAX
CALL 0x001435e2
MOV RAX,qword ptr [RBX]
MOV R15,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
MOV R12,RSP
LAB_00143563:
CMP R15,R13
JZ 0x00143470
ADD R15,0x20
LAB_00143570:
MOV RDI,R12
MOV RSI,R15
CALL 0x001424d0
LAB_0014357b:
ADD R15,0x10
JMP 0x00143563
caseD_3:
MOV RDI,qword ptr [RBX]
CALL 0x00124158
LAB_00143589:
PUSH 0x20
JMP 0x001435a3
caseD_2:
MOV RDI,qword ptr [RBX]
CALL 0x0014369a
PUSH 0x18
JMP 0x001435a3
caseD_8:
MOV RDI,qword ptr [RBX]
CALL 0x0014335a
PUSH 0x28
LAB_001435a3:
POP RSI
MOV RDI,qword ptr [RBX]
CALL 0x001238b0
caseD_4:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) */
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>
::json_value::destroy(json_value *this,uint param_2)
{
long *plVar1;
long lVar2;
byte bVar3;
long lVar4;
ulong uStack_60;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*local_58;
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>
*pbStack_50;
int8 local_48;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_40 [8];
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*local_38;
plVar1 = *(long **)this;
if (param_2 == 1 && plVar1 == (long *)0x0) {
return;
}
bVar3 = (byte)param_2;
if ((bVar3 == 8 || (bVar3 & 0xfe) == 2) && plVar1 == (long *)0x0) {
return;
}
if ((byte)(bVar3 - 1) < 2) {
local_58 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)0x0;
pbStack_50 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)0x0;
local_48 = 0;
if (bVar3 == 2) {
/* try { // try from 00143453 to 0014346f has its CatchHandler @ 001435bb */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_58,plVar1[1] - *plVar1 >> 4);
std::__copy_move<true,false,std::random_access_iterator_tag>::
__copy_m<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
(**(int8 **)this,(*(int8 **)this)[1],&local_58);
}
else {
/* try { // try from 0014354b to 00143555 has its CatchHandler @ 001435bb */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_58,(plVar1[1] - *plVar1) / 0x30);
lVar2 = (*(long **)this)[1];
for (lVar4 = **(long **)this; lVar4 != lVar2; lVar4 = lVar4 + 0x30) {
/* try { // try from 00143570 to 0014357a has its CatchHandler @ 001435bf */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_58,(basic_json *)(lVar4 + 0x20));
}
}
while (local_58 != pbStack_50) {
basic_json(local_40,pbStack_50 + -0x10);
pbStack_50 = pbStack_50 + -0x10;
~basic_json(pbStack_50);
if (local_40[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>
)0x1) {
lVar2 = *(long *)(local_38 + 8);
for (lVar4 = *(long *)local_38; lVar4 != lVar2; lVar4 = lVar4 + 0x30) {
/* try { // try from 001434ea to 001434f4 has its CatchHandler @ 001435c4 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_58,(basic_json *)(lVar4 + 0x20));
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::clear((vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)local_38);
}
else if (local_40[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>
)0x2) {
/* try { // try from 001434c1 to 001434c8 has its CatchHandler @ 001435bd */
std::__copy_move<true,false,std::random_access_iterator_tag>::
__copy_m<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
(*(long *)local_38,*(long *)(local_38 + 8),&local_58);
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::clear(local_38);
}
~basic_json(local_40);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_58);
}
switch(param_2 & 0xff) {
case 1:
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::~vector(*(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)this);
goto LAB_00143589;
case 2:
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)this);
uStack_60 = 0x18;
break;
case 3:
std::__cxx11::string::~string(*(string **)this);
LAB_00143589:
uStack_60 = 0x20;
break;
default:
goto switchD_00143537_caseD_4;
case 8:
std::_Vector_base<unsigned_char,std::allocator<unsigned_char>>::~_Vector_base
(*(_Vector_base<unsigned_char,std::allocator<unsigned_char>> **)this);
uStack_60 = 0x28;
}
operator_delete(*(void **)this,uStack_60);
switchD_00143537_caseD_4:
return;
}
| |
24,124 | 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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) | monkey531[P]llama/common/json.hpp | void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
{
//not initialized (e.g. due to exception in the ctor)
return;
}
if (t == value_t::array || t == value_t::object)
{
// flatten the current json_value to a heap-allocated stack
std::vector<basic_json> stack;
// move the top-level items to stack
if (t == value_t::array)
{
stack.reserve(array->size());
std::move(array->begin(), array->end(), std::back_inserter(stack));
}
else
{
stack.reserve(object->size());
for (auto&& it : *object)
{
stack.push_back(std::move(it.second));
}
}
while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
stack.pop_back();
// if current_item is array/object, move
// its children to the stack to be processed later
if (current_item.is_array())
{
std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
current_item.m_data.m_value.array->clear();
}
else if (current_item.is_object())
{
for (auto&& it : *current_item.m_data.m_value.object)
{
stack.push_back(std::move(it.second));
}
current_item.m_data.m_value.object->clear();
}
// it's now safe that current_item get destructed
// since it doesn't have any children
}
}
switch (t)
{
case value_t::object:
{
AllocatorType<object_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
break;
}
case value_t::array:
{
AllocatorType<array_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
break;
}
case value_t::string:
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
break;
}
case value_t::binary:
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
break;
}
case value_t::null:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::discarded:
default:
{
break;
}
}
} | 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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, %esi
sete %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x5f20a
movl %esi, %r14d
testq %rax, %rax
sete %cl
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
testb %cl, %sil
jne 0x5f20a
movq %rdi, %rbx
leal -0x1(%r14), %ecx
cmpb $0x1, %cl
ja 0x5f185
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x4, %rsi
cmpb $0x2, %r14b
jne 0x5f02b
movq %rsp, %rdi
callq 0x5f24e
movq (%rbx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
subq %r15, %r13
sarq $0x4, %r13
testq %r13, %r13
jle 0x5f06c
incq %r13
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5e16c
addq $0x10, %r15
decq %r13
cmpq $0x1, %r13
ja 0x5f011
jmp 0x5f06c
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rax
movq %rsp, %rdi
movq %rax, %rsi
callq 0x5f24e
movq (%rbx), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x5f06c
movq %rsp, %r15
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x5e16c
addq $0x30, %r12
cmpq %r13, %r12
jne 0x5f056
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
je 0x5f17d
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq -0x10(%r13), %rdi
movups -0x10(%r13), %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %esi, %esi
callq 0x595aa
movb $0x0, -0x10(%r13)
movq $0x0, -0x8(%r13)
movq %r15, %rdi
movl $0x1, %esi
callq 0x595aa
movq 0x8(%rsp), %r13
addq $-0x10, %r13
movq %r13, 0x8(%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x595aa
movq %r13, %rdi
callq 0x5ea98
movzbl 0x20(%rsp), %eax
cmpl $0x1, %eax
je 0x5f126
cmpl $0x2, %eax
jne 0x5f15c
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
subq %r13, %rbp
sarq $0x4, %rbp
testq %rbp, %rbp
jle 0x5f11c
incq %rbp
movq %r12, %rdi
movq %r13, %rsi
callq 0x5e16c
addq $0x10, %r13
decq %rbp
cmpq $0x1, %rbp
jg 0x5f0fc
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq %r13, %rsi
callq 0x5f334
jmp 0x5f15c
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
cmpq %rbp, %r13
je 0x5f154
leaq 0x20(%r13), %rsi
movq %r12, %rdi
callq 0x5e16c
addq $0x30, %r13
cmpq %rbp, %r13
jne 0x5f137
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq %r13, %rsi
callq 0x5f37a
movq %r15, %rdi
xorl %esi, %esi
callq 0x595aa
movq %r15, %rdi
callq 0x5ea98
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
jne 0x5f083
movq %rsp, %rdi
callq 0x5f2e2
movzbl %r14b, %eax
decl %eax
cmpl $0x7, %eax
ja 0x5f20a
leaq 0x87c61(%rip), %rcx # 0xe6df8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x5f434
jmp 0x5f1c7
movq (%rbx), %rdi
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x5f1ca
movq (%rcx), %rsi
incq %rsi
movq %rax, %rdi
callq 0x1a890
movq (%rbx), %rdi
movl $0x20, %esi
jmp 0x5f205
movq (%rbx), %rdi
callq 0x5f2e2
movq (%rbx), %rdi
movl $0x18, %esi
jmp 0x5f205
movq (%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x5f200
movq 0x10(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x1a890
movq (%rbx), %rdi
movl $0x28, %esi
callq 0x1a890
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5f21d
jmp 0x5f21d
movq %rax, %rbx
jmp 0x5f23e
jmp 0x5f224
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x595aa
movq %r14, %rdi
callq 0x5ea98
movq %rsp, %rdi
callq 0x5f2e2
movq %rbx, %rdi
callq 0x1af20
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
cmp esi, 1
setz cl
mov rax, [rdi]
test rax, rax
setz dl
test cl, dl
jnz def_5F19E; jumptable 000000000005F19E default case, cases 4-7
mov r14d, esi
test rax, rax
setz cl
mov edx, r14d
and dl, 0FEh
cmp dl, 2
setz dl
cmp r14b, 8
setz sil
or sil, dl
test sil, cl
jnz def_5F19E; jumptable 000000000005F19E default case, cases 4-7
mov rbx, rdi
lea ecx, [r14-1]
cmp cl, 1
ja loc_5F185
xorps xmm0, xmm0
movaps [rsp+68h+var_68], xmm0
mov [rsp+68h+var_58], 0
mov rsi, [rax+8]
sub rsi, [rax]
sar rsi, 4
cmp r14b, 2
jnz short loc_5F02B
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r15, [rax]
mov r13, [rax+8]
sub r13, r15
sar r13, 4
test r13, r13
jle short loc_5F06C
inc r13
mov r12, rsp
loc_5F011:
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(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> &&)
add r15, 10h
dec r13
cmp r13, 1
ja short loc_5F011
jmp short loc_5F06C
loc_5F02B:
mov rax, 0AAAAAAAAAAAAAAABh
imul rax, rsi
mov rdi, rsp
mov rsi, rax
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r12, [rax]
mov r13, [rax+8]
cmp r12, r13
jz short loc_5F06C
mov r15, rsp
loc_5F056:
lea rsi, [r12+20h]
mov rdi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(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> &&)
add r12, 30h ; '0'
cmp r12, r13
jnz short loc_5F056
loc_5F06C:
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jz loc_5F17D
lea r15, [rsp+68h+var_48]
mov r12, rsp
loc_5F083:
lea rdi, [r13-10h]
movups xmm0, xmmword ptr [r13-10h]
movaps [rsp+68h+var_48], xmm0
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 [r13-10h], 0
mov qword ptr [r13-8], 0
mov rdi, r15
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 r13, qword ptr [rsp+68h+var_68+8]
add r13, 0FFFFFFFFFFFFFFF0h
mov qword ptr [rsp+68h+var_68+8], r13
mov rdi, r13
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
movzx eax, byte ptr [rsp+68h+var_48]
cmp eax, 1
jz short loc_5F126
cmp eax, 2
jnz short loc_5F15C
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
mov rbp, [rdi+8]
sub rbp, r13
sar rbp, 4
test rbp, rbp
jle short loc_5F11C
inc rbp
loc_5F0FC:
mov rdi, r12
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(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> &&)
add r13, 10h
dec rbp
cmp rbp, 1
jg short loc_5F0FC
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
loc_5F11C:
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE15_M_erase_at_endEPSD_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::_M_erase_at_end(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>*)
jmp short loc_5F15C
loc_5F126:
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
mov rbp, [rdi+8]
cmp r13, rbp
jz short loc_5F154
loc_5F137:
lea rsi, [r13+20h]
mov rdi, r12
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(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> &&)
add r13, 30h ; '0'
cmp r13, rbp
jnz short loc_5F137
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
loc_5F154:
mov rsi, r13
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE15_M_erase_at_endEPSG_; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::_M_erase_at_end(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>*)
loc_5F15C:
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jnz loc_5F083
loc_5F17D:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
loc_5F185:
movzx eax, r14b
dec eax; switch 8 cases
cmp eax, 7
ja short def_5F19E; jumptable 000000000005F19E default case, cases 4-7
lea rcx, jpt_5F19E
movsxd rax, ds:(jpt_5F19E - 0E6DF8h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_5F1A0:
mov rdi, [rbx]; jumptable 000000000005F19E case 1
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EED2Ev; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::~vector()
jmp short loc_5F1C7
loc_5F1AA:
mov rdi, [rbx]; jumptable 000000000005F19E case 3
mov rax, [rdi]
lea rcx, [rdi+10h]
cmp rax, rcx
jz short loc_5F1CA
mov rsi, [rcx]
inc rsi; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_5F1C7:
mov rdi, [rbx]
loc_5F1CA:
mov esi, 20h ; ' '
jmp short loc_5F205
loc_5F1D1:
mov rdi, [rbx]; jumptable 000000000005F19E case 2
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, [rbx]
mov esi, 18h
jmp short loc_5F205
loc_5F1E3:
mov rdi, [rbx]; jumptable 000000000005F19E case 8
mov rax, [rdi]
test rax, rax
jz short loc_5F200
mov rsi, [rdi+10h]
sub rsi, rax; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [rbx]; void *
loc_5F200:
mov esi, 28h ; '('; unsigned __int64
loc_5F205:
call __ZdlPvm; operator delete(void *,ulong)
def_5F19E:
add rsp, 38h; jumptable 000000000005F19E default case, cases 4-7
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_5F21D
jmp short $+2
loc_5F21D:
mov rbx, rax
jmp short loc_5F23E
jmp short $+2
loc_5F224:
mov rbx, rax
lea r14, [rsp+arg_18]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_5F23E:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, rbx
call __Unwind_Resume
| void 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>::json_value::destroy(
long long **a1,
int a2)
{
long long *v2; // rax
char v3; // r14
long long v5; // rsi
long long v6; // r15
long long v7; // r13
long long v8; // r13
bool v9; // cf
long long v10; // r12
long long i; // r13
long long j; // r13
char *v13; // r13
long long v14; // rdi
long long v15; // r13
long long v16; // rbp
long long v17; // rbp
long long v18; // rdi
long long v19; // r13
long long v20; // rbp
void **v21; // rdi
_QWORD *v22; // rcx
unsigned long long v23; // rsi
long long v24; // rax
__int128 v25; // [rsp+0h] [rbp-68h] BYREF
long long v26; // [rsp+10h] [rbp-58h]
_OWORD v27[4]; // [rsp+20h] [rbp-48h] BYREF
v2 = *a1;
if ( *a1 != 0LL || a2 != 1 )
{
v3 = a2;
if ( v2 != 0LL || (a2 & 0xFE) != 2 && (_BYTE)a2 != 8 )
{
if ( (unsigned __int8)(a2 - 1) <= 1u )
{
v25 = 0LL;
v26 = 0LL;
v5 = (v2[1] - *v2) >> 4;
if ( v3 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v25,
v5);
v6 = **a1;
v7 = ((*a1)[1] - v6) >> 4;
if ( v7 > 0 )
{
v8 = v7 + 1;
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v25,
v6);
v6 += 16LL;
v9 = v8-- == 1;
}
while ( !v9 && v8 != 1 );
}
}
else
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v25,
0xAAAAAAAAAAAAAAABLL * v5);
v10 = **a1;
for ( i = (*a1)[1]; v10 != i; v10 += 48LL )
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v25,
v10 + 32);
}
for ( j = *((_QWORD *)&v25 + 1); (_QWORD)v25 != *((_QWORD *)&v25 + 1); j = *((_QWORD *)&v25 + 1) )
{
v27[0] = *(_OWORD *)(j - 16);
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 *)(j - 16));
*(_BYTE *)(j - 16) = 0;
*(_QWORD *)(j - 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 *)v27);
v13 = (char *)(*((_QWORD *)&v25 + 1) - 16LL);
*((_QWORD *)&v25 + 1) = v13;
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(v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v13);
if ( LOBYTE(v27[0]) == 1 )
{
v18 = *((_QWORD *)&v27[0] + 1);
v19 = **((_QWORD **)&v27[0] + 1);
v20 = *(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 8LL);
if ( **((_QWORD **)&v27[0] + 1) != v20 )
{
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v25,
v19 + 32);
v19 += 48LL;
}
while ( v19 != v20 );
v18 = *((_QWORD *)&v27[0] + 1);
v19 = **((_QWORD **)&v27[0] + 1);
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::_M_erase_at_end(
v18,
v19);
}
else if ( LOBYTE(v27[0]) == 2 )
{
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
v16 = (long long)(*(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 8LL) - **((_QWORD **)&v27[0] + 1)) >> 4;
if ( v16 > 0 )
{
v17 = v16 + 1;
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v25,
v15);
v15 += 16LL;
--v17;
}
while ( v17 > 1 );
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::_M_erase_at_end(
v14,
v15);
}
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 *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v27);
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(&v25);
}
switch ( v3 )
{
case 1:
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::~vector(*a1);
goto LABEL_29;
case 2:
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(*a1);
v21 = (void **)*a1;
v23 = 24LL;
goto LABEL_35;
case 3:
v21 = (void **)*a1;
v22 = *a1 + 2;
if ( (_QWORD *)**a1 != v22 )
{
operator delete((void *)**a1, *v22 + 1LL);
LABEL_29:
v21 = (void **)*a1;
}
v23 = 32LL;
goto LABEL_35;
case 8:
v21 = (void **)*a1;
v24 = **a1;
if ( v24 )
{
operator delete((void *)**a1, (unsigned long long)v21[2] - v24);
v21 = (void **)*a1;
}
v23 = 40LL;
LABEL_35:
operator delete(v21, v23);
break;
default:
return;
}
}
}
}
| destroy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
CMP ESI,0x1
SETZ CL
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
SETZ DL
TEST CL,DL
JNZ 0x0015f20a
MOV R14D,ESI
TEST RAX,RAX
SETZ CL
MOV EDX,R14D
AND DL,0xfe
CMP DL,0x2
SETZ DL
CMP R14B,0x8
SETZ SIL
OR SIL,DL
TEST SIL,CL
JNZ 0x0015f20a
MOV RBX,RDI
LEA ECX,[R14 + -0x1]
CMP CL,0x1
JA 0x0015f185
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,qword ptr [RAX]
SAR RSI,0x4
CMP R14B,0x2
JNZ 0x0015f02b
LAB_0015efed:
MOV RDI,RSP
CALL 0x0015f24e
MOV RAX,qword ptr [RBX]
MOV R15,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
SUB R13,R15
SAR R13,0x4
TEST R13,R13
JLE 0x0015f06c
INC R13
MOV R12,RSP
LAB_0015f011:
MOV RDI,R12
MOV RSI,R15
CALL 0x0015e16c
ADD R15,0x10
DEC R13
CMP R13,0x1
JA 0x0015f011
JMP 0x0015f06c
LAB_0015f02b:
MOV RAX,-0x5555555555555555
IMUL RAX,RSI
LAB_0015f039:
MOV RDI,RSP
MOV RSI,RAX
CALL 0x0015f24e
MOV RAX,qword ptr [RBX]
MOV R12,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
CMP R12,R13
JZ 0x0015f06c
MOV R15,RSP
LAB_0015f056:
LEA RSI,[R12 + 0x20]
LAB_0015f05b:
MOV RDI,R15
CALL 0x0015e16c
ADD R12,0x30
CMP R12,R13
JNZ 0x0015f056
LAB_0015f06c:
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JZ 0x0015f17d
LEA R15,[RSP + 0x20]
MOV R12,RSP
LAB_0015f083:
LEA RDI,[R13 + -0x10]
MOVUPS XMM0,xmmword ptr [R13 + -0x10]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
XOR ESI,ESI
CALL 0x001595aa
MOV byte ptr [R13 + -0x10],0x0
MOV qword ptr [R13 + -0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x001595aa
MOV R13,qword ptr [RSP + 0x8]
ADD R13,-0x10
MOV qword ptr [RSP + 0x8],R13
MOV RDI,R13
XOR ESI,ESI
CALL 0x001595aa
MOV RDI,R13
CALL 0x0015ea98
MOVZX EAX,byte ptr [RSP + 0x20]
CMP EAX,0x1
JZ 0x0015f126
CMP EAX,0x2
JNZ 0x0015f15c
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
SUB RBP,R13
SAR RBP,0x4
TEST RBP,RBP
JLE 0x0015f11c
INC RBP
LAB_0015f0fc:
MOV RDI,R12
MOV RSI,R13
CALL 0x0015e16c
ADD R13,0x10
DEC RBP
CMP RBP,0x1
JG 0x0015f0fc
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
LAB_0015f11c:
MOV RSI,R13
CALL 0x0015f334
JMP 0x0015f15c
LAB_0015f126:
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
CMP R13,RBP
JZ 0x0015f154
LAB_0015f137:
LEA RSI,[R13 + 0x20]
LAB_0015f13b:
MOV RDI,R12
CALL 0x0015e16c
LAB_0015f143:
ADD R13,0x30
CMP R13,RBP
JNZ 0x0015f137
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
LAB_0015f154:
MOV RSI,R13
CALL 0x0015f37a
LAB_0015f15c:
MOV RDI,R15
XOR ESI,ESI
CALL 0x001595aa
MOV RDI,R15
CALL 0x0015ea98
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JNZ 0x0015f083
LAB_0015f17d:
MOV RDI,RSP
CALL 0x0015f2e2
LAB_0015f185:
MOVZX EAX,R14B
DEC EAX
CMP EAX,0x7
JA 0x0015f20a
LEA RCX,[0x1e6df8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBX]
CALL 0x0015f434
JMP 0x0015f1c7
caseD_3:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
LEA RCX,[RDI + 0x10]
CMP RAX,RCX
JZ 0x0015f1ca
MOV RSI,qword ptr [RCX]
INC RSI
MOV RDI,RAX
CALL 0x0011a890
LAB_0015f1c7:
MOV RDI,qword ptr [RBX]
LAB_0015f1ca:
MOV ESI,0x20
JMP 0x0015f205
caseD_2:
MOV RDI,qword ptr [RBX]
CALL 0x0015f2e2
MOV RDI,qword ptr [RBX]
MOV ESI,0x18
JMP 0x0015f205
caseD_8:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0015f200
MOV RSI,qword ptr [RDI + 0x10]
SUB RSI,RAX
MOV RDI,RAX
CALL 0x0011a890
MOV RDI,qword ptr [RBX]
LAB_0015f200:
MOV ESI,0x28
LAB_0015f205:
CALL 0x0011a890
caseD_4:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) */
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>
::json_value::destroy(json_value *this,uint param_2)
{
long *plVar1;
long lVar2;
pair *ppVar3;
void *pvVar4;
byte bVar5;
ulong uVar6;
bool bVar7;
int8 *puVar8;
long lVar9;
data *pdVar10;
pair *ppVar11;
basic_json *pbVar12;
data *local_68;
data *pdStack_60;
int8 local_58;
int8 local_48;
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*pvStack_40;
plVar1 = *(long **)this;
if (param_2 == 1 && plVar1 == (long *)0x0) {
return;
}
bVar5 = (byte)param_2;
if ((bVar5 == 8 || (bVar5 & 0xfe) == 2) && plVar1 == (long *)0x0) {
return;
}
if ((byte)(bVar5 - 1) < 2) {
local_68 = (data *)0x0;
pdStack_60 = (data *)0x0;
local_58 = 0;
uVar6 = plVar1[1] - *plVar1 >> 4;
if (bVar5 == 2) {
/* try { // try from 0015efed to 0015eff4 has its CatchHandler @ 0015f219 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,uVar6);
pbVar12 = (basic_json *)**(long **)this;
lVar9 = (*(long **)this)[1] - (long)pbVar12 >> 4;
if (0 < lVar9) {
uVar6 = lVar9 + 1;
do {
/* try { // try from 0015f011 to 0015f01b has its CatchHandler @ 0015f21d */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar12);
pbVar12 = pbVar12 + 0x10;
uVar6 = uVar6 - 1;
} while (1 < uVar6);
}
}
else {
/* try { // try from 0015f039 to 0015f043 has its CatchHandler @ 0015f219 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,uVar6 * -0x5555555555555555);
lVar2 = (*(long **)this)[1];
for (lVar9 = **(long **)this; lVar9 != lVar2; lVar9 = lVar9 + 0x30) {
/* try { // try from 0015f05b to 0015f062 has its CatchHandler @ 0015f21b */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(lVar9 + 0x20));
}
}
if (local_68 != pdStack_60) {
do {
pdVar10 = pdStack_60;
local_48 = *(int8 *)(pdStack_60 + -0x10);
pvStack_40 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pdStack_60 + -8);
assert_invariant((bool)((char)pdStack_60 + -0x10));
pdVar10[-0x10] = (data)0x0;
*(int8 *)(pdVar10 + -8) = 0;
bVar7 = SUB81((data *)&local_48,0);
assert_invariant(bVar7);
pdVar10 = pdStack_60 + -0x10;
pdStack_60 = pdVar10;
assert_invariant(SUB81(pdVar10,0));
data::~data(pdVar10);
if (local_48._0_1_ == (data)0x1) {
ppVar11 = *(pair **)pvStack_40;
ppVar3 = *(pair **)(pvStack_40 + 8);
if (ppVar11 != ppVar3) {
do {
/* try { // try from 0015f13b to 0015f142 has its CatchHandler @ 0015f224 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(ppVar11 + 0x20));
ppVar11 = ppVar11 + 0x30;
} while (ppVar11 != ppVar3);
ppVar11 = *(pair **)pvStack_40;
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::_M_erase_at_end((vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)pvStack_40,ppVar11);
}
else if (local_48._0_1_ == (data)0x2) {
pbVar12 = *(basic_json **)pvStack_40;
lVar9 = *(long *)(pvStack_40 + 8) - (long)pbVar12 >> 4;
if (0 < lVar9) {
lVar9 = lVar9 + 1;
do {
/* try { // try from 0015f0fc to 0015f106 has its CatchHandler @ 0015f222 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar12);
pbVar12 = pbVar12 + 0x10;
lVar9 = lVar9 + -1;
} while (1 < lVar9);
pbVar12 = *(basic_json **)pvStack_40;
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::_M_erase_at_end(pvStack_40,pbVar12);
}
assert_invariant(bVar7);
data::~data((data *)&local_48);
} while (local_68 != pdStack_60);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68);
}
switch(param_2 & 0xff) {
case 1:
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::~vector(*(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)this);
LAB_0015f1c7:
puVar8 = *(int8 **)this;
goto LAB_0015f1ca;
case 2:
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)this);
puVar8 = *(int8 **)this;
uVar6 = 0x18;
break;
case 3:
puVar8 = *(int8 **)this;
if ((long *)*puVar8 != puVar8 + 2) {
operator_delete((long *)*puVar8,puVar8[2] + 1);
goto LAB_0015f1c7;
}
LAB_0015f1ca:
uVar6 = 0x20;
break;
default:
goto switchD_0015f19e_caseD_4;
case 8:
puVar8 = *(int8 **)this;
pvVar4 = (void *)*puVar8;
if (pvVar4 != (void *)0x0) {
operator_delete(pvVar4,puVar8[2] - (long)pvVar4);
puVar8 = *(int8 **)this;
}
uVar6 = 0x28;
}
operator_delete(puVar8,uVar6);
switchD_0015f19e_caseD_4:
return;
}
| |
24,125 | common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&, common_chat_inputs const&) | monkey531[P]llama/common/chat.cpp | static common_chat_params common_chat_params_init_functionary_v3_1_llama_3_1(const common_chat_template & tmpl, const struct common_chat_inputs & inputs) {
// https://github.com/MeetKai/functionary/blob/main/tests/prompt_test_v3-llama3.1.txt
common_chat_params data;
json tools = inputs.tools.is_null() ? inputs.tools : json::array();
std::string python_code_argument_name;
auto has_raw_python = false;
data.grammar_lazy = inputs.tool_choice != "required";
data.grammar = build_grammar([&](const common_grammar_builder & builder) {
std::vector<std::string> tool_rules;
foreach_function(inputs.tools, [&](const json & tool) {
const auto & function = tool["function"];
const auto & parameters = function["parameters"];
std::string name = function["name"];
if (name == "python" || name == "ipython") {
if (!parameters.contains("type")) {
throw std::runtime_error("Missing type in python tool");
}
has_raw_python = true;
auto type = parameters.at("type");
if (type == "object") {
auto properties = parameters.at("properties");
for (auto it = properties.begin(); it != properties.end(); ++it) {
if (it.value().at("type") == "string") {
if (!python_code_argument_name.empty()) {
throw std::runtime_error("Multiple string arguments found in python tool");
}
python_code_argument_name = it.key();
}
}
if (python_code_argument_name.empty()) {
throw std::runtime_error("No string argument found in python tool");
}
} else if (type != "string") {
throw std::runtime_error("Invalid type in python tool: " + type.dump());
}
}
tool_rules.push_back(builder.add_rule(name + "-call", "\"<function=" + name + ">\" " + builder.add_schema(name + "-args", parameters) + " \"</function>\" space"));
});
if (has_raw_python) {
tool_rules.push_back(builder.add_rule("python-call", "\"<|python_tag|>\" .*"));
data.grammar_triggers.push_back({"<|python_tag|>", /* .at_start = */ false});
}
auto tool_call = builder.add_rule("tool_call", string_join(tool_rules, " | ")) + " space";
builder.add_rule("root", inputs.parallel_tool_calls ? "(" + tool_call + ")+" : tool_call);
data.grammar_triggers.push_back({"<function=", /* .at_start = */ false});
}, grammar_options);
data.prompt = tmpl.apply(inputs.messages, inputs.tools.empty() ? json() : inputs.tools, inputs.add_generation_prompt);
// TODO: if (has_raw_python)
data.format = COMMON_CHAT_FORMAT_FUNCTIONARY_V3_1_LLAMA_3_1;
return data;
} | O1 | cpp | common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&, common_chat_inputs const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x0, (%rdi)
xorl %eax, %eax
movb %al, 0x8(%rdi)
movq %rax, 0x10(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movb %al, 0x28(%rdi)
movb %al, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x70(%rdi)
movq %rax, 0x80(%rdi)
leaq 0x10(%rdx), %r12
cmpb %al, 0x10(%rdx)
je 0xd62a0
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x2, %r8d
callq 0x849f4
jmp 0xd62ad
leaq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0x6ff00
leaq 0x88(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
xorl %eax, %eax
movb %al, (%rbp)
movb %al, 0xf(%rsp)
leaq 0x20(%r14), %rdi
leaq 0x215e8(%rip), %rsi # 0xf78bd
callq 0xaac5d
movb %al, 0x38(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x20, %edi
callq 0x1b8f0
movq %r14, (%rax)
leaq 0xf(%rsp), %rcx
movq %rcx, 0x8(%rax)
leaq 0x78(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rbx, 0x18(%rax)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xac44(%rip), %rax # 0xe0f60
movq %rax, 0x18(%rsi)
leaq 0xb327(%rip), %rax # 0xe164e
movq %rax, 0x10(%rsi)
leaq 0x2749a(%rip), %rdx # 0xfd7cc
leaq 0x38(%rsp), %rdi
callq 0xc08f6
leaq 0x18(%rbx), %rdi
leaq 0x38(%rsp), %r13
movq %r13, %rsi
callq 0x1bae0
movq (%r13), %rdi
leaq 0x48(%rsp), %r13
cmpq %r13, %rdi
je 0xd6368
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1b910
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xd6381
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movzbl (%r12), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0xd63aa
movq 0x18(%r14), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0xd63ae
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x6ff00
jmp 0xd63bc
testl %eax, %eax
jne 0xd639b
movb $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movzbl 0x68(%r14), %r8d
leaq 0x68(%rsp), %r9
movb $0x0, (%r9)
movq $0x0, 0x8(%r9)
movl $0x1, (%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0xa731c
leaq 0x98(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x8586c
movb 0x8(%rbx), %al
leaq 0x98(%rsp), %rdi
movb (%rdi), %cl
movb %cl, 0x8(%rbx)
movb %al, (%rdi)
movq 0x10(%rbx), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rdi)
callq 0x70460
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0xd643e
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1b910
leaq 0x68(%rsp), %rdi
callq 0x70460
leaq 0x10(%rsp), %rdi
callq 0x70460
movl $0x8, (%rbx)
movq 0x78(%rsp), %rdi
cmpq %rbp, %rdi
je 0xd6472
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x1b910
leaq 0x58(%rsp), %rdi
callq 0x70460
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd64f0
jmp 0xd64e8
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0xd64b4
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1b910
jmp 0xd64b4
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x70460
leaq 0x10(%rsp), %rdi
callq 0x70460
jmp 0xd64f3
movq %rax, %r14
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xd64f3
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xd64f3
movq %rax, %rdi
callq 0x25a95
movq %rax, %r14
movq 0x78(%rsp), %rdi
cmpq %rbp, %rdi
je 0xd650d
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x1b910
leaq 0x58(%rsp), %rdi
callq 0x70460
movq %rbx, %rdi
callq 0x8433a
movq %r14, %rdi
callq 0x1bff0
movq %rax, %r14
jmp 0xd6517
| _ZL50common_chat_params_init_functionary_v3_1_llama_3_1RKN5minja13chat_templateERK18common_chat_inputs:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov dword ptr [rdi], 0
xor eax, eax
mov [rdi+8], al
mov [rdi+10h], rax
lea rcx, [rdi+28h]
mov [rdi+18h], rcx
mov [rdi+20h], rax
mov [rdi+28h], al
mov [rdi+38h], al
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+50h], xmm0
movups xmmword ptr [rdi+60h], xmm0
movups xmmword ptr [rdi+70h], xmm0
mov [rdi+80h], rax
lea r12, [rdx+10h]
cmp [rdx+10h], al
jz short loc_D62A0
lea rdi, [rsp+0D8h+var_80]
xor esi, esi
xor edx, edx
xor ecx, ecx
mov r8d, 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE; 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(std::initializer_list<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,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)
jmp short loc_D62AD
loc_D62A0:
lea rdi, [rsp+0D8h+var_80]
mov rsi, r12
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&)
loc_D62AD:
lea rbp, [rsp+0D8h+var_50]
mov [rbp-10h], rbp
mov qword ptr [rbp-8], 0
xor eax, eax
mov [rbp+0], al
mov [rsp+0D8h+var_C9], al
lea rdi, [r14+20h]
lea rsi, aRequired; "required"
call _ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
mov [rbx+38h], al
xorps xmm0, xmm0
movaps [rsp+0D8h+var_B8], xmm0
movaps [rsp+0D8h+var_C8], xmm0
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
mov [rax], r14
lea rcx, [rsp+0D8h+var_C9]
mov [rax+8], rcx
lea rcx, [rsp+0D8h+var_60]
mov [rax+10h], rcx
mov [rax+18h], rbx
lea rsi, [rsp+0D8h+var_C8]
mov [rsi], rax
lea rax, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZL50common_chat_params_init_functionary_v3_1_llama_3_1RKN5minja13chat_templateERK18common_chat_inputsE3$_0E9_M_invokeERKSt9_Any_dataS2_; std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_invoke(std::_Any_data const&,common_grammar_builder const&)
mov [rsi+18h], rax
lea rax, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZL50common_chat_params_init_functionary_v3_1_llama_3_1RKN5minja13chat_templateERK18common_chat_inputsE3$_0E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation; std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsi+10h], rax
lea rdx, _ZL15grammar_options; grammar_options
lea rdi, [rsp+0D8h+var_A0]
call _Z13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_options; build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)
lea rdi, [rbx+18h]
lea r13, [rsp+0D8h+var_A0]
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r13+0]; void *
lea r13, [rsp+0D8h+var_90]
cmp rdi, r13
jz short loc_D6368
mov rsi, [rsp+0D8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D6368:
mov rax, qword ptr [rsp+0D8h+var_B8]
test rax, rax
jz short loc_D6381
lea rdi, [rsp+0D8h+var_C8]
mov rsi, rdi
mov edx, 3
call rax
loc_D6381:
movzx eax, byte ptr [r12]
lea ecx, [rax-1]
cmp ecx, 2
jnb short loc_D63AA
mov rax, [r14+18h]
mov rcx, [rax]
cmp rcx, [rax+8]
jz short loc_D63AE
loc_D639B:
lea rdi, [rsp+0D8h+var_C8]
mov rsi, r12
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_D63BC
loc_D63AA:
test eax, eax
jnz short loc_D639B
loc_D63AE:
mov byte ptr [rsp+0D8h+var_C8], 0
mov qword ptr [rsp+0D8h+var_C8+8], 0
loc_D63BC:
movzx r8d, byte ptr [r14+68h]
lea r9, [rsp+0D8h+var_70]
mov byte ptr [r9], 0
mov qword ptr [r9+8], 0
mov [rsp+0D8h+var_D8], 1
lea rdi, [rsp+0D8h+var_A0]
lea rcx, [rsp+0D8h+var_C8]
mov rsi, r15
mov rdx, r14
call _ZNK5minja13chat_template5applyERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEESH_bSH_b; minja::chat_template::apply(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&,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&,bool,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&,bool)
lea rdi, [rsp+0D8h+var_40]
lea rsi, [rsp+0D8h+var_A0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
mov al, [rbx+8]
lea rdi, [rsp+0D8h+var_40]
mov cl, [rdi]
mov [rbx+8], cl
mov [rdi], al
mov rax, [rbx+10h]
mov rcx, [rdi+8]
mov [rbx+10h], rcx
mov [rdi+8], rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+0D8h+var_A0]; void *
cmp rdi, r13
jz short loc_D643E
mov rsi, [rsp+0D8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D643E:
lea rdi, [rsp+0D8h+var_70]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+0D8h+var_C8]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov dword ptr [rbx], 8
mov rdi, [rsp+0D8h+var_60]; void *
cmp rdi, rbp
jz short loc_D6472
mov rsi, [rsp+0D8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D6472:
lea rdi, [rsp+0D8h+var_80]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rax, rbx
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_D64F0
jmp short loc_D64E8
mov r14, rax
mov rdi, [rsp+0D8h+var_A0]; void *
cmp rdi, r13
jz short loc_D64B4
mov rsi, [rsp+0D8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D64B4
mov r14, rax
loc_D64B4:
lea rdi, [rsp+0D8h+var_70]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+0D8h+var_C8]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_D64F3
mov r14, rax
mov rax, qword ptr [rsp+0D8h+var_B8]
test rax, rax
jz short loc_D64F3
lea rdi, [rsp+0D8h+var_C8]
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_D64F3
loc_D64E8:
mov rdi, rax
call __clang_call_terminate
loc_D64F0:
mov r14, rax
loc_D64F3:
mov rdi, [rsp+0D8h+var_60]; void *
cmp rdi, rbp
jz short loc_D650D
mov rsi, [rsp+0D8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D650D:
lea rdi, [rsp+0D8h+var_80]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_D6517:
mov rdi, rbx; this
call _ZN18common_chat_paramsD2Ev; common_chat_params::~common_chat_params()
mov rdi, r14
call __Unwind_Resume
mov r14, rax
jmp short loc_D6517
| const minja::chat_template * common_chat_params_init_functionary_v3_1_llama_3_1(
const minja::chat_template *a1,
const common_chat_inputs *a2,
long long a3)
{
unsigned __int8 *v4; // r12
_QWORD *v5; // rax
int v6; // r8d
int v7; // r9d
int v8; // r8d
char v9; // al
long long v10; // rax
char v12; // [rsp+Fh] [rbp-C9h] BYREF
__int128 v13; // [rsp+10h] [rbp-C8h] BYREF
long long ( *v14)(); // [rsp+20h] [rbp-B8h]
long long ( *v15)(); // [rsp+28h] [rbp-B0h]
void *v16[2]; // [rsp+38h] [rbp-A0h] BYREF
_QWORD v17[2]; // [rsp+48h] [rbp-90h] BYREF
unsigned __int8 v18[16]; // [rsp+58h] [rbp-80h] BYREF
unsigned __int8 v19[8]; // [rsp+68h] [rbp-70h] BYREF
long long v20; // [rsp+70h] [rbp-68h]
void *v21[2]; // [rsp+78h] [rbp-60h] BYREF
_QWORD v22[2]; // [rsp+88h] [rbp-50h] BYREF
char v23[8]; // [rsp+98h] [rbp-40h] BYREF
long long v24; // [rsp+A0h] [rbp-38h]
*(_DWORD *)a1 = 0;
*((_BYTE *)a1 + 8) = 0;
*((_QWORD *)a1 + 2) = 0LL;
*((_QWORD *)a1 + 3) = (char *)a1 + 40;
*((_QWORD *)a1 + 4) = 0LL;
*((_BYTE *)a1 + 40) = 0;
*((_BYTE *)a1 + 56) = 0;
*((_OWORD *)a1 + 4) = 0LL;
*((_OWORD *)a1 + 5) = 0LL;
*((_OWORD *)a1 + 6) = 0LL;
*((_OWORD *)a1 + 7) = 0LL;
*((_QWORD *)a1 + 16) = 0LL;
v4 = (unsigned __int8 *)(a3 + 16);
if ( *(_BYTE *)(a3 + 16) )
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(
v18,
0LL,
0LL,
0LL,
2LL);
else
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(
v18,
(unsigned __int8 *)(a3 + 16));
v21[0] = v22;
v21[1] = 0LL;
LOBYTE(v22[0]) = 0;
v12 = 0;
*((_BYTE *)a1 + 56) = ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_(
a3 + 32,
(long long)"required");
v13 = 0LL;
v5 = (_QWORD *)operator new(0x20uLL);
*v5 = a3;
v5[1] = &v12;
v5[2] = v21;
v5[3] = a1;
*(_QWORD *)&v13 = v5;
v15 = std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_invoke;
v14 = std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_manager;
build_grammar[abi:cxx11]((long long)v16, (long long)&v13, grammar_options, (long long)v21, v6, v7);
std::string::operator=((char *)a1 + 24, v16);
if ( v16[0] != v17 )
operator delete(v16[0], v17[0] + 1LL);
if ( v14 )
((void ( *)(__int128 *, __int128 *, long long))v14)(&v13, &v13, 3LL);
if ( (unsigned int)*v4 - 1 >= 2 )
{
if ( *v4 )
goto LABEL_10;
}
else if ( **(_QWORD **)(a3 + 24) != *(_QWORD *)(*(_QWORD *)(a3 + 24) + 8LL) )
{
LABEL_10:
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(
(unsigned __int8 *)&v13,
v4);
goto LABEL_13;
}
LOBYTE(v13) = 0;
*((_QWORD *)&v13 + 1) = 0LL;
LABEL_13:
v8 = *(unsigned __int8 *)(a3 + 104);
v19[0] = 0;
v20 = 0LL;
minja::chat_template::apply((long long)v16, a2, (unsigned __int8 *)a3, (unsigned __int8 *)&v13, v8, v19, 1);
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_(v23);
v9 = *((_BYTE *)a1 + 8);
*((_BYTE *)a1 + 8) = v23[0];
v23[0] = v9;
v10 = *((_QWORD *)a1 + 2);
*((_QWORD *)a1 + 2) = v24;
v24 = v10;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v23);
if ( v16[0] != v17 )
operator delete(v16[0], v17[0] + 1LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v19);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v13);
*(_DWORD *)a1 = 8;
if ( v21[0] != v22 )
operator delete(v21[0], v22[0] + 1LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v18);
return a1;
}
| common_chat_params_init_functionary_v3_1_llama_3_1:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV dword ptr [RDI],0x0
XOR EAX,EAX
MOV byte ptr [RDI + 0x8],AL
MOV qword ptr [RDI + 0x10],RAX
LEA RCX,[RDI + 0x28]
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],RAX
MOV byte ptr [RDI + 0x28],AL
MOV byte ptr [RDI + 0x38],AL
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x50],XMM0
MOVUPS xmmword ptr [RDI + 0x60],XMM0
MOVUPS xmmword ptr [RDI + 0x70],XMM0
MOV qword ptr [RDI + 0x80],RAX
LEA R12,[RDX + 0x10]
CMP byte ptr [RDX + 0x10],AL
JZ 0x001d62a0
LAB_001d6288:
LEA RDI,[RSP + 0x58]
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
MOV R8D,0x2
CALL 0x001849f4
JMP 0x001d62ad
LAB_001d62a0:
LEA RDI,[RSP + 0x58]
MOV RSI,R12
CALL 0x0016ff00
LAB_001d62ad:
LEA RBP,[RSP + 0x88]
MOV qword ptr [RBP + -0x10],RBP
MOV qword ptr [RBP + -0x8],0x0
XOR EAX,EAX
MOV byte ptr [RBP],AL
MOV byte ptr [RSP + 0xf],AL
LEA RDI,[R14 + 0x20]
LEA RSI,[0x1f78bd]
CALL 0x001aac5d
MOV byte ptr [RBX + 0x38],AL
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
LAB_001d62ea:
MOV EDI,0x20
CALL 0x0011b8f0
MOV qword ptr [RAX],R14
LEA RCX,[RSP + 0xf]
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[RSP + 0x78]
MOV qword ptr [RAX + 0x10],RCX
MOV qword ptr [RAX + 0x18],RBX
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],RAX
LEA RAX,[0x1e0f60]
MOV qword ptr [RSI + 0x18],RAX
LEA RAX,[0x1e164e]
MOV qword ptr [RSI + 0x10],RAX
LAB_001d632b:
LEA RDX,[0x1fd7cc]
LEA RDI,[RSP + 0x38]
CALL 0x001c08f6
LEA RDI,[RBX + 0x18]
LEA R13,[RSP + 0x38]
MOV RSI,R13
CALL 0x0011bae0
MOV RDI,qword ptr [R13]
LEA R13,[RSP + 0x48]
CMP RDI,R13
JZ 0x001d6368
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x0011b910
LAB_001d6368:
MOV RAX,qword ptr [RSP + 0x20]
TEST RAX,RAX
JZ 0x001d6381
LAB_001d6372:
LEA RDI,[RSP + 0x10]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001d6381:
MOVZX EAX,byte ptr [R12]
LEA ECX,[RAX + -0x1]
CMP ECX,0x2
JNC 0x001d63aa
MOV RAX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RAX]
CMP RCX,qword ptr [RAX + 0x8]
JZ 0x001d63ae
LAB_001d639b:
LEA RDI,[RSP + 0x10]
MOV RSI,R12
CALL 0x0016ff00
JMP 0x001d63bc
LAB_001d63aa:
TEST EAX,EAX
JNZ 0x001d639b
LAB_001d63ae:
MOV byte ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
LAB_001d63bc:
MOVZX R8D,byte ptr [R14 + 0x68]
LEA R9,[RSP + 0x68]
MOV byte ptr [R9],0x0
MOV qword ptr [R9 + 0x8],0x0
LAB_001d63d2:
MOV dword ptr [RSP],0x1
LEA RDI,[RSP + 0x38]
LEA RCX,[RSP + 0x10]
MOV RSI,R15
MOV RDX,R14
CALL 0x001a731c
LAB_001d63ee:
LEA RDI,[RSP + 0x98]
LEA RSI,[RSP + 0x38]
CALL 0x0018586c
MOV AL,byte ptr [RBX + 0x8]
LEA RDI,[RSP + 0x98]
MOV CL,byte ptr [RDI]
MOV byte ptr [RBX + 0x8],CL
MOV byte ptr [RDI],AL
MOV RAX,qword ptr [RBX + 0x10]
MOV RCX,qword ptr [RDI + 0x8]
MOV qword ptr [RBX + 0x10],RCX
MOV qword ptr [RDI + 0x8],RAX
CALL 0x00170460
MOV RDI,qword ptr [RSP + 0x38]
CMP RDI,R13
JZ 0x001d643e
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x0011b910
LAB_001d643e:
LEA RDI,[RSP + 0x68]
CALL 0x00170460
LEA RDI,[RSP + 0x10]
CALL 0x00170460
MOV dword ptr [RBX],0x8
MOV RDI,qword ptr [RSP + 0x78]
CMP RDI,RBP
JZ 0x001d6472
MOV RSI,qword ptr [RSP + 0x88]
INC RSI
CALL 0x0011b910
LAB_001d6472:
LEA RDI,[RSP + 0x58]
CALL 0x00170460
MOV RAX,RBX
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template const&,
common_chat_inputs const&) */
chat_template *
common_chat_params_init_functionary_v3_1_llama_3_1
(chat_template *param_1,common_chat_inputs *param_2)
{
basic_json *pbVar1;
int8 uVar2;
chat_template cVar3;
long in_RDX;
int1 local_c9;
long *local_c8;
int8 uStack_c0;
code *local_b8;
code *pcStack_b0;
long *local_a0 [2];
long local_90 [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>
local_80 [16];
data local_70 [8];
int8 local_68;
int1 *local_60;
int8 local_58;
int1 local_50;
int7 uStack_4f;
chat_template local_40 [8];
int8 local_38;
*(int4 *)param_1 = 0;
param_1[8] = (chat_template)0x0;
*(int8 *)(param_1 + 0x10) = 0;
*(chat_template **)(param_1 + 0x18) = param_1 + 0x28;
*(int8 *)(param_1 + 0x20) = 0;
param_1[0x28] = (chat_template)0x0;
param_1[0x38] = (chat_template)0x0;
*(int8 *)(param_1 + 0x40) = 0;
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)(param_1 + 0x50) = 0;
*(int8 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x60) = 0;
*(int8 *)(param_1 + 0x68) = 0;
*(int8 *)(param_1 + 0x70) = 0;
*(int8 *)(param_1 + 0x78) = 0;
*(int8 *)(param_1 + 0x80) = 0;
pbVar1 = (basic_json *)(in_RDX + 0x10);
if (*(char *)(in_RDX + 0x10) == '\0') {
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_80,pbVar1);
}
else {
/* try { // try from 001d6288 to 001d62ac has its CatchHandler @ 001d6527 */
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(local_80,0,0,0,2);
}
local_58 = 0;
local_50 = 0;
local_c9 = 0;
local_60 = &local_50;
cVar3 = (chat_template)
_ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
(in_RDX + 0x20,"required");
param_1[0x38] = cVar3;
local_b8 = (code *)0x0;
pcStack_b0 = (code *)0x0;
local_c8 = (long *)0x0;
uStack_c0 = 0;
/* try { // try from 001d62ea to 001d62f3 has its CatchHandler @ 001d64f0 */
local_c8 = (long *)operator_new(0x20);
*local_c8 = in_RDX;
local_c8[1] = (long)&local_c9;
local_c8[2] = (long)&local_60;
local_c8[3] = (long)param_1;
pcStack_b0 = std::
_Function_handler<void(common_grammar_builder_const&),common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template_const&,common_chat_inputs_const&)::$_0>
::_M_invoke;
local_b8 = std::
_Function_handler<void(common_grammar_builder_const&),common_chat_params_init_functionary_v3_1_llama_3_1(minja::chat_template_const&,common_chat_inputs_const&)::$_0>
::_M_manager;
/* try { // try from 001d632b to 001d633b has its CatchHandler @ 001d64ca */
build_grammar_abi_cxx11_((function *)local_a0,(common_grammar_options *)&local_c8);
std::__cxx11::string::operator=((string *)(param_1 + 0x18),(string *)local_a0);
if (local_a0[0] != local_90) {
operator_delete(local_a0[0],local_90[0] + 1);
}
if (local_b8 != (code *)0x0) {
/* try { // try from 001d6372 to 001d6380 has its CatchHandler @ 001d6493 */
(*local_b8)(&local_c8,&local_c8,3);
}
if ((byte)*pbVar1 - 1 < 2) {
if (**(long **)(in_RDX + 0x18) == (*(long **)(in_RDX + 0x18))[1]) {
LAB_001d63ae:
local_c8 = (long *)((ulong)local_c8 & 0xffffffffffffff00);
uStack_c0 = 0;
goto LAB_001d63bc;
}
}
else if (*pbVar1 == (basic_json)0x0) goto LAB_001d63ae;
/* try { // try from 001d639b to 001d63a7 has its CatchHandler @ 001d6491 */
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((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)&local_c8,pbVar1);
LAB_001d63bc:
local_70[0] = (data)0x0;
local_68 = 0;
/* try { // try from 001d63d2 to 001d63ed has its CatchHandler @ 001d64b1 */
minja::chat_template::apply
((basic_json *)local_a0,(basic_json *)param_2,SUB81(in_RDX,0),(basic_json *)&local_c8,
*(bool *)(in_RDX + 0x68));
/* try { // try from 001d63ee to 001d63ff has its CatchHandler @ 001d6495 */
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
(local_40,local_a0);
cVar3 = param_1[8];
param_1[8] = local_40[0];
uVar2 = *(int8 *)(param_1 + 0x10);
*(int8 *)(param_1 + 0x10) = local_38;
local_40[0] = cVar3;
local_38 = uVar2;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_40);
if (local_a0[0] != local_90) {
operator_delete(local_a0[0],local_90[0] + 1);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_70);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_c8);
*(int4 *)param_1 = 8;
if (local_60 != &local_50) {
operator_delete(local_60,CONCAT71(uStack_4f,local_50) + 1);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_80);
return param_1;
}
| |
24,126 | 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 0x4523d
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 0x4523d
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 0x4523d
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_4523D
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_4523D
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_4523D
mov eax, [rbp+var_C]
or eax, 400h
mov [rbp+var_C], eax
loc_4523D:
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 0x0014523d
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 0x0014523d
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 0x0014523d
MOV EAX,dword ptr [RBP + -0xc]
OR EAX,0x400
MOV dword ptr [RBP + -0xc],EAX
LAB_0014523d:
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;
}
| |
24,127 | wqueue_unlink_from_queue | eloqsql/mysys/wqueue.c | void wqueue_unlink_from_queue(WQUEUE *wqueue, struct st_my_thread_var *thread)
{
if (thread->next == thread)
/* The queue contains only one member */
wqueue->last_thread= NULL;
else
{
thread->next->prev= thread->prev;
*thread->prev= thread->next;
if (wqueue->last_thread == thread)
wqueue->last_thread= STRUCT_PTR(struct st_my_thread_var, next,
thread->prev);
}
thread->next= NULL;
} | O3 | c | wqueue_unlink_from_queue:
pushq %rbp
movq %rsp, %rbp
movq 0x88(%rsi), %rax
cmpq %rsi, %rax
je 0xa66d5
movq 0x90(%rsi), %rcx
movq %rcx, 0x90(%rax)
movq 0x88(%rsi), %rax
movq %rax, (%rcx)
cmpq %rsi, (%rdi)
jne 0xa66da
movq $-0x88, %rax
addq 0x90(%rsi), %rax
jmp 0xa66d7
xorl %eax, %eax
movq %rax, (%rdi)
movq $0x0, 0x88(%rsi)
popq %rbp
retq
| wqueue_unlink_from_queue:
push rbp
mov rbp, rsp
mov rax, [rsi+88h]
cmp rax, rsi
jz short loc_A66D5
mov rcx, [rsi+90h]
mov [rax+90h], rcx
mov rax, [rsi+88h]
mov [rcx], rax
cmp [rdi], rsi
jnz short loc_A66DA
mov rax, 0FFFFFFFFFFFFFF78h
add rax, [rsi+90h]
jmp short loc_A66D7
loc_A66D5:
xor eax, eax
loc_A66D7:
mov [rdi], rax
loc_A66DA:
mov qword ptr [rsi+88h], 0
pop rbp
retn
| long long wqueue_unlink_from_queue(long long *a1, long long a2)
{
long long v2; // rax
long long *v3; // rcx
long long result; // rax
v2 = *(_QWORD *)(a2 + 136);
if ( v2 == a2 )
{
result = 0LL;
goto LABEL_5;
}
v3 = *(long long **)(a2 + 144);
*(_QWORD *)(v2 + 144) = v3;
result = *(_QWORD *)(a2 + 136);
*v3 = result;
if ( *a1 == a2 )
{
result = *(_QWORD *)(a2 + 144) - 136LL;
LABEL_5:
*a1 = result;
}
*(_QWORD *)(a2 + 136) = 0LL;
return result;
}
| wqueue_unlink_from_queue:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RSI + 0x88]
CMP RAX,RSI
JZ 0x001a66d5
MOV RCX,qword ptr [RSI + 0x90]
MOV qword ptr [RAX + 0x90],RCX
MOV RAX,qword ptr [RSI + 0x88]
MOV qword ptr [RCX],RAX
CMP qword ptr [RDI],RSI
JNZ 0x001a66da
MOV RAX,-0x88
ADD RAX,qword ptr [RSI + 0x90]
JMP 0x001a66d7
LAB_001a66d5:
XOR EAX,EAX
LAB_001a66d7:
MOV qword ptr [RDI],RAX
LAB_001a66da:
MOV qword ptr [RSI + 0x88],0x0
POP RBP
RET
|
void wqueue_unlink_from_queue(long *param_1,long param_2)
{
int8 *puVar1;
long lVar2;
if (*(long *)(param_2 + 0x88) == param_2) {
lVar2 = 0;
}
else {
puVar1 = *(int8 **)(param_2 + 0x90);
*(int8 **)(*(long *)(param_2 + 0x88) + 0x90) = puVar1;
*puVar1 = *(int8 *)(param_2 + 0x88);
if (*param_1 != param_2) goto LAB_001a66da;
lVar2 = *(long *)(param_2 + 0x90) + -0x88;
}
*param_1 = lVar2;
LAB_001a66da:
*(int8 *)(param_2 + 0x88) = 0;
return;
}
| |
24,128 | translog_write_fixed_record | eloqsql/storage/maria/ma_loghandler.c | static my_bool translog_write_fixed_record(LSN *lsn,
enum translog_record_type type,
MARIA_HA *tbl_info,
SHORT_TRANSACTION_ID short_trid,
struct st_translog_parts *parts,
TRN *trn, void *hook_arg)
{
struct st_translog_buffer *buffer_to_flush= NULL;
uchar chunk1_header[1 + 2];
/* Max number of such LSNs per record is 2 */
uchar compressed_LSNs[MAX_NUMBER_OF_LSNS_PER_RECORD *
COMPRESSED_LSN_MAX_STORE_SIZE];
LEX_CUSTRING *part;
int rc= 1;
DBUG_ENTER("translog_write_fixed_record");
DBUG_ASSERT((log_record_type_descriptor[type].rclass ==
LOGRECTYPE_FIXEDLENGTH &&
parts->record_length ==
log_record_type_descriptor[type].fixed_length) ||
(log_record_type_descriptor[type].rclass ==
LOGRECTYPE_PSEUDOFIXEDLENGTH &&
parts->record_length ==
log_record_type_descriptor[type].fixed_length));
translog_lock();
DBUG_PRINT("info", ("horizon: " LSN_FMT,
LSN_IN_PARTS(log_descriptor.horizon)));
DBUG_ASSERT(log_descriptor.bc.current_page_fill <= TRANSLOG_PAGE_SIZE);
DBUG_PRINT("info",
("Page size: %u record: %u next cond: %d",
log_descriptor.bc.current_page_fill,
(parts->record_length +
log_record_type_descriptor[type].compressed_LSN * 2 + 3),
((((uint) log_descriptor.bc.current_page_fill) +
(parts->record_length +
log_record_type_descriptor[type].compressed_LSN * 2 + 3)) >
TRANSLOG_PAGE_SIZE)));
/*
check that there is enough place on current page.
NOTE: compressing may increase page LSN size on two bytes for every LSN
*/
if ((((uint) log_descriptor.bc.current_page_fill) +
(parts->record_length +
log_record_type_descriptor[type].compressed_LSN * 2 + 3)) >
TRANSLOG_PAGE_SIZE)
{
DBUG_PRINT("info", ("Next page"));
if (translog_page_next(&log_descriptor.horizon, &log_descriptor.bc,
&buffer_to_flush))
goto err; /* rc == 1 */
if (buffer_to_flush)
translog_buffer_lock_assert_owner(buffer_to_flush);
}
set_lsn(lsn, log_descriptor.horizon);
if (translog_set_lsn_for_files(LSN_FILE_NO(*lsn), LSN_FILE_NO(*lsn),
*lsn, TRUE) ||
(log_record_type_descriptor[type].inwrite_hook &&
(*log_record_type_descriptor[type].inwrite_hook)(type, trn, tbl_info,
lsn, hook_arg)))
goto err;
/* compress LSNs */
if (log_record_type_descriptor[type].rclass ==
LOGRECTYPE_PSEUDOFIXEDLENGTH)
{
DBUG_ASSERT(log_record_type_descriptor[type].compressed_LSN > 0);
translog_relative_LSN_encode(parts, *lsn,
log_record_type_descriptor[type].
compressed_LSN, compressed_LSNs);
}
/*
Write the whole record at once (we know that there is enough place on
the destination page)
*/
DBUG_ASSERT(parts->current != 0); /* first part is left for header */
part= parts->parts + (--parts->current);
parts->total_record_length+= (translog_size_t) (part->length= 1 + 2);
part->str= chunk1_header;
*chunk1_header= (uchar) (type | TRANSLOG_CHUNK_FIXED);
int2store(chunk1_header + 1, short_trid);
rc= translog_write_parts_on_page(&log_descriptor.horizon,
&log_descriptor.bc,
parts->total_record_length, parts);
log_descriptor.bc.buffer->last_lsn= *lsn;
DBUG_PRINT("info", ("last_lsn set to " LSN_FMT " buffer: %p",
LSN_IN_PARTS(log_descriptor.bc.buffer->last_lsn),
log_descriptor.bc.buffer));
err:
translog_unlock();
/*
check if we switched buffer and need process it (current buffer is
unlocked already => we will not delay other threads
*/
if (buffer_to_flush != NULL)
{
if (!rc)
rc= translog_buffer_flush(buffer_to_flush);
translog_buffer_unlock(buffer_to_flush);
}
DBUG_RETURN(rc);
} | O0 | c | translog_write_fixed_record:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movw %cx, %ax
movq 0x10(%rbp), %rcx
movq %fs:0x28, %rcx
movq %rcx, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movw %ax, -0x3a(%rbp)
movq %r8, -0x48(%rbp)
movq %r9, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movl $0x1, -0x6c(%rbp)
jmp 0x8b507
callq 0x86ca0
jmp 0x8b50e
jmp 0x8b510
jmp 0x8b512
jmp 0x8b514
jmp 0x8b516
movzwl 0xbf0b73(%rip), %eax # 0xc7c090
movq -0x48(%rbp), %rcx
movl (%rcx), %ecx
movl -0x2c(%rbp), %edx
movl %edx, %esi
leaq 0x3eece1(%rip), %rdx # 0x47a210
imulq $0x48, %rsi, %rsi
addq %rsi, %rdx
movswl 0x20(%rdx), %edx
shll %edx
addl %edx, %ecx
addl $0x3, %ecx
addl %ecx, %eax
cmpl $0x2000, %eax # imm = 0x2000
jbe 0x8b583
jmp 0x8b54c
jmp 0x8b54e
leaq 0x3efebb(%rip), %rsi # 0x47b410
movq %rsi, %rdi
addq $0x800c48, %rdi # imm = 0x800C48
addq $0x800c50, %rsi # imm = 0x800C50
leaq -0x58(%rbp), %rdx
callq 0x90610
cmpb $0x0, %al
je 0x8b578
jmp 0x8b711
cmpq $0x0, -0x58(%rbp)
je 0x8b581
jmp 0x8b581
jmp 0x8b583
movq -0x28(%rbp), %rdi
movq 0xbf0aca(%rip), %rsi # 0xc7c058
callq 0x91fa0
movq -0x28(%rbp), %rax
movq (%rax), %rax
sarq $0x20, %rax
movl %eax, %edi
movq -0x28(%rbp), %rax
movq (%rax), %rax
sarq $0x20, %rax
movl %eax, %esi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movl $0x1, %ecx
callq 0x91fd0
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x8b614
movl -0x2c(%rbp), %eax
movl %eax, %ecx
leaq 0x3eec3e(%rip), %rax # 0x47a210
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x8b619
movl -0x2c(%rbp), %eax
movl %eax, %ecx
leaq 0x3eec24(%rip), %rax # 0x47a210
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl -0x2c(%rbp), %edi
movq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %r8
callq *%rax
movsbl %al, %eax
cmpl $0x0, %eax
je 0x8b619
jmp 0x8b711
movl -0x2c(%rbp), %eax
movl %eax, %ecx
leaq 0x3eebeb(%rip), %rax # 0x47a210
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0x8b660
jmp 0x8b633
jmp 0x8b635
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movl -0x2c(%rbp), %eax
movl %eax, %ecx
leaq 0x3eebc4(%rip), %rax # 0x47a210
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movswl 0x20(%rax), %edx
leaq -0x20(%rbp), %rcx
callq 0x90710
jmp 0x8b662
jmp 0x8b664
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x48(%rbp), %rdx
movl 0x8(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rdx)
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq $0x3, 0x8(%rax)
movq -0x48(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x3, %ecx
movl %ecx, 0x4(%rax)
leaq -0x5b(%rbp), %rcx
movq -0x68(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
orl $0x40, %eax
movb %al, -0x5b(%rbp)
leaq -0x5b(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
movw -0x3a(%rbp), %cx
movq -0x78(%rbp), %rax
movw %cx, (%rax)
movq -0x48(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x48(%rbp), %rcx
leaq 0x3efd34(%rip), %rsi # 0x47b410
movq %rsi, %rdi
addq $0x800c48, %rdi # imm = 0x800C48
addq $0x800c50, %rsi # imm = 0x800C50
callq 0x92170
movsbl %al, %eax
movl %eax, -0x6c(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq 0xbf0982(%rip), %rax # 0xc7c088
movq %rcx, 0x100000(%rax)
jmp 0x8b70f
jmp 0x8b711
callq 0x86d90
cmpq $0x0, -0x58(%rbp)
je 0x8b73b
cmpl $0x0, -0x6c(%rbp)
jne 0x8b732
movq -0x58(%rbp), %rdi
callq 0x8cf50
movsbl %al, %eax
movl %eax, -0x6c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x86d60
jmp 0x8b73d
movl -0x6c(%rbp), %eax
movb %al, -0x79(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x8b761
movb -0x79(%rbp), %al
addq $0x80, %rsp
popq %rbp
retq
callq 0x29230
nopw %cs:(%rax,%rax)
| translog_write_fixed_record:
push rbp
mov rbp, rsp
sub rsp, 80h
mov ax, cx
mov rcx, [rbp+arg_0]
mov rcx, fs:28h
mov [rbp+var_8], rcx
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
mov [rbp+var_3A], ax
mov [rbp+var_48], r8
mov [rbp+var_50], r9
mov [rbp+var_58], 0
mov [rbp+var_6C], 1
jmp short $+2
loc_8B507:
call translog_lock
jmp short $+2
loc_8B50E:
jmp short $+2
loc_8B510:
jmp short $+2
loc_8B512:
jmp short $+2
loc_8B514:
jmp short $+2
loc_8B516:
movzx eax, cs:word_C7C090
mov rcx, [rbp+var_48]
mov ecx, [rcx]
mov edx, [rbp+var_2C]
mov esi, edx
lea rdx, log_record_type_descriptor
imul rsi, 48h ; 'H'
add rdx, rsi
movsx edx, word ptr [rdx+20h]
shl edx, 1
add ecx, edx
add ecx, 3
add eax, ecx
cmp eax, 2000h
jbe short loc_8B583
jmp short $+2
loc_8B54C:
jmp short $+2
loc_8B54E:
lea rsi, log_descriptor
mov rdi, rsi
add rdi, 800C48h
add rsi, 800C50h
lea rdx, [rbp+var_58]
call translog_page_next
cmp al, 0
jz short loc_8B578
jmp loc_8B711
loc_8B578:
cmp [rbp+var_58], 0
jz short loc_8B581
jmp short $+2
loc_8B581:
jmp short $+2
loc_8B583:
mov rdi, [rbp+var_28]
mov rsi, cs:qword_C7C058
call set_lsn
mov rax, [rbp+var_28]
mov rax, [rax]
sar rax, 20h
mov edi, eax
mov rax, [rbp+var_28]
mov rax, [rax]
sar rax, 20h
mov esi, eax
mov rax, [rbp+var_28]
mov rdx, [rax]
mov ecx, 1
call translog_set_lsn_for_files
movsx eax, al
cmp eax, 0
jnz short loc_8B614
mov eax, [rbp+var_2C]
mov ecx, eax
lea rax, log_record_type_descriptor
imul rcx, 48h ; 'H'
add rax, rcx
cmp qword ptr [rax+10h], 0
jz short loc_8B619
mov eax, [rbp+var_2C]
mov ecx, eax
lea rax, log_record_type_descriptor
imul rcx, 48h ; 'H'
add rax, rcx
mov rax, [rax+10h]
mov edi, [rbp+var_2C]
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_38]
mov rcx, [rbp+var_28]
mov r8, [rbp+arg_0]
call rax
movsx eax, al
cmp eax, 0
jz short loc_8B619
loc_8B614:
jmp loc_8B711
loc_8B619:
mov eax, [rbp+var_2C]
mov ecx, eax
lea rax, log_record_type_descriptor
imul rcx, 48h ; 'H'
add rax, rcx
cmp dword ptr [rax], 2
jnz short loc_8B660
jmp short $+2
loc_8B633:
jmp short $+2
loc_8B635:
mov rdi, [rbp+var_48]
mov rax, [rbp+var_28]
mov rsi, [rax]
mov eax, [rbp+var_2C]
mov ecx, eax
lea rax, log_record_type_descriptor
imul rcx, 48h ; 'H'
add rax, rcx
movsx edx, word ptr [rax+20h]
lea rcx, [rbp+var_20]
call translog_relative_LSN_encode
loc_8B660:
jmp short $+2
loc_8B662:
jmp short $+2
loc_8B664:
mov rax, [rbp+var_48]
mov rax, [rax+10h]
mov rdx, [rbp+var_48]
mov ecx, [rdx+8]
add ecx, 0FFFFFFFFh
mov [rdx+8], ecx
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
mov qword ptr [rax+8], 3
mov rax, [rbp+var_48]
mov ecx, [rax+4]
add ecx, 3
mov [rax+4], ecx
lea rcx, [rbp+var_5B]
mov rax, [rbp+var_68]
mov [rax], rcx
mov eax, [rbp+var_2C]
or eax, 40h
mov [rbp+var_5B], al
lea rax, [rbp+var_5B]
add rax, 1
mov [rbp+var_78], rax
mov cx, [rbp+var_3A]
mov rax, [rbp+var_78]
mov [rax], cx
mov rax, [rbp+var_48]
mov edx, [rax+4]
mov rcx, [rbp+var_48]
lea rsi, log_descriptor
mov rdi, rsi
add rdi, 800C48h
add rsi, 800C50h
call translog_write_parts_on_page
movsx eax, al
mov [rbp+var_6C], eax
mov rax, [rbp+var_28]
mov rcx, [rax]
mov rax, cs:qword_C7C088
mov qword ptr ds:loc_100000[rax], rcx
jmp short $+2
loc_8B70F:
jmp short $+2
loc_8B711:
call translog_unlock
cmp [rbp+var_58], 0
jz short loc_8B73B
cmp [rbp+var_6C], 0
jnz short loc_8B732
mov rdi, [rbp+var_58]
call translog_buffer_flush
movsx eax, al
mov [rbp+var_6C], eax
loc_8B732:
mov rdi, [rbp+var_58]
call translog_buffer_unlock
loc_8B73B:
jmp short $+2
loc_8B73D:
mov eax, [rbp+var_6C]
mov [rbp+var_79], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_8B761
mov al, [rbp+var_79]
add rsp, 80h
pop rbp
retn
loc_8B761:
call ___stack_chk_fail
| char translog_write_fixed_record(
_QWORD *a1,
unsigned int a2,
long long a3,
__int16 a4,
long long a5,
long long a6,
long long a7)
{
long long v7; // rax
unsigned int v8; // ecx
int v10; // [rsp+14h] [rbp-6Ch]
char v11; // [rsp+25h] [rbp-5Bh] BYREF
__int16 v12; // [rsp+26h] [rbp-5Ah]
long long v13; // [rsp+28h] [rbp-58h] BYREF
long long v14; // [rsp+30h] [rbp-50h]
long long v15; // [rsp+38h] [rbp-48h]
__int16 v16; // [rsp+46h] [rbp-3Ah]
long long v17; // [rsp+48h] [rbp-38h]
unsigned int v18; // [rsp+54h] [rbp-2Ch]
_QWORD *v19; // [rsp+58h] [rbp-28h]
_BYTE v20[24]; // [rsp+60h] [rbp-20h] BYREF
unsigned long long v21; // [rsp+78h] [rbp-8h]
v21 = __readfsqword(0x28u);
v19 = a1;
v18 = a2;
v17 = a3;
v16 = a4;
v15 = a5;
v14 = a6;
v13 = 0LL;
v10 = 1;
translog_lock();
if ( 2 * SLOWORD(log_record_type_descriptor[18 * a2 + 8])
+ *(_DWORD *)v15
+ 3
+ (unsigned int)(unsigned __int16)word_C7C090 <= 0x2000
|| !(unsigned __int8)translog_page_next(&log_descriptor[1048969], &log_descriptor[1048970], &v13) )
{
set_lsn(v19, qword_C7C058);
if ( !(unsigned __int8)translog_set_lsn_for_files(
(unsigned int)HIDWORD(*v19),
(unsigned int)HIDWORD(*v19),
*v19,
1LL)
&& (!*(_QWORD *)&log_record_type_descriptor[18 * v18 + 4]
|| !(*(unsigned __int8 ( **)(_QWORD, long long, long long, _QWORD *, long long))&log_record_type_descriptor[18 * v18 + 4])(
v18,
v14,
v17,
v19,
a7)) )
{
if ( log_record_type_descriptor[18 * v18] == 2 )
translog_relative_LSN_encode(v15, *v19, (unsigned int)SLOWORD(log_record_type_descriptor[18 * v18 + 8]), v20);
v7 = *(_QWORD *)(v15 + 16);
v8 = *(_DWORD *)(v15 + 8) - 1;
*(_DWORD *)(v15 + 8) = v8;
*(_QWORD *)(16LL * v8 + v7 + 8) = 3LL;
*(_DWORD *)(v15 + 4) += 3;
*(_QWORD *)(16LL * v8 + v7) = &v11;
v11 = v18 | 0x40;
v12 = v16;
v10 = (char)translog_write_parts_on_page(
&log_descriptor[1048969],
&log_descriptor[1048970],
*(unsigned int *)(v15 + 4),
v15);
*(_QWORD *)((char *)&loc_100000 + qword_C7C088) = *v19;
}
}
translog_unlock();
if ( v13 )
{
if ( !v10 )
v10 = (unsigned __int8)translog_buffer_flush(v13);
translog_buffer_unlock(v13);
}
return v10;
}
| translog_write_fixed_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV AX,CX
MOV RCX,qword ptr [RBP + 0x10]
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RCX
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
MOV word ptr [RBP + -0x3a],AX
MOV qword ptr [RBP + -0x48],R8
MOV qword ptr [RBP + -0x50],R9
MOV qword ptr [RBP + -0x58],0x0
MOV dword ptr [RBP + -0x6c],0x1
JMP 0x0018b507
LAB_0018b507:
CALL 0x00186ca0
JMP 0x0018b50e
LAB_0018b50e:
JMP 0x0018b510
LAB_0018b510:
JMP 0x0018b512
LAB_0018b512:
JMP 0x0018b514
LAB_0018b514:
JMP 0x0018b516
LAB_0018b516:
MOVZX EAX,word ptr [0x00d7c090]
MOV RCX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RCX]
MOV EDX,dword ptr [RBP + -0x2c]
MOV ESI,EDX
LEA RDX,[0x57a210]
IMUL RSI,RSI,0x48
ADD RDX,RSI
MOVSX EDX,word ptr [RDX + 0x20]
SHL EDX,0x1
ADD ECX,EDX
ADD ECX,0x3
ADD EAX,ECX
CMP EAX,0x2000
JBE 0x0018b583
JMP 0x0018b54c
LAB_0018b54c:
JMP 0x0018b54e
LAB_0018b54e:
LEA RSI,[0x57b410]
MOV RDI,RSI
ADD RDI,0x800c48
ADD RSI,0x800c50
LEA RDX,[RBP + -0x58]
CALL 0x00190610
CMP AL,0x0
JZ 0x0018b578
JMP 0x0018b711
LAB_0018b578:
CMP qword ptr [RBP + -0x58],0x0
JZ 0x0018b581
JMP 0x0018b581
LAB_0018b581:
JMP 0x0018b583
LAB_0018b583:
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [0x00d7c058]
CALL 0x00191fa0
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
SAR RAX,0x20
MOV EDI,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
SAR RAX,0x20
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX]
MOV ECX,0x1
CALL 0x00191fd0
MOVSX EAX,AL
CMP EAX,0x0
JNZ 0x0018b614
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,EAX
LEA RAX,[0x57a210]
IMUL RCX,RCX,0x48
ADD RAX,RCX
CMP qword ptr [RAX + 0x10],0x0
JZ 0x0018b619
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,EAX
LEA RAX,[0x57a210]
IMUL RCX,RCX,0x48
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV EDI,dword ptr [RBP + -0x2c]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + 0x10]
CALL RAX
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x0018b619
LAB_0018b614:
JMP 0x0018b711
LAB_0018b619:
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,EAX
LEA RAX,[0x57a210]
IMUL RCX,RCX,0x48
ADD RAX,RCX
CMP dword ptr [RAX],0x2
JNZ 0x0018b660
JMP 0x0018b633
LAB_0018b633:
JMP 0x0018b635
LAB_0018b635:
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,EAX
LEA RAX,[0x57a210]
IMUL RCX,RCX,0x48
ADD RAX,RCX
MOVSX EDX,word ptr [RAX + 0x20]
LEA RCX,[RBP + -0x20]
CALL 0x00190710
LAB_0018b660:
JMP 0x0018b662
LAB_0018b662:
JMP 0x0018b664
LAB_0018b664:
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RDX + 0x8]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x8],ECX
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX + 0x8],0x3
MOV RAX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RAX + 0x4]
ADD ECX,0x3
MOV dword ptr [RAX + 0x4],ECX
LEA RCX,[RBP + -0x5b]
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0x2c]
OR EAX,0x40
MOV byte ptr [RBP + -0x5b],AL
LEA RAX,[RBP + -0x5b]
ADD RAX,0x1
MOV qword ptr [RBP + -0x78],RAX
MOV CX,word ptr [RBP + -0x3a]
MOV RAX,qword ptr [RBP + -0x78]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x48]
MOV EDX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x48]
LEA RSI,[0x57b410]
MOV RDI,RSI
ADD RDI,0x800c48
ADD RSI,0x800c50
CALL 0x00192170
MOVSX EAX,AL
MOV dword ptr [RBP + -0x6c],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [0x00d7c088]
MOV qword ptr [RAX + 0x100000],RCX
JMP 0x0018b70f
LAB_0018b70f:
JMP 0x0018b711
LAB_0018b711:
CALL 0x00186d90
CMP qword ptr [RBP + -0x58],0x0
JZ 0x0018b73b
CMP dword ptr [RBP + -0x6c],0x0
JNZ 0x0018b732
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x0018cf50
MOVSX EAX,AL
MOV dword ptr [RBP + -0x6c],EAX
LAB_0018b732:
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x00186d60
LAB_0018b73b:
JMP 0x0018b73d
LAB_0018b73d:
MOV EAX,dword ptr [RBP + -0x6c]
MOV byte ptr [RBP + -0x79],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0018b761
MOV AL,byte ptr [RBP + -0x79]
ADD RSP,0x80
POP RBP
RET
LAB_0018b761:
CALL 0x00129230
|
int8
translog_write_fixed_record
(long *param_1,uint param_2,int8 param_3,int2 param_4,int *param_5,
int8 param_6,int8 param_7)
{
int iVar1;
char cVar2;
char cVar3;
long *plVar4;
long in_FS_OFFSET;
byte local_63;
int2 local_62;
long local_60;
int8 local_58;
int *local_50;
int2 local_42;
int8 local_40;
uint local_34;
long *local_30;
int1 local_28 [24];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_60 = 0;
cVar3 = '\x01';
local_58 = param_6;
local_50 = param_5;
local_42 = param_4;
local_40 = param_3;
local_34 = param_2;
local_30 = param_1;
translog_lock();
if (((uint)DAT_00d7c090 +
*local_50 + *(short *)(log_record_type_descriptor + (ulong)local_34 * 0x48 + 0x20) * 2 + 3 <
0x2001) || (cVar2 = translog_page_next(&DAT_00d7c058,&DAT_00d7c060,&local_60), cVar2 == '\0')
) {
set_lsn(local_30,DAT_00d7c058);
cVar2 = translog_set_lsn_for_files
(*local_30 >> 0x20 & 0xffffffff,*local_30 >> 0x20 & 0xffffffff,*local_30,1);
if ((cVar2 == '\0') &&
((*(long *)(log_record_type_descriptor + (ulong)local_34 * 0x48 + 0x10) == 0 ||
(cVar2 = (**(code **)(log_record_type_descriptor + (ulong)local_34 * 0x48 + 0x10))
(local_34,local_58,local_40,local_30,param_7), cVar2 == '\0')))) {
if (*(int *)(log_record_type_descriptor + (ulong)local_34 * 0x48) == 2) {
translog_relative_LSN_encode
(local_50,*local_30,
(int)*(short *)(log_record_type_descriptor + (ulong)local_34 * 0x48 + 0x20),
local_28);
}
iVar1 = local_50[2];
local_50[2] = iVar1 - 1U;
plVar4 = (long *)(*(long *)(local_50 + 4) + (ulong)(iVar1 - 1U) * 0x10);
plVar4[1] = 3;
local_50[1] = local_50[1] + 3;
*plVar4 = (long)&local_63;
local_63 = (byte)local_34 | 0x40;
local_62 = local_42;
cVar3 = translog_write_parts_on_page(&DAT_00d7c058,&DAT_00d7c060,local_50[1],local_50);
*(long *)(DAT_00d7c088 + 0x100000) = *local_30;
}
}
translog_unlock();
if (local_60 != 0) {
if (cVar3 == '\0') {
cVar3 = translog_buffer_flush(local_60);
}
translog_buffer_unlock(local_60);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),cVar3);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
24,129 | freeze_size | eloqsql/mysys/array.c | void freeze_size(DYNAMIC_ARRAY *array)
{
uint elements;
/*
Do nothing if we are using a static buffer
*/
if (array->malloc_flags & MY_INIT_BUFFER_USED)
return;
elements= MY_MAX(array->elements, 1);
if (array->buffer && array->max_element > elements)
{
array->buffer=(uchar*) my_realloc(array->m_psi_key, array->buffer,
elements * array->size_of_element,
MYF(MY_WME | array->malloc_flags));
array->max_element= elements;
}
} | O0 | c | freeze_size:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
andq $0x100, %rax # imm = 0x100
cmpq $0x0, %rax
je 0x34672
jmp 0x346f0
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jbe 0x34688
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x34692
movl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x34692
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x346f0
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0xc(%rbp), %eax
jbe 0x346f0
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
orq $0x10, %rcx
callq 0x30370
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| freeze_size:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+20h]
and rax, 100h
cmp rax, 0
jz short loc_34672
jmp short loc_346F0
loc_34672:
mov rax, [rbp+var_8]
cmp dword ptr [rax+8], 1
jbe short loc_34688
mov rax, [rbp+var_8]
mov eax, [rax+8]
mov [rbp+var_10], eax
jmp short loc_34692
loc_34688:
mov eax, 1
mov [rbp+var_10], eax
jmp short $+2
loc_34692:
mov eax, [rbp+var_10]
mov [rbp+var_C], eax
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz short loc_346F0
mov rax, [rbp+var_8]
mov eax, [rax+0Ch]
cmp eax, [rbp+var_C]
jbe short loc_346F0
mov rax, [rbp+var_8]
mov edi, [rax+18h]
mov rax, [rbp+var_8]
mov rsi, [rax]
mov eax, [rbp+var_C]
mov rcx, [rbp+var_8]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
or rcx, 10h
call my_realloc
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax], rcx
mov ecx, [rbp+var_C]
mov rax, [rbp+var_8]
mov [rax+0Ch], ecx
loc_346F0:
add rsp, 10h
pop rbp
retn
| long long freeze_size(long long a1)
{
long long result; // rax
unsigned int v2; // [rsp+0h] [rbp-10h]
result = *(_QWORD *)(a1 + 32) & 0x100LL;
if ( !result )
{
if ( *(_DWORD *)(a1 + 8) <= 1u )
v2 = 1;
else
v2 = *(_DWORD *)(a1 + 8);
result = a1;
if ( *(_QWORD *)a1 )
{
result = *(unsigned int *)(a1 + 12);
if ( (unsigned int)result > v2 )
{
*(_QWORD *)a1 = my_realloc(
*(_DWORD *)(a1 + 24),
*(_QWORD *)a1,
*(_DWORD *)(a1 + 20) * v2,
*(_BYTE *)(a1 + 32) | 0x10u);
result = a1;
*(_DWORD *)(a1 + 12) = v2;
}
}
}
return result;
}
| freeze_size:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x20]
AND RAX,0x100
CMP RAX,0x0
JZ 0x00134672
JMP 0x001346f0
LAB_00134672:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x8],0x1
JBE 0x00134688
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x10],EAX
JMP 0x00134692
LAB_00134688:
MOV EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x00134692
LAB_00134692:
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0xc],EAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX],0x0
JZ 0x001346f0
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xc]
CMP EAX,dword ptr [RBP + -0xc]
JBE 0x001346f0
MOV RAX,qword ptr [RBP + -0x8]
MOV EDI,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
OR RCX,0x10
CALL 0x00130370
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xc],ECX
LAB_001346f0:
ADD RSP,0x10
POP RBP
RET
|
void freeze_size(long *param_1)
{
long lVar1;
uint local_18;
if ((param_1[4] & 0x100U) == 0) {
if (*(uint *)(param_1 + 1) < 2) {
local_18 = 1;
}
else {
local_18 = *(uint *)(param_1 + 1);
}
if ((*param_1 != 0) && (local_18 < *(uint *)((long)param_1 + 0xc))) {
lVar1 = my_realloc((int)param_1[3],*param_1,local_18 * *(int *)((long)param_1 + 0x14),
param_1[4] | 0x10);
*param_1 = lVar1;
*(uint *)((long)param_1 + 0xc) = local_18;
}
}
return;
}
| |
24,130 | sp_get_linestring_mbr | eloqsql/storage/maria/ma_sp_key.c | static int sp_get_linestring_mbr(uchar *(*wkb), uchar *end, uint n_dims,
uchar byte_order, double *mbr)
{
uint n_points;
n_points = uint4korr(*wkb);
(*wkb) += 4;
for (; n_points > 0; --n_points)
{
/* Add next point to mbr */
if (sp_add_point_to_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
return 0;
} | O0 | c | sp_get_linestring_mbr:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x2c(%rbp)
jbe 0x9c761
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x1d(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x9c830
cmpl $0x0, %eax
je 0x9c754
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9c768
jmp 0x9c756
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9c726
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| sp_get_linestring_mbr:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, cl
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_1D], al
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_2C], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_9C726:
cmp [rbp+var_2C], 0
jbe short loc_9C761
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_1D]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_add_point_to_mbr
cmp eax, 0
jz short loc_9C754
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_9C768
loc_9C754:
jmp short $+2
loc_9C756:
mov eax, [rbp+var_2C]
add eax, 0FFFFFFFFh
mov [rbp+var_2C], eax
jmp short loc_9C726
loc_9C761:
mov [rbp+var_4], 0
loc_9C768:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long sp_get_linestring_mbr(_DWORD **a1, long long a2, unsigned int a3, unsigned __int8 a4, long long a5)
{
int i; // [rsp+4h] [rbp-2Ch]
for ( i = *(*a1)++; i; --i )
{
if ( (unsigned int)sp_add_point_to_mbr(a1, a2, a3, a4, a5) )
return (unsigned int)-1;
}
return 0;
}
| sp_get_linestring_mbr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,CL
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV byte ptr [RBP + -0x1d],AL
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_0019c726:
CMP dword ptr [RBP + -0x2c],0x0
JBE 0x0019c761
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x1d]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x0019c830
CMP EAX,0x0
JZ 0x0019c754
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0019c768
LAB_0019c754:
JMP 0x0019c756
LAB_0019c756:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0019c726
LAB_0019c761:
MOV dword ptr [RBP + -0x4],0x0
LAB_0019c768:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4
sp_get_linestring_mbr
(long *param_1,int8 param_2,int4 param_3,int1 param_4,int8 param_5
)
{
int iVar1;
int local_34;
local_34 = *(int *)*param_1;
*param_1 = *param_1 + 4;
while( true ) {
if (local_34 == 0) {
return 0;
}
iVar1 = sp_add_point_to_mbr(param_1,param_2,param_3,param_4,param_5);
if (iVar1 != 0) break;
local_34 = local_34 + -1;
}
return 0xffffffff;
}
| |
24,131 | psi_rwlock_rdlock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD
int psi_rwlock_rdlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_rdwait)
(&state, that->m_psi, PSI_RWLOCK_READLOCK, file, line);
int result= rw_rdlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, result);
return result;
} | O3 | c | psi_rwlock_rdlock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %r14
leaq 0x3573a3(%rip), %r15 # 0x386010
movq (%r15), %rax
movq 0x90(%rdi), %rsi
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq *0x1a0(%rax)
movq %rax, %rbx
movq %r14, %rdi
callq 0xa429c
movl %eax, %r14d
testq %rbx, %rbx
je 0x2eca5
movq (%r15), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x1a8(%rax)
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| psi_rwlock_rdlock:
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+90h]
lea rdi, [rbp+var_48]
xor edx, edx
call qword ptr [rax+1A0h]
mov rbx, rax
mov rdi, r14
call my_rw_rdlock
mov r14d, eax
test rbx, rbx
jz short loc_2ECA5
mov rax, [r15]
mov rdi, rbx
mov esi, r14d
call qword ptr [rax+1A8h]
loc_2ECA5:
mov eax, r14d
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long psi_rwlock_rdlock(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, _QWORD, long long, _QWORD))PSI_server[52])(
v6,
*(_QWORD *)(a1 + 144),
0LL,
a2,
a3);
v4 = my_rw_rdlock(a1);
if ( v3 )
((void ( *)(long long, _QWORD))PSI_server[53])(v3, v4);
return v4;
}
| psi_rwlock_rdlock:
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 + 0x90]
LEA RDI,[RBP + -0x48]
XOR EDX,EDX
CALL qword ptr [RAX + 0x1a0]
MOV RBX,RAX
MOV RDI,R14
CALL 0x001a429c
MOV R14D,EAX
TEST RBX,RBX
JZ 0x0012eca5
MOV RAX,qword ptr [R15]
MOV RDI,RBX
MOV ESI,R14D
CALL qword ptr [RAX + 0x1a8]
LAB_0012eca5:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 psi_rwlock_rdlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [48];
lVar2 = (**(code **)(PSI_server + 0x1a0))
(local_50,*(int8 *)(param_1 + 0x90),0,param_2,param_3);
uVar1 = my_rw_rdlock(param_1);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1a8))(lVar2,uVar1);
}
return uVar1;
}
| |
24,132 | js_os_close | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_os_close(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int fd, ret;
if (JS_ToInt32(ctx, &fd, argv[0]))
return JS_EXCEPTION;
ret = js_get_errno(close(fd));
return JS_NewInt32(ctx, ret);
} | O0 | c | js_os_close:
subq $0x68, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0xc(%rsp), %rsi
callq 0x38f20
cmpl $0x0, %eax
je 0x17c9f
movl $0x0, 0x38(%rsp)
movq $0x6, 0x40(%rsp)
jmp 0x17ceb
movl 0xc(%rsp), %edi
callq 0xe3a0
movslq %eax, %rdi
callq 0x13a50
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movl 0x8(%rsp), %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x58(%rsp)
movq $0x0, 0x60(%rsp)
movq 0x58(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x68, %rsp
retq
nopw (%rax,%rax)
| js_os_close:
sub rsp, 68h
mov [rsp+68h+var_40], rsi
mov [rsp+68h+var_38], rdx
mov [rsp+68h+var_48], rdi
mov [rsp+68h+var_4C], ecx
mov [rsp+68h+var_58], r8
mov rdi, [rsp+68h+var_48]
mov rax, [rsp+68h+var_58]
mov rdx, [rax]
mov rcx, [rax+8]
lea rsi, [rsp+68h+var_5C]
call JS_ToInt32
cmp eax, 0
jz short loc_17C9F
mov dword ptr [rsp+68h+var_30], 0
mov [rsp+68h+var_28], 6
jmp short loc_17CEB
loc_17C9F:
mov edi, [rsp+68h+var_5C]
call _close
movsxd rdi, eax
call js_get_errno
mov [rsp+68h+var_60], eax
mov rcx, [rsp+68h+var_48]
mov eax, [rsp+68h+var_60]
mov [rsp+68h+var_18], rcx
mov [rsp+68h+var_1C], eax
mov eax, [rsp+68h+var_1C]
mov dword ptr [rsp+68h+var_10], eax
mov [rsp+68h+var_8], 0
mov rcx, [rsp+68h+var_10]
mov rax, [rsp+68h+var_8]
mov [rsp+68h+var_30], rcx
mov [rsp+68h+var_28], rax
loc_17CEB:
mov rax, [rsp+68h+var_30]
mov rdx, [rsp+68h+var_28]
add rsp, 68h
retn
| long long js_os_close(long long a1, long long a2, long long a3, int a4, _QWORD *a5)
{
int v5; // eax
int errno; // [rsp+8h] [rbp-60h]
unsigned int v8; // [rsp+Ch] [rbp-5Ch] BYREF
_QWORD *v9; // [rsp+10h] [rbp-58h]
int v10; // [rsp+1Ch] [rbp-4Ch]
long long v11; // [rsp+20h] [rbp-48h]
long long v12; // [rsp+28h] [rbp-40h]
long long v13; // [rsp+30h] [rbp-38h]
long long v14; // [rsp+38h] [rbp-30h]
long long v15; // [rsp+40h] [rbp-28h]
int v16; // [rsp+4Ch] [rbp-1Ch]
long long v17; // [rsp+50h] [rbp-18h]
long long v18; // [rsp+58h] [rbp-10h]
long long v19; // [rsp+60h] [rbp-8h]
v12 = a2;
v13 = a3;
v11 = a1;
v10 = a4;
v9 = a5;
if ( (unsigned int)JS_ToInt32(a1, &v8, *a5, a5[1]) )
{
LODWORD(v14) = 0;
v15 = 6LL;
}
else
{
v5 = close(v8);
errno = js_get_errno(v5);
v17 = v11;
v16 = errno;
LODWORD(v18) = errno;
v19 = 0LL;
v14 = v18;
v15 = 0LL;
}
return v14;
}
| js_os_close:
SUB RSP,0x68
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ECX
MOV qword ptr [RSP + 0x10],R8
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0xc]
CALL 0x00138f20
CMP EAX,0x0
JZ 0x00117c9f
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x6
JMP 0x00117ceb
LAB_00117c9f:
MOV EDI,dword ptr [RSP + 0xc]
CALL 0x0010e3a0
MOVSXD RDI,EAX
CALL 0x00113a50
MOV dword ptr [RSP + 0x8],EAX
MOV RCX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x50],RCX
MOV dword ptr [RSP + 0x4c],EAX
MOV EAX,dword ptr [RSP + 0x4c]
MOV dword ptr [RSP + 0x58],EAX
MOV qword ptr [RSP + 0x60],0x0
MOV RCX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x40],RAX
LAB_00117ceb:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x68
RET
|
int1 [16]
js_os_close(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
int1 auVar1 [16];
int iVar2;
int local_5c;
int8 *local_58;
int4 local_4c;
int8 local_48;
int8 local_40;
int8 local_38;
int4 local_30;
int4 uStack_2c;
int8 local_28;
int4 uStack_c;
local_58 = param_5;
local_4c = param_4;
local_48 = param_1;
local_40 = param_2;
local_38 = param_3;
iVar2 = JS_ToInt32(param_1,&local_5c,*param_5,param_5[1]);
if (iVar2 == 0) {
iVar2 = close(local_5c);
local_30 = js_get_errno((long)iVar2);
uStack_2c = uStack_c;
local_28 = 0;
}
else {
local_30 = 0;
local_28 = 6;
}
auVar1._4_4_ = uStack_2c;
auVar1._0_4_ = local_30;
auVar1._8_8_ = local_28;
return auVar1;
}
| |
24,133 | build_repetition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/json-schema-to-grammar.cpp | static std::string build_repetition(const std::string & item_rule, int min_items, int max_items, const std::string & separator_rule = "") {
auto has_max = max_items != std::numeric_limits<int>::max();
if (min_items == 0 && max_items == 1) {
return item_rule + "?";
}
if (separator_rule.empty()) {
if (min_items == 1 && !has_max) {
return item_rule + "+";
} else if (min_items == 0 && !has_max) {
return item_rule + "*";
} else {
return item_rule + "{" + std::to_string(min_items) + "," + (has_max ? std::to_string(max_items) : "") + "}";
}
}
auto result = item_rule + " " + build_repetition("(" + separator_rule + " " + item_rule + ")", min_items == 0 ? 0 : min_items - 1, has_max ? max_items - 1 : max_items);
if (min_items == 0) {
result = "(" + result + ")?";
}
return result;
} | O2 | cpp | build_repetition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl %ecx, %eax
xorl $0x1, %eax
orl %edx, %eax
jne 0x8b444
leaq 0x2d3ef(%rip), %rdx # 0xb8823
movq %rbx, %rdi
movq %r15, %rsi
callq 0x384fb
jmp 0x8b6ed
movq %r8, %r12
movl %ecx, %ebp
movl %edx, %r14d
cmpq $0x0, 0x8(%r8)
je 0x8b5c9
leaq 0x2809f(%rip), %rdx # 0xb34fd
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x384fb
leaq 0x2d5c8(%rip), %rsi # 0xb8a3a
leaq 0x50(%rsp), %rdi
movq %r12, %rdx
callq 0x39738
leaq 0x28077(%rip), %rdx # 0xb34fd
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x384dc
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movq %r15, %rdx
callq 0x3acf4
leaq 0x2d242(%rip), %rdx # 0xb86f3
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x384dc
leaq 0x2460c(%rip), %rsi # 0xafad9
leaq 0xd0(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x27686
xorl %eax, %eax
cmpl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
setne %al
subl %eax, %ebp
xorl %eax, %eax
movl %r14d, %edx
subl $0x1, %edx
cmovbl %eax, %edx
leaq 0x10(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0xd0(%rsp), %r8
movl %ebp, %ecx
callq 0x8b40f
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x3956b
leaq 0x10(%rsp), %rdi
callq 0x241f8
leaq 0xd0(%rsp), %rdi
callq 0x241f8
leaq 0xb0(%rsp), %rdi
callq 0x241f8
leaq 0x90(%rsp), %rdi
callq 0x241f8
leaq 0x70(%rsp), %rdi
callq 0x241f8
leaq 0x50(%rsp), %rdi
callq 0x241f8
leaq 0x30(%rsp), %rdi
callq 0x241f8
testl %r14d, %r14d
jne 0x8b6ed
leaq 0x2d4b6(%rip), %rsi # 0xb8a3a
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
callq 0x39738
leaq 0x2d444(%rip), %rdx # 0xb89dc
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x384dc
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23ae0
movq %r14, %rdi
callq 0x241f8
leaq 0x10(%rsp), %rdi
jmp 0x8b6e8
movl %ebp, %eax
xorl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movl %r14d, %ecx
xorl $0x1, %ecx
orl %eax, %ecx
je 0x8b64c
orl %r14d, %eax
je 0x8b658
leaq 0x28687(%rip), %rdx # 0xb3c6d
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
callq 0x384fb
leaq 0x70(%rsp), %rdi
movl %r14d, %esi
callq 0x3de2f
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x3956b
leaq 0x28b42(%rip), %rdx # 0xb4166
leaq 0x10(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x384dc
cmpl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
je 0x8b664
leaq 0x50(%rsp), %rdi
movl %ebp, %esi
callq 0x3de2f
jmp 0x8b67d
leaq 0x293fa(%rip), %rdx # 0xb4a4d
jmp 0x8b434
leaq 0x2f15d(%rip), %rdx # 0xba7bc
jmp 0x8b434
leaq 0x2446e(%rip), %rsi # 0xafad9
leaq 0x50(%rsp), %rdi
leaq 0xd0(%rsp), %rdx
callq 0x27686
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x3956b
leaq 0x2cdb7(%rip), %rdx # 0xb844f
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x384dc
leaq 0x30(%rsp), %rdi
callq 0x241f8
leaq 0x50(%rsp), %rdi
callq 0x241f8
cmpl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x10(%rsp), %rdi
callq 0x241f8
leaq 0xb0(%rsp), %rdi
callq 0x241f8
leaq 0x70(%rsp), %rdi
callq 0x241f8
leaq 0x90(%rsp), %rdi
callq 0x241f8
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8b702
movq %rax, %r14
jmp 0x8b729
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x241f8
jmp 0x8b719
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x241f8
cmpl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
leaq 0x10(%rsp), %rdi
callq 0x241f8
jmp 0x8b738
movq %rax, %r14
leaq 0xb0(%rsp), %rdi
callq 0x241f8
jmp 0x8b74a
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x241f8
leaq 0x90(%rsp), %rdi
jmp 0x8b7db
movq %rax, %r14
jmp 0x8b754
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x241f8
jmp 0x8b775
movq %rax, %r14
movq %rbx, %rdi
jmp 0x8b7db
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x241f8
jmp 0x8b78c
movq %rax, %r14
leaq 0xd0(%rsp), %rdi
callq 0x241f8
jmp 0x8b79e
movq %rax, %r14
leaq 0xb0(%rsp), %rdi
callq 0x241f8
jmp 0x8b7b0
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x241f8
jmp 0x8b7c2
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x241f8
leaq 0x50(%rsp), %rdi
callq 0x241f8
leaq 0x30(%rsp), %rdi
callq 0x241f8
movq %r14, %rdi
callq 0x23fc0
movq %rax, %r14
jmp 0x8b7cc
movq %rax, %r14
jmp 0x8b7d6
| _ZL16build_repetitionRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiiS6_:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 0F0h
mov r15, rsi
mov rbx, rdi
mov eax, ecx
xor eax, 1
or eax, edx
jnz short loc_8B444
lea rdx, asc_B8820+3; "?"
loc_8B434:
mov rdi, rbx
mov rsi, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
jmp loc_8B6ED
loc_8B444:
mov r12, r8
mov ebp, ecx
mov r14d, edx
cmp qword ptr [r8+8], 0
jz loc_8B5C9
lea rdx, aForMessageInMe+144h; " "
lea rdi, [rsp+118h+var_E8]
mov rsi, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
lea rsi, asc_B8A35+5; "("
lea rdi, [rsp+118h+var_C8]
mov rdx, r12
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, aForMessageInMe+144h; " "
lea rdi, [rsp+118h+var_A8]
lea rsi, [rsp+118h+var_C8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+118h+var_88]
lea rsi, [rsp+118h+var_A8]
mov rdx, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
lea rdx, a09401910201912+51h; ")"
lea rdi, [rsp+118h+var_68]
lea rsi, [rsp+118h+var_88]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rsi, aErrorWhileHand_0+34h; ""
lea rdi, [rsp+118h+var_48]
lea rdx, [rsp+118h+var_109]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
xor eax, eax
cmp ebp, 7FFFFFFFh
setnz al
sub ebp, eax
xor eax, eax
mov edx, r14d
sub edx, 1
cmovb edx, eax
lea rdi, [rsp+118h+var_108]
lea rsi, [rsp+118h+var_68]
lea r8, [rsp+118h+var_48]
mov ecx, ebp
call _ZL16build_repetitionRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiiS6_; build_repetition(std::string const&,int,int,std::string const&)
lea rsi, [rsp+118h+var_E8]
lea rdx, [rsp+118h+var_108]
mov rdi, rbx
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdi, [rsp+118h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r14d, r14d
jnz loc_8B6ED
lea rsi, asc_B8A35+5; "("
lea rdi, [rsp+118h+var_108]
mov rdx, rbx
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, asc_B89DB+1; ")?"
lea rdi, [rsp+118h+var_E8]
lea rsi, [rsp+118h+var_108]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea r14, [rsp+118h+var_E8]
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_108]
jmp loc_8B6E8
loc_8B5C9:
mov eax, ebp
xor eax, 7FFFFFFFh
mov ecx, r14d
xor ecx, 1
or ecx, eax
jz short loc_8B64C
or eax, r14d
jz short loc_8B658
lea rdx, asc_B3C6D; "{"
lea rdi, [rsp+118h+var_88]
mov rsi, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
lea rdi, [rsp+118h+var_A8]; this
mov esi, r14d; int
call _ZNSt7__cxx119to_stringEi; std::to_string(int)
lea rdi, [rsp+118h+var_68]
lea rsi, [rsp+118h+var_88]
lea rdx, [rsp+118h+var_A8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdx, asc_B4166; ","
lea rdi, [rsp+118h+var_108]
lea rsi, [rsp+118h+var_68]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
cmp ebp, 7FFFFFFFh
jz short loc_8B664
lea rdi, [rsp+118h+var_C8]; this
mov esi, ebp; int
call _ZNSt7__cxx119to_stringEi; std::to_string(int)
jmp short loc_8B67D
loc_8B64C:
lea rdx, aSRN_0+0Bh; "+"
jmp loc_8B434
loc_8B658:
lea rdx, asc_BA7BB+1; "*"
jmp loc_8B434
loc_8B664:
lea rsi, aErrorWhileHand_0+34h; ""
lea rdi, [rsp+118h+var_C8]
lea rdx, [rsp+118h+var_48]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
loc_8B67D:
lea rdi, [rsp+118h+var_E8]
lea rsi, [rsp+118h+var_108]
lea rdx, [rsp+118h+var_C8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdx, aNT020+17h; "}"
lea rsi, [rsp+118h+var_E8]
mov rdi, rbx
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+118h+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
cmp ebp, 7FFFFFFFh
lea rdi, [rsp+118h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+118h+var_88]; void *
loc_8B6E8:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_8B6ED:
mov rax, rbx
add rsp, 0F0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_8B702:
mov r14, rax
jmp short loc_8B729
mov r14, rax
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B719
mov r14, rax
loc_8B719:
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
cmp ebp, 7FFFFFFFh
loc_8B729:
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B738
mov r14, rax
loc_8B738:
lea rdi, [rsp+arg_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B74A
mov r14, rax
loc_8B74A:
lea rdi, [rsp+arg_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_8B754:
lea rdi, [rsp+arg_88]
jmp short loc_8B7DB
mov r14, rax
jmp short loc_8B754
mov r14, rax
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B775
mov r14, rax
loc_8B775:
mov rdi, rbx
jmp short loc_8B7DB
mov r14, rax
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B78C
mov r14, rax
loc_8B78C:
lea rdi, [rsp+arg_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B79E
mov r14, rax
loc_8B79E:
lea rdi, [rsp+arg_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B7B0
mov r14, rax
loc_8B7B0:
lea rdi, [rsp+arg_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8B7C2
mov r14, rax
loc_8B7C2:
lea rdi, [rsp+arg_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_8B7CC:
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_8B7D6:
lea rdi, [rsp+arg_28]; void *
loc_8B7DB:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
mov r14, rax
jmp short loc_8B7CC
mov r14, rax
jmp short loc_8B7D6
| long long build_repetition(long long a1, long long a2, int a3, int a4, long long a5)
{
char *v6; // rdx
int v10; // r9d
int v11; // ebp
int v12; // edx
_QWORD *v13; // rdi
_QWORD v15[4]; // [rsp+10h] [rbp-108h] BYREF
_QWORD v16[4]; // [rsp+30h] [rbp-E8h] BYREF
_QWORD v17[4]; // [rsp+50h] [rbp-C8h] BYREF
_QWORD v18[4]; // [rsp+70h] [rbp-A8h] BYREF
_QWORD v19[4]; // [rsp+90h] [rbp-88h] BYREF
_BYTE v20[32]; // [rsp+B0h] [rbp-68h] BYREF
_QWORD v21[9]; // [rsp+D0h] [rbp-48h] BYREF
if ( !(a3 | a4 ^ 1) )
{
v6 = "?";
LABEL_3:
std::operator+<char>(a1, a2, (long long)v6);
return a1;
}
if ( !*(_QWORD *)(a5 + 8) )
{
if ( !(a4 ^ 0x7FFFFFFF | a3 ^ 1) )
{
v6 = "+";
goto LABEL_3;
}
if ( !(a3 | a4 ^ 0x7FFFFFFF) )
{
v6 = "*";
goto LABEL_3;
}
std::operator+<char>((long long)v19, a2, (long long)"{");
std::to_string((std::__cxx11 *)v18, a3);
std::operator+<char>((long long)v20, v19, v18);
std::operator+<char>((long long)v15, (long long)v20, (long long)",");
if ( a4 == 0x7FFFFFFF )
std::string::basic_string<std::allocator<char>>(v17, (long long)"");
else
std::to_string((std::__cxx11 *)v17, a4);
std::operator+<char>((long long)v16, v15, v17);
std::operator+<char>(a1, (long long)v16, (long long)"}");
std::string::~string(v16);
std::string::~string(v17);
std::string::~string(v15);
std::string::~string(v20);
std::string::~string(v18);
v13 = v19;
LABEL_17:
std::string::~string(v13);
return a1;
}
std::operator+<char>((long long)v16, a2, (long long)" ");
std::operator+<char>((long long)v17, (long long)"(", a5);
std::operator+<char>((long long)v18, (long long)v17, (long long)" ");
std::operator+<char>((long long)v19, (long long)v18, a2);
std::operator+<char>((long long)v20, (long long)v19, (long long)")");
std::string::basic_string<std::allocator<char>>(v21, (long long)"");
v11 = a4 - (a4 != 0x7FFFFFFF);
v12 = a3 - 1;
if ( !a3 )
v12 = 0;
build_repetition((unsigned int)v15, (unsigned int)v20, v12, v11, (unsigned int)v21, v10);
std::operator+<char>(a1, v16, v15);
std::string::~string(v15);
std::string::~string(v21);
std::string::~string(v20);
std::string::~string(v19);
std::string::~string(v18);
std::string::~string(v17);
std::string::~string(v16);
if ( !a3 )
{
std::operator+<char>((long long)v15, (long long)"(", a1);
std::operator+<char>((long long)v16, (long long)v15, (long long)")?");
std::string::operator=(a1, v16);
std::string::~string(v16);
v13 = v15;
goto LABEL_17;
}
return a1;
}
| build_repetition:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xf0
MOV R15,RSI
MOV RBX,RDI
MOV EAX,ECX
XOR EAX,0x1
OR EAX,EDX
JNZ 0x0018b444
LEA RDX,[0x1b8823]
LAB_0018b434:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001384fb
JMP 0x0018b6ed
LAB_0018b444:
MOV R12,R8
MOV EBP,ECX
MOV R14D,EDX
CMP qword ptr [R8 + 0x8],0x0
JZ 0x0018b5c9
LEA RDX,[0x1b34fd]
LEA RDI,[RSP + 0x30]
MOV RSI,R15
CALL 0x001384fb
LAB_0018b46b:
LEA RSI,[0x1b8a3a]
LEA RDI,[RSP + 0x50]
MOV RDX,R12
CALL 0x00139738
LAB_0018b47f:
LEA RDX,[0x1b34fd]
LEA RDI,[RSP + 0x70]
LEA RSI,[RSP + 0x50]
CALL 0x001384dc
LAB_0018b495:
LEA RDI,[RSP + 0x90]
LEA RSI,[RSP + 0x70]
MOV RDX,R15
CALL 0x0013acf4
LAB_0018b4aa:
LEA RDX,[0x1b86f3]
LEA RDI,[RSP + 0xb0]
LEA RSI,[RSP + 0x90]
CALL 0x001384dc
LAB_0018b4c6:
LEA RSI,[0x1afad9]
LEA RDI,[RSP + 0xd0]
LEA RDX,[RSP + 0xf]
CALL 0x00127686
XOR EAX,EAX
CMP EBP,0x7fffffff
SETNZ AL
SUB EBP,EAX
XOR EAX,EAX
MOV EDX,R14D
SUB EDX,0x1
CMOVC EDX,EAX
LAB_0018b4f7:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0xb0]
LEA R8,[RSP + 0xd0]
MOV ECX,EBP
CALL 0x0018b40f
LAB_0018b513:
LEA RSI,[RSP + 0x30]
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
CALL 0x0013956b
LEA RDI,[RSP + 0x10]
CALL 0x001241f8
LEA RDI,[RSP + 0xd0]
CALL 0x001241f8
LEA RDI,[RSP + 0xb0]
CALL 0x001241f8
LEA RDI,[RSP + 0x90]
CALL 0x001241f8
LEA RDI,[RSP + 0x70]
CALL 0x001241f8
LEA RDI,[RSP + 0x50]
CALL 0x001241f8
LEA RDI,[RSP + 0x30]
CALL 0x001241f8
TEST R14D,R14D
JNZ 0x0018b6ed
LAB_0018b57d:
LEA RSI,[0x1b8a3a]
LEA RDI,[RSP + 0x10]
MOV RDX,RBX
CALL 0x00139738
LAB_0018b591:
LEA RDX,[0x1b89dc]
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x10]
CALL 0x001384dc
LAB_0018b5a7:
LEA R14,[RSP + 0x30]
MOV RDI,RBX
MOV RSI,R14
CALL 0x00123ae0
MOV RDI,R14
CALL 0x001241f8
LEA RDI,[RSP + 0x10]
JMP 0x0018b6e8
LAB_0018b5c9:
MOV EAX,EBP
XOR EAX,0x7fffffff
MOV ECX,R14D
XOR ECX,0x1
OR ECX,EAX
JZ 0x0018b64c
OR EAX,R14D
JZ 0x0018b658
LEA RDX,[0x1b3c6d]
LEA RDI,[RSP + 0x90]
MOV RSI,R15
CALL 0x001384fb
LAB_0018b5f6:
LEA RDI,[RSP + 0x70]
MOV ESI,R14D
CALL 0x0013de2f
LAB_0018b603:
LEA RDI,[RSP + 0xb0]
LEA RSI,[RSP + 0x90]
LEA RDX,[RSP + 0x70]
CALL 0x0013956b
LAB_0018b61d:
LEA RDX,[0x1b4166]
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0xb0]
CALL 0x001384dc
CMP EBP,0x7fffffff
JZ 0x0018b664
LAB_0018b63e:
LEA RDI,[RSP + 0x50]
MOV ESI,EBP
CALL 0x0013de2f
JMP 0x0018b67d
LAB_0018b64c:
LEA RDX,[0x1b4a4d]
JMP 0x0018b434
LAB_0018b658:
LEA RDX,[0x1ba7bc]
JMP 0x0018b434
LAB_0018b664:
LEA RSI,[0x1afad9]
LEA RDI,[RSP + 0x50]
LEA RDX,[RSP + 0xd0]
CALL 0x00127686
LAB_0018b67d:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0x50]
CALL 0x0013956b
LAB_0018b691:
LEA RDX,[0x1b844f]
LEA RSI,[RSP + 0x30]
MOV RDI,RBX
CALL 0x001384dc
LAB_0018b6a5:
LEA RDI,[RSP + 0x30]
CALL 0x001241f8
LEA RDI,[RSP + 0x50]
CALL 0x001241f8
CMP EBP,0x7fffffff
LEA RDI,[RSP + 0x10]
CALL 0x001241f8
LEA RDI,[RSP + 0xb0]
CALL 0x001241f8
LEA RDI,[RSP + 0x70]
CALL 0x001241f8
LEA RDI,[RSP + 0x90]
LAB_0018b6e8:
CALL 0x001241f8
LAB_0018b6ed:
MOV RAX,RBX
ADD RSP,0xf0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* build_repetition(std::__cxx11::string const&, int, int, std::__cxx11::string const&) */
string * build_repetition(string *param_1,int param_2,int param_3,string *param_4)
{
uint uVar1;
int iVar2;
int4 in_register_00000034;
char *pcVar3;
string *this;
long in_R8;
allocator local_109;
string local_108 [32];
string local_e8 [32];
string local_c8 [32];
string local_a8 [32];
string local_88 [32];
string local_68 [32];
string local_48 [32];
pcVar3 = (char *)CONCAT44(in_register_00000034,param_2);
uVar1 = (uint)param_4;
if (uVar1 == 1 && param_3 == 0) {
LAB_0018b434:
std::operator+(param_1,pcVar3);
}
else {
if (*(long *)(in_R8 + 8) == 0) {
if ((param_3 == 1 && (uVar1 ^ 0x7fffffff) == 0) || ((uVar1 ^ 0x7fffffff) == 0 && param_3 == 0)
) goto LAB_0018b434;
std::operator+(local_88,pcVar3);
/* try { // try from 0018b5f6 to 0018b602 has its CatchHandler @ 0018b75e */
std::__cxx11::to_string((__cxx11 *)local_a8,param_3);
/* try { // try from 0018b603 to 0018b61c has its CatchHandler @ 0018b747 */
std::operator+(local_68,local_88);
/* try { // try from 0018b61d to 0018b635 has its CatchHandler @ 0018b735 */
std::operator+(local_108,(char *)local_68);
if (uVar1 == 0x7fffffff) {
/* try { // try from 0018b664 to 0018b67c has its CatchHandler @ 0018b700 */
std::__cxx11::string::string<std::allocator<char>>(local_c8,"",(allocator *)local_48);
}
else {
/* try { // try from 0018b63e to 0018b649 has its CatchHandler @ 0018b702 */
std::__cxx11::to_string((__cxx11 *)local_c8,uVar1);
}
/* try { // try from 0018b67d to 0018b690 has its CatchHandler @ 0018b716 */
std::operator+(local_e8,local_108);
/* try { // try from 0018b691 to 0018b6a4 has its CatchHandler @ 0018b707 */
std::operator+(param_1,(char *)local_e8);
std::__cxx11::string::~string(local_e8);
std::__cxx11::string::~string(local_c8);
std::__cxx11::string::~string(local_108);
std::__cxx11::string::~string(local_68);
std::__cxx11::string::~string(local_a8);
this = local_88;
}
else {
std::operator+(local_e8,pcVar3);
/* try { // try from 0018b46b to 0018b47e has its CatchHandler @ 0018b7ed */
std::operator+((char *)local_c8,(string *)&DAT_001b8a3a);
/* try { // try from 0018b47f to 0018b494 has its CatchHandler @ 0018b7e8 */
std::operator+(local_a8,(char *)local_c8);
/* try { // try from 0018b495 to 0018b4a9 has its CatchHandler @ 0018b7bf */
std::operator+(local_88,local_a8);
/* try { // try from 0018b4aa to 0018b4c5 has its CatchHandler @ 0018b7ad */
std::operator+(local_68,(char *)local_88);
/* try { // try from 0018b4c6 to 0018b4de has its CatchHandler @ 0018b79b */
std::__cxx11::string::string<std::allocator<char>>(local_48,"",&local_109);
iVar2 = param_3 + -1;
if (param_3 == 0) {
iVar2 = 0;
}
/* try { // try from 0018b4f7 to 0018b512 has its CatchHandler @ 0018b789 */
build_repetition(local_108,(int)local_68,iVar2,
(string *)(ulong)(uVar1 - (uVar1 != 0x7fffffff)));
/* try { // try from 0018b513 to 0018b524 has its CatchHandler @ 0018b77a */
std::operator+(param_1,local_e8);
std::__cxx11::string::~string(local_108);
std::__cxx11::string::~string(local_48);
std::__cxx11::string::~string(local_68);
std::__cxx11::string::~string(local_88);
std::__cxx11::string::~string(local_a8);
std::__cxx11::string::~string(local_c8);
std::__cxx11::string::~string(local_e8);
if (param_3 != 0) {
return param_1;
}
/* try { // try from 0018b57d to 0018b590 has its CatchHandler @ 0018b772 */
std::operator+((char *)local_108,(string *)&DAT_001b8a3a);
/* try { // try from 0018b591 to 0018b5a6 has its CatchHandler @ 0018b763 */
std::operator+(local_e8,(char *)local_108);
std::__cxx11::string::operator=(param_1,local_e8);
std::__cxx11::string::~string(local_e8);
this = local_108;
}
std::__cxx11::string::~string(this);
}
return param_1;
}
| |
24,134 | my_hash_sort_latin1_de | eloqsql/strings/ctype-latin1.c | void my_hash_sort_latin1_de(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
const uchar *end;
register ulong m1= *nr1, m2= *nr2;
/*
Remove end space. We have to do this to be able to compare
'AE' and 'Ä' as identical
*/
end= skip_trailing_space(key, len);
for (; key < end ; key++)
{
uint X= (uint) combo1map[(uint) *key];
MY_HASH_ADD(m1, m2, X);
if ((X= combo2map[*key]))
{
MY_HASH_ADD(m1, m2, X);
}
}
*nr1= m1;
*nr2= m2;
} | O3 | c | my_hash_sort_latin1_de:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
leaq (%rsi,%rdx), %r9
cmpq $0x15, %rdx
jb 0xb3a7b
movq %r9, %rdx
andq $-0x4, %rdx
cmpq %rsi, %rdx
jbe 0xb3a7b
leaq 0x3(%rsi), %rax
andq $-0x4, %rax
movq %r9, %rdi
movb -0x1(%r9), %r10b
cmpq %rdx, %r9
jbe 0xb3b24
leaq -0x1(%rdi), %r9
cmpb $0x20, %r10b
je 0xb3a5f
jmp 0xb3a7e
movq %r9, %rdi
movq (%rcx), %r11
movq (%r8), %rax
cmpq %rsi, %rdi
jbe 0xb3b11
leaq -0x1(%rdi), %rdx
cmpb $0x20, -0x1(%rdi)
movq %rdx, %rdi
je 0xb3a84
incq %rdx
leaq 0x171f2c(%rip), %r9 # 0x2259d0
leaq 0x172025(%rip), %r10 # 0x225ad0
movq %r11, %rdi
movzbl (%rsi), %r14d
movzbl (%r14,%r9), %ebx
movl %r11d, %r15d
andl $0x3f, %r15d
addq %rax, %r15
imulq %rbx, %r15
shlq $0x8, %rdi
addq %r15, %rdi
xorq %r11, %rdi
leaq 0x3(%rax), %rbx
movzbl (%r14,%r10), %r11d
testq %r11, %r11
je 0xb3b01
movl %edi, %r14d
andl $0x3f, %r14d
addq %rbx, %r14
imulq %r11, %r14
movq %rdi, %r11
shlq $0x8, %r11
addq %r14, %r11
xorq %r11, %rdi
addq $0x6, %rax
movq %rax, %rbx
jmp 0xb3b04
movq %rbx, %rax
incq %rsi
movq %rdi, %r11
cmpq %rdx, %rsi
jb 0xb3aae
jmp 0xb3b17
movq %r11, %rdi
movq %rax, %rbx
movq %rdi, (%rcx)
movq %rbx, (%r8)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x20, %r10b
setne %r9b
cmpq %rdx, %rax
setae %dl
orb %r9b, %dl
jne 0xb3a7e
movq %rdi, %rdx
movq %rdx, %rdi
cmpq %rax, %rdx
jbe 0xb3a7e
leaq -0x4(%rdi), %rdx
cmpl $0x20202020, -0x4(%rdi) # imm = 0x20202020
je 0xb3b3e
jmp 0xb3a7e
| my_hash_sort_latin1_de:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
lea r9, [rsi+rdx]
cmp rdx, 15h
jb short loc_B3A7B
mov rdx, r9
and rdx, 0FFFFFFFFFFFFFFFCh
cmp rdx, rsi
jbe short loc_B3A7B
lea rax, [rsi+3]
and rax, 0FFFFFFFFFFFFFFFCh
loc_B3A5F:
mov rdi, r9
mov r10b, [r9-1]
cmp r9, rdx
jbe loc_B3B24
lea r9, [rdi-1]
cmp r10b, 20h ; ' '
jz short loc_B3A5F
jmp short loc_B3A7E
loc_B3A7B:
mov rdi, r9
loc_B3A7E:
mov r11, [rcx]
mov rax, [r8]
loc_B3A84:
cmp rdi, rsi
jbe loc_B3B11
lea rdx, [rdi-1]
cmp byte ptr [rdi-1], 20h ; ' '
mov rdi, rdx
jz short loc_B3A84
inc rdx
lea r9, combo1map
lea r10, combo2map
mov rdi, r11
loc_B3AAE:
movzx r14d, byte ptr [rsi]
movzx ebx, byte ptr [r14+r9]
mov r15d, r11d
and r15d, 3Fh
add r15, rax
imul r15, rbx
shl rdi, 8
add rdi, r15
xor rdi, r11
lea rbx, [rax+3]
movzx r11d, byte ptr [r14+r10]
test r11, r11
jz short loc_B3B01
mov r14d, edi
and r14d, 3Fh
add r14, rbx
imul r14, r11
mov r11, rdi
shl r11, 8
add r11, r14
xor rdi, r11
add rax, 6
mov rbx, rax
jmp short loc_B3B04
loc_B3B01:
mov rax, rbx
loc_B3B04:
inc rsi
mov r11, rdi
cmp rsi, rdx
jb short loc_B3AAE
jmp short loc_B3B17
loc_B3B11:
mov rdi, r11
mov rbx, rax
loc_B3B17:
mov [rcx], rdi
mov [r8], rbx
pop rbx
pop r14
pop r15
pop rbp
retn
loc_B3B24:
cmp r10b, 20h ; ' '
setnz r9b
cmp rax, rdx
setnb dl
or dl, r9b
jnz loc_B3A7E
mov rdx, rdi
loc_B3B3E:
mov rdi, rdx
cmp rdx, rax
jbe loc_B3A7E
lea rdx, [rdi-4]
cmp dword ptr [rdi-4], 20202020h
jz short loc_B3B3E
jmp loc_B3A7E
| long long my_hash_sort_latin1_de(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
long long *a4,
long long *a5)
{
unsigned long long v5; // r9
unsigned long long v6; // rdx
unsigned long long v7; // rax
unsigned long long v8; // rdi
char v9; // r10
long long v10; // r11
long long result; // rax
unsigned long long v12; // rdx
unsigned long long v14; // rdx
long long v15; // rdi
long long v16; // r14
long long v17; // rbx
unsigned long long v18; // rdx
v5 = (unsigned long long)&a2[a3];
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v8 = v5;
}
else
{
v7 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v18 = v5;
do
{
v8 = v18;
if ( v18 <= v7 )
break;
v18 -= 4LL;
}
while ( *(_DWORD *)(v8 - 4) == 538976288 );
}
}
LABEL_8:
v10 = *a4;
result = *a5;
do
{
if ( v8 <= (unsigned long long)a2 )
{
v15 = *a4;
v17 = *a5;
goto LABEL_18;
}
v12 = v8 - 1;
}
while ( *(_BYTE *)--v8 == 32 );
v14 = v12 + 1;
v15 = *a4;
do
{
v16 = *a2;
v15 = v10 ^ (combo1map[v16] * (result + (v10 & 0x3F)) + (v15 << 8));
v17 = result + 3;
if ( combo2map[v16] )
{
v15 ^= combo2map[v16] * (v17 + (v15 & 0x3F)) + (v15 << 8);
result += 6LL;
v17 = result;
}
else
{
result += 3LL;
}
++a2;
v10 = v15;
}
while ( (unsigned long long)a2 < v14 );
LABEL_18:
*a4 = v15;
*a5 = v17;
return result;
}
| my_hash_sort_latin1_de:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
LEA R9,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x001b3a7b
MOV RDX,R9
AND RDX,-0x4
CMP RDX,RSI
JBE 0x001b3a7b
LEA RAX,[RSI + 0x3]
AND RAX,-0x4
LAB_001b3a5f:
MOV RDI,R9
MOV R10B,byte ptr [R9 + -0x1]
CMP R9,RDX
JBE 0x001b3b24
LEA R9,[RDI + -0x1]
CMP R10B,0x20
JZ 0x001b3a5f
JMP 0x001b3a7e
LAB_001b3a7b:
MOV RDI,R9
LAB_001b3a7e:
MOV R11,qword ptr [RCX]
MOV RAX,qword ptr [R8]
LAB_001b3a84:
CMP RDI,RSI
JBE 0x001b3b11
LEA RDX,[RDI + -0x1]
CMP byte ptr [RDI + -0x1],0x20
MOV RDI,RDX
JZ 0x001b3a84
INC RDX
LEA R9,[0x3259d0]
LEA R10,[0x325ad0]
MOV RDI,R11
LAB_001b3aae:
MOVZX R14D,byte ptr [RSI]
MOVZX EBX,byte ptr [R14 + R9*0x1]
MOV R15D,R11D
AND R15D,0x3f
ADD R15,RAX
IMUL R15,RBX
SHL RDI,0x8
ADD RDI,R15
XOR RDI,R11
LEA RBX,[RAX + 0x3]
MOVZX R11D,byte ptr [R14 + R10*0x1]
TEST R11,R11
JZ 0x001b3b01
MOV R14D,EDI
AND R14D,0x3f
ADD R14,RBX
IMUL R14,R11
MOV R11,RDI
SHL R11,0x8
ADD R11,R14
XOR RDI,R11
ADD RAX,0x6
MOV RBX,RAX
JMP 0x001b3b04
LAB_001b3b01:
MOV RAX,RBX
LAB_001b3b04:
INC RSI
MOV R11,RDI
CMP RSI,RDX
JC 0x001b3aae
JMP 0x001b3b17
LAB_001b3b11:
MOV RDI,R11
MOV RBX,RAX
LAB_001b3b17:
MOV qword ptr [RCX],RDI
MOV qword ptr [R8],RBX
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001b3b24:
CMP R10B,0x20
SETNZ R9B
CMP RAX,RDX
SETNC DL
OR DL,R9B
JNZ 0x001b3a7e
MOV RDX,RDI
LAB_001b3b3e:
MOV RDI,RDX
CMP RDX,RAX
JBE 0x001b3a7e
LEA RDX,[RDI + -0x4]
CMP dword ptr [RDI + -0x4],0x20202020
JZ 0x001b3b3e
JMP 0x001b3a7e
|
void my_hash_sort_latin1_de
(int8 param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
long lVar2;
long lVar3;
byte *pbVar4;
byte *pbVar5;
ulong uVar6;
pbVar5 = param_2 + param_3;
if ((0x14 < param_3) && (pbVar4 = (byte *)((ulong)pbVar5 & 0xfffffffffffffffc), param_2 < pbVar4))
{
pbVar1 = pbVar5;
do {
pbVar5 = pbVar1;
if (pbVar5 <= pbVar4) {
pbVar1 = pbVar5;
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar4 && pbVar5[-1] == 0x20)
goto LAB_001b3b3e;
break;
}
pbVar1 = pbVar5 + -1;
} while (pbVar5[-1] == 0x20);
}
goto LAB_001b3a7e;
while (pbVar1 = pbVar5 + -4, *(int *)(pbVar5 + -4) == 0x20202020) {
LAB_001b3b3e:
pbVar5 = pbVar1;
if (pbVar5 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_001b3a7e:
uVar6 = *param_4;
lVar2 = *param_5;
do {
pbVar4 = pbVar5;
lVar3 = lVar2;
if (pbVar4 <= param_2) goto LAB_001b3b17;
pbVar5 = pbVar4 + -1;
} while (pbVar4[-1] == 0x20);
do {
uVar6 = uVar6 * 0x100 + ((ulong)((uint)uVar6 & 0x3f) + lVar2) * (ulong)(byte)combo1map[*param_2]
^ uVar6;
lVar3 = lVar2 + 3;
if ((ulong)(byte)combo2map[*param_2] != 0) {
uVar6 = uVar6 ^ uVar6 * 0x100 +
((ulong)((uint)uVar6 & 0x3f) + lVar3) * (ulong)(byte)combo2map[*param_2];
lVar3 = lVar2 + 6;
}
param_2 = param_2 + 1;
lVar2 = lVar3;
} while (param_2 < pbVar4);
LAB_001b3b17:
*param_4 = uVar6;
*param_5 = lVar3;
return;
}
| |
24,135 | ma_update_block_record | eloqsql/storage/maria/ma_blockrec.c | my_bool _ma_update_block_record(MARIA_HA *info, MARIA_RECORD_POS record_pos,
const uchar *orig_rec, const uchar *new_rec)
{
return _ma_update_block_record2(info, record_pos, orig_rec, new_rec,
LSN_ERROR);
} | O3 | c | ma_update_block_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %r8
movq %rdx, -0x58(%rbp)
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x140(%rdi), %rdx
movq (%rdi), %r15
movl 0x7bc(%r15), %r14d
movl 0xb0(%rdi), %eax
movl 0x170(%rdi), %ecx
movq %rcx, -0x68(%rbp)
movl %eax, 0x170(%rdi)
movq %r8, -0x60(%rbp)
movq %r8, %rsi
movq %rdx, -0x38(%rbp)
callq 0x4da77
movq %r13, %r12
shrq $0x8, %r12
movq %rbx, %rdi
movl $0x1, %esi
callq 0x57115
movq 0x600(%r15), %rdi
leaq 0x470(%rbx), %rsi
movq %r15, -0x78(%rbp)
movl 0x7d4(%r15), %r9d
leaq -0xd8(%rbp), %r15
movq %r12, -0x70(%rbp)
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %r15
pushq $0x4
callq 0x3e012
addq $0x10, %rsp
movq %rax, %r12
movl $0x6, 0x8(%r15)
testq %rax, %rax
setne 0x10(%r15)
leaq 0x2e8(%rbx), %rdi
movq %r15, %rsi
callq 0x94922
testq %r12, %r12
je 0x4e5c7
leaq 0x80(%rbx), %rcx
movzwl 0xa(%r12), %esi
movl %esi, -0x2c(%rbp)
movzbl %r13b, %r13d
addq %r12, %r14
leal (,%r13,4), %eax
subq %rax, %r14
leaq -0x8(%r14), %r15
movzwl -0x6(%r14), %eax
addl %esi, %eax
cmpq %rax, 0x1d0(%rbx)
jbe 0x4e5d8
movq %rsi, -0x50(%rbp)
movq %r15, -0x80(%rbp)
movq %r12, -0x48(%rbp)
movq %rcx, %r12
movq 0xa8(%rbx), %rsi
cmpq $0x0, (%rsi)
je 0x4e4d8
movq %rbx, %rdi
callq 0x4ebbc
testb %al, %al
jne 0x4e626
cmpl $0x0, 0x12c(%rbx)
je 0x4e4f4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4ec23
testb %al, %al
jne 0x4e626
movzwl -0x6(%r14), %r15d
movq -0x50(%rbp), %rax
leal (%r15,%rax), %ecx
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq %r12, %r8
callq 0x567a4
testb %al, %al
jne 0x4e626
cmpl %r15d, 0x1f8(%rbx)
movq -0x50(%rbp), %rcx
ja 0x4e535
movl %r15d, %eax
cmpq %rax, 0x1d0(%rbx)
ja 0x4e563
movq 0x8(%rbx), %rax
movq 0x80(%rax), %r8
movq -0x78(%rbp), %rdi
movl 0x3b8(%rdi), %r9d
movq -0x48(%rbp), %rsi
movl %r13d, %edx
movl $0x1, %ecx
callq 0x4d57c
movzwl -0x6(%r14), %r15d
xorl %ecx, %ecx
leaq -0xa8(%rbp), %rax
movq -0x48(%rbp), %rdx
movq %rdx, (%rax)
movl %r13d, 0x1c(%rax)
addl %r15d, %ecx
movl %ecx, 0x20(%rax)
movq -0x80(%rbp), %rcx
movq %rcx, 0x10(%rax)
movzwl (%rcx), %ecx
addq %rcx, %rdx
movq %rdx, 0x8(%rax)
movl %r15d, 0x18(%rax)
subq $0x8, %rsp
movq %rbx, %rdi
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq %r12, %r8
movl $0x1, %r9d
pushq -0x68(%rbp)
pushq $0x1
pushq %rax
callq 0x526fa
addq $0x20, %rsp
testb %al, %al
jne 0x4e626
xorl %eax, %eax
jmp 0x4e657
callq 0xa8156
movl (%rax), %esi
movq %rbx, %rdi
callq 0x42bb4
jmp 0x4e626
movq %rcx, %r14
movq -0x78(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
callq 0x55caa
movb %al, -0xab(%rbp)
movl 0x1d0(%rbx), %r8d
subq $0x8, %rsp
leaq -0x3c(%rbp), %rax
leaq -0x40(%rbp), %r10
leaq -0x2c(%rbp), %r9
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r13d, %ecx
pushq $0x1
pushq %rax
pushq %r10
callq 0x50aea
addq $0x20, %rsp
testb %al, %al
je 0x4e669
cmpl $0x0, 0x644(%rbx)
je 0x4e63c
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x57115
movq %rbx, %rdi
xorl %esi, %esi
callq 0x42c40
movq 0x8(%rbx), %rax
movq $0x0, 0x90(%rax)
movb $0x1, %al
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, -0xa8(%rbp)
movl %r13d, -0x8c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x88(%rbp)
movq %r15, -0x98(%rbp)
movl -0x40(%rbp), %ecx
addq %rcx, %r12
movq %r12, -0xa0(%rbp)
movl -0x3c(%rbp), %ecx
movl %ecx, -0x90(%rbp)
leaq -0xc0(%rbp), %rcx
movq %rcx, 0x80(%rbx)
movl $0x1, %edx
movl %edx, 0x88(%rbx)
movq -0x70(%rbp), %rsi
movq %rsi, (%rcx)
movl %edx, 0x10(%rcx)
movb $0x3, 0x14(%rcx)
movl %eax, 0xc(%rcx)
movq 0xa8(%rbx), %rsi
cmpq $0x0, (%rsi)
je 0x4e6e4
movq %rbx, %rdi
callq 0x4ebbc
testb %al, %al
jne 0x4e626
cmpl $0x0, 0x12c(%rbx)
je 0x4e700
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ec23
testb %al, %al
jne 0x4e626
subq $0x8, %rsp
leaq -0xa8(%rbp), %rax
movq %rbx, %rdi
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq %r14, %r8
movl $0x1, %r9d
pushq -0x68(%rbp)
pushq $0x1
pushq %rax
callq 0x526fa
addq $0x20, %rsp
andb $-0x3, 0x624(%rbx)
jmp 0x4e657
| _ma_update_block_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov r8, rcx
mov [rbp+var_58], rdx
mov r13, rsi
mov rbx, rdi
lea rdx, [rdi+140h]
mov r15, [rdi]
mov r14d, [r15+7BCh]
mov eax, [rdi+0B0h]
mov ecx, [rdi+170h]
mov [rbp+var_68], rcx
mov [rdi+170h], eax
mov [rbp+var_60], r8
mov rsi, r8
mov [rbp+var_38], rdx
call calc_record_size
mov r12, r13
shr r12, 8
mov rdi, rbx
mov esi, 1
call _ma_bitmap_flushable
mov rdi, [r15+600h]
lea rsi, [rbx+470h]
mov [rbp+var_78], r15
mov r9d, [r15+7D4h]
lea r15, [rbp+var_D8]
mov [rbp+var_70], r12
mov rdx, r12
xor ecx, ecx
xor r8d, r8d
push r15
push 4
call pagecache_read
add rsp, 10h
mov r12, rax
mov dword ptr [r15+8], 6
test rax, rax
setnz byte ptr [r15+10h]
lea rdi, [rbx+2E8h]
mov rsi, r15
call insert_dynamic
test r12, r12
jz loc_4E5C7
lea rcx, [rbx+80h]
movzx esi, word ptr [r12+0Ah]
mov [rbp+var_2C], esi
movzx r13d, r13b
add r14, r12
lea eax, ds:0[r13*4]
sub r14, rax
lea r15, [r14-8]
movzx eax, word ptr [r14-6]
add eax, esi
cmp [rbx+1D0h], rax
jbe loc_4E5D8
mov [rbp+var_50], rsi
mov [rbp+var_80], r15
mov [rbp+var_48], r12
mov r12, rcx
mov rsi, [rbx+0A8h]
cmp qword ptr [rsi], 0
jz short loc_4E4D8
mov rdi, rbx
call delete_tails
test al, al
jnz loc_4E626
loc_4E4D8:
cmp dword ptr [rbx+12Ch], 0
jz short loc_4E4F4
mov rdi, rbx
mov rsi, r12
call free_full_pages
test al, al
jnz loc_4E626
loc_4E4F4:
movzx r15d, word ptr [r14-6]
mov rax, [rbp+var_50]
lea ecx, [r15+rax]
mov rdi, rbx
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_70]
mov r8, r12
call _ma_bitmap_find_new_place
test al, al
jnz loc_4E626
cmp [rbx+1F8h], r15d
mov rcx, [rbp+var_50]
ja short loc_4E535
mov eax, r15d
cmp [rbx+1D0h], rax
ja short loc_4E563
loc_4E535:
mov rax, [rbx+8]
mov r8, [rax+80h]
mov rdi, [rbp+var_78]
mov r9d, [rdi+3B8h]
mov rsi, [rbp+var_48]
mov edx, r13d
mov ecx, 1
call _ma_compact_block_page
movzx r15d, word ptr [r14-6]
xor ecx, ecx
loc_4E563:
lea rax, [rbp+var_A8]
mov rdx, [rbp+var_48]
mov [rax], rdx
mov [rax+1Ch], r13d
add ecx, r15d
mov [rax+20h], ecx
mov rcx, [rbp+var_80]
mov [rax+10h], rcx
movzx ecx, word ptr [rcx]
add rdx, rcx
mov [rax+8], rdx
mov [rax+18h], r15d
sub rsp, 8
mov rdi, rbx
mov rsi, [rbp+var_58]
mov rdx, [rbp+var_60]
mov rcx, [rbp+var_38]
mov r8, r12
mov r9d, 1
push [rbp+var_68]
push 1
push rax
call write_block_record
add rsp, 20h
test al, al
jnz short loc_4E626
xor eax, eax
jmp loc_4E657
loc_4E5C7:
call _my_thread_var
mov esi, [rax]
mov rdi, rbx
call _ma_set_fatal_error
jmp short loc_4E626
loc_4E5D8:
mov r14, rcx
mov rdi, [rbp+var_78]
add rdi, 0A10h
call _ma_free_size_to_head_pattern
mov [rbp+var_AB], al
mov r8d, [rbx+1D0h]
sub rsp, 8
lea rax, [rbp+var_3C]
lea r10, [rbp+var_40]
lea r9, [rbp+var_2C]
mov rdi, rbx
mov rsi, r12
mov rdx, r15
mov ecx, r13d
push 1
push rax
push r10
call extend_area_on_page
add rsp, 20h
test al, al
jz short loc_4E669
loc_4E626:
cmp dword ptr [rbx+644h], 0
jz short loc_4E63C
mov rdi, rbx
mov esi, 0FFFFFFFFh
call _ma_bitmap_flushable
loc_4E63C:
mov rdi, rbx
xor esi, esi
call _ma_unpin_all_pages
mov rax, [rbx+8]
mov qword ptr [rax+90h], 0
mov al, 1
loc_4E657:
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4E669:
mov [rbp+var_A8], r12
mov [rbp+var_8C], r13d
mov eax, [rbp+var_2C]
mov [rbp+var_88], eax
mov [rbp+var_98], r15
mov ecx, [rbp+var_40]
add r12, rcx
mov [rbp+var_A0], r12
mov ecx, [rbp+var_3C]
mov [rbp+var_90], ecx
lea rcx, [rbp+var_C0]
mov [rbx+80h], rcx
mov edx, 1
mov [rbx+88h], edx
mov rsi, [rbp+var_70]
mov [rcx], rsi
mov [rcx+10h], edx
mov byte ptr [rcx+14h], 3
mov [rcx+0Ch], eax
mov rsi, [rbx+0A8h]
cmp qword ptr [rsi], 0
jz short loc_4E6E4
mov rdi, rbx
call delete_tails
test al, al
jnz loc_4E626
loc_4E6E4:
cmp dword ptr [rbx+12Ch], 0
jz short loc_4E700
mov rdi, rbx
mov rsi, r14
call free_full_pages
test al, al
jnz loc_4E626
loc_4E700:
sub rsp, 8
lea rax, [rbp+var_A8]
mov rdi, rbx
mov rsi, [rbp+var_58]
mov rdx, [rbp+var_60]
mov rcx, [rbp+var_38]
mov r8, r14
mov r9d, 1
push [rbp+var_68]
push 1
push rax
call write_block_record
add rsp, 20h
and byte ptr [rbx+624h], 0FDh
jmp loc_4E657
| char ma_update_block_record(long long *a1, unsigned long long a2, long long a3, long long a4)
{
unsigned __int8 v4; // r13
long long v6; // r15
long long v7; // r14
int v8; // eax
long long v9; // rdi
int v10; // r9d
long long v11; // r12
long long v12; // rsi
long long v13; // r14
unsigned __int16 *v14; // r15
_DWORD *v15; // r12
unsigned int v16; // r15d
int v17; // ecx
char result; // al
int *v19; // rax
long long v20; // rdx
long long v21; // rcx
long long v22; // r8
int v23; // r9d
_DWORD *v24; // r14
int v25; // eax
long long v26; // [rsp+8h] [rbp-D8h] BYREF
int v27; // [rsp+10h] [rbp-D0h]
bool v28; // [rsp+18h] [rbp-C8h]
unsigned long long v29; // [rsp+20h] [rbp-C0h] BYREF
int v30; // [rsp+2Ch] [rbp-B4h]
int v31; // [rsp+30h] [rbp-B0h]
char v32; // [rsp+34h] [rbp-ACh]
char v33; // [rsp+35h] [rbp-ABh]
long long v34; // [rsp+38h] [rbp-A8h] BYREF
long long v35; // [rsp+40h] [rbp-A0h]
unsigned __int16 *v36; // [rsp+48h] [rbp-98h]
unsigned int v37; // [rsp+50h] [rbp-90h]
int v38; // [rsp+54h] [rbp-8Ch]
int v39; // [rsp+58h] [rbp-88h]
unsigned __int16 *v40; // [rsp+60h] [rbp-80h]
long long v41; // [rsp+68h] [rbp-78h]
unsigned long long v42; // [rsp+70h] [rbp-70h]
long long v43; // [rsp+78h] [rbp-68h]
long long v44; // [rsp+80h] [rbp-60h]
long long v45; // [rsp+88h] [rbp-58h]
long long v46; // [rsp+90h] [rbp-50h]
long long v47; // [rsp+98h] [rbp-48h]
unsigned int v48; // [rsp+A0h] [rbp-40h] BYREF
unsigned int v49; // [rsp+A4h] [rbp-3Ch] BYREF
_DWORD *v50; // [rsp+A8h] [rbp-38h]
int v51; // [rsp+B4h] [rbp-2Ch] BYREF
v45 = a3;
v4 = a2;
v6 = *a1;
v7 = *(unsigned int *)(*a1 + 1980);
v8 = *((_DWORD *)a1 + 44);
v43 = *((unsigned int *)a1 + 92);
*((_DWORD *)a1 + 92) = v8;
v44 = a4;
v50 = a1 + 40;
calc_record_size(a1, a4, (long long)(a1 + 40));
ma_bitmap_flushable(a1, 1LL);
v9 = *(_QWORD *)(v6 + 1536);
v41 = v6;
v10 = *(_DWORD *)(v6 + 2004);
v42 = a2 >> 8;
v11 = pagecache_read(v9, (long long)(a1 + 142), a2 >> 8, 0, 0LL, v10, 4u, &v26);
v27 = 6;
v28 = v11 != 0;
insert_dynamic(a1 + 93, &v26);
if ( v11 )
{
v12 = *(unsigned __int16 *)(v11 + 10);
v51 = v12;
v13 = v11 + v7 - 4 * (unsigned int)v4;
v14 = (unsigned __int16 *)(v13 - 8);
if ( a1[58] <= (unsigned long long)((unsigned int)v12 + *(unsigned __int16 *)(v13 - 6)) )
{
v24 = a1 + 16;
v33 = ma_free_size_to_head_pattern(v41 + 2576);
if ( !(unsigned __int8)extend_area_on_page(
(_DWORD)a1,
v11,
(_DWORD)v14,
v4,
*((_DWORD *)a1 + 116),
(unsigned int)&v51,
(long long)&v48,
(long long)&v49,
1) )
{
v34 = v11;
v38 = v4;
v25 = v51;
v39 = v51;
v36 = v14;
v35 = v48 + v11;
v37 = v49;
a1[16] = (long long)&v29;
*((_DWORD *)a1 + 34) = 1;
v29 = v42;
v31 = 1;
v32 = 3;
v30 = v25;
if ( (!*(_QWORD *)a1[21] || !(unsigned __int8)delete_tails(a1))
&& (!*((_DWORD *)a1 + 75) || !(unsigned __int8)free_full_pages(a1, v24)) )
{
result = write_block_record((_DWORD)a1, v45, v44, (_DWORD)v50, (_DWORD)v24, 1, (long long)&v34, 1LL, v43);
*((_BYTE *)a1 + 1572) &= ~2u;
return result;
}
}
}
else
{
v46 = v12;
v40 = (unsigned __int16 *)(v13 - 8);
v47 = v11;
v15 = a1 + 16;
if ( (!*(_QWORD *)a1[21] || !(unsigned __int8)delete_tails(a1))
&& (!*((_DWORD *)a1 + 75) || !(unsigned __int8)free_full_pages(a1, v15)) )
{
v16 = *(unsigned __int16 *)(v13 - 6);
if ( !(unsigned __int8)ma_bitmap_find_new_place(a1, v50, v42, v16 + (unsigned int)v46, v15) )
{
v17 = v46;
if ( *((_DWORD *)a1 + 126) > v16 || a1[58] <= (unsigned long long)v16 )
{
ma_compact_block_page(v41, v47, v4, 1, *(_QWORD *)(a1[1] + 128), *(_DWORD *)(v41 + 952));
v16 = *(unsigned __int16 *)(v13 - 6);
v17 = 0;
}
v34 = v47;
v38 = v4;
v39 = v16 + v17;
v36 = v40;
v35 = *v40 + v47;
v37 = v16;
if ( !(unsigned __int8)write_block_record(
(_DWORD)a1,
v45,
v44,
(_DWORD)v50,
(_DWORD)v15,
1,
(long long)&v34,
1LL,
v43) )
return 0;
}
}
}
}
else
{
v19 = (int *)my_thread_var(a1 + 93);
ma_set_fatal_error(a1, *v19, v20, v21, v22, v23);
}
if ( *((_DWORD *)a1 + 401) )
ma_bitmap_flushable(a1, 0xFFFFFFFFLL);
ma_unpin_all_pages((long long)a1, 0LL);
*(_QWORD *)(a1[1] + 144) = 0LL;
return 1;
}
| _ma_update_block_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV R8,RCX
MOV qword ptr [RBP + -0x58],RDX
MOV R13,RSI
MOV RBX,RDI
LEA RDX,[RDI + 0x140]
MOV R15,qword ptr [RDI]
MOV R14D,dword ptr [R15 + 0x7bc]
MOV EAX,dword ptr [RDI + 0xb0]
MOV ECX,dword ptr [RDI + 0x170]
MOV qword ptr [RBP + -0x68],RCX
MOV dword ptr [RDI + 0x170],EAX
MOV qword ptr [RBP + -0x60],R8
MOV RSI,R8
MOV qword ptr [RBP + -0x38],RDX
CALL 0x0014da77
MOV R12,R13
SHR R12,0x8
MOV RDI,RBX
MOV ESI,0x1
CALL 0x00157115
MOV RDI,qword ptr [R15 + 0x600]
LEA RSI,[RBX + 0x470]
MOV qword ptr [RBP + -0x78],R15
MOV R9D,dword ptr [R15 + 0x7d4]
LEA R15,[RBP + -0xd8]
MOV qword ptr [RBP + -0x70],R12
MOV RDX,R12
XOR ECX,ECX
XOR R8D,R8D
PUSH R15
PUSH 0x4
CALL 0x0013e012
ADD RSP,0x10
MOV R12,RAX
MOV dword ptr [R15 + 0x8],0x6
TEST RAX,RAX
SETNZ byte ptr [R15 + 0x10]
LEA RDI,[RBX + 0x2e8]
MOV RSI,R15
CALL 0x00194922
TEST R12,R12
JZ 0x0014e5c7
LEA RCX,[RBX + 0x80]
MOVZX ESI,word ptr [R12 + 0xa]
MOV dword ptr [RBP + -0x2c],ESI
MOVZX R13D,R13B
ADD R14,R12
LEA EAX,[R13*0x4]
SUB R14,RAX
LEA R15,[R14 + -0x8]
MOVZX EAX,word ptr [R14 + -0x6]
ADD EAX,ESI
CMP qword ptr [RBX + 0x1d0],RAX
JBE 0x0014e5d8
MOV qword ptr [RBP + -0x50],RSI
MOV qword ptr [RBP + -0x80],R15
MOV qword ptr [RBP + -0x48],R12
MOV R12,RCX
MOV RSI,qword ptr [RBX + 0xa8]
CMP qword ptr [RSI],0x0
JZ 0x0014e4d8
MOV RDI,RBX
CALL 0x0014ebbc
TEST AL,AL
JNZ 0x0014e626
LAB_0014e4d8:
CMP dword ptr [RBX + 0x12c],0x0
JZ 0x0014e4f4
MOV RDI,RBX
MOV RSI,R12
CALL 0x0014ec23
TEST AL,AL
JNZ 0x0014e626
LAB_0014e4f4:
MOVZX R15D,word ptr [R14 + -0x6]
MOV RAX,qword ptr [RBP + -0x50]
LEA ECX,[R15 + RAX*0x1]
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x70]
MOV R8,R12
CALL 0x001567a4
TEST AL,AL
JNZ 0x0014e626
CMP dword ptr [RBX + 0x1f8],R15D
MOV RCX,qword ptr [RBP + -0x50]
JA 0x0014e535
MOV EAX,R15D
CMP qword ptr [RBX + 0x1d0],RAX
JA 0x0014e563
LAB_0014e535:
MOV RAX,qword ptr [RBX + 0x8]
MOV R8,qword ptr [RAX + 0x80]
MOV RDI,qword ptr [RBP + -0x78]
MOV R9D,dword ptr [RDI + 0x3b8]
MOV RSI,qword ptr [RBP + -0x48]
MOV EDX,R13D
MOV ECX,0x1
CALL 0x0014d57c
MOVZX R15D,word ptr [R14 + -0x6]
XOR ECX,ECX
LAB_0014e563:
LEA RAX,[RBP + -0xa8]
MOV RDX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX],RDX
MOV dword ptr [RAX + 0x1c],R13D
ADD ECX,R15D
MOV dword ptr [RAX + 0x20],ECX
MOV RCX,qword ptr [RBP + -0x80]
MOV qword ptr [RAX + 0x10],RCX
MOVZX ECX,word ptr [RCX]
ADD RDX,RCX
MOV qword ptr [RAX + 0x8],RDX
MOV dword ptr [RAX + 0x18],R15D
SUB RSP,0x8
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x38]
MOV R8,R12
MOV R9D,0x1
PUSH qword ptr [RBP + -0x68]
PUSH 0x1
PUSH RAX
CALL 0x001526fa
ADD RSP,0x20
TEST AL,AL
JNZ 0x0014e626
XOR EAX,EAX
JMP 0x0014e657
LAB_0014e5c7:
CALL 0x001a8156
MOV ESI,dword ptr [RAX]
MOV RDI,RBX
CALL 0x00142bb4
JMP 0x0014e626
LAB_0014e5d8:
MOV R14,RCX
MOV RDI,qword ptr [RBP + -0x78]
ADD RDI,0xa10
CALL 0x00155caa
MOV byte ptr [RBP + -0xab],AL
MOV R8D,dword ptr [RBX + 0x1d0]
SUB RSP,0x8
LEA RAX,[RBP + -0x3c]
LEA R10,[RBP + -0x40]
LEA R9,[RBP + -0x2c]
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
MOV ECX,R13D
PUSH 0x1
PUSH RAX
PUSH R10
CALL 0x00150aea
ADD RSP,0x20
TEST AL,AL
JZ 0x0014e669
LAB_0014e626:
CMP dword ptr [RBX + 0x644],0x0
JZ 0x0014e63c
MOV RDI,RBX
MOV ESI,0xffffffff
CALL 0x00157115
LAB_0014e63c:
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00142c40
MOV RAX,qword ptr [RBX + 0x8]
MOV qword ptr [RAX + 0x90],0x0
MOV AL,0x1
LAB_0014e657:
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014e669:
MOV qword ptr [RBP + -0xa8],R12
MOV dword ptr [RBP + -0x8c],R13D
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x88],EAX
MOV qword ptr [RBP + -0x98],R15
MOV ECX,dword ptr [RBP + -0x40]
ADD R12,RCX
MOV qword ptr [RBP + -0xa0],R12
MOV ECX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x90],ECX
LEA RCX,[RBP + -0xc0]
MOV qword ptr [RBX + 0x80],RCX
MOV EDX,0x1
MOV dword ptr [RBX + 0x88],EDX
MOV RSI,qword ptr [RBP + -0x70]
MOV qword ptr [RCX],RSI
MOV dword ptr [RCX + 0x10],EDX
MOV byte ptr [RCX + 0x14],0x3
MOV dword ptr [RCX + 0xc],EAX
MOV RSI,qword ptr [RBX + 0xa8]
CMP qword ptr [RSI],0x0
JZ 0x0014e6e4
MOV RDI,RBX
CALL 0x0014ebbc
TEST AL,AL
JNZ 0x0014e626
LAB_0014e6e4:
CMP dword ptr [RBX + 0x12c],0x0
JZ 0x0014e700
MOV RDI,RBX
MOV RSI,R14
CALL 0x0014ec23
TEST AL,AL
JNZ 0x0014e626
LAB_0014e700:
SUB RSP,0x8
LEA RAX,[RBP + -0xa8]
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x38]
MOV R8,R14
MOV R9D,0x1
PUSH qword ptr [RBP + -0x68]
PUSH 0x1
PUSH RAX
CALL 0x001526fa
ADD RSP,0x20
AND byte ptr [RBX + 0x624],0xfd
JMP 0x0014e657
|
int8
_ma_update_block_record(long *param_1,ulong param_2,int8 param_3,int8 param_4)
{
ushort *puVar1;
long *plVar2;
ushort uVar3;
uint uVar4;
int iVar5;
char cVar6;
long lVar7;
int4 *puVar8;
int8 uVar9;
int iVar10;
long lVar11;
int1 local_e0 [8];
int4 local_d8;
int1 local_d0;
ulong local_c8;
uint local_bc;
int4 local_b8;
int1 local_b4;
int1 local_b3;
long local_b0;
long local_a8;
ushort *local_a0;
uint local_98;
int local_94;
uint local_90;
ushort *local_88;
long local_80;
ulong local_78;
ulong local_70;
int8 local_68;
int8 local_60;
ulong local_58;
long local_50;
uint local_48;
uint local_44;
long *local_40;
uint local_34;
local_40 = param_1 + 0x28;
lVar7 = *param_1;
uVar4 = *(uint *)(lVar7 + 0x7bc);
local_70 = (ulong)*(uint *)(param_1 + 0x2e);
*(int *)(param_1 + 0x2e) = (int)param_1[0x16];
local_68 = param_4;
local_60 = param_3;
calc_record_size(param_1,param_4);
_ma_bitmap_flushable(param_1,1);
local_80 = lVar7;
local_78 = param_2 >> 8;
lVar7 = pagecache_read(*(int8 *)(lVar7 + 0x600),param_1 + 0x8e,param_2 >> 8,0,0,
*(int4 *)(lVar7 + 0x7d4),4,local_e0);
local_d8 = 6;
local_d0 = lVar7 != 0;
insert_dynamic(param_1 + 0x5d,local_e0);
if (lVar7 == 0) {
puVar8 = (int4 *)_my_thread_var();
_ma_set_fatal_error(param_1,*puVar8);
}
else {
plVar2 = param_1 + 0x10;
uVar3 = *(ushort *)(lVar7 + 10);
local_34 = (uint)uVar3;
param_2 = param_2 & 0xff;
iVar5 = (int)param_2;
lVar11 = ((ulong)uVar4 + lVar7) - (ulong)(uint)(iVar5 * 4);
puVar1 = (ushort *)(lVar11 + -8);
if ((ulong)(*(ushort *)(lVar11 + -6) + local_34) < (ulong)param_1[0x3a]) {
local_88 = puVar1;
local_58 = (ulong)uVar3;
local_50 = lVar7;
if (((*(long *)param_1[0x15] == 0) || (cVar6 = delete_tails(param_1), cVar6 == '\0')) &&
((*(int *)((long)param_1 + 300) == 0 ||
(cVar6 = free_full_pages(param_1,plVar2), cVar6 == '\0')))) {
uVar3 = *(ushort *)(lVar11 + -6);
cVar6 = _ma_bitmap_find_new_place
(param_1,local_40,local_78,(uint)uVar3 + (int)local_58,plVar2);
if (cVar6 == '\0') {
iVar10 = (int)local_58;
if (((uint)uVar3 < *(uint *)(param_1 + 0x3f)) || ((ulong)param_1[0x3a] <= (ulong)uVar3)) {
_ma_compact_block_page
(local_80,local_50,param_2,1,*(int8 *)(param_1[1] + 0x80),
*(int4 *)(local_80 + 0x3b8));
uVar3 = *(ushort *)(lVar11 + -6);
iVar10 = 0;
}
local_98 = (uint)uVar3;
local_b0 = local_50;
local_90 = iVar10 + local_98;
local_a0 = local_88;
local_a8 = local_50 + (ulong)*local_88;
local_94 = iVar5;
cVar6 = write_block_record(param_1,local_60,local_68,local_40,plVar2,1,&local_b0,1,
local_70);
if (cVar6 == '\0') {
return 0;
}
}
}
}
else {
local_b3 = _ma_free_size_to_head_pattern(local_80 + 0xa10);
cVar6 = extend_area_on_page(param_1,lVar7,puVar1,param_2,(int)param_1[0x3a],&local_34,
&local_48,&local_44,1);
if (cVar6 == '\0') {
local_90 = local_34;
local_a8 = lVar7 + (ulong)local_48;
local_98 = local_44;
param_1[0x10] = (long)&local_c8;
*(int4 *)(param_1 + 0x11) = 1;
local_c8 = local_78;
local_b8 = 1;
local_b4 = 3;
local_bc = local_34;
local_b0 = lVar7;
local_a0 = puVar1;
local_94 = iVar5;
if (((*(long *)param_1[0x15] == 0) || (cVar6 = delete_tails(param_1), cVar6 == '\0')) &&
((*(int *)((long)param_1 + 300) == 0 ||
(cVar6 = free_full_pages(param_1,plVar2), cVar6 == '\0')))) {
uVar9 = write_block_record(param_1,local_60,local_68,local_40,plVar2,1,&local_b0,1,
local_70);
*(byte *)((long)param_1 + 0x624) = *(byte *)((long)param_1 + 0x624) & 0xfd;
return uVar9;
}
}
}
}
if (*(int *)((long)param_1 + 0x644) != 0) {
_ma_bitmap_flushable(param_1,0xffffffff);
}
_ma_unpin_all_pages(param_1,0);
lVar7 = param_1[1];
*(int8 *)(lVar7 + 0x90) = 0;
return CONCAT71((int7)((ulong)lVar7 >> 8),1);
}
| |
24,136 | void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double) | monkey531[P]llama/common/json.hpp | JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{
static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
"internal error: not enough precision");
JSON_ASSERT(std::isfinite(value));
JSON_ASSERT(value > 0);
// If the neighbors (and boundaries) of 'value' are always computed for double-precision
// numbers, all float's can be recovered using strtod (and strtof). However, the resulting
// decimal representations are not exactly "short".
//
// The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
// says "value is converted to a string as if by std::sprintf in the default ("C") locale"
// and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
// does.
// On the other hand, the documentation for 'std::to_chars' requires that "parsing the
// representation using the corresponding std::from_chars function recovers value exactly". That
// indicates that single precision floating-point numbers should be recovered using
// 'std::strtof'.
//
// NB: If the neighbors are computed for single-precision numbers, there is a single float
// (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
// value is off by 1 ulp.
#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
const boundaries w = compute_boundaries(static_cast<double>(value));
#else
const boundaries w = compute_boundaries(value);
#endif
grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
} | O2 | cpp | void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0x93639
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x93655
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x9380f
movq 0x10(%r12), %rcx
movl 0x18(%r12), %r8d
movups (%r12), %xmm0
movups 0x20(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x93957
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x28917(%rip), %rdi # 0xbbf57
leaq 0x224a9(%rip), %rdx # 0xb5af0
leaq 0x2df51(%rip), %rcx # 0xc159f
movl $0x4589, %esi # imm = 0x4589
jmp 0x9366f
leaq 0x288fb(%rip), %rdi # 0xbbf57
leaq 0x2248d(%rip), %rdx # 0xb5af0
leaq 0x2e04e(%rip), %rcx # 0xc16b8
movl $0x458a, %esi # imm = 0x458A
xorl %eax, %eax
callq 0x24f20
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl6grisu2IdEEvPcRiS5_T_:
push r15
push r14
push r12
push rbx
sub rsp, 58h
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FF0000000000000h
cmp rax, rcx
jge short loc_93639
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jbe short loc_93655
mov rbx, rdx
mov r14, rsi
mov r15, rdi
lea r12, [rsp+78h+var_50]
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl18compute_boundariesIdEENS2_10boundariesET_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double)
mov rcx, [r12+10h]
mov r8d, [r12+18h]
movups xmm0, xmmword ptr [r12]
movups xmm1, xmmword ptr [r12+20h]
movups [rsp+78h+var_68], xmm1
movups [rsp+78h+var_78], xmm0
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl6grisu2EPcRiS4_NS2_5diyfpES5_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char *,int &,int &,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
add rsp, 58h
pop rbx
pop r12
pop r14
pop r15
retn
loc_93639:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aStdIsfiniteVal; "std::isfinite(value)"
mov esi, 4589h
jmp short loc_9366F
loc_93655:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aValue0; "value > 0"
mov esi, 458Ah
loc_9366F:
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(
long long a1,
long long a2,
long long a3,
double a4)
{
long long v5; // r9
char *v7; // rsi
int v8; // edx
int v9; // ecx
int v10; // r8d
int v11; // r9d
_QWORD v12[3]; // [rsp+28h] [rbp-50h] BYREF
unsigned int v13; // [rsp+40h] [rbp-38h]
long long v14; // [rsp+48h] [rbp-30h]
long long v15; // [rsp+50h] [rbp-28h]
if ( (*(_QWORD *)&a4 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
{
v7 = (_BYTE *)(&stru_4578 + 17);
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17801LL,
"GGML_ASSERT(%s) failed",
"std::isfinite(value)");
}
else
{
if ( a4 > 0.0 )
{
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(v12);
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
a1,
a2,
a3,
v12[2],
v13,
v5,
v12[0],
v12[1],
v14,
v15);
}
v7 = (_BYTE *)(&stru_4578 + 18);
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17802LL,
"GGML_ASSERT(%s) failed",
"value > 0");
}
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v7,
v8,
v9,
v10,
v11);
}
| grisu2<double>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOVQ RAX,XMM0
BTR RAX,0x3f
MOV RCX,0x7ff0000000000000
CMP RAX,RCX
JGE 0x00193639
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JBE 0x00193655
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
LEA R12,[RSP + 0x28]
MOV RDI,R12
CALL 0x0019380f
MOV RCX,qword ptr [R12 + 0x10]
MOV R8D,dword ptr [R12 + 0x18]
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS XMM1,xmmword ptr [R12 + 0x20]
MOVUPS xmmword ptr [RSP + 0x10],XMM1
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00193957
ADD RSP,0x58
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00193639:
LEA RDI,[0x1bbf57]
LEA RDX,[0x1b5af0]
LEA RCX,[0x1c159f]
MOV ESI,0x4589
JMP 0x0019366f
LAB_00193655:
LEA RDI,[0x1bbf57]
LEA RDX,[0x1b5af0]
LEA RCX,[0x1c16b8]
MOV ESI,0x458a
LAB_0019366f:
XOR EAX,EAX
CALL 0x00124f20
|
/* void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>
(char *param_1,int *param_2,int *param_3,double param_4)
{
char *pcVar1;
int8 uVar2;
int8 in_R9;
int4 local_50 [2];
int4 uStack_48;
int8 local_40;
int4 local_38;
int4 local_30;
int4 uStack_28;
if ((ulong)ABS(param_4) < 0x7ff0000000000000) {
if (0.0 < param_4) {
compute_boundaries<double>((dtoa_impl *)local_50,param_4);
grisu2(param_1,param_2,param_3,local_40,local_38,in_R9,local_50[0],uStack_48,local_30,
uStack_28);
return;
}
pcVar1 = "value > 0";
uVar2 = 0x458a;
}
else {
pcVar1 = "std::isfinite(value)";
uVar2 = 0x4589;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar2,
"GGML_ASSERT(%s) failed",pcVar1);
}
| |
24,137 | resize_partitioned_key_cache | eloqsql/mysys/mf_keycache.c | static
int resize_partitioned_key_cache(PARTITIONED_KEY_CACHE_CB *keycache,
uint key_cache_block_size,
size_t use_mem, uint division_limit,
uint age_threshold,
uint changed_blocks_hash_size)
{
uint i;
uint partitions= keycache->partitions;
my_bool cleanup= use_mem == 0;
int blocks= -1;
int err= 0;
DBUG_ENTER("partitioned_resize_key_cache");
if (cleanup)
{
end_partitioned_key_cache(keycache, 0);
DBUG_RETURN(-1);
}
for (i= 0; i < partitions; i++)
{
err|= prepare_resize_simple_key_cache(keycache->partition_array[i], 1);
}
if (!err)
blocks= init_partitioned_key_cache(keycache, key_cache_block_size,
use_mem, division_limit, age_threshold,
changed_blocks_hash_size);
if (blocks > 0)
{
for (i= 0; i < partitions; i++)
{
keycache_pthread_mutex_lock(&keycache->partition_array[i]->cache_lock);
finish_resize_simple_key_cache(keycache->partition_array[i]);
}
}
DBUG_RETURN(blocks);
} | O0 | c | resize_partitioned_key_cache:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x20(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x35(%rbp)
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x40(%rbp)
cmpb $0x0, -0x35(%rbp)
je 0x75ae3
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x76070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x75ba5
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x34(%rbp), %eax
jae 0x75b1c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x30(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movl $0x1, %esi
callq 0x74900
orl -0x40(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x75aea
cmpl $0x0, -0x40(%rbp)
jne 0x75b40
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x2c(%rbp), %r9d
callq 0x757b0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jle 0x75b9d
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x34(%rbp), %eax
jae 0x75b9b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x30(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
addq $0xc0, %rdi
leaq 0x6408d(%rip), %rsi # 0xd9bff
movl $0x14a9, %edx # imm = 0x14A9
callq 0x71150
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x30(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x74a20
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x75b4d
jmp 0x75b9d
jmp 0x75b9f
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
| resize_partitioned_key_cache:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_28], r8d
mov [rbp+var_2C], r9d
mov rax, [rbp+var_10]
mov eax, [rax+1Ch]
mov [rbp+var_34], eax
cmp [rbp+var_20], 0
setz al
and al, 1
movzx eax, al
mov [rbp+var_35], al
mov [rbp+var_3C], 0FFFFFFFFh
mov [rbp+var_40], 0
cmp [rbp+var_35], 0
jz short loc_75AE3
mov rdi, [rbp+var_10]
xor esi, esi
call end_partitioned_key_cache
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_75BA5
loc_75AE3:
mov [rbp+var_30], 0
loc_75AEA:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_34]
jnb short loc_75B1C
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov ecx, [rbp+var_30]
mov rdi, [rax+rcx*8]
mov esi, 1
call prepare_resize_simple_key_cache
or eax, [rbp+var_40]
mov [rbp+var_40], eax
mov eax, [rbp+var_30]
add eax, 1
mov [rbp+var_30], eax
jmp short loc_75AEA
loc_75B1C:
cmp [rbp+var_40], 0
jnz short loc_75B40
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_24]
mov r8d, [rbp+var_28]
mov r9d, [rbp+var_2C]
call init_partitioned_key_cache
mov [rbp+var_3C], eax
loc_75B40:
cmp [rbp+var_3C], 0
jle short loc_75B9D
mov [rbp+var_30], 0
loc_75B4D:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_34]
jnb short loc_75B9B
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov ecx, [rbp+var_30]
mov rdi, [rax+rcx*8]
add rdi, 0C0h
lea rsi, aWorkspaceLlm4b_19; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 14A9h
call inline_mysql_mutex_lock_9
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov ecx, [rbp+var_30]
mov rdi, [rax+rcx*8]
call finish_resize_simple_key_cache
mov eax, [rbp+var_30]
add eax, 1
mov [rbp+var_30], eax
jmp short loc_75B4D
loc_75B9B:
jmp short $+2
loc_75B9D:
jmp short $+2
loc_75B9F:
mov eax, [rbp+var_3C]
mov [rbp+var_4], eax
loc_75BA5:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long resize_partitioned_key_cache(
long long a1,
unsigned int a2,
unsigned long long a3,
unsigned int a4,
unsigned int a5,
unsigned int a6)
{
int v7; // [rsp+0h] [rbp-40h]
int inited; // [rsp+4h] [rbp-3Ch]
unsigned int v9; // [rsp+Ch] [rbp-34h]
unsigned int i; // [rsp+10h] [rbp-30h]
unsigned int j; // [rsp+10h] [rbp-30h]
v9 = *(_DWORD *)(a1 + 28);
inited = -1;
v7 = 0;
if ( a3 )
{
for ( i = 0; i < v9; ++i )
v7 |= prepare_resize_simple_key_cache(*(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL * i), 1);
if ( !v7 )
inited = init_partitioned_key_cache((char *)a1, a2, a3, a4, a5, a6);
if ( inited > 0 )
{
for ( j = 0; j < v9; ++j )
{
inline_mysql_mutex_lock_9(
*(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL * j) + 192LL,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0x14A9u);
finish_resize_simple_key_cache(*(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL * j));
}
}
return (unsigned int)inited;
}
else
{
end_partitioned_key_cache(a1, 0LL);
return (unsigned int)-1;
}
}
| resize_partitioned_key_cache:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x28],R8D
MOV dword ptr [RBP + -0x2c],R9D
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBP + -0x34],EAX
CMP qword ptr [RBP + -0x20],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x35],AL
MOV dword ptr [RBP + -0x3c],0xffffffff
MOV dword ptr [RBP + -0x40],0x0
CMP byte ptr [RBP + -0x35],0x0
JZ 0x00175ae3
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x00176070
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00175ba5
LAB_00175ae3:
MOV dword ptr [RBP + -0x30],0x0
LAB_00175aea:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x34]
JNC 0x00175b1c
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV ESI,0x1
CALL 0x00174900
OR EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x40],EAX
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175aea
LAB_00175b1c:
CMP dword ptr [RBP + -0x40],0x0
JNZ 0x00175b40
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8D,dword ptr [RBP + -0x28]
MOV R9D,dword ptr [RBP + -0x2c]
CALL 0x001757b0
MOV dword ptr [RBP + -0x3c],EAX
LAB_00175b40:
CMP dword ptr [RBP + -0x3c],0x0
JLE 0x00175b9d
MOV dword ptr [RBP + -0x30],0x0
LAB_00175b4d:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x34]
JNC 0x00175b9b
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + RCX*0x8]
ADD RDI,0xc0
LEA RSI,[0x1d9bff]
MOV EDX,0x14a9
CALL 0x00171150
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + RCX*0x8]
CALL 0x00174a20
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00175b4d
LAB_00175b9b:
JMP 0x00175b9d
LAB_00175b9d:
JMP 0x00175b9f
LAB_00175b9f:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4],EAX
LAB_00175ba5:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int resize_partitioned_key_cache
(long param_1,int4 param_2,long param_3,int4 param_4,int4 param_5,
int4 param_6)
{
uint uVar1;
uint uVar2;
uint local_48;
int local_44;
uint local_38;
int local_c;
uVar1 = *(uint *)(param_1 + 0x1c);
local_44 = -1;
local_48 = 0;
if (param_3 == 0) {
end_partitioned_key_cache(param_1,0);
local_c = -1;
}
else {
for (local_38 = 0; local_38 < uVar1; local_38 = local_38 + 1) {
uVar2 = prepare_resize_simple_key_cache
(*(int8 *)(*(long *)(param_1 + 8) + (ulong)local_38 * 8),1);
local_48 = uVar2 | local_48;
}
if (local_48 == 0) {
local_44 = init_partitioned_key_cache(param_1,param_2,param_3,param_4,param_5,param_6);
}
if (0 < local_44) {
for (local_38 = 0; local_38 < uVar1; local_38 = local_38 + 1) {
inline_mysql_mutex_lock
(*(long *)(*(long *)(param_1 + 8) + (ulong)local_38 * 8) + 0xc0,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0x14a9);
finish_resize_simple_key_cache
(*(int8 *)(*(long *)(param_1 + 8) + (ulong)local_38 * 8));
}
}
local_c = local_44;
}
return local_c;
}
| |
24,138 | my_getcputime | eloqsql/mysys/my_getsystime.c | ulonglong my_getcputime()
{
#ifdef CLOCK_THREAD_CPUTIME_ID
struct timespec tp;
if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tp))
return 0;
return (ulonglong)tp.tv_sec*10000000+(ulonglong)tp.tv_nsec/100;
#elif defined(__NR_clock_gettime)
struct timespec tp;
if (syscall(__NR_clock_gettime, CLOCK_THREAD_CPUTIME_ID, &tp))
return 0;
return (ulonglong)tp.tv_sec*10000000+(ulonglong)tp.tv_nsec/100;
#endif /* CLOCK_THREAD_CPUTIME_ID */
return 0;
} | O0 | c | my_getcputime:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x3, %edi
leaq -0x18(%rbp), %rsi
callq 0x292d0
cmpl $0x0, %eax
je 0x42905
movq $0x0, -0x8(%rbp)
jmp 0x4292d
imulq $0x989680, -0x18(%rbp), %rax # imm = 0x989680
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| my_getcputime:
push rbp
mov rbp, rsp
sub rsp, 20h
mov edi, 3
lea rsi, [rbp+var_18]
call _clock_gettime
cmp eax, 0
jz short loc_42905
mov [rbp+var_8], 0
jmp short loc_4292D
loc_42905:
imul rax, [rbp+var_18], 989680h
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov ecx, 64h ; 'd'
xor edx, edx
div rcx
mov rcx, rax
mov rax, [rbp+var_20]
add rax, rcx
mov [rbp+var_8], rax
loc_4292D:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| unsigned long long my_getcputime()
{
long long v1; // [rsp+8h] [rbp-18h] BYREF
unsigned long long v2; // [rsp+10h] [rbp-10h]
if ( (unsigned int)clock_gettime(3LL, &v1) )
return 0LL;
else
return v2 / 0x64 + 10000000 * v1;
}
| my_getcputime:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV EDI,0x3
LEA RSI,[RBP + -0x18]
CALL 0x001292d0
CMP EAX,0x0
JZ 0x00142905
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014292d
LAB_00142905:
IMUL RAX,qword ptr [RBP + -0x18],0x989680
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x64
XOR EDX,EDX
DIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
LAB_0014292d:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
long my_getcputime(void)
{
int iVar1;
timespec local_20;
long local_10;
iVar1 = clock_gettime(3,&local_20);
if (iVar1 == 0) {
local_10 = local_20.tv_sec * 10000000 + (ulong)local_20.tv_nsec / 100;
}
else {
local_10 = 0;
}
return local_10;
}
| |
24,139 | is_stat_table(st_mysql_const_lex_string const*, st_mysql_const_lex_string*) | eloqsql/sql/sql_statistics.cc | bool is_stat_table(const LEX_CSTRING *db, LEX_CSTRING *table)
{
DBUG_ASSERT(db->str && table->str);
if (!my_strcasecmp(table_alias_charset, db->str, MYSQL_SCHEMA_NAME.str))
{
for (uint i= 0; i < STATISTICS_TABLES; i ++)
{
if (!my_strcasecmp(table_alias_charset, table->str, stat_table_name[i].str))
return true;
}
}
return false;
} | O0 | cpp | is_stat_table(st_mysql_const_lex_string const*, st_mysql_const_lex_string*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x66ba02
leaq 0xf54187(%rip), %rax # 0x15bfb90
movq (%rax), %rax
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
leaq 0xf54172(%rip), %rcx # 0x15bfb90
movq (%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
leaq 0xd7c191(%rip), %rcx # 0x13e7bc0
movq (%rcx), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0x66ba9e
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jae 0x66ba9c
leaq 0xf54143(%rip), %rax # 0x15bfb90
movq (%rax), %rax
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
leaq 0xf5412e(%rip), %rcx # 0x15bfb90
movq (%rcx), %rdi
movq -0x18(%rbp), %rcx
movq (%rcx), %rsi
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
leaq 0xc27808(%rip), %rcx # 0x1293280
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0x66ba8f
movb $0x1, -0x1(%rbp)
jmp 0x66baa2
jmp 0x66ba91
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x66ba40
jmp 0x66ba9e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| _Z13is_stat_tablePK25st_mysql_const_lex_stringPS_:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
jmp short $+2
loc_66BA02:
lea rax, table_alias_charset
mov rax, [rax]
mov rax, [rax+0C0h]
mov rax, [rax+40h]
lea rcx, table_alias_charset
mov rdi, [rcx]
mov rcx, [rbp+var_10]
mov rsi, [rcx]
lea rcx, MYSQL_SCHEMA_NAME
mov rdx, [rcx]
call rax
cmp eax, 0
jnz short loc_66BA9E
mov [rbp+var_1C], 0
loc_66BA40:
cmp [rbp+var_1C], 3
jnb short loc_66BA9C
lea rax, table_alias_charset
mov rax, [rax]
mov rax, [rax+0C0h]
mov rax, [rax+40h]
lea rcx, table_alias_charset
mov rdi, [rcx]
mov rcx, [rbp+var_18]
mov rsi, [rcx]
mov ecx, [rbp+var_1C]
mov edx, ecx
lea rcx, _ZL15stat_table_name; stat_table_name
shl rdx, 4
add rcx, rdx
mov rdx, [rcx]
call rax
cmp eax, 0
jnz short loc_66BA8F
mov [rbp+var_1], 1
jmp short loc_66BAA2
loc_66BA8F:
jmp short $+2
loc_66BA91:
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_66BA40
loc_66BA9C:
jmp short $+2
loc_66BA9E:
mov [rbp+var_1], 0
loc_66BAA2:
mov al, [rbp+var_1]
and al, 1
add rsp, 20h
pop rbp
retn
| char is_stat_table(_QWORD *a1, _QWORD *a2)
{
unsigned int i; // [rsp+4h] [rbp-1Ch]
if ( !(*(unsigned int ( **)(long long, _QWORD, void *))(*(_QWORD *)(table_alias_charset + 192) + 64LL))(
table_alias_charset,
*a1,
MYSQL_SCHEMA_NAME) )
{
for ( i = 0; i < 3; ++i )
{
if ( !(*(unsigned int ( **)(long long, _QWORD, _QWORD))(*(_QWORD *)(table_alias_charset + 192) + 64LL))(
table_alias_charset,
*a2,
*(&stat_table_name + 2 * i)) )
return 1;
}
}
return 0;
}
| free_memory:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
TEST byte ptr [RAX + 0x81],0x1
JZ 0x0066ba1a
MOV RDI,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00d0ff60
LAB_0066ba1a:
ADD RSP,0x10
POP RBP
RET
|
/* Warning_info::free_memory() */
void __thiscall Warning_info::free_memory(Warning_info *this)
{
if (((byte)this[0x81] & 1) != 0) {
free_root(this,0);
}
return;
}
| |
24,140 | is_stat_table(st_mysql_const_lex_string const*, st_mysql_const_lex_string*) | eloqsql/sql/sql_statistics.cc | bool is_stat_table(const LEX_CSTRING *db, LEX_CSTRING *table)
{
DBUG_ASSERT(db->str && table->str);
if (!my_strcasecmp(table_alias_charset, db->str, MYSQL_SCHEMA_NAME.str))
{
for (uint i= 0; i < STATISTICS_TABLES; i ++)
{
if (!my_strcasecmp(table_alias_charset, table->str, stat_table_name[i].str))
return true;
}
}
return false;
} | O3 | cpp | is_stat_table(st_mysql_const_lex_string const*, st_mysql_const_lex_string*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
leaq 0xb739bb(%rip), %r14 # 0x10e4b10
movq (%r14), %rax
movq 0xc0(%rax), %rcx
movq (%rdi), %rsi
leaq 0xadc477(%rip), %rdx # 0x104d5e0
movq (%rdx), %rdx
movq %rax, %rdi
callq *0x40(%rcx)
testl %eax, %eax
je 0x57117a
xorl %eax, %eax
jmp 0x5711ac
xorl %r15d, %r15d
leaq 0x99b6fc(%rip), %r12 # 0xf0c880
movq (%r14), %rdi
movq 0xc0(%rdi), %rax
movq (%rbx), %rsi
movq (%r15,%r12), %rdx
callq *0x40(%rax)
testl %eax, %eax
sete %al
je 0x5711ac
leaq 0x10(%r15), %rcx
cmpq $0x20, %r15
movq %rcx, %r15
jne 0x571184
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _Z13is_stat_tablePK25st_mysql_const_lex_stringPS_:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rsi
lea r14, table_alias_charset
mov rax, [r14]
mov rcx, [rax+0C0h]
mov rsi, [rdi]
lea rdx, MYSQL_SCHEMA_NAME
mov rdx, [rdx]
mov rdi, rax
call qword ptr [rcx+40h]
test eax, eax
jz short loc_57117A
xor eax, eax
jmp short loc_5711AC
loc_57117A:
xor r15d, r15d
lea r12, _ZL15stat_table_name; stat_table_name
loc_571184:
mov rdi, [r14]
mov rax, [rdi+0C0h]
mov rsi, [rbx]
mov rdx, [r15+r12]
call qword ptr [rax+40h]
test eax, eax
setz al
jz short loc_5711AC
lea rcx, [r15+10h]
cmp r15, 20h ; ' '
mov r15, rcx
jnz short loc_571184
loc_5711AC:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| bool is_stat_table(_QWORD *a1, _QWORD *a2)
{
bool result; // al
long long v3; // r15
bool v4; // zf
if ( (*(unsigned int ( **)(long long, _QWORD, void *))(*(_QWORD *)(table_alias_charset + 192) + 64LL))(
table_alias_charset,
*a1,
MYSQL_SCHEMA_NAME) )
{
return 0;
}
v3 = 0LL;
do
{
result = (*(unsigned int ( **)(long long, _QWORD, _QWORD))(*(_QWORD *)(table_alias_charset + 192) + 64LL))(
table_alias_charset,
*a2,
*(_UNKNOWN **)((char *)&stat_table_name + v3)) == 0;
if ( result )
break;
v4 = v3 == 32;
v3 += 16LL;
}
while ( !v4 );
return result;
}
| |||
24,141 | write_keys_varlen | eloqsql/storage/maria/ma_sort.c | static int write_keys_varlen(MARIA_SORT_PARAM *info,
register uchar **sort_keys,
ha_keys count, BUFFPEK *buffpek,
IO_CACHE *tempfile)
{
uchar **end;
int err;
DBUG_ENTER("write_keys_varlen");
if (!buffpek)
DBUG_RETURN(1); /* Out of memory */
my_qsort2((uchar*) sort_keys, (size_t) count, sizeof(uchar*),
(qsort2_cmp) info->key_cmp, info);
if (!my_b_inited(tempfile) &&
open_cached_file(tempfile, my_tmpdir(info->tmpdir), "ST",
DISK_BUFFER_SIZE, info->sort_info->param->myf_rw))
DBUG_RETURN(1); /* purecov: inspected */
buffpek->file_pos=my_b_tell(tempfile);
buffpek->count=count;
for (end=sort_keys+count ; sort_keys != end ; sort_keys++)
{
if ((err= my_var_write(info,tempfile, *sort_keys)))
DBUG_RETURN(err);
}
DBUG_RETURN(0);
} | O3 | c | write_keys_varlen:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x1, %r13d
testq %rcx, %rcx
je 0x7241d
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %r12
movq 0x668(%rdi), %rcx
movl $0x8, %edx
movq %rsi, -0x38(%rbp)
movq %rsi, %rdi
movq %r14, %rsi
movq %r12, %r8
callq 0xbcd28
cmpq $0x0, 0x20(%rbx)
je 0x723d7
movq %r12, -0x48(%rbp)
leaq 0x10(%rbx), %rax
cmpl $0x2, 0xb0(%rbx)
leaq 0x40(%rbx), %rcx
movq (%rbx), %rdx
cmoveq %rcx, %rax
subq 0x28(%rbx), %rdx
addq (%rax), %rdx
movq %rdx, (%r15)
movq %r14, 0x18(%r15)
testq %r14, %r14
je 0x723d2
movq %r14, %rax
movq -0x38(%rbp), %r14
shlq $0x3, %rax
movq %rax, -0x40(%rbp)
xorl %r12d, %r12d
movq (%r14,%r12), %r15
movq -0x48(%rbp), %rax
movq 0x378(%rax), %rdi
movq %r15, %rsi
callq 0x3fc4c
movw %ax, -0x2a(%rbp)
movq 0x40(%rbx), %rcx
leaq 0x2(%rcx), %rdx
cmpq 0x48(%rbx), %rdx
jbe 0x7237b
movl $0x2, %edx
movq %rbx, %rdi
leaq -0x2a(%rbp), %rsi
callq 0xb58ab
testl %eax, %eax
jne 0x7241a
movzwl -0x2a(%rbp), %eax
movq 0x40(%rbx), %rdi
jmp 0x7238e
movzwl -0x2a(%rbp), %edx
movw %dx, (%rcx)
movq 0x40(%rbx), %rdi
addq $0x2, %rdi
movq %rdi, 0x40(%rbx)
movzwl %ax, %r13d
leaq (%rdi,%r13), %rax
cmpq 0x48(%rbx), %rax
jbe 0x723b0
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xb58ab
testl %eax, %eax
je 0x723c4
jmp 0x7241a
testq %r13, %r13
je 0x723c4
movq %r15, %rsi
movq %r13, %rdx
callq 0x2b0b0
addq %r13, 0x40(%rbx)
addq $0x8, %r12
cmpq %r12, -0x40(%rbp)
jne 0x7232f
xorl %r13d, %r13d
jmp 0x7241d
movq 0x3f8(%r12), %rdi
callq 0xbd8aa
movq 0x380(%r12), %rcx
movq 0x90(%rcx), %rcx
movq 0x20998(%rcx), %r8
leaq 0x92636(%rip), %rdx # 0x104a37
movl $0x80000, %ecx # imm = 0x80000
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb46a8
testb %al, %al
jne 0x7241d
jmp 0x722ec
movl %eax, %r13d
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| write_keys_varlen:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r13d, 1
test rcx, rcx
jz loc_7241D
mov rbx, r8
mov r15, rcx
mov r14, rdx
mov r12, rdi
mov rcx, [rdi+668h]
mov edx, 8
mov [rbp+var_38], rsi
mov rdi, rsi
mov rsi, r14
mov r8, r12
call my_qsort2
cmp qword ptr [rbx+20h], 0
jz loc_723D7
loc_722EC:
mov [rbp+var_48], r12
lea rax, [rbx+10h]
cmp dword ptr [rbx+0B0h], 2
lea rcx, [rbx+40h]
mov rdx, [rbx]
cmovz rax, rcx
sub rdx, [rbx+28h]
add rdx, [rax]
mov [r15], rdx
mov [r15+18h], r14
test r14, r14
jz loc_723D2
mov rax, r14
mov r14, [rbp+var_38]
shl rax, 3
mov [rbp+var_40], rax
xor r12d, r12d
loc_7232F:
mov r15, [r14+r12]
mov rax, [rbp+var_48]
mov rdi, [rax+378h]
mov rsi, r15
call _ma_keylength
mov [rbp+var_2A], ax
mov rcx, [rbx+40h]
lea rdx, [rcx+2]
cmp rdx, [rbx+48h]
jbe short loc_7237B
mov edx, 2
mov rdi, rbx
lea rsi, [rbp+var_2A]
call _my_b_write
test eax, eax
jnz loc_7241A
movzx eax, [rbp+var_2A]
mov rdi, [rbx+40h]
jmp short loc_7238E
loc_7237B:
movzx edx, [rbp+var_2A]
mov [rcx], dx
mov rdi, [rbx+40h]
add rdi, 2
mov [rbx+40h], rdi
loc_7238E:
movzx r13d, ax
lea rax, [rdi+r13]
cmp rax, [rbx+48h]
jbe short loc_723B0
mov rdi, rbx
mov rsi, r15
mov rdx, r13
call _my_b_write
test eax, eax
jz short loc_723C4
jmp short loc_7241A
loc_723B0:
test r13, r13
jz short loc_723C4
mov rsi, r15
mov rdx, r13
call _memcpy
add [rbx+40h], r13
loc_723C4:
add r12, 8
cmp [rbp+var_40], r12
jnz loc_7232F
loc_723D2:
xor r13d, r13d
jmp short loc_7241D
loc_723D7:
mov rdi, [r12+3F8h]
call my_tmpdir
mov rcx, [r12+380h]
mov rcx, [rcx+90h]
mov r8, [rcx+20998h]
lea rdx, aSt; "ST"
mov ecx, 80000h
mov rdi, rbx
mov rsi, rax
call open_cached_file
test al, al
jnz short loc_7241D
jmp loc_722EC
loc_7241A:
mov r13d, eax
loc_7241D:
mov eax, r13d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long write_keys_varlen(long long *a1, long long a2, long long a3, _QWORD *a4, long long a5)
{
unsigned int v5; // r13d
_QWORD *v9; // rax
long long i; // r12
unsigned __int8 *v11; // r15
unsigned __int16 v12; // ax
_WORD *v13; // rcx
unsigned int v14; // eax
long long v15; // rdi
long long v16; // r13
long long v17; // rax
_WORD v20[21]; // [rsp+26h] [rbp-2Ah] BYREF
v5 = 1;
if ( a4 )
{
my_qsort2(a2, a3, 8LL, a1[205], a1);
if ( *(_QWORD *)(a5 + 32)
|| (v17 = my_tmpdir(a1[127]),
!(unsigned __int8)open_cached_file(
a5,
v17,
"ST",
0x80000LL,
*(_QWORD *)(*(_QWORD *)(a1[112] + 144) + 133528LL))) )
{
v9 = (_QWORD *)(a5 + 16);
if ( *(_DWORD *)(a5 + 176) == 2 )
v9 = (_QWORD *)(a5 + 64);
*a4 = *v9 + *(_QWORD *)a5 - *(_QWORD *)(a5 + 40);
a4[3] = a3;
if ( a3 )
{
for ( i = 0LL; 8 * a3 != i; i += 8LL )
{
v11 = *(unsigned __int8 **)(a2 + i);
v12 = ma_keylength(a1[111], v11);
v20[0] = v12;
v13 = *(_WORD **)(a5 + 64);
if ( (unsigned long long)(v13 + 1) <= *(_QWORD *)(a5 + 72) )
{
*v13 = v20[0];
v15 = *(_QWORD *)(a5 + 64) + 2LL;
*(_QWORD *)(a5 + 64) = v15;
}
else
{
v14 = my_b_write(a5, v20, 2LL);
if ( v14 )
return v14;
v12 = v20[0];
v15 = *(_QWORD *)(a5 + 64);
}
v16 = v12;
if ( v15 + (unsigned long long)v12 <= *(_QWORD *)(a5 + 72) )
{
if ( v12 )
{
memcpy(v15, v11, v12);
*(_QWORD *)(a5 + 64) += v16;
}
}
else
{
v14 = my_b_write(a5, v11, v12);
if ( v14 )
return v14;
}
}
}
return 0;
}
}
return v5;
}
| write_keys_varlen:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R13D,0x1
TEST RCX,RCX
JZ 0x0017241d
MOV RBX,R8
MOV R15,RCX
MOV R14,RDX
MOV R12,RDI
MOV RCX,qword ptr [RDI + 0x668]
MOV EDX,0x8
MOV qword ptr [RBP + -0x38],RSI
MOV RDI,RSI
MOV RSI,R14
MOV R8,R12
CALL 0x001bcd28
CMP qword ptr [RBX + 0x20],0x0
JZ 0x001723d7
LAB_001722ec:
MOV qword ptr [RBP + -0x48],R12
LEA RAX,[RBX + 0x10]
CMP dword ptr [RBX + 0xb0],0x2
LEA RCX,[RBX + 0x40]
MOV RDX,qword ptr [RBX]
CMOVZ RAX,RCX
SUB RDX,qword ptr [RBX + 0x28]
ADD RDX,qword ptr [RAX]
MOV qword ptr [R15],RDX
MOV qword ptr [R15 + 0x18],R14
TEST R14,R14
JZ 0x001723d2
MOV RAX,R14
MOV R14,qword ptr [RBP + -0x38]
SHL RAX,0x3
MOV qword ptr [RBP + -0x40],RAX
XOR R12D,R12D
LAB_0017232f:
MOV R15,qword ptr [R14 + R12*0x1]
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [RAX + 0x378]
MOV RSI,R15
CALL 0x0013fc4c
MOV word ptr [RBP + -0x2a],AX
MOV RCX,qword ptr [RBX + 0x40]
LEA RDX,[RCX + 0x2]
CMP RDX,qword ptr [RBX + 0x48]
JBE 0x0017237b
MOV EDX,0x2
MOV RDI,RBX
LEA RSI,[RBP + -0x2a]
CALL 0x001b58ab
TEST EAX,EAX
JNZ 0x0017241a
MOVZX EAX,word ptr [RBP + -0x2a]
MOV RDI,qword ptr [RBX + 0x40]
JMP 0x0017238e
LAB_0017237b:
MOVZX EDX,word ptr [RBP + -0x2a]
MOV word ptr [RCX],DX
MOV RDI,qword ptr [RBX + 0x40]
ADD RDI,0x2
MOV qword ptr [RBX + 0x40],RDI
LAB_0017238e:
MOVZX R13D,AX
LEA RAX,[RDI + R13*0x1]
CMP RAX,qword ptr [RBX + 0x48]
JBE 0x001723b0
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R13
CALL 0x001b58ab
TEST EAX,EAX
JZ 0x001723c4
JMP 0x0017241a
LAB_001723b0:
TEST R13,R13
JZ 0x001723c4
MOV RSI,R15
MOV RDX,R13
CALL 0x0012b0b0
ADD qword ptr [RBX + 0x40],R13
LAB_001723c4:
ADD R12,0x8
CMP qword ptr [RBP + -0x40],R12
JNZ 0x0017232f
LAB_001723d2:
XOR R13D,R13D
JMP 0x0017241d
LAB_001723d7:
MOV RDI,qword ptr [R12 + 0x3f8]
CALL 0x001bd8aa
MOV RCX,qword ptr [R12 + 0x380]
MOV RCX,qword ptr [RCX + 0x90]
MOV R8,qword ptr [RCX + 0x20998]
LEA RDX,[0x204a37]
MOV ECX,0x80000
MOV RDI,RBX
MOV RSI,RAX
CALL 0x001b46a8
TEST AL,AL
JNZ 0x0017241d
JMP 0x001722ec
LAB_0017241a:
MOV R13D,EAX
LAB_0017241d:
MOV EAX,R13D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int write_keys_varlen(long param_1,long param_2,long param_3,long *param_4,long *param_5)
{
void *__src;
char cVar1;
int iVar2;
long *plVar3;
int8 uVar4;
void *__dest;
long lVar5;
ulong __n;
ushort local_32;
iVar2 = 1;
if (param_4 != (long *)0x0) {
my_qsort2(param_2,param_3,8,*(int8 *)(param_1 + 0x668),param_1);
if (param_5[4] == 0) {
uVar4 = my_tmpdir(*(int8 *)(param_1 + 0x3f8));
cVar1 = open_cached_file(param_5,uVar4,&DAT_00204a37,0x80000,
*(int8 *)
(*(long *)(*(long *)(param_1 + 0x380) + 0x90) + 0x20998));
if (cVar1 != '\0') {
return 1;
}
}
plVar3 = param_5 + 2;
if ((int)param_5[0x16] == 2) {
plVar3 = param_5 + 8;
}
*param_4 = (*param_5 - param_5[5]) + *plVar3;
param_4[3] = param_3;
if (param_3 != 0) {
lVar5 = 0;
do {
__src = *(void **)(param_2 + lVar5);
local_32 = _ma_keylength(*(int8 *)(param_1 + 0x378),__src);
if ((ushort *)param_5[9] < (ushort *)param_5[8] + 1) {
iVar2 = _my_b_write(param_5,&local_32,2);
if (iVar2 != 0) {
return iVar2;
}
__dest = (void *)param_5[8];
}
else {
*(ushort *)param_5[8] = local_32;
__dest = (void *)(param_5[8] + 2);
param_5[8] = (long)__dest;
}
__n = (ulong)local_32;
if ((ulong)param_5[9] < (long)__dest + __n) {
iVar2 = _my_b_write(param_5,__src,__n);
if (iVar2 != 0) {
return iVar2;
}
}
else if (__n != 0) {
memcpy(__dest,__src,__n);
param_5[8] = param_5[8] + __n;
}
lVar5 = lVar5 + 8;
} while (param_3 << 3 != lVar5);
}
iVar2 = 0;
}
return iVar2;
}
| |
24,142 | mysql_read_query_result_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_read_query_result_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_read_query_result,
(parms->mysql),
parms->mysql,
my_bool,
r_my_bool)
} | O3 | c | mysql_read_query_result_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq 0x480(%rdi), %rax
movq 0x28(%rax), %rbx
callq 0x5f4c4
movb %al, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_read_query_result_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdi, [rdi]
mov rax, [rdi+480h]
mov rbx, [rax+28h]
call mysql_read_query_result
mov [rbx+8], al
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| bool mysql_read_query_result_start_internal(long long *a1)
{
long long v1; // rdi
long long v2; // rbx
bool result; // al
v1 = *a1;
v2 = *(_QWORD *)(*(_QWORD *)(v1 + 1152) + 40LL);
result = mysql_read_query_result(v1);
*(_BYTE *)(v2 + 8) = result;
*(_DWORD *)v2 = 0;
return result;
}
| mysql_read_query_result_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 0x0015f4c4
MOV byte ptr [RBX + 0x8],AL
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_read_query_result_start_internal(long *param_1)
{
int4 *puVar1;
int1 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_read_query_result();
*(int1 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
| |
24,143 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&) | hkr04[P]cpp-mcp/common/json.hpp | static diyfp mul(const diyfp& x, const diyfp& y) noexcept
{
static_assert(kPrecision == 64, "internal error");
// Computes:
// f = round((x.f * y.f) / 2^q)
// e = x.e + y.e + q
// Emulate the 64-bit * 64-bit multiplication:
//
// p = u * v
// = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
// = (u_lo v_lo ) + 2^32 ((u_lo v_hi ) + (u_hi v_lo )) + 2^64 (u_hi v_hi )
// = (p0 ) + 2^32 ((p1 ) + (p2 )) + 2^64 (p3 )
// = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3 )
// = (p0_lo ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi + p2_hi + p3)
// = (p0_lo ) + 2^32 (Q ) + 2^64 (H )
// = (p0_lo ) + 2^32 (Q_lo + 2^32 Q_hi ) + 2^64 (H )
//
// (Since Q might be larger than 2^32 - 1)
//
// = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
//
// (Q_hi + H does not overflow a 64-bit int)
//
// = p_lo + 2^64 p_hi
const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
const std::uint64_t u_hi = x.f >> 32u;
const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
const std::uint64_t v_hi = y.f >> 32u;
const std::uint64_t p0 = u_lo * v_lo;
const std::uint64_t p1 = u_lo * v_hi;
const std::uint64_t p2 = u_hi * v_lo;
const std::uint64_t p3 = u_hi * v_hi;
const std::uint64_t p0_hi = p0 >> 32u;
const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
const std::uint64_t p1_hi = p1 >> 32u;
const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
const std::uint64_t p2_hi = p2 >> 32u;
std::uint64_t Q = p0_hi + p1_lo + p2_lo;
// The full product might now be computed as
//
// p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
// p_lo = p0_lo + (Q << 32)
//
// But in this particular case here, the full p_lo is not required.
// Effectively we only need to add the highest bit in p_lo to p_hi (and
// Q_hi + 1 does not overflow).
Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
return {h, x.e + y.e + 64};
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&):
movq (%rdi), %rax
movl %eax, %ecx
shrq $0x20, %rax
movq (%rsi), %r8
movl %r8d, %edx
shrq $0x20, %r8
movq %rdx, %r9
imulq %rcx, %r9
imulq %r8, %rcx
imulq %rax, %rdx
imulq %rax, %r8
shrq $0x20, %r9
movl %ecx, %r10d
addq %r9, %r10
shrq $0x20, %rcx
movl %edx, %eax
addq %r10, %rax
shrq $0x20, %rdx
addq %r8, %rdx
addq %rcx, %rdx
subq $-0x80000000, %rax # imm = 0x80000000
shrq $0x20, %rax
addq %rdx, %rax
movl 0x8(%rdi), %ecx
movl 0x8(%rsi), %edx
addl %ecx, %edx
addl $0x40, %edx
retq
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3mulERKS3_S5_:
mov rax, [rdi]
mov ecx, eax
shr rax, 20h
mov r8, [rsi]
mov edx, r8d
shr r8, 20h
mov r9, rdx
imul r9, rcx
imul rcx, r8
imul rdx, rax
imul r8, rax
shr r9, 20h
mov r10d, ecx
add r10, r9
shr rcx, 20h
mov eax, edx
add rax, r10
shr rdx, 20h
add rdx, r8
add rdx, rcx
sub rax, 0FFFFFFFF80000000h
shr rax, 20h
add rax, rdx
mov ecx, [rdi+8]
mov edx, [rsi+8]
add edx, ecx
add edx, 40h ; '@'
retn
| unsigned long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(_QWORD *a1, _QWORD *a2)
{
long long v2; // rcx
v2 = (unsigned int)*a1;
return ((unsigned long long)(HIDWORD(*a2) * v2) >> 32)
+ HIDWORD(*a1) * HIDWORD(*a2)
+ ((HIDWORD(*a1) * (unsigned long long)(unsigned int)*a2) >> 32)
+ ((((v2 * (unsigned long long)(unsigned int)*a2) >> 32)
+ (unsigned int)(HIDWORD(*a2) * v2)
+ (unsigned int)(HIDWORD(*a1) * *a2)
+ 0x80000000) >> 32);
}
| mul:
MOV RAX,qword ptr [RDI]
MOV ECX,EAX
SHR RAX,0x20
MOV R8,qword ptr [RSI]
MOV EDX,R8D
SHR R8,0x20
MOV R9,RDX
IMUL R9,RCX
IMUL RCX,R8
IMUL RDX,RAX
IMUL R8,RAX
SHR R9,0x20
MOV R10D,ECX
ADD R10,R9
SHR RCX,0x20
MOV EAX,EDX
ADD RAX,R10
SHR RDX,0x20
ADD RDX,R8
ADD RDX,RCX
SUB RAX,-0x80000000
SHR RAX,0x20
ADD RAX,RDX
MOV ECX,dword ptr [RDI + 0x8]
MOV EDX,dword ptr [RSI + 0x8]
ADD EDX,ECX
ADD EDX,0x40
RET
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp
const&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&) */
int1 [16]
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::mul(diyfp *param_1,diyfp *param_2)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
int1 auVar7 [16];
uVar2 = *(ulong *)param_1 & 0xffffffff;
uVar1 = *(ulong *)param_1 >> 0x20;
uVar4 = *(ulong *)param_2 & 0xffffffff;
uVar6 = *(ulong *)param_2 >> 0x20;
uVar3 = uVar2 * uVar6;
uVar5 = uVar4 * uVar1;
auVar7._0_8_ = ((uVar5 & 0xffffffff) + (uVar3 & 0xffffffff) + (uVar4 * uVar2 >> 0x20) + 0x80000000
>> 0x20) + (uVar5 >> 0x20) + uVar6 * uVar1 + (uVar3 >> 0x20);
auVar7._8_4_ = *(int *)(param_2 + 8) + *(int *)(param_1 + 8) + 0x40;
auVar7._12_4_ = 0;
return auVar7;
}
| |
24,144 | js_std_file_eof | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_eof(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
FILE *f = js_std_file_get(ctx, this_val);
if (!f)
return JS_EXCEPTION;
return JS_NewBool(ctx, feof(f));
} | O0 | c | js_std_file_eof:
subq $0x68, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x13a80
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x12ff0
movl $0x0, 0x38(%rsp)
movq $0x6, 0x40(%rsp)
jmp 0x1303d
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0xe570
movq (%rsp), %rcx
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
testl %eax, %eax
setne %al
movzbl %al, %eax
movl %eax, 0x58(%rsp)
movq $0x1, 0x60(%rsp)
movq 0x58(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x68, %rsp
retq
nopl (%rax)
| js_std_file_eof:
sub rsp, 68h
mov [rsp+68h+var_40], rsi
mov [rsp+68h+var_38], rdx
mov [rsp+68h+var_48], rdi
mov [rsp+68h+var_4C], ecx
mov [rsp+68h+var_58], r8
mov rdi, [rsp+68h+var_48]
mov rsi, [rsp+68h+var_40]
mov rdx, [rsp+68h+var_38]
call js_std_file_get
mov [rsp+68h+var_60], rax
cmp [rsp+68h+var_60], 0
jnz short loc_12FF0
mov dword ptr [rsp+68h+var_30], 0
mov [rsp+68h+var_28], 6
jmp short loc_1303D
loc_12FF0:
mov rax, [rsp+68h+var_48]
mov [rsp+68h+var_68], rax
mov rdi, [rsp+68h+var_60]
call _feof
mov rcx, [rsp+68h+var_68]
mov [rsp+68h+var_18], rcx
mov [rsp+68h+var_1C], eax
mov eax, [rsp+68h+var_1C]
test eax, eax
setnz al
movzx eax, al
mov dword ptr [rsp+68h+var_10], eax
mov [rsp+68h+var_8], 1
mov rcx, [rsp+68h+var_10]
mov rax, [rsp+68h+var_8]
mov [rsp+68h+var_30], rcx
mov [rsp+68h+var_28], rax
loc_1303D:
mov rax, [rsp+68h+var_30]
mov rdx, [rsp+68h+var_28]
add rsp, 68h
retn
| long long js_std_file_eof(long long a1, long long a2, long long a3)
{
long long v4; // [rsp+8h] [rbp-60h]
long long v5; // [rsp+38h] [rbp-30h]
long long v6; // [rsp+58h] [rbp-10h]
v4 = js_std_file_get(a1, a2, a3);
if ( v4 )
{
LODWORD(v6) = feof(v4) != 0;
return v6;
}
else
{
LODWORD(v5) = 0;
}
return v5;
}
| js_std_file_eof:
SUB RSP,0x68
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ECX
MOV qword ptr [RSP + 0x10],R8
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x00113a80
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00112ff0
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x6
JMP 0x0011303d
LAB_00112ff0:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0010e570
MOV RCX,qword ptr [RSP]
MOV qword ptr [RSP + 0x50],RCX
MOV dword ptr [RSP + 0x4c],EAX
MOV EAX,dword ptr [RSP + 0x4c]
TEST EAX,EAX
SETNZ AL
MOVZX EAX,AL
MOV dword ptr [RSP + 0x58],EAX
MOV qword ptr [RSP + 0x60],0x1
MOV RCX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x40],RAX
LAB_0011303d:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x68
RET
|
int1 [16] js_std_file_eof(int8 param_1,int8 param_2,int8 param_3)
{
int1 auVar1 [16];
int iVar2;
FILE *__stream;
int4 local_30;
int4 uStack_2c;
int8 local_28;
int4 uStack_c;
__stream = (FILE *)js_std_file_get(param_1,param_2,param_3);
if (__stream == (FILE *)0x0) {
local_30 = 0;
local_28 = 6;
}
else {
iVar2 = feof(__stream);
local_30 = (uint)(iVar2 != 0);
uStack_2c = uStack_c;
local_28 = 1;
}
auVar1._4_4_ = uStack_2c;
auVar1._0_4_ = local_30;
auVar1._8_8_ = local_28;
return auVar1;
}
| |
24,145 | ggml::cpu::aarch64::extra_buffer_type::~extra_buffer_type() | llama.cpp/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp | bool supports_op(ggml_backend_dev_t, const struct ggml_tensor * op) override {
if ( op->op == GGML_OP_MUL_MAT &&
op->src[0]->buffer &&
(ggml_n_dims(op->src[0]) == 2) &&
op->src[0]->buffer->buft == ggml_backend_cpu_aarch64_buffer_type() &&
ggml_aarch64_get_optimal_repack_type(op->src[0])
) {
if (op->src[1]->buffer && !ggml_backend_buft_is_host(op->src[1]->buffer->buft)) {
return false;
}
if (op->src[1]->type == GGML_TYPE_F32) {
return true;
}
//if (op->src[1]->type == GGML_TYPE_Q8_0) {
// return true;
//}
// may be possible if Q8_0 packed...
} else if (op->op == GGML_OP_MUL_MAT_ID
&& op->src[0]->buffer
&& (ggml_n_dims(op->src[0]) == 3)
&& op->src[0]->buffer->buft == ggml_backend_cpu_aarch64_buffer_type()
&& ggml_aarch64_get_optimal_repack_type(op->src[0])
) {
if (op->src[1]->buffer && !ggml_backend_buft_is_host(op->src[1]->buffer->buft)) {
return false;
}
if (op->src[1]->type == GGML_TYPE_F32) {
return true;
}
//if (op->src[1]->type == GGML_TYPE_Q8_0) {
// return true;
//}
}
return false;
} | O3 | cpp | ggml::cpu::aarch64::extra_buffer_type::~extra_buffer_type():
pushq %rbx
movq %rdi, %rbx
callq 0xa6f0
movl $0x8, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xa910
nop
| _ZN4ggml3cpu7aarch6417extra_buffer_typeD0Ev:
push rbx
mov rbx, rdi
call __ZN4ggml3cpu17extra_buffer_typeD2Ev; ggml::cpu::extra_buffer_type::~extra_buffer_type()
mov esi, 8; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void ggml::cpu::aarch64::extra_buffer_type::~extra_buffer_type(ggml::cpu::aarch64::extra_buffer_type *this)
{
ggml::cpu::extra_buffer_type::~extra_buffer_type(this);
operator delete(this, 8uLL);
}
| ~extra_buffer_type:
PUSH RBX
MOV RBX,RDI
CALL 0x0010a6f0
MOV ESI,0x8
MOV RDI,RBX
POP RBX
JMP 0x0010a910
|
/* ggml::cpu::aarch64::extra_buffer_type::~extra_buffer_type() */
void __thiscall ggml::cpu::aarch64::extra_buffer_type::~extra_buffer_type(extra_buffer_type *this)
{
cpu::extra_buffer_type::~extra_buffer_type((extra_buffer_type *)this);
operator_delete(this,8);
return;
}
| |
24,146 | minja::ArgumentsValue::has_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/./minja.hpp | bool has_named(const std::string & name) {
for (const auto & p : kwargs) {
if (p.first == name) return true;
}
return false;
} | O2 | cpp | minja::ArgumentsValue::has_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %r15
movq %rcx, %r14
cmpq %r15, %rcx
je 0x4528d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a7d4
leaq 0x70(%r14), %rcx
testb %al, %al
je 0x45272
cmpq %r15, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN5minja14ArgumentsValue9has_namedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push rbx
mov rbx, rsi
mov rcx, [rdi+18h]
mov r15, [rdi+20h]
loc_45272:
mov r14, rcx
cmp rcx, r15
jz short loc_4528D
mov rdi, r14
mov rsi, rbx
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
lea rcx, [r14+70h]
test al, al
jz short loc_45272
loc_4528D:
cmp r14, r15
setnz al
pop rbx
pop r14
pop r15
retn
| bool minja::ArgumentsValue::has_named(long long a1, long long *a2)
{
long long *v2; // rcx
long long *v3; // r15
long long *v4; // r14
bool v5; // al
v2 = *(long long **)(a1 + 24);
v3 = *(long long **)(a1 + 32);
do
{
v4 = v2;
if ( v2 == v3 )
break;
v5 = std::operator==<char>(v2, a2);
v2 = v4 + 14;
}
while ( !v5 );
return v4 != v3;
}
| has_named:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV RCX,qword ptr [RDI + 0x18]
MOV R15,qword ptr [RDI + 0x20]
LAB_00145272:
MOV R14,RCX
CMP RCX,R15
JZ 0x0014528d
MOV RDI,R14
MOV RSI,RBX
CALL 0x0012a7d4
LEA RCX,[R14 + 0x70]
TEST AL,AL
JZ 0x00145272
LAB_0014528d:
CMP R14,R15
SETNZ AL
POP RBX
POP R14
POP R15
RET
|
/* minja::ArgumentsValue::has_named(std::__cxx11::string const&) */
bool __thiscall minja::ArgumentsValue::has_named(ArgumentsValue *this,string *param_1)
{
string *psVar1;
string *psVar2;
char cVar3;
string *psVar4;
psVar1 = *(string **)(this + 0x20);
psVar2 = *(string **)(this + 0x18);
do {
psVar4 = psVar2;
if (psVar4 == psVar1) break;
cVar3 = std::operator==(psVar4,param_1);
psVar2 = psVar4 + 0x70;
} while (cVar3 == '\0');
return psVar4 != psVar1;
}
| |
24,147 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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>>>>>::reset() | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | void reset() noexcept
{
token_buffer.clear();
token_string.clear();
decimal_point_position = std::string::npos;
token_string.push_back(char_traits<char_type>::to_char_type(current));
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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>>>>>::reset():
pushq %rax
movq %rdi, %rax
andq $0x0, 0x58(%rdi)
movq 0x50(%rdi), %rcx
movb $0x0, (%rcx)
addq $0x38, %rdi
movq 0x38(%rax), %rcx
cmpq %rcx, 0x40(%rax)
je 0x23e00
movq %rcx, 0x40(%rax)
orq $-0x1, 0x98(%rax)
movb 0x14(%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
callq 0x1ce70
popq %rax
retq
movq %rax, %rdi
callq 0x203e2
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5resetEv:
push rax
mov rax, rdi
and qword ptr [rdi+58h], 0
mov rcx, [rdi+50h]
mov byte ptr [rcx], 0
add rdi, 38h ; '8'
mov rcx, [rax+38h]
cmp [rax+40h], rcx
jz short loc_23E00
mov [rax+40h], rcx
loc_23E00:
or qword ptr [rax+98h], 0FFFFFFFFFFFFFFFFh
mov al, [rax+14h]
lea rsi, [rsp+8+var_1]
mov [rsi], al
call __ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
pop rax
retn
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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>>>::reset(
long long a1)
{
long long v1; // rax
long long v3; // rdi
long long v4; // rcx
long long v6; // [rsp-6h] [rbp-8h]
v6 = v1;
*(_QWORD *)(a1 + 88) = 0LL;
**(_BYTE **)(a1 + 80) = 0;
v3 = a1 + 56;
v4 = *(_QWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 64) != v4 )
*(_QWORD *)(a1 + 64) = v4;
*(_QWORD *)(a1 + 152) = -1LL;
HIBYTE(v6) = *(_BYTE *)(a1 + 20);
std::vector<char>::emplace_back<char>(v3);
return v6;
}
| reset:
PUSH RAX
MOV RAX,RDI
AND qword ptr [RDI + 0x58],0x0
MOV RCX,qword ptr [RDI + 0x50]
MOV byte ptr [RCX],0x0
ADD RDI,0x38
MOV RCX,qword ptr [RAX + 0x38]
CMP qword ptr [RAX + 0x40],RCX
JZ 0x00123e00
MOV qword ptr [RAX + 0x40],RCX
LAB_00123e00:
OR qword ptr [RAX + 0x98],-0x1
MOV AL,byte ptr [RAX + 0x14]
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],AL
LAB_00123e12:
CALL 0x0011ce70
POP RAX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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 > > >::reset() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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>>>
::reset(lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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)
{
int8 in_RAX;
int8 uStack_8;
*(int8 *)(this + 0x58) = 0;
**(int1 **)(this + 0x50) = 0;
if (*(long *)(this + 0x40) != *(long *)(this + 0x38)) {
*(long *)(this + 0x40) = *(long *)(this + 0x38);
}
*(int8 *)(this + 0x98) = 0xffffffffffffffff;
uStack_8 = CONCAT17(this[0x14],(int7)in_RAX);
/* try { // try from 00123e12 to 00123e16 has its CatchHandler @ 00123e19 */
std::vector<char,std::allocator<char>>::emplace_back<char>
((vector<char,std::allocator<char>> *)(this + 0x38),(char *)((long)&uStack_8 + 7));
return uStack_8;
}
| |
24,148 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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>>>>>::reset() | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | void reset() noexcept
{
token_buffer.clear();
token_string.clear();
decimal_point_position = std::string::npos;
token_string.push_back(char_traits<char_type>::to_char_type(current));
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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>>>>>::reset():
pushq %rax
movq %rdi, %rax
movq $0x0, 0x58(%rdi)
movq 0x50(%rdi), %rcx
movb $0x0, (%rcx)
addq $0x38, %rdi
movq 0x38(%rax), %rcx
cmpq %rcx, 0x40(%rax)
je 0x18cdb
movq %rcx, 0x40(%rax)
movq $-0x1, 0x98(%rax)
movb 0x14(%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
callq 0x117f0
popq %rax
retq
movq %rax, %rdi
callq 0x1532e
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5resetEv:
push rax
mov rax, rdi
mov qword ptr [rdi+58h], 0
mov rcx, [rdi+50h]
mov byte ptr [rcx], 0
add rdi, 38h ; '8'
mov rcx, [rax+38h]
cmp [rax+40h], rcx
jz short loc_18CDB
mov [rax+40h], rcx
loc_18CDB:
mov qword ptr [rax+98h], 0FFFFFFFFFFFFFFFFh
mov al, [rax+14h]
lea rsi, [rsp+8+var_1]
mov [rsi], al
call __ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
pop rax
retn
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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>>>::reset(
long long a1)
{
long long v1; // rax
long long v3; // rdi
long long v4; // rcx
long long v6; // [rsp-6h] [rbp-8h]
v6 = v1;
*(_QWORD *)(a1 + 88) = 0LL;
**(_BYTE **)(a1 + 80) = 0;
v3 = a1 + 56;
v4 = *(_QWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 64) != v4 )
*(_QWORD *)(a1 + 64) = v4;
*(_QWORD *)(a1 + 152) = -1LL;
HIBYTE(v6) = *(_BYTE *)(a1 + 20);
std::vector<char>::emplace_back<char>(v3);
return v6;
}
| reset:
PUSH RAX
MOV RAX,RDI
MOV qword ptr [RDI + 0x58],0x0
MOV RCX,qword ptr [RDI + 0x50]
MOV byte ptr [RCX],0x0
ADD RDI,0x38
MOV RCX,qword ptr [RAX + 0x38]
CMP qword ptr [RAX + 0x40],RCX
JZ 0x00118cdb
MOV qword ptr [RAX + 0x40],RCX
LAB_00118cdb:
MOV qword ptr [RAX + 0x98],-0x1
MOV AL,byte ptr [RAX + 0x14]
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],AL
LAB_00118cf0:
CALL 0x001117f0
POP RAX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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 > > >::reset() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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>>>
::reset(lexer<nlohmann::json_abi_v3_11_3::basic_json<std::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)
{
int8 in_RAX;
int8 uStack_8;
*(int8 *)(this + 0x58) = 0;
**(int1 **)(this + 0x50) = 0;
if (*(long *)(this + 0x40) != *(long *)(this + 0x38)) {
*(long *)(this + 0x40) = *(long *)(this + 0x38);
}
*(int8 *)(this + 0x98) = 0xffffffffffffffff;
uStack_8 = CONCAT17(this[0x14],(int7)in_RAX);
/* try { // try from 00118cf0 to 00118cf4 has its CatchHandler @ 00118cf7 */
std::vector<char,std::allocator<char>>::emplace_back<char>
((vector<char,std::allocator<char>> *)(this + 0x38),(char *)((long)&uStack_8 + 7));
return uStack_8;
}
| |
24,149 | SchemaConverter::_add_primitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BuiltinRule const&) | monkey531[P]llama/common/json-schema-to-grammar.cpp | std::string _add_primitive(const std::string & name, const BuiltinRule & rule) {
auto n = _add_rule(name, rule.content);
for (const auto & dep : rule.deps) {
BuiltinRule dep_rule;
auto it = PRIMITIVE_RULES.find(dep);
if (it == PRIMITIVE_RULES.end()) {
it = STRING_FORMAT_RULES.find(dep);
if (it == STRING_FORMAT_RULES.end()) {
_errors.push_back("Rule " + dep + " not known");
continue;
}
}
if (_rules.find(dep) == _rules.end()) {
_add_primitive(dep, it->second);
}
}
return n;
} | O3 | cpp | SchemaConverter::_add_primitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BuiltinRule const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %rbx
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
callq 0xab600
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %r14
cmpq %r14, %r15
je 0xb0a04
leaq 0x80(%rsp), %rbx
leaq 0x90(%rsp), %r12
movq 0x10(%rsp), %rax
leaq 0x28(%rax), %rcx
movq %rcx, 0x48(%rsp)
leaq 0x30(%rax), %rcx
movq %rcx, 0x40(%rsp)
addq $0xc8, %rax
movq %rax, 0x38(%rsp)
xorl %r13d, %r13d
movq %rbx, 0x70(%rsp)
movq %r13, 0x78(%rsp)
movb $0x0, 0x80(%rsp)
movq %r13, 0x10(%r12)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
leaq 0x41ec3(%rip), %rdi # 0xf2768
movq %r15, %rsi
callq 0xb5cb6
movq %rax, %rbp
testq %rax, %rax
jne 0xb08cc
leaq 0x41ee4(%rip), %rdi # 0xf27a0
movq %r15, %rsi
callq 0xb5cb6
movq %rax, %rbp
testq %rax, %rax
je 0xb0926
movq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x3a584
cmpq 0x40(%rsp), %rax
jne 0xb09d5
addq $0x28, %rbp
leaq 0xa8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0xb0816
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0xb09d5
movq 0xb8(%rsp), %rsi
jmp 0xb09cd
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
leaq 0x12372(%rip), %rsi # 0xc2ca7
movq %r15, %rdx
callq 0x433d6
movq %rbp, %rdi
leaq 0x12366(%rip), %rsi # 0xc2cad
callq 0x19ee0
leaq 0x28(%rsp), %rbp
movq %rbp, 0x18(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xb0974
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
jmp 0xb097b
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
movq %rdx, 0x20(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x241f6
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0xb09b9
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x197f0
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0xb09d5
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x197f0
movq %r12, %rdi
callq 0x23964
movq 0x70(%rsp), %rdi
cmpq %rbx, %rdi
je 0xb09f7
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x197f0
addq $0x20, %r15
cmpq %r14, %r15
jne 0xb087f
movq 0x8(%rsp), %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0xb0a3a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x197f0
jmp 0xb0a3a
movq %rax, %rbx
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0xb0a61
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x197f0
jmp 0xb0a61
jmp 0xb0a5e
jmp 0xb0a5e
jmp 0xb0a5e
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xa9bda
movq 0x8(%rsp), %rcx
movq (%rcx), %rdi
addq $0x10, %rcx
cmpq %rcx, %rdi
je 0xb0a87
movq (%rcx), %rsi
incq %rsi
callq 0x197f0
movq %rbx, %rdi
callq 0x19dc0
nop
| _ZN15SchemaConverter14_add_primitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERK11BuiltinRule:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov rbx, rcx
mov [rsp+0F8h+var_F0], rdi; int
mov [rsp+0F8h+var_E8], rsi; void *
call _ZN15SchemaConverter9_add_ruleERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_; SchemaConverter::_add_rule(std::string const&,std::string const&)
mov r15, [rbx+20h]
mov r14, [rbx+28h]
cmp r15, r14
jz loc_B0A04
lea rbx, [rsp+0F8h+var_78]
lea r12, [rsp+0F8h+var_68]
mov rax, [rsp+0F8h+var_E8]
lea rcx, [rax+28h]
mov [rsp+0F8h+var_B0], rcx; void *
lea rcx, [rax+30h]
mov qword ptr [rsp+0F8h+var_B8], rcx; int
add rax, 0C8h
mov [rsp+0F8h+var_C0], rax; int
xor r13d, r13d
loc_B087F:
mov [rsp+0F8h+var_88], rbx; int
mov [rsp+0F8h+var_80], r13; __int64
mov byte ptr [rsp+0F8h+var_78], 0; int
mov [r12+10h], r13
xorps xmm0, xmm0
movups xmmword ptr [r12], xmm0
lea rdi, _Z15PRIMITIVE_RULESB5cxx11; PRIMITIVE_RULES
mov rsi, r15
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_11BuiltinRuleESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,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>>::find(std::string const&)
mov rbp, rax
test rax, rax
jnz short loc_B08CC
lea rdi, _Z19STRING_FORMAT_RULESB5cxx11; STRING_FORMAT_RULES
mov rsi, r15
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_11BuiltinRuleESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,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>>::find(std::string const&)
mov rbp, rax
test rax, rax
jz short loc_B0926
loc_B08CC:
mov rdi, [rsp+0F8h+var_B0]
mov rsi, r15
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EE4findERS7_; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(std::string const&)
cmp rax, qword ptr [rsp+0F8h+var_B8]
jnz loc_B09D5
add rbp, 28h ; '('
lea rdi, [rsp+0F8h+var_50]; int
mov rsi, [rsp+0F8h+var_E8]; int
mov rdx, r15; int
mov rcx, rbp; int
call _ZN15SchemaConverter14_add_primitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERK11BuiltinRule; SchemaConverter::_add_primitive(std::string const&,BuiltinRule const&)
mov rdi, qword ptr [rsp+0F8h+var_50]
lea rax, [rsp+0F8h+var_40]
cmp rdi, rax
jz loc_B09D5
mov rsi, [rsp+0F8h+var_40]
jmp loc_B09CD
loc_B0926:
lea rbp, [rsp+0F8h+var_A8]
mov rdi, rbp
lea rsi, aRule; "Rule "
mov rdx, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov rdi, rbp
lea rsi, aNotKnown; " not known"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rbp, [rsp+0F8h+var_D0]
mov [rsp+0F8h+var_E0], rbp
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_B0974
mov [rsp+0F8h+var_E0], rdx
mov rdx, [rcx]
mov [rsp+0F8h+var_D0], rdx
jmp short loc_B097B
loc_B0974:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rbp+0], xmm0
loc_B097B:
mov rdx, [rax+8]
mov [rsp+0F8h+var_D8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, [rsp+0F8h+var_C0]
lea rsi, [rsp+0F8h+var_E0]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+0F8h+var_E0]; void *
cmp rdi, rbp
jz short loc_B09B9
mov rsi, [rsp+0F8h+var_D0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B09B9:
mov rdi, [rsp+0F8h+var_A8]; void *
lea rax, [rsp+0F8h+var_98]
cmp rdi, rax
jz short loc_B09D5
mov rsi, [rsp+0F8h+var_98]
loc_B09CD:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B09D5:
mov rdi, r12; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+0F8h+var_88]; void *
cmp rdi, rbx
jz short loc_B09F7
mov rsi, qword ptr [rsp+0F8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B09F7:
add r15, 20h ; ' '
cmp r15, r14
jnz loc_B087F
loc_B0A04:
mov rax, [rsp+0F8h+var_F0]
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_10]; void *
cmp rdi, rbp
jz short loc_B0A3A
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_B0A3A
mov rbx, rax
loc_B0A3A:
mov rdi, [rsp+arg_48]; void *
lea rax, [rsp+arg_58]
cmp rdi, rax
jz short loc_B0A61
mov rsi, [rsp+arg_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_B0A61
jmp short loc_B0A5E
jmp short loc_B0A5E
jmp short $+2
loc_B0A5E:
mov rbx, rax
loc_B0A61:
lea rdi, [rsp+arg_68]; this
call _ZN11BuiltinRuleD2Ev; BuiltinRule::~BuiltinRule()
mov rcx, [rsp+arg_0]
mov rdi, [rcx]; void *
add rcx, 10h
cmp rdi, rcx
jz short loc_B0A87
mov rsi, [rcx]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B0A87:
mov rdi, rbx
call __Unwind_Resume
| void * SchemaConverter::_add_primitive(long long a1, long long a2, long long *a3, _QWORD *a4)
{
_QWORD *v5; // r15
_QWORD *v6; // r14
long long v7; // rax
int v8; // ebp
long long v9; // rax
long long v10; // rax
int v11; // r8d
int v12; // r9d
void *v13; // rdi
long long v14; // rsi
long long v15; // rax
__int128 *v16; // rcx
long long v18; // [rsp+0h] [rbp-F8h]
void *v19; // [rsp+8h] [rbp-F0h]
void *v20; // [rsp+10h] [rbp-E8h]
void *v21; // [rsp+18h] [rbp-E0h] BYREF
long long v22; // [rsp+20h] [rbp-D8h]
__int128 v23; // [rsp+28h] [rbp-D0h] BYREF
long long v24; // [rsp+38h] [rbp-C0h]
int v25[2]; // [rsp+40h] [rbp-B8h]
void *v26; // [rsp+48h] [rbp-B0h]
void *v27[2]; // [rsp+50h] [rbp-A8h] BYREF
long long v28; // [rsp+60h] [rbp-98h] BYREF
char v29; // [rsp+68h] [rbp-90h]
void *v30; // [rsp+70h] [rbp-88h]
long long v31; // [rsp+78h] [rbp-80h]
int v32[2]; // [rsp+80h] [rbp-78h] BYREF
__int128 v33; // [rsp+90h] [rbp-68h] BYREF
long long v34; // [rsp+A0h] [rbp-58h]
int v35[2]; // [rsp+A8h] [rbp-50h] BYREF
long long v36; // [rsp+B8h] [rbp-40h] BYREF
v19 = (void *)a1;
v20 = (void *)a2;
SchemaConverter::_add_rule(a1, a2, a3, a4);
v5 = (_QWORD *)a4[4];
v6 = (_QWORD *)a4[5];
if ( v5 != v6 )
{
v26 = (void *)(a2 + 40);
*(_QWORD *)v25 = a2 + 48;
v24 = a2 + 200;
do
{
v30 = v32;
v31 = 0LL;
LOBYTE(v32[0]) = 0;
v34 = 0LL;
v33 = 0LL;
v7 = std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,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>>::find(
PRIMITIVE_RULES[abi:cxx11],
v5);
v8 = v7;
if ( v7
|| (v9 = std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,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>>::find(
STRING_FORMAT_RULES[abi:cxx11],
v5),
v8 = v9,
v9) )
{
v10 = std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::find(
(long long)v26,
(long long)v5);
if ( v10 != *(_QWORD *)v25 )
goto LABEL_16;
SchemaConverter::_add_primitive(
(int)v35,
(int)v20,
(int)v5,
v8 + 40,
v11,
v12,
v18,
(int)v19,
v20,
(int)v21,
v22,
v23,
SDWORD2(v23),
v24,
v25[0],
v26,
(int)v27[0],
(long long)v27[1],
v28,
v29);
v13 = *(void **)v35;
if ( *(long long **)v35 == &v36 )
goto LABEL_16;
v14 = v36;
}
else
{
std::operator+<char>((long long)v27, (long long)"Rule ", v5);
v15 = std::string::append(v27, " not known");
v21 = &v23;
v16 = (__int128 *)(v15 + 16);
if ( *(_QWORD *)v15 == v15 + 16 )
{
v23 = *v16;
}
else
{
v21 = *(void **)v15;
*(_QWORD *)&v23 = *(_QWORD *)v16;
}
v22 = *(_QWORD *)(v15 + 8);
*(_QWORD *)v15 = v16;
*(_QWORD *)(v15 + 8) = 0LL;
*(_BYTE *)(v15 + 16) = 0;
std::vector<std::string>::emplace_back<std::string>(v24, (long long)&v21);
if ( v21 != &v23 )
operator delete(v21, v23 + 1);
v13 = v27[0];
if ( v27[0] == &v28 )
goto LABEL_16;
v14 = v28;
}
operator delete(v13, v14 + 1);
LABEL_16:
std::vector<std::string>::~vector(&v33);
if ( v30 != v32 )
operator delete(v30, *(_QWORD *)v32 + 1LL);
v5 += 4;
}
while ( v5 != v6 );
}
return v19;
}
| _add_primitive:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV RBX,RCX
MOV qword ptr [RSP + 0x8],RDI
MOV qword ptr [RSP + 0x10],RSI
CALL 0x001ab600
MOV R15,qword ptr [RBX + 0x20]
MOV R14,qword ptr [RBX + 0x28]
CMP R15,R14
JZ 0x001b0a04
LEA RBX,[RSP + 0x80]
LEA R12,[RSP + 0x90]
MOV RAX,qword ptr [RSP + 0x10]
LEA RCX,[RAX + 0x28]
MOV qword ptr [RSP + 0x48],RCX
LEA RCX,[RAX + 0x30]
MOV qword ptr [RSP + 0x40],RCX
ADD RAX,0xc8
MOV qword ptr [RSP + 0x38],RAX
XOR R13D,R13D
LAB_001b087f:
MOV qword ptr [RSP + 0x70],RBX
MOV qword ptr [RSP + 0x78],R13
MOV byte ptr [RSP + 0x80],0x0
MOV qword ptr [R12 + 0x10],R13
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R12],XMM0
LAB_001b089e:
LEA RDI,[0x1f2768]
MOV RSI,R15
CALL 0x001b5cb6
MOV RBP,RAX
TEST RAX,RAX
JNZ 0x001b08cc
LAB_001b08b5:
LEA RDI,[0x1f27a0]
MOV RSI,R15
CALL 0x001b5cb6
MOV RBP,RAX
TEST RAX,RAX
JZ 0x001b0926
LAB_001b08cc:
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,R15
CALL 0x0013a584
CMP RAX,qword ptr [RSP + 0x40]
JNZ 0x001b09d5
ADD RBP,0x28
LAB_001b08e8:
LEA RDI,[RSP + 0xa8]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,R15
MOV RCX,RBP
CALL 0x001b0816
MOV RDI,qword ptr [RSP + 0xa8]
LEA RAX,[RSP + 0xb8]
CMP RDI,RAX
JZ 0x001b09d5
MOV RSI,qword ptr [RSP + 0xb8]
JMP 0x001b09cd
LAB_001b0926:
LEA RBP,[RSP + 0x50]
MOV RDI,RBP
LEA RSI,[0x1c2ca7]
MOV RDX,R15
CALL 0x001433d6
LAB_001b093d:
MOV RDI,RBP
LEA RSI,[0x1c2cad]
CALL 0x00119ee0
LEA RBP,[RSP + 0x28]
MOV qword ptr [RSP + 0x18],RBP
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001b0974
MOV qword ptr [RSP + 0x18],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x28],RDX
JMP 0x001b097b
LAB_001b0974:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RBP],XMM0
LAB_001b097b:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_001b0993:
MOV RDI,qword ptr [RSP + 0x38]
LEA RSI,[RSP + 0x18]
CALL 0x001241f6
LAB_001b09a2:
MOV RDI,qword ptr [RSP + 0x18]
CMP RDI,RBP
JZ 0x001b09b9
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x001197f0
LAB_001b09b9:
MOV RDI,qword ptr [RSP + 0x50]
LEA RAX,[RSP + 0x60]
CMP RDI,RAX
JZ 0x001b09d5
MOV RSI,qword ptr [RSP + 0x60]
LAB_001b09cd:
INC RSI
CALL 0x001197f0
LAB_001b09d5:
MOV RDI,R12
CALL 0x00123964
MOV RDI,qword ptr [RSP + 0x70]
CMP RDI,RBX
JZ 0x001b09f7
MOV RSI,qword ptr [RSP + 0x80]
INC RSI
CALL 0x001197f0
LAB_001b09f7:
ADD R15,0x20
CMP R15,R14
JNZ 0x001b087f
LAB_001b0a04:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* SchemaConverter::_add_primitive(std::__cxx11::string const&, BuiltinRule const&) */
string * SchemaConverter::_add_primitive(string *param_1,BuiltinRule *param_2)
{
string *psVar1;
long lVar2;
BuiltinRule *pBVar3;
long *plVar4;
long in_RCX;
long *plVar5;
string *psVar6;
long *local_e0;
long local_d8;
long local_d0;
long lStack_c8;
BuiltinRule *local_c0;
BuiltinRule *local_b8;
BuiltinRule *local_b0;
long *local_a8 [2];
long local_98 [2];
int1 *local_88;
int8 local_80;
int1 local_78;
int7 uStack_77;
int8 local_68;
int8 uStack_60;
int8 local_58;
long *local_50 [2];
long local_40 [2];
_add_rule(param_1,(string *)param_2);
psVar6 = *(string **)(in_RCX + 0x20);
psVar1 = *(string **)(in_RCX + 0x28);
if (psVar6 != psVar1) {
local_b0 = param_2 + 0x28;
local_b8 = param_2 + 0x30;
local_c0 = param_2 + 200;
do {
local_80 = 0;
local_78 = 0;
local_58 = 0;
local_68 = 0;
uStack_60 = 0;
local_88 = &local_78;
/* try { // try from 001b089e to 001b08ac has its CatchHandler @ 001b0a5e */
lVar2 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,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>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,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>>
*)PRIMITIVE_RULES_abi_cxx11_,psVar6);
/* try { // try from 001b08b5 to 001b08c3 has its CatchHandler @ 001b0a5a */
if ((lVar2 == 0) &&
(lVar2 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,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>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,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>>
*)STRING_FORMAT_RULES_abi_cxx11_,psVar6), lVar2 == 0)) {
/* try { // try from 001b0926 to 001b093c has its CatchHandler @ 001b0a58 */
std::operator+((char *)local_a8,(string *)"Rule ");
/* try { // try from 001b093d to 001b094b has its CatchHandler @ 001b0a37 */
plVar4 = (long *)std::__cxx11::string::append((char *)local_a8);
plVar5 = plVar4 + 2;
if ((long *)*plVar4 == plVar5) {
local_d0 = *plVar5;
lStack_c8 = plVar4[3];
local_e0 = &local_d0;
}
else {
local_d0 = *plVar5;
local_e0 = (long *)*plVar4;
}
local_d8 = plVar4[1];
*plVar4 = (long)plVar5;
plVar4[1] = 0;
*(int1 *)(plVar4 + 2) = 0;
/* try { // try from 001b0993 to 001b09a1 has its CatchHandler @ 001b0a1b */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_c0,
(string *)&local_e0);
if (local_e0 != &local_d0) {
operator_delete(local_e0,local_d0 + 1);
}
lVar2 = local_98[0];
plVar4 = local_a8[0];
if (local_a8[0] != local_98) {
LAB_001b09cd:
operator_delete(plVar4,lVar2 + 1);
}
}
else {
/* try { // try from 001b08cc to 001b08d8 has its CatchHandler @ 001b0a5c */
pBVar3 = (BuiltinRule *)
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::find((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)local_b0,psVar6);
/* try { // try from 001b08e8 to 001b08ff has its CatchHandler @ 001b0a5e */
if ((pBVar3 == local_b8) &&
(_add_primitive((string *)local_50,param_2), lVar2 = local_40[0], plVar4 = local_50[0],
local_50[0] != local_40)) goto LAB_001b09cd;
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_68);
if (local_88 != &local_78) {
operator_delete(local_88,CONCAT71(uStack_77,local_78) + 1);
}
psVar6 = psVar6 + 0x20;
} while (psVar6 != psVar1);
}
return param_1;
}
| |
24,150 | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_array() | monkey531[P]llama/common/json.hpp | bool end_array()
{
bool keep = true;
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
if (keep)
{
ref_stack.back()->set_parents();
}
else
{
// discard array
*ref_stack.back() = discarded;
}
}
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
// remove discarded value
if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->pop_back();
}
return true;
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_array():
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movb $0x1, 0x2f(%rsp)
addq $0x8, %rdi
callq 0xb9370
cmpq $0x0, (%rax)
je 0xb8632
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x80, %rax
movq %rax, (%rsp)
addq $0x8, %rdi
callq 0xb8d80
movq 0x10(%rsp), %rdi
subl $0x1, %eax
movl %eax, 0xc(%rsp)
addq $0x8, %rdi
callq 0xb9370
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movq (%rax), %rcx
movl $0x3, %edx
callq 0xb8d20
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
je 0xb85f5
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9370
movq (%rax), %rdi
callq 0x9fad0
jmp 0xb8630
movq 0x10(%rsp), %rsi
addq $0xa8, %rsi
leaq 0x18(%rsp), %rdi
callq 0x6d330
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9370
movq (%rax), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6ce50
leaq 0x18(%rsp), %rdi
callq 0x6ced0
jmp 0xb8632
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xb97c0
testb $0x1, %al
jne 0xb8646
jmp 0xb8667
leaq 0xff298(%rip), %rdi # 0x1b78e5
movl $0x1bf5, %esi # imm = 0x1BF5
leaq 0xfbc33(%rip), %rdx # 0x1b428c
leaq 0x100790(%rip), %rcx # 0x1b8df0
movb $0x0, %al
callq 0x4fbf0
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0xb8c00
testb $0x1, %al
jne 0xb867b
jmp 0xb869c
leaq 0xff263(%rip), %rdi # 0x1b78e5
movl $0x1bf6, %esi # imm = 0x1BF6
leaq 0xfbbfe(%rip), %rdx # 0x1b428c
leaq 0x1006d5(%rip), %rcx # 0x1b8d6a
movb $0x0, %al
callq 0x4fbf0
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xba460
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0xb8d00
testb $0x1, 0x2f(%rsp)
jne 0xb8707
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xb97c0
testb $0x1, %al
jne 0xb8707
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9370
movq (%rax), %rdi
callq 0xa2940
testb $0x1, %al
jne 0xb86ed
jmp 0xb8707
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9370
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0xa2920
movb $0x1, %al
andb $0x1, %al
addq $0x38, %rsp
retq
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9end_arrayEv:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov rdi, [rsp+38h+var_8]
mov [rsp+38h+var_28], rdi
mov [rsp+38h+var_9], 1
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
cmp qword ptr [rax], 0
jz loc_B8632
mov rdi, [rsp+38h+var_28]
mov rax, rdi
add rax, 80h
mov [rsp+38h+var_38], rax
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4sizeEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::size(void)
mov rdi, [rsp+38h+var_28]
sub eax, 1
mov [rsp+38h+var_2C], eax
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rsp+38h+var_38]
mov esi, [rsp+38h+var_2C]
mov rcx, [rax]
mov edx, 3
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
and al, 1
mov [rsp+38h+var_9], al
test [rsp+38h+var_9], 1
jz short loc_B85F5
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE11set_parentsEv; 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>::set_parents(void)
jmp short loc_B8630
loc_B85F5:
mov rsi, [rsp+38h+var_28]
add rsi, 0A8h
lea rdi, [rsp+38h+var_20]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
lea rsi, [rsp+38h+var_20]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(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>)
lea rdi, [rsp+38h+var_20]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; 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()
loc_B8630:
jmp short $+2
loc_B8632:
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE5emptyEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::empty(void)
test al, 1
jnz short loc_B8646
jmp short loc_B8667
loc_B8646:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1BF5h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackEmpty; "!ref_stack.empty()"
mov al, 0
call _ggml_abort
loc_B8667:
mov rdi, [rsp+38h+var_28]
add rdi, 20h ; ' '
call _ZNKSt6vectorIbSaIbEE5emptyEv; std::vector<bool>::empty(void)
test al, 1
jnz short loc_B867B
jmp short loc_B869C
loc_B867B:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1BF6h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov al, 0
call _ggml_abort
loc_B869C:
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE8pop_backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::pop_back(void)
mov rdi, [rsp+38h+var_28]
add rdi, 20h ; ' '
call _ZNSt6vectorIbSaIbEE8pop_backEv; std::vector<bool>::pop_back(void)
test [rsp+38h+var_9], 1
jnz short loc_B8707
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE5emptyEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::empty(void)
test al, 1
jnz short loc_B8707
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8is_arrayEv; 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>::is_array(void)
test al, 1
jnz short loc_B86ED
jmp short loc_B8707
loc_B86ED:
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rax, [rax]
mov rdi, [rax+8]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE8pop_backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::pop_back(void)
loc_B8707:
mov al, 1
and al, 1
add rsp, 38h
retn
| char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::end_array(
long long a1)
{
_QWORD *v1; // rax
long long *v2; // rax
_BYTE **v3; // rax
long long v4; // rax
unsigned int v6; // [rsp+Ch] [rbp-2Ch]
_BYTE v7[23]; // [rsp+18h] [rbp-20h] BYREF
char v8; // [rsp+2Fh] [rbp-9h]
long long v9; // [rsp+30h] [rbp-8h]
v9 = a1;
v8 = 1;
if ( *(_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::back(a1 + 8) )
{
v6 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::size(a1 + 8)
- 1;
v1 = (_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::back(a1 + 8);
v8 = std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()(
a1 + 128,
v6,
3LL,
*v1) & 1;
if ( v8 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::back(a1 + 8);
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>::set_parents();
}
else
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(long long)v7,
a1 + 168);
v2 = (long long *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::back(a1 + 8);
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=(
*v2,
(long long)v7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v7);
}
}
if ( (std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::empty(a1 + 8) & 1) != 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7157LL,
"GGML_ASSERT(%s) failed",
"!ref_stack.empty()");
if ( (std::vector<bool>::empty(a1 + 32) & 1) != 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7158LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::pop_back(a1 + 8);
std::vector<bool>::pop_back(a1 + 32);
if ( (v8 & 1) == 0
&& (std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::empty(a1 + 8) & 1) == 0 )
{
v3 = (_BYTE **)std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::back(a1 + 8);
if ( 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>::is_array(*v3) )
{
v4 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<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> *>>::back(a1 + 8);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::pop_back(*(_QWORD *)(*(_QWORD *)v4 + 8LL));
}
}
return 1;
}
| end_array:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV RDI,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RDI
MOV byte ptr [RSP + 0x2f],0x1
ADD RDI,0x8
CALL 0x001b9370
CMP qword ptr [RAX],0x0
JZ 0x001b8632
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,RDI
ADD RAX,0x80
MOV qword ptr [RSP],RAX
ADD RDI,0x8
CALL 0x001b8d80
MOV RDI,qword ptr [RSP + 0x10]
SUB EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
ADD RDI,0x8
CALL 0x001b9370
MOV RDI,qword ptr [RSP]
MOV ESI,dword ptr [RSP + 0xc]
MOV RCX,qword ptr [RAX]
MOV EDX,0x3
CALL 0x001b8d20
AND AL,0x1
MOV byte ptr [RSP + 0x2f],AL
TEST byte ptr [RSP + 0x2f],0x1
JZ 0x001b85f5
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001b9370
MOV RDI,qword ptr [RAX]
CALL 0x0019fad0
JMP 0x001b8630
LAB_001b85f5:
MOV RSI,qword ptr [RSP + 0x10]
ADD RSI,0xa8
LEA RDI,[RSP + 0x18]
CALL 0x0016d330
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001b9370
MOV RDI,qword ptr [RAX]
LEA RSI,[RSP + 0x18]
CALL 0x0016ce50
LEA RDI,[RSP + 0x18]
CALL 0x0016ced0
LAB_001b8630:
JMP 0x001b8632
LAB_001b8632:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001b97c0
TEST AL,0x1
JNZ 0x001b8646
JMP 0x001b8667
LAB_001b8646:
LEA RDI,[0x2b78e5]
MOV ESI,0x1bf5
LEA RDX,[0x2b428c]
LEA RCX,[0x2b8df0]
MOV AL,0x0
CALL 0x0014fbf0
LAB_001b8667:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x20
CALL 0x001b8c00
TEST AL,0x1
JNZ 0x001b867b
JMP 0x001b869c
LAB_001b867b:
LEA RDI,[0x2b78e5]
MOV ESI,0x1bf6
LEA RDX,[0x2b428c]
LEA RCX,[0x2b8d6a]
MOV AL,0x0
CALL 0x0014fbf0
LAB_001b869c:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001ba460
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x20
CALL 0x001b8d00
TEST byte ptr [RSP + 0x2f],0x1
JNZ 0x001b8707
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001b97c0
TEST AL,0x1
JNZ 0x001b8707
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001b9370
MOV RDI,qword ptr [RAX]
CALL 0x001a2940
TEST AL,0x1
JNZ 0x001b86ed
JMP 0x001b8707
LAB_001b86ed:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001b9370
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001a2920
LAB_001b8707:
MOV AL,0x1
AND AL,0x1
ADD RSP,0x38
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::end_array() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::end_array(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
int iVar1;
long *plVar2;
int8 *puVar3;
ulong uVar4;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_20 [23];
byte local_9;
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*local_8;
local_9 = 1;
local_8 = this;
plVar2 = (long *)std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
if (*plVar2 != 0) {
iVar1 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::size((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
puVar3 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
local_9 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
*)(this + 0x80),iVar1 + -1,3,*puVar3);
local_9 = local_9 & 1;
if (local_9 == 0) {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_20,this + 0xa8);
puVar3 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
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>
*)*puVar3,local_20);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_20);
}
else {
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
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>
::set_parents();
}
}
uVar4 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::empty((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
if ((uVar4 & 1) != 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1bf5,
"GGML_ASSERT(%s) failed","!ref_stack.empty()");
}
uVar4 = std::vector<bool,std::allocator<bool>>::empty
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if ((uVar4 & 1) != 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1bf6,
"GGML_ASSERT(%s) failed","!keep_stack.empty()");
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::pop_back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
std::vector<bool,std::allocator<bool>>::pop_back
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if (((local_9 & 1) == 0) &&
(uVar4 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::empty((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8)), (uVar4 & 1) == 0)) {
puVar3 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
uVar4 = 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>
::is_array((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>
*)*puVar3);
if ((uVar4 & 1) != 0) {
plVar2 = (long *)std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::pop_back(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(*plVar2 + 8));
}
}
return 1;
}
| |
24,151 | skip | eloqsql/unittest/mytap/tap.c | void
skip(int how_many, char const * const fmt, ...)
{
char reason[80];
if (fmt && *fmt)
{
va_list ap;
va_start(ap, fmt);
vsnprintf(reason, sizeof(reason), fmt, ap);
va_end(ap);
}
else
reason[0] = '\0';
while (how_many-- > 0)
{
va_list ap;
memset((char*) &ap, 0, sizeof(ap)); /* Keep compiler happy */
vemit_tap(1, NULL, ap);
emit_dir("skip", reason);
emit_endl();
}
} | O0 | c | skip:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
testb %al, %al
je 0x268e7
movaps %xmm0, -0x130(%rbp)
movaps %xmm1, -0x120(%rbp)
movaps %xmm2, -0x110(%rbp)
movaps %xmm3, -0x100(%rbp)
movaps %xmm4, -0xf0(%rbp)
movaps %xmm5, -0xe0(%rbp)
movaps %xmm6, -0xd0(%rbp)
movaps %xmm7, -0xc0(%rbp)
movq %r9, -0x138(%rbp)
movq %r8, -0x140(%rbp)
movq %rcx, -0x148(%rbp)
movq %rdx, -0x150(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x64(%rbp)
movq %rsi, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
je 0x26973
movq -0x70(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x26973
leaq -0x90(%rbp), %rax
leaq -0x160(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq -0x90(%rbp), %rcx
movl $0x50, %esi
callq 0x25230
leaq -0x90(%rbp), %rax
jmp 0x26977
movb $0x0, -0x60(%rbp)
jmp 0x26979
movl -0x64(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x64(%rbp)
cmpl $0x0, %eax
jle 0x269c8
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x251e0
leaq -0xb0(%rbp), %rdx
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x266f0
leaq -0x60(%rbp), %rsi
leaq 0x54895(%rip), %rdi # 0x7b251
callq 0x267d0
callq 0x26c30
jmp 0x26979
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x269e3
addq $0x160, %rsp # imm = 0x160
popq %rbp
retq
callq 0x253d0
nopl (%rax,%rax)
| skip:
push rbp
mov rbp, rsp
sub rsp, 160h
test al, al
jz short loc_268E7
movaps [rbp+var_130], xmm0
movaps [rbp+var_120], xmm1
movaps [rbp+var_110], xmm2
movaps [rbp+var_100], xmm3
movaps [rbp+var_F0], xmm4
movaps [rbp+var_E0], xmm5
movaps [rbp+var_D0], xmm6
movaps [rbp+var_C0], xmm7
loc_268E7:
mov [rbp+var_138], r9
mov [rbp+var_140], r8
mov [rbp+var_148], rcx
mov [rbp+var_150], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_64], edi
mov [rbp+var_70], rsi
cmp [rbp+var_70], 0
jz short loc_26973
mov rax, [rbp+var_70]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_26973
lea rax, [rbp+var_90]
lea rcx, [rbp+var_160]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
lea rdi, [rbp+var_60]
mov rdx, [rbp+var_70]
lea rcx, [rbp+var_90]
mov esi, 50h ; 'P'
call _vsnprintf
lea rax, [rbp+var_90]
jmp short loc_26977
loc_26973:
mov [rbp+var_60], 0
loc_26977:
jmp short $+2
loc_26979:
mov eax, [rbp+var_64]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_64], ecx
cmp eax, 0
jle short loc_269C8
lea rdi, [rbp+var_B0]
xor esi, esi
mov edx, 18h
call _memset
lea rdx, [rbp+var_B0]
mov edi, 1
xor eax, eax
mov esi, eax
call vemit_tap
lea rsi, [rbp+var_60]
lea rdi, aSkip; "skip"
call emit_dir
call emit_endl
jmp short loc_26979
loc_269C8:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_269E3
add rsp, 160h
pop rbp
retn
loc_269E3:
call ___stack_chk_fail
| unsigned long long skip(int a1, _BYTE *a2, ...)
{
int v2; // eax
_BYTE v4[32]; // [rsp+B0h] [rbp-B0h] BYREF
va_list va; // [rsp+D0h] [rbp-90h] BYREF
_BYTE *v6; // [rsp+F0h] [rbp-70h]
int v7; // [rsp+FCh] [rbp-64h]
char v8[88]; // [rsp+100h] [rbp-60h] BYREF
unsigned long long v9; // [rsp+158h] [rbp-8h]
v9 = __readfsqword(0x28u);
v7 = a1;
v6 = a2;
if ( a2 && *v6 )
{
va_start(va, a2);
vsnprintf(v8, 80LL, v6, va);
}
else
{
v8[0] = 0;
}
while ( 1 )
{
v2 = v7--;
if ( v2 <= 0 )
break;
memset(v4, 0LL, 24LL);
vemit_tap(1, 0LL, (long long)v4);
emit_dir("skip", v8);
emit_endl();
}
return __readfsqword(0x28u);
}
| skip:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x160
TEST AL,AL
JZ 0x001268e7
MOVAPS xmmword ptr [RBP + -0x130],XMM0
MOVAPS xmmword ptr [RBP + -0x120],XMM1
MOVAPS xmmword ptr [RBP + -0x110],XMM2
MOVAPS xmmword ptr [RBP + -0x100],XMM3
MOVAPS xmmword ptr [RBP + -0xf0],XMM4
MOVAPS xmmword ptr [RBP + -0xe0],XMM5
MOVAPS xmmword ptr [RBP + -0xd0],XMM6
MOVAPS xmmword ptr [RBP + -0xc0],XMM7
LAB_001268e7:
MOV qword ptr [RBP + -0x138],R9
MOV qword ptr [RBP + -0x140],R8
MOV qword ptr [RBP + -0x148],RCX
MOV qword ptr [RBP + -0x150],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x64],EDI
MOV qword ptr [RBP + -0x70],RSI
CMP qword ptr [RBP + -0x70],0x0
JZ 0x00126973
MOV RAX,qword ptr [RBP + -0x70]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x00126973
LEA RAX,[RBP + -0x90]
LEA RCX,[RBP + -0x160]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
LEA RDI,[RBP + -0x60]
MOV RDX,qword ptr [RBP + -0x70]
LEA RCX,[RBP + -0x90]
MOV ESI,0x50
CALL 0x00125230
LEA RAX,[RBP + -0x90]
JMP 0x00126977
LAB_00126973:
MOV byte ptr [RBP + -0x60],0x0
LAB_00126977:
JMP 0x00126979
LAB_00126979:
MOV EAX,dword ptr [RBP + -0x64]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x64],ECX
CMP EAX,0x0
JLE 0x001269c8
LEA RDI,[RBP + -0xb0]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x001251e0
LEA RDX,[RBP + -0xb0]
MOV EDI,0x1
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001266f0
LEA RSI,[RBP + -0x60]
LEA RDI,[0x17b251]
CALL 0x001267d0
CALL 0x00126c30
JMP 0x00126979
LAB_001269c8:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001269e3
ADD RSP,0x160
POP RBP
RET
LAB_001269e3:
CALL 0x001253d0
|
void skip(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,int param_9,
char *param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
char in_AL;
long in_FS_OFFSET;
int1 local_168 [16];
int8 local_158;
int8 local_150;
int8 local_148;
int8 local_140;
int8 local_138;
int8 local_128;
int8 local_118;
int8 local_108;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int1 local_b8 [32];
int4 local_98;
int4 local_94;
int1 *local_90;
int1 *local_88;
char *local_78;
int local_6c;
char local_68 [88];
long local_10;
if (in_AL != '\0') {
local_138 = param_1;
local_128 = param_2;
local_118 = param_3;
local_108 = param_4;
local_f8 = param_5;
local_e8 = param_6;
local_d8 = param_7;
local_c8 = param_8;
}
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_158 = param_11;
local_150 = param_12;
local_148 = param_13;
local_140 = param_14;
local_78 = param_10;
local_6c = param_9;
if ((param_10 == (char *)0x0) || (*param_10 == '\0')) {
local_68[0] = '\0';
}
else {
local_88 = local_168;
local_90 = &stack0x00000008;
local_94 = 0x30;
local_98 = 0x10;
vsnprintf(local_68,0x50,param_10,&local_98);
}
while (0 < local_6c) {
local_6c = local_6c + -1;
memset(local_b8,0,0x18);
vemit_tap(1,0,local_b8);
emit_dir(&DAT_0017b251);
emit_endl();
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
local_6c = local_6c + -1;
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
| |
24,152 | get_collation_number_internal | eloqsql/mysys/charset.c | static uint
get_collation_number_internal(const char *name)
{
CHARSET_INFO **cs;
for (cs= all_charsets;
cs < all_charsets + array_elements(all_charsets);
cs++)
{
if (cs[0] && cs[0]->coll_name.str &&
!my_strcasecmp(&my_charset_latin1, cs[0]->coll_name.str, name))
return cs[0]->number;
}
return 0;
} | O0 | c | get_collation_number_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x35e97d(%rip), %rax # 0x391e10
movq %rax, -0x18(%rbp)
leaq 0x35e972(%rip), %rax # 0x391e10
addq $0x4000, %rax # imm = 0x4000
cmpq %rax, -0x18(%rbp)
jae 0x3350f
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x334ff
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x334ff
leaq 0x24c967(%rip), %rax # 0x27fe30
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq 0x20(%rcx), %rsi
movq -0x10(%rbp), %rdx
leaq 0x24c946(%rip), %rdi # 0x27fe30
callq *%rax
cmpl $0x0, %eax
jne 0x334ff
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x33516
jmp 0x33501
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x33497
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| get_collation_number_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
lea rax, all_charsets
mov [rbp+var_18], rax
loc_33497:
lea rax, all_charsets
add rax, 4000h
cmp [rbp+var_18], rax
jnb short loc_3350F
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jz short loc_334FF
mov rax, [rbp+var_18]
mov rax, [rax]
cmp qword ptr [rax+20h], 0
jz short loc_334FF
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
mov rsi, [rcx+20h]
mov rdx, [rbp+var_10]
lea rdi, my_charset_latin1
call rax
cmp eax, 0
jnz short loc_334FF
mov rax, [rbp+var_18]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_4], eax
jmp short loc_33516
loc_334FF:
jmp short $+2
loc_33501:
mov rax, [rbp+var_18]
add rax, 8
mov [rbp+var_18], rax
jmp short loc_33497
loc_3350F:
mov [rbp+var_4], 0
loc_33516:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long get_collation_number_internal(long long a1)
{
unsigned int **i; // [rsp+8h] [rbp-18h]
for ( i = (unsigned int **)all_charsets; i < &all_charsets[2048]; ++i )
{
if ( *i
&& *((_QWORD *)*i + 4)
&& !(*(unsigned int ( **)(void *, _QWORD, long long))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*((_QWORD *)*i + 4),
a1) )
{
return **i;
}
}
return 0;
}
| get_collation_number_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[0x491e10]
MOV qword ptr [RBP + -0x18],RAX
LAB_00133497:
LEA RAX,[0x491e10]
ADD RAX,0x4000
CMP qword ptr [RBP + -0x18],RAX
JNC 0x0013350f
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX],0x0
JZ 0x001334ff
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x001334ff
LEA RAX,[0x37fe30]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOV RSI,qword ptr [RCX + 0x20]
MOV RDX,qword ptr [RBP + -0x10]
LEA RDI,[0x37fe30]
CALL RAX
CMP EAX,0x0
JNZ 0x001334ff
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00133516
LAB_001334ff:
JMP 0x00133501
LAB_00133501:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x8
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00133497
LAB_0013350f:
MOV dword ptr [RBP + -0x4],0x0
LAB_00133516:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 get_collation_number_internal(int8 param_1)
{
int iVar1;
long *local_20;
local_20 = &all_charsets;
while( true ) {
if ((long *)0x495e0f < local_20) {
return 0;
}
if (((*local_20 != 0) && (*(long *)(*local_20 + 0x20) != 0)) &&
(iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_0037fef0 + 0x40))
(&my_charset_latin1,*(int8 *)(*local_20 + 0x20),param_1), iVar1 == 0
)) break;
local_20 = local_20 + 1;
}
return *(int4 *)*local_20;
}
| |
24,153 | ma_once_end_block_record | eloqsql/storage/maria/ma_blockrec.c | my_bool _ma_once_end_block_record(MARIA_SHARE *share)
{
int res= _ma_bitmap_end(share);
if (share->bitmap.file.file >= 0)
{
if (flush_pagecache_blocks(share->pagecache, &share->bitmap.file,
share->deleting ? FLUSH_IGNORE_CHANGED : FLUSH_RELEASE))
res= 1;
/*
File must be synced as it is going out of the maria_open_list and so
becoming unknown to Checkpoint.
*/
if (!share->s3_path)
{
if (share->now_transactional &&
mysql_file_sync(share->bitmap.file.file, MYF(MY_WME)))
res= 1;
if (mysql_file_close(share->bitmap.file.file, MYF(MY_WME)))
res= 1;
}
/*
Trivial assignment to guard against multiple invocations
(May happen if file are closed but we want to keep the maria object
around a bit longer)
*/
share->bitmap.file.file= -1;
}
if (share->id != 0)
{
/*
We de-assign the id even though index has not been flushed, this is ok
as close_lock serializes us with a Checkpoint looking at our share.
*/
translog_deassign_id_from_share(share);
}
return res;
} | O0 | c | ma_once_end_block_record:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x64370
movsbl %al, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xa60(%rax)
jl 0x56700
movq -0x8(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0xa10, %rsi # imm = 0xA10
addq $0x40, %rsi
movq -0x8(%rbp), %rax
movsbl 0x7ea(%rax), %ecx
movl $0x1, %edx
movl $0x2, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x40e70
cmpl $0x0, %eax
je 0x5667a
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x798(%rax)
jne 0x566f2
movq -0x8(%rbp), %rax
movsbl 0x7e7(%rax), %eax
cmpl $0x0, %eax
je 0x566c4
movq -0x8(%rbp), %rax
movl 0xa60(%rax), %edx
leaq 0x10562b(%rip), %rdi # 0x15bcd4
movl $0x1cd, %esi # imm = 0x1CD
movl $0x10, %ecx
callq 0x56730
cmpl $0x0, %eax
je 0x566c4
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0xa60(%rax), %edx
leaq 0x1055ff(%rip), %rdi # 0x15bcd4
movl $0x1cf, %esi # imm = 0x1CF
movl $0x10, %ecx
callq 0x56810
cmpl $0x0, %eax
je 0x566f0
movl $0x1, -0xc(%rbp)
jmp 0x566f2
movq -0x8(%rbp), %rax
movl $0xffffffff, 0xa60(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movzwl 0x620(%rax), %eax
cmpl $0x0, %eax
je 0x56719
movq -0x8(%rbp), %rdi
callq 0x36d00
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_once_end_block_record:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
call _ma_bitmap_end
movsx eax, al
mov [rbp+var_C], eax
mov rax, [rbp+var_8]
cmp dword ptr [rax+0A60h], 0
jl loc_56700
mov rax, [rbp+var_8]
mov rdi, [rax+600h]
mov rsi, [rbp+var_8]
add rsi, 0A10h
add rsi, 40h ; '@'
mov rax, [rbp+var_8]
movsx ecx, byte ptr [rax+7EAh]
mov edx, 1
mov eax, 2
cmp ecx, 0
cmovnz edx, eax
xor eax, eax
mov r8d, eax
mov rcx, r8
call flush_pagecache_blocks_with_filter
cmp eax, 0
jz short loc_5667A
mov [rbp+var_C], 1
loc_5667A:
mov rax, [rbp+var_8]
cmp qword ptr [rax+798h], 0
jnz short loc_566F2
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax+7E7h]
cmp eax, 0
jz short loc_566C4
mov rax, [rbp+var_8]
mov edx, [rax+0A60h]
lea rdi, aWorkspaceLlm4b_10; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 1CDh
mov ecx, 10h
call inline_mysql_file_sync_2
cmp eax, 0
jz short loc_566C4
mov [rbp+var_C], 1
loc_566C4:
mov rax, [rbp+var_8]
mov edx, [rax+0A60h]
lea rdi, aWorkspaceLlm4b_10; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 1CFh
mov ecx, 10h
call inline_mysql_file_close_1
cmp eax, 0
jz short loc_566F0
mov [rbp+var_C], 1
loc_566F0:
jmp short $+2
loc_566F2:
mov rax, [rbp+var_8]
mov dword ptr [rax+0A60h], 0FFFFFFFFh
loc_56700:
mov rax, [rbp+var_8]
movzx eax, word ptr [rax+620h]
cmp eax, 0
jz short loc_56719
mov rdi, [rbp+var_8]
call translog_deassign_id_from_share
loc_56719:
mov eax, [rbp+var_C]
add rsp, 10h
pop rbp
retn
| long long ma_once_end_block_record(long long a1)
{
unsigned int v1; // edx
unsigned int v3; // [rsp+4h] [rbp-Ch]
v3 = (char)ma_bitmap_end(a1);
if ( *(int *)(a1 + 2656) >= 0 )
{
v1 = 1;
if ( *(_BYTE *)(a1 + 2026) )
v1 = 2;
if ( (unsigned int)flush_pagecache_blocks_with_filter(*(_QWORD *)(a1 + 1536), a1 + 2640, v1, 0LL, 0LL) )
v3 = 1;
if ( !*(_QWORD *)(a1 + 1944) )
{
if ( *(_BYTE *)(a1 + 2023)
&& (unsigned int)inline_mysql_file_sync_2(
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",
461LL,
*(unsigned int *)(a1 + 2656),
16LL) )
{
v3 = 1;
}
if ( (unsigned int)inline_mysql_file_close_1(
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",
463LL,
*(unsigned int *)(a1 + 2656),
16LL) )
v3 = 1;
}
*(_DWORD *)(a1 + 2656) = -1;
}
if ( *(_WORD *)(a1 + 1568) )
translog_deassign_id_from_share(a1);
return v3;
}
| _ma_once_end_block_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00164370
MOVSX EAX,AL
MOV dword ptr [RBP + -0xc],EAX
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0xa60],0x0
JL 0x00156700
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xa10
ADD RSI,0x40
MOV RAX,qword ptr [RBP + -0x8]
MOVSX ECX,byte ptr [RAX + 0x7ea]
MOV EDX,0x1
MOV EAX,0x2
CMP ECX,0x0
CMOVNZ EDX,EAX
XOR EAX,EAX
MOV R8D,EAX
MOV RCX,R8
CALL 0x00140e70
CMP EAX,0x0
JZ 0x0015667a
MOV dword ptr [RBP + -0xc],0x1
LAB_0015667a:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x798],0x0
JNZ 0x001566f2
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + 0x7e7]
CMP EAX,0x0
JZ 0x001566c4
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RAX + 0xa60]
LEA RDI,[0x25bcd4]
MOV ESI,0x1cd
MOV ECX,0x10
CALL 0x00156730
CMP EAX,0x0
JZ 0x001566c4
MOV dword ptr [RBP + -0xc],0x1
LAB_001566c4:
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RAX + 0xa60]
LEA RDI,[0x25bcd4]
MOV ESI,0x1cf
MOV ECX,0x10
CALL 0x00156810
CMP EAX,0x0
JZ 0x001566f0
MOV dword ptr [RBP + -0xc],0x1
LAB_001566f0:
JMP 0x001566f2
LAB_001566f2:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xa60],0xffffffff
LAB_00156700:
MOV RAX,qword ptr [RBP + -0x8]
MOVZX EAX,word ptr [RAX + 0x620]
CMP EAX,0x0
JZ 0x00156719
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00136d00
LAB_00156719:
MOV EAX,dword ptr [RBP + -0xc]
ADD RSP,0x10
POP RBP
RET
|
int _ma_once_end_block_record(long param_1)
{
char cVar1;
int iVar2;
int8 uVar3;
int local_14;
cVar1 = _ma_bitmap_end(param_1);
local_14 = (int)cVar1;
if (-1 < *(int *)(param_1 + 0xa60)) {
uVar3 = 1;
if (*(char *)(param_1 + 0x7ea) != '\0') {
uVar3 = 2;
}
iVar2 = flush_pagecache_blocks_with_filter
(*(int8 *)(param_1 + 0x600),param_1 + 0xa50,uVar3,0);
if (iVar2 != 0) {
local_14 = 1;
}
if (*(long *)(param_1 + 0x798) == 0) {
if ((*(char *)(param_1 + 0x7e7) != '\0') &&
(iVar2 = inline_mysql_file_sync
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",
0x1cd,*(int4 *)(param_1 + 0xa60),0x10), iVar2 != 0)) {
local_14 = 1;
}
iVar2 = inline_mysql_file_close
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",
0x1cf,*(int4 *)(param_1 + 0xa60),0x10);
if (iVar2 != 0) {
local_14 = 1;
}
}
*(int4 *)(param_1 + 0xa60) = 0xffffffff;
}
if (*(short *)(param_1 + 0x620) != 0) {
translog_deassign_id_from_share(param_1);
}
return local_14;
}
| |
24,154 | 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>::at(unsigned long) | monkey531[P]llama/common/json.hpp | reference at(size_type idx)
{
// at only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
JSON_TRY
{
return set_parent(m_data.m_value.array->at(idx));
}
JSON_CATCH (std::out_of_range&)
{
// create better exception explanation
JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
}
} | O2 | 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>::at(unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpb $0x2, (%rdi)
jne 0x7da7b
movq %rsi, %r12
movq 0x8(%rbx), %rdi
callq 0x7dd44
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x24460
movq %rax, %r14
movq %rbx, %rdi
callq 0x434f0
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x39285(%rip), %rsi # 0xb6d22
movq %rsp, %rdi
callq 0x7ddd5
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0x130, %esi # imm = 0x130
movq %rbx, %rcx
callq 0x433a4
xorl %ebp, %ebp
leaq 0x80474(%rip), %rsi # 0xfdf38
leaq -0x3da4b(%rip), %rdx # 0x40080
movq %r14, %rdi
callq 0x24ee0
jmp 0x7db4a
movq %rax, %r15
cmpl $0x1, %edx
jne 0x7dba5
movq %r15, %rdi
callq 0x24380
pushq $0x20
popq %rdi
callq 0x24460
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x41d9b
leaq 0x391fc(%rip), %rsi # 0xb6d04
leaq 0x39202(%rip), %rcx # 0xb6d11
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x7dd65
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0x191, %esi # imm = 0x191
movq %rbx, %rcx
callq 0x41c50
xorl %ebp, %ebp
leaq 0x8037d(%rip), %rsi # 0xfdeb8
leaq -0x3dac2(%rip), %rdx # 0x40080
movq %r14, %rdi
callq 0x24ee0
movq %rax, %r15
movq %rsp, %rdi
callq 0x251b8
jmp 0x7db5d
movq %rax, %r15
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x251b8
testb %bpl, %bpl
jne 0x7db71
jmp 0x7db79
movq %rax, %r15
movq %r14, %rdi
callq 0x24670
callq 0x24e30
jmp 0x7dba5
movq %rax, %rdi
callq 0x27af1
movq %rax, %r15
movq %rsp, %rdi
callq 0x251b8
testb %bpl, %bpl
jne 0x7db9d
jmp 0x7dba5
movq %rax, %r15
movq %r14, %rdi
callq 0x24670
movq %r15, %rdi
callq 0x24f60
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atEm:
push rbp; char
push r15; int
push r14; int
push r12; int
push rbx; char
sub rsp, 40h
mov rbx, rdi
cmp byte ptr [rdi], 2
jnz short loc_7DA7B
mov r12, rsi
mov rdi, [rbx+8]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE2atEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::at(ulong)
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_7DA7B:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+68h+var_48]
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, r14; this
mov esi, 130h; int
mov rcx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
| 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>::at(
long long a1)
{
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // r14
_QWORD v3[13]; // [rsp+0h] [rbp-68h] BYREF
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v3[4] = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(v3, "cannot use at() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
304,
(long long)v3);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::at(*(_QWORD *)(a1 + 8));
}
| at:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
CMP byte ptr [RDI],0x2
JNZ 0x0017da7b
MOV R12,RSI
MOV RDI,qword ptr [RBX + 0x8]
LAB_0017da69:
CALL 0x0017dd44
LAB_0017da6e:
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0017da7b:
PUSH 0x20
POP RDI
CALL 0x00124460
MOV R14,RAX
MOV RDI,RBX
CALL 0x001434f0
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_0017da96:
LEA RSI,[0x1b6d22]
MOV RDI,RSP
CALL 0x0017ddd5
MOV BPL,0x1
LAB_0017daa8:
MOV RDX,RSP
MOV RDI,R14
MOV ESI,0x130
MOV RCX,RBX
CALL 0x001433a4
XOR EBP,EBP
LEA RSI,[0x1fdf38]
LEA RDX,[0x140080]
MOV RDI,R14
CALL 0x00124ee0
|
/* 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>::at(unsigned long) */
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>
::at(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,ulong param_1)
{
int8 uVar1;
detail adStack_68 [32];
char *local_48 [4];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
/* try { // try from 0017da69 to 0017da6d has its CatchHandler @ 0017dad5 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::at(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8),param_1);
return;
}
uVar1 = __cxa_allocate_exception(0x20);
local_48[0] = (char *)type_name(this);
/* try { // try from 0017da96 to 0017daa4 has its CatchHandler @ 0017db9a */
detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(adStack_68,"cannot use at() with ",local_48);
/* try { // try from 0017daa8 to 0017dad2 has its CatchHandler @ 0017db88 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x130,adStack_68,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
24,155 | translog_get_file_size | eloqsql/storage/maria/ma_loghandler.c | uint32 translog_get_file_size()
{
uint32 res;
translog_lock();
res= log_descriptor.log_file_max_size;
translog_unlock();
return (res);
} | O3 | c | translog_get_file_size:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x442bb
movl 0x3b3ecb(%rip), %ebx # 0x3fd170
movq 0xbb4b2c(%rip), %r14 # 0xbfddd8
movq 0x1000d0(%r14), %rdi
testq %rdi, %rdi
jne 0x492ce
addq $0x100090, %r14 # imm = 0x100090
movq %r14, %rdi
callq 0x291e0
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x33bd3b(%rip), %rax # 0x385010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x492b8
| translog_get_file_size:
push rbp
mov rbp, rsp
push r14
push rbx
call translog_lock
mov ebx, cs:dword_3FD170
mov r14, qword ptr cs:xmmword_BFDDD0+8
mov rdi, ds:qword_1000D0[r14]
test rdi, rdi
jnz short loc_492CE
loc_492B8:
add r14, 100090h
mov rdi, r14
call _pthread_mutex_unlock
mov eax, ebx
pop rbx
pop r14
pop rbp
retn
loc_492CE:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_492B8
| long long translog_get_file_size()
{
unsigned int v0; // ebx
long long v1; // r14
translog_lock();
v0 = dword_3FD170;
v1 = *((_QWORD *)&xmmword_BFDDD0 + 1);
if ( *(long long *)((char *)&qword_1000D0 + *((_QWORD *)&xmmword_BFDDD0 + 1)) )
PSI_server[44]();
pthread_mutex_unlock(v1 + 1048720);
return v0;
}
| translog_get_file_size:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
CALL 0x001442bb
MOV EBX,dword ptr [0x004fd170]
MOV R14,qword ptr [0x00cfddd8]
MOV RDI,qword ptr [R14 + 0x1000d0]
TEST RDI,RDI
JNZ 0x001492ce
LAB_001492b8:
ADD R14,0x100090
MOV RDI,R14
CALL 0x001291e0
MOV EAX,EBX
POP RBX
POP R14
POP RBP
RET
LAB_001492ce:
LEA RAX,[0x485010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001492b8
|
int4 translog_get_file_size(void)
{
int4 uVar1;
long lVar2;
translog_lock();
lVar2 = DAT_00cfddd8;
uVar1 = DAT_004fd170;
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_filesz + DAT_00cfddd8) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + lVar2));
return uVar1;
}
| |
24,156 | set_default_charset_by_name | eloqsql/libmariadb/libmariadb/mariadb_charset.c | my_bool set_default_charset_by_name(const char *cs_name, myf flags __attribute__((unused)))
{
MARIADB_CHARSET_INFO *new_charset;
new_charset = mysql_get_charset_by_name(cs_name);
if (!new_charset)
{
return(TRUE); /* error */
}
ma_default_charset_info = new_charset;
return(FALSE);
} | O0 | c | set_default_charset_by_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61590
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x61669
movb $0x1, -0x1(%rbp)
jmp 0x6167b
movq -0x20(%rbp), %rcx
leaq 0x216e4(%rip), %rax # 0x82d58
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| set_default_charset_by_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov rdi, [rbp+var_10]
call mysql_get_charset_by_name
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jnz short loc_61669
mov [rbp+var_1], 1
jmp short loc_6167B
loc_61669:
mov rcx, [rbp+var_20]
lea rax, ma_default_charset_info
mov [rax], rcx
mov [rbp+var_1], 0
loc_6167B:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char set_default_charset_by_name(long long a1)
{
char *charset_by_name; // [rsp+0h] [rbp-20h]
charset_by_name = mysql_get_charset_by_name(a1);
if ( !charset_by_name )
return 1;
ma_default_charset_info = charset_by_name;
return 0;
}
| set_default_charset_by_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00161590
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x00161669
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0016167b
LAB_00161669:
MOV RCX,qword ptr [RBP + -0x20]
LEA RAX,[0x182d58]
MOV qword ptr [RAX],RCX
MOV byte ptr [RBP + -0x1],0x0
LAB_0016167b:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int8 set_default_charset_by_name(int8 param_1)
{
long lVar1;
int8 *puVar2;
bool local_9;
lVar1 = mysql_get_charset_by_name(param_1);
if (lVar1 != 0) {
puVar2 = &ma_default_charset_info;
ma_default_charset_info = lVar1;
}
else {
puVar2 = (int8 *)0x0;
}
local_9 = lVar1 == 0;
return CONCAT71((int7)((ulong)puVar2 >> 8),local_9);
}
| |
24,157 | blst_miller_loop_n | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/pairing.c | void blst_miller_loop_n(vec384fp12 out, const POINTonE2_affine *const Qs[],
const POINTonE1_affine *const Ps[],
size_t n)
{ /* ~10KB of stack storage */
POINTonE2 T[MILLER_LOOP_N_MAX];
POINTonE2_affine Q[MILLER_LOOP_N_MAX];
POINTonE1_affine Px2[MILLER_LOOP_N_MAX];
const POINTonE2_affine *Qptr = NULL;
const POINTonE1_affine *Pptr = NULL;
size_t i, j;
for (i = 0, j = 0; j < n; j++) {
Qptr = *Qs ? *Qs++ : Qptr+1;
Pptr = *Ps ? *Ps++ : Pptr+1;
/* Move common expression from line evaluation to line_by_Px2. */
add_fp(Px2[i].X, Pptr->X, Pptr->X);
neg_fp(Px2[i].X, Px2[i].X);
add_fp(Px2[i].Y, Pptr->Y, Pptr->Y);
vec_copy(Q[i].X, Qptr->X, 2*sizeof(Q[i].X));
vec_copy(T[i].X, Qptr->X, 2*sizeof(T[i].X));
vec_copy(T[i].Z, BLS12_381_Rx.p2, sizeof(T[i].Z));
if (++i == MILLER_LOOP_N_MAX || j == n-1) {
vec384fp12 tmp;
vec384fp6 *ret = j < MILLER_LOOP_N_MAX ? out : tmp;
/* first step is ret = 1^2*line, which is just ret = line */
start_dbl_n(ret, T, Px2, i); /* 0x2 */
add_n_dbl_n(ret, T, Q, Px2, i, 2); /* ..0xc */
add_n_dbl_n(ret, T, Q, Px2, i, 3); /* ..0x68 */
add_n_dbl_n(ret, T, Q, Px2, i, 9); /* ..0xd200 */
add_n_dbl_n(ret, T, Q, Px2, i, 32); /* ..0xd20100000000 */
add_n_dbl_n(ret, T, Q, Px2, i, 16); /* ..0xd201000000010000 */
conjugate_fp12(ret); /* account for z being negative */
if (j >= MILLER_LOOP_N_MAX)
mul_fp12(out, out, ret);
i = 0;
}
}
} | O0 | c | blst_miller_loop_n:
pushq %rbp
movq %rsp, %rbp
subq $0x26a0, %rsp # imm = 0x26A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x2428(%rbp)
movq $0x0, -0x2430(%rbp)
movq $0x0, -0x2438(%rbp)
movq $0x0, -0x2440(%rbp)
movq -0x2440(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2a919
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2a5fd
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x2690(%rbp)
jmp 0x2a611
movq -0x2428(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x2690(%rbp)
movq -0x2690(%rbp), %rax
movq %rax, -0x2428(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2a644
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x2698(%rbp)
jmp 0x2a656
movq -0x2430(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x2698(%rbp)
movq -0x2698(%rbp), %rax
movq %rax, -0x2430(%rbp)
leaq -0x2420(%rbp), %rdi
imulq $0x60, -0x2438(%rbp), %rax
addq %rax, %rdi
movq -0x2430(%rbp), %rsi
movq -0x2430(%rbp), %rdx
callq 0x2a930
leaq -0x2420(%rbp), %rdi
imulq $0x60, -0x2438(%rbp), %rax
addq %rax, %rdi
leaq -0x2420(%rbp), %rsi
imulq $0x60, -0x2438(%rbp), %rax
addq %rax, %rsi
movl $0x1, %edx
callq 0x2a970
leaq -0x2420(%rbp), %rdi
imulq $0x60, -0x2438(%rbp), %rax
addq %rax, %rdi
addq $0x30, %rdi
movq -0x2430(%rbp), %rsi
addq $0x30, %rsi
movq -0x2430(%rbp), %rdx
addq $0x30, %rdx
callq 0x2a930
leaq -0x1e20(%rbp), %rdi
imulq $0xc0, -0x2438(%rbp), %rax
addq %rax, %rdi
movq -0x2428(%rbp), %rsi
movl $0xc0, %edx
callq 0x23620
leaq -0x1220(%rbp), %rdi
imulq $0x120, -0x2438(%rbp), %rax # imm = 0x120
addq %rax, %rdi
movq -0x2428(%rbp), %rsi
movl $0xc0, %edx
callq 0x23620
leaq -0x1220(%rbp), %rdi
imulq $0x120, -0x2438(%rbp), %rax # imm = 0x120
addq %rax, %rdi
addq $0xc0, %rdi
leaq 0x2a5d1(%rip), %rsi # 0x54d28
movl $0x60, %edx
callq 0x23620
movq -0x2438(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x2438(%rbp)
cmpq $0x10, %rax
je 0x2a791
movq -0x2440(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x2a900
cmpq $0x10, -0x2440(%rbp)
jae 0x2a7a8
movq -0x8(%rbp), %rax
movq %rax, -0x26a0(%rbp)
jmp 0x2a7b6
leaq -0x2680(%rbp), %rax
movq %rax, -0x26a0(%rbp)
movq -0x26a0(%rbp), %rax
movq %rax, -0x2688(%rbp)
movq -0x2688(%rbp), %rdi
leaq -0x1220(%rbp), %rsi
leaq -0x2420(%rbp), %rdx
movq -0x2438(%rbp), %rcx
callq 0x2a9b0
movq -0x2688(%rbp), %rdi
leaq -0x1220(%rbp), %rsi
leaq -0x1e20(%rbp), %rdx
leaq -0x2420(%rbp), %rcx
movq -0x2438(%rbp), %r8
movl $0x2, %r9d
callq 0x2aac0
movq -0x2688(%rbp), %rdi
leaq -0x1220(%rbp), %rsi
leaq -0x1e20(%rbp), %rdx
leaq -0x2420(%rbp), %rcx
movq -0x2438(%rbp), %r8
movl $0x3, %r9d
callq 0x2aac0
movq -0x2688(%rbp), %rdi
leaq -0x1220(%rbp), %rsi
leaq -0x1e20(%rbp), %rdx
leaq -0x2420(%rbp), %rcx
movq -0x2438(%rbp), %r8
movl $0x9, %r9d
callq 0x2aac0
movq -0x2688(%rbp), %rdi
leaq -0x1220(%rbp), %rsi
leaq -0x1e20(%rbp), %rdx
leaq -0x2420(%rbp), %rcx
movq -0x2438(%rbp), %r8
movl $0x20, %r9d
callq 0x2aac0
movq -0x2688(%rbp), %rdi
leaq -0x1220(%rbp), %rsi
leaq -0x1e20(%rbp), %rdx
leaq -0x2420(%rbp), %rcx
movq -0x2438(%rbp), %r8
movl $0x10, %r9d
callq 0x2aac0
movq -0x2688(%rbp), %rdi
callq 0x29d90
cmpq $0x10, -0x2440(%rbp)
jb 0x2a8f5
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x2688(%rbp), %rdx
callq 0x299e0
movq $0x0, -0x2438(%rbp)
jmp 0x2a902
movq -0x2440(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x2440(%rbp)
jmp 0x2a5c7
addq $0x26a0, %rsp # imm = 0x26A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| blst_miller_loop_n:
push rbp
mov rbp, rsp
sub rsp, 26A0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_2428], 0
mov [rbp+var_2430], 0
mov [rbp+var_2438], 0
mov [rbp+var_2440], 0
loc_2A5C7:
mov rax, [rbp+var_2440]
cmp rax, [rbp+var_20]
jnb loc_2A919
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jz short loc_2A5FD
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 8
mov [rbp+var_10], rcx
mov rax, [rax]
mov [rbp+var_2690], rax
jmp short loc_2A611
loc_2A5FD:
mov rax, [rbp+var_2428]
add rax, 0C0h
mov [rbp+var_2690], rax
loc_2A611:
mov rax, [rbp+var_2690]
mov [rbp+var_2428], rax
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jz short loc_2A644
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 8
mov [rbp+var_18], rcx
mov rax, [rax]
mov [rbp+var_2698], rax
jmp short loc_2A656
loc_2A644:
mov rax, [rbp+var_2430]
add rax, 60h ; '`'
mov [rbp+var_2698], rax
loc_2A656:
mov rax, [rbp+var_2698]
mov [rbp+var_2430], rax
lea rdi, [rbp+var_2420]
imul rax, [rbp+var_2438], 60h ; '`'
add rdi, rax
mov rsi, [rbp+var_2430]
mov rdx, [rbp+var_2430]
call add_fp
lea rdi, [rbp+var_2420]
imul rax, [rbp+var_2438], 60h ; '`'
add rdi, rax
lea rsi, [rbp+var_2420]
imul rax, [rbp+var_2438], 60h ; '`'
add rsi, rax
mov edx, 1
call cneg_fp
lea rdi, [rbp+var_2420]
imul rax, [rbp+var_2438], 60h ; '`'
add rdi, rax
add rdi, 30h ; '0'
mov rsi, [rbp+var_2430]
add rsi, 30h ; '0'
mov rdx, [rbp+var_2430]
add rdx, 30h ; '0'
call add_fp
lea rdi, [rbp+var_1E20]
imul rax, [rbp+var_2438], 0C0h
add rdi, rax
mov rsi, [rbp+var_2428]
mov edx, 0C0h
call vec_copy
lea rdi, [rbp+var_1220]
imul rax, [rbp+var_2438], 120h
add rdi, rax
mov rsi, [rbp+var_2428]
mov edx, 0C0h
call vec_copy
lea rdi, [rbp+var_1220]
imul rax, [rbp+var_2438], 120h
add rdi, rax
add rdi, 0C0h
lea rsi, BLS12_381_Rx
mov edx, 60h ; '`'
call vec_copy
mov rax, [rbp+var_2438]
add rax, 1
mov [rbp+var_2438], rax
cmp rax, 10h
jz short loc_2A791
mov rax, [rbp+var_2440]
mov rcx, [rbp+var_20]
sub rcx, 1
cmp rax, rcx
jnz loc_2A900
loc_2A791:
cmp [rbp+var_2440], 10h
jnb short loc_2A7A8
mov rax, [rbp+var_8]
mov [rbp+var_26A0], rax
jmp short loc_2A7B6
loc_2A7A8:
lea rax, [rbp+var_2680]
mov [rbp+var_26A0], rax
loc_2A7B6:
mov rax, [rbp+var_26A0]
mov [rbp+var_2688], rax
mov rdi, [rbp+var_2688]
lea rsi, [rbp+var_1220]
lea rdx, [rbp+var_2420]
mov rcx, [rbp+var_2438]
call start_dbl_n
mov rdi, [rbp+var_2688]
lea rsi, [rbp+var_1220]
lea rdx, [rbp+var_1E20]
lea rcx, [rbp+var_2420]
mov r8, [rbp+var_2438]
mov r9d, 2
call add_n_dbl_n
mov rdi, [rbp+var_2688]
lea rsi, [rbp+var_1220]
lea rdx, [rbp+var_1E20]
lea rcx, [rbp+var_2420]
mov r8, [rbp+var_2438]
mov r9d, 3
call add_n_dbl_n
mov rdi, [rbp+var_2688]
lea rsi, [rbp+var_1220]
lea rdx, [rbp+var_1E20]
lea rcx, [rbp+var_2420]
mov r8, [rbp+var_2438]
mov r9d, 9
call add_n_dbl_n
mov rdi, [rbp+var_2688]
lea rsi, [rbp+var_1220]
lea rdx, [rbp+var_1E20]
lea rcx, [rbp+var_2420]
mov r8, [rbp+var_2438]
mov r9d, 20h ; ' '
call add_n_dbl_n
mov rdi, [rbp+var_2688]
lea rsi, [rbp+var_1220]
lea rdx, [rbp+var_1E20]
lea rcx, [rbp+var_2420]
mov r8, [rbp+var_2438]
mov r9d, 10h
call add_n_dbl_n
mov rdi, [rbp+var_2688]
call conjugate_fp12
cmp [rbp+var_2440], 10h
jb short loc_2A8F5
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_8]
mov rdx, [rbp+var_2688]
call mul_fp12
loc_2A8F5:
mov [rbp+var_2438], 0
loc_2A900:
jmp short $+2
loc_2A902:
mov rax, [rbp+var_2440]
add rax, 1
mov [rbp+var_2440], rax
jmp loc_2A5C7
loc_2A919:
add rsp, 26A0h
pop rbp
retn
| unsigned long long blst_miller_loop_n(long long a1, long long *a2, long long *a3, unsigned long long a4)
{
unsigned long long result; // rax
long long *v5; // rax
long long *v6; // rax
char *v7; // [rsp+0h] [rbp-26A0h]
long long v8; // [rsp+8h] [rbp-2698h]
long long v9; // [rsp+10h] [rbp-2690h]
char v10; // [rsp+20h] [rbp-2680h] BYREF
unsigned long long i; // [rsp+260h] [rbp-2440h]
long long v12; // [rsp+268h] [rbp-2438h]
long long v13; // [rsp+270h] [rbp-2430h]
long long v14; // [rsp+278h] [rbp-2428h]
_OWORD v15[96]; // [rsp+280h] [rbp-2420h] BYREF
_OWORD v16[192]; // [rsp+880h] [rbp-1E20h] BYREF
_OWORD v17[288]; // [rsp+1480h] [rbp-1220h] BYREF
unsigned long long v18; // [rsp+2680h] [rbp-20h]
long long *v19; // [rsp+2688h] [rbp-18h]
long long *v20; // [rsp+2690h] [rbp-10h]
char *v21; // [rsp+2698h] [rbp-8h]
v21 = (char *)a1;
v20 = a2;
v19 = a3;
v18 = a4;
v14 = 0LL;
v13 = 0LL;
v12 = 0LL;
for ( i = 0LL; ; ++i )
{
result = i;
if ( i >= v18 )
break;
if ( *v20 )
{
v5 = v20++;
v9 = *v5;
}
else
{
v9 = v14 + 192;
}
v14 = v9;
if ( *v19 )
{
v6 = v19++;
v8 = *v6;
}
else
{
v8 = v13 + 96;
}
v13 = v8;
add_fp(&v15[6 * v12], v8, v8);
cneg_fp(&v15[6 * v12], &v15[6 * v12], 1LL);
add_fp(&v15[6 * v12 + 3], v13 + 48, v13 + 48);
vec_copy((long long)&v16[12 * v12], v14, 0xC0uLL);
vec_copy((long long)&v17[18 * v12], v14, 0xC0uLL);
vec_copy((long long)&v17[18 * v12++ + 12], (long long)&BLS12_381_Rx, 0x60uLL);
if ( v12 == 16 || i == v18 - 1 )
{
if ( i >= 0x10 )
v7 = &v10;
else
v7 = v21;
start_dbl_n(v7, v17, v15, v12);
add_n_dbl_n(v7, v17, v16, v15, v12, 2LL);
add_n_dbl_n(v7, v17, v16, v15, v12, 3LL);
add_n_dbl_n(v7, v17, v16, v15, v12, 9LL);
add_n_dbl_n(v7, v17, v16, v15, v12, 32LL);
add_n_dbl_n(v7, v17, v16, v15, v12, 16LL);
conjugate_fp12((long long)v7);
if ( i >= 0x10 )
mul_fp12((long long)v21, (long long)v21, (long long)v7);
v12 = 0LL;
}
}
return result;
}
| blst_miller_loop_n:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x26a0
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 + -0x2428],0x0
MOV qword ptr [RBP + -0x2430],0x0
MOV qword ptr [RBP + -0x2438],0x0
MOV qword ptr [RBP + -0x2440],0x0
LAB_0012a5c7:
MOV RAX,qword ptr [RBP + -0x2440]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0012a919
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JZ 0x0012a5fd
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x8
MOV qword ptr [RBP + -0x10],RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x2690],RAX
JMP 0x0012a611
LAB_0012a5fd:
MOV RAX,qword ptr [RBP + -0x2428]
ADD RAX,0xc0
MOV qword ptr [RBP + -0x2690],RAX
LAB_0012a611:
MOV RAX,qword ptr [RBP + -0x2690]
MOV qword ptr [RBP + -0x2428],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX],0x0
JZ 0x0012a644
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x8
MOV qword ptr [RBP + -0x18],RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x2698],RAX
JMP 0x0012a656
LAB_0012a644:
MOV RAX,qword ptr [RBP + -0x2430]
ADD RAX,0x60
MOV qword ptr [RBP + -0x2698],RAX
LAB_0012a656:
MOV RAX,qword ptr [RBP + -0x2698]
MOV qword ptr [RBP + -0x2430],RAX
LEA RDI,[RBP + -0x2420]
IMUL RAX,qword ptr [RBP + -0x2438],0x60
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x2430]
MOV RDX,qword ptr [RBP + -0x2430]
CALL 0x0012a930
LEA RDI,[RBP + -0x2420]
IMUL RAX,qword ptr [RBP + -0x2438],0x60
ADD RDI,RAX
LEA RSI,[RBP + -0x2420]
IMUL RAX,qword ptr [RBP + -0x2438],0x60
ADD RSI,RAX
MOV EDX,0x1
CALL 0x0012a970
LEA RDI,[RBP + -0x2420]
IMUL RAX,qword ptr [RBP + -0x2438],0x60
ADD RDI,RAX
ADD RDI,0x30
MOV RSI,qword ptr [RBP + -0x2430]
ADD RSI,0x30
MOV RDX,qword ptr [RBP + -0x2430]
ADD RDX,0x30
CALL 0x0012a930
LEA RDI,[RBP + -0x1e20]
IMUL RAX,qword ptr [RBP + -0x2438],0xc0
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x2428]
MOV EDX,0xc0
CALL 0x00123620
LEA RDI,[RBP + -0x1220]
IMUL RAX,qword ptr [RBP + -0x2438],0x120
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x2428]
MOV EDX,0xc0
CALL 0x00123620
LEA RDI,[RBP + -0x1220]
IMUL RAX,qword ptr [RBP + -0x2438],0x120
ADD RDI,RAX
ADD RDI,0xc0
LEA RSI,[0x154d28]
MOV EDX,0x60
CALL 0x00123620
MOV RAX,qword ptr [RBP + -0x2438]
ADD RAX,0x1
MOV qword ptr [RBP + -0x2438],RAX
CMP RAX,0x10
JZ 0x0012a791
MOV RAX,qword ptr [RBP + -0x2440]
MOV RCX,qword ptr [RBP + -0x20]
SUB RCX,0x1
CMP RAX,RCX
JNZ 0x0012a900
LAB_0012a791:
CMP qword ptr [RBP + -0x2440],0x10
JNC 0x0012a7a8
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x26a0],RAX
JMP 0x0012a7b6
LAB_0012a7a8:
LEA RAX,[RBP + -0x2680]
MOV qword ptr [RBP + -0x26a0],RAX
LAB_0012a7b6:
MOV RAX,qword ptr [RBP + -0x26a0]
MOV qword ptr [RBP + -0x2688],RAX
MOV RDI,qword ptr [RBP + -0x2688]
LEA RSI,[RBP + -0x1220]
LEA RDX,[RBP + -0x2420]
MOV RCX,qword ptr [RBP + -0x2438]
CALL 0x0012a9b0
MOV RDI,qword ptr [RBP + -0x2688]
LEA RSI,[RBP + -0x1220]
LEA RDX,[RBP + -0x1e20]
LEA RCX,[RBP + -0x2420]
MOV R8,qword ptr [RBP + -0x2438]
MOV R9D,0x2
CALL 0x0012aac0
MOV RDI,qword ptr [RBP + -0x2688]
LEA RSI,[RBP + -0x1220]
LEA RDX,[RBP + -0x1e20]
LEA RCX,[RBP + -0x2420]
MOV R8,qword ptr [RBP + -0x2438]
MOV R9D,0x3
CALL 0x0012aac0
MOV RDI,qword ptr [RBP + -0x2688]
LEA RSI,[RBP + -0x1220]
LEA RDX,[RBP + -0x1e20]
LEA RCX,[RBP + -0x2420]
MOV R8,qword ptr [RBP + -0x2438]
MOV R9D,0x9
CALL 0x0012aac0
MOV RDI,qword ptr [RBP + -0x2688]
LEA RSI,[RBP + -0x1220]
LEA RDX,[RBP + -0x1e20]
LEA RCX,[RBP + -0x2420]
MOV R8,qword ptr [RBP + -0x2438]
MOV R9D,0x20
CALL 0x0012aac0
MOV RDI,qword ptr [RBP + -0x2688]
LEA RSI,[RBP + -0x1220]
LEA RDX,[RBP + -0x1e20]
LEA RCX,[RBP + -0x2420]
MOV R8,qword ptr [RBP + -0x2438]
MOV R9D,0x10
CALL 0x0012aac0
MOV RDI,qword ptr [RBP + -0x2688]
CALL 0x00129d90
CMP qword ptr [RBP + -0x2440],0x10
JC 0x0012a8f5
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x2688]
CALL 0x001299e0
LAB_0012a8f5:
MOV qword ptr [RBP + -0x2438],0x0
LAB_0012a900:
JMP 0x0012a902
LAB_0012a902:
MOV RAX,qword ptr [RBP + -0x2440]
ADD RAX,0x1
MOV qword ptr [RBP + -0x2440],RAX
JMP 0x0012a5c7
LAB_0012a919:
ADD RSP,0x26a0
POP RBP
RET
|
void blst_miller_loop_n(int1 *param_1,long *param_2,long *param_3,ulong param_4)
{
int1 *local_26a8;
long local_26a0;
long local_2698;
int1 local_2688 [576];
ulong local_2448;
long local_2440;
long local_2438;
long local_2430;
int1 local_2428 [48];
int1 auStack_23f8 [1488];
int1 local_1e28 [3072];
int1 local_1228 [192];
int1 auStack_1168 [4416];
ulong local_28;
long *local_20;
long *local_18;
int1 *local_10;
local_2430 = 0;
local_2438 = 0;
local_2440 = 0;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
for (local_2448 = 0; local_2448 < local_28; local_2448 = local_2448 + 1) {
if (*local_18 == 0) {
local_2698 = local_2430 + 0xc0;
}
else {
local_2698 = *local_18;
local_18 = local_18 + 1;
}
local_2430 = local_2698;
if (*local_20 == 0) {
local_26a0 = local_2438 + 0x60;
}
else {
local_26a0 = *local_20;
local_20 = local_20 + 1;
}
local_2438 = local_26a0;
add_fp(local_2428 + local_2440 * 0x60,local_26a0,local_26a0);
cneg_fp(local_2428 + local_2440 * 0x60,local_2428 + local_2440 * 0x60,1);
add_fp(auStack_23f8 + local_2440 * 0x60,local_2438 + 0x30,local_2438 + 0x30);
vec_copy(local_1e28 + local_2440 * 0xc0,local_2430,0xc0);
vec_copy(local_1228 + local_2440 * 0x120,local_2430,0xc0);
vec_copy(auStack_1168 + local_2440 * 0x120,BLS12_381_Rx,0x60);
local_2440 = local_2440 + 1;
if ((local_2440 == 0x10) || (local_2448 == local_28 - 1)) {
if (local_2448 < 0x10) {
local_26a8 = local_10;
}
else {
local_26a8 = local_2688;
}
start_dbl_n(local_26a8,local_1228,local_2428,local_2440);
add_n_dbl_n(local_26a8,local_1228,local_1e28,local_2428,local_2440,2);
add_n_dbl_n(local_26a8,local_1228,local_1e28,local_2428,local_2440,3);
add_n_dbl_n(local_26a8,local_1228,local_1e28,local_2428,local_2440,9);
add_n_dbl_n(local_26a8,local_1228,local_1e28,local_2428,local_2440,0x20);
add_n_dbl_n(local_26a8,local_1228,local_1e28,local_2428,local_2440,0x10);
conjugate_fp12(local_26a8);
if (0xf < local_2448) {
mul_fp12(local_10,local_10,local_26a8);
}
local_2440 = 0;
}
}
return;
}
| |
24,158 | get_MARIA_HA_from_REDO_record | eloqsql/storage/maria/ma_recovery.c | static MARIA_HA *get_MARIA_HA_from_REDO_record(const
TRANSLOG_HEADER_BUFFER *rec)
{
uint16 sid;
pgcache_page_no_t UNINIT_VAR(page);
MARIA_HA *info;
MARIA_SHARE *share;
char llbuf[22];
my_bool index_page_redo_entry= FALSE, page_redo_entry= FALSE;
print_redo_phase_progress(rec->lsn);
sid= fileid_korr(rec->header);
switch (rec->type) {
/* not all REDO records have a page: */
case LOGREC_REDO_INDEX_NEW_PAGE:
case LOGREC_REDO_INDEX:
case LOGREC_REDO_INDEX_FREE_PAGE:
index_page_redo_entry= 1;
/* fall through*/
case LOGREC_REDO_INSERT_ROW_HEAD:
case LOGREC_REDO_INSERT_ROW_TAIL:
case LOGREC_REDO_PURGE_ROW_HEAD:
case LOGREC_REDO_PURGE_ROW_TAIL:
case LOGREC_REDO_NEW_ROW_HEAD:
case LOGREC_REDO_NEW_ROW_TAIL:
case LOGREC_REDO_FREE_HEAD_OR_TAIL:
page_redo_entry= TRUE;
page= page_korr(rec->header + FILEID_STORE_SIZE);
llstr(page, llbuf);
break;
case LOGREC_REDO_FREE_BLOCKS:
/*
We are checking against the dirty pages in _ma_apply_redo_free_blocks()
*/
break;
default:
break;
}
tprint(tracef, " For table of short id %u", sid);
info= all_tables[sid].info;
#ifndef DBUG_OFF
DBUG_ASSERT(current_group_table == NULL || current_group_table == info);
current_group_table= info;
#endif
if (info == NULL)
{
tprint(tracef, ", table skipped, so skipping record\n");
return NULL;
}
share= info->s;
tprint(tracef, ", '%s'", share->open_file_name.str);
DBUG_ASSERT(in_redo_phase);
if (!table_is_part_of_recovery_set(&share->open_file_name))
{
tprint(tracef, ", skipped by user\n");
return NULL;
}
if (cmp_translog_addr(rec->lsn, share->lsn_of_file_id) <= 0)
{
/*
This can happen only if processing a record before the checkpoint
record.
id->name mapping is newer than REDO record: for sure the table subject
of the REDO has been flushed and forced (id re-assignment implies this);
REDO can be ignored (and must be, as we don't know what this subject
table was).
*/
DBUG_ASSERT(cmp_translog_addr(rec->lsn, checkpoint_start) < 0);
tprint(tracef, ", table's LOGREC_FILE_ID has LSN " LSN_FMT " more recent"
" than record, skipping record",
LSN_IN_PARTS(share->lsn_of_file_id));
return NULL;
}
if (cmp_translog_addr(rec->lsn, share->state.skip_redo_lsn) <= 0)
{
/* probably a bulk insert repair */
tprint(tracef, ", has skip_redo_lsn " LSN_FMT " more recent than"
" record, skipping record\n",
LSN_IN_PARTS(share->state.skip_redo_lsn));
return NULL;
}
/* detect if an open instance of a dropped table (internal bug) */
DBUG_ASSERT(share->last_version != 0);
if (page_redo_entry)
{
/*
Consult dirty pages list.
REDO_INSERT_ROW_BLOBS will consult list by itself, as it covers several
pages.
*/
if (_ma_redo_not_needed_for_page(sid, rec->lsn, page,
index_page_redo_entry))
return NULL;
}
/*
So we are going to read the page, and if its LSN is older than the
record's we will modify the page
*/
tprint(tracef, ", applying record\n");
_ma_writeinfo(info, WRITEINFO_UPDATE_KEYFILE); /* to flush state on close */
return info;
} | O0 | c | get_MARIA_HA_from_REDO_record:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x30(%rbp)
movb $0x0, -0x51(%rbp)
movb $0x0, -0x52(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0xc1ac0
movq -0x30(%rbp), %rax
movw 0x18(%rax), %ax
movw %ax, -0x32(%rbp)
movq -0x30(%rbp), %rax
movl 0x420(%rax), %eax
movl %eax, -0x58(%rbp)
decl %eax
subl $0x4, %eax
jb 0xc1871
jmp 0xc183f
movl -0x58(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0xc1871
jmp 0xc184c
movl -0x58(%rbp), %eax
subl $0x8, %eax
je 0xc1899
jmp 0xc1856
movl -0x58(%rbp), %eax
subl $0x9, %eax
je 0xc1871
jmp 0xc1860
movl -0x58(%rbp), %eax
addl $-0xc, %eax
subl $0x2, %eax
ja 0xc189b
jmp 0xc186d
movb $0x1, -0x51(%rbp)
movb $0x1, -0x52(%rbp)
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
addq $0x2, %rdi
callq 0xc1c90
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x17ea60
jmp 0xc189d
jmp 0xc189d
jmp 0xc189d
leaq 0xc1b274(%rip), %rax # 0xcdcb18
movq (%rax), %rdi
movzwl -0x32(%rbp), %edx
leaq 0xcc037(%rip), %rsi # 0x18d8e9
movb $0x0, %al
callq 0xc2dd0
movq 0xc1b100(%rip), %rax # 0xcdc9c0
movzwl -0x32(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xc18f8
leaq 0xc1b23e(%rip), %rax # 0xcdcb18
movq (%rax), %rdi
leaq 0xcc021(%rip), %rsi # 0x18d905
movb $0x0, %al
callq 0xc2dd0
movq $0x0, -0x28(%rbp)
jmp 0xc1a8f
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
leaq 0xc1b20e(%rip), %rax # 0xcdcb18
movq (%rax), %rdi
movq -0x50(%rbp), %rax
movq 0x5e0(%rax), %rdx
leaq 0xcc00b(%rip), %rsi # 0x18d92a
movb $0x0, %al
callq 0xc2dd0
jmp 0xc1928
movq -0x50(%rbp), %rdi
addq $0x5e0, %rdi # imm = 0x5E0
callq 0xc1cc0
cmpb $0x0, %al
jne 0xc1961
leaq 0xc1b1d5(%rip), %rax # 0xcdcb18
movq (%rax), %rdi
leaq 0xcbfe4(%rip), %rsi # 0x18d931
movb $0x0, %al
callq 0xc2dd0
movq $0x0, -0x28(%rbp)
jmp 0xc1a8f
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x50(%rbp), %rcx
subq 0xc10(%rcx), %rax
cmpq $0x0, %rax
jg 0xc19ca
jmp 0xc197b
jmp 0xc197d
leaq 0xc1b194(%rip), %rax # 0xcdcb18
movq (%rax), %rdi
movq -0x50(%rbp), %rax
movq 0xc10(%rax), %rax
sarq $0x20, %rax
movl %eax, %edx
movq -0x50(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq 0xc10(%rcx), %rax
movl %eax, %ecx
leaq 0xcbf8e(%rip), %rsi # 0x18d944
movb $0x0, %al
callq 0xc2dd0
movq $0x0, -0x28(%rbp)
jmp 0xc1a8f
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x50(%rbp), %rcx
subq 0x188(%rcx), %rax
cmpq $0x0, %rax
jg 0xc1a2c
leaq 0xc1b12f(%rip), %rax # 0xcdcb18
movq (%rax), %rdi
movq -0x50(%rbp), %rax
movq 0x188(%rax), %rax
sarq $0x20, %rax
movl %eax, %edx
movq -0x50(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq 0x188(%rcx), %rax
movl %eax, %ecx
leaq 0xcbf7d(%rip), %rsi # 0x18d998
movb $0x0, %al
callq 0xc2dd0
movq $0x0, -0x28(%rbp)
jmp 0xc1a8f
jmp 0xc1a2e
jmp 0xc1a30
cmpb $0x0, -0x52(%rbp)
je 0xc1a61
movw -0x32(%rbp), %ax
movq -0x30(%rbp), %rcx
movq (%rcx), %rsi
movq -0x40(%rbp), %rdx
movzwl %ax, %edi
movsbl -0x51(%rbp), %ecx
callq 0xc2fd0
cmpb $0x0, %al
je 0xc1a5f
movq $0x0, -0x28(%rbp)
jmp 0xc1a8f
jmp 0xc1a61
leaq 0xc1b0b0(%rip), %rax # 0xcdcb18
movq (%rax), %rdi
leaq 0xcbf6e(%rip), %rsi # 0x18d9e0
movb $0x0, %al
callq 0xc2dd0
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x4a8a0
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xc1ab3
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
callq 0x2c290
nopl (%rax,%rax)
| get_MARIA_HA_from_REDO_record:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_30], rdi
mov [rbp+var_51], 0
mov [rbp+var_52], 0
mov rax, [rbp+var_30]
mov rdi, [rax]
call print_redo_phase_progress
mov rax, [rbp+var_30]
mov ax, [rax+18h]
mov [rbp+var_32], ax
mov rax, [rbp+var_30]
mov eax, [rax+420h]
mov [rbp+var_58], eax
dec eax
sub eax, 4
jb short loc_C1871
jmp short $+2
loc_C183F:
mov eax, [rbp+var_58]
add eax, 0FFFFFFFAh
sub eax, 2
jb short loc_C1871
jmp short $+2
loc_C184C:
mov eax, [rbp+var_58]
sub eax, 8
jz short loc_C1899
jmp short $+2
loc_C1856:
mov eax, [rbp+var_58]
sub eax, 9
jz short loc_C1871
jmp short $+2
loc_C1860:
mov eax, [rbp+var_58]
add eax, 0FFFFFFF4h
sub eax, 2
ja short loc_C189B
jmp short $+2
loc_C186D:
mov [rbp+var_51], 1
loc_C1871:
mov [rbp+var_52], 1
mov rdi, [rbp+var_30]
add rdi, 18h
add rdi, 2
call uint5korr_3
mov [rbp+var_40], rax
mov rdi, [rbp+var_40]
lea rsi, [rbp+var_20]
call llstr
jmp short loc_C189D
loc_C1899:
jmp short loc_C189D
loc_C189B:
jmp short $+2
loc_C189D:
lea rax, tracef
mov rdi, [rax]
movzx edx, [rbp+var_32]
lea rsi, aForTableOfShor; " For table of short id %u"
mov al, 0
call tprint
mov rax, cs:all_tables
movzx ecx, [rbp+var_32]
mov rax, [rax+rcx*8]
mov [rbp+var_48], rax
cmp [rbp+var_48], 0
jnz short loc_C18F8
lea rax, tracef
mov rdi, [rax]
lea rsi, aTableSkippedSo; ", table skipped, so skipping record\n"
mov al, 0
call tprint
mov [rbp+var_28], 0
jmp loc_C1A8F
loc_C18F8:
mov rax, [rbp+var_48]
mov rax, [rax]
mov [rbp+var_50], rax
lea rax, tracef
mov rdi, [rax]
mov rax, [rbp+var_50]
mov rdx, [rax+5E0h]
lea rsi, aS_0; ", '%s'"
mov al, 0
call tprint
jmp short $+2
loc_C1928:
mov rdi, [rbp+var_50]
add rdi, 5E0h
call table_is_part_of_recovery_set
cmp al, 0
jnz short loc_C1961
lea rax, tracef
mov rdi, [rax]
lea rsi, aSkippedByUser; ", skipped by user\n"
mov al, 0
call tprint
mov [rbp+var_28], 0
jmp loc_C1A8F
loc_C1961:
mov rax, [rbp+var_30]
mov rax, [rax]
mov rcx, [rbp+var_50]
sub rax, [rcx+0C10h]
cmp rax, 0
jg short loc_C19CA
jmp short $+2
loc_C197B:
jmp short $+2
loc_C197D:
lea rax, tracef
mov rdi, [rax]
mov rax, [rbp+var_50]
mov rax, [rax+0C10h]
sar rax, 20h
mov edx, eax
mov rcx, [rbp+var_50]
mov rax, 0FFFFFFFFh
and rax, [rcx+0C10h]
mov ecx, eax
lea rsi, aTableSLogrecFi; ", table's LOGREC_FILE_ID has LSN (%u,0x"...
mov al, 0
call tprint
mov [rbp+var_28], 0
jmp loc_C1A8F
loc_C19CA:
mov rax, [rbp+var_30]
mov rax, [rax]
mov rcx, [rbp+var_50]
sub rax, [rcx+188h]
cmp rax, 0
jg short loc_C1A2C
lea rax, tracef
mov rdi, [rax]
mov rax, [rbp+var_50]
mov rax, [rax+188h]
sar rax, 20h
mov edx, eax
mov rcx, [rbp+var_50]
mov rax, 0FFFFFFFFh
and rax, [rcx+188h]
mov ecx, eax
lea rsi, aHasSkipRedoLsn; ", has skip_redo_lsn (%u,0x%x) more rece"...
mov al, 0
call tprint
mov [rbp+var_28], 0
jmp short loc_C1A8F
loc_C1A2C:
jmp short $+2
loc_C1A2E:
jmp short $+2
loc_C1A30:
cmp [rbp+var_52], 0
jz short loc_C1A61
mov ax, [rbp+var_32]
mov rcx, [rbp+var_30]
mov rsi, [rcx]
mov rdx, [rbp+var_40]
movzx edi, ax
movsx ecx, [rbp+var_51]
call _ma_redo_not_needed_for_page
cmp al, 0
jz short loc_C1A5F
mov [rbp+var_28], 0
jmp short loc_C1A8F
loc_C1A5F:
jmp short $+2
loc_C1A61:
lea rax, tracef
mov rdi, [rax]
lea rsi, aApplyingRecord; ", applying record\n"
mov al, 0
call tprint
mov rdi, [rbp+var_48]
mov esi, 1
call _ma_writeinfo
mov rax, [rbp+var_48]
mov [rbp+var_28], rax
loc_C1A8F:
mov rax, [rbp+var_28]
mov [rbp+var_60], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_C1AB3
mov rax, [rbp+var_60]
add rsp, 60h
pop rbp
retn
loc_C1AB3:
call ___stack_chk_fail
| long long * get_MARIA_HA_from_REDO_record(_QWORD *a1)
{
int v1; // ecx
int v2; // r8d
int v3; // r9d
int v4; // edx
int v5; // r8d
int v6; // r9d
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
int v11; // ecx
int v13; // [rsp+8h] [rbp-58h]
char v14; // [rsp+Eh] [rbp-52h]
char v15; // [rsp+Fh] [rbp-51h]
long long v16; // [rsp+10h] [rbp-50h]
long long *v17; // [rsp+18h] [rbp-48h]
long long v18; // [rsp+20h] [rbp-40h]
unsigned __int16 v19; // [rsp+2Eh] [rbp-32h]
_BYTE v21[24]; // [rsp+40h] [rbp-20h] BYREF
unsigned long long v22; // [rsp+58h] [rbp-8h]
v22 = __readfsqword(0x28u);
v15 = 0;
v14 = 0;
print_redo_phase_progress(*a1);
v19 = *((_WORD *)a1 + 12);
v13 = *((_DWORD *)a1 + 264);
if ( (unsigned int)(v13 - 1) >= 4 && (unsigned int)(v13 - 6) >= 2 )
{
if ( v13 == 8 )
goto LABEL_8;
if ( v13 != 9 )
{
if ( (unsigned int)(v13 - 12) > 2 )
goto LABEL_8;
v15 = 1;
}
}
v14 = 1;
v18 = uint5korr_3((char *)a1 + 26);
llstr(v18, v21);
LABEL_8:
tprint(tracef, (unsigned int)" For table of short id %u", v19, v1, v2, v3);
v17 = *(long long **)(all_tables + 8LL * v19);
if ( v17 )
{
v16 = *v17;
tprint(tracef, (unsigned int)", '%s'", *(_QWORD *)(*v17 + 1504), v19, v5, v6);
if ( (unsigned __int8)table_is_part_of_recovery_set(v16 + 1504) )
{
if ( (long long)(*a1 - *(_QWORD *)(v16 + 3088)) > 0 )
{
v11 = v16;
if ( (long long)(*a1 - *(_QWORD *)(v16 + 392)) > 0 )
{
if ( v14 && (unsigned __int8)ma_redo_not_needed_for_page(v19, *a1, v18, (unsigned int)v15) )
{
return 0LL;
}
else
{
tprint(tracef, (unsigned int)", applying record\n", v7, v11, v9, v10);
ma_writeinfo(v17, (_BYTE *)&dword_0 + 1);
return v17;
}
}
else
{
tprint(
tracef,
(unsigned int)", has skip_redo_lsn (%u,0x%x) more recent than record, skipping record\n",
HIDWORD(*(_QWORD *)(v16 + 392)),
*(_QWORD *)(v16 + 392),
v9,
v10);
return 0LL;
}
}
else
{
tprint(
tracef,
(unsigned int)", table's LOGREC_FILE_ID has LSN (%u,0x%x) more recent than record, skipping record",
HIDWORD(*(_QWORD *)(v16 + 3088)),
*(_QWORD *)(v16 + 3088),
v9,
v10);
return 0LL;
}
}
else
{
tprint(tracef, (unsigned int)", skipped by user\n", v7, v8, v9, v10);
return 0LL;
}
}
else
{
tprint(tracef, (unsigned int)", table skipped, so skipping record\n", v4, v19, v5, v6);
return 0LL;
}
}
| get_MARIA_HA_from_REDO_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x30],RDI
MOV byte ptr [RBP + -0x51],0x0
MOV byte ptr [RBP + -0x52],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX]
CALL 0x001c1ac0
MOV RAX,qword ptr [RBP + -0x30]
MOV AX,word ptr [RAX + 0x18]
MOV word ptr [RBP + -0x32],AX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x420]
MOV dword ptr [RBP + -0x58],EAX
DEC EAX
SUB EAX,0x4
JC 0x001c1871
JMP 0x001c183f
LAB_001c183f:
MOV EAX,dword ptr [RBP + -0x58]
ADD EAX,-0x6
SUB EAX,0x2
JC 0x001c1871
JMP 0x001c184c
LAB_001c184c:
MOV EAX,dword ptr [RBP + -0x58]
SUB EAX,0x8
JZ 0x001c1899
JMP 0x001c1856
LAB_001c1856:
MOV EAX,dword ptr [RBP + -0x58]
SUB EAX,0x9
JZ 0x001c1871
JMP 0x001c1860
LAB_001c1860:
MOV EAX,dword ptr [RBP + -0x58]
ADD EAX,-0xc
SUB EAX,0x2
JA 0x001c189b
JMP 0x001c186d
LAB_001c186d:
MOV byte ptr [RBP + -0x51],0x1
LAB_001c1871:
MOV byte ptr [RBP + -0x52],0x1
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x18
ADD RDI,0x2
CALL 0x001c1c90
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x20]
CALL 0x0027ea60
JMP 0x001c189d
LAB_001c1899:
JMP 0x001c189d
LAB_001c189b:
JMP 0x001c189d
LAB_001c189d:
LEA RAX,[0xddcb18]
MOV RDI,qword ptr [RAX]
MOVZX EDX,word ptr [RBP + -0x32]
LEA RSI,[0x28d8e9]
MOV AL,0x0
CALL 0x001c2dd0
MOV RAX,qword ptr [0x00ddc9c0]
MOVZX ECX,word ptr [RBP + -0x32]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x48],RAX
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x001c18f8
LEA RAX,[0xddcb18]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x28d905]
MOV AL,0x0
CALL 0x001c2dd0
MOV qword ptr [RBP + -0x28],0x0
JMP 0x001c1a8f
LAB_001c18f8:
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[0xddcb18]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RAX + 0x5e0]
LEA RSI,[0x28d92a]
MOV AL,0x0
CALL 0x001c2dd0
JMP 0x001c1928
LAB_001c1928:
MOV RDI,qword ptr [RBP + -0x50]
ADD RDI,0x5e0
CALL 0x001c1cc0
CMP AL,0x0
JNZ 0x001c1961
LEA RAX,[0xddcb18]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x28d931]
MOV AL,0x0
CALL 0x001c2dd0
MOV qword ptr [RBP + -0x28],0x0
JMP 0x001c1a8f
LAB_001c1961:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,qword ptr [RCX + 0xc10]
CMP RAX,0x0
JG 0x001c19ca
JMP 0x001c197b
LAB_001c197b:
JMP 0x001c197d
LAB_001c197d:
LEA RAX,[0xddcb18]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX + 0xc10]
SAR RAX,0x20
MOV EDX,EAX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX + 0xc10]
MOV ECX,EAX
LEA RSI,[0x28d944]
MOV AL,0x0
CALL 0x001c2dd0
MOV qword ptr [RBP + -0x28],0x0
JMP 0x001c1a8f
LAB_001c19ca:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,qword ptr [RCX + 0x188]
CMP RAX,0x0
JG 0x001c1a2c
LEA RAX,[0xddcb18]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX + 0x188]
SAR RAX,0x20
MOV EDX,EAX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX + 0x188]
MOV ECX,EAX
LEA RSI,[0x28d998]
MOV AL,0x0
CALL 0x001c2dd0
MOV qword ptr [RBP + -0x28],0x0
JMP 0x001c1a8f
LAB_001c1a2c:
JMP 0x001c1a2e
LAB_001c1a2e:
JMP 0x001c1a30
LAB_001c1a30:
CMP byte ptr [RBP + -0x52],0x0
JZ 0x001c1a61
MOV AX,word ptr [RBP + -0x32]
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RCX]
MOV RDX,qword ptr [RBP + -0x40]
MOVZX EDI,AX
MOVSX ECX,byte ptr [RBP + -0x51]
CALL 0x001c2fd0
CMP AL,0x0
JZ 0x001c1a5f
MOV qword ptr [RBP + -0x28],0x0
JMP 0x001c1a8f
LAB_001c1a5f:
JMP 0x001c1a61
LAB_001c1a61:
LEA RAX,[0xddcb18]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x28d9e0]
MOV AL,0x0
CALL 0x001c2dd0
MOV RDI,qword ptr [RBP + -0x48]
MOV ESI,0x1
CALL 0x0014a8a0
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x28],RAX
LAB_001c1a8f:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001c1ab3
MOV RAX,qword ptr [RBP + -0x60]
ADD RSP,0x60
POP RBP
RET
LAB_001c1ab3:
CALL 0x0012c290
|
long * get_MARIA_HA_from_REDO_record(long *param_1)
{
ushort uVar1;
int iVar2;
long lVar3;
bool bVar4;
char cVar5;
long in_FS_OFFSET;
int1 local_59;
int8 local_48;
long *local_30;
int1 local_28 [24];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_59 = 0;
bVar4 = false;
print_redo_phase_progress(*param_1);
uVar1 = *(ushort *)(param_1 + 3);
iVar2 = (int)param_1[0x84];
if ((3 < iVar2 - 1U) && (1 < iVar2 - 6U)) {
if (iVar2 == 8) goto LAB_001c189d;
if (iVar2 != 9) {
if (2 < iVar2 - 0xcU) goto LAB_001c189d;
local_59 = 1;
}
}
bVar4 = true;
local_48 = uint5korr((long)param_1 + 0x1a);
llstr(local_48,local_28);
LAB_001c189d:
tprint(tracef," For table of short id %u",uVar1);
local_30 = *(long **)(all_tables + (ulong)uVar1 * 8);
if (local_30 == (long *)0x0) {
tprint(tracef,", table skipped, so skipping record\n");
local_30 = (long *)0x0;
}
else {
lVar3 = *local_30;
tprint(tracef,", \'%s\'",*(int8 *)(lVar3 + 0x5e0));
cVar5 = table_is_part_of_recovery_set(lVar3 + 0x5e0);
if (cVar5 == '\0') {
tprint(tracef,", skipped by user\n");
local_30 = (long *)0x0;
}
else if (*param_1 - *(long *)(lVar3 + 0xc10) < 1) {
tprint(tracef,
", table\'s LOGREC_FILE_ID has LSN (%u,0x%x) more recent than record, skipping record",
*(long *)(lVar3 + 0xc10) >> 0x20 & 0xffffffff,*(ulong *)(lVar3 + 0xc10) & 0xffffffff);
local_30 = (long *)0x0;
}
else if (*param_1 - *(long *)(lVar3 + 0x188) < 1) {
tprint(tracef,", has skip_redo_lsn (%u,0x%x) more recent than record, skipping record\n",
*(long *)(lVar3 + 0x188) >> 0x20 & 0xffffffff,*(ulong *)(lVar3 + 0x188) & 0xffffffff);
local_30 = (long *)0x0;
}
else if ((bVar4) &&
(cVar5 = _ma_redo_not_needed_for_page(uVar1,*param_1,local_48,local_59), cVar5 != '\0'))
{
local_30 = (long *)0x0;
}
else {
tprint(tracef,", applying record\n");
_ma_writeinfo(local_30,1);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_30;
}
| |
24,159 | get_MARIA_HA_from_REDO_record | eloqsql/storage/maria/ma_recovery.c | static MARIA_HA *get_MARIA_HA_from_REDO_record(const
TRANSLOG_HEADER_BUFFER *rec)
{
uint16 sid;
pgcache_page_no_t UNINIT_VAR(page);
MARIA_HA *info;
MARIA_SHARE *share;
char llbuf[22];
my_bool index_page_redo_entry= FALSE, page_redo_entry= FALSE;
print_redo_phase_progress(rec->lsn);
sid= fileid_korr(rec->header);
switch (rec->type) {
/* not all REDO records have a page: */
case LOGREC_REDO_INDEX_NEW_PAGE:
case LOGREC_REDO_INDEX:
case LOGREC_REDO_INDEX_FREE_PAGE:
index_page_redo_entry= 1;
/* fall through*/
case LOGREC_REDO_INSERT_ROW_HEAD:
case LOGREC_REDO_INSERT_ROW_TAIL:
case LOGREC_REDO_PURGE_ROW_HEAD:
case LOGREC_REDO_PURGE_ROW_TAIL:
case LOGREC_REDO_NEW_ROW_HEAD:
case LOGREC_REDO_NEW_ROW_TAIL:
case LOGREC_REDO_FREE_HEAD_OR_TAIL:
page_redo_entry= TRUE;
page= page_korr(rec->header + FILEID_STORE_SIZE);
llstr(page, llbuf);
break;
case LOGREC_REDO_FREE_BLOCKS:
/*
We are checking against the dirty pages in _ma_apply_redo_free_blocks()
*/
break;
default:
break;
}
tprint(tracef, " For table of short id %u", sid);
info= all_tables[sid].info;
#ifndef DBUG_OFF
DBUG_ASSERT(current_group_table == NULL || current_group_table == info);
current_group_table= info;
#endif
if (info == NULL)
{
tprint(tracef, ", table skipped, so skipping record\n");
return NULL;
}
share= info->s;
tprint(tracef, ", '%s'", share->open_file_name.str);
DBUG_ASSERT(in_redo_phase);
if (!table_is_part_of_recovery_set(&share->open_file_name))
{
tprint(tracef, ", skipped by user\n");
return NULL;
}
if (cmp_translog_addr(rec->lsn, share->lsn_of_file_id) <= 0)
{
/*
This can happen only if processing a record before the checkpoint
record.
id->name mapping is newer than REDO record: for sure the table subject
of the REDO has been flushed and forced (id re-assignment implies this);
REDO can be ignored (and must be, as we don't know what this subject
table was).
*/
DBUG_ASSERT(cmp_translog_addr(rec->lsn, checkpoint_start) < 0);
tprint(tracef, ", table's LOGREC_FILE_ID has LSN " LSN_FMT " more recent"
" than record, skipping record",
LSN_IN_PARTS(share->lsn_of_file_id));
return NULL;
}
if (cmp_translog_addr(rec->lsn, share->state.skip_redo_lsn) <= 0)
{
/* probably a bulk insert repair */
tprint(tracef, ", has skip_redo_lsn " LSN_FMT " more recent than"
" record, skipping record\n",
LSN_IN_PARTS(share->state.skip_redo_lsn));
return NULL;
}
/* detect if an open instance of a dropped table (internal bug) */
DBUG_ASSERT(share->last_version != 0);
if (page_redo_entry)
{
/*
Consult dirty pages list.
REDO_INSERT_ROW_BLOBS will consult list by itself, as it covers several
pages.
*/
if (_ma_redo_not_needed_for_page(sid, rec->lsn, page,
index_page_redo_entry))
return NULL;
}
/*
So we are going to read the page, and if its LSN is older than the
record's we will modify the page
*/
tprint(tracef, ", applying record\n");
_ma_writeinfo(info, WRITEINFO_UPDATE_KEYFILE); /* to flush state on close */
return info;
} | O3 | c | get_MARIA_HA_from_REDO_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq 0xbc5e53(%rip), %r13 # 0xc52dc8
movq (%r13), %rax
movq 0x328028(%rip), %rcx # 0x3b4fa8
cmpq (%rcx), %rax
je 0x8d0b4
movq (%rbx), %r14
cmpl $0x0, 0xbc5ce5(%rip) # 0xc52c78
jne 0x8cfed
leaq 0x77e35(%rip), %rsi # 0x104dd1
leaq 0x797dd(%rip), %rcx # 0x106780
movl $0x400, %edx # imm = 0x400
movl $0xa8, %edi
xorl %eax, %eax
callq 0xbf641
movq 0x327ff5(%rip), %r15 # 0x3b4fb0
movq (%r15), %rdi
leaq 0x797a0(%rip), %rdx # 0x106765
movl $0x1, %esi
xorl %eax, %eax
callq 0x2b210
movq (%r15), %rdi
callq 0x2b490
leaq 0xbc5d70(%rip), %rax # 0xc52d50
movb $0x1, (%rax)
movl $0x1, 0xbc5c8b(%rip) # 0xc52c78
movl 0xbc5d45(%rip), %eax # 0xc52d38
testl %eax, %eax
jne 0x8d011
xorl %eax, %eax
callq 0x7e2d0
movl %eax, %ecx
shrq $0x20, %rax
movl %eax, 0xbc5d2e(%rip) # 0xc52d38
movq %rcx, 0xbc5d2f(%rip) # 0xc52d40
movq %r14, %rdx
shrq $0x20, %rdx
movl %r14d, %ecx
cmpl %edx, %eax
jne 0x8d02b
movq 0xbc5d1a(%rip), %rax # 0xc52d40
subq %rcx, %rax
jmp 0x8d04a
leaq 0x329c96(%rip), %rsi # 0x3b6cc8
movq (%rsi), %rsi
notl %edx
addl %edx, %eax
imulq %rsi, %rax
subq %rcx, %rsi
addq %rsi, %rax
addq 0xbc5cf6(%rip), %rax # 0xc52d40
movq 0x329cdf(%rip), %rcx # 0x3b6d30
cmpq $-0x1, %rcx
jne 0x8d061
movq %rax, 0x329cd2(%rip) # 0x3b6d30
movq %rax, %rcx
movq %rcx, %rdx
subq %rax, %rdx
imulq $0x64, %rdx, %rax
xorl %edx, %edx
divq %rcx
movl %eax, %ecx
subl 0xbc5cc4(%rip), %ecx # 0xc52d3c
cmpl $0xa, %ecx
jb 0x8d0b4
movl %eax, 0xbc5cb9(%rip) # 0xc52d3c
movq 0x327f26(%rip), %r14 # 0x3b4fb0
movq (%r14), %rdi
leaq 0x796e6(%rip), %rdx # 0x10677a
movl $0x1, %esi
movl %eax, %ecx
xorl %eax, %eax
callq 0x2b210
movq (%r14), %rdi
callq 0x2b490
leaq 0xbc5c9f(%rip), %rax # 0xc52d50
movb $0x1, (%rax)
movzwl 0x18(%rbx), %r15d
movl 0x420(%rbx), %eax
decl %eax
cmpl $0xd, %eax
ja 0x8d101
movl $0x396f, %ecx # imm = 0x396F
btl %eax, %ecx
jae 0x8d101
movl %eax, %eax
leaq 0x811a3(%rip), %rcx # 0x10e27c
movb (%rax,%rcx), %r12b
movl 0x1a(%rbx), %eax
movzbl 0x1e(%rbx), %edi
shlq $0x20, %rdi
orq %rax, %rdi
leaq -0x50(%rbp), %rsi
movq %rdi, -0x60(%rbp)
callq 0xfa484
movl $0x0, -0x54(%rbp)
jmp 0x8d109
movb $0x1, %al
movl %eax, -0x54(%rbp)
xorl %r12d, %r12d
movq (%r13), %rdi
leaq 0x79547(%rip), %rsi # 0x10665b
movl %r15d, %edx
xorl %eax, %eax
callq 0x8da80
movq 0xbc5b4b(%rip), %rax # 0xc52c70
movl %r15d, %ecx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x8d1b0
movl %r12d, -0x58(%rbp)
movq (%r14), %r12
movq (%r13), %rdi
leaq 0x5e0(%r12), %r13
movq 0x5e0(%r12), %rdx
leaq 0x79549(%rip), %rsi # 0x10669c
xorl %eax, %eax
callq 0x8da80
movq %r13, %rdi
callq 0x8d24e
testb %al, %al
je 0x8d1bd
leaq 0xbc5c5b(%rip), %rax # 0xc52dc8
movq (%rbx), %rsi
movq 0xc10(%r12), %rcx
cmpq %rcx, %rsi
jle 0x8d1da
movq 0x188(%r12), %rcx
cmpq %rcx, %rsi
movq %rax, %rbx
jle 0x8d1ed
cmpb $0x0, -0x54(%rbp)
jne 0x8d229
movsbl -0x58(%rbp), %ecx
movl %r15d, %edi
movq -0x60(%rbp), %rdx
callq 0x8dc1b
testb %al, %al
je 0x8d229
xorl %r14d, %r14d
jmp 0x8d208
movq (%r13), %rdi
leaq 0x794bc(%rip), %rsi # 0x106677
jmp 0x8d1ce
leaq 0xbc5c04(%rip), %rax # 0xc52dc8
movq (%rax), %rdi
leaq 0x794d5(%rip), %rsi # 0x1066a3
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x8da80
jmp 0x8d208
movq (%rax), %rdi
movq %rcx, %rdx
shrq $0x20, %rdx
leaq 0x794cb(%rip), %rsi # 0x1066b6
jmp 0x8d1fe
movq (%rbx), %rdi
movq %rcx, %rdx
shrq $0x20, %rdx
leaq 0x7950c(%rip), %rsi # 0x10670a
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x8da80
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x8d249
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
leaq 0x7951f(%rip), %rsi # 0x106752
xorl %eax, %eax
callq 0x8da80
movq %r14, %rdi
movl $0x1, %esi
callq 0x4417e
jmp 0x8d208
callq 0x2b280
| get_MARIA_HA_from_REDO_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r13, tracef
mov rax, [r13+0]
mov rcx, cs:stdout_ptr
cmp rax, [rcx]
jz loc_8D0B4
mov r14, [rbx]
cmp cs:recovery_message_printed, 0
jnz short loc_8CFED
lea rsi, aAriaEngineS; "Aria engine: %s"
lea rcx, aStartingRecove; "starting recovery"
mov edx, 400h
mov edi, 0A8h
xor eax, eax
call my_printf_error
mov r15, cs:stderr_ptr
mov rdi, [r15]
lea rdx, aRecoveredPages; "recovered pages: 0%%"
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [r15]
call _fflush
lea rax, procent_printed
mov byte ptr [rax], 1
mov cs:recovery_message_printed, 1
loc_8CFED:
mov eax, cs:print_redo_phase_progress_end_logno
test eax, eax
jnz short loc_8D011
xor eax, eax
call translog_get_horizon
mov ecx, eax
shr rax, 20h
mov cs:print_redo_phase_progress_end_logno, eax
mov cs:print_redo_phase_progress_end_offset, rcx
loc_8D011:
mov rdx, r14
shr rdx, 20h
mov ecx, r14d
cmp eax, edx
jnz short loc_8D02B
mov rax, cs:print_redo_phase_progress_end_offset
sub rax, rcx
jmp short loc_8D04A
loc_8D02B:
lea rsi, log_file_size
mov rsi, [rsi]
not edx
add eax, edx
imul rax, rsi
sub rsi, rcx
add rax, rsi
add rax, cs:print_redo_phase_progress_end_offset
loc_8D04A:
mov rcx, cs:print_redo_phase_progress_initial_remainder
cmp rcx, 0FFFFFFFFFFFFFFFFh
jnz short loc_8D061
mov cs:print_redo_phase_progress_initial_remainder, rax
mov rcx, rax
loc_8D061:
mov rdx, rcx
sub rdx, rax
imul rax, rdx, 64h ; 'd'
xor edx, edx
div rcx
mov ecx, eax
sub ecx, cs:print_redo_phase_progress_percentage_printed
cmp ecx, 0Ah
jb short loc_8D0B4
mov cs:print_redo_phase_progress_percentage_printed, eax
mov r14, cs:stderr_ptr
mov rdi, [r14]
lea rdx, aU; " %u%%"
mov esi, 1
mov ecx, eax
xor eax, eax
call ___fprintf_chk
mov rdi, [r14]
call _fflush
lea rax, procent_printed
mov byte ptr [rax], 1
loc_8D0B4:
movzx r15d, word ptr [rbx+18h]
mov eax, [rbx+420h]
dec eax
cmp eax, 0Dh
ja short loc_8D101
mov ecx, 396Fh
bt ecx, eax
jnb short loc_8D101
mov eax, eax
lea rcx, unk_10E27C
mov r12b, [rax+rcx]
mov eax, [rbx+1Ah]
movzx edi, byte ptr [rbx+1Eh]
shl rdi, 20h
or rdi, rax
lea rsi, [rbp+var_50]
mov [rbp+var_60], rdi
call llstr
mov [rbp+var_54], 0
jmp short loc_8D109
loc_8D101:
mov al, 1
mov [rbp+var_54], eax
xor r12d, r12d
loc_8D109:
mov rdi, [r13+0]
lea rsi, aForTableOfShor; " For table of short id %u"
mov edx, r15d
xor eax, eax
call tprint
mov rax, cs:all_tables
mov ecx, r15d
mov r14, [rax+rcx*8]
test r14, r14
jz short loc_8D1B0
mov [rbp+var_58], r12d
mov r12, [r14]
mov rdi, [r13+0]
lea r13, [r12+5E0h]
mov rdx, [r12+5E0h]
lea rsi, aS_0; ", '%s'"
xor eax, eax
call tprint
mov rdi, r13
call table_is_part_of_recovery_set
test al, al
jz short loc_8D1BD
lea rax, tracef
mov rsi, [rbx]
mov rcx, [r12+0C10h]
cmp rsi, rcx
jle short loc_8D1DA
mov rcx, [r12+188h]
cmp rsi, rcx
mov rbx, rax
jle short loc_8D1ED
cmp byte ptr [rbp+var_54], 0
jnz loc_8D229
movsx ecx, byte ptr [rbp+var_58]
mov edi, r15d
mov rdx, [rbp+var_60]
call _ma_redo_not_needed_for_page
test al, al
jz short loc_8D229
xor r14d, r14d
jmp short loc_8D208
loc_8D1B0:
mov rdi, [r13+0]
lea rsi, aTableSkippedSo; ", table skipped, so skipping record\n"
jmp short loc_8D1CE
loc_8D1BD:
lea rax, tracef
mov rdi, [rax]
lea rsi, aSkippedByUser; ", skipped by user\n"
loc_8D1CE:
xor r14d, r14d
xor eax, eax
call tprint
jmp short loc_8D208
loc_8D1DA:
mov rdi, [rax]
mov rdx, rcx
shr rdx, 20h
lea rsi, aTableSLogrecFi; ", table's LOGREC_FILE_ID has LSN (%u,0x"...
jmp short loc_8D1FE
loc_8D1ED:
mov rdi, [rbx]
mov rdx, rcx
shr rdx, 20h
lea rsi, aHasSkipRedoLsn; ", has skip_redo_lsn (%u,0x%x) more rece"...
loc_8D1FE:
xor r14d, r14d
xor eax, eax
call tprint
loc_8D208:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_8D249
mov rax, r14
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8D229:
mov rdi, [rbx]
lea rsi, aApplyingRecord; ", applying record\n"
xor eax, eax
call tprint
mov rdi, r14
mov esi, 1
call _ma_writeinfo
jmp short loc_8D208
loc_8D249:
call ___stack_chk_fail
| long long * get_MARIA_HA_from_REDO_record(long long *a1, long long a2, long long a3, long long a4, int a5, int a6)
{
unsigned long long v6; // rcx
long long v7; // r14
unsigned long long v8; // rax
unsigned long long horizon; // rax
long long v10; // rcx
long long v11; // rax
unsigned long long v12; // rax
unsigned long long v13; // rtt
unsigned int v14; // r15d
unsigned int v15; // eax
char v16; // r12
unsigned long long v17; // rdx
int v18; // r8d
int v19; // r9d
unsigned long long v20; // rcx
long long *v21; // r14
long long v22; // r12
_QWORD *v23; // r13
long long v24; // rsi
int v25; // edi
const char *v26; // rsi
unsigned long long v28; // [rsp+0h] [rbp-60h]
char v29; // [rsp+8h] [rbp-58h]
char v30; // [rsp+Ch] [rbp-54h]
_BYTE v31[32]; // [rsp+10h] [rbp-50h] BYREF
unsigned long long v32; // [rsp+30h] [rbp-30h]
v32 = __readfsqword(0x28u);
v6 = (unsigned long long)&stdout;
if ( tracef != stdout )
{
v7 = *a1;
if ( !recovery_message_printed )
{
my_printf_error(168, (unsigned int)"Aria engine: %s", 1024, (unsigned int)"starting recovery", a5, a6);
__fprintf_chk(stderr, 1LL, "recovered pages: 0%%");
fflush(stderr);
procent_printed = 1;
recovery_message_printed = 1;
}
LODWORD(v8) = print_redo_phase_progress_end_logno;
if ( !print_redo_phase_progress_end_logno )
{
horizon = translog_get_horizon();
v10 = (unsigned int)horizon;
v8 = HIDWORD(horizon);
print_redo_phase_progress_end_logno = v8;
print_redo_phase_progress_end_offset = v10;
}
if ( (_DWORD)v8 == HIDWORD(v7) )
v11 = print_redo_phase_progress_end_offset - (unsigned int)v7;
else
v11 = print_redo_phase_progress_end_offset
+ log_file_size
- (unsigned int)v7
+ log_file_size * (unsigned int)(~HIDWORD(v7) + v8);
v6 = print_redo_phase_progress_initial_remainder;
if ( print_redo_phase_progress_initial_remainder == -1 )
{
print_redo_phase_progress_initial_remainder = v11;
v6 = v11;
}
v13 = 100 * (v6 - v11);
v12 = v13 / v6;
LODWORD(v6) = v13 / v6 - print_redo_phase_progress_percentage_printed;
if ( (unsigned int)v6 >= 0xA )
{
print_redo_phase_progress_percentage_printed = v12;
__fprintf_chk(stderr, 1LL, " %u%%", v12);
fflush(stderr);
procent_printed = 1;
}
}
v14 = *((unsigned __int16 *)a1 + 12);
v15 = *((_DWORD *)a1 + 264) - 1;
if ( v15 <= 0xD && (LODWORD(v6) = 14703, _bittest((const int *)&v6, v15)) )
{
v16 = byte_10E27C[v15];
v28 = *(unsigned int *)((char *)a1 + 26) | ((unsigned long long)*((unsigned __int8 *)a1 + 30) << 32);
llstr(v28, v31);
v30 = 0;
}
else
{
v30 = 1;
v16 = 0;
}
tprint(tracef, (unsigned int)" For table of short id %u", v14, v6, a5, a6);
LODWORD(v20) = v14;
v21 = *(long long **)(all_tables + 8LL * v14);
if ( !v21 )
{
v25 = tracef;
v26 = ", table skipped, so skipping record\n";
LABEL_28:
v21 = 0LL;
tprint(v25, (_DWORD)v26, v17, v20, v18, v19);
return v21;
}
v29 = v16;
v22 = *v21;
v23 = (_QWORD *)(*v21 + 1504);
tprint(tracef, (unsigned int)", '%s'", *v23, v14, v18, v19);
if ( !(unsigned __int8)table_is_part_of_recovery_set(v23) )
{
v25 = tracef;
v26 = ", skipped by user\n";
goto LABEL_28;
}
v24 = *a1;
v20 = *(_QWORD *)(v22 + 3088);
if ( *a1 <= (long long)v20 )
{
v25 = tracef;
v17 = HIDWORD(v20);
v26 = ", table's LOGREC_FILE_ID has LSN (%u,0x%x) more recent than record, skipping record";
goto LABEL_28;
}
v20 = *(_QWORD *)(v22 + 392);
if ( v24 <= (long long)v20 )
{
v25 = tracef;
v17 = HIDWORD(v20);
v26 = ", has skip_redo_lsn (%u,0x%x) more recent than record, skipping record\n";
goto LABEL_28;
}
if ( !v30 && (unsigned __int8)ma_redo_not_needed_for_page(v14, v24, v28, (unsigned int)v29) )
return 0LL;
tprint(tracef, (unsigned int)", applying record\n", v17, v20, v18, v19);
ma_writeinfo(v21, 1);
return v21;
}
| get_MARIA_HA_from_REDO_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R13,[0xd52dc8]
MOV RAX,qword ptr [R13]
MOV RCX,qword ptr [0x004b4fa8]
CMP RAX,qword ptr [RCX]
JZ 0x0018d0b4
MOV R14,qword ptr [RBX]
CMP dword ptr [0x00d52c78],0x0
JNZ 0x0018cfed
LEA RSI,[0x204dd1]
LEA RCX,[0x206780]
MOV EDX,0x400
MOV EDI,0xa8
XOR EAX,EAX
CALL 0x001bf641
MOV R15,qword ptr [0x004b4fb0]
MOV RDI,qword ptr [R15]
LEA RDX,[0x206765]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x0012b210
MOV RDI,qword ptr [R15]
CALL 0x0012b490
LEA RAX,[0xd52d50]
MOV byte ptr [RAX],0x1
MOV dword ptr [0x00d52c78],0x1
LAB_0018cfed:
MOV EAX,dword ptr [0x00d52d38]
TEST EAX,EAX
JNZ 0x0018d011
XOR EAX,EAX
CALL 0x0017e2d0
MOV ECX,EAX
SHR RAX,0x20
MOV dword ptr [0x00d52d38],EAX
MOV qword ptr [0x00d52d40],RCX
LAB_0018d011:
MOV RDX,R14
SHR RDX,0x20
MOV ECX,R14D
CMP EAX,EDX
JNZ 0x0018d02b
MOV RAX,qword ptr [0x00d52d40]
SUB RAX,RCX
JMP 0x0018d04a
LAB_0018d02b:
LEA RSI,[0x4b6cc8]
MOV RSI,qword ptr [RSI]
NOT EDX
ADD EAX,EDX
IMUL RAX,RSI
SUB RSI,RCX
ADD RAX,RSI
ADD RAX,qword ptr [0x00d52d40]
LAB_0018d04a:
MOV RCX,qword ptr [0x004b6d30]
CMP RCX,-0x1
JNZ 0x0018d061
MOV qword ptr [0x004b6d30],RAX
MOV RCX,RAX
LAB_0018d061:
MOV RDX,RCX
SUB RDX,RAX
IMUL RAX,RDX,0x64
XOR EDX,EDX
DIV RCX
MOV ECX,EAX
SUB ECX,dword ptr [0x00d52d3c]
CMP ECX,0xa
JC 0x0018d0b4
MOV dword ptr [0x00d52d3c],EAX
MOV R14,qword ptr [0x004b4fb0]
MOV RDI,qword ptr [R14]
LEA RDX,[0x20677a]
MOV ESI,0x1
MOV ECX,EAX
XOR EAX,EAX
CALL 0x0012b210
MOV RDI,qword ptr [R14]
CALL 0x0012b490
LEA RAX,[0xd52d50]
MOV byte ptr [RAX],0x1
LAB_0018d0b4:
MOVZX R15D,word ptr [RBX + 0x18]
MOV EAX,dword ptr [RBX + 0x420]
DEC EAX
CMP EAX,0xd
JA 0x0018d101
MOV ECX,0x396f
BT ECX,EAX
JNC 0x0018d101
MOV EAX,EAX
LEA RCX,[0x20e27c]
MOV R12B,byte ptr [RAX + RCX*0x1]
MOV EAX,dword ptr [RBX + 0x1a]
MOVZX EDI,byte ptr [RBX + 0x1e]
SHL RDI,0x20
OR RDI,RAX
LEA RSI,[RBP + -0x50]
MOV qword ptr [RBP + -0x60],RDI
CALL 0x001fa484
MOV dword ptr [RBP + -0x54],0x0
JMP 0x0018d109
LAB_0018d101:
MOV AL,0x1
MOV dword ptr [RBP + -0x54],EAX
XOR R12D,R12D
LAB_0018d109:
MOV RDI,qword ptr [R13]
LEA RSI,[0x20665b]
MOV EDX,R15D
XOR EAX,EAX
CALL 0x0018da80
MOV RAX,qword ptr [0x00d52c70]
MOV ECX,R15D
MOV R14,qword ptr [RAX + RCX*0x8]
TEST R14,R14
JZ 0x0018d1b0
MOV dword ptr [RBP + -0x58],R12D
MOV R12,qword ptr [R14]
MOV RDI,qword ptr [R13]
LEA R13,[R12 + 0x5e0]
MOV RDX,qword ptr [R12 + 0x5e0]
LEA RSI,[0x20669c]
XOR EAX,EAX
CALL 0x0018da80
MOV RDI,R13
CALL 0x0018d24e
TEST AL,AL
JZ 0x0018d1bd
LEA RAX,[0xd52dc8]
MOV RSI,qword ptr [RBX]
MOV RCX,qword ptr [R12 + 0xc10]
CMP RSI,RCX
JLE 0x0018d1da
MOV RCX,qword ptr [R12 + 0x188]
CMP RSI,RCX
MOV RBX,RAX
JLE 0x0018d1ed
CMP byte ptr [RBP + -0x54],0x0
JNZ 0x0018d229
MOVSX ECX,byte ptr [RBP + -0x58]
MOV EDI,R15D
MOV RDX,qword ptr [RBP + -0x60]
CALL 0x0018dc1b
TEST AL,AL
JZ 0x0018d229
XOR R14D,R14D
JMP 0x0018d208
LAB_0018d1b0:
MOV RDI,qword ptr [R13]
LEA RSI,[0x206677]
JMP 0x0018d1ce
LAB_0018d1bd:
LEA RAX,[0xd52dc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x2066a3]
LAB_0018d1ce:
XOR R14D,R14D
XOR EAX,EAX
CALL 0x0018da80
JMP 0x0018d208
LAB_0018d1da:
MOV RDI,qword ptr [RAX]
MOV RDX,RCX
SHR RDX,0x20
LEA RSI,[0x2066b6]
JMP 0x0018d1fe
LAB_0018d1ed:
MOV RDI,qword ptr [RBX]
MOV RDX,RCX
SHR RDX,0x20
LEA RSI,[0x20670a]
LAB_0018d1fe:
XOR R14D,R14D
XOR EAX,EAX
CALL 0x0018da80
LAB_0018d208:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0018d249
MOV RAX,R14
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018d229:
MOV RDI,qword ptr [RBX]
LEA RSI,[0x206752]
XOR EAX,EAX
CALL 0x0018da80
MOV RDI,R14
MOV ESI,0x1
CALL 0x0014417e
JMP 0x0018d208
LAB_0018d249:
CALL 0x0012b280
|
long * get_MARIA_HA_from_REDO_record(ulong *param_1)
{
ushort uVar1;
ulong uVar2;
bool bVar3;
int *puVar4;
char cVar5;
char cVar6;
int iVar7;
uint uVar8;
ulong uVar9;
long lVar10;
char *pcVar11;
long *plVar12;
long in_FS_OFFSET;
ulong local_68;
int1 local_58 [32];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (tracef != *(long *)PTR_stdout_004b4fa8) {
uVar2 = *param_1;
if (recovery_message_printed == 0) {
my_printf_error(0xa8,"Aria engine: %s",0x400,"starting recovery");
puVar4 = PTR_stderr_004b4fb0;
__fprintf_chk(*(int8 *)PTR_stderr_004b4fb0,1,"recovered pages: 0%%");
fflush(*(FILE **)puVar4);
procent_printed = 1;
recovery_message_printed = 1;
}
if (print_redo_phase_progress_end_logno == 0) {
uVar9 = translog_get_horizon();
print_redo_phase_progress_end_offset = uVar9 & 0xffffffff;
print_redo_phase_progress_end_logno = (uint)(uVar9 >> 0x20);
}
puVar4 = PTR_stderr_004b4fb0;
uVar9 = uVar2 & 0xffffffff;
uVar8 = (uint)(uVar2 >> 0x20);
if (print_redo_phase_progress_end_logno == uVar8) {
lVar10 = -uVar9;
}
else {
lVar10 = (ulong)(print_redo_phase_progress_end_logno + ~uVar8) * log_file_size +
(log_file_size - uVar9);
}
if (print_redo_phase_progress_initial_remainder == 0xffffffffffffffff) {
print_redo_phase_progress_initial_remainder = print_redo_phase_progress_end_offset + lVar10;
}
uVar2 = ((print_redo_phase_progress_initial_remainder -
(print_redo_phase_progress_end_offset + lVar10)) * 100) /
print_redo_phase_progress_initial_remainder;
iVar7 = (int)uVar2;
if (9 < (uint)(iVar7 - print_redo_phase_progress_percentage_printed)) {
print_redo_phase_progress_percentage_printed = iVar7;
__fprintf_chk(*(int8 *)PTR_stderr_004b4fb0,1," %u%%",uVar2 & 0xffffffff);
fflush(*(FILE **)puVar4);
procent_printed = 1;
}
}
uVar1 = (ushort)param_1[3];
uVar8 = (int)param_1[0x84] - 1;
if ((uVar8 < 0xe) && ((0x396fU >> (uVar8 & 0x1f) & 1) != 0)) {
cVar6 = (&DAT_0020e27c)[uVar8];
local_68 = (ulong)*(uint5 *)((long)param_1 + 0x1a);
llstr(local_68,local_58);
bVar3 = false;
}
else {
bVar3 = true;
cVar6 = '\0';
}
tprint(tracef," For table of short id %u",uVar1);
plVar12 = *(long **)(all_tables + (ulong)uVar1 * 8);
if (plVar12 == (long *)0x0) {
pcVar11 = ", table skipped, so skipping record\n";
}
else {
lVar10 = *plVar12;
tprint(tracef,", \'%s\'",*(int8 *)(lVar10 + 0x5e0));
cVar5 = table_is_part_of_recovery_set(lVar10 + 0x5e0);
if (cVar5 != '\0') {
uVar2 = *param_1;
uVar9 = *(ulong *)(lVar10 + 0xc10);
if ((long)uVar9 < (long)uVar2) {
uVar9 = *(ulong *)(lVar10 + 0x188);
if ((long)uVar9 < (long)uVar2) {
if (!bVar3) {
cVar6 = _ma_redo_not_needed_for_page(uVar1,uVar2,local_68,(int)cVar6);
if (cVar6 != '\0') {
plVar12 = (long *)0x0;
goto LAB_0018d208;
}
}
tprint(tracef,", applying record\n");
_ma_writeinfo(plVar12,1);
goto LAB_0018d208;
}
pcVar11 = ", has skip_redo_lsn (%u,0x%x) more recent than record, skipping record\n";
}
else {
pcVar11 =
", table\'s LOGREC_FILE_ID has LSN (%u,0x%x) more recent than record, skipping record";
}
plVar12 = (long *)0x0;
tprint(tracef,pcVar11,uVar9 >> 0x20);
goto LAB_0018d208;
}
pcVar11 = ", skipped by user\n";
}
plVar12 = (long *)0x0;
tprint(tracef,pcVar11);
LAB_0018d208:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return plVar12;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
24,160 | 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;
} | O0 | c | my_fprintf:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x7d278
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)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x7d090
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
| my_fprintf:
push rbp
mov rbp, rsp
sub rsp, 0E0h
test al, al
jz short loc_7D278
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_7D278:
mov [rbp+var_B8], r9
mov [rbp+var_C0], r8
mov [rbp+var_C8], rcx
mov [rbp+var_D0], rdx
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
lea rax, [rbp+var_E0]
mov [rbp+var_20], rax
lea rax, [rbp+arg_0]
mov [rbp+var_28], rax
mov [rbp+var_2C], 30h ; '0'
mov [rbp+var_30], 10h
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
lea rdx, [rbp+var_30]
call my_vfprintf
mov [rbp+var_14], eax
mov eax, [rbp+var_14]
add rsp, 0E0h
pop rbp
retn
| long long my_fprintf(
long long a1,
char *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-E0h] BYREF
long long v17; // [rsp+10h] [rbp-D0h]
long long v18; // [rsp+18h] [rbp-C8h]
long long v19; // [rsp+20h] [rbp-C0h]
long long v20; // [rsp+28h] [rbp-B8h]
__m128 v21; // [rsp+30h] [rbp-B0h]
__m128 v22; // [rsp+40h] [rbp-A0h]
__m128 v23; // [rsp+50h] [rbp-90h]
__m128 v24; // [rsp+60h] [rbp-80h]
__m128 v25; // [rsp+70h] [rbp-70h]
__m128 v26; // [rsp+80h] [rbp-60h]
__m128 v27; // [rsp+90h] [rbp-50h]
__m128 v28; // [rsp+A0h] [rbp-40h]
int v29[2]; // [rsp+B0h] [rbp-30h] BYREF
char *v30; // [rsp+B8h] [rbp-28h]
char *v31; // [rsp+C0h] [rbp-20h]
char *v32; // [rsp+D0h] [rbp-10h]
long long v33; // [rsp+D8h] [rbp-8h]
v21 = a7;
v22 = a8;
v23 = a9;
v24 = a10;
v25 = a11;
v26 = a12;
v27 = a13;
v28 = a14;
v20 = a6;
v19 = a5;
v18 = a4;
v17 = a3;
v33 = a1;
v32 = a2;
v31 = &v16;
v30 = &a15;
v29[1] = 48;
v29[0] = 16;
return (unsigned int)my_vfprintf(a1, a2, v29);
}
| my_fprintf:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
TEST AL,AL
JZ 0x0017d278
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_0017d278:
MOV qword ptr [RBP + -0xb8],R9
MOV qword ptr [RBP + -0xc0],R8
MOV qword ptr [RBP + -0xc8],RCX
MOV qword ptr [RBP + -0xd0],RDX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
LEA RAX,[RBP + -0xe0]
MOV qword ptr [RBP + -0x20],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV dword ptr [RBP + -0x2c],0x30
MOV dword ptr [RBP + -0x30],0x10
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x30]
CALL 0x0017d090
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x14]
ADD RSP,0xe0
POP RBP
RET
|
int4
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;
int4 uVar1;
int1 local_e8 [16];
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;
int4 local_38;
int4 local_34;
int1 *local_30;
int1 *local_28;
int8 local_18;
int8 local_10;
if (in_AL != '\0') {
local_b8 = param_1;
local_a8 = param_2;
local_98 = param_3;
local_88 = param_4;
local_78 = param_5;
local_68 = param_6;
local_58 = param_7;
local_48 = param_8;
}
local_28 = local_e8;
local_30 = &stack0x00000008;
local_34 = 0x30;
local_38 = 0x10;
local_d8 = param_11;
local_d0 = param_12;
local_c8 = param_13;
local_c0 = param_14;
local_18 = param_10;
local_10 = param_9;
uVar1 = my_vfprintf(param_9,param_10,&local_38);
return uVar1;
}
| |
24,161 | my_register_filename | eloqsql/mysys/my_open.c | File my_register_filename(File fd, const char *FileName, enum file_type
type_of_file, uint error_message_number, myf MyFlags)
{
DBUG_ENTER("my_register_filename");
if ((int) fd >= MY_FILE_MIN)
{
my_atomic_add32_explicit(&my_file_opened, 1, MY_MEMORY_ORDER_RELAXED);
if ((uint) fd >= my_file_limit || (MyFlags & MY_NO_REGISTER))
DBUG_RETURN(fd);
my_file_info[fd].name = my_strdup(key_memory_my_file_info, FileName, MyFlags);
statistic_increment(my_file_total_opened,&THR_LOCK_open);
my_file_info[fd].type = type_of_file;
DBUG_PRINT("exit",("fd: %d",fd));
DBUG_RETURN(fd);
}
my_errno= errno;
DBUG_PRINT("error",("Got error %d on open", my_errno));
if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
{
if (my_errno == EMFILE)
error_message_number= EE_OUT_OF_FILERESOURCES;
my_error(error_message_number,
MYF(ME_BELL | (MyFlags & (ME_NOTE | ME_ERROR_LOG))),
FileName, my_errno);
}
DBUG_RETURN(-1);
} | O3 | c | my_register_filename:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rsi, %r15
testl %edi, %edi
js 0x34fa5
movl %edi, %ebx
leaq 0x33f2ad(%rip), %rax # 0x3741f4
lock
incl (%rax)
testl $0x2004, %r14d # imm = 0x2004
jne 0x34ff4
leaq 0x2c8402(%rip), %rax # 0x2fd360
cmpl %ebx, (%rax)
jbe 0x34ff4
movl %edx, %r13d
leaq 0x33f7b4(%rip), %rax # 0x374724
movl (%rax), %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x28c98
leaq 0x2c83e4(%rip), %rcx # 0x2fd368
movq (%rcx), %rdx
movl %ebx, %esi
shlq $0x4, %rsi
movq %rax, (%rdx,%rsi)
leaq 0x33f248(%rip), %rax # 0x3741e0
incq (%rax)
movq (%rcx), %rax
movl %r13d, 0x8(%rax,%rsi)
jmp 0x34ff4
movl %ecx, %r12d
callq 0x24060
movl (%rax), %ebx
callq 0x293f2
movl %ebx, (%rax)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testb $0x19, %r14b
je 0x34ff4
callq 0x293f2
cmpl $0x18, (%rax)
movl $0x17, %eax
cmovel %eax, %r12d
andl $0x440, %r14d # imm = 0x440
orq $0x4, %r14
callq 0x293f2
movl (%rax), %ecx
movl %r12d, %edi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x34477
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_register_filename:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15, rsi
test edi, edi
js short loc_34FA5
mov ebx, edi
lea rax, my_file_opened
lock inc dword ptr [rax]
test r14d, 2004h
jnz loc_34FF4
lea rax, my_file_limit
cmp [rax], ebx
jbe loc_34FF4
mov r13d, edx
lea rax, key_memory_my_file_info
mov edi, [rax]
mov rsi, r15
mov rdx, r14
call my_strdup
lea rcx, my_file_info
mov rdx, [rcx]
mov esi, ebx
shl rsi, 4
mov [rdx+rsi], rax
lea rax, my_file_total_opened
inc qword ptr [rax]
mov rax, [rcx]
mov [rax+rsi+8], r13d
jmp short loc_34FF4
loc_34FA5:
mov r12d, ecx
call ___errno_location
mov ebx, [rax]
call _my_thread_var
mov [rax], ebx
mov ebx, 0FFFFFFFFh
test r14b, 19h
jz short loc_34FF4
call _my_thread_var
cmp dword ptr [rax], 18h
mov eax, 17h
cmovz r12d, eax
and r14d, 440h
or r14, 4
call _my_thread_var
mov ecx, [rax]
mov edi, r12d
mov rsi, r14
mov rdx, r15
xor eax, eax
call my_error
loc_34FF4:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_register_filename(long long a1, long long a2, int a3, unsigned int a4, __int16 a5)
{
unsigned int v6; // ebx
long long v8; // rax
long long v9; // rsi
int v11; // ebx
unsigned int *v12; // rax
if ( (int)a1 < 0 )
{
v11 = *(_DWORD *)__errno_location(a1);
*(_DWORD *)my_thread_var() = v11;
v6 = -1;
if ( (a5 & 0x19) != 0 )
{
if ( *(_DWORD *)my_thread_var() == 24 )
a4 = 23;
v12 = (unsigned int *)my_thread_var();
my_error(a4, a5 & 0x440 | 4, a2, *v12);
}
}
else
{
v6 = a1;
_InterlockedIncrement(my_file_opened);
if ( (a5 & 0x2004) == 0 && my_file_limit > (unsigned int)a1 )
{
v8 = my_strdup(key_memory_my_file_info, a2, a5);
v9 = 16LL * (unsigned int)a1;
*(_QWORD *)((char *)my_file_info + v9) = v8;
++my_file_total_opened;
*(_DWORD *)((char *)my_file_info + v9 + 8) = a3;
}
}
return v6;
}
| my_register_filename:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15,RSI
TEST EDI,EDI
JS 0x00134fa5
MOV EBX,EDI
LEA RAX,[0x4741f4]
INC.LOCK dword ptr [RAX]
TEST R14D,0x2004
JNZ 0x00134ff4
LEA RAX,[0x3fd360]
CMP dword ptr [RAX],EBX
JBE 0x00134ff4
MOV R13D,EDX
LEA RAX,[0x474724]
MOV EDI,dword ptr [RAX]
MOV RSI,R15
MOV RDX,R14
CALL 0x00128c98
LEA RCX,[0x3fd368]
MOV RDX,qword ptr [RCX]
MOV ESI,EBX
SHL RSI,0x4
MOV qword ptr [RDX + RSI*0x1],RAX
LEA RAX,[0x4741e0]
INC qword ptr [RAX]
MOV RAX,qword ptr [RCX]
MOV dword ptr [RAX + RSI*0x1 + 0x8],R13D
JMP 0x00134ff4
LAB_00134fa5:
MOV R12D,ECX
CALL 0x00124060
MOV EBX,dword ptr [RAX]
CALL 0x001293f2
MOV dword ptr [RAX],EBX
MOV EBX,0xffffffff
TEST R14B,0x19
JZ 0x00134ff4
CALL 0x001293f2
CMP dword ptr [RAX],0x18
MOV EAX,0x17
CMOVZ R12D,EAX
AND R14D,0x440
OR R14,0x4
CALL 0x001293f2
MOV ECX,dword ptr [RAX]
MOV EDI,R12D
MOV RSI,R14
MOV RDX,R15
XOR EAX,EAX
CALL 0x00134477
LAB_00134ff4:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint my_register_filename
(uint param_1,int8 param_2,int4 param_3,int4 param_4,ulong param_5)
{
int iVar1;
int8 uVar2;
int *piVar3;
int4 *puVar4;
if ((int)param_1 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
param_1 = 0xffffffff;
if ((param_5 & 0x19) != 0) {
piVar3 = (int *)_my_thread_var();
if (*piVar3 == 0x18) {
param_4 = 0x17;
}
puVar4 = (int4 *)_my_thread_var();
my_error(param_4,(uint)param_5 & 0x440 | 4,param_2,*puVar4);
}
}
else {
LOCK();
my_file_opened = my_file_opened + 1;
UNLOCK();
if (((param_5 & 0x2004) == 0) && (param_1 < my_file_limit)) {
uVar2 = my_strdup(key_memory_my_file_info,param_2,param_5);
*(int8 *)(my_file_info + (ulong)param_1 * 0x10) = uVar2;
my_file_total_opened = my_file_total_opened + 1;
*(int4 *)(my_file_info + (ulong)param_1 * 0x10 + 8) = param_3;
}
}
return param_1;
}
| |
24,162 | lshift | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static Bigint *lshift(Bigint *b, int k, Stack_alloc *alloc)
{
int i, k1, n, n1;
Bigint *b1;
ULong *x, *x1, *xe, z;
n= k >> 5;
k1= b->k;
n1= n + b->wds + 1;
for (i= b->maxwds; n1 > i; i<<= 1)
k1++;
b1= Balloc(k1, alloc);
x1= b1->p.x;
for (i= 0; i < n; i++)
*x1++= 0;
x= b->p.x;
xe= x + b->wds;
if (k&= 0x1f)
{
k1= 32 - k;
z= 0;
do
{
*x1++= *x << k | z;
z= *x++ >> k1;
}
while (x < xe);
if ((*x1= z))
++n1;
}
else
do
*x1++= *x++;
while (x < xe);
b1->wds= n1 - 1;
Bfree(b, alloc);
return b1;
} | O0 | c | lshift:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
sarl $0x5, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
addl 0x14(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x34d5b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
jmp 0x34d40
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x350b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x34da5
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl $0x0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x34d7d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x14(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x34e44
movl $0x20, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl -0xc(%rbp), %ecx
shll %cl, %eax
movl %eax, %ecx
orl -0x4c(%rbp), %ecx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x40(%rbp)
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %eax
movl -0x20(%rbp), %ecx
shrl %cl, %eax
movl %eax, -0x4c(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x34de7
movl -0x4c(%rbp), %eax
movq -0x40(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
je 0x34e42
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x34e74
jmp 0x34e46
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x40(%rbp)
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x34e46
jmp 0x34e74
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34bb0
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| lshift:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov eax, [rbp+var_C]
sar eax, 5
mov [rbp+var_24], eax
mov rax, [rbp+var_8]
mov eax, [rax+8]
mov [rbp+var_20], eax
mov eax, [rbp+var_24]
mov rcx, [rbp+var_8]
add eax, [rcx+14h]
add eax, 1
mov [rbp+var_28], eax
mov rax, [rbp+var_8]
mov eax, [rax+0Ch]
mov [rbp+var_1C], eax
loc_34D40:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_1C]
jle short loc_34D5B
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
mov eax, [rbp+var_1C]
shl eax, 1
mov [rbp+var_1C], eax
jmp short loc_34D40
loc_34D5B:
mov edi, [rbp+var_20]
mov rsi, [rbp+var_18]
call Balloc
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_40], rax
mov [rbp+var_1C], 0
loc_34D7D:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_24]
jge short loc_34DA5
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov dword ptr [rax], 0
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_34D7D
loc_34DA5:
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+14h]
shl rcx, 2
add rax, rcx
mov [rbp+var_48], rax
mov eax, [rbp+var_C]
and eax, 1Fh
mov [rbp+var_C], eax
cmp eax, 0
jz short loc_34E44
mov eax, 20h ; ' '
sub eax, [rbp+var_C]
mov [rbp+var_20], eax
mov [rbp+var_4C], 0
loc_34DE7:
mov rax, [rbp+var_38]
mov eax, [rax]
mov ecx, [rbp+var_C]
shl eax, cl
mov ecx, eax
or ecx, [rbp+var_4C]
mov rax, [rbp+var_40]
mov rdx, rax
add rdx, 4
mov [rbp+var_40], rdx
mov [rax], ecx
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 4
mov [rbp+var_38], rcx
mov eax, [rax]
mov ecx, [rbp+var_20]
shr eax, cl
mov [rbp+var_4C], eax
mov rax, [rbp+var_38]
cmp rax, [rbp+var_48]
jb short loc_34DE7
mov eax, [rbp+var_4C]
mov rcx, [rbp+var_40]
mov [rcx], eax
cmp eax, 0
jz short loc_34E42
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_28], eax
loc_34E42:
jmp short loc_34E74
loc_34E44:
jmp short $+2
loc_34E46:
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 4
mov [rbp+var_38], rcx
mov ecx, [rax]
mov rax, [rbp+var_40]
mov rdx, rax
add rdx, 4
mov [rbp+var_40], rdx
mov [rax], ecx
mov rax, [rbp+var_38]
cmp rax, [rbp+var_48]
jb short loc_34E46
jmp short $+2
loc_34E74:
mov ecx, [rbp+var_28]
sub ecx, 1
mov rax, [rbp+var_30]
mov [rax+14h], ecx
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call Bfree
mov rax, [rbp+var_30]
add rsp, 50h
pop rbp
retn
| long long lshift(unsigned long long a1, int a2, unsigned long long *a3)
{
int *v3; // rax
int *v4; // rax
int *v5; // rax
int *v6; // rax
int v7; // ecx
int *v8; // rax
int v10; // [rsp+4h] [rbp-4Ch]
unsigned long long v11; // [rsp+8h] [rbp-48h]
int *v12; // [rsp+10h] [rbp-40h]
int *v13; // [rsp+18h] [rbp-38h]
long long v14; // [rsp+20h] [rbp-30h]
int v15; // [rsp+28h] [rbp-28h]
unsigned int v16; // [rsp+30h] [rbp-20h]
int i; // [rsp+34h] [rbp-1Ch]
int j; // [rsp+34h] [rbp-1Ch]
char v20; // [rsp+44h] [rbp-Ch]
v16 = *(_DWORD *)(a1 + 8);
v15 = *(_DWORD *)(a1 + 20) + (a2 >> 5) + 1;
for ( i = *(_DWORD *)(a1 + 12); v15 > i; i *= 2 )
++v16;
v14 = Balloc(v16, a3);
v12 = *(int **)v14;
for ( j = 0; j < a2 >> 5; ++j )
{
v3 = v12++;
*v3 = 0;
}
v13 = *(int **)a1;
v11 = 4LL * *(int *)(a1 + 20) + *(_QWORD *)a1;
v20 = a2 & 0x1F;
if ( (a2 & 0x1F) != 0 )
{
v10 = 0;
do
{
v4 = v12++;
*v4 = v10 | (*v13 << v20);
v5 = v13++;
v10 = (unsigned int)*v5 >> (32 - v20);
}
while ( (unsigned long long)v13 < v11 );
*v12 = v10;
if ( v10 )
++v15;
}
else
{
do
{
v6 = v13++;
v7 = *v6;
v8 = v12++;
*v8 = v7;
}
while ( (unsigned long long)v13 < v11 );
}
*(_DWORD *)(v14 + 20) = v15 - 1;
Bfree(a1, a3);
return v14;
}
| lshift:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV EAX,dword ptr [RBP + -0xc]
SAR EAX,0x5
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x8]
ADD EAX,dword ptr [RCX + 0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x1c],EAX
LAB_00134d40:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x1c]
JLE 0x00134d5b
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x1c]
SHL EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00134d40
LAB_00134d5b:
MOV EDI,dword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001350b0
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x1c],0x0
LAB_00134d7d:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x24]
JGE 0x00134da5
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x40],RCX
MOV dword ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00134d7d
LAB_00134da5:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x14]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x1f
MOV dword ptr [RBP + -0xc],EAX
CMP EAX,0x0
JZ 0x00134e44
MOV EAX,0x20
SUB EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x20],EAX
MOV dword ptr [RBP + -0x4c],0x0
LAB_00134de7:
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0xc]
SHL EAX,CL
MOV ECX,EAX
OR ECX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x40]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x40],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x38],RCX
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x20]
SHR EAX,CL
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x48]
JC 0x00134de7
MOV EAX,dword ptr [RBP + -0x4c]
MOV RCX,qword ptr [RBP + -0x40]
MOV dword ptr [RCX],EAX
CMP EAX,0x0
JZ 0x00134e42
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
LAB_00134e42:
JMP 0x00134e74
LAB_00134e44:
JMP 0x00134e46
LAB_00134e46:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x38],RCX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x40]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x40],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x48]
JC 0x00134e46
JMP 0x00134e74
LAB_00134e74:
MOV ECX,dword ptr [RBP + -0x28]
SUB ECX,0x1
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x14],ECX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00134bb0
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x50
POP RBP
RET
|
int8 * lshift(int8 *param_1,uint param_2,int8 param_3)
{
sbyte sVar1;
int iVar2;
int8 *puVar3;
uint *puVar4;
uint *puVar5;
uint *puVar6;
uint local_54;
uint *local_48;
uint *local_40;
int local_30;
int local_28;
int local_24;
local_28 = *(int *)(param_1 + 1);
iVar2 = ((int)param_2 >> 5) + *(int *)((long)param_1 + 0x14);
local_30 = iVar2 + 1;
for (local_24 = *(int *)((long)param_1 + 0xc); local_24 < local_30; local_24 = local_24 << 1) {
local_28 = local_28 + 1;
}
puVar3 = (int8 *)Balloc(local_28,param_3);
local_48 = (uint *)*puVar3;
for (local_24 = 0; local_24 < (int)param_2 >> 5; local_24 = local_24 + 1) {
*local_48 = 0;
local_48 = local_48 + 1;
}
local_40 = (uint *)*param_1;
puVar4 = local_40 + *(int *)((long)param_1 + 0x14);
if ((param_2 & 0x1f) == 0) {
do {
puVar5 = local_40 + 1;
*local_48 = *local_40;
local_48 = local_48 + 1;
local_40 = puVar5;
} while (puVar5 < puVar4);
}
else {
sVar1 = (sbyte)(param_2 & 0x1f);
local_54 = 0;
do {
puVar6 = local_48 + 1;
*local_48 = *local_40 << sVar1 | local_54;
puVar5 = local_40 + 1;
local_54 = *local_40 >> (0x20U - sVar1 & 0x1f);
local_48 = puVar6;
local_40 = puVar5;
} while (puVar5 < puVar4);
*puVar6 = local_54;
if (local_54 != 0) {
local_30 = iVar2 + 2;
}
}
*(int *)((long)puVar3 + 0x14) = local_30 + -1;
Bfree(param_1,param_3);
return puVar3;
}
| |
24,163 | flush_log_for_bitmap | eloqsql/storage/maria/ma_bitmap.c | static my_bool
flush_log_for_bitmap(PAGECACHE_IO_HOOK_ARGS *args __attribute__ ((unused)))
{
#ifdef DBUG_ASSERT_EXISTS
const MARIA_SHARE *share= (MARIA_SHARE*)args->data;
#endif
DBUG_ENTER("flush_log_for_bitmap");
DBUG_ASSERT(share->now_transactional);
/*
WAL imposes that UNDOs reach disk before bitmap is flushed. We don't know
the LSN of the last UNDO about this bitmap page, so we flush whole log.
*/
DBUG_RETURN(translog_flush(translog_get_horizon()));
} | O0 | c | flush_log_for_bitmap:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x6671e
jmp 0x66720
movb $0x0, %al
callq 0x343e0
movq %rax, %rdi
callq 0x36020
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| flush_log_for_bitmap:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_6671E:
jmp short $+2
loc_66720:
mov al, 0
call translog_get_horizon
mov rdi, rax
call translog_flush
mov [rbp+var_9], al
mov al, [rbp+var_9]
add rsp, 10h
pop rbp
retn
| char flush_log_for_bitmap()
{
long long horizon; // rax
horizon = translog_get_horizon();
return translog_flush(horizon);
}
| flush_log_for_bitmap:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0016671e
LAB_0016671e:
JMP 0x00166720
LAB_00166720:
MOV AL,0x0
CALL 0x001343e0
MOV RDI,RAX
CALL 0x00136020
MOV byte ptr [RBP + -0x9],AL
MOV AL,byte ptr [RBP + -0x9]
ADD RSP,0x10
POP RBP
RET
|
int1 flush_log_for_bitmap(void)
{
int8 uVar1;
int1 uVar2;
uVar1 = translog_get_horizon();
uVar2 = translog_flush(uVar1);
return uVar2;
}
| |
24,164 | 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)
} | O0 | c | mysql_list_processes_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3abf0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mysql_list_processes_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
call mysql_list_processes
mov [rbp+var_18], rax
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+8], rcx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| long long mysql_list_processes_start_internal(long long *a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-20h]
v2 = *(_QWORD *)(*(_QWORD *)(*a1 + 1152) + 40LL);
*(_QWORD *)(v2 + 8) = mysql_list_processes(*a1);
result = v2;
*(_DWORD *)v2 = 0;
return result;
}
| mysql_list_processes_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x0013abf0
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
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(*param_1);
*(int8 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
| |
24,165 | common_log::pause() | monkey531[P]llama/common/log.cpp | void pause() {
{
std::lock_guard<std::mutex> lock(mtx);
if (!running) {
return;
}
running = false;
// push an entry to signal the worker thread to stop
{
auto & entry = entries[tail];
entry.is_end = true;
tail = (tail + 1) % entries.size();
}
cv.notify_one();
}
thrd.join();
} | O0 | cpp | common_log::pause():
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rsi
movq %rsi, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x15f9f0
movq 0x10(%rsp), %rax
testb $0x1, 0x6a(%rax)
jne 0x15e042
movl $0x1, 0x24(%rsp)
jmp 0x15e0b4
movq 0x10(%rsp), %rax
movb $0x0, 0x6a(%rax)
movq %rax, %rdi
addq $0x78, %rdi
movq 0x98(%rax), %rsi
callq 0x15fa20
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movb $0x1, 0x28(%rax)
movq 0x98(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
addq $0x78, %rdi
callq 0x15edd0
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, 0x98(%rdi)
addq $0x30, %rdi
callq 0x528c0
movl $0x0, 0x24(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x15fa40
movl 0x24(%rsp), %eax
testl %eax, %eax
je 0x15e0ca
jmp 0x15e0c8
jmp 0x15e0d8
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x52410
addq $0x38, %rsp
retq
nopl (%rax)
| _ZN10common_log5pauseEv:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov rsi, [rsp+38h+var_8]
mov [rsp+38h+var_28], rsi
lea rdi, [rsp+38h+var_10]
call _ZNSt10lock_guardISt5mutexEC2ERS0_; std::lock_guard<std::mutex>::lock_guard(std::mutex&)
mov rax, [rsp+38h+var_28]
test byte ptr [rax+6Ah], 1
jnz short loc_15E042
mov [rsp+38h+var_14], 1
jmp short loc_15E0B4
loc_15E042:
mov rax, [rsp+38h+var_28]
mov byte ptr [rax+6Ah], 0
mov rdi, rax
add rdi, 78h ; 'x'
mov rsi, [rax+98h]
call _ZNSt6vectorI16common_log_entrySaIS0_EEixEm; std::vector<common_log_entry>::operator[](ulong)
mov rdi, [rsp+38h+var_28]
mov [rsp+38h+var_20], rax
mov rax, [rsp+38h+var_20]
mov byte ptr [rax+28h], 1
mov rax, [rdi+98h]
add rax, 1
mov [rsp+38h+var_30], rax
add rdi, 78h ; 'x'
call _ZNKSt6vectorI16common_log_entrySaIS0_EE4sizeEv; std::vector<common_log_entry>::size(void)
mov rdi, [rsp+38h+var_28]
mov rcx, rax
mov rax, [rsp+38h+var_30]
xor edx, edx
div rcx
mov [rdi+98h], rdx
add rdi, 30h ; '0'; this
call __ZNSt18condition_variable10notify_oneEv; std::condition_variable::notify_one(void)
mov [rsp+38h+var_14], 0
loc_15E0B4:
lea rdi, [rsp+38h+var_10]
call _ZNSt10lock_guardISt5mutexED2Ev; std::lock_guard<std::mutex>::~lock_guard()
mov eax, [rsp+38h+var_14]
test eax, eax
jz short loc_15E0CA
jmp short $+2
loc_15E0C8:
jmp short loc_15E0D8
loc_15E0CA:
mov rdi, [rsp+38h+var_28]
add rdi, 28h ; '('; this
call __ZNSt6thread4joinEv; std::thread::join(void)
loc_15E0D8:
add rsp, 38h
retn
| long long common_log::pause(common_log *this)
{
long long result; // rax
unsigned long long v2; // [rsp+8h] [rbp-30h]
unsigned int v3; // [rsp+24h] [rbp-14h]
_BYTE v4[8]; // [rsp+28h] [rbp-10h] BYREF
common_log *v5; // [rsp+30h] [rbp-8h]
v5 = this;
std::lock_guard<std::mutex>::lock_guard(v4);
if ( (*((_BYTE *)this + 106) & 1) != 0 )
{
*((_BYTE *)this + 106) = 0;
*(_BYTE *)(std::vector<common_log_entry>::operator[]((char *)this + 120, *((_QWORD *)this + 19)) + 40) = 1;
v2 = *((_QWORD *)this + 19) + 1LL;
*((_QWORD *)this + 19) = v2 % std::vector<common_log_entry>::size((char *)this + 120);
std::condition_variable::notify_one((common_log *)((char *)this + 48));
v3 = 0;
}
else
{
v3 = 1;
}
std::lock_guard<std::mutex>::~lock_guard(v4);
result = v3;
if ( !v3 )
return std::thread::join((common_log *)((char *)this + 40));
return result;
}
| |||
24,166 | common_log::pause() | monkey531[P]llama/common/log.cpp | void pause() {
{
std::lock_guard<std::mutex> lock(mtx);
if (!running) {
return;
}
running = false;
// push an entry to signal the worker thread to stop
{
auto & entry = entries[tail];
entry.is_end = true;
tail = (tail + 1) % entries.size();
}
cv.notify_one();
}
thrd.join();
} | O3 | cpp | common_log::pause():
pushq %rbx
movq %rdi, %rbx
callq 0x18a30
testl %eax, %eax
jne 0x82889
cmpb $0x0, 0x6a(%rbx)
je 0x82880
movb $0x0, 0x6a(%rbx)
movq 0x78(%rbx), %rcx
movq 0x98(%rbx), %rax
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
movb $0x1, 0x28(%rcx,%rdx)
incq %rax
movq 0x80(%rbx), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, 0x98(%rbx)
leaq 0x30(%rbx), %rdi
callq 0x18390
movq %rbx, %rdi
callq 0x18550
addq $0x28, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x18ba0
movq %rbx, %rdi
popq %rbx
jmp 0x18550
movl %eax, %edi
callq 0x184a0
| _ZN10common_log5pauseEv:
push rbx
mov rbx, rdi
call _pthread_mutex_lock
test eax, eax
jnz short loc_82889
cmp byte ptr [rbx+6Ah], 0
jz short loc_82880
mov byte ptr [rbx+6Ah], 0
mov rcx, [rbx+78h]
mov rax, [rbx+98h]
lea rdx, [rax+rax*2]
shl rdx, 4
mov byte ptr [rcx+rdx+28h], 1
inc rax
mov rdx, [rbx+80h]
sub rdx, rcx
sar rdx, 4
mov rcx, 0AAAAAAAAAAAAAAABh
imul rcx, rdx
xor edx, edx
div rcx
mov [rbx+98h], rdx
lea rdi, [rbx+30h]; this
call __ZNSt18condition_variable10notify_oneEv; std::condition_variable::notify_one(void)
mov rdi, rbx
call _pthread_mutex_unlock
add rbx, 28h ; '('
mov rdi, rbx; this
pop rbx
jmp __ZNSt6thread4joinEv; std::thread::join(void)
loc_82880:
mov rdi, rbx
pop rbx
jmp _pthread_mutex_unlock
loc_82889:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
| long long common_log::pause(common_log *this)
{
int v1; // eax
long long v2; // rcx
long long v3; // rax
v1 = pthread_mutex_lock();
if ( v1 )
std::__throw_system_error(v1);
if ( !*((_BYTE *)this + 106) )
return pthread_mutex_unlock(this);
*((_BYTE *)this + 106) = 0;
v2 = *((_QWORD *)this + 15);
v3 = *((_QWORD *)this + 19);
*(_BYTE *)(v2 + 48 * v3 + 40) = 1;
*((_QWORD *)this + 19) = (v3 + 1) % (0xAAAAAAAAAAAAAAABLL * ((*((_QWORD *)this + 16) - v2) >> 4));
std::condition_variable::notify_one((common_log *)((char *)this + 48));
pthread_mutex_unlock(this);
return std::thread::join((common_log *)((char *)this + 40));
}
| pause:
PUSH RBX
MOV RBX,RDI
CALL 0x00118a30
TEST EAX,EAX
JNZ 0x00182889
CMP byte ptr [RBX + 0x6a],0x0
JZ 0x00182880
MOV byte ptr [RBX + 0x6a],0x0
MOV RCX,qword ptr [RBX + 0x78]
MOV RAX,qword ptr [RBX + 0x98]
LEA RDX,[RAX + RAX*0x2]
SHL RDX,0x4
MOV byte ptr [RCX + RDX*0x1 + 0x28],0x1
INC RAX
MOV RDX,qword ptr [RBX + 0x80]
SUB RDX,RCX
SAR RDX,0x4
MOV RCX,-0x5555555555555555
IMUL RCX,RDX
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBX + 0x98],RDX
LEA RDI,[RBX + 0x30]
CALL 0x00118390
MOV RDI,RBX
CALL 0x00118550
ADD RBX,0x28
MOV RDI,RBX
POP RBX
JMP 0x00118ba0
LAB_00182880:
MOV RDI,RBX
POP RBX
JMP 0x00118550
LAB_00182889:
MOV EDI,EAX
CALL 0x001184a0
|
/* common_log::pause() */
void __thiscall common_log::pause(common_log *this)
{
long lVar1;
long lVar2;
int iVar3;
iVar3 = pthread_mutex_lock((pthread_mutex_t *)this);
if (iVar3 != 0) {
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar3);
}
if (this[0x6a] != (common_log)0x0) {
this[0x6a] = (common_log)0x0;
lVar1 = *(long *)(this + 0x78);
lVar2 = *(long *)(this + 0x98);
*(int1 *)(lVar1 + 0x28 + lVar2 * 0x30) = 1;
*(ulong *)(this + 0x98) =
(lVar2 + 1U) % (ulong)((*(long *)(this + 0x80) - lVar1 >> 4) * -0x5555555555555555);
std::condition_variable::notify_one();
pthread_mutex_unlock((pthread_mutex_t *)this);
std::thread::join();
return;
}
pthread_mutex_unlock((pthread_mutex_t *)this);
return;
}
| |
24,167 | write_hook_for_undo_key_delete | eloqsql/storage/maria/ma_key_recover.c | my_bool write_hook_for_undo_key_delete(enum translog_record_type type,
TRN *trn, MARIA_HA *tbl_info,
LSN *lsn, void *hook_arg)
{
struct st_msg_to_write_hook_for_undo_key *msg=
(struct st_msg_to_write_hook_for_undo_key *) hook_arg;
MARIA_SHARE *share= tbl_info->s;
if (msg->auto_increment > 0) /* If auto increment key */
{
/* Restore auto increment if no one has changed it in between */
if (share->last_auto_increment == tbl_info->last_auto_increment &&
tbl_info->last_auto_increment != ~(ulonglong) 0)
share->state.auto_increment= tbl_info->last_auto_increment;
}
return write_hook_for_undo_key(type, trn, tbl_info, lsn, hook_arg);
} | O3 | c | write_hook_for_undo_key_delete:
cmpq $0x0, 0x18(%r8)
je 0x3b0ae
pushq %rbp
movq %rsp, %rbp
movq (%rdx), %rax
movq 0x610(%rax), %r9
movq 0x3e8(%rdx), %r10
cmpq %r10, %r9
setne %r11b
cmpq $-0x1, %r10
sete %r10b
orb %r11b, %r10b
jne 0x3b18c
movq %r9, 0xd8(%rax)
popq %rbp
jmp 0x3b0ae
| write_hook_for_undo_key_delete:
cmp qword ptr [r8+18h], 0
jz write_hook_for_undo_key
push rbp
mov rbp, rsp
mov rax, [rdx]
mov r9, [rax+610h]
mov r10, [rdx+3E8h]
cmp r9, r10
setnz r11b
cmp r10, 0FFFFFFFFFFFFFFFFh
setz r10b
or r10b, r11b
jnz short loc_3B18C
mov [rax+0D8h], r9
loc_3B18C:
pop rbp
jmp write_hook_for_undo_key
| long long write_hook_for_undo_key_delete(unsigned int a1, long long a2, long long a3, long long a4, long long a5)
{
long long v6; // r9
if ( *(_QWORD *)(a5 + 24) )
{
v6 = *(_QWORD *)(*(_QWORD *)a3 + 1552LL);
if ( v6 == *(_QWORD *)(a3 + 1000) && *(_QWORD *)(a3 + 1000) != -1LL )
*(_QWORD *)(*(_QWORD *)a3 + 216LL) = v6;
}
return write_hook_for_undo_key(a1, a2, a3, a4, a5);
}
| write_hook_for_undo_key_delete:
CMP qword ptr [R8 + 0x18],0x0
JZ 0x0013b0ae
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDX]
MOV R9,qword ptr [RAX + 0x610]
MOV R10,qword ptr [RDX + 0x3e8]
CMP R9,R10
SETNZ R11B
CMP R10,-0x1
SETZ R10B
OR R10B,R11B
JNZ 0x0013b18c
MOV qword ptr [RAX + 0xd8],R9
LAB_0013b18c:
POP RBP
JMP 0x0013b0ae
|
void write_hook_for_undo_key_delete
(int4 param_1,int8 param_2,long *param_3,int8 param_4,
int8 *param_5)
{
long lVar1;
if (param_5[3] != 0) {
lVar1 = *(long *)(*param_3 + 0x610);
if (param_3[0x7d] != -1 && lVar1 == param_3[0x7d]) {
*(long *)(*param_3 + 0xd8) = lVar1;
}
write_hook_for_undo_key();
return;
}
*(int8 *)*param_5 = param_5[1];
if (*(char *)((long)param_3 + 0x67e) != '\0') {
_ma_unlock_key_del(param_3);
}
write_hook_for_undo(param_1,param_2,param_3,param_4,0);
return;
}
| |
24,168 | my_strnxfrm_tis620 | eloqsql/strings/ctype-tis620.c | static size_t
my_strnxfrm_tis620(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
size_t len, dstlen0= dstlen;
len= MY_MIN(dstlen, srclen);
memcpy(dst, src, len);
len= thai2sortable(dst, len);
set_if_smaller(dstlen, nweights);
set_if_smaller(len, dstlen);
len= my_strxfrm_pad_desc_and_reverse(cs, dst, dst + len, dst + dstlen,
(uint)(dstlen - len), flags, 0);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len < dstlen0)
{
size_t fill_length= dstlen0 - len;
my_ci_fill(cs, (char*) dst + len, fill_length, cs->pad_char);
len= dstlen0;
}
return len;
} | O0 | c | my_strnxfrm_tis620:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x48b0e
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x48b16
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x24220
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x48c00
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x48b53
movl -0x1c(%rbp), %eax
movq %rax, -0x18(%rbp)
jmp 0x48b55
jmp 0x48b57
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x48b69
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x48b6b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
subq -0x38(%rbp), %rax
movl %eax, %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x431c0
movq %rax, -0x38(%rbp)
movl 0x10(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x48bef
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x48bef
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x8(%rbp), %rax
movzbl 0xb0(%rax), %ecx
callq 0x48da0
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnxfrm_tis620:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_30]
jnb short loc_48B0E
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
jmp short loc_48B16
loc_48B0E:
mov rax, [rbp+var_30]
mov [rbp+var_50], rax
loc_48B16:
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
call _memcpy
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
call thai2sortable
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov ecx, [rbp+var_1C]
cmp rax, rcx
jbe short loc_48B53
mov eax, [rbp+var_1C]
mov [rbp+var_18], rax
loc_48B53:
jmp short $+2
loc_48B55:
jmp short $+2
loc_48B57:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_18]
jbe short loc_48B69
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
loc_48B69:
jmp short $+2
loc_48B6B:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
add rdx, [rbp+var_38]
mov rcx, [rbp+var_10]
add rcx, [rbp+var_18]
mov rax, [rbp+var_18]
sub rax, [rbp+var_38]
mov r8d, eax
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+60h+var_60], 0
call my_strxfrm_pad_desc_and_reverse
mov [rbp+var_38], rax
mov eax, [rbp+arg_0]
and eax, 80h
cmp eax, 0
jz short loc_48BEF
mov rax, [rbp+var_38]
cmp rax, [rbp+var_40]
jnb short loc_48BEF
mov rax, [rbp+var_40]
sub rax, [rbp+var_38]
mov [rbp+var_48], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
add rsi, [rbp+var_38]
mov rdx, [rbp+var_48]
mov rax, [rbp+var_8]
movzx ecx, byte ptr [rax+0B0h]
call my_ci_fill_1
mov rax, [rbp+var_40]
mov [rbp+var_38], rax
loc_48BEF:
mov rax, [rbp+var_38]
add rsp, 60h
pop rbp
retn
| unsigned long long my_strnxfrm_tis620(
long long a1,
long long a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
unsigned int a7)
{
unsigned long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v10; // [rsp+28h] [rbp-38h]
unsigned long long v11; // [rsp+28h] [rbp-38h]
unsigned long long v13; // [rsp+48h] [rbp-18h]
v13 = a3;
if ( a3 >= a6 )
v8 = a6;
else
v8 = a3;
memcpy(a2, a5, v8);
v10 = thai2sortable(a2, v8);
if ( v13 > a4 )
v13 = a4;
if ( v10 > v13 )
v10 = v13;
v11 = my_strxfrm_pad_desc_and_reverse(a1, a2, v10 + a2, v13 + a2, (int)v13 - (int)v10, a7, 0);
if ( (a7 & 0x80) != 0 && v11 < a3 )
{
my_ci_fill_1(a1, v11 + a2, a3 - v11, *(unsigned __int8 *)(a1 + 176));
return a3;
}
return v11;
}
| my_strnxfrm_tis620:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00148b0e
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00148b16
LAB_00148b0e:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x50],RAX
LAB_00148b16:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x00124220
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00148c00
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x1c]
CMP RAX,RCX
JBE 0x00148b53
MOV EAX,dword ptr [RBP + -0x1c]
MOV qword ptr [RBP + -0x18],RAX
LAB_00148b53:
JMP 0x00148b55
LAB_00148b55:
JMP 0x00148b57
LAB_00148b57:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x00148b69
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
LAB_00148b69:
JMP 0x00148b6b
LAB_00148b6b:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [RBP + -0x38]
MOV R8D,EAX
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x001431c0
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x80
CMP EAX,0x0
JZ 0x00148bef
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x00148bef
MOV RAX,qword ptr [RBP + -0x40]
SUB RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RAX + 0xb0]
CALL 0x00148da0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
LAB_00148bef:
MOV RAX,qword ptr [RBP + -0x38]
ADD RSP,0x60
POP RBP
RET
|
ulong my_strnxfrm_tis620(long param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,uint param_7)
{
size_t local_58;
ulong local_40;
ulong local_20;
local_58 = param_6;
if (param_3 < param_6) {
local_58 = param_3;
}
memcpy(param_2,param_5,local_58);
local_40 = thai2sortable(param_2,local_58);
local_20 = param_3;
if (param_4 < param_3) {
local_20 = (ulong)param_4;
}
if (local_20 < local_40) {
local_40 = local_20;
}
local_40 = my_strxfrm_pad_desc_and_reverse
(param_1,param_2,(long)param_2 + local_40,(long)param_2 + local_20,
(int)local_20 - (int)local_40,param_7,0);
if (((param_7 & 0x80) != 0) && (local_40 < param_3)) {
my_ci_fill(param_1,(long)param_2 + local_40,param_3 - local_40,*(int1 *)(param_1 + 0xb0));
local_40 = param_3;
}
return local_40;
}
| |
24,169 | my_set_max_open_files | eloqsql/mysys/my_file.c | uint my_set_max_open_files(uint files)
{
struct st_my_file_info *tmp;
DBUG_ENTER("my_set_max_open_files");
DBUG_PRINT("enter",("files: %u my_file_limit: %u", files, my_file_limit));
files+= MY_FILE_MIN;
files= set_max_open_files(MY_MIN(files, OS_FILE_LIMIT));
if (files <= MY_NFILE)
DBUG_RETURN(files);
if (!(tmp= (struct st_my_file_info*) my_malloc(key_memory_my_file_info,
sizeof(*tmp) * files,
MYF(MY_WME))))
DBUG_RETURN(MY_NFILE);
/* Copy any initialized files */
memcpy((char*) tmp, (char*) my_file_info,
sizeof(*tmp) * MY_MIN(my_file_limit, files));
bzero((char*) (tmp + my_file_limit),
MY_MAX((int) (files- my_file_limit), 0)*sizeof(*tmp));
my_free_open_file_info(); /* Free if already allocated */
my_file_info= tmp;
my_file_limit= files;
DBUG_PRINT("exit",("files: %u", files));
DBUG_RETURN(files);
} | O0 | c | my_set_max_open_files:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
jmp 0xf448d
movl -0x8(%rbp), %eax
addl $0x0, %eax
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
jae 0xf44a4
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xf44ae
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %eax, -0x14(%rbp)
jmp 0xf44ae
movl -0x14(%rbp), %edi
callq 0xf45e0
movl %eax, -0x8(%rbp)
cmpl $0x40, -0x8(%rbp)
ja 0xf44cc
jmp 0xf44c1
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf45cf
leaq 0xb9a211(%rip), %rax # 0xc8e6e4
movl (%rax), %edi
movl -0x8(%rbp), %eax
movl %eax, %esi
shlq $0x4, %rsi
movl $0x10, %edx
callq 0xfc020
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xf4500
jmp 0xf44f4
movl $0x40, -0x4(%rbp)
jmp 0xf45cf
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x1d6a89(%rip), %rax # 0x2caf98
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x1d6a73(%rip), %rax # 0x2caf90
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jae 0xf4532
leaq 0x1d6a65(%rip), %rax # 0x2caf90
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0xf4538
movl -0x8(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x4, %rdx
callq 0x2a0b0
movq -0x10(%rbp), %rax
leaq 0x1d6a35(%rip), %rcx # 0x2caf90
movl (%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x8(%rbp), %eax
leaq 0x1d6a1e(%rip), %rcx # 0x2caf90
subl (%rcx), %eax
cmpl $0x0, %eax
jle 0xf458a
movl -0x8(%rbp), %eax
leaq 0x1d6a0d(%rip), %rcx # 0x2caf90
subl (%rcx), %eax
movl %eax, -0x3c(%rbp)
jmp 0xf4591
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0xf4591
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %eax
movslq %eax, %rdx
shlq $0x4, %rdx
xorl %esi, %esi
callq 0x2a2c0
callq 0xf4690
movq -0x10(%rbp), %rcx
leaq 0x1d69e2(%rip), %rax # 0x2caf98
movq %rcx, (%rax)
movl -0x8(%rbp), %ecx
leaq 0x1d69cd(%rip), %rax # 0x2caf90
movl %ecx, (%rax)
jmp 0xf45c7
jmp 0xf45c9
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_set_max_open_files:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], edi
jmp short $+2
loc_F448D:
mov eax, [rbp+var_8]
add eax, 0
mov [rbp+var_8], eax
cmp [rbp+var_8], 0FFFFFFFFh
jnb short loc_F44A4
mov eax, [rbp+var_8]
mov [rbp+var_14], eax
jmp short loc_F44AE
loc_F44A4:
mov eax, 0FFFFFFFFh
mov [rbp+var_14], eax
jmp short $+2
loc_F44AE:
mov edi, [rbp+var_14]
call set_max_open_files
mov [rbp+var_8], eax
cmp [rbp+var_8], 40h ; '@'
ja short loc_F44CC
jmp short $+2
loc_F44C1:
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
jmp loc_F45CF
loc_F44CC:
lea rax, key_memory_my_file_info
mov edi, [rax]
mov eax, [rbp+var_8]
mov esi, eax
shl rsi, 4
mov edx, 10h
call my_malloc
mov [rbp+var_10], rax
cmp rax, 0
jnz short loc_F4500
jmp short $+2
loc_F44F4:
mov [rbp+var_4], 40h ; '@'
jmp loc_F45CF
loc_F4500:
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
lea rax, my_file_info
mov rax, [rax]
mov [rbp+var_20], rax
lea rax, my_file_limit
mov eax, [rax]
cmp eax, [rbp+var_8]
jnb short loc_F4532
lea rax, my_file_limit
mov eax, [rax]
mov [rbp+var_2C], eax
jmp short loc_F4538
loc_F4532:
mov eax, [rbp+var_8]
mov [rbp+var_2C], eax
loc_F4538:
mov rsi, [rbp+var_20]
mov rdi, [rbp+var_28]
mov eax, [rbp+var_2C]
mov eax, eax
mov edx, eax
shl rdx, 4
call _memcpy
mov rax, [rbp+var_10]
lea rcx, my_file_limit
mov ecx, [rcx]
shl rcx, 4
add rax, rcx
mov [rbp+var_38], rax
mov eax, [rbp+var_8]
lea rcx, my_file_limit
sub eax, [rcx]
cmp eax, 0
jle short loc_F458A
mov eax, [rbp+var_8]
lea rcx, my_file_limit
sub eax, [rcx]
mov [rbp+var_3C], eax
jmp short loc_F4591
loc_F458A:
xor eax, eax
mov [rbp+var_3C], eax
jmp short $+2
loc_F4591:
mov rdi, [rbp+var_38]
mov eax, [rbp+var_3C]
movsxd rdx, eax
shl rdx, 4
xor esi, esi
call _memset
call my_free_open_file_info
mov rcx, [rbp+var_10]
lea rax, my_file_info
mov [rax], rcx
mov ecx, [rbp+var_8]
lea rax, my_file_limit
mov [rax], ecx
jmp short $+2
loc_F45C7:
jmp short $+2
loc_F45C9:
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
loc_F45CF:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long my_set_max_open_files(unsigned int a1)
{
signed int v2; // [rsp+4h] [rbp-3Ch]
unsigned int v3; // [rsp+14h] [rbp-2Ch]
unsigned int v4; // [rsp+2Ch] [rbp-14h]
char *v5; // [rsp+30h] [rbp-10h]
unsigned int v6; // [rsp+38h] [rbp-8h]
if ( a1 == -1 )
v4 = -1;
else
v4 = a1;
v6 = set_max_open_files(v4);
if ( v6 > 0x40 )
{
v5 = (char *)my_malloc(key_memory_my_file_info, 16LL * v6, 16LL);
if ( v5 )
{
if ( my_file_limit >= v6 )
v3 = v6;
else
v3 = my_file_limit;
memcpy(v5, my_file_info, 16LL * v3);
if ( (int)(v6 - my_file_limit) <= 0 )
v2 = 0;
else
v2 = v6 - my_file_limit;
memset(&v5[16 * my_file_limit], 0LL, 16LL * v2);
my_free_open_file_info();
my_file_info = v5;
my_file_limit = v6;
return v6;
}
else
{
return 64;
}
}
else
{
return v6;
}
}
| my_set_max_open_files:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x8],EDI
JMP 0x001f448d
LAB_001f448d:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x0
MOV dword ptr [RBP + -0x8],EAX
CMP dword ptr [RBP + -0x8],-0x1
JNC 0x001f44a4
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001f44ae
LAB_001f44a4:
MOV EAX,0xffffffff
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001f44ae
LAB_001f44ae:
MOV EDI,dword ptr [RBP + -0x14]
CALL 0x001f45e0
MOV dword ptr [RBP + -0x8],EAX
CMP dword ptr [RBP + -0x8],0x40
JA 0x001f44cc
JMP 0x001f44c1
LAB_001f44c1:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001f45cf
LAB_001f44cc:
LEA RAX,[0xd8e6e4]
MOV EDI,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x8]
MOV ESI,EAX
SHL RSI,0x4
MOV EDX,0x10
CALL 0x001fc020
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JNZ 0x001f4500
JMP 0x001f44f4
LAB_001f44f4:
MOV dword ptr [RBP + -0x4],0x40
JMP 0x001f45cf
LAB_001f4500:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
LEA RAX,[0x3caf98]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
LEA RAX,[0x3caf90]
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RBP + -0x8]
JNC 0x001f4532
LEA RAX,[0x3caf90]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001f4538
LAB_001f4532:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x2c],EAX
LAB_001f4538:
MOV RSI,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x2c]
MOV EAX,EAX
MOV EDX,EAX
SHL RDX,0x4
CALL 0x0012a0b0
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x3caf90]
MOV ECX,dword ptr [RCX]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + -0x8]
LEA RCX,[0x3caf90]
SUB EAX,dword ptr [RCX]
CMP EAX,0x0
JLE 0x001f458a
MOV EAX,dword ptr [RBP + -0x8]
LEA RCX,[0x3caf90]
SUB EAX,dword ptr [RCX]
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x001f4591
LAB_001f458a:
XOR EAX,EAX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x001f4591
LAB_001f4591:
MOV RDI,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
SHL RDX,0x4
XOR ESI,ESI
CALL 0x0012a2c0
CALL 0x001f4690
MOV RCX,qword ptr [RBP + -0x10]
LEA RAX,[0x3caf98]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x8]
LEA RAX,[0x3caf90]
MOV dword ptr [RAX],ECX
JMP 0x001f45c7
LAB_001f45c7:
JMP 0x001f45c9
LAB_001f45c9:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
LAB_001f45cf:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
uint my_set_max_open_files(int param_1)
{
int *__dest;
int local_44;
uint local_34;
int local_1c;
uint local_c;
local_1c = param_1;
if (param_1 == -1) {
local_1c = -1;
}
local_c = set_max_open_files(local_1c);
if (0x40 < local_c) {
__dest = (int *)my_malloc(key_memory_my_file_info,(ulong)local_c << 4,0x10);
if (__dest == (int *)0x0) {
local_c = 0x40;
}
else {
local_34 = local_c;
if (my_file_limit < local_c) {
local_34 = my_file_limit;
}
memcpy(__dest,my_file_info,(ulong)local_34 << 4);
if ((int)(local_c - my_file_limit) < 1) {
local_44 = 0;
}
else {
local_44 = local_c - my_file_limit;
}
memset(__dest + (ulong)my_file_limit * 0x10,0,(long)local_44 << 4);
my_free_open_file_info();
my_file_limit = local_c;
my_file_info = __dest;
}
}
return local_c;
}
| |
24,170 | flush_pagecache_blocks_with_filter | eloqsql/storage/maria/ma_pagecache.c | int flush_pagecache_blocks_with_filter(PAGECACHE *pagecache,
PAGECACHE_FILE *file,
enum flush_type type,
PAGECACHE_FLUSH_FILTER filter,
void *filter_arg)
{
int res;
DBUG_ENTER("flush_pagecache_blocks_with_filter");
DBUG_PRINT("enter", ("pagecache: %p", pagecache));
if (pagecache->disk_blocks <= 0)
DBUG_RETURN(0);
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
inc_counter_for_resize_op(pagecache);
res= flush_pagecache_blocks_int(pagecache, file, type, filter, filter_arg);
dec_counter_for_resize_op(pagecache);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_RETURN(res);
} | O0 | c | flush_pagecache_blocks_with_filter:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
jmp 0x2f79d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jg 0x2f7b3
jmp 0x2f7aa
movl $0x0, -0x4(%rbp)
jmp 0x2f812
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
leaq 0x121c5c(%rip), %rsi # 0x151421
movl $0x1471, %edx # imm = 0x1471
callq 0x2c4a0
movq -0x10(%rbp), %rdi
callq 0x2c850
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x2f820
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2d580
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
callq 0x2c510
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| flush_pagecache_blocks_with_filter:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
jmp short $+2
loc_2F79D:
mov rax, [rbp+var_10]
cmp qword ptr [rax+40h], 0
jg short loc_2F7B3
jmp short $+2
loc_2F7AA:
mov [rbp+var_4], 0
jmp short loc_2F812
loc_2F7B3:
mov rdi, [rbp+var_10]
add rdi, 0C8h
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 1471h
call inline_mysql_mutex_lock
mov rdi, [rbp+var_10]
call inc_counter_for_resize_op
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
call flush_pagecache_blocks_int
mov [rbp+var_34], eax
mov rdi, [rbp+var_10]
call dec_counter_for_resize_op
mov rdi, [rbp+var_10]
add rdi, 0C8h
call inline_mysql_mutex_unlock
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
loc_2F812:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long flush_pagecache_blocks_with_filter(long long a1, long long a2, unsigned int a3, long long a4, long long a5)
{
unsigned int v6; // [rsp+Ch] [rbp-34h]
if ( *(long long *)(a1 + 64) > 0 )
{
inline_mysql_mutex_lock(
a1 + 200,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x1471u);
inc_counter_for_resize_op(a1);
v6 = flush_pagecache_blocks_int(a1, a2, a3, a4, a5);
dec_counter_for_resize_op(a1);
inline_mysql_mutex_unlock(a1 + 200);
return v6;
}
else
{
return 0;
}
}
| flush_pagecache_blocks_with_filter:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
JMP 0x0012f79d
LAB_0012f79d:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x40],0x0
JG 0x0012f7b3
JMP 0x0012f7aa
LAB_0012f7aa:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0012f812
LAB_0012f7b3:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc8
LEA RSI,[0x251421]
MOV EDX,0x1471
CALL 0x0012c4a0
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0012c850
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
CALL 0x0012f820
MOV dword ptr [RBP + -0x34],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0012d580
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc8
CALL 0x0012c510
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
LAB_0012f812:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4
flush_pagecache_blocks_with_filter
(long param_1,int8 param_2,int4 param_3,int8 param_4,int8 param_5)
{
int4 local_c;
if (*(long *)(param_1 + 0x40) < 1) {
local_c = 0;
}
else {
inline_mysql_mutex_lock
(param_1 + 200,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c"
,0x1471);
inc_counter_for_resize_op(param_1);
local_c = flush_pagecache_blocks_int(param_1,param_2,param_3,param_4,param_5);
dec_counter_for_resize_op(param_1);
inline_mysql_mutex_unlock(param_1 + 200);
}
return local_c;
}
| |
24,171 | rb_delete_fixup | eloqsql/mysys/tree.c | static void rb_delete_fixup(TREE *tree, TREE_ELEMENT ***parent)
{
TREE_ELEMENT *x,*w,*par;
x= **parent;
while (x != tree->root && x->colour == BLACK)
{
if (x == (par=parent[-1][0])->left)
{
w=par->right;
if (w->colour == RED)
{
w->colour=BLACK;
par->colour=RED;
left_rotate(parent[-1],par);
parent[0]= &w->left;
*++parent= &par->left;
w=par->right;
}
if (w->left->colour == BLACK && w->right->colour == BLACK)
{
w->colour=RED;
x=par;
parent--;
}
else
{
if (w->right->colour == BLACK)
{
w->left->colour=BLACK;
w->colour=RED;
right_rotate(&par->right,w);
w=par->right;
}
w->colour=par->colour;
par->colour=BLACK;
w->right->colour=BLACK;
left_rotate(parent[-1],par);
x=tree->root;
break;
}
}
else
{
w=par->left;
if (w->colour == RED)
{
w->colour=BLACK;
par->colour=RED;
right_rotate(parent[-1],par);
parent[0]= &w->right;
*++parent= &par->right;
w=par->left;
}
if (w->right->colour == BLACK && w->left->colour == BLACK)
{
w->colour=RED;
x=par;
parent--;
}
else
{
if (w->left->colour == BLACK)
{
w->right->colour=BLACK;
w->colour=RED;
left_rotate(&par->left,w);
w=par->left;
}
w->colour=par->colour;
par->colour=BLACK;
w->left->colour=BLACK;
right_rotate(parent[-1],par);
x=tree->root;
break;
}
}
}
x->colour=BLACK;
} | O0 | c | rb_delete_fixup:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x29(%rbp)
je 0xffc03
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xffc0f
jmp 0xfff7a
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, -0x28(%rbp)
cmpq (%rcx), %rax
jne 0xffdd3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0xffcae
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x100bb0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x10(%rbp)
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xffcff
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xffcff
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xffdce
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xffd5b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x100bf0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %edx
shrl $0x1f, %edx
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x1, %edx
shll $0x1f, %edx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x100bb0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xfff7a
jmp 0xfff75
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0xffe5c
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x100bf0
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x10(%rbp)
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xffead
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xffead
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xfff73
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xfff04
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x100bb0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %edx
shrl $0x1f, %edx
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x1, %edx
shll $0x1f, %edx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x100bf0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xfff7a
jmp 0xfff75
jmp 0xffbde
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| rb_delete_fixup:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax]
mov [rbp+var_18], rax
loc_FFBDE:
mov rcx, [rbp+var_18]
mov rdx, [rbp+var_8]
xor eax, eax
cmp rcx, [rdx]
mov [rbp+var_29], al
jz short loc_FFC03
mov rax, [rbp+var_18]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
setz al
mov [rbp+var_29], al
loc_FFC03:
mov al, [rbp+var_29]
test al, 1
jnz short loc_FFC0F
jmp loc_FFF7A
loc_FFC0F:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rcx, [rcx-8]
mov rcx, [rcx]
mov [rbp+var_28], rcx
cmp rax, [rcx]
jnz loc_FFDD3
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 0
jnz short loc_FFCAE
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call left_rotate
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 8
mov [rbp+var_10], rdx
mov [rax+8], rcx
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov [rbp+var_20], rax
loc_FFCAE:
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_FFCFF
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_FFCFF
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_10], rax
jmp loc_FFDCE
loc_FFCFF:
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_FFD5B
mov rax, [rbp+var_20]
mov rax, [rax]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rdi, [rbp+var_28]
add rdi, 8
mov rsi, [rbp+var_20]
call right_rotate
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov [rbp+var_20], rax
loc_FFD5B:
mov rax, [rbp+var_28]
mov edx, [rax+10h]
shr edx, 1Fh
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and edx, 1
shl edx, 1Fh
and ecx, 7FFFFFFFh
or ecx, edx
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call left_rotate
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
jmp loc_FFF7A
loc_FFDCE:
jmp loc_FFF75
loc_FFDD3:
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 0
jnz short loc_FFE5C
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call right_rotate
mov rcx, [rbp+var_20]
add rcx, 8
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_28]
add rcx, 8
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 8
mov [rbp+var_10], rdx
mov [rax+8], rcx
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_20], rax
loc_FFE5C:
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_FFEAD
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_FFEAD
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_10], rax
jmp loc_FFF73
loc_FFEAD:
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_FFF04
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_20]
call left_rotate
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_20], rax
loc_FFF04:
mov rax, [rbp+var_28]
mov edx, [rax+10h]
shr edx, 1Fh
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and edx, 1
shl edx, 1Fh
and ecx, 7FFFFFFFh
or ecx, edx
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov rax, [rax]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call right_rotate
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
jmp short loc_FFF7A
loc_FFF73:
jmp short $+2
loc_FFF75:
jmp loc_FFBDE
loc_FFF7A:
mov rax, [rbp+var_18]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
add rsp, 30h
pop rbp
retn
| long long * rb_delete_fixup(long long **a1, _QWORD **a2)
{
_QWORD *v2; // rax
_QWORD *v3; // rax
long long *result; // rax
bool v5; // [rsp+7h] [rbp-29h]
long long *v6; // [rsp+8h] [rbp-28h]
long long v7; // [rsp+10h] [rbp-20h]
long long v8; // [rsp+10h] [rbp-20h]
long long *v9; // [rsp+18h] [rbp-18h]
_QWORD *v10; // [rsp+20h] [rbp-10h]
v10 = a2;
v9 = (long long *)**a2;
while ( 1 )
{
v5 = 0;
if ( v9 != *a1 )
v5 = *((_DWORD *)v9 + 4) >> 31 == 1;
if ( !v5 )
break;
v6 = *(long long **)*(v10 - 1);
if ( v9 == (long long *)*v6 )
{
v7 = v6[1];
if ( *(int *)(v7 + 16) >= 0 )
{
*(_DWORD *)(v7 + 16) = *(_DWORD *)(v7 + 16) & 0x7FFFFFFF | 0x80000000;
*((_DWORD *)v6 + 4) &= ~0x80000000;
left_rotate(*(v10 - 1), v6);
*v10 = v7;
v2 = v10++;
v2[1] = v6;
v7 = v6[1];
}
if ( *(_DWORD *)(*(_QWORD *)v7 + 16LL) >> 31 != 1 || *(_DWORD *)(*(_QWORD *)(v7 + 8) + 16LL) >> 31 != 1 )
{
if ( *(_DWORD *)(*(_QWORD *)(v7 + 8) + 16LL) >> 31 == 1 )
{
*(_DWORD *)(*(_QWORD *)v7 + 16LL) = *(_DWORD *)(*(_QWORD *)v7 + 16LL) & 0x7FFFFFFF | 0x80000000;
*(_DWORD *)(v7 + 16) &= ~0x80000000;
right_rotate(v6 + 1, v7);
v7 = v6[1];
}
*(_DWORD *)(v7 + 16) = (*((_DWORD *)v6 + 4) >> 31 << 31) | *(_DWORD *)(v7 + 16) & 0x7FFFFFFF;
*((_DWORD *)v6 + 4) = v6[2] & 0x7FFFFFFF | 0x80000000;
*(_DWORD *)(*(_QWORD *)(v7 + 8) + 16LL) = *(_DWORD *)(*(_QWORD *)(v7 + 8) + 16LL) & 0x7FFFFFFF | 0x80000000;
left_rotate(*(v10 - 1), v6);
v9 = *a1;
break;
}
*(_DWORD *)(v7 + 16) &= ~0x80000000;
v9 = v6;
--v10;
}
else
{
v8 = *v6;
if ( *(int *)(*v6 + 16) >= 0 )
{
*(_DWORD *)(v8 + 16) = *(_DWORD *)(v8 + 16) & 0x7FFFFFFF | 0x80000000;
*((_DWORD *)v6 + 4) &= ~0x80000000;
right_rotate(*(v10 - 1), v6);
*v10 = v8 + 8;
v3 = v10++;
v3[1] = v6 + 1;
v8 = *v6;
}
if ( *(_DWORD *)(*(_QWORD *)(v8 + 8) + 16LL) >> 31 != 1 || *(_DWORD *)(*(_QWORD *)v8 + 16LL) >> 31 != 1 )
{
if ( *(_DWORD *)(*(_QWORD *)v8 + 16LL) >> 31 == 1 )
{
*(_DWORD *)(*(_QWORD *)(v8 + 8) + 16LL) = *(_DWORD *)(*(_QWORD *)(v8 + 8) + 16LL) & 0x7FFFFFFF | 0x80000000;
*(_DWORD *)(v8 + 16) &= ~0x80000000;
left_rotate(v6, v8);
v8 = *v6;
}
*(_DWORD *)(v8 + 16) = (*((_DWORD *)v6 + 4) >> 31 << 31) | *(_DWORD *)(v8 + 16) & 0x7FFFFFFF;
*((_DWORD *)v6 + 4) = v6[2] & 0x7FFFFFFF | 0x80000000;
*(_DWORD *)(*(_QWORD *)v8 + 16LL) = *(_DWORD *)(*(_QWORD *)v8 + 16LL) & 0x7FFFFFFF | 0x80000000;
right_rotate(*(v10 - 1), v6);
v9 = *a1;
break;
}
*(_DWORD *)(v8 + 16) &= ~0x80000000;
v9 = v6;
--v10;
}
}
result = v9;
*((_DWORD *)v9 + 4) = v9[2] & 0x7FFFFFFF | 0x80000000;
return result;
}
| rb_delete_fixup:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LAB_001ffbde:
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x8]
XOR EAX,EAX
CMP RCX,qword ptr [RDX]
MOV byte ptr [RBP + -0x29],AL
JZ 0x001ffc03
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
SETZ AL
MOV byte ptr [RBP + -0x29],AL
LAB_001ffc03:
MOV AL,byte ptr [RBP + -0x29]
TEST AL,0x1
JNZ 0x001ffc0f
JMP 0x001fff7a
LAB_001ffc0f:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + -0x8]
MOV RCX,qword ptr [RCX]
MOV qword ptr [RBP + -0x28],RCX
CMP RAX,qword ptr [RCX]
JNZ 0x001ffdd3
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x0
JNZ 0x001ffcae
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00200bb0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_001ffcae:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001ffcff
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001ffcff
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x8
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001ffdce
LAB_001ffcff:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001ffd5b
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00200bf0
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_001ffd5b:
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RAX + 0x10]
SHR EDX,0x1f
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND EDX,0x1
SHL EDX,0x1f
AND ECX,0x7fffffff
OR ECX,EDX
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00200bb0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001fff7a
LAB_001ffdce:
JMP 0x001fff75
LAB_001ffdd3:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x0
JNZ 0x001ffe5c
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00200bf0
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
LAB_001ffe5c:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001ffead
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001ffead
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x8
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001fff73
LAB_001ffead:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001fff04
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00200bb0
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
LAB_001fff04:
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RAX + 0x10]
SHR EDX,0x1f
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND EDX,0x1
SHL EDX,0x1f
AND ECX,0x7fffffff
OR ECX,EDX
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00200bf0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001fff7a
LAB_001fff73:
JMP 0x001fff75
LAB_001fff75:
JMP 0x001ffbde
LAB_001fff7a:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
ADD RSP,0x30
POP RBP
RET
|
void rb_delete_fixup(long *param_1,long *param_2)
{
long *plVar1;
bool bVar2;
long *local_28;
long *local_20;
long *local_18;
local_20 = *(long **)*param_2;
local_18 = param_2;
do {
bVar2 = false;
if (local_20 != (long *)*param_1) {
bVar2 = (int)local_20[2] < 0;
}
if (!bVar2) goto LAB_001fff7a;
plVar1 = *(long **)local_18[-1];
if (local_20 == (long *)*plVar1) {
local_28 = (long *)plVar1[1];
if (-1 < (int)local_28[2]) {
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff;
left_rotate(local_18[-1],plVar1);
*local_18 = (long)local_28;
local_18[1] = (long)plVar1;
local_28 = (long *)plVar1[1];
local_18 = local_18 + 1;
}
if ((-1 < *(int *)(*local_28 + 0x10)) || (-1 < *(int *)(local_28[1] + 0x10))) {
if (*(int *)(local_28[1] + 0x10) < 0) {
*(uint *)(*local_28 + 0x10) = *(uint *)(*local_28 + 0x10) & 0x7fffffff | 0x80000000;
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff;
right_rotate(plVar1 + 1,local_28);
local_28 = (long *)plVar1[1];
}
*(uint *)(local_28 + 2) =
*(uint *)(local_28 + 2) & 0x7fffffff | *(uint *)(plVar1 + 2) & 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(local_28[1] + 0x10) = *(uint *)(local_28[1] + 0x10) & 0x7fffffff | 0x80000000;
left_rotate(local_18[-1],plVar1);
local_20 = (long *)*param_1;
LAB_001fff7a:
*(uint *)(local_20 + 2) = *(uint *)(local_20 + 2) & 0x7fffffff | 0x80000000;
return;
}
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff;
}
else {
local_28 = (long *)*plVar1;
if (-1 < (int)local_28[2]) {
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff;
right_rotate(local_18[-1],plVar1);
*local_18 = (long)(local_28 + 1);
local_18[1] = (long)(plVar1 + 1);
local_28 = (long *)*plVar1;
local_18 = local_18 + 1;
}
if ((-1 < *(int *)(local_28[1] + 0x10)) || (-1 < *(int *)(*local_28 + 0x10))) {
if (*(int *)(*local_28 + 0x10) < 0) {
*(uint *)(local_28[1] + 0x10) = *(uint *)(local_28[1] + 0x10) & 0x7fffffff | 0x80000000;
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff;
left_rotate(plVar1,local_28);
local_28 = (long *)*plVar1;
}
*(uint *)(local_28 + 2) =
*(uint *)(local_28 + 2) & 0x7fffffff | *(uint *)(plVar1 + 2) & 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(*local_28 + 0x10) = *(uint *)(*local_28 + 0x10) & 0x7fffffff | 0x80000000;
right_rotate(local_18[-1],plVar1);
local_20 = (long *)*param_1;
goto LAB_001fff7a;
}
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff;
}
local_18 = local_18 + -1;
local_20 = plVar1;
} while( true );
}
| |
24,172 | PFS_table_io_stat::aggregate(PFS_table_io_stat const*) | eloqsql/storage/perfschema/pfs_stat.h | inline void aggregate(const PFS_table_io_stat *stat)
{
if (stat->m_has_data)
{
m_has_data= true;
m_fetch.aggregate(&stat->m_fetch);
m_insert.aggregate(&stat->m_insert);
m_update.aggregate(&stat->m_update);
m_delete.aggregate(&stat->m_delete);
}
} | O3 | c | PFS_table_io_stat::aggregate(PFS_table_io_stat const*):
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, (%rsi)
jne 0x3aade
movb $0x1, (%rdi)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x3aa5d
addq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
addq %rax, 0x10(%rdi)
movq 0x18(%rsi), %rax
cmpq %rax, 0x18(%rdi)
ja 0x3aae0
movq 0x20(%rsi), %rax
cmpq %rax, 0x20(%rdi)
jb 0x3aae9
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x3aa86
addq %rax, 0x28(%rdi)
movq 0x30(%rsi), %rax
addq %rax, 0x30(%rdi)
movq 0x38(%rsi), %rax
cmpq %rax, 0x38(%rdi)
ja 0x3aaf2
movq 0x40(%rsi), %rax
cmpq %rax, 0x40(%rdi)
jb 0x3aaf8
movq 0x48(%rsi), %rax
testq %rax, %rax
je 0x3aaaf
addq %rax, 0x48(%rdi)
movq 0x50(%rsi), %rax
addq %rax, 0x50(%rdi)
movq 0x58(%rsi), %rax
cmpq %rax, 0x58(%rdi)
ja 0x3aafe
movq 0x60(%rsi), %rax
cmpq %rax, 0x60(%rdi)
jb 0x3ab04
movq 0x68(%rsi), %rax
testq %rax, %rax
je 0x3aade
addq %rax, 0x68(%rdi)
movq 0x70(%rsi), %rax
addq %rax, 0x70(%rdi)
movq 0x78(%rsi), %rax
cmpq %rax, 0x78(%rdi)
ja 0x3ab0a
movq 0x80(%rsi), %rax
cmpq %rax, 0x80(%rdi)
jb 0x3ab10
popq %rbp
retq
movq %rax, 0x18(%rdi)
jmp 0x3aa4f
movq %rax, 0x20(%rdi)
jmp 0x3aa5d
movq %rax, 0x38(%rdi)
jmp 0x3aa7c
movq %rax, 0x40(%rdi)
jmp 0x3aa86
movq %rax, 0x58(%rdi)
jmp 0x3aaa5
movq %rax, 0x60(%rdi)
jmp 0x3aaaf
movq %rax, 0x78(%rdi)
jmp 0x3aace
movq %rax, 0x80(%rdi)
jmp 0x3aade
nop
| _ZN17PFS_table_io_stat9aggregateEPKS_:
push rbp
mov rbp, rsp
cmp byte ptr [rsi], 1
jnz loc_3AADE
mov byte ptr [rdi], 1
mov rax, [rsi+8]
test rax, rax
jz short loc_3AA5D
add [rdi+8], rax
mov rax, [rsi+10h]
add [rdi+10h], rax
mov rax, [rsi+18h]
cmp [rdi+18h], rax
ja loc_3AAE0
loc_3AA4F:
mov rax, [rsi+20h]
cmp [rdi+20h], rax
jb loc_3AAE9
loc_3AA5D:
mov rax, [rsi+28h]
test rax, rax
jz short loc_3AA86
add [rdi+28h], rax
mov rax, [rsi+30h]
add [rdi+30h], rax
mov rax, [rsi+38h]
cmp [rdi+38h], rax
ja short loc_3AAF2
loc_3AA7C:
mov rax, [rsi+40h]
cmp [rdi+40h], rax
jb short loc_3AAF8
loc_3AA86:
mov rax, [rsi+48h]
test rax, rax
jz short loc_3AAAF
add [rdi+48h], rax
mov rax, [rsi+50h]
add [rdi+50h], rax
mov rax, [rsi+58h]
cmp [rdi+58h], rax
ja short loc_3AAFE
loc_3AAA5:
mov rax, [rsi+60h]
cmp [rdi+60h], rax
jb short loc_3AB04
loc_3AAAF:
mov rax, [rsi+68h]
test rax, rax
jz short loc_3AADE
add [rdi+68h], rax
mov rax, [rsi+70h]
add [rdi+70h], rax
mov rax, [rsi+78h]
cmp [rdi+78h], rax
ja short loc_3AB0A
loc_3AACE:
mov rax, [rsi+80h]
cmp [rdi+80h], rax
jb short loc_3AB10
loc_3AADE:
pop rbp
retn
loc_3AAE0:
mov [rdi+18h], rax
jmp loc_3AA4F
loc_3AAE9:
mov [rdi+20h], rax
jmp loc_3AA5D
loc_3AAF2:
mov [rdi+38h], rax
jmp short loc_3AA7C
loc_3AAF8:
mov [rdi+40h], rax
jmp short loc_3AA86
loc_3AAFE:
mov [rdi+58h], rax
jmp short loc_3AAA5
loc_3AB04:
mov [rdi+60h], rax
jmp short loc_3AAAF
loc_3AB0A:
mov [rdi+78h], rax
jmp short loc_3AACE
loc_3AB10:
mov [rdi+80h], rax
jmp short loc_3AADE
| void PFS_table_io_stat::aggregate(long long a1, long long a2)
{
long long v2; // rax
unsigned long long v3; // rax
unsigned long long v4; // rax
long long v5; // rax
unsigned long long v6; // rax
unsigned long long v7; // rax
long long v8; // rax
unsigned long long v9; // rax
unsigned long long v10; // rax
long long v11; // rax
unsigned long long v12; // rax
unsigned long long v13; // rax
if ( *(_BYTE *)a2 == 1 )
{
*(_BYTE *)a1 = 1;
v2 = *(_QWORD *)(a2 + 8);
if ( v2 )
{
*(_QWORD *)(a1 + 8) += v2;
*(_QWORD *)(a1 + 16) += *(_QWORD *)(a2 + 16);
v3 = *(_QWORD *)(a2 + 24);
if ( *(_QWORD *)(a1 + 24) > v3 )
*(_QWORD *)(a1 + 24) = v3;
v4 = *(_QWORD *)(a2 + 32);
if ( *(_QWORD *)(a1 + 32) < v4 )
*(_QWORD *)(a1 + 32) = v4;
}
v5 = *(_QWORD *)(a2 + 40);
if ( v5 )
{
*(_QWORD *)(a1 + 40) += v5;
*(_QWORD *)(a1 + 48) += *(_QWORD *)(a2 + 48);
v6 = *(_QWORD *)(a2 + 56);
if ( *(_QWORD *)(a1 + 56) > v6 )
*(_QWORD *)(a1 + 56) = v6;
v7 = *(_QWORD *)(a2 + 64);
if ( *(_QWORD *)(a1 + 64) < v7 )
*(_QWORD *)(a1 + 64) = v7;
}
v8 = *(_QWORD *)(a2 + 72);
if ( v8 )
{
*(_QWORD *)(a1 + 72) += v8;
*(_QWORD *)(a1 + 80) += *(_QWORD *)(a2 + 80);
v9 = *(_QWORD *)(a2 + 88);
if ( *(_QWORD *)(a1 + 88) > v9 )
*(_QWORD *)(a1 + 88) = v9;
v10 = *(_QWORD *)(a2 + 96);
if ( *(_QWORD *)(a1 + 96) < v10 )
*(_QWORD *)(a1 + 96) = v10;
}
v11 = *(_QWORD *)(a2 + 104);
if ( v11 )
{
*(_QWORD *)(a1 + 104) += v11;
*(_QWORD *)(a1 + 112) += *(_QWORD *)(a2 + 112);
v12 = *(_QWORD *)(a2 + 120);
if ( *(_QWORD *)(a1 + 120) > v12 )
*(_QWORD *)(a1 + 120) = v12;
v13 = *(_QWORD *)(a2 + 128);
if ( *(_QWORD *)(a1 + 128) < v13 )
*(_QWORD *)(a1 + 128) = v13;
}
}
}
| aggregate:
PUSH RBP
MOV RBP,RSP
CMP byte ptr [RSI],0x1
JNZ 0x0013aade
MOV byte ptr [RDI],0x1
MOV RAX,qword ptr [RSI + 0x8]
TEST RAX,RAX
JZ 0x0013aa5d
ADD qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x10]
ADD qword ptr [RDI + 0x10],RAX
MOV RAX,qword ptr [RSI + 0x18]
CMP qword ptr [RDI + 0x18],RAX
JA 0x0013aae0
LAB_0013aa4f:
MOV RAX,qword ptr [RSI + 0x20]
CMP qword ptr [RDI + 0x20],RAX
JC 0x0013aae9
LAB_0013aa5d:
MOV RAX,qword ptr [RSI + 0x28]
TEST RAX,RAX
JZ 0x0013aa86
ADD qword ptr [RDI + 0x28],RAX
MOV RAX,qword ptr [RSI + 0x30]
ADD qword ptr [RDI + 0x30],RAX
MOV RAX,qword ptr [RSI + 0x38]
CMP qword ptr [RDI + 0x38],RAX
JA 0x0013aaf2
LAB_0013aa7c:
MOV RAX,qword ptr [RSI + 0x40]
CMP qword ptr [RDI + 0x40],RAX
JC 0x0013aaf8
LAB_0013aa86:
MOV RAX,qword ptr [RSI + 0x48]
TEST RAX,RAX
JZ 0x0013aaaf
ADD qword ptr [RDI + 0x48],RAX
MOV RAX,qword ptr [RSI + 0x50]
ADD qword ptr [RDI + 0x50],RAX
MOV RAX,qword ptr [RSI + 0x58]
CMP qword ptr [RDI + 0x58],RAX
JA 0x0013aafe
LAB_0013aaa5:
MOV RAX,qword ptr [RSI + 0x60]
CMP qword ptr [RDI + 0x60],RAX
JC 0x0013ab04
LAB_0013aaaf:
MOV RAX,qword ptr [RSI + 0x68]
TEST RAX,RAX
JZ 0x0013aade
ADD qword ptr [RDI + 0x68],RAX
MOV RAX,qword ptr [RSI + 0x70]
ADD qword ptr [RDI + 0x70],RAX
MOV RAX,qword ptr [RSI + 0x78]
CMP qword ptr [RDI + 0x78],RAX
JA 0x0013ab0a
LAB_0013aace:
MOV RAX,qword ptr [RSI + 0x80]
CMP qword ptr [RDI + 0x80],RAX
JC 0x0013ab10
LAB_0013aade:
POP RBP
RET
LAB_0013aae0:
MOV qword ptr [RDI + 0x18],RAX
JMP 0x0013aa4f
LAB_0013aae9:
MOV qword ptr [RDI + 0x20],RAX
JMP 0x0013aa5d
LAB_0013aaf2:
MOV qword ptr [RDI + 0x38],RAX
JMP 0x0013aa7c
LAB_0013aaf8:
MOV qword ptr [RDI + 0x40],RAX
JMP 0x0013aa86
LAB_0013aafe:
MOV qword ptr [RDI + 0x58],RAX
JMP 0x0013aaa5
LAB_0013ab04:
MOV qword ptr [RDI + 0x60],RAX
JMP 0x0013aaaf
LAB_0013ab0a:
MOV qword ptr [RDI + 0x78],RAX
JMP 0x0013aace
LAB_0013ab10:
MOV qword ptr [RDI + 0x80],RAX
JMP 0x0013aade
|
/* PFS_table_io_stat::aggregate(PFS_table_io_stat const*) */
void __thiscall PFS_table_io_stat::aggregate(PFS_table_io_stat *this,PFS_table_io_stat *param_1)
{
if (*param_1 == (PFS_table_io_stat)0x1) {
*this = (PFS_table_io_stat)0x1;
if (*(long *)(param_1 + 8) != 0) {
*(long *)(this + 8) = *(long *)(this + 8) + *(long *)(param_1 + 8);
*(long *)(this + 0x10) = *(long *)(this + 0x10) + *(long *)(param_1 + 0x10);
if (*(ulong *)(param_1 + 0x18) < *(ulong *)(this + 0x18)) {
*(ulong *)(this + 0x18) = *(ulong *)(param_1 + 0x18);
}
if (*(ulong *)(this + 0x20) < *(ulong *)(param_1 + 0x20)) {
*(ulong *)(this + 0x20) = *(ulong *)(param_1 + 0x20);
}
}
if (*(long *)(param_1 + 0x28) != 0) {
*(long *)(this + 0x28) = *(long *)(this + 0x28) + *(long *)(param_1 + 0x28);
*(long *)(this + 0x30) = *(long *)(this + 0x30) + *(long *)(param_1 + 0x30);
if (*(ulong *)(param_1 + 0x38) < *(ulong *)(this + 0x38)) {
*(ulong *)(this + 0x38) = *(ulong *)(param_1 + 0x38);
}
if (*(ulong *)(this + 0x40) < *(ulong *)(param_1 + 0x40)) {
*(ulong *)(this + 0x40) = *(ulong *)(param_1 + 0x40);
}
}
if (*(long *)(param_1 + 0x48) != 0) {
*(long *)(this + 0x48) = *(long *)(this + 0x48) + *(long *)(param_1 + 0x48);
*(long *)(this + 0x50) = *(long *)(this + 0x50) + *(long *)(param_1 + 0x50);
if (*(ulong *)(param_1 + 0x58) < *(ulong *)(this + 0x58)) {
*(ulong *)(this + 0x58) = *(ulong *)(param_1 + 0x58);
}
if (*(ulong *)(this + 0x60) < *(ulong *)(param_1 + 0x60)) {
*(ulong *)(this + 0x60) = *(ulong *)(param_1 + 0x60);
}
}
if (*(long *)(param_1 + 0x68) != 0) {
*(long *)(this + 0x68) = *(long *)(this + 0x68) + *(long *)(param_1 + 0x68);
*(long *)(this + 0x70) = *(long *)(this + 0x70) + *(long *)(param_1 + 0x70);
if (*(ulong *)(param_1 + 0x78) < *(ulong *)(this + 0x78)) {
*(ulong *)(this + 0x78) = *(ulong *)(param_1 + 0x78);
}
if (*(ulong *)(this + 0x80) < *(ulong *)(param_1 + 0x80)) {
*(ulong *)(this + 0x80) = *(ulong *)(param_1 + 0x80);
}
}
}
return;
}
| |
24,173 | google::protobuf::DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(google::protobuf::DescriptorProto_ReservedRange const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc | DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(const DescriptorProto_ReservedRange& from)
: ::PROTOBUF_NAMESPACE_ID::Message() {
DescriptorProto_ReservedRange* const _this = this; (void)_this;
new (&_impl_) Impl_{
decltype(_impl_._has_bits_){from._impl_._has_bits_}
, /*decltype(_impl_._cached_size_)*/{}
, decltype(_impl_.start_){}
, decltype(_impl_.end_){}};
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
::memcpy(&_impl_.start_, &from._impl_.start_,
static_cast<size_t>(reinterpret_cast<char*>(&_impl_.end_) -
reinterpret_cast<char*>(&_impl_.start_)) + sizeof(_impl_.end_));
// @@protoc_insertion_point(copy_constructor:google.protobuf.DescriptorProto.ReservedRange)
} | O0 | cpp | google::protobuf::DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(google::protobuf::DescriptorProto_ReservedRange const&):
subq $0xa8, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1540b0
movq 0x28(%rsp), %rax
leaq 0x247864(%rip), %rcx # 0x4fe8c0
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rax, 0x48(%rsp)
movq %rax, %rdi
addq $0x10, %rdi
movq 0x50(%rsp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
addq $0x4, %rdi
movq %rdi, 0x20(%rsp)
xorl %esi, %esi
movl $0x4, %edx
callq 0x8db70
movq 0x20(%rsp), %rdi
callq 0x1540e0
movq 0x28(%rsp), %rcx
movl $0x0, 0x18(%rcx)
movl $0x0, 0x1c(%rcx)
addq $0x8, %rcx
movq 0x50(%rsp), %rax
addq $0x8, %rax
movq %rcx, 0x68(%rsp)
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
setne %al
movb %al, 0x3b(%rsp)
movb 0x3b(%rsp), %al
testb $0x1, %al
jne 0x2b710b
jmp 0x2b71ae
movq 0x60(%rsp), %rax
movq %rax, 0x80(%rsp)
movq $0x0, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x2b7173
movq 0x18(%rsp), %rdi
callq 0x155370
addq $0x8, %rax
movq %rax, 0x88(%rsp)
jmp 0x2b718e
movq 0x78(%rsp), %rax
callq *%rax
movq %rax, 0x10(%rsp)
jmp 0x2b7181
movq 0x10(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x155200
jmp 0x2b71ac
jmp 0x2b71ae
jmp 0x2b71b0
movq 0x28(%rsp), %rax
movq %rax, %rdi
addq $0x10, %rdi
addq $0x8, %rdi
movq 0x50(%rsp), %rsi
addq $0x10, %rsi
addq $0x8, %rsi
movq %rax, %rdx
addq $0x10, %rdx
addq $0xc, %rdx
addq $0x10, %rax
addq $0x8, %rax
subq %rax, %rdx
addq $0x4, %rdx
callq 0x8b800
addq $0xa8, %rsp
retq
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x1540a0
movq 0x40(%rsp), %rdi
callq 0x90db0
nopw %cs:(%rax,%rax)
| _ZN6google8protobuf29DescriptorProto_ReservedRangeC2ERKS1_:
sub rsp, 0A8h
mov [rsp+0A8h+var_50], rdi
mov [rsp+0A8h+var_58], rsi
mov rdi, [rsp+0A8h+var_50]; this
mov [rsp+0A8h+var_80], rdi
call _ZN6google8protobuf7MessageC2Ev; google::protobuf::Message::Message(void)
mov rax, [rsp+0A8h+var_80]
lea rcx, _ZTVN6google8protobuf29DescriptorProto_ReservedRangeE; `vtable for'google::protobuf::DescriptorProto_ReservedRange
add rcx, 10h
mov [rax], rcx
mov [rsp+0A8h+var_60], rax
mov rdi, rax
add rdi, 10h
mov rcx, [rsp+0A8h+var_58]
mov ecx, [rcx+10h]
mov [rax+10h], ecx
add rdi, 4
mov [rsp+0A8h+var_88], rdi
xor esi, esi
mov edx, 4
call _memset
mov rdi, [rsp+0A8h+var_88]; this
call _ZN6google8protobuf8internal10CachedSizeC2Ev; google::protobuf::internal::CachedSize::CachedSize(void)
mov rcx, [rsp+0A8h+var_80]
mov dword ptr [rcx+18h], 0
mov dword ptr [rcx+1Ch], 0
add rcx, 8
mov rax, [rsp+0A8h+var_58]
add rax, 8
mov [rsp+0A8h+var_40], rcx
mov [rsp+0A8h+var_48], rax
mov rax, [rsp+0A8h+var_40]
mov [rsp+0A8h+var_78], rax
mov rax, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_38], rax
mov rax, [rsp+0A8h+var_38]
mov [rsp+0A8h+var_8], rax
mov rax, [rsp+0A8h+var_8]
mov rax, [rax]
and rax, 1
cmp rax, 0
setnz al
mov [rsp+0A8h+var_6D], al
mov al, [rsp+0A8h+var_6D]
test al, 1
jnz short loc_2B710B
jmp loc_2B71AE
loc_2B710B:
mov rax, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_28], rax
mov [rsp+0A8h+var_30], 0
mov rax, [rsp+0A8h+var_28]
mov [rsp+0A8h+var_90], rax
mov [rsp+0A8h+var_18], rax
mov rax, [rsp+0A8h+var_18]
mov [rsp+0A8h+var_10], rax
mov rax, [rsp+0A8h+var_10]
mov rax, [rax]
and rax, 1
cmp rax, 0
jz short loc_2B7173
mov rdi, [rsp+0A8h+var_90]
call _ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS2_9ContainerINS0_15UnknownFieldSetEEEEEPT_v; google::protobuf::internal::InternalMetadata::PtrValue<google::protobuf::internal::InternalMetadata::Container<google::protobuf::UnknownFieldSet>>(void)
add rax, 8
mov [rsp+0A8h+var_20], rax
jmp short loc_2B718E
loc_2B7173:
mov rax, [rsp+0A8h+var_30]
call rax
mov [rsp+0A8h+var_98], rax
jmp short $+2
loc_2B7181:
mov rax, [rsp+0A8h+var_98]
mov [rsp+0A8h+var_20], rax
loc_2B718E:
mov rax, [rsp+0A8h+var_20]
mov qword ptr [rsp+0A8h+var_A0], rax
mov rsi, qword ptr [rsp+0A8h+var_A0]; int
mov rdi, [rsp+0A8h+var_78]; void *
call _ZN6google8protobuf8internal16InternalMetadata11DoMergeFromINS0_15UnknownFieldSetEEEvRKT_; google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(google::protobuf::UnknownFieldSet const&)
jmp short $+2
loc_2B71AC:
jmp short $+2
loc_2B71AE:
jmp short $+2
loc_2B71B0:
mov rax, [rsp+0A8h+var_80]
mov rdi, rax
add rdi, 10h
add rdi, 8
mov rsi, [rsp+0A8h+var_58]
add rsi, 10h
add rsi, 8
mov rdx, rax
add rdx, 10h
add rdx, 0Ch
add rax, 10h
add rax, 8
sub rdx, rax
add rdx, 4
call _memcpy
add rsp, 0A8h
retn
mov rdi, [rsp+arg_20]; this
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
call _ZN6google8protobuf7MessageD2Ev; google::protobuf::Message::~Message()
mov rdi, [rsp+arg_38]
call __Unwind_Resume
| long long google::protobuf::DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(
google::protobuf::DescriptorProto_ReservedRange *this,
const google::protobuf::DescriptorProto_ReservedRange *a2)
{
unsigned long long v3; // [rsp+88h] [rbp-20h]
google::protobuf::Message::Message(this);
*(_QWORD *)this = &`vtable for'google::protobuf::DescriptorProto_ReservedRange + 2;
*((_DWORD *)this + 4) = *((_DWORD *)a2 + 4);
memset((char *)this + 20, 0LL, 4LL);
google::protobuf::internal::CachedSize::CachedSize((google::protobuf::DescriptorProto_ReservedRange *)((char *)this + 20));
*((_DWORD *)this + 6) = 0;
*((_DWORD *)this + 7) = 0;
if ( (*((_QWORD *)a2 + 1) & 1LL) != 0 )
{
v3 = google::protobuf::internal::InternalMetadata::PtrValue<google::protobuf::internal::InternalMetadata::Container<google::protobuf::UnknownFieldSet>>((_QWORD *)a2 + 1)
+ 8;
google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>((char *)this + 8, v3);
}
return memcpy((char *)this + 24, (char *)a2 + 24, 8LL);
}
| MutableRepeatedFieldInternal<bool>:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP],RDX
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP]
MOV ECX,0x7
MOV R8D,0xffffffff
XOR EAX,EAX
MOV R9D,EAX
CALL 0x002b5f70
ADD RSP,0x18
RET
|
/* google::protobuf::RepeatedField<bool>*
google::protobuf::Reflection::MutableRepeatedFieldInternal<bool>(google::protobuf::Message*,
google::protobuf::FieldDescriptor const*) const */
RepeatedField * __thiscall
google::protobuf::Reflection::MutableRepeatedFieldInternal<bool>
(Reflection *this,Message *param_1,FieldDescriptor *param_2)
{
RepeatedField *pRVar1;
pRVar1 = (RepeatedField *)MutableRawRepeatedField(this,param_1,param_2,7,0xffffffff,0);
return pRVar1;
}
| |
24,174 | google::protobuf::DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(google::protobuf::DescriptorProto_ReservedRange const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc | DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(const DescriptorProto_ReservedRange& from)
: ::PROTOBUF_NAMESPACE_ID::Message() {
DescriptorProto_ReservedRange* const _this = this; (void)_this;
new (&_impl_) Impl_{
decltype(_impl_._has_bits_){from._impl_._has_bits_}
, /*decltype(_impl_._cached_size_)*/{}
, decltype(_impl_.start_){}
, decltype(_impl_.end_){}};
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
::memcpy(&_impl_.start_, &from._impl_.start_,
static_cast<size_t>(reinterpret_cast<char*>(&_impl_.end_) -
reinterpret_cast<char*>(&_impl_.start_)) + sizeof(_impl_.end_));
// @@protoc_insertion_point(copy_constructor:google.protobuf.DescriptorProto.ReservedRange)
} | O3 | cpp | google::protobuf::DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(google::protobuf::DescriptorProto_ReservedRange const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x120970(%rip), %rcx # 0x20c930
movq %rcx, (%rdi)
movl 0x10(%rsi), %ecx
movl %ecx, 0x10(%rdi)
movq %rax, 0x14(%rdi)
movl $0x0, 0x1c(%rdi)
movq 0x8(%rsi), %rsi
testb $0x1, %sil
je 0xebff2
leaq 0x8(%rbx), %r15
andq $-0x4, %rsi
addq $0x8, %rsi
movq %r15, %rdi
callq 0x734be
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x11e516(%rip), %rax # 0x20a520
addq $0x10, %rax
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x73456
movq %r14, %rdi
callq 0x2e220
nop
| _ZN6google8protobuf29DescriptorProto_ReservedRangeC2ERKS1_:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
xor eax, eax
mov [rdi+8], rax
lea rcx, off_20C930
mov [rdi], rcx
mov ecx, [rsi+10h]
mov [rdi+10h], ecx
mov [rdi+14h], rax
mov dword ptr [rdi+1Ch], 0
mov rsi, [rsi+8]
test sil, 1
jz short loc_EBFF2
lea r15, [rbx+8]
and rsi, 0FFFFFFFFFFFFFFFCh
add rsi, 8
mov rdi, r15
call _ZN6google8protobuf8internal16InternalMetadata11DoMergeFromINS0_15UnknownFieldSetEEEvRKT_; google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(google::protobuf::UnknownFieldSet const&)
loc_EBFF2:
mov rax, [r14+18h]
mov [rbx+18h], rax
pop rbx
pop r14
pop r15
retn
mov r14, rax
lea rax, _ZTVN6google8protobuf11MessageLiteE; `vtable for'google::protobuf::MessageLite
add rax, 10h
mov [rbx], rax
mov rdi, r15; this
call _ZN6google8protobuf8internal16InternalMetadataD2Ev; google::protobuf::internal::InternalMetadata::~InternalMetadata()
mov rdi, r14
call __Unwind_Resume
| long long google::protobuf::DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(
google::protobuf::DescriptorProto_ReservedRange *this,
const google::protobuf::DescriptorProto_ReservedRange *a2)
{
long long v3; // rsi
long long result; // rax
*((_QWORD *)this + 1) = 0LL;
*(_QWORD *)this = off_20C930;
*((_DWORD *)this + 4) = *((_DWORD *)a2 + 4);
*(_QWORD *)((char *)this + 20) = 0LL;
*((_DWORD *)this + 7) = 0;
v3 = *((_QWORD *)a2 + 1);
if ( (v3 & 1) != 0 )
google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(
(long long *)this + 1,
(const google::protobuf::UnknownFieldSet *)((v3 & 0xFFFFFFFFFFFFFFFCLL) + 8));
result = *((_QWORD *)a2 + 3);
*((_QWORD *)this + 3) = result;
return result;
}
| DescriptorProto_ReservedRange:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
XOR EAX,EAX
MOV qword ptr [RDI + 0x8],RAX
LEA RCX,[0x30c930]
MOV qword ptr [RDI],RCX
MOV ECX,dword ptr [RSI + 0x10]
MOV dword ptr [RDI + 0x10],ECX
MOV qword ptr [RDI + 0x14],RAX
MOV dword ptr [RDI + 0x1c],0x0
MOV RSI,qword ptr [RSI + 0x8]
TEST SIL,0x1
JZ 0x001ebff2
LEA R15,[RBX + 0x8]
AND RSI,-0x4
ADD RSI,0x8
LAB_001ebfea:
MOV RDI,R15
CALL 0x001734be
LAB_001ebff2:
MOV RAX,qword ptr [R14 + 0x18]
MOV qword ptr [RBX + 0x18],RAX
POP RBX
POP R14
POP R15
RET
|
/* google::protobuf::DescriptorProto_ReservedRange::DescriptorProto_ReservedRange(google::protobuf::DescriptorProto_ReservedRange
const&) */
void __thiscall
google::protobuf::DescriptorProto_ReservedRange::DescriptorProto_ReservedRange
(DescriptorProto_ReservedRange *this,DescriptorProto_ReservedRange *param_1)
{
*(int8 *)(this + 8) = 0;
*(int ***)this = &PTR__DescriptorProto_ReservedRange_0030c930;
*(int4 *)(this + 0x10) = *(int4 *)(param_1 + 0x10);
*(int8 *)(this + 0x14) = 0;
*(int4 *)(this + 0x1c) = 0;
if ((*(ulong *)(param_1 + 8) & 1) != 0) {
/* try { // try from 001ebfea to 001ebff1 has its CatchHandler @ 001ec000 */
internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>
((InternalMetadata *)(this + 8),
(UnknownFieldSet *)((*(ulong *)(param_1 + 8) & 0xfffffffffffffffc) + 8));
}
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x18);
return;
}
| |
24,175 | minja::VariableExpr::VariableExpr(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/minja.hpp | VariableExpr(const Location & location, const std::string& n)
: Expression(location), name(n) {} | O3 | cpp | minja::VariableExpr::VariableExpr(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbx
movq %rdi, %rbx
leaq 0x94771(%rip), %rax # 0x12cda0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x9864e
movq (%rax), %rsi
incq %rsi
callq 0x1b8b0
leaq 0x93d43(%rip), %rax # 0x12c398
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x9866a
callq 0x6d556
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1b8b0
| _ZN5minja12VariableExprD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja12VariableExprE; `vtable for'minja::VariableExpr
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+20h]; void *
lea rax, [rbx+30h]
cmp rdi, rax
jz short loc_9864E
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9864E:
lea rax, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_9866A
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9866A:
mov esi, 40h ; '@'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void minja::VariableExpr::~VariableExpr(minja::VariableExpr *this)
{
char *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::VariableExpr + 2;
v2 = (char *)*((_QWORD *)this + 4);
if ( v2 != (char *)this + 48 )
operator delete(v2, *((_QWORD *)this + 6) + 1LL);
*(_QWORD *)this = &`vtable for'minja::Expression + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x40uLL);
}
| ~VariableExpr:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22cda0]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x20]
LEA RAX,[RBX + 0x30]
CMP RDI,RAX
JZ 0x0019864e
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0011b8b0
LAB_0019864e:
LEA RAX,[0x22c398]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x0019866a
CALL 0x0016d556
LAB_0019866a:
MOV ESI,0x40
MOV RDI,RBX
POP RBX
JMP 0x0011b8b0
|
/* minja::VariableExpr::~VariableExpr() */
void __thiscall minja::VariableExpr::~VariableExpr(VariableExpr *this)
{
*(int ***)this = &PTR_do_evaluate_0022cdb0;
if (*(VariableExpr **)(this + 0x20) != this + 0x30) {
operator_delete(*(VariableExpr **)(this + 0x20),*(long *)(this + 0x30) + 1);
}
*(int ***)this = &PTR___cxa_pure_virtual_0022c3a8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10));
}
operator_delete(this,0x40);
return;
}
| |
24,176 | my_open_parent_dir_nosymlinks | eloqsql/mysys/my_symlink.c | const char *my_open_parent_dir_nosymlinks(const char *pathname, int *pdfd)
{
char buf[FN_REFLEN + 1];
char *s= buf, *e= buf+1, *end= strnmov(buf, pathname, sizeof(buf));
int fd, dfd= -1;
if (*end)
{
errno= ENAMETOOLONG;
return NULL;
}
if (*s != '/') /* not an absolute path */
{
errno= ENOENT;
return NULL;
}
for (;;)
{
if (*e == '/') /* '//' in the path */
{
errno= ENOENT;
goto err;
}
while (*e && *e != '/')
e++;
*e= 0;
if (!memcmp(s, ".", 2) || !memcmp(s, "..", 3))
{
errno= ENOENT;
goto err;
}
if (++e >= end)
{
*pdfd= dfd;
return pathname + (s - buf);
}
fd = openat(dfd, s, O_NOFOLLOW | O_PATH | O_CLOEXEC);
if (fd < 0)
goto err;
if (dfd >= 0)
close(dfd);
dfd= fd;
s= e;
}
err:
if (dfd >= 0)
close(dfd);
return NULL;
} | O3 | c | my_open_parent_dir_nosymlinks:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0x240(%rbp), %r15
movl $0x201, %edx # imm = 0x201
movq %r15, %rdi
movq %rbx, %rsi
callq 0xdde2c
cmpb $0x0, (%rax)
je 0xa756f
callq 0x2a820
movl $0x24, (%rax)
jmp 0xa7646
cmpb $0x2f, -0x240(%rbp)
jne 0xa761b
movq %rax, %r12
movq %r14, -0x248(%rbp)
movb -0x23f(%rbp), %al
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
cmpb $0x2f, %al
je 0xa762b
leaq -0x23f(%rbp), %rcx
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movq %r15, %rsi
incq %rcx
movq %rcx, %r15
testb %al, %al
je 0xa75c4
movzbl %al, %eax
cmpl $0x2f, %eax
je 0xa75c4
movb (%r15), %al
incq %r15
jmp 0xa75b0
movb $0x0, -0x1(%r15)
cmpw $0x2e, (%rsi)
je 0xa7628
movzwl (%rsi), %eax
xorl $0x2e2e, %eax # imm = 0x2E2E
movzbl 0x2(%rsi), %ecx
orw %ax, %cx
je 0xa7628
cmpq %r12, %r15
jae 0xa766c
movl %r14d, %edi
movl $0x2a0000, %edx # imm = 0x2A0000
xorl %eax, %eax
callq 0x2a5f0
testl %eax, %eax
js 0xa7639
movl %eax, %r13d
testl %r14d, %r14d
js 0xa760c
movl %r14d, %edi
callq 0x2a1b0
movb (%r15), %al
movl %r13d, %r14d
movq %r15, %rcx
cmpb $0x2f, %al
jne 0xa75a7
jmp 0xa762b
callq 0x2a820
movl $0x2, (%rax)
jmp 0xa7646
movl %r14d, %r13d
callq 0x2a820
movl $0x2, (%rax)
movl %r13d, %r14d
testl %r14d, %r14d
js 0xa7646
movl %r14d, %edi
callq 0x2a1b0
xorl %ebx, %ebx
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xa7685
movq %rbx, %rax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x248(%rbp), %rax
movl %r14d, (%rax)
leaq -0x240(%rbp), %rax
subq %rax, %rsi
addq %rsi, %rbx
jmp 0xa7648
callq 0x2a270
nop
| my_open_parent_dir_nosymlinks:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 228h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r15, [rbp+var_240]
mov edx, 201h
mov rdi, r15
mov rsi, rbx
call strnmov
cmp byte ptr [rax], 0
jz short loc_A756F
call ___errno_location
mov dword ptr [rax], 24h ; '$'
jmp loc_A7646
loc_A756F:
cmp [rbp+var_240], 2Fh ; '/'
jnz loc_A761B
mov r12, rax
mov [rbp+var_248], r14
mov al, [rbp+var_23F]
mov r13d, 0FFFFFFFFh
cmp al, 2Fh ; '/'
jz loc_A762B
lea rcx, [rbp+var_23F]
mov r14d, 0FFFFFFFFh
loc_A75A7:
mov rsi, r15
inc rcx
mov r15, rcx
loc_A75B0:
test al, al
jz short loc_A75C4
movzx eax, al
cmp eax, 2Fh ; '/'
jz short loc_A75C4
mov al, [r15]
inc r15
jmp short loc_A75B0
loc_A75C4:
mov byte ptr [r15-1], 0
cmp word ptr [rsi], 2Eh ; '.'
jz short loc_A7628
movzx eax, word ptr [rsi]
xor eax, 2E2Eh
movzx ecx, byte ptr [rsi+2]
or cx, ax
jz short loc_A7628
cmp r15, r12
jnb loc_A766C
mov edi, r14d
mov edx, offset unk_2A0000
xor eax, eax
call _openat64
test eax, eax
js short loc_A7639
mov r13d, eax
test r14d, r14d
js short loc_A760C
mov edi, r14d
call _close
loc_A760C:
mov al, [r15]
mov r14d, r13d
mov rcx, r15
cmp al, 2Fh ; '/'
jnz short loc_A75A7
jmp short loc_A762B
loc_A761B:
call ___errno_location
mov dword ptr [rax], 2
jmp short loc_A7646
loc_A7628:
mov r13d, r14d
loc_A762B:
call ___errno_location
mov dword ptr [rax], 2
mov r14d, r13d
loc_A7639:
test r14d, r14d
js short loc_A7646
mov edi, r14d
call _close
loc_A7646:
xor ebx, ebx
loc_A7648:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_A7685
mov rax, rbx
add rsp, 228h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A766C:
mov rax, [rbp+var_248]
mov [rax], r14d
lea rax, [rbp+var_240]
sub rsi, rax
add rbx, rsi
jmp short loc_A7648
loc_A7685:
call ___stack_chk_fail
| long long my_open_parent_dir_nosymlinks(long long a1, unsigned int *a2)
{
char *v3; // r15
char *v4; // rdi
char *v5; // rax
char *v6; // r12
char v7; // al
int v8; // r13d
char *v9; // rcx
unsigned int v10; // r14d
char *v11; // rsi
long long v12; // rcx
int v13; // eax
unsigned int *v16; // [rsp+8h] [rbp-248h]
char v17; // [rsp+10h] [rbp-240h] BYREF
char v18; // [rsp+11h] [rbp-23Fh] BYREF
unsigned long long v19; // [rsp+220h] [rbp-30h]
v19 = __readfsqword(0x28u);
v3 = &v17;
v4 = &v17;
v5 = (char *)strnmov(&v17, a1, 513LL);
if ( *v5 )
{
*(_DWORD *)__errno_location(&v17) = 36;
return 0LL;
}
if ( v17 != 47 )
{
*(_DWORD *)__errno_location(&v17) = 2;
return 0LL;
}
v6 = v5;
v16 = a2;
v7 = v18;
v8 = -1;
if ( v18 == 47 )
{
LABEL_20:
*(_DWORD *)__errno_location(v4) = 2;
v10 = v8;
LABEL_21:
if ( (v10 & 0x80000000) == 0 )
close(v10);
return 0LL;
}
v9 = &v18;
v10 = -1;
while ( 1 )
{
v11 = v3;
v3 = v9 + 1;
while ( v7 && v7 != 47 )
v7 = *v3++;
*(v3 - 1) = 0;
if ( *(_WORD *)v11 == 46 || (v12 = (unsigned __int8)v11[2], LOWORD(v12) = *(_WORD *)v11 ^ 0x2E2E | v12, !(_WORD)v12) )
{
v8 = v10;
goto LABEL_20;
}
if ( v3 >= v6 )
break;
v4 = (char *)v10;
v13 = openat64(v10, v11, &unk_2A0000, v12);
if ( v13 < 0 )
goto LABEL_21;
v8 = v13;
if ( (v10 & 0x80000000) == 0 )
{
v4 = (char *)v10;
close(v10);
}
v7 = *v3;
v10 = v8;
v9 = v3;
if ( *v3 == 47 )
goto LABEL_20;
}
*v16 = v10;
return v11 - &v17 + a1;
}
| my_open_parent_dir_nosymlinks:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x228
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R15,[RBP + -0x240]
MOV EDX,0x201
MOV RDI,R15
MOV RSI,RBX
CALL 0x001dde2c
CMP byte ptr [RAX],0x0
JZ 0x001a756f
CALL 0x0012a820
MOV dword ptr [RAX],0x24
JMP 0x001a7646
LAB_001a756f:
CMP byte ptr [RBP + -0x240],0x2f
JNZ 0x001a761b
MOV R12,RAX
MOV qword ptr [RBP + -0x248],R14
MOV AL,byte ptr [RBP + -0x23f]
MOV R13D,0xffffffff
CMP AL,0x2f
JZ 0x001a762b
LEA RCX,[RBP + -0x23f]
MOV R14D,0xffffffff
LAB_001a75a7:
MOV RSI,R15
INC RCX
MOV R15,RCX
LAB_001a75b0:
TEST AL,AL
JZ 0x001a75c4
MOVZX EAX,AL
CMP EAX,0x2f
JZ 0x001a75c4
MOV AL,byte ptr [R15]
INC R15
JMP 0x001a75b0
LAB_001a75c4:
MOV byte ptr [R15 + -0x1],0x0
CMP word ptr [RSI],0x2e
JZ 0x001a7628
MOVZX EAX,word ptr [RSI]
XOR EAX,0x2e2e
MOVZX ECX,byte ptr [RSI + 0x2]
OR CX,AX
JZ 0x001a7628
CMP R15,R12
JNC 0x001a766c
MOV EDI,R14D
MOV EDX,0x2a0000
XOR EAX,EAX
CALL 0x0012a5f0
TEST EAX,EAX
JS 0x001a7639
MOV R13D,EAX
TEST R14D,R14D
JS 0x001a760c
MOV EDI,R14D
CALL 0x0012a1b0
LAB_001a760c:
MOV AL,byte ptr [R15]
MOV R14D,R13D
MOV RCX,R15
CMP AL,0x2f
JNZ 0x001a75a7
JMP 0x001a762b
LAB_001a761b:
CALL 0x0012a820
MOV dword ptr [RAX],0x2
JMP 0x001a7646
LAB_001a7628:
MOV R13D,R14D
LAB_001a762b:
CALL 0x0012a820
MOV dword ptr [RAX],0x2
MOV R14D,R13D
LAB_001a7639:
TEST R14D,R14D
JS 0x001a7646
MOV EDI,R14D
CALL 0x0012a1b0
LAB_001a7646:
XOR EBX,EBX
LAB_001a7648:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001a7685
MOV RAX,RBX
ADD RSP,0x228
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a766c:
MOV RAX,qword ptr [RBP + -0x248]
MOV dword ptr [RAX],R14D
LEA RAX,[RBP + -0x240]
SUB RSI,RAX
ADD RBX,RSI
JMP 0x001a7648
LAB_001a7685:
CALL 0x0012a270
|
long my_open_parent_dir_nosymlinks(long param_1,int *param_2)
{
short *psVar1;
int iVar2;
short *psVar3;
int *piVar4;
long lVar5;
int __fd;
short *psVar6;
short *__file;
long in_FS_OFFSET;
int1 local_248 [2];
int1 local_246 [526];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
psVar3 = (short *)strnmov(local_248,param_1,0x201);
if ((char)*psVar3 == '\0') {
if (local_248[0] == '/') {
__fd = -1;
if (local_248[1] != '/') {
psVar1 = (short *)(local_248 + 1);
__file = (short *)local_248;
__fd = -1;
do {
while ((psVar6 = (short *)((long)psVar1 + 1), local_248[1] != '\0' &&
(local_248[1] != '/'))) {
psVar1 = psVar6;
local_248[1] = *(char *)psVar6;
}
*(char *)psVar1 = '\0';
if ((*__file == 0x2e) || ((char)__file[1] == '\0' && *__file == 0x2e2e)) break;
if (psVar3 <= psVar6) {
*param_2 = __fd;
lVar5 = (long)__file + (param_1 - (long)local_248);
goto LAB_001a7648;
}
iVar2 = openat64(__fd,(char *)__file,0x2a0000);
if (iVar2 < 0) goto LAB_001a7639;
if (-1 < __fd) {
close(__fd);
}
local_248[1] = *(char *)psVar6;
__fd = iVar2;
psVar1 = psVar6;
__file = psVar6;
} while (local_248[1] != '/');
}
piVar4 = __errno_location();
*piVar4 = 2;
LAB_001a7639:
if (-1 < __fd) {
close(__fd);
}
}
else {
piVar4 = __errno_location();
*piVar4 = 2;
}
}
else {
piVar4 = __errno_location();
*piVar4 = 0x24;
}
lVar5 = 0;
LAB_001a7648:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar5;
}
| |
24,177 | spacingCB(LefDefParser::lefrCallbackType_e, LefDefParser::lefiSpacing*, void*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lefdiff/diffLefRW.cpp | int spacingCB(lefrCallbackType_e c, lefiSpacing* spacing, lefiUserData ud) {
checkType(c);
if (ud != userData) dataError();
lefSpacing(spacing, (char*)"SPACING");
return 0;
} | O3 | cpp | spacingCB(LefDefParser::lefrCallbackType_e, LefDefParser::lefiSpacing*, void*):
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
cmpl $0x39, %edi
jb 0xe910
movq 0x68af6(%rip), %rcx # 0x773f0
leaq 0x3c8f6(%rip), %rdi # 0x4b1f7
movl $0x27, %esi
movl $0x1, %edx
callq 0x23b0
cmpq %r14, 0x68ae9(%rip) # 0x77400
je 0xe936
movq 0x68ad0(%rip), %rcx # 0x773f0
leaq 0x3c8a5(%rip), %rdi # 0x4b1cc
movl $0x2a, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x3deaf(%rip), %rsi # 0x4c7ec
movq %rbx, %rdi
callq 0x311f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _Z9spacingCBN12LefDefParser18lefrCallbackType_eEPNS_11lefiSpacingEPv:
push r14
push rbx
push rax
mov r14, rdx
mov rbx, rsi
cmp edi, 39h ; '9'
jb short loc_E910
mov rcx, cs:fout
lea rdi, aErrorCallbackT; "ERROR: callback type is out of bounds!"...
mov esi, 27h ; '''
mov edx, 1
call _fwrite
loc_E910:
cmp cs:userData, r14
jz short loc_E936
mov rcx, cs:fout
lea rdi, aErrorReturnedU; "ERROR: returned user data is not correc"...
mov esi, 2Ah ; '*'
mov edx, 1
call _fwrite
loc_E936:
lea rsi, aNondefaultrule_2+12h; char *
mov rdi, rbx; this
call _Z10lefSpacingPN12LefDefParser11lefiSpacingEPc; lefSpacing(LefDefParser::lefiSpacing *,char *)
xor eax, eax
add rsp, 8
pop rbx
pop r14
retn
| long long spacingCB(unsigned int a1, LefDefParser::lefiSpacing *a2, long long a3, double a4)
{
if ( a1 >= 0x39 )
fwrite("ERROR: callback type is out of bounds!\n", 39LL, 1LL, fout);
if ( userData != a3 )
fwrite("ERROR: returned user data is not correct!\n", 42LL, 1LL, fout);
lefSpacing(a2, "SPACING", a4);
return 0LL;
}
| spacingCB:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV RBX,RSI
CMP EDI,0x39
JC 0x0010e910
MOV RCX,qword ptr [0x001773f0]
LEA RDI,[0x14b1f7]
MOV ESI,0x27
MOV EDX,0x1
CALL 0x001023b0
LAB_0010e910:
CMP qword ptr [0x00177400],R14
JZ 0x0010e936
MOV RCX,qword ptr [0x001773f0]
LEA RDI,[0x14b1cc]
MOV ESI,0x2a
MOV EDX,0x1
CALL 0x001023b0
LAB_0010e936:
LEA RSI,[0x14c7ec]
MOV RDI,RBX
CALL 0x0010311f
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* spacingCB(LefDefParser::lefrCallbackType_e, LefDefParser::lefiSpacing*, void*) */
int8 spacingCB(uint param_1,lefiSpacing *param_2,long param_3)
{
if (0x38 < param_1) {
fwrite("ERROR: callback type is out of bounds!\n",0x27,1,fout);
}
if (userData != param_3) {
fwrite("ERROR: returned user data is not correct!\n",0x2a,1,fout);
}
lefSpacing(param_2,"SPACING");
return 0;
}
| |
24,178 | my_numcells_eucjpms | eloqsql/strings/ctype-eucjpms.c | static
size_t my_numcells_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
const char *str, const char *str_end)
{
size_t clen;
const uchar *b= (const uchar *) str;
const uchar *e= (const uchar *) str_end;
for (clen= 0; b < e; )
{
if (*b == 0x8E)
{
clen++;
b+= 2;
}
else if (*b == 0x8F)
{
clen+= 2;
b+= 3;
}
else if (*b & 0x80)
{
clen+= 2;
b+= 2;
}
else
{
clen++;
b++;
}
}
return clen;
} | O0 | c | my_numcells_eucjpms:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x71ae2
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x8e, %eax
jne 0x71a6e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x71add
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x8f, %eax
jne 0x71a96
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x28(%rbp)
jmp 0x71adb
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x71ac1
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x71ad9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x71adb
jmp 0x71add
jmp 0x71a38
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
| my_numcells_eucjpms:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov [rbp+var_20], 0
loc_71A38:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnb loc_71AE2
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
cmp eax, 8Eh
jnz short loc_71A6E
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
jmp short loc_71ADD
loc_71A6E:
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
cmp eax, 8Fh
jnz short loc_71A96
mov rax, [rbp+var_20]
add rax, 2
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, 3
mov [rbp+var_28], rax
jmp short loc_71ADB
loc_71A96:
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
and eax, 80h
cmp eax, 0
jz short loc_71AC1
mov rax, [rbp+var_20]
add rax, 2
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
jmp short loc_71AD9
loc_71AC1:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
loc_71AD9:
jmp short $+2
loc_71ADB:
jmp short $+2
loc_71ADD:
jmp loc_71A38
loc_71AE2:
mov rax, [rbp+var_20]
pop rbp
retn
| long long my_numcells_eucjpms(long long a1, _BYTE *a2, unsigned long long a3)
{
long long v5; // [rsp+10h] [rbp-20h]
v5 = 0LL;
while ( (unsigned long long)a2 < a3 )
{
if ( (unsigned __int8)*a2 == 142 )
{
++v5;
a2 += 2;
}
else if ( (unsigned __int8)*a2 == 143 )
{
v5 += 2LL;
a2 += 3;
}
else if ( (*a2 & 0x80) != 0 )
{
v5 += 2LL;
a2 += 2;
}
else
{
++v5;
++a2;
}
}
return v5;
}
| my_numcells_eucjpms:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x20],0x0
LAB_00171a38:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00171ae2
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x8e
JNZ 0x00171a6e
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x2
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00171add
LAB_00171a6e:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x8f
JNZ 0x00171a96
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x3
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00171adb
LAB_00171a96:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x80
CMP EAX,0x0
JZ 0x00171ac1
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x2
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00171ad9
LAB_00171ac1:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_00171ad9:
JMP 0x00171adb
LAB_00171adb:
JMP 0x00171add
LAB_00171add:
JMP 0x00171a38
LAB_00171ae2:
MOV RAX,qword ptr [RBP + -0x20]
POP RBP
RET
|
long my_numcells_eucjpms(int8 param_1,byte *param_2,byte *param_3)
{
byte *local_30;
long local_28;
local_28 = 0;
local_30 = param_2;
while (local_30 < param_3) {
if (*local_30 == 0x8e) {
local_28 = local_28 + 1;
local_30 = local_30 + 2;
}
else if (*local_30 == 0x8f) {
local_28 = local_28 + 2;
local_30 = local_30 + 3;
}
else if ((*local_30 & 0x80) == 0) {
local_28 = local_28 + 1;
local_30 = local_30 + 1;
}
else {
local_28 = local_28 + 2;
local_30 = local_30 + 2;
}
}
return local_28;
}
| |
24,179 | bfdec_set_si | bluesky950520[P]quickjs/libbf.c | int bfdec_set_si(bfdec_t *r, int64_t v)
{
int ret;
if (v < 0) {
ret = bfdec_set_ui(r, -v);
r->sign = 1;
} else {
ret = bfdec_set_ui(r, v);
}
return ret;
} | O1 | c | bfdec_set_si:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
js 0x8eddd
movq %rbx, %rdi
popq %rbx
jmp 0x8ecbf
negq %rsi
movq %rbx, %rdi
callq 0x8ecbf
movl $0x1, 0x8(%rbx)
popq %rbx
retq
| bfdec_set_si:
push rbx
mov rbx, rdi
test rsi, rsi
js short loc_8EDDD
mov rdi, rbx
pop rbx
jmp bfdec_set_ui
loc_8EDDD:
neg rsi
mov rdi, rbx
call bfdec_set_ui
mov dword ptr [rbx+8], 1
pop rbx
retn
| long long bfdec_set_si(long long a1, signed long long a2)
{
long long result; // rax
if ( a2 >= 0 )
return bfdec_set_ui((_QWORD **)a1, a2);
result = bfdec_set_ui((_QWORD **)a1, -a2);
*(_DWORD *)(a1 + 8) = 1;
return result;
}
| bfdec_set_si:
PUSH RBX
MOV RBX,RDI
TEST RSI,RSI
JS 0x0018eddd
MOV RDI,RBX
POP RBX
JMP 0x0018ecbf
LAB_0018eddd:
NEG RSI
MOV RDI,RBX
CALL 0x0018ecbf
MOV dword ptr [RBX + 0x8],0x1
POP RBX
RET
|
void bfdec_set_si(long param_1,long param_2)
{
if (-1 < param_2) {
bfdec_set_ui(param_1);
return;
}
bfdec_set_ui(param_1,-param_2);
*(int4 *)(param_1 + 8) = 1;
return;
}
| |
24,180 | dump_all_databases | eloqsql/client/mysqldump.c | static int dump_all_databases()
{
MYSQL_ROW row;
MYSQL_RES *tableres;
int result=0;
if (mysql_query_with_error_report(mysql, &tableres, "SHOW DATABASES"))
return 1;
while ((row= mysql_fetch_row(tableres)))
{
if (mysql_get_server_version(mysql) >= FIRST_INFORMATION_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, row[0], INFORMATION_SCHEMA_DB_NAME))
continue;
if (mysql_get_server_version(mysql) >= FIRST_PERFORMANCE_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, row[0], PERFORMANCE_SCHEMA_DB_NAME))
continue;
if (mysql_get_server_version(mysql) >= FIRST_SYS_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, row[0], SYS_SCHEMA_DB_NAME))
continue;
if (include_database(row[0]))
if (dump_all_tables_in_db(row[0]))
result=1;
}
mysql_free_result(tableres);
if (seen_views)
{
if (mysql_query(mysql, "SHOW DATABASES") ||
!(tableres= mysql_store_result(mysql)))
{
fprintf(stderr, "%s: Error: Couldn't execute 'SHOW DATABASES': %s\n",
my_progname_short, mysql_error(mysql));
return 1;
}
while ((row= mysql_fetch_row(tableres)))
{
if (mysql_get_server_version(mysql) >= FIRST_INFORMATION_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, row[0], INFORMATION_SCHEMA_DB_NAME))
continue;
if (mysql_get_server_version(mysql) >= FIRST_PERFORMANCE_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, row[0], PERFORMANCE_SCHEMA_DB_NAME))
continue;
if (mysql_get_server_version(mysql) >= FIRST_SYS_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, row[0], SYS_SCHEMA_DB_NAME))
continue;
if (include_database(row[0]))
if (dump_all_views_in_db(row[0]))
result=1;
}
mysql_free_result(tableres);
}
return result;
} | O0 | c | dump_all_databases:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x1c(%rbp)
movq 0x3c2c82(%rip), %rdi # 0x4014c8
leaq -0x18(%rbp), %rsi
leaq 0x9d9fa(%rip), %rdx # 0xdc24b
callq 0x39350
cmpl $0x0, %eax
je 0x3e867
movl $0x1, -0x4(%rbp)
jmp 0x3eb3a
jmp 0x3e869
movq -0x18(%rbp), %rdi
callq 0x51800
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x3e981
movq 0x3c2c41(%rip), %rdi # 0x4014c8
callq 0x523b0
cmpq $0xc353, %rax # imm = 0xC353
jb 0x3e8c4
leaq 0x2b1c65(%rip), %rax # 0x2f0500
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
leaq 0x2b1c4c(%rip), %rdi # 0x2f0500
leaq 0x9d99f(%rip), %rdx # 0xdc25a
callq *%rax
cmpl $0x0, %eax
jne 0x3e8c4
jmp 0x3e869
movq 0x3c2bfd(%rip), %rdi # 0x4014c8
callq 0x523b0
cmpq $0xc547, %rax # imm = 0xC547
jb 0x3e90b
leaq 0x2b1c21(%rip), %rax # 0x2f0500
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
leaq 0x2b1c08(%rip), %rdi # 0x2f0500
leaq 0x9d96e(%rip), %rdx # 0xdc26d
callq *%rax
cmpl $0x0, %eax
jne 0x3e90b
jmp 0x3e869
movq 0x3c2bb6(%rip), %rdi # 0x4014c8
callq 0x523b0
cmpq $0x188f8, %rax # imm = 0x188F8
jb 0x3e952
leaq 0x2b1bda(%rip), %rax # 0x2f0500
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
leaq 0x2b1bc1(%rip), %rdi # 0x2f0500
leaq 0xa4e2d(%rip), %rdx # 0xe3773
callq *%rax
cmpl $0x0, %eax
jne 0x3e952
jmp 0x3e869
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3eb50
cmpb $0x0, %al
je 0x3e97c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3eba0
cmpl $0x0, %eax
je 0x3e97a
movl $0x1, -0x1c(%rbp)
jmp 0x3e97c
jmp 0x3e869
movq -0x18(%rbp), %rdi
callq 0x48d00
cmpb $0x0, 0x3c2b2f(%rip) # 0x4014c0
je 0x3eb34
movq 0x3c2b2a(%rip), %rdi # 0x4014c8
leaq 0x9d8a6(%rip), %rsi # 0xdc24b
callq 0x4fe70
cmpl $0x0, %eax
jne 0x3e9c5
movq 0x3c2b12(%rip), %rdi # 0x4014c8
callq 0x514c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3ea12
movq 0x206614(%rip), %rax # 0x244fe0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
leaq 0x3ce1fe(%rip), %rax # 0x40cbd8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x3c2ae0(%rip), %rdi # 0x4014c8
callq 0x537f0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x9d881(%rip), %rsi # 0xdc280
movb $0x0, %al
callq 0x381d0
movl $0x1, -0x4(%rbp)
jmp 0x3eb3a
jmp 0x3ea14
movq -0x18(%rbp), %rdi
callq 0x51800
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x3eb2b
movq 0x3c2a96(%rip), %rdi # 0x4014c8
callq 0x523b0
cmpq $0xc353, %rax # imm = 0xC353
jb 0x3ea6f
leaq 0x2b1aba(%rip), %rax # 0x2f0500
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
leaq 0x2b1aa1(%rip), %rdi # 0x2f0500
leaq 0x9d7f4(%rip), %rdx # 0xdc25a
callq *%rax
cmpl $0x0, %eax
jne 0x3ea6f
jmp 0x3ea14
movq 0x3c2a52(%rip), %rdi # 0x4014c8
callq 0x523b0
cmpq $0xc547, %rax # imm = 0xC547
jb 0x3eab6
leaq 0x2b1a76(%rip), %rax # 0x2f0500
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
leaq 0x2b1a5d(%rip), %rdi # 0x2f0500
leaq 0x9d7c3(%rip), %rdx # 0xdc26d
callq *%rax
cmpl $0x0, %eax
jne 0x3eab6
jmp 0x3ea14
movq 0x3c2a0b(%rip), %rdi # 0x4014c8
callq 0x523b0
cmpq $0x188f8, %rax # imm = 0x188F8
jb 0x3eafd
leaq 0x2b1a2f(%rip), %rax # 0x2f0500
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
leaq 0x2b1a16(%rip), %rdi # 0x2f0500
leaq 0xa4c82(%rip), %rdx # 0xe3773
callq *%rax
cmpl $0x0, %eax
jne 0x3eafd
jmp 0x3ea14
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3eb50
cmpb $0x0, %al
je 0x3eb26
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3f290
cmpb $0x0, %al
je 0x3eb24
movl $0x1, -0x1c(%rbp)
jmp 0x3eb26
jmp 0x3ea14
movq -0x18(%rbp), %rdi
callq 0x48d00
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| dump_all_databases:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_1C], 0
mov rdi, cs:mysql
lea rsi, [rbp+var_18]
lea rdx, aShowDatabases; "SHOW DATABASES"
call mysql_query_with_error_report
cmp eax, 0
jz short loc_3E867
mov [rbp+var_4], 1
jmp loc_3EB3A
loc_3E867:
jmp short $+2
loc_3E869:
mov rdi, [rbp+var_18]
call mysql_fetch_row
mov [rbp+var_10], rax
cmp rax, 0
jz loc_3E981
mov rdi, cs:mysql
call mysql_get_server_version
cmp rax, 0C353h
jb short loc_3E8C4
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
mov rsi, [rcx]
lea rdi, my_charset_latin1
lea rdx, aInformationSch; "information_schema"
call rax
cmp eax, 0
jnz short loc_3E8C4
jmp short loc_3E869
loc_3E8C4:
mov rdi, cs:mysql
call mysql_get_server_version
cmp rax, 0C547h
jb short loc_3E90B
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
mov rsi, [rcx]
lea rdi, my_charset_latin1
lea rdx, aPerformanceSch; "performance_schema"
call rax
cmp eax, 0
jnz short loc_3E90B
jmp loc_3E869
loc_3E90B:
mov rdi, cs:mysql
call mysql_get_server_version
cmp rax, 188F8h
jb short loc_3E952
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
mov rsi, [rcx]
lea rdi, my_charset_latin1
lea rdx, aMysys+2; "sys"
call rax
cmp eax, 0
jnz short loc_3E952
jmp loc_3E869
loc_3E952:
mov rax, [rbp+var_10]
mov rdi, [rax]
call include_database
cmp al, 0
jz short loc_3E97C
mov rax, [rbp+var_10]
mov rdi, [rax]
call dump_all_tables_in_db
cmp eax, 0
jz short loc_3E97A
mov [rbp+var_1C], 1
loc_3E97A:
jmp short $+2
loc_3E97C:
jmp loc_3E869
loc_3E981:
mov rdi, [rbp+var_18]
call mysql_free_result
cmp cs:seen_views, 0
jz loc_3EB34
mov rdi, cs:mysql
lea rsi, aShowDatabases; "SHOW DATABASES"
call mysql_query
cmp eax, 0
jnz short loc_3E9C5
mov rdi, cs:mysql
call mysql_store_result
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_3EA12
loc_3E9C5:
mov rax, cs:stderr_ptr
mov rax, [rax]
mov [rbp+var_30], rax
lea rax, my_progname_short
mov rax, [rax]
mov [rbp+var_28], rax
mov rdi, cs:mysql
call mysql_error
mov rdi, [rbp+var_30]
mov rdx, [rbp+var_28]
mov rcx, rax
lea rsi, aSErrorCouldnTE; "%s: Error: Couldn't execute 'SHOW DATAB"...
mov al, 0
call _fprintf
mov [rbp+var_4], 1
jmp loc_3EB3A
loc_3EA12:
jmp short $+2
loc_3EA14:
mov rdi, [rbp+var_18]
call mysql_fetch_row
mov [rbp+var_10], rax
cmp rax, 0
jz loc_3EB2B
mov rdi, cs:mysql
call mysql_get_server_version
cmp rax, 0C353h
jb short loc_3EA6F
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
mov rsi, [rcx]
lea rdi, my_charset_latin1
lea rdx, aInformationSch; "information_schema"
call rax
cmp eax, 0
jnz short loc_3EA6F
jmp short loc_3EA14
loc_3EA6F:
mov rdi, cs:mysql
call mysql_get_server_version
cmp rax, 0C547h
jb short loc_3EAB6
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
mov rsi, [rcx]
lea rdi, my_charset_latin1
lea rdx, aPerformanceSch; "performance_schema"
call rax
cmp eax, 0
jnz short loc_3EAB6
jmp loc_3EA14
loc_3EAB6:
mov rdi, cs:mysql
call mysql_get_server_version
cmp rax, 188F8h
jb short loc_3EAFD
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
mov rsi, [rcx]
lea rdi, my_charset_latin1
lea rdx, aMysys+2; "sys"
call rax
cmp eax, 0
jnz short loc_3EAFD
jmp loc_3EA14
loc_3EAFD:
mov rax, [rbp+var_10]
mov rdi, [rax]
call include_database
cmp al, 0
jz short loc_3EB26
mov rax, [rbp+var_10]
mov rdi, [rax]
call dump_all_views_in_db
cmp al, 0
jz short loc_3EB24
mov [rbp+var_1C], 1
loc_3EB24:
jmp short $+2
loc_3EB26:
jmp loc_3EA14
loc_3EB2B:
mov rdi, [rbp+var_18]
call mysql_free_result
loc_3EB34:
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
loc_3EB3A:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long dump_all_databases(double a1)
{
const char *v1; // rax
long long v3; // [rsp+0h] [rbp-30h]
const char *v4; // [rsp+8h] [rbp-28h]
unsigned int v5; // [rsp+14h] [rbp-1Ch]
long long v6; // [rsp+18h] [rbp-18h] BYREF
_QWORD *row; // [rsp+20h] [rbp-10h]
v5 = 0;
if ( !(unsigned int)mysql_query_with_error_report(mysql, &v6, (long long)"SHOW DATABASES") )
{
while ( 1 )
{
row = (_QWORD *)mysql_fetch_row(v6);
if ( !row )
break;
if ( ((unsigned long long)mysql_get_server_version(mysql, a1) < 0xC353
|| (*(unsigned int ( **)(void *, _QWORD, const char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*row,
"information_schema"))
&& ((unsigned long long)mysql_get_server_version(mysql, a1) < 0xC547
|| (*(unsigned int ( **)(void *, _QWORD, const char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*row,
"performance_schema"))
&& ((unsigned long long)mysql_get_server_version(mysql, a1) < 0x188F8
|| (*(unsigned int ( **)(void *, _QWORD, char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*row,
"sys"))
&& (unsigned __int8)include_database(*row)
&& (unsigned int)dump_all_tables_in_db(*row) )
{
v5 = 1;
}
}
mysql_free_result(v6);
if ( seen_views )
{
if ( (unsigned int)mysql_query(mysql, "SHOW DATABASES") || (v6 = mysql_store_result(mysql)) == 0 )
{
v3 = stderr;
v4 = (const char *)my_progname_short;
v1 = (const char *)mysql_error(mysql);
fprintf(v3, "%s: Error: Couldn't execute 'SHOW DATABASES': %s\n", v4, v1);
return 1;
}
while ( 1 )
{
row = (_QWORD *)mysql_fetch_row(v6);
if ( !row )
break;
if ( ((unsigned long long)mysql_get_server_version(mysql, a1) < 0xC353
|| (*(unsigned int ( **)(void *, _QWORD, const char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*row,
"information_schema"))
&& ((unsigned long long)mysql_get_server_version(mysql, a1) < 0xC547
|| (*(unsigned int ( **)(void *, _QWORD, const char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*row,
"performance_schema"))
&& ((unsigned long long)mysql_get_server_version(mysql, a1) < 0x188F8
|| (*(unsigned int ( **)(void *, _QWORD, char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*row,
"sys"))
&& (unsigned __int8)include_database(*row)
&& (unsigned __int8)dump_all_views_in_db(*row) )
{
v5 = 1;
}
}
mysql_free_result(v6);
}
return v5;
}
return 1;
}
| dump_all_databases:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x1c],0x0
MOV RDI,qword ptr [0x005014c8]
LEA RSI,[RBP + -0x18]
LEA RDX,[0x1dc24b]
CALL 0x00139350
CMP EAX,0x0
JZ 0x0013e867
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013eb3a
LAB_0013e867:
JMP 0x0013e869
LAB_0013e869:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00151800
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x0013e981
MOV RDI,qword ptr [0x005014c8]
CALL 0x001523b0
CMP RAX,0xc353
JC 0x0013e8c4
LEA RAX,[0x3f0500]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX]
LEA RDI,[0x3f0500]
LEA RDX,[0x1dc25a]
CALL RAX
CMP EAX,0x0
JNZ 0x0013e8c4
JMP 0x0013e869
LAB_0013e8c4:
MOV RDI,qword ptr [0x005014c8]
CALL 0x001523b0
CMP RAX,0xc547
JC 0x0013e90b
LEA RAX,[0x3f0500]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX]
LEA RDI,[0x3f0500]
LEA RDX,[0x1dc26d]
CALL RAX
CMP EAX,0x0
JNZ 0x0013e90b
JMP 0x0013e869
LAB_0013e90b:
MOV RDI,qword ptr [0x005014c8]
CALL 0x001523b0
CMP RAX,0x188f8
JC 0x0013e952
LEA RAX,[0x3f0500]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX]
LEA RDI,[0x3f0500]
LEA RDX,[0x1e3773]
CALL RAX
CMP EAX,0x0
JNZ 0x0013e952
JMP 0x0013e869
LAB_0013e952:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x0013eb50
CMP AL,0x0
JZ 0x0013e97c
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x0013eba0
CMP EAX,0x0
JZ 0x0013e97a
MOV dword ptr [RBP + -0x1c],0x1
LAB_0013e97a:
JMP 0x0013e97c
LAB_0013e97c:
JMP 0x0013e869
LAB_0013e981:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00148d00
CMP byte ptr [0x005014c0],0x0
JZ 0x0013eb34
MOV RDI,qword ptr [0x005014c8]
LEA RSI,[0x1dc24b]
CALL 0x0014fe70
CMP EAX,0x0
JNZ 0x0013e9c5
MOV RDI,qword ptr [0x005014c8]
CALL 0x001514c0
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x0013ea12
LAB_0013e9c5:
MOV RAX,qword ptr [0x00344fe0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x50cbd8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [0x005014c8]
CALL 0x001537f0
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,RAX
LEA RSI,[0x1dc280]
MOV AL,0x0
CALL 0x001381d0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013eb3a
LAB_0013ea12:
JMP 0x0013ea14
LAB_0013ea14:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00151800
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x0013eb2b
MOV RDI,qword ptr [0x005014c8]
CALL 0x001523b0
CMP RAX,0xc353
JC 0x0013ea6f
LEA RAX,[0x3f0500]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX]
LEA RDI,[0x3f0500]
LEA RDX,[0x1dc25a]
CALL RAX
CMP EAX,0x0
JNZ 0x0013ea6f
JMP 0x0013ea14
LAB_0013ea6f:
MOV RDI,qword ptr [0x005014c8]
CALL 0x001523b0
CMP RAX,0xc547
JC 0x0013eab6
LEA RAX,[0x3f0500]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX]
LEA RDI,[0x3f0500]
LEA RDX,[0x1dc26d]
CALL RAX
CMP EAX,0x0
JNZ 0x0013eab6
JMP 0x0013ea14
LAB_0013eab6:
MOV RDI,qword ptr [0x005014c8]
CALL 0x001523b0
CMP RAX,0x188f8
JC 0x0013eafd
LEA RAX,[0x3f0500]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX]
LEA RDI,[0x3f0500]
LEA RDX,[0x1e3773]
CALL RAX
CMP EAX,0x0
JNZ 0x0013eafd
JMP 0x0013ea14
LAB_0013eafd:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x0013eb50
CMP AL,0x0
JZ 0x0013eb26
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x0013f290
CMP AL,0x0
JZ 0x0013eb24
MOV dword ptr [RBP + -0x1c],0x1
LAB_0013eb24:
JMP 0x0013eb26
LAB_0013eb26:
JMP 0x0013ea14
LAB_0013eb2b:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00148d00
LAB_0013eb34:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
LAB_0013eb3a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 dump_all_databases(void)
{
FILE *__stream;
int8 uVar1;
char cVar2;
int iVar3;
ulong uVar4;
int8 uVar5;
int4 local_24;
long local_20;
int8 *local_18;
int4 local_c;
local_24 = 0;
iVar3 = mysql_query_with_error_report(mysql,&local_20,"SHOW DATABASES");
if (iVar3 == 0) {
while (local_18 = (int8 *)mysql_fetch_row(local_20), local_18 != (int8 *)0x0) {
uVar4 = mysql_get_server_version(mysql);
if ((((uVar4 < 0xc353) ||
(iVar3 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_003f05c0 + 0x40))
(&my_charset_latin1,*local_18,"information_schema"), iVar3 != 0)) &&
((uVar4 = mysql_get_server_version(mysql), uVar4 < 0xc547 ||
(iVar3 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_003f05c0 + 0x40))
(&my_charset_latin1,*local_18,"performance_schema"), iVar3 != 0)))) &&
((((uVar4 = mysql_get_server_version(mysql), uVar4 < 0x188f8 ||
(iVar3 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_003f05c0 + 0x40))
(&my_charset_latin1,*local_18,&DAT_001e3773), iVar3 != 0)) &&
(cVar2 = include_database(*local_18), cVar2 != '\0')) &&
(iVar3 = dump_all_tables_in_db(*local_18), iVar3 != 0)))) {
local_24 = 1;
}
}
mysql_free_result(local_20);
if (seen_views != '\0') {
iVar3 = mysql_query(mysql,"SHOW DATABASES");
if ((iVar3 != 0) || (local_20 = mysql_store_result(mysql), local_20 == 0)) {
uVar1 = my_progname_short;
__stream = *(FILE **)PTR_stderr_00344fe0;
uVar5 = mysql_error(mysql);
fprintf(__stream,"%s: Error: Couldn\'t execute \'SHOW DATABASES\': %s\n",uVar1,uVar5);
return 1;
}
while (local_18 = (int8 *)mysql_fetch_row(local_20), local_18 != (int8 *)0x0) {
uVar4 = mysql_get_server_version(mysql);
if ((((uVar4 < 0xc353) ||
(iVar3 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_003f05c0 + 0x40))
(&my_charset_latin1,*local_18,"information_schema"), iVar3 != 0)) &&
((uVar4 = mysql_get_server_version(mysql), uVar4 < 0xc547 ||
(iVar3 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_003f05c0 + 0x40))
(&my_charset_latin1,*local_18,"performance_schema"), iVar3 != 0))))
&& ((((uVar4 = mysql_get_server_version(mysql), uVar4 < 0x188f8 ||
(iVar3 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_003f05c0 + 0x40))
(&my_charset_latin1,*local_18,&DAT_001e3773), iVar3 != 0)) &&
(cVar2 = include_database(*local_18), cVar2 != '\0')) &&
(cVar2 = dump_all_views_in_db(*local_18), cVar2 != '\0')))) {
local_24 = 1;
}
}
mysql_free_result(local_20);
}
local_c = local_24;
}
else {
local_c = 1;
}
return local_c;
}
| |
24,181 | dump_all_databases | eloqsql/client/mysqldump.c | static int dump_all_databases()
{
MYSQL_ROW row;
MYSQL_RES *tableres;
int result=0;
if (mysql_query_with_error_report(mysql, &tableres, "SHOW DATABASES"))
return 1;
while ((row= mysql_fetch_row(tableres)))
{
if (mysql_get_server_version(mysql) >= FIRST_INFORMATION_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, row[0], INFORMATION_SCHEMA_DB_NAME))
continue;
if (mysql_get_server_version(mysql) >= FIRST_PERFORMANCE_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, row[0], PERFORMANCE_SCHEMA_DB_NAME))
continue;
if (mysql_get_server_version(mysql) >= FIRST_SYS_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, row[0], SYS_SCHEMA_DB_NAME))
continue;
if (include_database(row[0]))
if (dump_all_tables_in_db(row[0]))
result=1;
}
mysql_free_result(tableres);
if (seen_views)
{
if (mysql_query(mysql, "SHOW DATABASES") ||
!(tableres= mysql_store_result(mysql)))
{
fprintf(stderr, "%s: Error: Couldn't execute 'SHOW DATABASES': %s\n",
my_progname_short, mysql_error(mysql));
return 1;
}
while ((row= mysql_fetch_row(tableres)))
{
if (mysql_get_server_version(mysql) >= FIRST_INFORMATION_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, row[0], INFORMATION_SCHEMA_DB_NAME))
continue;
if (mysql_get_server_version(mysql) >= FIRST_PERFORMANCE_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, row[0], PERFORMANCE_SCHEMA_DB_NAME))
continue;
if (mysql_get_server_version(mysql) >= FIRST_SYS_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, row[0], SYS_SCHEMA_DB_NAME))
continue;
if (include_database(row[0]))
if (dump_all_views_in_db(row[0]))
result=1;
}
mysql_free_result(tableres);
}
return result;
} | O3 | c | dump_all_databases:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x387164(%rip), %rdi # 0x3c4498
leaq 0x63f3b(%rip), %rdx # 0xa1276
leaq -0x38(%rbp), %rsi
callq 0x390fd
testl %eax, %eax
jne 0x3d62f
movq -0x38(%rbp), %rdi
callq 0x4a40c
testq %rax, %rax
je 0x3d479
movq %rax, %r13
movl $0x0, -0x2c(%rbp)
leaq 0x336cb1(%rip), %rbx # 0x374020
leaq 0x63f0f(%rip), %r14 # 0xa1285
leaq 0x63f1b(%rip), %r15 # 0xa1298
leaq 0x6b3a6(%rip), %r12 # 0xa872a
movq 0x38710d(%rip), %rdi # 0x3c4498
callq 0x4ab27
cmpq $0xc353, %rax # imm = 0xC353
jb 0x3d3b0
movq 0xc0(%rbx), %rax
movq (%r13), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0x40(%rax)
testl %eax, %eax
je 0x3d408
movq 0x3870e1(%rip), %rdi # 0x3c4498
callq 0x4ab27
cmpq $0xc547, %rax # imm = 0xC547
jb 0x3d3dc
movq 0xc0(%rbx), %rax
movq (%r13), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq *0x40(%rax)
testl %eax, %eax
je 0x3d408
movq 0x3870b5(%rip), %rdi # 0x3c4498
callq 0x4ab27
cmpq $0x188f8, %rax # imm = 0x188F8
jb 0x3d41f
movq 0xc0(%rbx), %rax
movq (%r13), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq *0x40(%rax)
testl %eax, %eax
jne 0x3d41f
movq -0x38(%rbp), %rdi
callq 0x4a40c
movq %rax, %r13
testq %rax, %rax
jne 0x3d384
jmp 0x3d480
movq (%r13), %r15
movq %r15, %rdi
callq 0x37410
leaq 0x38722e(%rip), %rdi # 0x3c4660
movq %r15, %rsi
movq %rax, %rdx
callq 0x65566
testq %rax, %rax
jne 0x3d45b
movq (%r13), %rdi
callq 0x3d63e
testl %eax, %eax
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmovnel %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4a40c
movq %rax, %r13
testq %rax, %rax
leaq 0x63e27(%rip), %r15 # 0xa1298
jne 0x3d384
jmp 0x3d480
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x44fbe
cmpb $0x0, 0x387000(%rip) # 0x3c4490
je 0x3d62f
movq 0x386ffb(%rip), %rdi # 0x3c4498
leaq 0x63dd2(%rip), %rsi # 0xa1276
callq 0x49311
testl %eax, %eax
je 0x3d4ee
movq 0x30bb14(%rip), %rax # 0x348fc8
movq (%rax), %rbx
leaq 0x3926da(%rip), %rax # 0x3cfb98
movq (%rax), %r14
movq 0x386fd0(%rip), %rdi # 0x3c4498
callq 0x4b38a
leaq 0x63dd7(%rip), %rdx # 0xa12ab
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x37260
jmp 0x3d62f
movq 0x386fa3(%rip), %rdi # 0x3c4498
callq 0x4a209
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x3d4ad
movq %rax, %rdi
callq 0x4a40c
testq %rax, %rax
je 0x3d626
movq %rax, %r13
leaq 0x336b02(%rip), %rbx # 0x374020
leaq 0x63d60(%rip), %r14 # 0xa1285
leaq 0x63d6c(%rip), %r15 # 0xa1298
leaq 0x6b1f7(%rip), %r12 # 0xa872a
movq 0x386f5e(%rip), %rdi # 0x3c4498
callq 0x4ab27
cmpq $0xc353, %rax # imm = 0xC353
jb 0x3d55f
movq 0xc0(%rbx), %rax
movq (%r13), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0x40(%rax)
testl %eax, %eax
je 0x3d5b7
movq 0x386f32(%rip), %rdi # 0x3c4498
callq 0x4ab27
cmpq $0xc547, %rax # imm = 0xC547
jb 0x3d58b
movq 0xc0(%rbx), %rax
movq (%r13), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq *0x40(%rax)
testl %eax, %eax
je 0x3d5b7
movq 0x386f06(%rip), %rdi # 0x3c4498
callq 0x4ab27
cmpq $0x188f8, %rax # imm = 0x188F8
jb 0x3d5ce
movq 0xc0(%rbx), %rax
movq (%r13), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq *0x40(%rax)
testl %eax, %eax
jne 0x3d5ce
movq -0x38(%rbp), %rdi
callq 0x4a40c
movq %rax, %r13
testq %rax, %rax
jne 0x3d533
jmp 0x3d626
movq (%r13), %r15
movq %r15, %rdi
callq 0x37410
leaq 0x38707f(%rip), %rdi # 0x3c4660
movq %r15, %rsi
movq %rax, %rdx
callq 0x65566
testq %rax, %rax
jne 0x3d60a
movq (%r13), %rdi
callq 0x3dcc8
testb %al, %al
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmovnel %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4a40c
movq %rax, %r13
testq %rax, %rax
leaq 0x63c78(%rip), %r15 # 0xa1298
jne 0x3d533
movq -0x38(%rbp), %rdi
callq 0x44fbe
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| dump_all_databases:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rdi, cs:mysql
lea rdx, aShowDatabases; "SHOW DATABASES"
lea rsi, [rbp+var_38]
call mysql_query_with_error_report
test eax, eax
jnz loc_3D62F
mov rdi, [rbp+var_38]
call mysql_fetch_row
test rax, rax
jz loc_3D479
mov r13, rax
mov [rbp+var_2C], 0
lea rbx, my_charset_latin1
lea r14, aInformationSch; "information_schema"
lea r15, aPerformanceSch; "performance_schema"
lea r12, aMysys+2; "sys"
loc_3D384:
mov rdi, cs:mysql
call mysql_get_server_version
cmp rax, 0C353h
jb short loc_3D3B0
mov rax, [rbx+0C0h]
mov rsi, [r13+0]
mov rdi, rbx
mov rdx, r14
call qword ptr [rax+40h]
test eax, eax
jz short loc_3D408
loc_3D3B0:
mov rdi, cs:mysql
call mysql_get_server_version
cmp rax, 0C547h
jb short loc_3D3DC
mov rax, [rbx+0C0h]
mov rsi, [r13+0]
mov rdi, rbx
mov rdx, r15
call qword ptr [rax+40h]
test eax, eax
jz short loc_3D408
loc_3D3DC:
mov rdi, cs:mysql
call mysql_get_server_version
cmp rax, 188F8h
jb short loc_3D41F
mov rax, [rbx+0C0h]
mov rsi, [r13+0]
mov rdi, rbx
mov rdx, r12
call qword ptr [rax+40h]
test eax, eax
jnz short loc_3D41F
loc_3D408:
mov rdi, [rbp+var_38]
call mysql_fetch_row
mov r13, rax
test rax, rax
jnz loc_3D384
jmp short loc_3D480
loc_3D41F:
mov r15, [r13+0]
mov rdi, r15
call _strlen
lea rdi, ignore_database
mov rsi, r15
mov rdx, rax
call my_hash_search
test rax, rax
jnz short loc_3D45B
mov rdi, [r13+0]
call dump_all_tables_in_db
test eax, eax
mov eax, [rbp+var_2C]
mov ecx, 1
cmovnz eax, ecx
mov [rbp+var_2C], eax
loc_3D45B:
mov rdi, [rbp+var_38]
call mysql_fetch_row
mov r13, rax
test rax, rax
lea r15, aPerformanceSch; "performance_schema"
jnz loc_3D384
jmp short loc_3D480
loc_3D479:
mov [rbp+var_2C], 0
loc_3D480:
mov rdi, [rbp+var_38]
call mysql_free_result
cmp cs:seen_views, 0
jz loc_3D62F
mov rdi, cs:mysql
lea rsi, aShowDatabases; "SHOW DATABASES"
call mysql_query
test eax, eax
jz short loc_3D4EE
loc_3D4AD:
mov rax, cs:stderr_ptr
mov rbx, [rax]
lea rax, my_progname_short
mov r14, [rax]
mov rdi, cs:mysql
call mysql_error
lea rdx, aSErrorCouldnTE; "%s: Error: Couldn't execute 'SHOW DATAB"...
mov rdi, rbx
mov esi, 1
mov rcx, r14
mov r8, rax
xor eax, eax
call ___fprintf_chk
jmp loc_3D62F
loc_3D4EE:
mov rdi, cs:mysql
call mysql_store_result
mov [rbp+var_38], rax
test rax, rax
jz short loc_3D4AD
mov rdi, rax
call mysql_fetch_row
test rax, rax
jz loc_3D626
mov r13, rax
lea rbx, my_charset_latin1
lea r14, aInformationSch; "information_schema"
lea r15, aPerformanceSch; "performance_schema"
lea r12, aMysys+2; "sys"
loc_3D533:
mov rdi, cs:mysql
call mysql_get_server_version
cmp rax, 0C353h
jb short loc_3D55F
mov rax, [rbx+0C0h]
mov rsi, [r13+0]
mov rdi, rbx
mov rdx, r14
call qword ptr [rax+40h]
test eax, eax
jz short loc_3D5B7
loc_3D55F:
mov rdi, cs:mysql
call mysql_get_server_version
cmp rax, 0C547h
jb short loc_3D58B
mov rax, [rbx+0C0h]
mov rsi, [r13+0]
mov rdi, rbx
mov rdx, r15
call qword ptr [rax+40h]
test eax, eax
jz short loc_3D5B7
loc_3D58B:
mov rdi, cs:mysql
call mysql_get_server_version
cmp rax, 188F8h
jb short loc_3D5CE
mov rax, [rbx+0C0h]
mov rsi, [r13+0]
mov rdi, rbx
mov rdx, r12
call qword ptr [rax+40h]
test eax, eax
jnz short loc_3D5CE
loc_3D5B7:
mov rdi, [rbp+var_38]
call mysql_fetch_row
mov r13, rax
test rax, rax
jnz loc_3D533
jmp short loc_3D626
loc_3D5CE:
mov r15, [r13+0]
mov rdi, r15
call _strlen
lea rdi, ignore_database
mov rsi, r15
mov rdx, rax
call my_hash_search
test rax, rax
jnz short loc_3D60A
mov rdi, [r13+0]
call dump_all_views_in_db
test al, al
mov eax, [rbp+var_2C]
mov ecx, 1
cmovnz eax, ecx
mov [rbp+var_2C], eax
loc_3D60A:
mov rdi, [rbp+var_38]
call mysql_fetch_row
mov r13, rax
test rax, rax
lea r15, aPerformanceSch; "performance_schema"
jnz loc_3D533
loc_3D626:
mov rdi, [rbp+var_38]
call mysql_free_result
loc_3D62F:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long dump_all_databases()
{
long long result; // rax
long long row; // rax
_QWORD *v2; // r13
long long v3; // r15
long long v4; // rax
bool v5; // zf
int v6; // eax
long long v7; // rbx
const char *v8; // r14
const char *v9; // rax
long long v10; // rax
long long v11; // rax
_QWORD *v12; // r13
long long v13; // r15
long long v14; // rax
int v15; // eax
long long v16; // [rsp+8h] [rbp-38h] BYREF
int v17; // [rsp+14h] [rbp-2Ch]
result = mysql_query_with_error_report(mysql, &v16, (long long)"SHOW DATABASES");
if ( !(_DWORD)result )
{
row = mysql_fetch_row(v16);
if ( row )
{
v2 = (_QWORD *)row;
v17 = 0;
do
{
while ( (unsigned long long)mysql_get_server_version(mysql) >= 0xC353
&& !(*(unsigned int ( **)(void *, _QWORD, const char *))(*((_QWORD *)&my_charset_latin1 + 24)
+ 64LL))(
&my_charset_latin1,
*v2,
"information_schema")
|| (unsigned long long)mysql_get_server_version(mysql) >= 0xC547
&& !(*(unsigned int ( **)(void *, _QWORD, const char *))(*((_QWORD *)&my_charset_latin1 + 24)
+ 64LL))(
&my_charset_latin1,
*v2,
"performance_schema")
|| (unsigned long long)mysql_get_server_version(mysql) >= 0x188F8
&& !(*(unsigned int ( **)(void *, _QWORD, char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*v2,
"sys") )
{
v2 = (_QWORD *)mysql_fetch_row(v16);
if ( !v2 )
goto LABEL_19;
}
v3 = *v2;
v4 = strlen(*v2);
if ( !my_hash_search(&ignore_database, v3, v4) )
{
v5 = (unsigned int)dump_all_tables_in_db(*v2) == 0;
v6 = v17;
if ( !v5 )
v6 = 1;
v17 = v6;
}
v2 = (_QWORD *)mysql_fetch_row(v16);
}
while ( v2 );
}
else
{
v17 = 0;
}
LABEL_19:
result = mysql_free_result(v16);
if ( seen_views )
{
if ( (unsigned int)mysql_query(mysql, "SHOW DATABASES") || (v10 = mysql_store_result(mysql), (v16 = v10) == 0) )
{
v7 = stderr;
v8 = my_progname_short;
v9 = (const char *)mysql_error(mysql);
return __fprintf_chk(v7, 1LL, "%s: Error: Couldn't execute 'SHOW DATABASES': %s\n", v8, v9);
}
else
{
v11 = mysql_fetch_row(v10);
if ( v11 )
{
v12 = (_QWORD *)v11;
do
{
while ( (unsigned long long)mysql_get_server_version(mysql) >= 0xC353
&& !(*(unsigned int ( **)(void *, _QWORD, const char *))(*((_QWORD *)&my_charset_latin1 + 24)
+ 64LL))(
&my_charset_latin1,
*v12,
"information_schema")
|| (unsigned long long)mysql_get_server_version(mysql) >= 0xC547
&& !(*(unsigned int ( **)(void *, _QWORD, const char *))(*((_QWORD *)&my_charset_latin1 + 24)
+ 64LL))(
&my_charset_latin1,
*v12,
"performance_schema")
|| (unsigned long long)mysql_get_server_version(mysql) >= 0x188F8
&& !(*(unsigned int ( **)(void *, _QWORD, char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
*v12,
"sys") )
{
v12 = (_QWORD *)mysql_fetch_row(v16);
if ( !v12 )
return mysql_free_result(v16);
}
v13 = *v12;
v14 = strlen(*v12);
if ( !my_hash_search(&ignore_database, v13, v14) )
{
v5 = (unsigned __int8)dump_all_views_in_db(*v12) == 0;
v15 = v17;
if ( !v5 )
v15 = 1;
v17 = v15;
}
v12 = (_QWORD *)mysql_fetch_row(v16);
}
while ( v12 );
}
return mysql_free_result(v16);
}
}
}
return result;
}
| dump_all_databases:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RDI,qword ptr [0x004c4498]
LEA RDX,[0x1a1276]
LEA RSI,[RBP + -0x38]
CALL 0x001390fd
TEST EAX,EAX
JNZ 0x0013d62f
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x0014a40c
TEST RAX,RAX
JZ 0x0013d479
MOV R13,RAX
MOV dword ptr [RBP + -0x2c],0x0
LEA RBX,[0x474020]
LEA R14,[0x1a1285]
LEA R15,[0x1a1298]
LEA R12,[0x1a872a]
LAB_0013d384:
MOV RDI,qword ptr [0x004c4498]
CALL 0x0014ab27
CMP RAX,0xc353
JC 0x0013d3b0
MOV RAX,qword ptr [RBX + 0xc0]
MOV RSI,qword ptr [R13]
MOV RDI,RBX
MOV RDX,R14
CALL qword ptr [RAX + 0x40]
TEST EAX,EAX
JZ 0x0013d408
LAB_0013d3b0:
MOV RDI,qword ptr [0x004c4498]
CALL 0x0014ab27
CMP RAX,0xc547
JC 0x0013d3dc
MOV RAX,qword ptr [RBX + 0xc0]
MOV RSI,qword ptr [R13]
MOV RDI,RBX
MOV RDX,R15
CALL qword ptr [RAX + 0x40]
TEST EAX,EAX
JZ 0x0013d408
LAB_0013d3dc:
MOV RDI,qword ptr [0x004c4498]
CALL 0x0014ab27
CMP RAX,0x188f8
JC 0x0013d41f
MOV RAX,qword ptr [RBX + 0xc0]
MOV RSI,qword ptr [R13]
MOV RDI,RBX
MOV RDX,R12
CALL qword ptr [RAX + 0x40]
TEST EAX,EAX
JNZ 0x0013d41f
LAB_0013d408:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x0014a40c
MOV R13,RAX
TEST RAX,RAX
JNZ 0x0013d384
JMP 0x0013d480
LAB_0013d41f:
MOV R15,qword ptr [R13]
MOV RDI,R15
CALL 0x00137410
LEA RDI,[0x4c4660]
MOV RSI,R15
MOV RDX,RAX
CALL 0x00165566
TEST RAX,RAX
JNZ 0x0013d45b
MOV RDI,qword ptr [R13]
CALL 0x0013d63e
TEST EAX,EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x2c],EAX
LAB_0013d45b:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x0014a40c
MOV R13,RAX
TEST RAX,RAX
LEA R15,[0x1a1298]
JNZ 0x0013d384
JMP 0x0013d480
LAB_0013d479:
MOV dword ptr [RBP + -0x2c],0x0
LAB_0013d480:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00144fbe
CMP byte ptr [0x004c4490],0x0
JZ 0x0013d62f
MOV RDI,qword ptr [0x004c4498]
LEA RSI,[0x1a1276]
CALL 0x00149311
TEST EAX,EAX
JZ 0x0013d4ee
LAB_0013d4ad:
MOV RAX,qword ptr [0x00448fc8]
MOV RBX,qword ptr [RAX]
LEA RAX,[0x4cfb98]
MOV R14,qword ptr [RAX]
MOV RDI,qword ptr [0x004c4498]
CALL 0x0014b38a
LEA RDX,[0x1a12ab]
MOV RDI,RBX
MOV ESI,0x1
MOV RCX,R14
MOV R8,RAX
XOR EAX,EAX
CALL 0x00137260
JMP 0x0013d62f
LAB_0013d4ee:
MOV RDI,qword ptr [0x004c4498]
CALL 0x0014a209
MOV qword ptr [RBP + -0x38],RAX
TEST RAX,RAX
JZ 0x0013d4ad
MOV RDI,RAX
CALL 0x0014a40c
TEST RAX,RAX
JZ 0x0013d626
MOV R13,RAX
LEA RBX,[0x474020]
LEA R14,[0x1a1285]
LEA R15,[0x1a1298]
LEA R12,[0x1a872a]
LAB_0013d533:
MOV RDI,qword ptr [0x004c4498]
CALL 0x0014ab27
CMP RAX,0xc353
JC 0x0013d55f
MOV RAX,qword ptr [RBX + 0xc0]
MOV RSI,qword ptr [R13]
MOV RDI,RBX
MOV RDX,R14
CALL qword ptr [RAX + 0x40]
TEST EAX,EAX
JZ 0x0013d5b7
LAB_0013d55f:
MOV RDI,qword ptr [0x004c4498]
CALL 0x0014ab27
CMP RAX,0xc547
JC 0x0013d58b
MOV RAX,qword ptr [RBX + 0xc0]
MOV RSI,qword ptr [R13]
MOV RDI,RBX
MOV RDX,R15
CALL qword ptr [RAX + 0x40]
TEST EAX,EAX
JZ 0x0013d5b7
LAB_0013d58b:
MOV RDI,qword ptr [0x004c4498]
CALL 0x0014ab27
CMP RAX,0x188f8
JC 0x0013d5ce
MOV RAX,qword ptr [RBX + 0xc0]
MOV RSI,qword ptr [R13]
MOV RDI,RBX
MOV RDX,R12
CALL qword ptr [RAX + 0x40]
TEST EAX,EAX
JNZ 0x0013d5ce
LAB_0013d5b7:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x0014a40c
MOV R13,RAX
TEST RAX,RAX
JNZ 0x0013d533
JMP 0x0013d626
LAB_0013d5ce:
MOV R15,qword ptr [R13]
MOV RDI,R15
CALL 0x00137410
LEA RDI,[0x4c4660]
MOV RSI,R15
MOV RDX,RAX
CALL 0x00165566
TEST RAX,RAX
JNZ 0x0013d60a
MOV RDI,qword ptr [R13]
CALL 0x0013dcc8
TEST AL,AL
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x2c],EAX
LAB_0013d60a:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x0014a40c
MOV R13,RAX
TEST RAX,RAX
LEA R15,[0x1a1298]
JNZ 0x0013d533
LAB_0013d626:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00144fbe
LAB_0013d62f:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void dump_all_databases(void)
{
int8 uVar1;
char *pcVar2;
int8 uVar3;
char cVar4;
int iVar5;
int8 *puVar6;
ulong uVar7;
int8 uVar8;
size_t sVar9;
long lVar10;
long local_40;
int4 local_34;
iVar5 = mysql_query_with_error_report(mysql,&local_40,"SHOW DATABASES");
if (iVar5 == 0) {
puVar6 = (int8 *)mysql_fetch_row(local_40);
if (puVar6 == (int8 *)0x0) {
local_34 = 0;
}
else {
local_34 = 0;
do {
while ((((uVar7 = mysql_get_server_version(mysql), uVar7 < 0xc353 ||
(iVar5 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_004740e0 + 0x40))
(&my_charset_latin1,*puVar6,"information_schema"), iVar5 != 0))
&& ((uVar7 = mysql_get_server_version(mysql), uVar7 < 0xc547 ||
(iVar5 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_004740e0 + 0x40))
(&my_charset_latin1,*puVar6,"performance_schema"), iVar5 != 0
)))) &&
((uVar7 = mysql_get_server_version(mysql), uVar7 < 0x188f8 ||
(iVar5 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_004740e0 + 0x40))
(&my_charset_latin1,*puVar6,&DAT_001a872a), iVar5 != 0))))) {
pcVar2 = (char *)*puVar6;
sVar9 = strlen(pcVar2);
lVar10 = my_hash_search(ignore_database,pcVar2,sVar9);
if ((lVar10 == 0) && (iVar5 = dump_all_tables_in_db(*puVar6), iVar5 != 0)) {
local_34 = 1;
}
puVar6 = (int8 *)mysql_fetch_row(local_40);
if (puVar6 == (int8 *)0x0) goto LAB_0013d480;
}
puVar6 = (int8 *)mysql_fetch_row(local_40);
} while (puVar6 != (int8 *)0x0);
}
LAB_0013d480:
mysql_free_result(local_40);
if (seen_views != '\0') {
iVar5 = mysql_query(mysql,"SHOW DATABASES");
if ((iVar5 == 0) && (local_40 = mysql_store_result(mysql), local_40 != 0)) {
puVar6 = (int8 *)mysql_fetch_row(local_40);
while (puVar6 != (int8 *)0x0) {
while ((((uVar7 = mysql_get_server_version(mysql), 0xc352 < uVar7 &&
(iVar5 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_004740e0 + 0x40))
(&my_charset_latin1,*puVar6,"information_schema"), iVar5 == 0)
) || ((uVar7 = mysql_get_server_version(mysql), 0xc546 < uVar7 &&
(iVar5 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_004740e0 +
0x40))(&my_charset_latin1,*puVar6,"performance_schema"
), iVar5 == 0)))) ||
((uVar7 = mysql_get_server_version(mysql), 0x188f7 < uVar7 &&
(iVar5 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_004740e0 + 0x40))
(&my_charset_latin1,*puVar6,&DAT_001a872a), iVar5 == 0))))) {
puVar6 = (int8 *)mysql_fetch_row(local_40);
if (puVar6 == (int8 *)0x0) goto LAB_0013d626;
}
pcVar2 = (char *)*puVar6;
sVar9 = strlen(pcVar2);
lVar10 = my_hash_search(ignore_database,pcVar2,sVar9);
if ((lVar10 == 0) && (cVar4 = dump_all_views_in_db(*puVar6), cVar4 != '\0')) {
local_34 = 1;
}
puVar6 = (int8 *)mysql_fetch_row(local_40);
}
LAB_0013d626:
mysql_free_result(local_40);
}
else {
uVar3 = my_progname_short;
uVar1 = *(int8 *)PTR_stderr_00448fc8;
uVar8 = mysql_error(mysql);
__fprintf_chk(uVar1,1,"%s: Error: Couldn\'t execute \'SHOW DATABASES\': %s\n",uVar3,uVar8);
}
}
}
return;
}
| |
24,182 | ms3_assume_role | eloqsql/storage/maria/libmarias3/src/marias3.c | uint8_t ms3_assume_role(ms3_st *ms3)
{
uint8_t res = 0;
if (!ms3 || !ms3->iam_role)
{
return MS3_ERR_PARAMETER;
}
if (!strstr(ms3->iam_role_arn, ms3->iam_role))
{
ms3debug("Lookup IAM role ARN");
res = execute_assume_role_request(ms3, MS3_CMD_LIST_ROLE, NULL, 0, NULL);
if(res)
{
return res;
}
}
ms3debug("Assume IAM role");
res = execute_assume_role_request(ms3, MS3_CMD_ASSUME_ROLE, NULL, 0, NULL);
return res;
} | O0 | c | ms3_assume_role:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2c942
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x2c94b
movb $0x1, -0x1(%rbp)
jmp 0x2ca1a
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x27450
cmpq $0x0, %rax
jne 0x2c9c5
jmp 0x2c968
callq 0x2c190
testb $0x1, %al
jne 0x2c973
jmp 0x2c997
movq 0x25a65e(%rip), %rax # 0x286fd8
movq (%rax), %rdi
leaq 0xf11d3(%rip), %rsi # 0x11db57
leaq 0xf1146(%rip), %rdx # 0x11dad1
movl $0x28f, %ecx # imm = 0x28F
movb $0x0, %al
callq 0x271d0
jmp 0x2c999
movq -0x10(%rbp), %rdi
movl $0x7, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x33710
movb %al, -0x11(%rbp)
cmpb $0x0, -0x11(%rbp)
je 0x2c9c3
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x2ca1a
jmp 0x2c9c5
jmp 0x2c9c7
callq 0x2c190
testb $0x1, %al
jne 0x2c9d2
jmp 0x2c9f6
movq 0x25a5ff(%rip), %rax # 0x286fd8
movq (%rax), %rdi
leaq 0xf119c(%rip), %rsi # 0x11db7f
leaq 0xf10e7(%rip), %rdx # 0x11dad1
movl $0x297, %ecx # imm = 0x297
movb $0x0, %al
callq 0x271d0
jmp 0x2c9f8
movq -0x10(%rbp), %rdi
movl $0x8, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x33710
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ms3_assume_role:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_11], 0
cmp [rbp+var_10], 0
jz short loc_2C942
mov rax, [rbp+var_10]
cmp qword ptr [rax+40h], 0
jnz short loc_2C94B
loc_2C942:
mov [rbp+var_1], 1
jmp loc_2CA1A
loc_2C94B:
mov rax, [rbp+var_10]
mov rdi, [rax+60h]
mov rax, [rbp+var_10]
mov rsi, [rax+40h]
call _strstr
cmp rax, 0
jnz short loc_2C9C5
jmp short $+2
loc_2C968:
call ms3debug_get
test al, 1
jnz short loc_2C973
jmp short loc_2C997
loc_2C973:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aLibmarias3SDLo; "[libmarias3] %s:%d Lookup IAM role ARN"...
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 28Fh
mov al, 0
call _fprintf
loc_2C997:
jmp short $+2
loc_2C999:
mov rdi, [rbp+var_10]
mov esi, 7
xor eax, eax
mov r8d, eax
mov rdx, r8
mov rcx, r8
call execute_assume_role_request
mov [rbp+var_11], al
cmp [rbp+var_11], 0
jz short loc_2C9C3
mov al, [rbp+var_11]
mov [rbp+var_1], al
jmp short loc_2CA1A
loc_2C9C3:
jmp short $+2
loc_2C9C5:
jmp short $+2
loc_2C9C7:
call ms3debug_get
test al, 1
jnz short loc_2C9D2
jmp short loc_2C9F6
loc_2C9D2:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aLibmarias3SDAs; "[libmarias3] %s:%d Assume IAM role\n"
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 297h
mov al, 0
call _fprintf
loc_2C9F6:
jmp short $+2
loc_2C9F8:
mov rdi, [rbp+var_10]
mov esi, 8
xor eax, eax
mov r8d, eax
mov rdx, r8
mov rcx, r8
call execute_assume_role_request
mov [rbp+var_11], al
mov al, [rbp+var_11]
mov [rbp+var_1], al
loc_2CA1A:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char ms3_assume_role(long long a1)
{
char v2; // [rsp+Fh] [rbp-11h]
if ( !a1 || !*(_QWORD *)(a1 + 64) )
return 1;
if ( strstr(*(_QWORD *)(a1 + 96), *(_QWORD *)(a1 + 64)) )
goto LABEL_9;
if ( (ms3debug_get() & 1) != 0 )
fprintf(
stderr,
"[libmarias3] %s:%d Lookup IAM role ARN\n",
"/workspace/llm4binary/github2025/eloqsql/storage/maria/libmarias3/src/marias3.c",
655);
v2 = execute_assume_role_request(a1, 7LL, 0LL, 0LL);
if ( v2 )
return v2;
LABEL_9:
if ( (ms3debug_get() & 1) != 0 )
fprintf(
stderr,
"[libmarias3] %s:%d Assume IAM role\n",
"/workspace/llm4binary/github2025/eloqsql/storage/maria/libmarias3/src/marias3.c",
663);
return execute_assume_role_request(a1, 8LL, 0LL, 0LL);
}
| ms3_assume_role:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],0x0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0012c942
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x40],0x0
JNZ 0x0012c94b
LAB_0012c942:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012ca1a
LAB_0012c94b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x60]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x40]
CALL 0x00127450
CMP RAX,0x0
JNZ 0x0012c9c5
JMP 0x0012c968
LAB_0012c968:
CALL 0x0012c190
TEST AL,0x1
JNZ 0x0012c973
JMP 0x0012c997
LAB_0012c973:
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x21db57]
LEA RDX,[0x21dad1]
MOV ECX,0x28f
MOV AL,0x0
CALL 0x001271d0
LAB_0012c997:
JMP 0x0012c999
LAB_0012c999:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x7
XOR EAX,EAX
MOV R8D,EAX
MOV RDX,R8
MOV RCX,R8
CALL 0x00133710
MOV byte ptr [RBP + -0x11],AL
CMP byte ptr [RBP + -0x11],0x0
JZ 0x0012c9c3
MOV AL,byte ptr [RBP + -0x11]
MOV byte ptr [RBP + -0x1],AL
JMP 0x0012ca1a
LAB_0012c9c3:
JMP 0x0012c9c5
LAB_0012c9c5:
JMP 0x0012c9c7
LAB_0012c9c7:
CALL 0x0012c190
TEST AL,0x1
JNZ 0x0012c9d2
JMP 0x0012c9f6
LAB_0012c9d2:
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x21db7f]
LEA RDX,[0x21dad1]
MOV ECX,0x297
MOV AL,0x0
CALL 0x001271d0
LAB_0012c9f6:
JMP 0x0012c9f8
LAB_0012c9f8:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x8
XOR EAX,EAX
MOV R8D,EAX
MOV RDX,R8
MOV RCX,R8
CALL 0x00133710
MOV byte ptr [RBP + -0x11],AL
MOV AL,byte ptr [RBP + -0x11]
MOV byte ptr [RBP + -0x1],AL
LAB_0012ca1a:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
char ms3_assume_role(long param_1)
{
char cVar1;
char *pcVar2;
ulong uVar3;
char local_9;
if ((param_1 == 0) || (*(long *)(param_1 + 0x40) == 0)) {
local_9 = '\x01';
}
else {
pcVar2 = strstr(*(char **)(param_1 + 0x60),*(char **)(param_1 + 0x40));
if (pcVar2 == (char *)0x0) {
uVar3 = ms3debug_get();
if ((uVar3 & 1) != 0) {
fprintf(*(FILE **)PTR_stderr_00386fd8,"[libmarias3] %s:%d Lookup IAM role ARN\n",
"/workspace/llm4binary/github2025/eloqsql/storage/maria/libmarias3/src/marias3.c",
0x28f);
}
cVar1 = execute_assume_role_request(param_1,7,0,0);
if (cVar1 != '\0') {
return cVar1;
}
}
uVar3 = ms3debug_get();
if ((uVar3 & 1) != 0) {
fprintf(*(FILE **)PTR_stderr_00386fd8,"[libmarias3] %s:%d Assume IAM role\n",
"/workspace/llm4binary/github2025/eloqsql/storage/maria/libmarias3/src/marias3.c",
0x297);
}
local_9 = execute_assume_role_request(param_1,8,0,0);
}
return local_9;
}
| |
24,183 | print_name | eloqsql/mysys/my_getopt.c | static uint print_name(const struct my_option *optp)
{
const char *s= optp->name;
for (;*s;s++)
putchar(*s == '_' ? '-' : *s);
return (uint)(s - optp->name);
} | O0 | c | print_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x864a6
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x86486
movl $0x2d, %eax
movl %eax, -0x14(%rbp)
jmp 0x86490
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x29540
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x86467
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| print_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
loc_86467:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jz short loc_864A6
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 5Fh ; '_'
jnz short loc_86486
mov eax, 2Dh ; '-'
mov [rbp+var_14], eax
jmp short loc_86490
loc_86486:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
mov [rbp+var_14], eax
loc_86490:
mov edi, [rbp+var_14]
call _putchar
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_86467
loc_864A6:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
mov rcx, [rcx]
sub rax, rcx
add rsp, 20h
pop rbp
retn
| long long print_name(_BYTE **a1)
{
unsigned int v2; // [rsp+Ch] [rbp-14h]
_BYTE *i; // [rsp+10h] [rbp-10h]
for ( i = *a1; *i; ++i )
{
if ( *i == 95 )
v2 = 45;
else
v2 = (char)*i;
putchar(v2);
}
return i - *a1;
}
| print_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
LAB_00186467:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JZ 0x001864a6
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x5f
JNZ 0x00186486
MOV EAX,0x2d
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00186490
LAB_00186486:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
LAB_00186490:
MOV EDI,dword ptr [RBP + -0x14]
CALL 0x00129540
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00186467
LAB_001864a6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
SUB RAX,RCX
ADD RSP,0x20
POP RBP
RET
|
long print_name(long *param_1)
{
int local_1c;
char *local_18;
for (local_18 = (char *)*param_1; *local_18 != '\0'; local_18 = local_18 + 1) {
if (*local_18 == '_') {
local_1c = 0x2d;
}
else {
local_1c = (int)*local_18;
}
putchar(local_1c);
}
return (long)local_18 - *param_1;
}
| |
24,184 | 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_number() | monkey531[P]llama/common/json.hpp | token_type scan_number() // lgtm [cpp/use-of-goto]
{
// reset token_buffer to store the number's bytes
reset();
// the type of the parsed number; initially set to unsigned; will be
// changed if minus sign, decimal point or exponent is read
token_type number_type = token_type::value_unsigned;
// state (init): we just found out we need to scan a number
switch (current)
{
case '-':
{
add(current);
goto scan_number_minus;
}
case '0':
{
add(current);
goto scan_number_zero;
}
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any1;
}
// all other characters are rejected outside scan_number()
default: // LCOV_EXCL_LINE
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
}
scan_number_minus:
// state: we just parsed a leading minus sign
number_type = token_type::value_integer;
switch (get())
{
case '0':
{
add(current);
goto scan_number_zero;
}
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any1;
}
default:
{
error_message = "invalid number; expected digit after '-'";
return token_type::parse_error;
}
}
scan_number_zero:
// state: we just parse a zero (maybe with a leading minus sign)
switch (get())
{
case '.':
{
add(decimal_point_char);
goto scan_number_decimal1;
}
case 'e':
case 'E':
{
add(current);
goto scan_number_exponent;
}
default:
goto scan_number_done;
}
scan_number_any1:
// state: we just parsed a number 0-9 (maybe with a leading minus sign)
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any1;
}
case '.':
{
add(decimal_point_char);
goto scan_number_decimal1;
}
case 'e':
case 'E':
{
add(current);
goto scan_number_exponent;
}
default:
goto scan_number_done;
}
scan_number_decimal1:
// state: we just parsed a decimal point
number_type = token_type::value_float;
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_decimal2;
}
default:
{
error_message = "invalid number; expected digit after '.'";
return token_type::parse_error;
}
}
scan_number_decimal2:
// we just parsed at least one number after a decimal point
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_decimal2;
}
case 'e':
case 'E':
{
add(current);
goto scan_number_exponent;
}
default:
goto scan_number_done;
}
scan_number_exponent:
// we just parsed an exponent
number_type = token_type::value_float;
switch (get())
{
case '+':
case '-':
{
add(current);
goto scan_number_sign;
}
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any2;
}
default:
{
error_message =
"invalid number; expected '+', '-', or digit after exponent";
return token_type::parse_error;
}
}
scan_number_sign:
// we just parsed an exponent sign
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any2;
}
default:
{
error_message = "invalid number; expected digit after exponent sign";
return token_type::parse_error;
}
}
scan_number_any2:
// we just parsed a number after the exponent or exponent sign
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any2;
}
default:
goto scan_number_done;
}
scan_number_done:
// unget the character after the number (we only read it to know that
// we are done scanning a number)
unget();
char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
errno = 0;
// try to parse integers first and fall back to floats
if (number_type == token_type::value_unsigned)
{
const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
// we checked the number format before
JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
if (errno == 0)
{
value_unsigned = static_cast<number_unsigned_t>(x);
if (value_unsigned == x)
{
return token_type::value_unsigned;
}
}
}
else if (number_type == token_type::value_integer)
{
const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
// we checked the number format before
JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
if (errno == 0)
{
value_integer = static_cast<number_integer_t>(x);
if (value_integer == x)
{
return token_type::value_integer;
}
}
}
// this code is reached if we parse a floating-point number or if an
// integer conversion above failed
strtof(value_float, token_buffer.data(), &endptr);
// we checked the number format before
JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
return token_type::value_float;
} | 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_number():
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x48b98
movl 0x14(%rbx), %eax
leal -0x31(%rax), %ecx
cmpl $0x9, %ecx
jae 0x48912
leaq 0x50(%rbx), %r14
movl $0x5, %ebp
movsbl %al, %esi
movq %r14, %rdi
callq 0x185c0
leaq 0x50(%rbx), %r14
movq %rbx, %rdi
callq 0x19150
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jae 0x48822
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x185c0
jmp 0x48804
cmpl $0x2e, %eax
je 0x48984
cmpl $0x45, %eax
je 0x489e0
cmpl $0x65, %eax
je 0x489e0
movq %rbx, %rdi
callq 0x48b34
movq $0x0, (%rsp)
callq 0x18060
movq %rax, %r14
movl $0x0, (%rax)
movq 0x50(%rbx), %rdi
movq %rsp, %r15
movq %r15, %rsi
movl $0xa, %edx
cmpl $0x5, %ebp
jne 0x48897
callq 0x188f0
movq 0x50(%rbx), %rcx
addq 0x58(%rbx), %rcx
cmpq %rcx, (%r15)
jne 0x48ada
cmpl $0x0, (%r14)
jne 0x488b3
movl $0x5, %ecx
movl $0x80, %edx
jmp 0x48909
callq 0x18100
movq 0x50(%rbx), %rcx
addq 0x58(%rbx), %rcx
cmpq %rcx, (%r15)
jne 0x48af6
cmpl $0x0, (%r14)
je 0x488ff
movq 0x50(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x18570
movsd %xmm0, 0x88(%rbx)
movq 0x50(%rbx), %rax
addq 0x58(%rbx), %rax
movl $0x7, %ecx
cmpq %rax, (%r14)
je 0x48a1a
leaq 0x64b97(%rip), %rdi # 0xad47e
leaq 0x6336b(%rip), %rdx # 0xabc59
leaq 0x65f01(%rip), %rcx # 0xae7f6
movl $0x21d6, %esi # imm = 0x21D6
jmp 0x48b2c
movl $0x6, %ecx
movl $0x78, %edx
movq %rax, (%rbx,%rdx)
jmp 0x48a1a
cmpl $0x30, %eax
je 0x48952
cmpl $0x2d, %eax
jne 0x48b12
leaq 0x50(%rbx), %r14
movq %r14, %rdi
movl $0x2d, %esi
callq 0x185c0
movq %rbx, %rdi
callq 0x19150
leal -0x31(%rax), %ecx
cmpl $0x9, %ecx
jae 0x48ab3
movl 0x14(%rbx), %eax
movl $0x6, %ebp
jmp 0x487f5
leaq 0x50(%rbx), %rdi
movl $0x30, %esi
callq 0x185c0
movl $0x5, %ebp
movq %rbx, %rdi
callq 0x19150
cmpl $0x65, %eax
je 0x489dc
cmpl $0x45, %eax
je 0x489dc
cmpl $0x2e, %eax
jne 0x4883d
leaq 0x50(%rbx), %r14
movsbl 0x90(%rbx), %esi
movq %r14, %rdi
callq 0x185c0
movq %rbx, %rdi
callq 0x19150
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x489d3
leaq 0x50(%rbx), %r14
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x185c0
movq %rbx, %rdi
callq 0x19150
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x489a7
cmpl $0x65, %eax
je 0x489e0
cmpl $0x45, %eax
jne 0x48a67
jmp 0x489e0
leaq 0x65d85(%rip), %rax # 0xae75f
jmp 0x48a11
leaq 0x50(%rbx), %r14
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x185c0
movq %rbx, %rdi
callq 0x19150
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x48a27
cmpl $0x2d, %eax
je 0x48a87
cmpl $0x2b, %eax
je 0x48a87
leaq 0x65d77(%rip), %rax # 0xae788
movq %rax, 0x70(%rbx)
movl $0xe, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x50(%rbx), %r14
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x185c0
movq %rbx, %rdi
callq 0x19150
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x48a67
leaq 0x50(%rbx), %r14
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x185c0
movq %rbx, %rdi
callq 0x19150
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x48a4b
movq %rbx, %rdi
callq 0x48b34
movq $0x0, (%rsp)
callq 0x18060
movl $0x0, (%rax)
jmp 0x488b3
movsbl 0x14(%rbx), %esi
leaq 0x50(%rbx), %r14
movq %r14, %rdi
callq 0x185c0
movq %rbx, %rdi
callq 0x19150
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x48a2b
leaq 0x65d15(%rip), %rax # 0xae7c3
jmp 0x48a11
cmpl $0x30, %eax
je 0x48ac4
leaq 0x65c77(%rip), %rax # 0xae736
jmp 0x48a11
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x185c0
movl $0x6, %ebp
jmp 0x48965
leaq 0x6499d(%rip), %rdi # 0xad47e
leaq 0x63171(%rip), %rdx # 0xabc59
leaq 0x65d07(%rip), %rcx # 0xae7f6
movl $0x21b5, %esi # imm = 0x21B5
jmp 0x48b2c
leaq 0x64981(%rip), %rdi # 0xad47e
leaq 0x63155(%rip), %rdx # 0xabc59
leaq 0x65ceb(%rip), %rcx # 0xae7f6
movl $0x21c5, %esi # imm = 0x21C5
jmp 0x48b2c
leaq 0x64965(%rip), %rdi # 0xad47e
leaq 0x63139(%rip), %rdx # 0xabc59
leaq 0x63190(%rip), %rcx # 0xabcb7
movl $0x20be, %esi # imm = 0x20BE
xorl %eax, %eax
callq 0x18b50
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE11scan_numberEv:
push rbp
push r15
push r14
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_EEEEE5resetEv; 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>>>::reset(void)
mov eax, [rbx+14h]
lea ecx, [rax-31h]
cmp ecx, 9
jnb loc_48912
lea r14, [rbx+50h]
mov ebp, 5
loc_487F5:
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
lea r14, [rbx+50h]
loc_48804:
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-30h]
cmp ecx, 0Ah
jnb short loc_48822
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short loc_48804
loc_48822:
cmp eax, 2Eh ; '.'
jz loc_48984
cmp eax, 45h ; 'E'
jz loc_489E0
cmp eax, 65h ; 'e'
jz loc_489E0
loc_4883D:
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)
mov [rsp+28h+var_28], 0
call ___errno_location
mov r14, rax
mov dword ptr [rax], 0
mov rdi, [rbx+50h]
mov r15, rsp
mov rsi, r15
mov edx, 0Ah
cmp ebp, 5
jnz short loc_48897
call _strtoull
mov rcx, [rbx+50h]
add rcx, [rbx+58h]
cmp [r15], rcx
jnz loc_48ADA
cmp dword ptr [r14], 0
jnz short loc_488B3
mov ecx, 5
mov edx, 80h
jmp short loc_48909
loc_48897:
call _strtoll
mov rcx, [rbx+50h]
add rcx, [rbx+58h]
cmp [r15], rcx
jnz loc_48AF6
cmp dword ptr [r14], 0
jz short loc_488FF
loc_488B3:
mov rdi, [rbx+50h]
mov r14, rsp
mov rsi, r14
call _strtod
movsd qword ptr [rbx+88h], xmm0
mov rax, [rbx+50h]
add rax, [rbx+58h]
mov ecx, 7
cmp [r14], rax
jz loc_48A1A
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aEndptrTokenBuf; "endptr == token_buffer.data() + token_b"...
mov esi, 21D6h
jmp loc_48B2C
loc_488FF:
mov ecx, 6
mov edx, 78h ; 'x'
loc_48909:
mov [rbx+rdx], rax
jmp loc_48A1A
loc_48912:
cmp eax, 30h ; '0'
jz short loc_48952
cmp eax, 2Dh ; '-'
jnz loc_48B12
lea r14, [rbx+50h]
mov rdi, r14
mov esi, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
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-31h]
cmp ecx, 9
jnb loc_48AB3
mov eax, [rbx+14h]
mov ebp, 6
jmp loc_487F5
loc_48952:
lea rdi, [rbx+50h]
mov esi, 30h ; '0'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov ebp, 5
loc_48965:
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, 65h ; 'e'
jz short loc_489DC
cmp eax, 45h ; 'E'
jz short loc_489DC
cmp eax, 2Eh ; '.'
jnz loc_4883D
lea r14, [rbx+50h]
loc_48984:
movsx esi, byte ptr [rbx+90h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
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)
add eax, 0FFFFFFD0h
cmp eax, 9
ja short loc_489D3
lea r14, [rbx+50h]
loc_489A7:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
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-30h]
cmp ecx, 0Ah
jb short loc_489A7
cmp eax, 65h ; 'e'
jz short loc_489E0
cmp eax, 45h ; 'E'
jnz loc_48A67
jmp short loc_489E0
loc_489D3:
lea rax, aInvalidNumberE; "invalid number; expected digit after '."...
jmp short loc_48A11
loc_489DC:
lea r14, [rbx+50h]
loc_489E0:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
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-30h]
cmp ecx, 0Ah
jb short loc_48A27
cmp eax, 2Dh ; '-'
jz loc_48A87
cmp eax, 2Bh ; '+'
jz short loc_48A87
lea rax, aInvalidNumberE_0; "invalid number; expected '+', '-', or d"...
loc_48A11:
mov [rbx+70h], rax
mov ecx, 0Eh
loc_48A1A:
mov eax, ecx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_48A27:
lea r14, [rbx+50h]
loc_48A2B:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
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)
add eax, 0FFFFFFD0h
cmp eax, 9
ja short loc_48A67
lea r14, [rbx+50h]
loc_48A4B:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
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)
add eax, 0FFFFFFD0h
cmp eax, 0Ah
jb short loc_48A4B
loc_48A67:
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)
mov [rsp+28h+var_28], 0
call ___errno_location
mov dword ptr [rax], 0
jmp loc_488B3
loc_48A87:
movsx esi, byte ptr [rbx+14h]
lea r14, [rbx+50h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
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)
add eax, 0FFFFFFD0h
cmp eax, 0Ah
jb short loc_48A2B
lea rax, aInvalidNumberE_1; "invalid number; expected digit after ex"...
jmp loc_48A11
loc_48AB3:
cmp eax, 30h ; '0'
jz short loc_48AC4
lea rax, aInvalidNumberE_2; "invalid number; expected digit after '-"...
jmp loc_48A11
loc_48AC4:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov ebp, 6
jmp loc_48965
loc_48ADA:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aEndptrTokenBuf; "endptr == token_buffer.data() + token_b"...
mov esi, 21B5h
jmp short loc_48B2C
loc_48AF6:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aEndptrTokenBuf; "endptr == token_buffer.data() + token_b"...
mov esi, 21C5h
jmp short loc_48B2C
loc_48B12:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFalse; "false"
mov esi, 20BEh
loc_48B2C:
xor eax, eax
call _ggml_abort
nop
| long long 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_number(
long long a1)
{
long long v1; // rax
int v3; // eax
long long v4; // r14
int v5; // ebp
long long v6; // r14
int v7; // eax
_DWORD *v8; // r14
long long v9; // rdi
long long v10; // rax
unsigned int v11; // ecx
long long v12; // rdx
int v13; // eax
int v14; // eax
int v15; // eax
const char *v16; // rax
int v17; // eax
long long v19; // r14
_QWORD v20[5]; // [rsp+0h] [rbp-28h] BYREF
v20[0] = 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>>>::reset(a1);
v3 = *(_DWORD *)(a1 + 20);
if ( (unsigned int)(v3 - 49) >= 9 )
{
if ( v3 == 48 )
{
std::string::push_back(a1 + 80, 48LL);
v5 = 5;
}
else
{
if ( v3 != 45 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
8382LL,
"GGML_ASSERT(%s) failed",
"false");
return 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("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
v4 = a1 + 80;
std::string::push_back(a1 + 80, 45LL);
v13 = 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((__m128i *)a1);
if ( (unsigned int)(v13 - 49) < 9 )
{
v3 = *(_DWORD *)(a1 + 20);
v5 = 6;
goto LABEL_3;
}
if ( v13 != 48 )
{
v16 = "invalid number; expected digit after '-'";
goto LABEL_40;
}
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
v5 = 6;
}
v14 = 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((__m128i *)a1);
if ( v14 == 101 || v14 == 69 )
{
v6 = a1 + 80;
goto LABEL_36;
}
if ( v14 != 46 )
goto LABEL_9;
v6 = a1 + 80;
LABEL_28:
std::string::push_back(v6, (unsigned int)*(char *)(a1 + 144));
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((__m128i *)a1)
- 48 > 9 )
{
v16 = "invalid number; expected digit after '.'";
LABEL_40:
*(_QWORD *)(a1 + 112) = v16;
return 14;
}
v6 = a1 + 80;
do
{
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
v15 = 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((__m128i *)a1);
}
while ( (unsigned int)(v15 - 48) < 0xA );
if ( v15 != 101 && v15 != 69 )
{
LABEL_45:
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);
v20[0] = 0LL;
*(_DWORD *)__errno_location() = 0;
goto LABEL_15;
}
LABEL_36:
std::string::push_back(v6, (unsigned int)*(char *)(a1 + 20));
v17 = 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((__m128i *)a1);
if ( (unsigned int)(v17 - 48) < 0xA )
{
v19 = a1 + 80;
}
else
{
if ( v17 != 45 && v17 != 43 )
{
v16 = "invalid number; expected '+', '-', or digit after exponent";
goto LABEL_40;
}
v19 = a1 + 80;
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
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((__m128i *)a1)
- 48 >= 0xA )
{
v16 = "invalid number; expected digit after exponent sign";
goto LABEL_40;
}
}
std::string::push_back(v19, (unsigned int)*(char *)(a1 + 20));
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((__m128i *)a1)
- 48 <= 9 )
{
do
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
while ( (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((__m128i *)a1)
- 48 < 0xA );
}
goto LABEL_45;
}
v4 = a1 + 80;
v5 = 5;
LABEL_3:
std::string::push_back(v4, (unsigned int)(char)v3);
v6 = a1 + 80;
while ( 1 )
{
v7 = 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((__m128i *)a1);
if ( (unsigned int)(v7 - 48) >= 0xA )
break;
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
}
if ( v7 == 46 )
goto LABEL_28;
if ( v7 == 69 || v7 == 101 )
goto LABEL_36;
LABEL_9:
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);
v20[0] = 0LL;
v8 = (_DWORD *)__errno_location();
*v8 = 0;
v9 = *(_QWORD *)(a1 + 80);
if ( v5 == 5 )
{
v10 = strtoull(v9, v20, 10LL);
if ( v20[0] != *(_QWORD *)(a1 + 88) + *(_QWORD *)(a1 + 80) )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
8629LL,
"GGML_ASSERT(%s) failed",
"endptr == token_buffer.data() + token_buffer.size()");
return 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("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
if ( !*v8 )
{
v11 = 5;
v12 = 128LL;
LABEL_18:
*(_QWORD *)(a1 + v12) = v10;
return v11;
}
}
else
{
v10 = strtoll(v9, v20, 10LL);
if ( v20[0] != *(_QWORD *)(a1 + 88) + *(_QWORD *)(a1 + 80) )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
8645LL,
"GGML_ASSERT(%s) failed",
"endptr == token_buffer.data() + token_buffer.size()");
return 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("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
if ( !*v8 )
{
v11 = 6;
v12 = 120LL;
goto LABEL_18;
}
}
LABEL_15:
*(double *)(a1 + 136) = strtod(*(_QWORD *)(a1 + 80), v20);
v11 = 7;
if ( v20[0] == *(_QWORD *)(a1 + 88) + *(_QWORD *)(a1 + 80) )
return v11;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
8662LL,
"GGML_ASSERT(%s) failed",
"endptr == token_buffer.data() + token_buffer.size()");
return 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("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
| scan_number:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00148b98
MOV EAX,dword ptr [RBX + 0x14]
LEA ECX,[RAX + -0x31]
CMP ECX,0x9
JNC 0x00148912
LEA R14,[RBX + 0x50]
MOV EBP,0x5
LAB_001487f5:
MOVSX ESI,AL
MOV RDI,R14
CALL 0x001185c0
LEA R14,[RBX + 0x50]
LAB_00148804:
MOV RDI,RBX
CALL 0x00119150
LEA ECX,[RAX + -0x30]
CMP ECX,0xa
JNC 0x00148822
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x001185c0
JMP 0x00148804
LAB_00148822:
CMP EAX,0x2e
JZ 0x00148984
CMP EAX,0x45
JZ 0x001489e0
CMP EAX,0x65
JZ 0x001489e0
LAB_0014883d:
MOV RDI,RBX
CALL 0x00148b34
MOV qword ptr [RSP],0x0
CALL 0x00118060
MOV R14,RAX
MOV dword ptr [RAX],0x0
MOV RDI,qword ptr [RBX + 0x50]
MOV R15,RSP
MOV RSI,R15
MOV EDX,0xa
CMP EBP,0x5
JNZ 0x00148897
CALL 0x001188f0
MOV RCX,qword ptr [RBX + 0x50]
ADD RCX,qword ptr [RBX + 0x58]
CMP qword ptr [R15],RCX
JNZ 0x00148ada
CMP dword ptr [R14],0x0
JNZ 0x001488b3
MOV ECX,0x5
MOV EDX,0x80
JMP 0x00148909
LAB_00148897:
CALL 0x00118100
MOV RCX,qword ptr [RBX + 0x50]
ADD RCX,qword ptr [RBX + 0x58]
CMP qword ptr [R15],RCX
JNZ 0x00148af6
CMP dword ptr [R14],0x0
JZ 0x001488ff
LAB_001488b3:
MOV RDI,qword ptr [RBX + 0x50]
MOV R14,RSP
MOV RSI,R14
CALL 0x00118570
MOVSD qword ptr [RBX + 0x88],XMM0
MOV RAX,qword ptr [RBX + 0x50]
ADD RAX,qword ptr [RBX + 0x58]
MOV ECX,0x7
CMP qword ptr [R14],RAX
JZ 0x00148a1a
LEA RDI,[0x1ad47e]
LEA RDX,[0x1abc59]
LEA RCX,[0x1ae7f6]
MOV ESI,0x21d6
JMP 0x00148b2c
LAB_001488ff:
MOV ECX,0x6
MOV EDX,0x78
LAB_00148909:
MOV qword ptr [RBX + RDX*0x1],RAX
JMP 0x00148a1a
LAB_00148912:
CMP EAX,0x30
JZ 0x00148952
CMP EAX,0x2d
JNZ 0x00148b12
LEA R14,[RBX + 0x50]
MOV RDI,R14
MOV ESI,0x2d
CALL 0x001185c0
MOV RDI,RBX
CALL 0x00119150
LEA ECX,[RAX + -0x31]
CMP ECX,0x9
JNC 0x00148ab3
MOV EAX,dword ptr [RBX + 0x14]
MOV EBP,0x6
JMP 0x001487f5
LAB_00148952:
LEA RDI,[RBX + 0x50]
MOV ESI,0x30
CALL 0x001185c0
MOV EBP,0x5
LAB_00148965:
MOV RDI,RBX
CALL 0x00119150
CMP EAX,0x65
JZ 0x001489dc
CMP EAX,0x45
JZ 0x001489dc
CMP EAX,0x2e
JNZ 0x0014883d
LEA R14,[RBX + 0x50]
LAB_00148984:
MOVSX ESI,byte ptr [RBX + 0x90]
MOV RDI,R14
CALL 0x001185c0
MOV RDI,RBX
CALL 0x00119150
ADD EAX,-0x30
CMP EAX,0x9
JA 0x001489d3
LEA R14,[RBX + 0x50]
LAB_001489a7:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x001185c0
MOV RDI,RBX
CALL 0x00119150
LEA ECX,[RAX + -0x30]
CMP ECX,0xa
JC 0x001489a7
CMP EAX,0x65
JZ 0x001489e0
CMP EAX,0x45
JNZ 0x00148a67
JMP 0x001489e0
LAB_001489d3:
LEA RAX,[0x1ae75f]
JMP 0x00148a11
LAB_001489dc:
LEA R14,[RBX + 0x50]
LAB_001489e0:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x001185c0
MOV RDI,RBX
CALL 0x00119150
LEA ECX,[RAX + -0x30]
CMP ECX,0xa
JC 0x00148a27
CMP EAX,0x2d
JZ 0x00148a87
CMP EAX,0x2b
JZ 0x00148a87
LEA RAX,[0x1ae788]
LAB_00148a11:
MOV qword ptr [RBX + 0x70],RAX
MOV ECX,0xe
LAB_00148a1a:
MOV EAX,ECX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00148a27:
LEA R14,[RBX + 0x50]
LAB_00148a2b:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x001185c0
MOV RDI,RBX
CALL 0x00119150
ADD EAX,-0x30
CMP EAX,0x9
JA 0x00148a67
LEA R14,[RBX + 0x50]
LAB_00148a4b:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x001185c0
MOV RDI,RBX
CALL 0x00119150
ADD EAX,-0x30
CMP EAX,0xa
JC 0x00148a4b
LAB_00148a67:
MOV RDI,RBX
CALL 0x00148b34
MOV qword ptr [RSP],0x0
CALL 0x00118060
MOV dword ptr [RAX],0x0
JMP 0x001488b3
LAB_00148a87:
MOVSX ESI,byte ptr [RBX + 0x14]
LEA R14,[RBX + 0x50]
MOV RDI,R14
CALL 0x001185c0
MOV RDI,RBX
CALL 0x00119150
ADD EAX,-0x30
CMP EAX,0xa
JC 0x00148a2b
LEA RAX,[0x1ae7c3]
JMP 0x00148a11
LAB_00148ab3:
CMP EAX,0x30
JZ 0x00148ac4
LEA RAX,[0x1ae736]
JMP 0x00148a11
LAB_00148ac4:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x001185c0
MOV EBP,0x6
JMP 0x00148965
LAB_00148ada:
LEA RDI,[0x1ad47e]
LEA RDX,[0x1abc59]
LEA RCX,[0x1ae7f6]
MOV ESI,0x21b5
JMP 0x00148b2c
LAB_00148af6:
LEA RDI,[0x1ad47e]
LEA RDX,[0x1abc59]
LEA RCX,[0x1ae7f6]
MOV ESI,0x21c5
JMP 0x00148b2c
LAB_00148b12:
LEA RDI,[0x1ad47e]
LEA RDX,[0x1abc59]
LEA RCX,[0x1abcb7]
MOV ESI,0x20be
LAB_00148b2c:
XOR EAX,EAX
CALL 0x00118b50
|
/* 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_number() */
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_number(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)
{
char cVar1;
int iVar2;
int iVar3;
char *in_RAX;
int *piVar4;
ulonglong uVar5;
int8 uVar6;
char *pcVar7;
long lVar8;
double dVar9;
char *local_28;
local_28 = in_RAX;
reset(this);
iVar3 = *(int *)(this + 0x14);
cVar1 = (char)this;
if (iVar3 - 0x31U < 9) {
iVar3 = 5;
LAB_001487f5:
std::__cxx11::string::push_back(cVar1 + 'P');
while (iVar2 = get(this), iVar2 - 0x30U < 10) {
std::__cxx11::string::push_back(cVar1 + 'P');
}
if (iVar2 == 0x2e) {
LAB_00148984:
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
if (9 < iVar3 - 0x30U) {
pcVar7 = "invalid number; expected digit after \'.\'";
goto LAB_00148a11;
}
do {
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
} while (iVar3 - 0x30U < 10);
if ((iVar3 == 0x65) || (iVar3 == 0x45)) goto LAB_001489e0;
goto LAB_00148a67;
}
if ((iVar2 == 0x45) || (iVar2 == 0x65)) goto LAB_001489e0;
LAB_0014883d:
unget(this);
local_28 = (char *)0x0;
piVar4 = __errno_location();
*piVar4 = 0;
if (iVar3 == 5) {
uVar5 = strtoull(*(char **)(this + 0x50),&local_28,10);
if (local_28 != (char *)(*(long *)(this + 0x50) + *(long *)(this + 0x58))) {
pcVar7 = "endptr == token_buffer.data() + token_buffer.size()";
uVar6 = 0x21b5;
goto LAB_00148b2c;
}
if (*piVar4 == 0) {
uVar6 = 5;
lVar8 = 0x80;
LAB_00148909:
*(ulonglong *)(this + lVar8) = uVar5;
return uVar6;
}
}
else {
uVar5 = strtoll(*(char **)(this + 0x50),&local_28,10);
if (local_28 != (char *)(*(long *)(this + 0x50) + *(long *)(this + 0x58))) {
pcVar7 = "endptr == token_buffer.data() + token_buffer.size()";
uVar6 = 0x21c5;
goto LAB_00148b2c;
}
if (*piVar4 == 0) {
uVar6 = 6;
lVar8 = 0x78;
goto LAB_00148909;
}
}
}
else {
if (iVar3 == 0x30) {
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = 5;
}
else {
if (iVar3 != 0x2d) {
pcVar7 = "false";
uVar6 = 0x20be;
goto LAB_00148b2c;
}
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
if (iVar3 - 0x31U < 9) {
iVar3 = 6;
goto LAB_001487f5;
}
if (iVar3 != 0x30) {
pcVar7 = "invalid number; expected digit after \'-\'";
goto LAB_00148a11;
}
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = 6;
}
iVar2 = get(this);
if ((iVar2 != 0x65) && (iVar2 != 0x45)) {
if (iVar2 != 0x2e) goto LAB_0014883d;
goto LAB_00148984;
}
LAB_001489e0:
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
if (9 < iVar3 - 0x30U) {
if ((iVar3 != 0x2d) && (iVar3 != 0x2b)) {
pcVar7 = "invalid number; expected \'+\', \'-\', or digit after exponent";
LAB_00148a11:
*(char **)(this + 0x70) = pcVar7;
return 0xe;
}
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
if (9 < iVar3 - 0x30U) {
pcVar7 = "invalid number; expected digit after exponent sign";
goto LAB_00148a11;
}
}
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
if (iVar3 - 0x30U < 10) {
do {
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
} while (iVar3 - 0x30U < 10);
}
LAB_00148a67:
unget(this);
local_28 = (char *)0x0;
piVar4 = __errno_location();
*piVar4 = 0;
}
dVar9 = strtod(*(char **)(this + 0x50),&local_28);
*(double *)(this + 0x88) = dVar9;
if (local_28 == (char *)(*(long *)(this + 0x50) + *(long *)(this + 0x58))) {
return 7;
}
pcVar7 = "endptr == token_buffer.data() + token_buffer.size()";
uVar6 = 0x21d6;
LAB_00148b2c:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar7);
}
| |
24,185 | wait_for_readers | eloqsql/storage/maria/ma_pagecache.c | static inline void wait_for_readers(PAGECACHE *pagecache
__attribute__((unused)),
PAGECACHE_BLOCK_LINK *block
__attribute__((unused)))
{
struct st_my_thread_var *thread= my_thread_var;
DBUG_ASSERT(block->condvar == NULL);
while (block->hash_link->requests)
{
DBUG_ENTER("wait_for_readers");
DBUG_PRINT("wait",
("suspend thread: %s %ld block: %u",
thread->name, (ulong) thread->id,
PCBLOCK_NUMBER(pagecache, block)));
block->condvar= &thread->suspend;
pagecache_pthread_cond_wait(&thread->suspend, &pagecache->cache_lock);
block->condvar= NULL;
DBUG_VOID_RETURN;
}
} | O3 | c | wait_for_readers:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa1672
movq 0x20(%rbx), %rcx
cmpl $0x0, 0x68(%rcx)
je 0x34a9b
movq %rax, %rcx
addq $0x8, %rax
movq %rax, 0x28(%rbx)
addq $0xc8, %r14
cmpq $0x0, 0x38(%rcx)
jne 0x34aa0
movq %rax, %rdi
movq %r14, %rsi
callq 0x29430
movq $0x0, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xa4804(%rip), %rdx # 0xd92ab
movq %rax, %rdi
movq %r14, %rsi
movl $0x64d, %ecx # imm = 0x64D
callq 0x2eea0
jmp 0x34a93
| wait_for_readers:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
call _my_thread_var
mov rcx, [rbx+20h]
cmp dword ptr [rcx+68h], 0
jz short loc_34A9B
mov rcx, rax
add rax, 8
mov [rbx+28h], rax
add r14, 0C8h
cmp qword ptr [rcx+38h], 0
jnz short loc_34AA0
mov rdi, rax
mov rsi, r14
call _pthread_cond_wait
loc_34A93:
mov qword ptr [rbx+28h], 0
loc_34A9B:
pop rbx
pop r14
pop rbp
retn
loc_34AA0:
lea rdx, aWorkspaceLlm4b_25; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rax
mov rsi, r14
mov ecx, 64Dh
call psi_cond_wait
jmp short loc_34A93
| long long wait_for_readers(long long a1, long long a2, long long a3, long long a4, long long a5)
{
long long result; // rax
long long v6; // rcx
long long v7; // rax
long long v8; // r14
result = my_thread_var(a1, a2, a3, a4, a5);
if ( *(_DWORD *)(*(_QWORD *)(a2 + 32) + 104LL) )
{
v6 = result;
v7 = result + 8;
*(_QWORD *)(a2 + 40) = v7;
v8 = a1 + 200;
if ( *(_QWORD *)(v6 + 56) )
result = psi_cond_wait(
v7,
v8,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x64Du);
else
result = pthread_cond_wait(v7, v8);
*(_QWORD *)(a2 + 40) = 0LL;
}
return result;
}
| wait_for_readers:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CALL 0x001a1672
MOV RCX,qword ptr [RBX + 0x20]
CMP dword ptr [RCX + 0x68],0x0
JZ 0x00134a9b
MOV RCX,RAX
ADD RAX,0x8
MOV qword ptr [RBX + 0x28],RAX
ADD R14,0xc8
CMP qword ptr [RCX + 0x38],0x0
JNZ 0x00134aa0
MOV RDI,RAX
MOV RSI,R14
CALL 0x00129430
LAB_00134a93:
MOV qword ptr [RBX + 0x28],0x0
LAB_00134a9b:
POP RBX
POP R14
POP RBP
RET
LAB_00134aa0:
LEA RDX,[0x1d92ab]
MOV RDI,RAX
MOV RSI,R14
MOV ECX,0x64d
CALL 0x0012eea0
JMP 0x00134a93
|
void wait_for_readers(long param_1,long param_2)
{
long lVar1;
pthread_cond_t *__cond;
lVar1 = _my_thread_var();
if (*(int *)(*(long *)(param_2 + 0x20) + 0x68) != 0) {
__cond = (pthread_cond_t *)(lVar1 + 8);
*(pthread_cond_t **)(param_2 + 0x28) = __cond;
if (*(long *)(lVar1 + 0x38) == 0) {
pthread_cond_wait(__cond,(pthread_mutex_t *)(param_1 + 200));
}
else {
psi_cond_wait(__cond,(pthread_mutex_t *)(param_1 + 200),
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",0x64d);
}
*(int8 *)(param_2 + 0x28) = 0;
}
return;
}
| |
24,186 | 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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) | monkey531[P]llama/common/json.hpp | void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
{
//not initialized (e.g. due to exception in the ctor)
return;
}
if (t == value_t::array || t == value_t::object)
{
// flatten the current json_value to a heap-allocated stack
std::vector<basic_json> stack;
// move the top-level items to stack
if (t == value_t::array)
{
stack.reserve(array->size());
std::move(array->begin(), array->end(), std::back_inserter(stack));
}
else
{
stack.reserve(object->size());
for (auto&& it : *object)
{
stack.push_back(std::move(it.second));
}
}
while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
stack.pop_back();
// if current_item is array/object, move
// its children to the stack to be processed later
if (current_item.is_array())
{
std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
current_item.m_data.m_value.array->clear();
}
else if (current_item.is_object())
{
for (auto&& it : *current_item.m_data.m_value.object)
{
stack.push_back(std::move(it.second));
}
current_item.m_data.m_value.object->clear();
}
// it's now safe that current_item get destructed
// since it doesn't have any children
}
}
switch (t)
{
case value_t::object:
{
AllocatorType<object_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
break;
}
case value_t::array:
{
AllocatorType<array_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
break;
}
case value_t::string:
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
break;
}
case value_t::binary:
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
break;
}
case value_t::null:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::discarded:
default:
{
break;
}
}
} | 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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, %esi
sete %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x5e2e8
movl %esi, %r14d
testq %rax, %rax
sete %cl
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
testb %cl, %sil
jne 0x5e2e8
movq %rdi, %rbx
leal -0x1(%r14), %ecx
cmpb $0x1, %cl
ja 0x5e263
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x4, %rsi
cmpb $0x2, %r14b
jne 0x5e109
movq %rsp, %rdi
callq 0x5e32c
movq (%rbx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
subq %r15, %r13
sarq $0x4, %r13
testq %r13, %r13
jle 0x5e14a
incq %r13
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5d282
addq $0x10, %r15
decq %r13
cmpq $0x1, %r13
ja 0x5e0ef
jmp 0x5e14a
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rax
movq %rsp, %rdi
movq %rax, %rsi
callq 0x5e32c
movq (%rbx), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x5e14a
movq %rsp, %r15
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x5d282
addq $0x30, %r12
cmpq %r13, %r12
jne 0x5e134
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
je 0x5e25b
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq -0x10(%r13), %rdi
movups -0x10(%r13), %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %esi, %esi
callq 0x586c0
movb $0x0, -0x10(%r13)
movq $0x0, -0x8(%r13)
movq %r15, %rdi
movl $0x1, %esi
callq 0x586c0
movq 0x8(%rsp), %r13
addq $-0x10, %r13
movq %r13, 0x8(%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x586c0
movq %r13, %rdi
callq 0x5dbae
movzbl 0x20(%rsp), %eax
cmpl $0x1, %eax
je 0x5e204
cmpl $0x2, %eax
jne 0x5e23a
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
subq %r13, %rbp
sarq $0x4, %rbp
testq %rbp, %rbp
jle 0x5e1fa
incq %rbp
movq %r12, %rdi
movq %r13, %rsi
callq 0x5d282
addq $0x10, %r13
decq %rbp
cmpq $0x1, %rbp
jg 0x5e1da
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq %r13, %rsi
callq 0x5e412
jmp 0x5e23a
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
cmpq %rbp, %r13
je 0x5e232
leaq 0x20(%r13), %rsi
movq %r12, %rdi
callq 0x5d282
addq $0x30, %r13
cmpq %rbp, %r13
jne 0x5e215
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq %r13, %rsi
callq 0x5e458
movq %r15, %rdi
xorl %esi, %esi
callq 0x586c0
movq %r15, %rdi
callq 0x5dbae
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
jne 0x5e161
movq %rsp, %rdi
callq 0x5e3c0
movzbl %r14b, %eax
decl %eax
cmpl $0x7, %eax
ja 0x5e2e8
leaq 0x887f3(%rip), %rcx # 0xe6a68
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x5e512
jmp 0x5e2a5
movq (%rbx), %rdi
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x5e2a8
movq (%rcx), %rsi
incq %rsi
movq %rax, %rdi
callq 0x1a8d0
movq (%rbx), %rdi
movl $0x20, %esi
jmp 0x5e2e3
movq (%rbx), %rdi
callq 0x5e3c0
movq (%rbx), %rdi
movl $0x18, %esi
jmp 0x5e2e3
movq (%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x5e2de
movq 0x10(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x1a8d0
movq (%rbx), %rdi
movl $0x28, %esi
callq 0x1a8d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5e2fb
jmp 0x5e2fb
movq %rax, %rbx
jmp 0x5e31c
jmp 0x5e302
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x586c0
movq %r14, %rdi
callq 0x5dbae
movq %rsp, %rdi
callq 0x5e3c0
movq %rbx, %rdi
callq 0x1afc0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
cmp esi, 1
setz cl
mov rax, [rdi]
test rax, rax
setz dl
test cl, dl
jnz def_5E27C; jumptable 000000000005E27C default case, cases 4-7
mov r14d, esi
test rax, rax
setz cl
mov edx, r14d
and dl, 0FEh
cmp dl, 2
setz dl
cmp r14b, 8
setz sil
or sil, dl
test sil, cl
jnz def_5E27C; jumptable 000000000005E27C default case, cases 4-7
mov rbx, rdi
lea ecx, [r14-1]
cmp cl, 1
ja loc_5E263
xorps xmm0, xmm0
movaps [rsp+68h+var_68], xmm0
mov [rsp+68h+var_58], 0
mov rsi, [rax+8]
sub rsi, [rax]
sar rsi, 4
cmp r14b, 2
jnz short loc_5E109
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r15, [rax]
mov r13, [rax+8]
sub r13, r15
sar r13, 4
test r13, r13
jle short loc_5E14A
inc r13
mov r12, rsp
loc_5E0EF:
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(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> &&)
add r15, 10h
dec r13
cmp r13, 1
ja short loc_5E0EF
jmp short loc_5E14A
loc_5E109:
mov rax, 0AAAAAAAAAAAAAAABh
imul rax, rsi
mov rdi, rsp
mov rsi, rax
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r12, [rax]
mov r13, [rax+8]
cmp r12, r13
jz short loc_5E14A
mov r15, rsp
loc_5E134:
lea rsi, [r12+20h]
mov rdi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(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> &&)
add r12, 30h ; '0'
cmp r12, r13
jnz short loc_5E134
loc_5E14A:
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jz loc_5E25B
lea r15, [rsp+68h+var_48]
mov r12, rsp
loc_5E161:
lea rdi, [r13-10h]
movups xmm0, xmmword ptr [r13-10h]
movaps [rsp+68h+var_48], xmm0
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 [r13-10h], 0
mov qword ptr [r13-8], 0
mov rdi, r15
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 r13, qword ptr [rsp+68h+var_68+8]
add r13, 0FFFFFFFFFFFFFFF0h
mov qword ptr [rsp+68h+var_68+8], r13
mov rdi, r13
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
movzx eax, byte ptr [rsp+68h+var_48]
cmp eax, 1
jz short loc_5E204
cmp eax, 2
jnz short loc_5E23A
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
mov rbp, [rdi+8]
sub rbp, r13
sar rbp, 4
test rbp, rbp
jle short loc_5E1FA
inc rbp
loc_5E1DA:
mov rdi, r12
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(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> &&)
add r13, 10h
dec rbp
cmp rbp, 1
jg short loc_5E1DA
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
loc_5E1FA:
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE15_M_erase_at_endEPSD_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::_M_erase_at_end(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>*)
jmp short loc_5E23A
loc_5E204:
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
mov rbp, [rdi+8]
cmp r13, rbp
jz short loc_5E232
loc_5E215:
lea rsi, [r13+20h]
mov rdi, r12
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(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> &&)
add r13, 30h ; '0'
cmp r13, rbp
jnz short loc_5E215
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
loc_5E232:
mov rsi, r13
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE15_M_erase_at_endEPSG_; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::_M_erase_at_end(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>*)
loc_5E23A:
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jnz loc_5E161
loc_5E25B:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
loc_5E263:
movzx eax, r14b
dec eax; switch 8 cases
cmp eax, 7
ja short def_5E27C; jumptable 000000000005E27C default case, cases 4-7
lea rcx, jpt_5E27C
movsxd rax, ds:(jpt_5E27C - 0E6A68h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_5E27E:
mov rdi, [rbx]; jumptable 000000000005E27C case 1
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EED2Ev; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::~vector()
jmp short loc_5E2A5
loc_5E288:
mov rdi, [rbx]; jumptable 000000000005E27C case 3
mov rax, [rdi]
lea rcx, [rdi+10h]
cmp rax, rcx
jz short loc_5E2A8
mov rsi, [rcx]
inc rsi; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_5E2A5:
mov rdi, [rbx]
loc_5E2A8:
mov esi, 20h ; ' '
jmp short loc_5E2E3
loc_5E2AF:
mov rdi, [rbx]; jumptable 000000000005E27C case 2
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, [rbx]
mov esi, 18h
jmp short loc_5E2E3
loc_5E2C1:
mov rdi, [rbx]; jumptable 000000000005E27C case 8
mov rax, [rdi]
test rax, rax
jz short loc_5E2DE
mov rsi, [rdi+10h]
sub rsi, rax; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [rbx]; void *
loc_5E2DE:
mov esi, 28h ; '('; unsigned __int64
loc_5E2E3:
call __ZdlPvm; operator delete(void *,ulong)
def_5E27C:
add rsp, 38h; jumptable 000000000005E27C default case, cases 4-7
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_5E2FB
jmp short $+2
loc_5E2FB:
mov rbx, rax
jmp short loc_5E31C
jmp short $+2
loc_5E302:
mov rbx, rax
lea r14, [rsp+arg_18]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_5E31C:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, rbx
call __Unwind_Resume
| void 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>::json_value::destroy(
long long **a1,
int a2)
{
long long *v2; // rax
char v3; // r14
long long v5; // rsi
long long v6; // r15
long long v7; // r13
long long v8; // r13
bool v9; // cf
long long v10; // r12
long long i; // r13
long long j; // r13
char *v13; // r13
long long v14; // rdi
long long v15; // r13
long long v16; // rbp
long long v17; // rbp
long long v18; // rdi
long long v19; // r13
long long v20; // rbp
void **v21; // rdi
_QWORD *v22; // rcx
unsigned long long v23; // rsi
long long v24; // rax
__int128 v25; // [rsp+0h] [rbp-68h] BYREF
long long v26; // [rsp+10h] [rbp-58h]
_OWORD v27[4]; // [rsp+20h] [rbp-48h] BYREF
v2 = *a1;
if ( *a1 != 0LL || a2 != 1 )
{
v3 = a2;
if ( v2 != 0LL || (a2 & 0xFE) != 2 && (_BYTE)a2 != 8 )
{
if ( (unsigned __int8)(a2 - 1) <= 1u )
{
v25 = 0LL;
v26 = 0LL;
v5 = (v2[1] - *v2) >> 4;
if ( v3 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v25,
v5);
v6 = **a1;
v7 = ((*a1)[1] - v6) >> 4;
if ( v7 > 0 )
{
v8 = v7 + 1;
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v25,
v6);
v6 += 16LL;
v9 = v8-- == 1;
}
while ( !v9 && v8 != 1 );
}
}
else
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v25,
0xAAAAAAAAAAAAAAABLL * v5);
v10 = **a1;
for ( i = (*a1)[1]; v10 != i; v10 += 48LL )
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v25,
v10 + 32);
}
for ( j = *((_QWORD *)&v25 + 1); (_QWORD)v25 != *((_QWORD *)&v25 + 1); j = *((_QWORD *)&v25 + 1) )
{
v27[0] = *(_OWORD *)(j - 16);
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 *)(j - 16));
*(_BYTE *)(j - 16) = 0;
*(_QWORD *)(j - 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 *)v27);
v13 = (char *)(*((_QWORD *)&v25 + 1) - 16LL);
*((_QWORD *)&v25 + 1) = v13;
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(v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v13);
if ( LOBYTE(v27[0]) == 1 )
{
v18 = *((_QWORD *)&v27[0] + 1);
v19 = **((_QWORD **)&v27[0] + 1);
v20 = *(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 8LL);
if ( **((_QWORD **)&v27[0] + 1) != v20 )
{
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v25,
v19 + 32);
v19 += 48LL;
}
while ( v19 != v20 );
v18 = *((_QWORD *)&v27[0] + 1);
v19 = **((_QWORD **)&v27[0] + 1);
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::_M_erase_at_end(
v18,
v19);
}
else if ( LOBYTE(v27[0]) == 2 )
{
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
v16 = (long long)(*(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 8LL) - **((_QWORD **)&v27[0] + 1)) >> 4;
if ( v16 > 0 )
{
v17 = v16 + 1;
do
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<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>>(
(long long)&v25,
v15);
v15 += 16LL;
--v17;
}
while ( v17 > 1 );
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::_M_erase_at_end(
v14,
v15);
}
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 *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v27);
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(&v25);
}
switch ( v3 )
{
case 1:
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::~vector(*a1);
goto LABEL_29;
case 2:
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(*a1);
v21 = (void **)*a1;
v23 = 24LL;
goto LABEL_35;
case 3:
v21 = (void **)*a1;
v22 = *a1 + 2;
if ( (_QWORD *)**a1 != v22 )
{
operator delete((void *)**a1, *v22 + 1LL);
LABEL_29:
v21 = (void **)*a1;
}
v23 = 32LL;
goto LABEL_35;
case 8:
v21 = (void **)*a1;
v24 = **a1;
if ( v24 )
{
operator delete((void *)**a1, (unsigned long long)v21[2] - v24);
v21 = (void **)*a1;
}
v23 = 40LL;
LABEL_35:
operator delete(v21, v23);
break;
default:
return;
}
}
}
}
| destroy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
CMP ESI,0x1
SETZ CL
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
SETZ DL
TEST CL,DL
JNZ 0x0015e2e8
MOV R14D,ESI
TEST RAX,RAX
SETZ CL
MOV EDX,R14D
AND DL,0xfe
CMP DL,0x2
SETZ DL
CMP R14B,0x8
SETZ SIL
OR SIL,DL
TEST SIL,CL
JNZ 0x0015e2e8
MOV RBX,RDI
LEA ECX,[R14 + -0x1]
CMP CL,0x1
JA 0x0015e263
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,qword ptr [RAX]
SAR RSI,0x4
CMP R14B,0x2
JNZ 0x0015e109
LAB_0015e0cb:
MOV RDI,RSP
CALL 0x0015e32c
MOV RAX,qword ptr [RBX]
MOV R15,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
SUB R13,R15
SAR R13,0x4
TEST R13,R13
JLE 0x0015e14a
INC R13
MOV R12,RSP
LAB_0015e0ef:
MOV RDI,R12
MOV RSI,R15
CALL 0x0015d282
ADD R15,0x10
DEC R13
CMP R13,0x1
JA 0x0015e0ef
JMP 0x0015e14a
LAB_0015e109:
MOV RAX,-0x5555555555555555
IMUL RAX,RSI
LAB_0015e117:
MOV RDI,RSP
MOV RSI,RAX
CALL 0x0015e32c
MOV RAX,qword ptr [RBX]
MOV R12,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
CMP R12,R13
JZ 0x0015e14a
MOV R15,RSP
LAB_0015e134:
LEA RSI,[R12 + 0x20]
LAB_0015e139:
MOV RDI,R15
CALL 0x0015d282
ADD R12,0x30
CMP R12,R13
JNZ 0x0015e134
LAB_0015e14a:
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JZ 0x0015e25b
LEA R15,[RSP + 0x20]
MOV R12,RSP
LAB_0015e161:
LEA RDI,[R13 + -0x10]
MOVUPS XMM0,xmmword ptr [R13 + -0x10]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
XOR ESI,ESI
CALL 0x001586c0
MOV byte ptr [R13 + -0x10],0x0
MOV qword ptr [R13 + -0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x001586c0
MOV R13,qword ptr [RSP + 0x8]
ADD R13,-0x10
MOV qword ptr [RSP + 0x8],R13
MOV RDI,R13
XOR ESI,ESI
CALL 0x001586c0
MOV RDI,R13
CALL 0x0015dbae
MOVZX EAX,byte ptr [RSP + 0x20]
CMP EAX,0x1
JZ 0x0015e204
CMP EAX,0x2
JNZ 0x0015e23a
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
SUB RBP,R13
SAR RBP,0x4
TEST RBP,RBP
JLE 0x0015e1fa
INC RBP
LAB_0015e1da:
MOV RDI,R12
MOV RSI,R13
CALL 0x0015d282
ADD R13,0x10
DEC RBP
CMP RBP,0x1
JG 0x0015e1da
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
LAB_0015e1fa:
MOV RSI,R13
CALL 0x0015e412
JMP 0x0015e23a
LAB_0015e204:
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
CMP R13,RBP
JZ 0x0015e232
LAB_0015e215:
LEA RSI,[R13 + 0x20]
LAB_0015e219:
MOV RDI,R12
CALL 0x0015d282
LAB_0015e221:
ADD R13,0x30
CMP R13,RBP
JNZ 0x0015e215
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
LAB_0015e232:
MOV RSI,R13
CALL 0x0015e458
LAB_0015e23a:
MOV RDI,R15
XOR ESI,ESI
CALL 0x001586c0
MOV RDI,R15
CALL 0x0015dbae
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JNZ 0x0015e161
LAB_0015e25b:
MOV RDI,RSP
CALL 0x0015e3c0
LAB_0015e263:
MOVZX EAX,R14B
DEC EAX
CMP EAX,0x7
JA 0x0015e2e8
LEA RCX,[0x1e6a68]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBX]
CALL 0x0015e512
JMP 0x0015e2a5
caseD_3:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
LEA RCX,[RDI + 0x10]
CMP RAX,RCX
JZ 0x0015e2a8
MOV RSI,qword ptr [RCX]
INC RSI
MOV RDI,RAX
CALL 0x0011a8d0
LAB_0015e2a5:
MOV RDI,qword ptr [RBX]
LAB_0015e2a8:
MOV ESI,0x20
JMP 0x0015e2e3
caseD_2:
MOV RDI,qword ptr [RBX]
CALL 0x0015e3c0
MOV RDI,qword ptr [RBX]
MOV ESI,0x18
JMP 0x0015e2e3
caseD_8:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0015e2de
MOV RSI,qword ptr [RDI + 0x10]
SUB RSI,RAX
MOV RDI,RAX
CALL 0x0011a8d0
MOV RDI,qword ptr [RBX]
LAB_0015e2de:
MOV ESI,0x28
LAB_0015e2e3:
CALL 0x0011a8d0
caseD_4:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) */
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>
::json_value::destroy(json_value *this,uint param_2)
{
long *plVar1;
long lVar2;
pair *ppVar3;
void *pvVar4;
byte bVar5;
ulong uVar6;
bool bVar7;
int8 *puVar8;
long lVar9;
data *pdVar10;
pair *ppVar11;
basic_json *pbVar12;
data *local_68;
data *pdStack_60;
int8 local_58;
int8 local_48;
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*pvStack_40;
plVar1 = *(long **)this;
if (param_2 == 1 && plVar1 == (long *)0x0) {
return;
}
bVar5 = (byte)param_2;
if ((bVar5 == 8 || (bVar5 & 0xfe) == 2) && plVar1 == (long *)0x0) {
return;
}
if ((byte)(bVar5 - 1) < 2) {
local_68 = (data *)0x0;
pdStack_60 = (data *)0x0;
local_58 = 0;
uVar6 = plVar1[1] - *plVar1 >> 4;
if (bVar5 == 2) {
/* try { // try from 0015e0cb to 0015e0d2 has its CatchHandler @ 0015e2f7 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,uVar6);
pbVar12 = (basic_json *)**(long **)this;
lVar9 = (*(long **)this)[1] - (long)pbVar12 >> 4;
if (0 < lVar9) {
uVar6 = lVar9 + 1;
do {
/* try { // try from 0015e0ef to 0015e0f9 has its CatchHandler @ 0015e2fb */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar12);
pbVar12 = pbVar12 + 0x10;
uVar6 = uVar6 - 1;
} while (1 < uVar6);
}
}
else {
/* try { // try from 0015e117 to 0015e121 has its CatchHandler @ 0015e2f7 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,uVar6 * -0x5555555555555555);
lVar2 = (*(long **)this)[1];
for (lVar9 = **(long **)this; lVar9 != lVar2; lVar9 = lVar9 + 0x30) {
/* try { // try from 0015e139 to 0015e140 has its CatchHandler @ 0015e2f9 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(lVar9 + 0x20));
}
}
if (local_68 != pdStack_60) {
do {
pdVar10 = pdStack_60;
local_48 = *(int8 *)(pdStack_60 + -0x10);
pvStack_40 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pdStack_60 + -8);
assert_invariant((bool)((char)pdStack_60 + -0x10));
pdVar10[-0x10] = (data)0x0;
*(int8 *)(pdVar10 + -8) = 0;
bVar7 = SUB81((data *)&local_48,0);
assert_invariant(bVar7);
pdVar10 = pdStack_60 + -0x10;
pdStack_60 = pdVar10;
assert_invariant(SUB81(pdVar10,0));
data::~data(pdVar10);
if (local_48._0_1_ == (data)0x1) {
ppVar11 = *(pair **)pvStack_40;
ppVar3 = *(pair **)(pvStack_40 + 8);
if (ppVar11 != ppVar3) {
do {
/* try { // try from 0015e219 to 0015e220 has its CatchHandler @ 0015e302 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(ppVar11 + 0x20));
ppVar11 = ppVar11 + 0x30;
} while (ppVar11 != ppVar3);
ppVar11 = *(pair **)pvStack_40;
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::_M_erase_at_end((vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)pvStack_40,ppVar11);
}
else if (local_48._0_1_ == (data)0x2) {
pbVar12 = *(basic_json **)pvStack_40;
lVar9 = *(long *)(pvStack_40 + 8) - (long)pbVar12 >> 4;
if (0 < lVar9) {
lVar9 = lVar9 + 1;
do {
/* try { // try from 0015e1da to 0015e1e4 has its CatchHandler @ 0015e300 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<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>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,pbVar12);
pbVar12 = pbVar12 + 0x10;
lVar9 = lVar9 + -1;
} while (1 < lVar9);
pbVar12 = *(basic_json **)pvStack_40;
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::_M_erase_at_end(pvStack_40,pbVar12);
}
assert_invariant(bVar7);
data::~data((data *)&local_48);
} while (local_68 != pdStack_60);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68);
}
switch(param_2 & 0xff) {
case 1:
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::~vector(*(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)this);
LAB_0015e2a5:
puVar8 = *(int8 **)this;
goto LAB_0015e2a8;
case 2:
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)this);
puVar8 = *(int8 **)this;
uVar6 = 0x18;
break;
case 3:
puVar8 = *(int8 **)this;
if ((long *)*puVar8 != puVar8 + 2) {
operator_delete((long *)*puVar8,puVar8[2] + 1);
goto LAB_0015e2a5;
}
LAB_0015e2a8:
uVar6 = 0x20;
break;
default:
goto switchD_0015e27c_caseD_4;
case 8:
puVar8 = *(int8 **)this;
pvVar4 = (void *)*puVar8;
if (pvVar4 != (void *)0x0) {
operator_delete(pvVar4,puVar8[2] - (long)pvVar4);
puVar8 = *(int8 **)this;
}
uVar6 = 0x28;
}
operator_delete(puVar8,uVar6);
switchD_0015e27c_caseD_4:
return;
}
| |
24,187 | get_cpu_name | tsotchke[P]eshkol/src/core/utils/simd.c | static void get_cpu_name(char* name, size_t size) {
int regs[4];
int i;
// Check if CPU name is supported
int eax = 0x80000000;
int ebx = 0;
int ecx = 0;
int edx = 0;
cpuid(&eax, &ebx, &ecx, &edx);
if (eax < 0x80000004) {
strncpy(name, "Unknown", size);
return;
}
// Get CPU name
for (i = 0; i < 3; i++) {
eax = 0x80000002 + i;
ecx = 0;
cpuidex(&eax, &ecx, &ebx, &edx);
regs[0] = eax;
regs[1] = ebx;
regs[2] = ecx;
regs[3] = edx;
memcpy(name + i * 16, regs, 16);
}
name[48] = '\0';
// Remove leading spaces
char* p = name;
while (*p == ' ') {
p++;
}
if (p != name) {
memmove(name, p, strlen(p) + 1);
}
// Remove trailing spaces
p = name + strlen(name) - 1;
while (p >= name && *p == ' ') {
*p-- = '\0';
}
} | O0 | c | get_cpu_name:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x80000000, -0x28(%rbp) # imm = 0x80000000
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x85b0
cmpl $0x80000004, -0x28(%rbp) # imm = 0x80000004
jae 0x8413
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x5c86(%rip), %rsi # 0xe08f
callq 0x1050
jmp 0x8548
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x8488
movl -0x24(%rbp), %eax
addl $0x80000002, %eax # imm = 0x80000002
movl %eax, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x8550
movl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
shll $0x4, %ecx
movslq %ecx, %rcx
movq -0x20(%rbp), %rdx
movq %rdx, (%rax,%rcx)
movq -0x18(%rbp), %rdx
movq %rdx, 0x8(%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x841a
movq -0x8(%rbp), %rax
movb $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x84b2
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x8498
movq -0x40(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x84e9
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1080
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x1140
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1080
movq %rax, %rcx
movq -0x58(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x59(%rbp)
jb 0x852b
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x8534
jmp 0x8548
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, (%rax)
jmp 0x850c
addq $0x60, %rsp
popq %rbp
retq
nop
| get_cpu_name:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_28], 80000000h
mov [rbp+var_2C], 0
mov [rbp+var_30], 0
mov [rbp+var_34], 0
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_2C]
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_34]
call cpuid
cmp [rbp+var_28], 80000004h
jnb short loc_8413
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
lea rsi, aUnknown; "Unknown"
call _strncpy
jmp loc_8548
loc_8413:
mov [rbp+var_24], 0
loc_841A:
cmp [rbp+var_24], 3
jge short loc_8488
mov eax, [rbp+var_24]
add eax, 80000002h
mov [rbp+var_28], eax
mov [rbp+var_30], 0
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_30]
lea rdx, [rbp+var_2C]
lea rcx, [rbp+var_34]
call cpuidex
mov eax, [rbp+var_28]
mov dword ptr [rbp+var_20], eax
mov eax, [rbp+var_2C]
mov dword ptr [rbp+var_20+4], eax
mov eax, [rbp+var_30]
mov dword ptr [rbp+var_18], eax
mov eax, [rbp+var_34]
mov dword ptr [rbp+var_18+4], eax
mov rax, [rbp+var_8]
mov ecx, [rbp+var_24]
shl ecx, 4
movsxd rcx, ecx
mov rdx, [rbp+var_20]
mov [rax+rcx], rdx
mov rdx, [rbp+var_18]
mov [rax+rcx+8], rdx
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_841A
loc_8488:
mov rax, [rbp+var_8]
mov byte ptr [rax+30h], 0
mov rax, [rbp+var_8]
mov [rbp+var_40], rax
loc_8498:
mov rax, [rbp+var_40]
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
jnz short loc_84B2
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp short loc_8498
loc_84B2:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_8]
jz short loc_84E9
mov rax, [rbp+var_8]
mov [rbp+var_50], rax
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
mov rdi, [rbp+var_40]
call _strlen
mov rdi, [rbp+var_50]
mov rsi, [rbp+var_48]
mov rdx, rax
add rdx, 1
call _memmove
loc_84E9:
mov rax, [rbp+var_8]
mov [rbp+var_58], rax
mov rdi, [rbp+var_8]
call _strlen
mov rcx, rax
mov rax, [rbp+var_58]
add rax, rcx
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_40], rax
loc_850C:
mov rcx, [rbp+var_40]
xor eax, eax
cmp rcx, [rbp+var_8]
mov [rbp+var_59], al
jb short loc_852B
mov rax, [rbp+var_40]
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
setz al
mov [rbp+var_59], al
loc_852B:
mov al, [rbp+var_59]
test al, 1
jnz short loc_8534
jmp short loc_8548
loc_8534:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_40], rcx
mov byte ptr [rax], 0
jmp short loc_850C
loc_8548:
add rsp, 60h
pop rbp
retn
| char get_cpu_name(_BYTE *a1, long long a2)
{
char result; // al
_BYTE *v3; // rax
long long v4; // rcx
long long v5; // rax
_BYTE *v6; // rax
bool v7; // [rsp+7h] [rbp-59h]
_BYTE *v8; // [rsp+8h] [rbp-58h]
_BYTE *v9; // [rsp+10h] [rbp-50h]
_BYTE *j; // [rsp+20h] [rbp-40h]
_BYTE *k; // [rsp+20h] [rbp-40h]
unsigned int v12; // [rsp+2Ch] [rbp-34h] BYREF
unsigned int v13; // [rsp+30h] [rbp-30h] BYREF
unsigned int v14; // [rsp+34h] [rbp-2Ch] BYREF
unsigned int v15; // [rsp+38h] [rbp-28h] BYREF
int i; // [rsp+3Ch] [rbp-24h]
unsigned long long v17; // [rsp+40h] [rbp-20h]
unsigned long long v18; // [rsp+48h] [rbp-18h]
long long v19; // [rsp+50h] [rbp-10h]
_BYTE *v20; // [rsp+58h] [rbp-8h]
v20 = a1;
v19 = a2;
v15 = 0x80000000;
v14 = 0;
v13 = 0;
v12 = 0;
cpuid(&v15, &v14, &v13, &v12);
if ( v15 < 0x80000004 )
return strncpy(v20, "Unknown", v19);
for ( i = 0; i < 3; ++i )
{
v15 = i - 2147483646;
v13 = 0;
cpuidex(&v15, &v13, &v14, &v12);
v17 = __PAIR64__(v14, v15);
v18 = __PAIR64__(v12, v13);
v3 = v20;
v4 = 16 * i;
*(_QWORD *)&v20[v4] = __PAIR64__(v14, v15);
*(_QWORD *)&v3[v4 + 8] = v18;
}
v20[48] = 0;
for ( j = v20; *j == 32; ++j )
;
if ( j != v20 )
{
v9 = v20;
v5 = strlen(j);
memmove(v9, j, v5 + 1);
}
v8 = v20;
for ( k = &v8[strlen(v20) - 1]; ; --k )
{
v7 = 0;
if ( k >= v20 )
v7 = *k == 32;
result = v7;
if ( !v7 )
break;
v6 = k;
*v6 = 0;
}
return result;
}
| get_cpu_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x28],0x80000000
MOV dword ptr [RBP + -0x2c],0x0
MOV dword ptr [RBP + -0x30],0x0
MOV dword ptr [RBP + -0x34],0x0
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x2c]
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x34]
CALL 0x001085b0
CMP dword ptr [RBP + -0x28],0x80000004
JNC 0x00108413
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
LEA RSI,[0x10e055]
CALL 0x00101050
JMP 0x00108548
LAB_00108413:
MOV dword ptr [RBP + -0x24],0x0
LAB_0010841a:
CMP dword ptr [RBP + -0x24],0x3
JGE 0x00108488
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x80000002
MOV dword ptr [RBP + -0x28],EAX
MOV dword ptr [RBP + -0x30],0x0
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x30]
LEA RDX,[RBP + -0x2c]
LEA RCX,[RBP + -0x34]
CALL 0x00108550
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x14],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x24]
SHL ECX,0x4
MOVSXD RCX,ECX
MOV RDX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + RCX*0x1],RDX
MOV RDX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + RCX*0x1 + 0x8],RDX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0010841a
LAB_00108488:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x40],RAX
LAB_00108498:
MOV RAX,qword ptr [RBP + -0x40]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
JNZ 0x001084b2
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00108498
LAB_001084b2:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x8]
JZ 0x001084e9
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00101080
MOV RDI,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,RAX
ADD RDX,0x1
CALL 0x00101140
LAB_001084e9:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00101080
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RCX
ADD RAX,-0x1
MOV qword ptr [RBP + -0x40],RAX
LAB_0010850c:
MOV RCX,qword ptr [RBP + -0x40]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x8]
MOV byte ptr [RBP + -0x59],AL
JC 0x0010852b
MOV RAX,qword ptr [RBP + -0x40]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
SETZ AL
MOV byte ptr [RBP + -0x59],AL
LAB_0010852b:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x00108534
JMP 0x00108548
LAB_00108534:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RBP + -0x40],RCX
MOV byte ptr [RAX],0x0
JMP 0x0010850c
LAB_00108548:
ADD RSP,0x60
POP RBP
RET
|
void get_cpu_name(char *param_1,size_t param_2)
{
char *__dest;
size_t sVar1;
bool bVar2;
char *local_48;
int4 local_3c;
int4 local_38;
int4 local_34;
uint local_30;
int local_2c;
uint local_28;
int4 uStack_24;
int4 local_20;
int4 uStack_1c;
size_t local_18;
char *local_10;
local_30 = 0x80000000;
local_34 = 0;
local_38 = 0;
local_3c = 0;
local_18 = param_2;
local_10 = param_1;
cpuid(&local_30,&local_34,&local_38,&local_3c);
if (local_30 < 0x80000004) {
strncpy(local_10,"Unknown",local_18);
}
else {
for (local_2c = 0; __dest = local_10, local_2c < 3; local_2c = local_2c + 1) {
local_30 = local_2c + 0x80000002;
local_38 = 0;
cpuidex(&local_30,&local_38,&local_34,&local_3c);
local_28 = local_30;
uStack_24 = local_34;
local_20 = local_38;
uStack_1c = local_3c;
*(ulong *)(local_10 + (local_2c << 4)) = CONCAT44(local_34,local_30);
*(ulong *)(local_10 + (long)(local_2c << 4) + 8) = CONCAT44(local_3c,local_38);
}
local_10[0x30] = '\0';
for (local_48 = local_10; *local_48 == ' '; local_48 = local_48 + 1) {
}
if (local_48 != local_10) {
sVar1 = strlen(local_48);
memmove(__dest,local_48,sVar1 + 1);
}
local_48 = local_10;
sVar1 = strlen(local_10);
local_48 = local_48 + sVar1;
while( true ) {
local_48 = local_48 + -1;
bVar2 = false;
if (local_10 <= local_48) {
bVar2 = *local_48 == ' ';
}
if (!bVar2) break;
*local_48 = '\0';
}
}
return;
}
| |
24,188 | LefDefParser::defiFill::setLayer(char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiFill.cpp | void defiFill::setLayer(const char* name) {
int len = strlen(name) + 1;
if (layerNameLength_ < len) {
if (layerName_) free(layerName_);
layerName_ = (char*)malloc(len);
layerNameLength_ = len;
}
strcpy(layerName_, defData->DEFCASE(name));
hasLayer_ = 1;
} | O0 | cpp | LefDefParser::defiFill::setLayer(char const*):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x70e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq $0x1, %rcx
movl %ecx, 0x14(%rsp)
movl 0x10(%rax), %eax
cmpl 0x14(%rsp), %eax
jge 0x42ee2
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x42ec5
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x72a0
movslq 0x14(%rsp), %rdi
callq 0x72d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x14(%rsp), %ecx
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%rsp)
movq 0x80(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x250b0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x7220
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
| _ZN12LefDefParser8defiFill8setLayerEPKc:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_20], rax
mov rdi, [rsp+28h+var_10]
call _strlen
mov rcx, rax
mov rax, [rsp+28h+var_20]
add rcx, 1
mov [rsp+28h+var_14], ecx
mov eax, [rax+10h]
cmp eax, [rsp+28h+var_14]
jge short loc_42EE2
mov rax, [rsp+28h+var_20]
cmp qword ptr [rax+8], 0
jz short loc_42EC5
mov rax, [rsp+28h+var_20]
mov rdi, [rax+8]
call _free
loc_42EC5:
movsxd rdi, [rsp+28h+var_14]
call _malloc
mov rcx, rax
mov rax, [rsp+28h+var_20]
mov [rax+8], rcx
mov ecx, [rsp+28h+var_14]
mov [rax+10h], ecx
loc_42EE2:
mov rax, [rsp+28h+var_20]
mov rcx, [rax+8]
mov [rsp+28h+var_28], rcx
mov rdi, [rax+80h]; this
mov rsi, [rsp+28h+var_10]; char *
call _ZN12LefDefParser8defrData7DEFCASEEPKc; LefDefParser::defrData::DEFCASE(char const*)
mov rdi, [rsp+28h+var_28]
mov rsi, rax
call _strcpy
mov rax, [rsp+28h+var_20]
mov dword ptr [rax], 1
add rsp, 28h
retn
| LefDefParser::defiFill * LefDefParser::defiFill::setLayer(LefDefParser::defiFill *this, const char *a2)
{
const char *v2; // rax
LefDefParser::defiFill *result; // rax
long long v4; // [rsp+0h] [rbp-28h]
int v5; // [rsp+14h] [rbp-14h]
v5 = strlen(a2) + 1;
if ( *((_DWORD *)this + 4) < v5 )
{
if ( *((_QWORD *)this + 1) )
free(*((_QWORD *)this + 1));
*((_QWORD *)this + 1) = malloc(v5);
*((_DWORD *)this + 4) = v5;
}
v4 = *((_QWORD *)this + 1);
v2 = LefDefParser::defrData::DEFCASE(*((LefDefParser::defrData **)this + 16), a2);
strcpy(v4, v2);
result = this;
*(_DWORD *)this = 1;
return result;
}
| setLayer:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001070e0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
ADD RCX,0x1
MOV dword ptr [RSP + 0x14],ECX
MOV EAX,dword ptr [RAX + 0x10]
CMP EAX,dword ptr [RSP + 0x14]
JGE 0x00142ee2
MOV RAX,qword ptr [RSP + 0x8]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x00142ec5
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001072a0
LAB_00142ec5:
MOVSXD RDI,dword ptr [RSP + 0x14]
CALL 0x001072d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RSP + 0x14]
MOV dword ptr [RAX + 0x10],ECX
LAB_00142ee2:
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP],RCX
MOV RDI,qword ptr [RAX + 0x80]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x001250b0
MOV RDI,qword ptr [RSP]
MOV RSI,RAX
CALL 0x00107220
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX],0x1
ADD RSP,0x28
RET
|
/* LefDefParser::defiFill::setLayer(char const*) */
void __thiscall LefDefParser::defiFill::setLayer(defiFill *this,char *param_1)
{
char *__dest;
size_t sVar1;
void *pvVar2;
char *__src;
int iVar3;
sVar1 = strlen(param_1);
iVar3 = (int)sVar1 + 1;
if (*(int *)(this + 0x10) < iVar3) {
if (*(long *)(this + 8) != 0) {
free(*(void **)(this + 8));
}
pvVar2 = malloc((long)iVar3);
*(void **)(this + 8) = pvVar2;
*(int *)(this + 0x10) = iVar3;
}
__dest = *(char **)(this + 8);
__src = (char *)defrData::DEFCASE(*(defrData **)(this + 0x80),param_1);
strcpy(__dest,__src);
*(int4 *)this = 1;
return;
}
| |
24,189 | evmone::(anonymous namespace)::get_section_missing_error(unsigned char) | corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/lib/evmone/eof.cpp | EOFValidationError get_section_missing_error(uint8_t section_id) noexcept
{
switch (section_id)
{
case TERMINATOR:
return EOFValidationError::header_terminator_missing;
case TYPE_SECTION:
return EOFValidationError::type_section_missing;
case CODE_SECTION:
return EOFValidationError::code_section_missing;
case DATA_SECTION:
return EOFValidationError::data_section_missing;
default:
intx::unreachable();
}
} | O0 | cpp | evmone::(anonymous namespace)::get_section_missing_error(unsigned char):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x774eb
jmp 0x774cb
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x774f4
jmp 0x774d5
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x774fd
jmp 0x774df
movl -0xc(%rbp), %eax
subl $0xff, %eax
je 0x77506
jmp 0x7750f
movl $0x5, -0x4(%rbp)
jmp 0x77514
movl $0x6, -0x4(%rbp)
jmp 0x77514
movl $0x7, -0x4(%rbp)
jmp 0x77514
movl $0x8, -0x4(%rbp)
jmp 0x77514
callq 0x7b440
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN6evmone12_GLOBAL__N_125get_section_missing_errorEh:
push rbp
mov rbp, rsp
sub rsp, 10h
mov al, dil
mov [rbp+var_5], al
movzx eax, [rbp+var_5]
mov [rbp+var_C], eax
test eax, eax
jz short loc_774EB
jmp short $+2
loc_774CB:
mov eax, [rbp+var_C]
sub eax, 1
jz short loc_774F4
jmp short $+2
loc_774D5:
mov eax, [rbp+var_C]
sub eax, 2
jz short loc_774FD
jmp short $+2
loc_774DF:
mov eax, [rbp+var_C]
sub eax, 0FFh
jz short loc_77506
jmp short loc_7750F
loc_774EB:
mov [rbp+var_4], 5
jmp short loc_77514
loc_774F4:
mov [rbp+var_4], 6
jmp short loc_77514
loc_774FD:
mov [rbp+var_4], 7
jmp short loc_77514
loc_77506:
mov [rbp+var_4], 8
jmp short loc_77514
loc_7750F:
call _ZN4intx11unreachableEv; intx::unreachable(void)
loc_77514:
mov eax, [rbp+var_4]
add rsp, 10h
pop rbp
retn
| long long evmone::`anonymous namespace'::get_section_missing_error(evmone::_anonymous_namespace_ *this)
{
unsigned int v2; // [rsp+Ch] [rbp-4h]
if ( (_BYTE)this )
{
switch ( (unsigned __int8)this )
{
case 1u:
return 6;
case 2u:
return 7;
case 0xFFu:
return 8;
default:
intx::unreachable(this);
break;
}
}
else
{
return 5;
}
return v2;
}
| get_section_missing_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV AL,DIL
MOV byte ptr [RBP + -0x5],AL
MOVZX EAX,byte ptr [RBP + -0x5]
MOV dword ptr [RBP + -0xc],EAX
TEST EAX,EAX
JZ 0x001774eb
JMP 0x001774cb
LAB_001774cb:
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1
JZ 0x001774f4
JMP 0x001774d5
LAB_001774d5:
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x2
JZ 0x001774fd
JMP 0x001774df
LAB_001774df:
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0xff
JZ 0x00177506
JMP 0x0017750f
LAB_001774eb:
MOV dword ptr [RBP + -0x4],0x5
JMP 0x00177514
LAB_001774f4:
MOV dword ptr [RBP + -0x4],0x6
JMP 0x00177514
LAB_001774fd:
MOV dword ptr [RBP + -0x4],0x7
JMP 0x00177514
LAB_00177506:
MOV dword ptr [RBP + -0x4],0x8
JMP 0x00177514
LAB_0017750f:
CALL 0x0017b440
LAB_00177514:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x10
POP RBP
RET
|
/* evmone::(anonymous namespace)::get_section_missing_error(unsigned char) */
int4 evmone::(anonymous_namespace)::get_section_missing_error(uchar param_1)
{
int4 local_c;
if (param_1 == '\0') {
local_c = 5;
}
else if (param_1 == '\x01') {
local_c = 6;
}
else if (param_1 == '\x02') {
local_c = 7;
}
else if (param_1 == 0xff) {
local_c = 8;
}
else {
intx::unreachable();
}
return local_c;
}
| |
24,190 | my_uca_implicit_weight_put | eloqsql/strings/ctype-uca.c | static inline void
my_uca_implicit_weight_put(uint16 *to, my_wc_t code, uint level)
{
switch (level) {
case 1: to[0]= 0x0020; to[1]= 0; break; /* Secondary level */
case 2: to[0]= 0x0002; to[1]= 0; break; /* Tertiary level */
case 3: to[0]= 0x0001; to[1]= 0; break; /* Quaternary level */
default:
DBUG_ASSERT(0);
case 0:
break;
}
/* Primary level */
to[0]= (uint16)(code >> 15) + my_uca_implicit_weight_base(code);
to[1]= (code & 0x7FFF) | 0x8000;
to[2]= 0;
} | O0 | c | my_uca_implicit_weight_put:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x5c003
movq -0x20(%rbp), %rax
leaq 0xf20b1(%rip), %rcx # 0x14e06c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movw $0x20, (%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x2(%rax)
jmp 0x5c00b
movq -0x8(%rbp), %rax
movw $0x2, (%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x2(%rax)
jmp 0x5c00b
movq -0x8(%rbp), %rax
movw $0x1, (%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x2(%rax)
jmp 0x5c00b
jmp 0x5c005
jmp 0x5c007
jmp 0x5c009
jmp 0x5c00b
movq -0x10(%rbp), %rax
shrq $0xf, %rax
movzwl %ax, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5c070
movw %ax, %cx
movl -0x24(%rbp), %eax
movzwl %cx, %ecx
addl %ecx, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
andq $0x7fff, %rax # imm = 0x7FFF
orq $0x8000, %rax # imm = 0x8000
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_uca_implicit_weight_put:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov eax, [rbp+var_14]
mov [rbp+var_20], rax
sub rax, 3; switch 4 cases
ja short def_5BFC2; jumptable 000000000005BFC2 default case
mov rax, [rbp+var_20]
lea rcx, jpt_5BFC2
movsxd rax, ds:(jpt_5BFC2 - 14E06Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_5BFC4:
mov rax, [rbp+var_8]; jumptable 000000000005BFC2 case 1
mov word ptr [rax], 20h ; ' '
mov rax, [rbp+var_8]
mov word ptr [rax+2], 0
jmp short loc_5C00B
loc_5BFD9:
mov rax, [rbp+var_8]; jumptable 000000000005BFC2 case 2
mov word ptr [rax], 2
mov rax, [rbp+var_8]
mov word ptr [rax+2], 0
jmp short loc_5C00B
loc_5BFEE:
mov rax, [rbp+var_8]; jumptable 000000000005BFC2 case 3
mov word ptr [rax], 1
mov rax, [rbp+var_8]
mov word ptr [rax+2], 0
jmp short loc_5C00B
def_5BFC2:
jmp short $+2; jumptable 000000000005BFC2 default case
loc_5C005:
jmp short $+2
loc_5C007:
jmp short $+2; jumptable 000000000005BFC2 case 0
loc_5C009:
jmp short $+2; jumptable 000000000005BFC2 case 0
loc_5C00B:
mov rax, [rbp+var_10]
shr rax, 0Fh
movzx eax, ax
mov [rbp+var_24], eax
mov rdi, [rbp+var_10]
call my_uca_implicit_weight_base
mov cx, ax
mov eax, [rbp+var_24]
movzx ecx, cx
add eax, ecx
mov cx, ax
mov rax, [rbp+var_8]
mov [rax], cx
mov rax, [rbp+var_10]
and rax, 7FFFh
or rax, 8000h
mov cx, ax
mov rax, [rbp+var_8]
mov [rax+2], cx
mov rax, [rbp+var_8]
mov word ptr [rax+4], 0
add rsp, 30h
pop rbp
retn
| _WORD * my_uca_implicit_weight_put(_WORD *a1, unsigned long long a2, int a3)
{
_WORD *result; // rax
switch ( a3 )
{
case 1:
*a1 = 32;
a1[1] = 0;
break;
case 2:
*a1 = 2;
a1[1] = 0;
break;
case 3:
*a1 = 1;
a1[1] = 0;
break;
default:
break;
}
*a1 = my_uca_implicit_weight_base(a2) + (a2 >> 15);
a1[1] = a2 & 0x7FFF | 0x8000;
result = a1;
a1[2] = 0;
return result;
}
| my_uca_implicit_weight_put:
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 EAX,dword ptr [RBP + -0x14]
MOV qword ptr [RBP + -0x20],RAX
SUB RAX,0x3
JA 0x0015c003
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x24e06c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX],0x20
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x2],0x0
JMP 0x0015c00b
caseD_2:
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX],0x2
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x2],0x0
JMP 0x0015c00b
caseD_3:
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x2],0x0
JMP 0x0015c00b
LAB_0015c003:
JMP 0x0015c005
LAB_0015c005:
JMP 0x0015c007
LAB_0015c007:
JMP 0x0015c009
caseD_0:
JMP 0x0015c00b
LAB_0015c00b:
MOV RAX,qword ptr [RBP + -0x10]
SHR RAX,0xf
MOVZX EAX,AX
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0015c070
MOV CX,AX
MOV EAX,dword ptr [RBP + -0x24]
MOVZX ECX,CX
ADD EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x7fff
OR RAX,0x8000
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x2],CX
MOV RAX,qword ptr [RBP + -0x8]
MOV word ptr [RAX + 0x4],0x0
ADD RSP,0x30
POP RBP
RET
|
void my_uca_implicit_weight_put(short *param_1,ulong param_2,int4 param_3)
{
short sVar1;
switch(param_3) {
default:
break;
case 1:
*param_1 = 0x20;
param_1[1] = 0;
break;
case 2:
*param_1 = 2;
param_1[1] = 0;
break;
case 3:
*param_1 = 1;
param_1[1] = 0;
}
sVar1 = my_uca_implicit_weight_base(param_2);
*param_1 = (short)(param_2 >> 0xf) + sVar1;
param_1[1] = (ushort)param_2 & 0x7fff | 0x8000;
param_1[2] = 0;
return;
}
| |
24,191 | my_mb_wc_utf8mb4_quick | eloqsql/strings/ctype-utf8.h | static inline int
my_mb_wc_utf8mb4_quick(my_wc_t *pwc, const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0x80)
{
*pwc= c;
return 1;
}
else if (c < 0xc2)
return MY_CS_ILSEQ;
else if (c < 0xe0)
{
if (s + 2 > e) /* We need 2 characters */
return MY_CS_TOOSMALL2;
if (!(IS_CONTINUATION_BYTE(s[1])))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
else if (c < 0xf0)
{
if (s + 3 > e) /* We need 3 characters */
return MY_CS_TOOSMALL3;
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
else if (c < 0xf5)
{
if (s + 4 > e) /* We need 4 characters */
return MY_CS_TOOSMALL4;
if (!IS_UTF8MB4_STEP2(c, s[1], s[2], s[3]))
return MY_CS_ILSEQ;
*pwc= UTF8MB4_CODE(c, s[1], s[2], s[3]);
return 4;
}
return MY_CS_ILSEQ;
} | O3 | c | my_mb_wc_utf8mb4_quick:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rdx, %rsi
jae 0x5a5b8
movzbl (%rsi), %ecx
testb %cl, %cl
js 0x5a5b1
movl $0x1, %eax
movq %rcx, (%rdi)
jmp 0x5a5b8
cmpb $-0x3e, %cl
jae 0x5a5ba
xorl %eax, %eax
popq %rbp
retq
cmpb $-0x21, %cl
ja 0x5a5f0
leaq 0x2(%rsi), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rdx, %r8
ja 0x5a5b8
movzbl 0x1(%rsi), %edx
xorl $0x80, %edx
movl $0x0, %eax
cmpb $0x3f, %dl
ja 0x5a5b8
andl $0x1f, %ecx
shll $0x6, %ecx
orl %edx, %ecx
movl $0x2, %eax
jmp 0x5a5ac
cmpb $-0x11, %cl
ja 0x5a652
leaq 0x3(%rsi), %r8
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rdx, %r8
ja 0x5a5b8
movzbl 0x1(%rsi), %edx
cmpb $-0x41, %dl
jg 0x5a5b6
movzbl 0x2(%rsi), %esi
cmpb $-0x41, %sil
jg 0x5a5b6
cmpl $0xe0, %ecx
sete %r8b
cmpb $-0x60, %dl
setb %r9b
movl $0x0, %eax
testb %r9b, %r8b
jne 0x5a5b8
shll $0xc, %ecx
movzwl %cx, %eax
andl $0x3f, %edx
shll $0x6, %edx
orl %eax, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x3, %eax
movq %rsi, %rcx
jmp 0x5a5ac
cmpb $-0xc, %cl
ja 0x5a5b6
leaq 0x4(%rsi), %r8
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rdx, %r8
ja 0x5a5b8
movzbl 0x1(%rsi), %r8d
cmpb $-0x41, %r8b
jg 0x5a5b6
movzbl 0x2(%rsi), %edx
cmpb $-0x41, %dl
jg 0x5a5b6
movzbl 0x3(%rsi), %esi
cmpb $-0x41, %sil
jg 0x5a5b6
cmpl $0xf0, %ecx
sete %al
cmpb $-0x70, %r8b
setb %r9b
testb %r9b, %al
jne 0x5a5b6
cmpl $0xf4, %ecx
sete %r9b
cmpb $-0x70, %r8b
setae %r10b
movl $0x0, %eax
testb %r10b, %r9b
jne 0x5a5b8
andl $0x7, %ecx
shll $0x12, %ecx
andl $0x3f, %r8d
shll $0xc, %r8d
orl %ecx, %r8d
andl $0x3f, %edx
shll $0x6, %edx
orl %r8d, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x4, %eax
jmp 0x5a64a
| my_mb_wc_utf8mb4_quick_0:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rsi, rdx
jnb short loc_5A5B8
movzx ecx, byte ptr [rsi]
test cl, cl
js short loc_5A5B1
mov eax, 1
loc_5A5AC:
mov [rdi], rcx
jmp short loc_5A5B8
loc_5A5B1:
cmp cl, 0C2h
jnb short loc_5A5BA
loc_5A5B6:
xor eax, eax
loc_5A5B8:
pop rbp
retn
loc_5A5BA:
cmp cl, 0DFh
ja short loc_5A5F0
lea r8, [rsi+2]
mov eax, 0FFFFFF9Ah
cmp r8, rdx
ja short loc_5A5B8
movzx edx, byte ptr [rsi+1]
xor edx, 80h
mov eax, 0
cmp dl, 3Fh ; '?'
ja short loc_5A5B8
and ecx, 1Fh
shl ecx, 6
or ecx, edx
mov eax, 2
jmp short loc_5A5AC
loc_5A5F0:
cmp cl, 0EFh
ja short loc_5A652
lea r8, [rsi+3]
mov eax, 0FFFFFF99h
cmp r8, rdx
ja short loc_5A5B8
movzx edx, byte ptr [rsi+1]
cmp dl, 0BFh
jg short loc_5A5B6
movzx esi, byte ptr [rsi+2]
cmp sil, 0BFh
jg short loc_5A5B6
cmp ecx, 0E0h
setz r8b
cmp dl, 0A0h
setb r9b
mov eax, 0
test r8b, r9b
jnz short loc_5A5B8
shl ecx, 0Ch
movzx eax, cx
and edx, 3Fh
shl edx, 6
or edx, eax
and esi, 3Fh
or rsi, rdx
mov eax, 3
loc_5A64A:
mov rcx, rsi
jmp loc_5A5AC
loc_5A652:
cmp cl, 0F4h
ja loc_5A5B6
lea r8, [rsi+4]
mov eax, 0FFFFFF98h
cmp r8, rdx
ja loc_5A5B8
movzx r8d, byte ptr [rsi+1]
cmp r8b, 0BFh
jg loc_5A5B6
movzx edx, byte ptr [rsi+2]
cmp dl, 0BFh
jg loc_5A5B6
movzx esi, byte ptr [rsi+3]
cmp sil, 0BFh
jg loc_5A5B6
cmp ecx, 0F0h
setz al
cmp r8b, 90h
setb r9b
test al, r9b
jnz loc_5A5B6
cmp ecx, 0F4h
setz r9b
cmp r8b, 90h
setnb r10b
mov eax, 0
test r9b, r10b
jnz loc_5A5B8
and ecx, 7
shl ecx, 12h
and r8d, 3Fh
shl r8d, 0Ch
or r8d, ecx
and edx, 3Fh
shl edx, 6
or edx, r8d
and esi, 3Fh
or rsi, rdx
mov eax, 4
jmp loc_5A64A
| long long my_mb_wc_utf8mb4_quick_0(unsigned long long *a1, unsigned __int8 *a2, unsigned long long a3)
{
long long result; // rax
unsigned long long v4; // rcx
char v5; // dl
char v6; // si
unsigned long long v7; // rsi
char v8; // r8
char v9; // dl
char v10; // si
result = 4294967195LL;
if ( (unsigned long long)a2 >= a3 )
return result;
v4 = *a2;
if ( (v4 & 0x80u) == 0LL )
{
result = 1LL;
LABEL_4:
*a1 = v4;
return result;
}
if ( (unsigned __int8)v4 < 0xC2u )
return 0LL;
if ( (unsigned __int8)v4 > 0xDFu )
{
if ( (unsigned __int8)v4 > 0xEFu )
{
if ( (unsigned __int8)v4 <= 0xF4u )
{
result = 4294967192LL;
if ( (unsigned long long)(a2 + 4) > a3 )
return result;
v8 = a2[1];
if ( v8 <= -65 )
{
v9 = a2[2];
if ( v9 <= -65 )
{
v10 = a2[3];
if ( v10 <= -65 && ((unsigned __int8)v8 >= 0x90u || (_DWORD)v4 != 240) )
{
result = 0LL;
if ( (unsigned __int8)v8 >= 0x90u && (_DWORD)v4 == 244 )
return result;
v7 = ((v4 & 7) << 18) | ((unsigned __int8)(v8 & 0x3F) << 12) | ((unsigned __int8)(v9 & 0x3F) << 6) | v10 & 0x3F;
result = 4LL;
LABEL_18:
v4 = v7;
goto LABEL_4;
}
}
}
}
}
else
{
result = 4294967193LL;
if ( (unsigned long long)(a2 + 3) > a3 )
return result;
v5 = a2[1];
if ( v5 <= -65 )
{
v6 = a2[2];
if ( v6 <= -65 )
{
result = 0LL;
if ( (unsigned __int8)v5 < 0xA0u && (_DWORD)v4 == 224 )
return result;
v7 = (unsigned __int16)((_WORD)v4 << 12) | ((unsigned __int8)(v5 & 0x3F) << 6) | (unsigned long long)(v6 & 0x3F);
result = 3LL;
goto LABEL_18;
}
}
}
return 0LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a2 + 2) <= a3 )
{
result = 0LL;
if ( (a2[1] ^ 0x80u) <= 0x3F )
{
v4 = a2[1] ^ 0x80 | ((unsigned __int8)(v4 & 0x1F) << 6);
result = 2LL;
goto LABEL_4;
}
}
return result;
}
| my_mb_wc_utf8mb4_quick:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RSI,RDX
JNC 0x0015a5b8
MOVZX ECX,byte ptr [RSI]
TEST CL,CL
JS 0x0015a5b1
MOV EAX,0x1
LAB_0015a5ac:
MOV qword ptr [RDI],RCX
JMP 0x0015a5b8
LAB_0015a5b1:
CMP CL,0xc2
JNC 0x0015a5ba
LAB_0015a5b6:
XOR EAX,EAX
LAB_0015a5b8:
POP RBP
RET
LAB_0015a5ba:
CMP CL,0xdf
JA 0x0015a5f0
LEA R8,[RSI + 0x2]
MOV EAX,0xffffff9a
CMP R8,RDX
JA 0x0015a5b8
MOVZX EDX,byte ptr [RSI + 0x1]
XOR EDX,0x80
MOV EAX,0x0
CMP DL,0x3f
JA 0x0015a5b8
AND ECX,0x1f
SHL ECX,0x6
OR ECX,EDX
MOV EAX,0x2
JMP 0x0015a5ac
LAB_0015a5f0:
CMP CL,0xef
JA 0x0015a652
LEA R8,[RSI + 0x3]
MOV EAX,0xffffff99
CMP R8,RDX
JA 0x0015a5b8
MOVZX EDX,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x0015a5b6
MOVZX ESI,byte ptr [RSI + 0x2]
CMP SIL,0xbf
JG 0x0015a5b6
CMP ECX,0xe0
SETZ R8B
CMP DL,0xa0
SETC R9B
MOV EAX,0x0
TEST R8B,R9B
JNZ 0x0015a5b8
SHL ECX,0xc
MOVZX EAX,CX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,EAX
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x3
LAB_0015a64a:
MOV RCX,RSI
JMP 0x0015a5ac
LAB_0015a652:
CMP CL,0xf4
JA 0x0015a5b6
LEA R8,[RSI + 0x4]
MOV EAX,0xffffff98
CMP R8,RDX
JA 0x0015a5b8
MOVZX R8D,byte ptr [RSI + 0x1]
CMP R8B,0xbf
JG 0x0015a5b6
MOVZX EDX,byte ptr [RSI + 0x2]
CMP DL,0xbf
JG 0x0015a5b6
MOVZX ESI,byte ptr [RSI + 0x3]
CMP SIL,0xbf
JG 0x0015a5b6
CMP ECX,0xf0
SETZ AL
CMP R8B,0x90
SETC R9B
TEST AL,R9B
JNZ 0x0015a5b6
CMP ECX,0xf4
SETZ R9B
CMP R8B,0x90
SETNC R10B
MOV EAX,0x0
TEST R9B,R10B
JNZ 0x0015a5b8
AND ECX,0x7
SHL ECX,0x12
AND R8D,0x3f
SHL R8D,0xc
OR R8D,ECX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,R8D
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x4
JMP 0x0015a64a
|
int8 my_mb_wc_utf8mb4_quick(ulong *param_1,byte *param_2,byte *param_3)
{
byte bVar1;
byte bVar2;
int8 uVar3;
uint uVar4;
ulong uVar5;
if (param_3 <= param_2) {
return 0xffffff9b;
}
bVar1 = *param_2;
uVar5 = (ulong)bVar1;
if ((char)bVar1 < '\0') {
if (0xc1 < bVar1) {
uVar4 = (uint)bVar1;
if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
return 0xffffff9a;
}
if (0x3f < (byte)(param_2[1] ^ 0x80)) {
return 0;
}
uVar5 = (ulong)((uVar4 & 0x1f) << 6 | param_2[1] ^ 0x80);
uVar3 = 2;
goto LAB_0015a5ac;
}
if (bVar1 < 0xf0) {
if (param_3 < param_2 + 3) {
return 0xffffff99;
}
bVar2 = param_2[1];
if (((char)bVar2 < -0x40) && ((char)param_2[2] < -0x40)) {
if (uVar4 == 0xe0 && bVar2 < 0xa0) {
return 0;
}
uVar4 = param_2[2] & 0x3f | (bVar2 & 0x3f) << 6 | (bVar1 & 0xf) << 0xc;
uVar3 = 3;
LAB_0015a64a:
uVar5 = (ulong)uVar4;
goto LAB_0015a5ac;
}
}
else if (bVar1 < 0xf5) {
if (param_3 < param_2 + 4) {
return 0xffffff98;
}
bVar1 = param_2[1];
if (((((char)bVar1 < -0x40) && ((char)param_2[2] < -0x40)) && ((char)param_2[3] < -0x40)) &&
(uVar4 != 0xf0 || 0x8f < bVar1)) {
if (uVar4 == 0xf4 && 0x8f < bVar1) {
return 0;
}
uVar4 = param_2[3] & 0x3f |
(param_2[2] & 0x3f) << 6 | (bVar1 & 0x3f) << 0xc | (uVar4 & 7) << 0x12;
uVar3 = 4;
goto LAB_0015a64a;
}
}
}
uVar3 = 0;
}
else {
uVar3 = 1;
LAB_0015a5ac:
*param_1 = uVar5;
}
return uVar3;
}
| |
24,192 | httplib::detail::BufferStream::read(char*, unsigned long) | hkr04[P]cpp-mcp/common/httplib.h | inline ssize_t BufferStream::read(char *ptr, size_t size) {
#if defined(_MSC_VER) && _MSC_VER < 1910
auto len_read = buffer._Copy_s(ptr, size, size, position);
#else
auto len_read = buffer.copy(ptr, size, position);
#endif
position += static_cast<size_t>(len_read);
return static_cast<ssize_t>(len_read);
} | O0 | c | httplib::detail::BufferStream::read(char*, unsigned long):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq %rax, %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x28(%rax), %rcx
callq 0xb0d0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rcx
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
| _ZN7httplib6detail12BufferStream4readEPcm:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_18], rdx
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_28], rax
mov rdi, rax
add rdi, 8
mov rsi, [rsp+28h+var_10]
mov rdx, [rsp+28h+var_18]
mov rcx, [rax+28h]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4copyEPcmm; std::string::copy(char *,ulong,ulong)
mov rcx, rax
mov rax, [rsp+28h+var_28]
mov [rsp+28h+var_20], rcx
mov rcx, [rsp+28h+var_20]
add rcx, [rax+28h]
mov [rax+28h], rcx
mov rax, [rsp+28h+var_20]
add rsp, 28h
retn
| long long httplib::detail::BufferStream::read(httplib::detail::BufferStream *this, char *a2, long long a3)
{
long long result; // rax
result = std::string::copy((char *)this + 8, a2, a3, *((_QWORD *)this + 5));
*((_QWORD *)this + 5) += result;
return result;
}
| read:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP],RAX
MOV RDI,RAX
ADD RDI,0x8
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RAX + 0x28]
CALL 0x0010b0d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RCX
MOV RCX,qword ptr [RSP + 0x8]
ADD RCX,qword ptr [RAX + 0x28]
MOV qword ptr [RAX + 0x28],RCX
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x28
RET
|
/* httplib::detail::BufferStream::read(char*, unsigned long) */
long __thiscall httplib::detail::BufferStream::read(BufferStream *this,char *param_1,ulong param_2)
{
long lVar1;
lVar1 = std::__cxx11::string::copy((char *)(this + 8),(ulong)param_1,param_2);
*(long *)(this + 0x28) = lVar1 + *(long *)(this + 0x28);
return lVar1;
}
| |
24,193 | nglog::tools::ProgramInvocationShortName() | ng-log[P]ng-log/src/utilities.cc | const char* ProgramInvocationShortName() {
if (g_program_invocation_short_name != nullptr) {
return g_program_invocation_short_name;
}
#if defined(HAVE_PROGRAM_INVOCATION_SHORT_NAME)
return program_invocation_short_name;
#elif defined(HAVE_GETPROGNAME)
return getprogname();
#elif defined(HAVE___PROGNAME)
return __progname;
#elif defined(HAVE___ARGV)
return const_basename(__argv[0]);
#else
return "UNKNOWN";
#endif
} | O1 | cpp | nglog::tools::ProgramInvocationShortName():
movq 0x1f982(%rip), %rax # 0x41aa0
testq %rax, %rax
jne 0x2212d
movq 0xee76(%rip), %rax # 0x30fa0
movq (%rax), %rax
retq
| _ZN5nglog5tools26ProgramInvocationShortNameEv:
mov rax, cs:_ZN5nglogL31g_program_invocation_short_nameE; nglog::g_program_invocation_short_name
test rax, rax
jnz short locret_2212D
mov rax, cs:program_invocation_short_name_ptr
mov rax, [rax]
locret_2212D:
retn
| long long nglog::tools::ProgramInvocationShortName(nglog::tools *this)
{
long long result; // rax
result = nglog::g_program_invocation_short_name;
if ( !nglog::g_program_invocation_short_name )
return program_invocation_short_name;
return result;
}
| ProgramInvocationShortName:
MOV RAX,qword ptr [0x00141aa0]
TEST RAX,RAX
JNZ 0x0012212d
MOV RAX,qword ptr [0x00130fa0]
MOV RAX,qword ptr [RAX]
LAB_0012212d:
RET
|
/* nglog::tools::ProgramInvocationShortName() */
long nglog::tools::ProgramInvocationShortName(void)
{
long lVar1;
lVar1 = g_program_invocation_short_name;
if (g_program_invocation_short_name == 0) {
lVar1 = *(long *)PTR_program_invocation_short_name_00130fa0;
}
return lVar1;
}
| |
24,194 | nglog::tools::ProgramInvocationShortName() | ng-log[P]ng-log/src/utilities.cc | const char* ProgramInvocationShortName() {
if (g_program_invocation_short_name != nullptr) {
return g_program_invocation_short_name;
}
#if defined(HAVE_PROGRAM_INVOCATION_SHORT_NAME)
return program_invocation_short_name;
#elif defined(HAVE_GETPROGNAME)
return getprogname();
#elif defined(HAVE___PROGNAME)
return __progname;
#elif defined(HAVE___ARGV)
return const_basename(__argv[0]);
#else
return "UNKNOWN";
#endif
} | O2 | cpp | nglog::tools::ProgramInvocationShortName():
movq 0x215e8(%rip), %rax # 0x3eb00
testq %rax, %rax
jne 0x1d527
movq 0x10a74(%rip), %rax # 0x2df98
movq (%rax), %rax
retq
| _ZN5nglog5tools26ProgramInvocationShortNameEv:
mov rax, cs:_ZN5nglogL31g_program_invocation_short_nameE; nglog::g_program_invocation_short_name
test rax, rax
jnz short locret_1D527
mov rax, cs:program_invocation_short_name_ptr
mov rax, [rax]
locret_1D527:
retn
| long long nglog::tools::ProgramInvocationShortName(nglog::tools *this)
{
long long result; // rax
result = nglog::g_program_invocation_short_name;
if ( !nglog::g_program_invocation_short_name )
return program_invocation_short_name;
return result;
}
| ProgramInvocationShortName:
MOV RAX,qword ptr [0x0013eb00]
TEST RAX,RAX
JNZ 0x0011d527
MOV RAX,qword ptr [0x0012df98]
MOV RAX,qword ptr [RAX]
LAB_0011d527:
RET
|
/* nglog::tools::ProgramInvocationShortName() */
long nglog::tools::ProgramInvocationShortName(void)
{
long lVar1;
lVar1 = g_program_invocation_short_name;
if (g_program_invocation_short_name == 0) {
lVar1 = *(long *)PTR_program_invocation_short_name_0012df98;
}
return lVar1;
}
| |
24,195 | nglog::tools::ProgramInvocationShortName() | ng-log[P]ng-log/src/utilities.cc | const char* ProgramInvocationShortName() {
if (g_program_invocation_short_name != nullptr) {
return g_program_invocation_short_name;
}
#if defined(HAVE_PROGRAM_INVOCATION_SHORT_NAME)
return program_invocation_short_name;
#elif defined(HAVE_GETPROGNAME)
return getprogname();
#elif defined(HAVE___PROGNAME)
return __progname;
#elif defined(HAVE___ARGV)
return const_basename(__argv[0]);
#else
return "UNKNOWN";
#endif
} | O3 | cpp | nglog::tools::ProgramInvocationShortName():
movq 0x1f03e(%rip), %rax # 0x40aa0
testq %rax, %rax
jne 0x21a71
movq 0xe532(%rip), %rax # 0x2ffa0
movq (%rax), %rax
retq
| _ZN5nglog5tools26ProgramInvocationShortNameEv:
mov rax, cs:_ZN5nglogL31g_program_invocation_short_nameE; nglog::g_program_invocation_short_name
test rax, rax
jnz short locret_21A71
mov rax, cs:program_invocation_short_name_ptr
mov rax, [rax]
locret_21A71:
retn
| long long nglog::tools::ProgramInvocationShortName(nglog::tools *this)
{
long long result; // rax
result = nglog::g_program_invocation_short_name;
if ( !nglog::g_program_invocation_short_name )
return program_invocation_short_name;
return result;
}
| ProgramInvocationShortName:
MOV RAX,qword ptr [0x00140aa0]
TEST RAX,RAX
JNZ 0x00121a71
MOV RAX,qword ptr [0x0012ffa0]
MOV RAX,qword ptr [RAX]
LAB_00121a71:
RET
|
/* nglog::tools::ProgramInvocationShortName() */
long nglog::tools::ProgramInvocationShortName(void)
{
long lVar1;
lVar1 = g_program_invocation_short_name;
if (g_program_invocation_short_name == 0) {
lVar1 = *(long *)PTR_program_invocation_short_name_0012ffa0;
}
return lVar1;
}
| |
24,196 | 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;
} | O1 | 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 0x6ac11
movq %rbx, %rdi
callq 0x302d2
jmp 0x6ac3b
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x4326e
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x4326e
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_6AC11
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_6AC3B
loc_6AC11:
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_6AC3B:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| char * 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(
char *a1,
long long a2)
{
long long v3; // rsi
v3 = *(_QWORD *)(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(
(long long)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(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 0x0016ac11
MOV RDI,RBX
CALL 0x001302d2
JMP 0x0016ac3b
LAB_0016ac11:
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RBX],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x0014326e
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,RBX
MOV ESI,0x1
CALL 0x0014326e
LAB_0016ac3b:
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;
}
| |
24,197 | my_thread_global_init | eloqsql/mysys/my_thr_init.c | my_bool my_thread_global_init(void)
{
int pth_ret;
/* Normally this should never be called twice */
DBUG_ASSERT(my_thread_global_init_done == 0);
if (my_thread_global_init_done)
return 0;
my_thread_global_init_done= 1;
/*
THR_KEY_mysys is deleted in my_end() as DBUG libraries are using it even
after my_thread_global_end() is called.
my_thr_key_mysys_exist is used to protect against application like QT
that calls my_thread_global_init() + my_thread_global_end() multiple times
without calling my_init() + my_end().
*/
if (!my_thr_key_mysys_exists &&
(pth_ret= pthread_key_create(&THR_KEY_mysys, NULL)) != 0)
{
fprintf(stderr, "Can't initialize threads: error %d\n", pth_ret);
return 1;
}
my_thr_key_mysys_exists= 1;
/* Mutex used by my_thread_init() and after my_thread_destroy_mutex() */
my_thread_init_internal_mutex();
if (my_thread_init())
return 1;
my_thread_init_common_mutex();
return 0;
} | O3 | c | my_thread_global_init:
cmpb $0x0, 0xb66df9(%rip) # 0xc089f0
je 0xa1bfc
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb $0x1, 0xb66de7(%rip) # 0xc089f0
leaq 0xb66b1c(%rip), %rbx # 0xc0872c
cmpb $0x0, (%rbx)
je 0xa1c33
movb $0x1, (%rbx)
callq 0xa1a4b
callq 0xa1c6d
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xa1c66
callq 0xa18be
xorl %eax, %eax
jmp 0xa1c66
leaq 0xb66dba(%rip), %rdi # 0xc089f4
xorl %esi, %esi
callq 0x29700
testl %eax, %eax
je 0xa1c15
movq 0x2e2364(%rip), %rcx # 0x383fb0
movq (%rcx), %rdi
leaq 0x3ab08(%rip), %rdx # 0xdc75e
movl $0x1, %esi
movl %eax, %ecx
xorl %eax, %eax
callq 0x29200
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| my_thread_global_init:
cmp cs:my_thread_global_init_done, 0
jz short loc_A1BFC
xor eax, eax
retn
loc_A1BFC:
push rbp
mov rbp, rsp
push rbx
push rax
mov cs:my_thread_global_init_done, 1
lea rbx, my_thr_key_mysys_exists
cmp byte ptr [rbx], 0
jz short loc_A1C33
loc_A1C15:
mov byte ptr [rbx], 1
call my_thread_init_internal_mutex
call my_thread_init
mov ecx, eax
mov al, 1
test cl, cl
jnz short loc_A1C66
call my_thread_init_common_mutex
xor eax, eax
jmp short loc_A1C66
loc_A1C33:
lea rdi, THR_KEY_mysys
xor esi, esi
call _pthread_key_create
test eax, eax
jz short loc_A1C15
mov rcx, cs:stderr_ptr
mov rdi, [rcx]
lea rdx, aCanTInitialize; "Can't initialize threads: error %d\n"
mov esi, 1
mov ecx, eax
xor eax, eax
call ___fprintf_chk
mov al, 1
loc_A1C66:
add rsp, 8
pop rbx
pop rbp
retn
| char my_thread_global_init(void *a1)
{
char result; // al
char v2; // cl
int v3; // eax
if ( my_thread_global_init_done )
return 0;
my_thread_global_init_done = 1;
if ( my_thr_key_mysys_exists || (a1 = &THR_KEY_mysys, (v3 = pthread_key_create(&THR_KEY_mysys, 0LL)) == 0) )
{
my_thr_key_mysys_exists = 1;
my_thread_init_internal_mutex();
v2 = my_thread_init(a1);
result = 1;
if ( !v2 )
{
my_thread_init_common_mutex();
return 0;
}
}
else
{
__fprintf_chk(stderr, 1LL, "Can't initialize threads: error %d\n", v3);
return 1;
}
return result;
}
| my_thread_global_init:
CMP byte ptr [0x00d089f0],0x0
JZ 0x001a1bfc
XOR EAX,EAX
RET
LAB_001a1bfc:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV byte ptr [0x00d089f0],0x1
LEA RBX,[0xd0872c]
CMP byte ptr [RBX],0x0
JZ 0x001a1c33
LAB_001a1c15:
MOV byte ptr [RBX],0x1
CALL 0x001a1a4b
CALL 0x001a1c6d
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x001a1c66
CALL 0x001a18be
XOR EAX,EAX
JMP 0x001a1c66
LAB_001a1c33:
LEA RDI,[0xd089f4]
XOR ESI,ESI
CALL 0x00129700
TEST EAX,EAX
JZ 0x001a1c15
MOV RCX,qword ptr [0x00483fb0]
MOV RDI,qword ptr [RCX]
LEA RDX,[0x1dc75e]
MOV ESI,0x1
MOV ECX,EAX
XOR EAX,EAX
CALL 0x00129200
MOV AL,0x1
LAB_001a1c66:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
bool my_thread_global_init(void)
{
char cVar1;
int iVar2;
if (my_thread_global_init_done != '\0') {
return false;
}
my_thread_global_init_done = 1;
if ((my_thr_key_mysys_exists == '\0') &&
(iVar2 = pthread_key_create(&THR_KEY_mysys,(__destr_function *)0x0), iVar2 != 0)) {
__fprintf_chk(*(int8 *)PTR_stderr_00483fb0,1,"Can\'t initialize threads: error %d\n",iVar2
);
return true;
}
my_thr_key_mysys_exists = 1;
my_thread_init_internal_mutex();
cVar1 = my_thread_init();
if (cVar1 == '\0') {
my_thread_init_common_mutex();
}
return cVar1 != '\0';
}
| |
24,198 | my_strnncoll_tis620 | eloqsql/strings/ctype-tis620.c | static
int my_strnncoll_tis620(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s1, size_t len1,
const uchar *s2, size_t len2,
my_bool s2_is_prefix)
{
uchar buf[80] ;
uchar *tc1, *tc2;
int i;
if (s2_is_prefix && len1 > len2)
len1= len2;
tc1= buf;
if ((len1 + len2 +2) > (int) sizeof(buf))
tc1= (uchar*) my_malloc(PSI_INSTRUMENT_ME, len1+len2+2, MYF(MY_FAE));
tc2= tc1 + len1+1;
memcpy((char*) tc1, (char*) s1, len1);
tc1[len1]= 0; /* if length(s1)> len1, need to put 'end of string' */
memcpy((char *)tc2, (char *)s2, len2);
tc2[len2]= 0; /* put end of string */
thai2sortable(tc1, len1);
thai2sortable(tc2, len2);
i= strcmp((char*)tc1, (char*)tc2);
if (tc1 != buf)
my_free(tc1);
return i;
} | O0 | c | my_strnncoll_tis620:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %r9b, %al
movq %fs:0x28, %r9
movq %r9, -0x8(%rbp)
movq %rdi, -0x68(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdx, -0x78(%rbp)
movq %rcx, -0x80(%rbp)
movq %r8, -0x88(%rbp)
movb %al, -0x89(%rbp)
movsbl -0x89(%rbp), %eax
cmpl $0x0, %eax
je 0x4796c
movq -0x78(%rbp), %rax
cmpq -0x88(%rbp), %rax
jbe 0x4796c
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x78(%rbp), %rax
addq -0x88(%rbp), %rax
addq $0x2, %rax
cmpq $0x50, %rax
jbe 0x479ae
movq -0x78(%rbp), %rsi
addq -0x88(%rbp), %rsi
addq $0x2, %rsi
xorl %edi, %edi
movl $0x8, %edx
callq 0x2ebe0
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
addq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x24230
movq -0x98(%rbp), %rax
movq -0x78(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0xa0(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x24230
movq -0xa0(%rbp), %rax
movq -0x88(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x98(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x47e90
movq -0xa0(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x47e90
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x243f0
movl %eax, -0xa4(%rbp)
movq -0x98(%rbp), %rax
leaq -0x60(%rbp), %rcx
cmpq %rcx, %rax
je 0x47a68
movq -0x98(%rbp), %rdi
callq 0x2ef60
movl -0xa4(%rbp), %eax
movl %eax, -0xa8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x47a95
movl -0xa8(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
callq 0x242f0
nopw (%rax,%rax)
| my_strnncoll_tis620:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov al, r9b
mov r9, fs:28h
mov [rbp+var_8], r9
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov [rbp+var_78], rdx
mov [rbp+var_80], rcx
mov [rbp+var_88], r8
mov [rbp+var_89], al
movsx eax, [rbp+var_89]
cmp eax, 0
jz short loc_4796C
mov rax, [rbp+var_78]
cmp rax, [rbp+var_88]
jbe short loc_4796C
mov rax, [rbp+var_88]
mov [rbp+var_78], rax
loc_4796C:
lea rax, [rbp+var_60]
mov [rbp+var_98], rax
mov rax, [rbp+var_78]
add rax, [rbp+var_88]
add rax, 2
cmp rax, 50h ; 'P'
jbe short loc_479AE
mov rsi, [rbp+var_78]
add rsi, [rbp+var_88]
add rsi, 2
xor edi, edi
mov edx, 8
call my_malloc
mov [rbp+var_98], rax
loc_479AE:
mov rax, [rbp+var_98]
add rax, [rbp+var_78]
add rax, 1
mov [rbp+var_A0], rax
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_70]
mov rdx, [rbp+var_78]
call _memcpy
mov rax, [rbp+var_98]
mov rcx, [rbp+var_78]
mov byte ptr [rax+rcx], 0
mov rdi, [rbp+var_A0]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_88]
call _memcpy
mov rax, [rbp+var_A0]
mov rcx, [rbp+var_88]
mov byte ptr [rax+rcx], 0
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_78]
call thai2sortable
mov rdi, [rbp+var_A0]
mov rsi, [rbp+var_88]
call thai2sortable
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_A0]
call _strcmp
mov [rbp+var_A4], eax
mov rax, [rbp+var_98]
lea rcx, [rbp+var_60]
cmp rax, rcx
jz short loc_47A68
mov rdi, [rbp+var_98]
call my_free
loc_47A68:
mov eax, [rbp+var_A4]
mov [rbp+var_A8], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_47A95
mov eax, [rbp+var_A8]
add rsp, 0B0h
pop rbp
retn
loc_47A95:
call ___stack_chk_fail
| long long my_strnncoll_tis620(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
char a6)
{
unsigned int v7; // [rsp+Ch] [rbp-A4h]
long long v8; // [rsp+10h] [rbp-A0h]
_BYTE *v9; // [rsp+18h] [rbp-98h]
unsigned long long v12; // [rsp+38h] [rbp-78h]
_BYTE v13[88]; // [rsp+50h] [rbp-60h] BYREF
unsigned long long v14; // [rsp+A8h] [rbp-8h]
v14 = __readfsqword(0x28u);
v12 = a3;
if ( a6 && a3 > a5 )
v12 = a5;
v9 = v13;
if ( a5 + v12 + 2 > 0x50 )
v9 = (_BYTE *)my_malloc(0, a5 + v12 + 2, 8);
v8 = (long long)&v9[v12 + 1];
memcpy(v9, a2, v12);
v9[v12] = 0;
memcpy(v8, a4, a5);
*(_BYTE *)(v8 + a5) = 0;
thai2sortable(v9, v12);
thai2sortable(v8, a5);
v7 = strcmp(v9, v8);
if ( v9 != v13 )
my_free((long long)v9);
return v7;
}
| my_strnncoll_tis620:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV AL,R9B
MOV R9,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],R9
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV qword ptr [RBP + -0x78],RDX
MOV qword ptr [RBP + -0x80],RCX
MOV qword ptr [RBP + -0x88],R8
MOV byte ptr [RBP + -0x89],AL
MOVSX EAX,byte ptr [RBP + -0x89]
CMP EAX,0x0
JZ 0x0014796c
MOV RAX,qword ptr [RBP + -0x78]
CMP RAX,qword ptr [RBP + -0x88]
JBE 0x0014796c
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x78],RAX
LAB_0014796c:
LEA RAX,[RBP + -0x60]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,qword ptr [RBP + -0x88]
ADD RAX,0x2
CMP RAX,0x50
JBE 0x001479ae
MOV RSI,qword ptr [RBP + -0x78]
ADD RSI,qword ptr [RBP + -0x88]
ADD RSI,0x2
XOR EDI,EDI
MOV EDX,0x8
CALL 0x0012ebe0
MOV qword ptr [RBP + -0x98],RAX
LAB_001479ae:
MOV RAX,qword ptr [RBP + -0x98]
ADD RAX,qword ptr [RBP + -0x78]
ADD RAX,0x1
MOV qword ptr [RBP + -0xa0],RAX
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x70]
MOV RDX,qword ptr [RBP + -0x78]
CALL 0x00124230
MOV RAX,qword ptr [RBP + -0x98]
MOV RCX,qword ptr [RBP + -0x78]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RDI,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x88]
CALL 0x00124230
MOV RAX,qword ptr [RBP + -0xa0]
MOV RCX,qword ptr [RBP + -0x88]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x78]
CALL 0x00147e90
MOV RDI,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0x88]
CALL 0x00147e90
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0xa0]
CALL 0x001243f0
MOV dword ptr [RBP + -0xa4],EAX
MOV RAX,qword ptr [RBP + -0x98]
LEA RCX,[RBP + -0x60]
CMP RAX,RCX
JZ 0x00147a68
MOV RDI,qword ptr [RBP + -0x98]
CALL 0x0012ef60
LAB_00147a68:
MOV EAX,dword ptr [RBP + -0xa4]
MOV dword ptr [RBP + -0xa8],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00147a95
MOV EAX,dword ptr [RBP + -0xa8]
ADD RSP,0xb0
POP RBP
RET
LAB_00147a95:
CALL 0x001242f0
|
int my_strnncoll_tis620(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
char param_6)
{
int iVar1;
char *__s2;
long in_FS_OFFSET;
char *local_a0;
size_t local_80;
char local_68 [88];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_80 = param_3;
if ((param_6 != '\0') && (param_5 < param_3)) {
local_80 = param_5;
}
local_a0 = local_68;
if (0x50 < local_80 + param_5 + 2) {
local_a0 = (char *)my_malloc(0,local_80 + param_5 + 2,8);
}
__s2 = local_a0 + local_80 + 1;
memcpy(local_a0,param_2,local_80);
local_a0[local_80] = '\0';
memcpy(__s2,param_4,param_5);
__s2[param_5] = '\0';
thai2sortable(local_a0,local_80);
thai2sortable(__s2,param_5);
iVar1 = strcmp(local_a0,__s2);
if (local_a0 != local_68) {
my_free(local_a0);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return iVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
24,199 | void nglog::internal::MakeCheckOpValueString<unsigned char>(std::ostream*, unsigned char const&) | ng-log[P]ng-log/src/logging.cc | void MakeCheckOpValueString(std::ostream* os, const unsigned char& v) {
if (v >= 32 && v <= 126) {
(*os) << "'" << v << "'";
} else {
(*os) << "unsigned char value " << static_cast<unsigned short>(v);
}
} | O3 | cpp | void nglog::internal::MakeCheckOpValueString<unsigned char>(std::ostream*, unsigned char const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb (%rsi), %al
addb $-0x20, %al
cmpb $0x5e, %al
ja 0xf118
leaq 0x148c7(%rip), %r15 # 0x2399e
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7600
movb (%r14), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x7600
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x7600
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x14a35(%rip), %rsi # 0x23b54
movl $0x14, %edx
movq %rbx, %rdi
callq 0x7600
movzbl (%r14), %esi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7360
| _ZN5nglog8internal22MakeCheckOpValueStringIhEEvPSoRKT_:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
mov al, [rsi]
add al, 0E0h
cmp al, 5Eh ; '^'
ja short loc_F118
lea r15, aDataNumCharsTo+59h; "'"
mov edx, 1
mov rdi, rbx
mov rsi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov al, [r14]
lea rsi, [rsp+28h+var_19]
mov [rsi], al
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)
mov edx, 1
mov rdi, rax
mov rsi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
add rsp, 10h
pop rbx
pop r14
pop r15
retn
loc_F118:
lea rsi, aUnsignedCharVa; "unsigned char value "
mov edx, 14h
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)
movzx esi, byte ptr [r14]
mov rdi, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
jmp __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
| long long nglog::internal::MakeCheckOpValueString<unsigned char>(long long a1, _BYTE *a2)
{
long long v2; // rax
_BYTE v4[25]; // [rsp+Fh] [rbp-19h] BYREF
if ( (unsigned __int8)(*a2 - 32) > 0x5Eu )
{
std::__ostream_insert<char,std::char_traits<char>>(a1, "unsigned char value ", 20LL);
return std::ostream::_M_insert<unsigned long>(a1);
}
else
{
std::__ostream_insert<char,std::char_traits<char>>(a1, "'", 1LL);
v4[0] = *a2;
v2 = std::__ostream_insert<char,std::char_traits<char>>(a1, v4, 1LL);
return std::__ostream_insert<char,std::char_traits<char>>(v2, "'", 1LL);
}
}
| MakeCheckOpValueString<unsigned_char>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
MOV AL,byte ptr [RSI]
ADD AL,0xe0
CMP AL,0x5e
JA 0x0010f118
LEA R15,[0x12399e]
MOV EDX,0x1
MOV RDI,RBX
MOV RSI,R15
CALL 0x00107600
MOV AL,byte ptr [R14]
LEA RSI,[RSP + 0xf]
MOV byte ptr [RSI],AL
MOV EDX,0x1
MOV RDI,RBX
CALL 0x00107600
MOV EDX,0x1
MOV RDI,RAX
MOV RSI,R15
CALL 0x00107600
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
LAB_0010f118:
LEA RSI,[0x123b54]
MOV EDX,0x14
MOV RDI,RBX
CALL 0x00107600
MOVZX ESI,byte ptr [R14]
MOV RDI,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
JMP 0x00107360
|
/* void nglog::internal::MakeCheckOpValueString<unsigned char>(std::ostream*, unsigned char const&)
*/
void nglog::internal::MakeCheckOpValueString<unsigned_char>(ostream *param_1,uchar *param_2)
{
ostream *poVar1;
uchar local_19;
if ((byte)(*param_2 - 0x20) < 0x5f) {
std::__ostream_insert<char,std::char_traits<char>>(param_1,"\'",1);
local_19 = *param_2;
poVar1 = std::__ostream_insert<char,std::char_traits<char>>(param_1,(char *)&local_19,1);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,"\'",1);
return;
}
std::__ostream_insert<char,std::char_traits<char>>(param_1,"unsigned char value ",0x14);
std::ostream::_M_insert<unsigned_long>((ulong)param_1);
return;
}
|
Subsets and Splits
C++ Functions Using STL
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++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
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.