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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
28,400 | signature_item::to_words(item_writer_context&) const | msxemulator/build_O0/_deps/picotool-src/bintool/metadata.h | std::vector<uint32_t> to_words(item_writer_context& ctx) const override {
assert(signature_bytes.size() % 4 == 0);
assert(public_key_bytes.size() % 4 == 0);
std::vector<uint32_t> rc = {
encode_type_and_size(1 + public_key_bytes.size()/4 + signature_bytes.size()/4) | (sig_type << 24),
};
auto words = lsb_bytes_to_words(public_key_bytes.begin(), public_key_bytes.end());
std::copy(words.begin(), words.end(), std::back_inserter(rc));
words = lsb_bytes_to_words(signature_bytes.begin(), signature_bytes.end());
std::copy(words.begin(), words.end(), std::back_inserter(rc));
return rc;
} | O0 | c | signature_item::to_words(item_writer_context&) const:
subq $0x148, %rsp # imm = 0x148
movq %rdi, 0x60(%rsp)
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
movq 0x138(%rsp), %rdi
movq %rdi, 0x58(%rsp)
movb $0x0, 0x12f(%rsp)
addq $0x28, %rdi
callq 0x5f500
movq 0x58(%rsp), %rdi
shrq $0x2, %rax
movl %eax, 0x54(%rsp)
addq $0x10, %rdi
callq 0x5f500
movl 0x54(%rsp), %edx
movq 0x58(%rsp), %rdi
movq %rax, %rcx
shrq $0x2, %rcx
movl %edx, %eax
movl %ecx, %edx
movl %edx, %ecx
leal 0x1(%rax,%rcx), %esi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movq 0x58(%rsp), %rcx
movl 0x8(%rcx), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, 0x114(%rsp)
leaq 0x114(%rsp), %rax
movq %rax, 0x118(%rsp)
movq $0x1, 0x120(%rsp)
leaq 0x113(%rsp), %rdi
movq %rdi, 0x68(%rsp)
callq 0x91b20
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rcx
movq 0x118(%rsp), %rsi
movq 0x120(%rsp), %rdx
callq 0x91b30
jmp 0x95af6
leaq 0x113(%rsp), %rdi
callq 0x91bc0
movq 0x58(%rsp), %rdi
addq $0x28, %rdi
movq %rdi, 0x40(%rsp)
callq 0x94de0
movq 0x40(%rsp), %rdi
movq %rax, 0xe0(%rsp)
callq 0x94e10
movq %rax, 0xd8(%rsp)
movq 0xe0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
leaq 0xe8(%rsp), %rdi
callq 0x94c40
jmp 0x95b4f
leaq 0xe8(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x61340
movq 0x30(%rsp), %rdi
movq %rax, 0xd0(%rsp)
callq 0x61370
movq 0x60(%rsp), %rdi
movq %rax, 0xc8(%rsp)
callq 0x94eb0
movq %rax, 0x38(%rsp)
jmp 0x95b8c
movq 0x38(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xc0(%rsp), %rdx
callq 0x94e40
movq %rax, 0x28(%rsp)
jmp 0x95bbd
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0xb8(%rsp)
addq $0x10, %rdi
movq %rdi, 0x20(%rsp)
callq 0x94de0
movq 0x20(%rsp), %rdi
movq %rax, 0x98(%rsp)
callq 0x94e10
movq %rax, 0x90(%rsp)
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
callq 0x94c40
jmp 0x95c16
leaq 0xe8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0xa0(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x5b0f0
movq 0x8(%rsp), %rdi
callq 0x5b130
movq 0x10(%rsp), %rdi
callq 0x61340
movq 0x10(%rsp), %rdi
movq %rax, 0x88(%rsp)
callq 0x61370
movq 0x60(%rsp), %rdi
movq %rax, 0x80(%rsp)
callq 0x94eb0
movq %rax, 0x18(%rsp)
jmp 0x95c74
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x94e40
movq %rax, (%rsp)
jmp 0x95c9e
movq (%rsp), %rax
movq %rax, 0x70(%rsp)
movb $0x1, 0x12f(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0x5b130
testb $0x1, 0x12f(%rsp)
jne 0x95d2e
jmp 0x95d24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
leaq 0x113(%rsp), %rdi
callq 0x91bc0
jmp 0x95d45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
jmp 0x95d3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0x5b130
jmp 0x95d3b
movq 0x60(%rsp), %rdi
callq 0x5b130
movq 0x48(%rsp), %rax
addq $0x148, %rsp # imm = 0x148
retq
movq 0x60(%rsp), %rdi
callq 0x5b130
movq 0x108(%rsp), %rdi
callq 0xf9e0
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZNK14signature_item8to_wordsER19item_writer_context:
sub rsp, 148h
mov [rsp+148h+var_E8], rdi
mov rax, rdi
mov [rsp+148h+var_100], rax
mov [rsp+148h+var_8], rdi
mov [rsp+148h+var_10], rsi
mov [rsp+148h+var_18], rdx
mov rdi, [rsp+148h+var_10]
mov [rsp+148h+var_F0], rdi
mov [rsp+148h+var_19], 0
add rdi, 28h ; '('
call _ZNKSt6vectorIhSaIhEE4sizeEv; std::vector<uchar>::size(void)
mov rdi, [rsp+148h+var_F0]
shr rax, 2
mov [rsp+148h+var_F4], eax
add rdi, 10h
call _ZNKSt6vectorIhSaIhEE4sizeEv; std::vector<uchar>::size(void)
mov edx, [rsp+148h+var_F4]
mov rdi, [rsp+148h+var_F0]
mov rcx, rax
shr rcx, 2
mov eax, edx
mov edx, ecx
mov ecx, edx
lea esi, [rax+rcx+1]
mov rax, [rdi]
mov rax, [rax+20h]
call rax
mov rcx, [rsp+148h+var_F0]
mov ecx, [rcx+8]
shl ecx, 18h
or eax, ecx
mov [rsp+148h+var_34], eax
lea rax, [rsp+148h+var_34]
mov [rsp+148h+var_30], rax
mov [rsp+148h+var_28], 1
lea rdi, [rsp+148h+var_35]
mov [rsp+148h+var_E0], rdi
call _ZNSaIjEC2Ev; std::allocator<uint>::allocator(void)
mov rdi, [rsp+148h+var_E8]
mov rcx, [rsp+148h+var_E0]
mov rsi, [rsp+148h+var_30]
mov rdx, [rsp+148h+var_28]
call _ZNSt6vectorIjSaIjEEC2ESt16initializer_listIjERKS0_; std::vector<uint>::vector(std::initializer_list<uint>,std::allocator<uint> const&)
jmp short $+2
loc_95AF6:
lea rdi, [rsp+148h+var_35]
call _ZNSaIjED2Ev; std::allocator<uint>::~allocator()
mov rdi, [rsp+148h+var_F0]
add rdi, 28h ; '('
mov [rsp+148h+var_108], rdi
call _ZNKSt6vectorIhSaIhEE5beginEv; std::vector<uchar>::begin(void)
mov rdi, [rsp+148h+var_108]
mov [rsp+148h+var_68], rax
call _ZNKSt6vectorIhSaIhEE3endEv; std::vector<uchar>::end(void)
mov [rsp+148h+var_70], rax
mov rsi, [rsp+148h+var_68]
mov rdx, [rsp+148h+var_70]
lea rdi, [rsp+148h+var_60]
call _Z18lsb_bytes_to_wordsIN9__gnu_cxx17__normal_iteratorIPKhSt6vectorIhSaIhEEEEES4_IjSaIjEET_SA_; lsb_bytes_to_words<__gnu_cxx::__normal_iterator<uchar const*,std::vector<uchar>>>(__gnu_cxx::__normal_iterator<uchar const*,std::vector<uchar>>,__gnu_cxx::__normal_iterator<uchar const*,std::vector<uchar>>)
jmp short $+2
loc_95B4F:
lea rdi, [rsp+148h+var_60]
mov [rsp+148h+var_118], rdi
call _ZNSt6vectorIjSaIjEE5beginEv; std::vector<uint>::begin(void)
mov rdi, [rsp+148h+var_118]
mov [rsp+148h+var_78], rax
call _ZNSt6vectorIjSaIjEE3endEv; std::vector<uint>::end(void)
mov rdi, [rsp+148h+var_E8]
mov [rsp+148h+var_80], rax
call _ZSt13back_inserterISt6vectorIjSaIjEEESt20back_insert_iteratorIT_ERS4_; std::back_inserter<std::vector<uint>>(std::vector<uint>&)
mov [rsp+148h+var_110], rax
jmp short $+2
loc_95B8C:
mov rax, [rsp+148h+var_110]
mov [rsp+148h+var_88], rax
mov rdi, [rsp+148h+var_78]
mov rsi, [rsp+148h+var_80]
mov rdx, [rsp+148h+var_88]
call _ZSt4copyIN9__gnu_cxx17__normal_iteratorIPjSt6vectorIjSaIjEEEESt20back_insert_iteratorIS5_EET0_T_SA_S9_; std::copy<__gnu_cxx::__normal_iterator<uint *,std::vector<uint>>,std::back_insert_iterator<std::vector<uint>>>(__gnu_cxx::__normal_iterator<uint *,std::vector<uint>>,__gnu_cxx::__normal_iterator<uint *,std::vector<uint>>,std::back_insert_iterator<std::vector<uint>>)
mov [rsp+148h+var_120], rax
jmp short $+2
loc_95BBD:
mov rdi, [rsp+148h+var_F0]
mov rax, [rsp+148h+var_120]
mov [rsp+148h+var_90], rax
add rdi, 10h
mov [rsp+148h+var_128], rdi
call _ZNKSt6vectorIhSaIhEE5beginEv; std::vector<uchar>::begin(void)
mov rdi, [rsp+148h+var_128]
mov [rsp+148h+var_B0], rax
call _ZNKSt6vectorIhSaIhEE3endEv; std::vector<uchar>::end(void)
mov [rsp+148h+var_B8], rax
mov rsi, [rsp+148h+var_B0]
mov rdx, [rsp+148h+var_B8]
lea rdi, [rsp+148h+var_A8]
call _Z18lsb_bytes_to_wordsIN9__gnu_cxx17__normal_iteratorIPKhSt6vectorIhSaIhEEEEES4_IjSaIjEET_SA_; lsb_bytes_to_words<__gnu_cxx::__normal_iterator<uchar const*,std::vector<uchar>>>(__gnu_cxx::__normal_iterator<uchar const*,std::vector<uchar>>,__gnu_cxx::__normal_iterator<uchar const*,std::vector<uchar>>)
jmp short $+2
loc_95C16:
lea rdi, [rsp+148h+var_60]
mov [rsp+148h+var_138], rdi
lea rsi, [rsp+148h+var_A8]
mov [rsp+148h+var_140], rsi
call _ZNSt6vectorIjSaIjEEaSEOS1_; std::vector<uint>::operator=(std::vector<uint>&&)
mov rdi, [rsp+148h+var_140]
call _ZNSt6vectorIjSaIjEED2Ev; std::vector<uint>::~vector()
mov rdi, [rsp+148h+var_138]
call _ZNSt6vectorIjSaIjEE5beginEv; std::vector<uint>::begin(void)
mov rdi, [rsp+148h+var_138]
mov [rsp+148h+var_C0], rax
call _ZNSt6vectorIjSaIjEE3endEv; std::vector<uint>::end(void)
mov rdi, [rsp+148h+var_E8]
mov [rsp+148h+var_C8], rax
call _ZSt13back_inserterISt6vectorIjSaIjEEESt20back_insert_iteratorIT_ERS4_; std::back_inserter<std::vector<uint>>(std::vector<uint>&)
mov [rsp+148h+var_130], rax
jmp short $+2
loc_95C74:
mov rax, [rsp+148h+var_130]
mov [rsp+148h+var_D0], rax
mov rdi, [rsp+148h+var_C0]
mov rsi, [rsp+148h+var_C8]
mov rdx, [rsp+148h+var_D0]
call _ZSt4copyIN9__gnu_cxx17__normal_iteratorIPjSt6vectorIjSaIjEEEESt20back_insert_iteratorIS5_EET0_T_SA_S9_; std::copy<__gnu_cxx::__normal_iterator<uint *,std::vector<uint>>,std::back_insert_iterator<std::vector<uint>>>(__gnu_cxx::__normal_iterator<uint *,std::vector<uint>>,__gnu_cxx::__normal_iterator<uint *,std::vector<uint>>,std::back_insert_iterator<std::vector<uint>>)
mov [rsp+148h+var_148], rax
jmp short $+2
loc_95C9E:
mov rax, [rsp+148h+var_148]
mov [rsp+148h+var_D8], rax
mov [rsp+148h+var_19], 1
lea rdi, [rsp+148h+var_60]
call _ZNSt6vectorIjSaIjEED2Ev; std::vector<uint>::~vector()
test [rsp+148h+var_19], 1
jnz short loc_95D2E
jmp short loc_95D24
mov rcx, rax
mov eax, edx
mov [rsp+arg_100], rcx
mov [rsp+arg_FC], eax
lea rdi, [rsp+arg_10B]
call _ZNSaIjED2Ev; std::allocator<uint>::~allocator()
jmp short loc_95D45
mov rcx, rax
mov eax, edx
mov [rsp+arg_100], rcx
mov [rsp+arg_FC], eax
jmp short loc_95D3B
mov rcx, rax
mov eax, edx
mov [rsp+arg_100], rcx
mov [rsp+arg_FC], eax
lea rdi, [rsp+arg_E0]
call _ZNSt6vectorIjSaIjEED2Ev; std::vector<uint>::~vector()
jmp short loc_95D3B
loc_95D24:
mov rdi, [rsp+148h+var_E8]
call _ZNSt6vectorIjSaIjEED2Ev; std::vector<uint>::~vector()
loc_95D2E:
mov rax, [rsp+148h+var_100]
add rsp, 148h
retn
loc_95D3B:
mov rdi, [rsp+arg_58]
call _ZNSt6vectorIjSaIjEED2Ev; std::vector<uint>::~vector()
loc_95D45:
mov rdi, [rsp+arg_100]
call __Unwind_Resume
| signature_item * signature_item::to_words(signature_item *this, item_writer_context *a2, long long a3)
{
unsigned long long v3; // rax
int v5; // [rsp+54h] [rbp-F4h]
long long v6; // [rsp+78h] [rbp-D0h]
long long v7; // [rsp+80h] [rbp-C8h]
long long v8; // [rsp+88h] [rbp-C0h]
long long v9; // [rsp+90h] [rbp-B8h]
long long v10; // [rsp+98h] [rbp-B0h]
long long v11[4]; // [rsp+A0h] [rbp-A8h] BYREF
long long v12; // [rsp+C0h] [rbp-88h]
long long v13; // [rsp+C8h] [rbp-80h]
long long v14; // [rsp+D0h] [rbp-78h]
long long v15; // [rsp+D8h] [rbp-70h]
long long v16; // [rsp+E0h] [rbp-68h]
long long v17[5]; // [rsp+E8h] [rbp-60h] BYREF
char v18; // [rsp+113h] [rbp-35h] BYREF
int v19; // [rsp+114h] [rbp-34h] BYREF
int *v20; // [rsp+118h] [rbp-30h]
long long v21; // [rsp+120h] [rbp-28h]
char v22; // [rsp+12Fh] [rbp-19h]
long long v23; // [rsp+130h] [rbp-18h]
item_writer_context *v24; // [rsp+138h] [rbp-10h]
signature_item *v25; // [rsp+140h] [rbp-8h]
v25 = this;
v24 = a2;
v23 = a3;
v22 = 0;
v5 = (unsigned long long)std::vector<unsigned char>::size((_QWORD *)a2 + 5) >> 2;
v3 = std::vector<unsigned char>::size((_QWORD *)a2 + 2);
v19 = (*((_DWORD *)a2 + 2) << 24) | (*(long long ( **)(item_writer_context *, _QWORD))(*(_QWORD *)a2 + 32LL))(
a2,
v5 + (unsigned int)(v3 >> 2) + 1);
v20 = &v19;
v21 = 1LL;
std::allocator<unsigned int>::allocator((long long)&v18);
std::vector<unsigned int>::vector((long long)this, (long long)v20, v21, (long long)&v18);
std::allocator<unsigned int>::~allocator((long long)&v18);
v16 = std::vector<unsigned char>::begin((long long)a2 + 40);
v15 = std::vector<unsigned char>::end((long long)a2 + 40);
lsb_bytes_to_words<__gnu_cxx::__normal_iterator<unsigned char const*,std::vector<unsigned char>>>(
(long long)v17,
v16,
v15);
v14 = std::vector<unsigned int>::begin((long long)v17);
v13 = std::vector<unsigned int>::end((long long)v17);
v12 = std::back_inserter<std::vector<unsigned int>>((long long)this);
v11[3] = std::copy<__gnu_cxx::__normal_iterator<unsigned int *,std::vector<unsigned int>>,std::back_insert_iterator<std::vector<unsigned int>>>(
v14,
v13,
v12);
v10 = std::vector<unsigned char>::begin((long long)a2 + 16);
v9 = std::vector<unsigned char>::end((long long)a2 + 16);
lsb_bytes_to_words<__gnu_cxx::__normal_iterator<unsigned char const*,std::vector<unsigned char>>>(
(long long)v11,
v10,
v9);
std::vector<unsigned int>::operator=((long long)v17, (long long)v11);
std::vector<unsigned int>::~vector(v11);
v8 = std::vector<unsigned int>::begin((long long)v17);
v7 = std::vector<unsigned int>::end((long long)v17);
v6 = std::back_inserter<std::vector<unsigned int>>((long long)this);
std::copy<__gnu_cxx::__normal_iterator<unsigned int *,std::vector<unsigned int>>,std::back_insert_iterator<std::vector<unsigned int>>>(
v8,
v7,
v6);
v22 = 1;
std::vector<unsigned int>::~vector(v17);
if ( (v22 & 1) == 0 )
std::vector<unsigned int>::~vector((long long *)this);
return this;
}
| to_words:
SUB RSP,0x148
MOV qword ptr [RSP + 0x60],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x140],RDI
MOV qword ptr [RSP + 0x138],RSI
MOV qword ptr [RSP + 0x130],RDX
MOV RDI,qword ptr [RSP + 0x138]
MOV qword ptr [RSP + 0x58],RDI
MOV byte ptr [RSP + 0x12f],0x0
ADD RDI,0x28
CALL 0x0015f500
MOV RDI,qword ptr [RSP + 0x58]
SHR RAX,0x2
MOV dword ptr [RSP + 0x54],EAX
ADD RDI,0x10
CALL 0x0015f500
MOV EDX,dword ptr [RSP + 0x54]
MOV RDI,qword ptr [RSP + 0x58]
MOV RCX,RAX
SHR RCX,0x2
MOV EAX,EDX
MOV EDX,ECX
MOV ECX,EDX
LEA ESI,[RAX + RCX*0x1 + 0x1]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x20]
CALL RAX
MOV RCX,qword ptr [RSP + 0x58]
MOV ECX,dword ptr [RCX + 0x8]
SHL ECX,0x18
OR EAX,ECX
MOV dword ptr [RSP + 0x114],EAX
LEA RAX,[RSP + 0x114]
MOV qword ptr [RSP + 0x118],RAX
MOV qword ptr [RSP + 0x120],0x1
LEA RDI,[RSP + 0x113]
MOV qword ptr [RSP + 0x68],RDI
CALL 0x00191b20
MOV RDI,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x118]
MOV RDX,qword ptr [RSP + 0x120]
LAB_00195aef:
CALL 0x00191b30
JMP 0x00195af6
LAB_00195af6:
LEA RDI,[RSP + 0x113]
CALL 0x00191bc0
MOV RDI,qword ptr [RSP + 0x58]
ADD RDI,0x28
MOV qword ptr [RSP + 0x40],RDI
CALL 0x00194de0
MOV RDI,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0xe0],RAX
CALL 0x00194e10
MOV qword ptr [RSP + 0xd8],RAX
MOV RSI,qword ptr [RSP + 0xe0]
MOV RDX,qword ptr [RSP + 0xd8]
LAB_00195b40:
LEA RDI,[RSP + 0xe8]
CALL 0x00194c40
JMP 0x00195b4f
LAB_00195b4f:
LEA RDI,[RSP + 0xe8]
MOV qword ptr [RSP + 0x30],RDI
CALL 0x00161340
MOV RDI,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0xd0],RAX
CALL 0x00161370
MOV RDI,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0xc8],RAX
LAB_00195b80:
CALL 0x00194eb0
MOV qword ptr [RSP + 0x38],RAX
JMP 0x00195b8c
LAB_00195b8c:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0xc0],RAX
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xc0]
CALL 0x00194e40
MOV qword ptr [RSP + 0x28],RAX
JMP 0x00195bbd
LAB_00195bbd:
MOV RDI,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0xb8],RAX
ADD RDI,0x10
MOV qword ptr [RSP + 0x20],RDI
CALL 0x00194de0
MOV RDI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x98],RAX
CALL 0x00194e10
MOV qword ptr [RSP + 0x90],RAX
MOV RSI,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0x90]
LEA RDI,[RSP + 0xa0]
CALL 0x00194c40
JMP 0x00195c16
LAB_00195c16:
LEA RDI,[RSP + 0xe8]
MOV qword ptr [RSP + 0x10],RDI
LEA RSI,[RSP + 0xa0]
MOV qword ptr [RSP + 0x8],RSI
CALL 0x0015b0f0
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0015b130
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00161340
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x88],RAX
CALL 0x00161370
MOV RDI,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x80],RAX
CALL 0x00194eb0
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00195c74
LAB_00195c74:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x00194e40
LAB_00195c98:
MOV qword ptr [RSP],RAX
JMP 0x00195c9e
LAB_00195c9e:
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x70],RAX
MOV byte ptr [RSP + 0x12f],0x1
LEA RDI,[RSP + 0xe8]
CALL 0x0015b130
TEST byte ptr [RSP + 0x12f],0x1
JNZ 0x00195d2e
JMP 0x00195d24
LAB_00195d24:
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x0015b130
LAB_00195d2e:
MOV RAX,qword ptr [RSP + 0x48]
ADD RSP,0x148
RET
|
/* signature_item::to_words(item_writer_context&) const */
item_writer_context * signature_item::to_words(item_writer_context *param_1)
{
ulong uVar1;
ulong uVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
long *in_RSI;
vector<unsigned_int,std::allocator<unsigned_int>> local_a8 [24];
int8 local_90;
int8 local_88;
int8 local_80;
int8 local_78;
int8 local_70;
int8 local_68;
vector<unsigned_int,std::allocator<unsigned_int>> local_60 [43];
allocator<unsigned_int> local_35;
uint local_34;
uint *local_30;
int8 local_28;
byte local_19;
item_writer_context *local_8;
local_19 = 0;
local_8 = param_1;
uVar1 = std::vector<unsigned_char,std::allocator<unsigned_char>>::size
((vector<unsigned_char,std::allocator<unsigned_char>> *)(in_RSI + 5));
uVar2 = std::vector<unsigned_char,std::allocator<unsigned_char>>::size
((vector<unsigned_char,std::allocator<unsigned_char>> *)(in_RSI + 2));
local_34 = (**(code **)(*in_RSI + 0x20))(in_RSI,(int)(uVar1 >> 2) + 1 + (int)(uVar2 >> 2));
local_34 = local_34 | (int)in_RSI[1] << 0x18;
local_30 = &local_34;
local_28 = 1;
std::allocator<unsigned_int>::allocator(&local_35);
/* try { // try from 00195aef to 00195af3 has its CatchHandler @ 00195cc8 */
std::vector<unsigned_int,std::allocator<unsigned_int>>::vector
(param_1,local_30,local_28,&local_35);
std::allocator<unsigned_int>::~allocator(&local_35);
local_68 = std::vector<unsigned_char,std::allocator<unsigned_char>>::begin
((vector<unsigned_char,std::allocator<unsigned_char>> *)(in_RSI + 5));
local_70 = std::vector<unsigned_char,std::allocator<unsigned_char>>::end
((vector<unsigned_char,std::allocator<unsigned_char>> *)(in_RSI + 5));
/* try { // try from 00195b40 to 00195b4c has its CatchHandler @ 00195ceb */
lsb_bytes_to_words<__gnu_cxx::__normal_iterator<unsigned_char_const*,std::vector<unsigned_char,std::allocator<unsigned_char>>>>
(local_60,local_68,local_70);
local_78 = std::vector<unsigned_int,std::allocator<unsigned_int>>::begin(local_60);
local_80 = std::vector<unsigned_int,std::allocator<unsigned_int>>::end(local_60);
/* try { // try from 00195b80 to 00195c97 has its CatchHandler @ 00195d01 */
local_88 = std::back_inserter<std::vector<unsigned_int,std::allocator<unsigned_int>>>(param_1);
local_90 = std::
copy<__gnu_cxx::__normal_iterator<unsigned_int*,std::vector<unsigned_int,std::allocator<unsigned_int>>>,std::back_insert_iterator<std::vector<unsigned_int,std::allocator<unsigned_int>>>>
(local_78,local_80,local_88);
uVar3 = std::vector<unsigned_char,std::allocator<unsigned_char>>::begin
((vector<unsigned_char,std::allocator<unsigned_char>> *)(in_RSI + 2));
uVar4 = std::vector<unsigned_char,std::allocator<unsigned_char>>::end
((vector<unsigned_char,std::allocator<unsigned_char>> *)(in_RSI + 2));
lsb_bytes_to_words<__gnu_cxx::__normal_iterator<unsigned_char_const*,std::vector<unsigned_char,std::allocator<unsigned_char>>>>
(local_a8,uVar3,uVar4);
std::vector<unsigned_int,std::allocator<unsigned_int>>::operator=(local_60,local_a8);
std::vector<unsigned_int,std::allocator<unsigned_int>>::~vector(local_a8);
uVar3 = std::vector<unsigned_int,std::allocator<unsigned_int>>::begin(local_60);
uVar4 = std::vector<unsigned_int,std::allocator<unsigned_int>>::end(local_60);
uVar5 = std::back_inserter<std::vector<unsigned_int,std::allocator<unsigned_int>>>(param_1);
std::
copy<__gnu_cxx::__normal_iterator<unsigned_int*,std::vector<unsigned_int,std::allocator<unsigned_int>>>,std::back_insert_iterator<std::vector<unsigned_int,std::allocator<unsigned_int>>>>
(uVar3,uVar4,uVar5);
local_19 = 1;
std::vector<unsigned_int,std::allocator<unsigned_int>>::~vector(local_60);
if ((local_19 & 1) == 0) {
std::vector<unsigned_int,std::allocator<unsigned_int>>::~vector
((vector<unsigned_int,std::allocator<unsigned_int>> *)param_1);
}
return param_1;
}
| |
28,401 | fs_get_cache_directory[abi:cxx11]() | llama.cpp/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x64a4(%rip), %rdx # 0x5bc4c
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x2fb78
leaq 0xd48c(%rip), %rdi # 0x62c48
callq 0x17840
testq %rax, %rax
je 0x557f2
movq %rax, %r14
leaq 0x28(%rsp), %r15
movq 0x8(%r15), %r12
movq %rax, %rdi
callq 0x17430
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x17580
jmp 0x55a12
leaq 0xd45b(%rip), %rdi # 0x62c54
callq 0x17840
testq %rax, %rax
je 0x5582f
movq %rax, %r14
leaq 0x28(%rsp), %r15
movq 0x8(%r15), %r12
movq %rax, %rdi
callq 0x17430
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x17580
jmp 0x5592d
leaq 0xd428(%rip), %rdi # 0x62c5e
callq 0x17840
movq %rax, %r14
leaq 0x98(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xd411(%rip), %rsi # 0x62c63
leaq 0xd412(%rip), %rdx # 0x62c6b
leaq 0x88(%rsp), %rdi
callq 0x2fb78
movq %r14, %rdi
callq 0x17430
leaq 0x88(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
callq 0x17170
movq %rax, %r15
leaq 0x78(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rax
movq %r15, %r12
addq $0x10, %r12
cmpq %r12, %rax
je 0x558b4
movq %rax, 0x68(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x78(%rsp)
movq 0x8(%r15), %rbp
jmp 0x558c7
movq 0x8(%r15), %rbp
leaq 0x1(%rbp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x170b0
leaq 0x68(%rsp), %r13
movq %rbp, 0x8(%r13)
movq %r12, (%r15)
movq $0x0, 0x8(%r15)
movb $0x0, 0x10(%r15)
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x175e0
movq (%r13), %rdi
cmpq %r14, %rdi
je 0x55903
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x17100
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
leaq 0x38(%rsp), %rbp
je 0x5592d
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x17100
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x256d4
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x55972
leaq 0x8(%rsp), %rdi
movl $0x2f, %esi
callq 0x17c70
movq 0x8(%rsp), %rax
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
cmpq %r14, %rax
je 0x55996
movq %rax, 0x68(%rsp)
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0x559aa
movq 0x10(%rsp), %r13
leaq 0x1(%r13), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x170b0
leaq 0x68(%rsp), %r12
movq %r13, 0x8(%r12)
movq %r14, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x175e0
movq (%r12), %rdi
cmpq %r15, %rdi
je 0x559ea
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x17100
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x55a01
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17100
leaq 0xd264(%rip), %rsi # 0x62c6c
leaq 0x28(%rsp), %rdi
callq 0x17740
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x256d4
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x55a57
leaq 0x48(%rsp), %rdi
movl $0x2f, %esi
callq 0x17c70
movq 0x48(%rsp), %rax
leaq 0x10(%rbx), %rdi
movq %rdi, (%rbx)
cmpq %r14, %rax
je 0x55a76
movq %rax, (%rbx)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rbx)
movq 0x50(%rsp), %r15
jmp 0x55a87
movq 0x50(%rsp), %r15
leaq 0x1(%r15), %rdx
movq %r14, %rsi
callq 0x170b0
movq %r15, 0x8(%rbx)
movq %r14, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movb $0x0, 0x58(%rsp)
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x55ab5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x17100
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r12, %rdi
je 0x55b1b
movq 0x98(%rsp), %rsi
jmp 0x55b0e
jmp 0x55b18
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x55b1b
movq 0x18(%rsp), %rsi
jmp 0x55b0e
jmp 0x55b18
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x55b1b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x17100
jmp 0x55b1b
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x55b32
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x17100
movq %rbx, %rdi
callq 0x17710
| _Z22fs_get_cache_directoryB5cxx11v:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov rbx, rdi
lea rbp, [rsp+0D8h+var_A0]
mov [rbp-10h], rbp
lea rdx, aNoteDebugGramm+0CAh; ""
lea rdi, [rsp+0D8h+var_B0]
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_557F2
mov r14, rax
lea r15, [rsp+0D8h+var_B0]
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_55A12
loc_557F2:
lea rdi, aXdgCacheHome; "XDG_CACHE_HOME"
call _getenv
test rax, rax
jz short loc_5582F
mov r14, rax
lea r15, [rsp+0D8h+var_B0]
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_5592D
loc_5582F:
lea rdi, aXdgCacheHome+0Ah; "HOME"
call _getenv
mov r14, rax
lea r12, [rsp+0D8h+var_40]
mov [r12-10h], r12
lea rsi, aCache; "/.cache/"
lea rdx, aCache+8; ""
lea rdi, [rsp+0D8h+var_50]
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+0D8h+var_50]
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)
mov r15, rax
lea r14, [rsp+0D8h+var_60]
mov [r14-10h], r14
mov rax, [rax]
mov r12, r15
add r12, 10h
cmp rax, r12
jz short loc_558B4
mov [rsp+0D8h+var_70], rax
mov rax, [r15+10h]
mov [rsp+0D8h+var_60], rax
mov rbp, [r15+8]
jmp short loc_558C7
loc_558B4:
mov rbp, [r15+8]
lea rdx, [rbp+1]
mov rdi, r14
mov rsi, r12
call _memcpy
loc_558C7:
lea r13, [rsp+0D8h+var_70]
mov [r13+8], rbp
mov [r15], r12
mov qword ptr [r15+8], 0
mov byte ptr [r15+10h], 0
lea rdi, [rsp+0D8h+var_B0]
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r13+0]; void *
cmp rdi, r14
jz short loc_55903
mov rsi, [rsp+0D8h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_55903:
mov rdi, [rsp+0D8h+var_50]; void *
lea rax, [rsp+0D8h+var_40]
cmp rdi, rax
lea rbp, [rsp+0D8h+var_A0]
jz short loc_5592D
mov rsi, [rsp+0D8h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5592D:
lea r14, [rsp+0D8h+var_C0]
mov [r14-10h], r14
mov rsi, [rsp+0D8h+var_B0]
mov rdx, [rsp+0D8h+var_A8]
add rdx, rsi
lea rdi, [rsp+0D8h+var_D0]
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+0D8h+var_D0]
mov rcx, [rsp+0D8h+var_C8]
cmp byte ptr [rax+rcx-1], 2Fh ; '/'
jz short loc_55972
lea rdi, [rsp+0D8h+var_D0]
mov esi, 2Fh ; '/'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rax, [rsp+0D8h+var_D0]
loc_55972:
lea r15, [rsp+0D8h+var_60]
mov [r15-10h], r15
cmp rax, r14
jz short loc_55996
mov [rsp+0D8h+var_70], rax
mov r13, [rsp+0D8h+var_C8]
mov rax, [rsp+0D8h+var_C0]
mov [rsp+0D8h+var_60], rax
jmp short loc_559AA
loc_55996:
mov r13, [rsp+0D8h+var_C8]
lea rdx, [r13+1]
mov rdi, r15
mov rsi, r14
call _memcpy
loc_559AA:
lea r12, [rsp+0D8h+var_70]
mov [r12+8], r13
mov [rsp+0D8h+var_D0], r14
mov [rsp+0D8h+var_C8], 0
mov byte ptr [rsp+0D8h+var_C0], 0
lea rdi, [rsp+0D8h+var_B0]
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r12]; void *
cmp rdi, r15
jz short loc_559EA
mov rsi, [rsp+0D8h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_559EA:
mov rdi, [rsp+0D8h+var_D0]; void *
cmp rdi, r14
jz short loc_55A01
mov rsi, [rsp+0D8h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_55A01:
lea rsi, aLlamaCpp; "llama.cpp"
lea rdi, [rsp+0D8h+var_B0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
loc_55A12:
lea r14, [rsp+0D8h+var_80]
mov [r14-10h], r14
mov rsi, [rsp+0D8h+var_B0]
mov rdx, [rsp+0D8h+var_A8]
add rdx, rsi
lea rdi, [rsp+0D8h+var_90]
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+0D8h+var_90]
mov rcx, [rsp+0D8h+var_88]
cmp byte ptr [rax+rcx-1], 2Fh ; '/'
jz short loc_55A57
lea rdi, [rsp+0D8h+var_90]
mov esi, 2Fh ; '/'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rax, [rsp+0D8h+var_90]
loc_55A57:
lea rdi, [rbx+10h]
mov [rbx], rdi
cmp rax, r14
jz short loc_55A76
mov [rbx], rax
mov rax, [rsp+0D8h+var_80]
mov [rbx+10h], rax
mov r15, [rsp+0D8h+var_88]
jmp short loc_55A87
loc_55A76:
mov r15, [rsp+0D8h+var_88]
lea rdx, [r15+1]
mov rsi, r14
call _memcpy
loc_55A87:
mov [rbx+8], r15
mov [rsp+0D8h+var_90], r14
mov [rsp+0D8h+var_88], 0
mov byte ptr [rsp+0D8h+var_80], 0
mov rdi, [rsp+0D8h+var_B0]; void *
cmp rdi, rbp
jz short loc_55AB5
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_55AB5:
mov rax, rbx
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_80]
cmp rdi, r12
jz short loc_55B1B
mov rsi, [rsp+arg_90]
jmp short loc_55B0E
jmp short loc_55B18
mov rbx, rax
mov rdi, [rsp+arg_0]
cmp rdi, r14
jz short loc_55B1B
mov rsi, [rsp+arg_10]
jmp short loc_55B0E
jmp short loc_55B18
mov rbx, rax
mov rdi, [rsp+arg_40]; void *
cmp rdi, r14
jz short loc_55B1B
mov rsi, [rsp+arg_50]
loc_55B0E:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_55B1B
loc_55B18:
mov rbx, rax
loc_55B1B:
mov rdi, [rsp+arg_20]; void *
cmp rdi, rbp
jz short loc_55B32
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_55B32:
mov rdi, rbx
call __Unwind_Resume
| _QWORD * fs_get_cache_directory[abi:cxx11](_QWORD *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; // r15
long long v11; // rbp
_QWORD *v12; // rax
long long v13; // r13
_QWORD *v14; // rax
long long v15; // r15
void *v17; // [rsp+8h] [rbp-D0h] BYREF
long long v18; // [rsp+10h] [rbp-C8h]
_QWORD v19[2]; // [rsp+18h] [rbp-C0h] BYREF
void *v20; // [rsp+28h] [rbp-B0h] BYREF
long long v21; // [rsp+30h] [rbp-A8h]
_QWORD v22[2]; // [rsp+38h] [rbp-A0h] BYREF
_QWORD *v23; // [rsp+48h] [rbp-90h] BYREF
long long v24; // [rsp+50h] [rbp-88h]
_QWORD v25[2]; // [rsp+58h] [rbp-80h] BYREF
_QWORD *v26; // [rsp+68h] [rbp-70h] BYREF
long long v27; // [rsp+70h] [rbp-68h]
_QWORD v28[2]; // [rsp+78h] [rbp-60h] BYREF
void *v29[2]; // [rsp+88h] [rbp-50h] BYREF
_QWORD v30[8]; // [rsp+98h] [rbp-40h] BYREF
v20 = v22;
std::string::_M_construct<char const*>((long long)&v20, "", (long long)"");
v1 = getenv("LLAMA_CACHE", "");
if ( v1 )
{
v2 = v1;
v3 = v21;
v4 = strlen(v1);
std::string::_M_replace(&v20, 0LL, v3, v2, v4);
}
else
{
v5 = getenv("XDG_CACHE_HOME", "");
if ( v5 )
{
v6 = v5;
v7 = v21;
v8 = strlen(v5);
std::string::_M_replace(&v20, 0LL, v7, v6, v8);
}
else
{
v9 = getenv("HOME", "");
v29[0] = v30;
std::string::_M_construct<char const*>((long long)v29, "/.cache/", (long long)"");
strlen(v9);
v10 = std::string::replace(v29, 0LL, 0LL);
v26 = v28;
if ( *(_QWORD *)v10 == v10 + 16 )
{
v11 = *(_QWORD *)(v10 + 8);
memcpy(v28, v10 + 16, v11 + 1);
}
else
{
v26 = *(_QWORD **)v10;
v28[0] = *(_QWORD *)(v10 + 16);
v11 = *(_QWORD *)(v10 + 8);
}
v27 = v11;
*(_QWORD *)v10 = v10 + 16;
*(_QWORD *)(v10 + 8) = 0LL;
*(_BYTE *)(v10 + 16) = 0;
std::string::operator=(&v20, &v26);
if ( v26 != v28 )
operator delete(v26, v28[0] + 1LL);
if ( v29[0] != v30 )
operator delete(v29[0], v30[0] + 1LL);
}
v17 = v19;
std::string::_M_construct<char *>((long long)&v17, v20, (long long)v20 + v21);
v12 = v17;
if ( *((char *)v17 + v18 - 1) != 47 )
{
std::string::push_back(&v17, 47LL);
v12 = v17;
}
v26 = v28;
if ( v12 == v19 )
{
v13 = v18;
memcpy(v28, v19, v18 + 1);
}
else
{
v26 = v12;
v13 = v18;
v28[0] = v19[0];
}
v27 = v13;
v17 = v19;
v18 = 0LL;
LOBYTE(v19[0]) = 0;
std::string::operator=(&v20, &v26);
if ( v26 != v28 )
operator delete(v26, v28[0] + 1LL);
if ( v17 != v19 )
operator delete(v17, v19[0] + 1LL);
std::string::append(&v20, "llama.cpp");
}
v23 = v25;
std::string::_M_construct<char *>((long long)&v23, v20, (long long)v20 + v21);
v14 = v23;
if ( *((_BYTE *)v23 + v24 - 1) != 47 )
{
std::string::push_back(&v23, 47LL);
v14 = v23;
}
*a1 = a1 + 2;
if ( v14 == v25 )
{
v15 = v24;
memcpy(a1 + 2, v25, v24 + 1);
}
else
{
*a1 = v14;
a1[2] = v25[0];
v15 = v24;
}
a1[1] = v15;
v23 = v25;
v24 = 0LL;
LOBYTE(v25[0]) = 0;
if ( v20 != v22 )
operator delete(v20, v22[0] + 1LL);
return a1;
}
| fs_get_cache_directory[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV RBX,RDI
LEA RBP,[RSP + 0x38]
MOV qword ptr [RBP + -0x10],RBP
LEA RDX,[0x15bc4c]
LEA RDI,[RSP + 0x28]
MOV RSI,RDX
CALL 0x0012fb78
LEA RDI,[0x162c48]
CALL 0x00117840
TEST RAX,RAX
JZ 0x001557f2
MOV R14,RAX
LEA R15,[RSP + 0x28]
MOV R12,qword ptr [R15 + 0x8]
MOV RDI,RAX
CALL 0x00117430
LAB_001557da:
MOV RDI,R15
XOR ESI,ESI
MOV RDX,R12
MOV RCX,R14
MOV R8,RAX
CALL 0x00117580
JMP 0x00155a12
LAB_001557f2:
LEA RDI,[0x162c54]
CALL 0x00117840
TEST RAX,RAX
JZ 0x0015582f
MOV R14,RAX
LEA R15,[RSP + 0x28]
MOV R12,qword ptr [R15 + 0x8]
MOV RDI,RAX
CALL 0x00117430
MOV RDI,R15
XOR ESI,ESI
MOV RDX,R12
MOV RCX,R14
MOV R8,RAX
CALL 0x00117580
JMP 0x0015592d
LAB_0015582f:
LEA RDI,[0x162c5e]
CALL 0x00117840
MOV R14,RAX
LEA R12,[RSP + 0x98]
MOV qword ptr [R12 + -0x10],R12
LAB_0015584b:
LEA RSI,[0x162c63]
LEA RDX,[0x162c6b]
LEA RDI,[RSP + 0x88]
CALL 0x0012fb78
MOV RDI,R14
CALL 0x00117430
LAB_0015586e:
LEA RDI,[RSP + 0x88]
XOR ESI,ESI
XOR EDX,EDX
MOV RCX,R14
MOV R8,RAX
CALL 0x00117170
LAB_00155885:
MOV R15,RAX
LEA R14,[RSP + 0x78]
MOV qword ptr [R14 + -0x10],R14
MOV RAX,qword ptr [RAX]
MOV R12,R15
ADD R12,0x10
CMP RAX,R12
JZ 0x001558b4
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x78],RAX
MOV RBP,qword ptr [R15 + 0x8]
JMP 0x001558c7
LAB_001558b4:
MOV RBP,qword ptr [R15 + 0x8]
LEA RDX,[RBP + 0x1]
MOV RDI,R14
MOV RSI,R12
CALL 0x001170b0
LAB_001558c7:
LEA R13,[RSP + 0x68]
MOV qword ptr [R13 + 0x8],RBP
MOV qword ptr [R15],R12
MOV qword ptr [R15 + 0x8],0x0
MOV byte ptr [R15 + 0x10],0x0
LEA RDI,[RSP + 0x28]
MOV RSI,R13
CALL 0x001175e0
MOV RDI,qword ptr [R13]
CMP RDI,R14
JZ 0x00155903
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x00117100
LAB_00155903:
MOV RDI,qword ptr [RSP + 0x88]
LEA RAX,[RSP + 0x98]
CMP RDI,RAX
LEA RBP,[RSP + 0x38]
JZ 0x0015592d
MOV RSI,qword ptr [RSP + 0x98]
INC RSI
CALL 0x00117100
LAB_0015592d:
LEA R14,[RSP + 0x18]
MOV qword ptr [R14 + -0x10],R14
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
ADD RDX,RSI
LAB_00155943:
LEA RDI,[RSP + 0x8]
CALL 0x001256d4
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x10]
CMP byte ptr [RAX + RCX*0x1 + -0x1],0x2f
JZ 0x00155972
LAB_0015595e:
LEA RDI,[RSP + 0x8]
MOV ESI,0x2f
CALL 0x00117c70
LAB_0015596d:
MOV RAX,qword ptr [RSP + 0x8]
LAB_00155972:
LEA R15,[RSP + 0x78]
MOV qword ptr [R15 + -0x10],R15
CMP RAX,R14
JZ 0x00155996
MOV qword ptr [RSP + 0x68],RAX
MOV R13,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x78],RAX
JMP 0x001559aa
LAB_00155996:
MOV R13,qword ptr [RSP + 0x10]
LEA RDX,[R13 + 0x1]
MOV RDI,R15
MOV RSI,R14
CALL 0x001170b0
LAB_001559aa:
LEA R12,[RSP + 0x68]
MOV qword ptr [R12 + 0x8],R13
MOV qword ptr [RSP + 0x8],R14
MOV qword ptr [RSP + 0x10],0x0
MOV byte ptr [RSP + 0x18],0x0
LEA RDI,[RSP + 0x28]
MOV RSI,R12
CALL 0x001175e0
MOV RDI,qword ptr [R12]
CMP RDI,R15
JZ 0x001559ea
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x00117100
LAB_001559ea:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R14
JZ 0x00155a01
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00117100
LAB_00155a01:
LEA RSI,[0x162c6c]
LEA RDI,[RSP + 0x28]
CALL 0x00117740
LAB_00155a12:
LEA R14,[RSP + 0x58]
MOV qword ptr [R14 + -0x10],R14
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
ADD RDX,RSI
LEA RDI,[RSP + 0x48]
CALL 0x001256d4
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,qword ptr [RSP + 0x50]
CMP byte ptr [RAX + RCX*0x1 + -0x1],0x2f
JZ 0x00155a57
LAB_00155a43:
LEA RDI,[RSP + 0x48]
MOV ESI,0x2f
CALL 0x00117c70
LAB_00155a52:
MOV RAX,qword ptr [RSP + 0x48]
LAB_00155a57:
LEA RDI,[RBX + 0x10]
MOV qword ptr [RBX],RDI
CMP RAX,R14
JZ 0x00155a76
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RBX + 0x10],RAX
MOV R15,qword ptr [RSP + 0x50]
JMP 0x00155a87
LAB_00155a76:
MOV R15,qword ptr [RSP + 0x50]
LEA RDX,[R15 + 0x1]
MOV RSI,R14
CALL 0x001170b0
LAB_00155a87:
MOV qword ptr [RBX + 0x8],R15
MOV qword ptr [RSP + 0x48],R14
MOV qword ptr [RSP + 0x50],0x0
MOV byte ptr [RSP + 0x58],0x0
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,RBP
JZ 0x00155ab5
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x00117100
LAB_00155ab5:
MOV RAX,RBX
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
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;
int8 *puVar3;
long lVar4;
int8 *in_RDI;
long *__src;
long *local_d0;
long local_c8;
int1 local_c0;
int7 uStack_bf;
long *local_b0;
char *local_a8;
long local_a0 [2];
int1 *local_90;
long local_88;
int1 local_80;
int7 uStack_7f;
long *local_70;
long local_68;
long local_60 [2];
long *local_50 [2];
long local_40 [2];
local_b0 = local_a0;
std::__cxx11::string::_M_construct<char_const*>(&local_b0);
pcVar1 = getenv("LLAMA_CACHE");
pcVar2 = local_a8;
if (pcVar1 == (char *)0x0) {
pcVar1 = getenv("XDG_CACHE_HOME");
pcVar2 = local_a8;
if (pcVar1 == (char *)0x0) {
pcVar2 = getenv("HOME");
local_50[0] = local_40;
/* try { // try from 0015584b to 00155865 has its CatchHandler @ 00155ae4 */
std::__cxx11::string::_M_construct<char_const*>(local_50,"/.cache/","");
strlen(pcVar2);
/* try { // try from 0015586e to 00155884 has its CatchHandler @ 00155aca */
puVar3 = (int8 *)
std::__cxx11::string::replace((ulong)local_50,0,(char *)0x0,(ulong)pcVar2);
local_70 = (long *)*puVar3;
__src = puVar3 + 2;
if (local_70 == __src) {
lVar4 = puVar3[1];
local_70 = local_60;
memcpy(local_60,__src,lVar4 + 1);
}
else {
local_60[0] = puVar3[2];
lVar4 = puVar3[1];
}
*puVar3 = __src;
puVar3[1] = 0;
*(int1 *)(puVar3 + 2) = 0;
local_68 = lVar4;
std::__cxx11::string::operator=((string *)&local_b0,(string *)&local_70);
if (local_70 != local_60) {
operator_delete(local_70,local_60[0] + 1);
}
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
}
else {
strlen(pcVar1);
std::__cxx11::string::_M_replace((ulong)&local_b0,0,pcVar2,(ulong)pcVar1);
}
/* try { // try from 00155943 to 0015594c has its CatchHandler @ 00155afa */
local_d0 = (long *)&local_c0;
std::__cxx11::string::_M_construct<char*>(&local_d0,local_b0,local_a8 + (long)local_b0);
if (*(char *)((long)local_d0 + local_c8 + -1) != '/') {
/* try { // try from 0015595e to 0015596c has its CatchHandler @ 00155ae6 */
std::__cxx11::string::push_back((char)&local_d0);
}
if (local_d0 == (long *)&local_c0) {
local_70 = local_60;
memcpy(local_60,&local_c0,local_c8 + 1);
}
else {
local_70 = local_d0;
local_60[0] = CONCAT71(uStack_bf,local_c0);
}
local_68 = local_c8;
local_c8 = 0;
local_c0 = 0;
local_d0 = (long *)&local_c0;
std::__cxx11::string::operator=((string *)&local_b0,(string *)&local_70);
if (local_70 != local_60) {
operator_delete(local_70,local_60[0] + 1);
}
if (local_d0 != (long *)&local_c0) {
operator_delete(local_d0,CONCAT71(uStack_bf,local_c0) + 1);
}
/* try { // try from 00155a01 to 00155a31 has its CatchHandler @ 00155b18 */
std::__cxx11::string::append((char *)&local_b0);
}
else {
strlen(pcVar1);
/* try { // try from 001557da to 00155829 has its CatchHandler @ 00155b18 */
std::__cxx11::string::_M_replace((ulong)&local_b0,0,pcVar2,(ulong)pcVar1);
}
local_90 = &local_80;
std::__cxx11::string::_M_construct<char*>(&local_90,local_b0,local_a8 + (long)local_b0);
if (local_90[local_88 + -1] != '/') {
/* try { // try from 00155a43 to 00155a51 has its CatchHandler @ 00155afc */
std::__cxx11::string::push_back((char)&local_90);
}
*in_RDI = in_RDI + 2;
if (local_90 == &local_80) {
memcpy(in_RDI + 2,&local_80,local_88 + 1);
}
else {
*in_RDI = local_90;
in_RDI[2] = CONCAT71(uStack_7f,local_80);
}
in_RDI[1] = local_88;
local_88 = 0;
local_80 = 0;
if (local_b0 != local_a0) {
local_90 = &local_80;
operator_delete(local_b0,local_a0[0] + 1);
}
return;
}
| |
28,402 | check_mb_euckr | eloqsql/libmariadb/libmariadb/ma_charset.c | static unsigned int check_mb_euckr(const char *start, const char *end)
{
if (end - start <= 1) {
return 0; /* invalid length */
}
if (*(uchar *)start < 0x80) {
return 0; /* invalid euckr character */
}
if (valid_euckr(start[1])) {
return 2;
}
return 0;
} | O3 | c | check_mb_euckr:
pushq %rbp
movq %rsp, %rbp
subq %rdi, %rsi
xorl %eax, %eax
cmpq $0x2, %rsi
jl 0x34dbb
cmpb $0x0, (%rdi)
jns 0x34dbb
movb 0x1(%rdi), %cl
incb %cl
xorl %eax, %eax
cmpb $-0x5e, %cl
setae %al
addl %eax, %eax
popq %rbp
retq
| check_mb_euckr:
push rbp
mov rbp, rsp
sub rsi, rdi
xor eax, eax
cmp rsi, 2
jl short loc_34DBB
cmp byte ptr [rdi], 0
jns short loc_34DBB
mov cl, [rdi+1]
inc cl
xor eax, eax
cmp cl, 0A2h
setnb al
add eax, eax
loc_34DBB:
pop rbp
retn
| long long check_mb_euckr(char *a1, long long a2)
{
long long result; // rax
result = 0LL;
if ( a2 - (long long)a1 >= 2 && *a1 < 0 )
return 2 * (unsigned int)((unsigned __int8)(a1[1] + 1) >= 0xA2u);
return result;
}
| check_mb_euckr:
PUSH RBP
MOV RBP,RSP
SUB RSI,RDI
XOR EAX,EAX
CMP RSI,0x2
JL 0x00134dbb
CMP byte ptr [RDI],0x0
JNS 0x00134dbb
MOV CL,byte ptr [RDI + 0x1]
INC CL
XOR EAX,EAX
CMP CL,0xa2
SETNC AL
ADD EAX,EAX
LAB_00134dbb:
POP RBP
RET
|
char check_mb_euckr(char *param_1,long param_2)
{
char cVar1;
cVar1 = '\0';
if ((1 < param_2 - (long)param_1) && (*param_1 < '\0')) {
cVar1 = (0xa1 < (byte)(param_1[1] + 1U)) * '\x02';
}
return cVar1;
}
| |
28,403 | translog_flush_wait_for_end | eloqsql/storage/maria/ma_loghandler.c | void translog_flush_wait_for_end(LSN lsn)
{
DBUG_ENTER("translog_flush_wait_for_end");
DBUG_PRINT("enter", ("LSN: " LSN_FMT, LSN_IN_PARTS(lsn)));
mysql_mutex_assert_owner(&log_descriptor.log_flush_lock);
while (cmp_translog_addr(log_descriptor.flushed, lsn) < 0)
mysql_cond_wait(&log_descriptor.log_flush_cond,
&log_descriptor.log_flush_lock);
DBUG_VOID_RETURN;
} | O0 | c | translog_flush_wait_for_end:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x55eae
jmp 0x55eb0
jmp 0x55eb2
jmp 0x55eb4
movq 0xc2419d(%rip), %rax # 0xc7a058
subq -0x8(%rbp), %rax
cmpq $0x0, %rax
jge 0x55ef0
leaq 0x4234f4(%rip), %rsi # 0x4793c0
movq %rsi, %rdi
addq $0x800d50, %rdi # imm = 0x800D50
addq $0x800d08, %rsi # imm = 0x800D08
leaq 0xfbdf3(%rip), %rdx # 0x151cd7
movl $0x1e91, %ecx # imm = 0x1E91
callq 0x50080
jmp 0x55eb4
jmp 0x55ef2
jmp 0x55ef4
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| translog_flush_wait_for_end:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_55EAE:
jmp short $+2
loc_55EB0:
jmp short $+2
loc_55EB2:
jmp short $+2
loc_55EB4:
mov rax, cs:qword_C7A058
sub rax, [rbp+var_8]
cmp rax, 0
jge short loc_55EF0
lea rsi, log_descriptor
mov rdi, rsi
add rdi, 800D50h
add rsi, 800D08h
lea rdx, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1E91h
call inline_mysql_cond_wait_1
jmp short loc_55EB4
loc_55EF0:
jmp short $+2
loc_55EF2:
jmp short $+2
loc_55EF4:
add rsp, 10h
pop rbp
retn
| long long translog_flush_wait_for_end(long long a1)
{
long long result; // rax
while ( 1 )
{
result = qword_C7A058 - a1;
if ( qword_C7A058 - a1 >= 0 )
break;
inline_mysql_cond_wait_1(
(long long)&log_descriptor[1049002],
(long long)&log_descriptor[1048993],
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x1E91u);
}
return result;
}
| translog_flush_wait_for_end:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x00155eae
LAB_00155eae:
JMP 0x00155eb0
LAB_00155eb0:
JMP 0x00155eb2
LAB_00155eb2:
JMP 0x00155eb4
LAB_00155eb4:
MOV RAX,qword ptr [0x00d7a058]
SUB RAX,qword ptr [RBP + -0x8]
CMP RAX,0x0
JGE 0x00155ef0
LEA RSI,[0x5793c0]
MOV RDI,RSI
ADD RDI,0x800d50
ADD RSI,0x800d08
LEA RDX,[0x251cd7]
MOV ECX,0x1e91
CALL 0x00150080
JMP 0x00155eb4
LAB_00155ef0:
JMP 0x00155ef2
LAB_00155ef2:
JMP 0x00155ef4
LAB_00155ef4:
ADD RSP,0x10
POP RBP
RET
|
void translog_flush_wait_for_end(long param_1)
{
while (DAT_00d7a058 - param_1 < 0) {
inline_mysql_cond_wait
(&DAT_00d7a110,&DAT_00d7a0c8,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",0x1e91);
}
return;
}
| |
28,404 | my_interval_timer | eloqsql/mysys/my_getsystime.c | ulonglong my_interval_timer()
{
#ifdef HAVE_CLOCK_GETTIME
struct timespec tp;
clock_gettime(CLOCK_MONOTONIC, &tp);
return tp.tv_sec*1000000000ULL+tp.tv_nsec;
#elif defined(HAVE_GETHRTIME)
return gethrtime();
#elif defined(_WIN32)
DBUG_ASSERT(query_performance_frequency);
LARGE_INTEGER t_cnt;
QueryPerformanceCounter(&t_cnt);
return (t_cnt.QuadPart / query_performance_frequency * 1000000000ULL) +
((t_cnt.QuadPart % query_performance_frequency) * 1000000000ULL /
query_performance_frequency);
#else
/* TODO: check for other possibilities for hi-res timestamping */
struct timeval tv;
gettimeofday(&tv,NULL);
return tv.tv_sec*1000000000ULL+tv.tv_usec*1000ULL;
#endif
} | O0 | c | my_interval_timer:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
leaq -0x10(%rbp), %rsi
callq 0x262d0
imulq $0x3b9aca00, -0x10(%rbp), %rax # imm = 0x3B9ACA00
addq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_interval_timer:
push rbp
mov rbp, rsp
sub rsp, 10h
mov edi, 1
lea rsi, [rbp+var_10]
call _clock_gettime
imul rax, [rbp+var_10], 3B9ACA00h
add rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
| long long my_interval_timer()
{
_QWORD v1[2]; // [rsp+0h] [rbp-10h] BYREF
clock_gettime(1LL, v1);
return v1[1] + 1000000000LL * v1[0];
}
| my_interval_timer:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV EDI,0x1
LEA RSI,[RBP + -0x10]
CALL 0x001262d0
IMUL RAX,qword ptr [RBP + -0x10],0x3b9aca00
ADD RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
long my_interval_timer(void)
{
timespec local_18;
clock_gettime(1,&local_18);
return local_18.tv_sec * 1000000000 + local_18.tv_nsec;
}
| |
28,405 | testing::internal::BriefUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&) | AlayaLite/build_O3/_deps/googletest-src/googletest/src/gtest.cc | void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
if (test_info.result()->Failed()) {
ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
PrintTestName(test_info.test_suite_name(), test_info.name());
PrintFullTestCommentIfPresent(test_info);
if (GTEST_FLAG_GET(print_time)) {
printf(" (%s ms)\n",
internal::StreamableToString(test_info.result()->elapsed_time())
.c_str());
} else {
printf("\n");
}
fflush(stdout);
}
} | O3 | cpp | testing::internal::BriefUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&):
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %rdi
callq 0x61960
testb %al, %al
je 0x651b3
leaq 0x223de(%rip), %rsi # 0x874f5
movl $0x1, %edi
xorl %eax, %eax
callq 0x63bb9
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x2240a(%rip), %rdi # 0x8753b
xorl %eax, %eax
callq 0x11080
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rsi
callq 0x6471f
leaq 0x4f9dd(%rip), %rax # 0xb4b29
cmpb $0x1, (%rax)
jne 0x6519a
movq 0x108(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x762d8
movq (%rbx), %rsi
leaq 0x2238c(%rip), %rdi # 0x87503
xorl %eax, %eax
callq 0x11080
movq (%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x651a4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11120
jmp 0x651a4
movl $0xa, %edi
callq 0x11d80
movq 0x4edb5(%rip), %rax # 0xb3f60
movq (%rax), %rdi
callq 0x11610
addq $0x30, %rsp
popq %rbx
retq
nop
| _ZN7testing8internal26BriefUnitTestResultPrinter9OnTestEndERKNS_8TestInfoE:
push rbx
sub rsp, 30h
mov rbx, rsi
lea rdi, [rsi+90h]; this
call _ZNK7testing10TestResult6FailedEv; testing::TestResult::Failed(void)
test al, al
jz loc_651B3
lea rsi, aFailed_0; "[ FAILED ] "
mov edi, 1
xor eax, eax
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
mov rsi, [rbx]
mov rdx, [rbx+20h]
lea rdi, aSS_0; "%s.%s"
xor eax, eax
call _printf
mov rdi, [rbx+40h]
mov rsi, [rbx+48h]
call _ZN7testing8internalL29PrintFullTestCommentIfPresentERKNS_8TestInfoE; testing::internal::PrintFullTestCommentIfPresent(testing::TestInfo const&)
lea rax, _ZN7testing22FLAGS_gtest_print_timeE; testing::FLAGS_gtest_print_time
cmp byte ptr [rax], 1
jnz short loc_6519A
mov rax, [rbx+108h]
lea rsi, [rsp+38h+var_30]
mov [rsi], rax
lea rbx, [rsp+38h+var_28]
mov rdi, rbx
call _ZN7testing8internal18StreamableToStringIlEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::internal::StreamableToString<long>(long const&)
mov rsi, [rbx]
lea rdi, aSMs; " (%s ms)\n"
xor eax, eax
call _printf
mov rdi, [rbx]; void *
lea rax, [rsp+38h+var_18]
cmp rdi, rax
jz short loc_651A4
mov rsi, [rsp+38h+var_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_651A4
loc_6519A:
mov edi, 0Ah
call _putchar
loc_651A4:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
loc_651B3:
add rsp, 30h
pop rbx
retn
| char testing::internal::BriefUnitTestResultPrinter::OnTestEnd(
testing::internal::BriefUnitTestResultPrinter *this,
const char **a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
char result; // al
long long v11; // rdx
long long v12; // rcx
long long v13; // r8
long long v14; // r9
__m128 v15; // xmm4
__m128 v16; // xmm5
int v17; // edx
int v18; // ecx
int v19; // r8d
int v20; // r9d
char v21; // [rsp+0h] [rbp-38h]
long long v22; // [rsp+0h] [rbp-38h]
const char *v23; // [rsp+8h] [rbp-30h] BYREF
char *v24; // [rsp+10h] [rbp-28h] BYREF
long long v25; // [rsp+20h] [rbp-18h] BYREF
result = testing::TestResult::Failed((testing::TestResult *)(a2 + 18));
if ( result )
{
testing::internal::ColoredPrintf(
1,
(long long)"[ FAILED ] ",
v11,
v12,
v13,
v14,
a3,
a4,
a5,
a6,
v15,
v16,
a9,
a10,
v21);
printf("%s.%s", *a2, a2[4]);
testing::internal::PrintFullTestCommentIfPresent((const char **)a2[8], (const char **)a2[9]);
if ( testing::FLAGS_gtest_print_time == 1 )
{
v23 = a2[33];
testing::internal::StreamableToString<long>((unsigned int)&v24, (unsigned int)&v23, v17, v18, v19, v20, v22);
printf(" (%s ms)\n", v24);
if ( v24 != (char *)&v25 )
operator delete(v24, v25 + 1);
}
else
{
putchar(10LL);
}
return fflush(stdout);
}
return result;
}
| OnTestEnd:
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
LEA RDI,[RSI + 0x90]
CALL 0x00161960
TEST AL,AL
JZ 0x001651b3
LEA RSI,[0x1874f5]
MOV EDI,0x1
XOR EAX,EAX
CALL 0x00163bb9
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x20]
LEA RDI,[0x18753b]
XOR EAX,EAX
CALL 0x00111080
MOV RDI,qword ptr [RBX + 0x40]
MOV RSI,qword ptr [RBX + 0x48]
CALL 0x0016471f
LEA RAX,[0x1b4b29]
CMP byte ptr [RAX],0x1
JNZ 0x0016519a
MOV RAX,qword ptr [RBX + 0x108]
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RAX
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
CALL 0x001762d8
MOV RSI,qword ptr [RBX]
LEA RDI,[0x187503]
XOR EAX,EAX
CALL 0x00111080
MOV RDI,qword ptr [RBX]
LEA RAX,[RSP + 0x20]
CMP RDI,RAX
JZ 0x001651a4
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x00111120
JMP 0x001651a4
LAB_0016519a:
MOV EDI,0xa
CALL 0x00111d80
LAB_001651a4:
MOV RAX,qword ptr [0x001b3f60]
MOV RDI,qword ptr [RAX]
CALL 0x00111610
LAB_001651b3:
ADD RSP,0x30
POP RBX
RET
|
/* testing::internal::BriefUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&) */
void __thiscall
testing::internal::BriefUnitTestResultPrinter::OnTestEnd
(BriefUnitTestResultPrinter *this,TestInfo *param_1)
{
char cVar1;
long *local_28 [2];
long local_18 [2];
cVar1 = TestResult::Failed((TestResult *)(param_1 + 0x90));
if (cVar1 != '\0') {
ColoredPrintf(1,"[ FAILED ] ");
printf("%s.%s",*(int8 *)param_1,*(int8 *)(param_1 + 0x20));
PrintFullTestCommentIfPresent(*(internal **)(param_1 + 0x40),*(TestInfo **)(param_1 + 0x48));
if (FLAGS_gtest_print_time == '\x01') {
StreamableToString<long>((long *)local_28);
printf(" (%s ms)\n",local_28[0]);
if (local_28[0] != local_18) {
operator_delete(local_28[0],local_18[0] + 1);
}
}
else {
putchar(10);
}
fflush(*(FILE **)PTR_stdout_001b3f60);
}
return;
}
| |
28,406 | nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::~serializer() | monkey531[P]llama/common/./json.hpp | ~serializer() = default; | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::~serializer():
pushq %rbx
movq %rdi, %rbx
movq 0x260(%rdi), %rdi
leaq 0x270(%rbx), %rax
cmpq %rax, %rdi
je 0x68238
movq (%rax), %rsi
incq %rsi
callq 0x186a0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x68247
popq %rbx
jmp 0x30e64
popq %rbx
retq
nop
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEED2Ev:
push rbx
mov rbx, rdi
mov rdi, [rdi+260h]; void *
lea rax, [rbx+270h]
cmp rdi, rax
jz short loc_68238
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_68238:
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_68247
pop rbx
jmp _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_68247:
pop rbx
retn
| void nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~serializer(
_QWORD *a1)
{
_QWORD *v2; // rdi
volatile signed __int32 *v3; // rdi
v2 = (_QWORD *)a1[76];
if ( v2 != a1 + 78 )
operator delete(v2, a1[78] + 1LL);
v3 = (volatile signed __int32 *)a1[1];
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
}
| ~serializer:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x260]
LEA RAX,[RBX + 0x270]
CMP RDI,RAX
JZ 0x00168238
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x001186a0
LAB_00168238:
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x00168247
POP RBX
JMP 0x00130e64
LAB_00168247:
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::~serializer() */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::~serializer(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
if (*(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
**)(this + 0x260) != this + 0x270) {
operator_delete(*(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
**)(this + 0x260),*(long *)(this + 0x270) + 1);
}
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 8) !=
(_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 + 8));
return;
}
return;
}
| |
28,407 | 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, 0x3b7baf(%rip) # 0x3ff420
je 0x4792b
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x3b7e73(%rip), %rbx # 0x3ff6f8
testq %rbx, %rbx
je 0x478d0
leaq 0x34082f(%rip), %r14 # 0x3880c0
movq 0x68(%rbx), %rax
movq %rax, 0x3b7e5c(%rip) # 0x3ff6f8
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x478b3
movq (%r14), %rax
callq *0x48(%rax)
movq $0x0, 0x50(%rbx)
leaq 0x10(%rbx), %rdi
callq 0x290c0
movq %rbx, %rdi
callq 0xa0eba
movq 0x3b7e2d(%rip), %rbx # 0x3ff6f8
testq %rbx, %rbx
jne 0x47891
leaq 0x3b7e31(%rip), %rdi # 0x3ff708
callq 0xa6c02
movq 0x3b7f2d(%rip), %rdi # 0x3ff810
testq %rdi, %rdi
je 0x47900
leaq 0x3407d1(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x3b7f10(%rip) # 0x3ff810
leaq 0x3b7ec9(%rip), %rdi # 0x3ff7d0
callq 0x290c0
movq 0x3b7b0d(%rip), %rdi # 0x3ff420
addq $0x8, %rdi
callq 0xa0eba
movq $0x0, 0x3b7af9(%rip) # 0x3ff420
popq %rbx
popq %r14
popq %rbp
retq
| trnman_destroy:
cmp cs:short_trid_to_active_trn, 0
jz locret_4792B
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, cs:pool
test rbx, rbx
jz short loc_478D0
lea r14, PSI_server
loc_47891:
mov rax, [rbx+68h]
mov cs:pool, rax
mov rdi, [rbx+50h]
test rdi, rdi
jz short loc_478B3
mov rax, [r14]
call qword ptr [rax+48h]
mov qword ptr [rbx+50h], 0
loc_478B3:
lea rdi, [rbx+10h]
call _pthread_mutex_destroy
mov rdi, rbx
call my_free
mov rbx, cs:pool
test rbx, rbx
jnz short loc_47891
loc_478D0:
lea rdi, trid_to_trn
call lf_hash_destroy
mov rdi, cs:qword_3FF810
test rdi, rdi
jz short loc_47900
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov cs:qword_3FF810, 0
loc_47900:
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_4792B:
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_3FF810 )
{
PSI_server[9]();
qword_3FF810 = 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 [0x004ff420],0x0
JZ 0x0014792b
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,qword ptr [0x004ff6f8]
TEST RBX,RBX
JZ 0x001478d0
LEA R14,[0x4880c0]
LAB_00147891:
MOV RAX,qword ptr [RBX + 0x68]
MOV qword ptr [0x004ff6f8],RAX
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JZ 0x001478b3
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x50],0x0
LAB_001478b3:
LEA RDI,[RBX + 0x10]
CALL 0x001290c0
MOV RDI,RBX
CALL 0x001a0eba
MOV RBX,qword ptr [0x004ff6f8]
TEST RBX,RBX
JNZ 0x00147891
LAB_001478d0:
LEA RDI,[0x4ff708]
CALL 0x001a6c02
MOV RDI,qword ptr [0x004ff810]
TEST RDI,RDI
JZ 0x00147900
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [0x004ff810],0x0
LAB_00147900:
LEA RDI,[0x4ff7d0]
CALL 0x001290c0
MOV RDI,qword ptr [0x004ff420]
ADD RDI,0x8
CALL 0x001a0eba
MOV qword ptr [0x004ff420],0x0
POP RBX
POP R14
POP RBP
LAB_0014792b:
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;
}
| |
28,408 | mysql_change_user | eloqsql/libmariadb/libmariadb/mariadb_lib.c | my_bool STDCALL mysql_change_user(MYSQL *mysql, const char *user,
const char *passwd, const char *db)
{
const MARIADB_CHARSET_INFO *s_cs= mysql->charset;
char *s_user= mysql->user,
*s_passwd= mysql->passwd,
*s_db= mysql->db;
int rc;
if (mysql->options.charset_name)
mysql->charset= mysql_find_charset_name(mysql->options.charset_name);
else
mysql->charset=mysql_find_charset_name(MARIADB_DEFAULT_CHARSET);
mysql->user= strdup(user ? user : "");
mysql->passwd= strdup(passwd ? passwd : "");
/* db will be set in run_plugin_auth */
mysql->db= 0;
rc= run_plugin_auth(mysql, 0, 0, 0, db);
/* COM_CHANGE_USER always releases prepared statements, so we need to invalidate them */
ma_invalidate_stmts(mysql, "mysql_change_user()");
if (rc==0)
{
free(s_user);
free(s_passwd);
free(s_db);
if (!mysql->db && db && !(mysql->db= strdup(db)))
{
SET_CLIENT_ERROR(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
rc= 1;
}
} else
{
free(mysql->user);
free(mysql->passwd);
free(mysql->db);
mysql->user= s_user;
mysql->passwd= s_passwd;
mysql->db= s_db;
mysql->charset= s_cs;
}
return(rc);
} | O0 | c | mysql_change_user:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x2f0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x2c0(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x2e8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x3f8(%rax)
je 0x41d02
movq -0x8(%rbp), %rax
movq 0x3f8(%rax), %rdi
callq 0x67e10
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2f0(%rax)
jmp 0x41d1c
leaq 0x882e2(%rip), %rdi # 0xc9feb
callq 0x67e10
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2f0(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x41d2d
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x41d3a
leaq 0x87e6d(%rip), %rax # 0xc9ba1
movq %rax, -0x50(%rbp)
jmp 0x41d3a
movq -0x50(%rbp), %rdi
callq 0x36030
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x41d62
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x41d6f
leaq 0x87e38(%rip), %rax # 0xc9ba1
movq %rax, -0x58(%rbp)
jmp 0x41d6f
movq -0x58(%rbp), %rdi
callq 0x36030
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2c0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x2e8(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
xorl %edx, %edx
movq %rcx, %rsi
callq 0x63750
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x882d3(%rip), %rsi # 0xca08c
callq 0x41aa0
cmpl $0x0, -0x44(%rbp)
jne 0x41e88
movq -0x30(%rbp), %rdi
callq 0x361a0
movq -0x38(%rbp), %rdi
callq 0x361a0
movq -0x40(%rbp), %rdi
callq 0x361a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2e8(%rax)
jne 0x41e86
cmpq $0x0, -0x20(%rbp)
je 0x41e86
movq -0x20(%rbp), %rdi
callq 0x36030
movq -0x8(%rbp), %rcx
movq %rax, 0x2e8(%rcx)
cmpq $0x0, %rax
jne 0x41e86
jmp 0x41e1c
movq -0x8(%rbp), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x8(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x1efdd4(%rip), %rax # 0x231c10
movq (%rax), %rsi
movl $0x5, %edx
callq 0x36140
movq -0x8(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x8(%rbp), %rdi
addq $0x97, %rdi
leaq 0x1efdba(%rip), %rax # 0x231c20
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x36140
movq -0x8(%rbp), %rax
movb $0x0, 0x296(%rax)
movl $0x1, -0x44(%rbp)
jmp 0x41ef4
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rdi
callq 0x361a0
movq -0x8(%rbp), %rax
movq 0x2c0(%rax), %rdi
callq 0x361a0
movq -0x8(%rbp), %rax
movq 0x2e8(%rax), %rdi
callq 0x361a0
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b8(%rax)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2c0(%rax)
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2e8(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2f0(%rax)
movl -0x44(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| mysql_change_user:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_8]
mov rax, [rax+2F0h]
mov [rbp+var_28], rax
mov rax, [rbp+var_8]
mov rax, [rax+2B8h]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov rax, [rax+2C0h]
mov [rbp+var_38], rax
mov rax, [rbp+var_8]
mov rax, [rax+2E8h]
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
cmp qword ptr [rax+3F8h], 0
jz short loc_41D02
mov rax, [rbp+var_8]
mov rdi, [rax+3F8h]
call mysql_find_charset_name
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+2F0h], rcx
jmp short loc_41D1C
loc_41D02:
lea rdi, aUtf8mb4; "utf8mb4"
call mysql_find_charset_name
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+2F0h], rcx
loc_41D1C:
cmp [rbp+var_10], 0
jz short loc_41D2D
mov rax, [rbp+var_10]
mov [rbp+var_50], rax
jmp short loc_41D3A
loc_41D2D:
lea rax, aURowSInSet_0+12h; ""
mov [rbp+var_50], rax
jmp short $+2
loc_41D3A:
mov rdi, [rbp+var_50]
call _strdup
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+2B8h], rcx
cmp [rbp+var_18], 0
jz short loc_41D62
mov rax, [rbp+var_18]
mov [rbp+var_58], rax
jmp short loc_41D6F
loc_41D62:
lea rax, aURowSInSet_0+12h; ""
mov [rbp+var_58], rax
jmp short $+2
loc_41D6F:
mov rdi, [rbp+var_58]
call _strdup
mov rcx, rax
mov rax, [rbp+var_8]
mov [rax+2C0h], rcx
mov rax, [rbp+var_8]
mov qword ptr [rax+2E8h], 0
mov rdi, [rbp+var_8]
mov r8, [rbp+var_20]
xor eax, eax
mov ecx, eax
xor edx, edx
mov rsi, rcx
call run_plugin_auth
mov [rbp+var_44], eax
mov rdi, [rbp+var_8]
lea rsi, aMysqlChangeUse; "mysql_change_user()"
call ma_invalidate_stmts
cmp [rbp+var_44], 0
jnz loc_41E88
mov rdi, [rbp+var_30]
call _free
mov rdi, [rbp+var_38]
call _free
mov rdi, [rbp+var_40]
call _free
mov rax, [rbp+var_8]
cmp qword ptr [rax+2E8h], 0
jnz loc_41E86
cmp [rbp+var_20], 0
jz loc_41E86
mov rdi, [rbp+var_20]
call _strdup
mov rcx, [rbp+var_8]
mov [rcx+2E8h], rax
cmp rax, 0
jnz short loc_41E86
jmp short $+2
loc_41E1C:
mov rax, [rbp+var_8]
mov dword ptr [rax+90h], 7D8h
mov rdi, [rbp+var_8]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_8]
mov byte ptr [rax+29Ch], 0
mov rdi, [rbp+var_8]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_8]
mov byte ptr [rax+296h], 0
mov [rbp+var_44], 1
loc_41E86:
jmp short loc_41EF4
loc_41E88:
mov rax, [rbp+var_8]
mov rdi, [rax+2B8h]
call _free
mov rax, [rbp+var_8]
mov rdi, [rax+2C0h]
call _free
mov rax, [rbp+var_8]
mov rdi, [rax+2E8h]
call _free
mov rcx, [rbp+var_30]
mov rax, [rbp+var_8]
mov [rax+2B8h], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_8]
mov [rax+2C0h], rcx
mov rcx, [rbp+var_40]
mov rax, [rbp+var_8]
mov [rax+2E8h], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_8]
mov [rax+2F0h], rcx
loc_41EF4:
mov eax, [rbp+var_44]
add rsp, 60h
pop rbp
retn
| long long mysql_change_user(long long a1, long long a2, long long a3, long long a4)
{
long long charset_name; // rcx
long long v5; // rax
long long v6; // rax
long long v7; // rax
unsigned int v9; // [rsp+1Ch] [rbp-44h]
long long v10; // [rsp+20h] [rbp-40h]
long long v11; // [rsp+28h] [rbp-38h]
long long v12; // [rsp+30h] [rbp-30h]
long long v13; // [rsp+38h] [rbp-28h]
v13 = *(_QWORD *)(a1 + 752);
v12 = *(_QWORD *)(a1 + 696);
v11 = *(_QWORD *)(a1 + 704);
v10 = *(_QWORD *)(a1 + 744);
if ( *(_QWORD *)(a1 + 1016) )
charset_name = mysql_find_charset_name(*(_QWORD *)(a1 + 1016));
else
charset_name = mysql_find_charset_name("utf8mb4");
*(_QWORD *)(a1 + 752) = charset_name;
if ( a2 )
v5 = strdup(a2);
else
v5 = strdup("");
*(_QWORD *)(a1 + 696) = v5;
if ( a3 )
v6 = strdup(a3);
else
v6 = strdup("");
*(_QWORD *)(a1 + 704) = v6;
*(_QWORD *)(a1 + 744) = 0LL;
v9 = run_plugin_auth(a1, 0LL, 0LL, 0LL, a4);
ma_invalidate_stmts(a1, (long long)"mysql_change_user()");
if ( v9 )
{
free(*(_QWORD *)(a1 + 696));
free(*(_QWORD *)(a1 + 704));
free(*(_QWORD *)(a1 + 744));
*(_QWORD *)(a1 + 696) = v12;
*(_QWORD *)(a1 + 704) = v11;
*(_QWORD *)(a1 + 744) = v10;
*(_QWORD *)(a1 + 752) = v13;
}
else
{
free(v12);
free(v11);
free(v10);
if ( !*(_QWORD *)(a1 + 744) )
{
if ( a4 )
{
v7 = strdup(a4);
*(_QWORD *)(a1 + 744) = v7;
if ( !v7 )
{
*(_DWORD *)(a1 + 144) = 2008;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[8], 511LL);
*(_BYTE *)(a1 + 662) = 0;
return 1;
}
}
}
}
return v9;
}
| mysql_change_user:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2f0]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2b8]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2c0]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2e8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x3f8],0x0
JZ 0x00141d02
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x3f8]
CALL 0x00167e10
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2f0],RCX
JMP 0x00141d1c
LAB_00141d02:
LEA RDI,[0x1c9feb]
CALL 0x00167e10
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2f0],RCX
LAB_00141d1c:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00141d2d
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00141d3a
LAB_00141d2d:
LEA RAX,[0x1c9ba1]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00141d3a
LAB_00141d3a:
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x00136030
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2b8],RCX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00141d62
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00141d6f
LAB_00141d62:
LEA RAX,[0x1c9ba1]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00141d6f
LAB_00141d6f:
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x00136030
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2c0],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2e8],0x0
MOV RDI,qword ptr [RBP + -0x8]
MOV R8,qword ptr [RBP + -0x20]
XOR EAX,EAX
MOV ECX,EAX
XOR EDX,EDX
MOV RSI,RCX
CALL 0x00163750
MOV dword ptr [RBP + -0x44],EAX
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1ca08c]
CALL 0x00141aa0
CMP dword ptr [RBP + -0x44],0x0
JNZ 0x00141e88
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001361a0
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001361a0
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x001361a0
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x2e8],0x0
JNZ 0x00141e86
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00141e86
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00136030
MOV RCX,qword ptr [RBP + -0x8]
MOV qword ptr [RCX + 0x2e8],RAX
CMP RAX,0x0
JNZ 0x00141e86
JMP 0x00141e1c
LAB_00141e1c:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x297
LEA RAX,[0x331c10]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00136140
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x97
LEA RAX,[0x331c20]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00136140
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x296],0x0
MOV dword ptr [RBP + -0x44],0x1
LAB_00141e86:
JMP 0x00141ef4
LAB_00141e88:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x2b8]
CALL 0x001361a0
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x2c0]
CALL 0x001361a0
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x2e8]
CALL 0x001361a0
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2b8],RCX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2c0],RCX
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2e8],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x2f0],RCX
LAB_00141ef4:
MOV EAX,dword ptr [RBP + -0x44]
ADD RSP,0x60
POP RBP
RET
|
int mysql_change_user(long param_1,char *param_2,char *param_3,char *param_4)
{
int8 uVar1;
void *__ptr;
void *__ptr_00;
void *__ptr_01;
int8 uVar2;
char *pcVar3;
char *local_60;
char *local_58;
int local_4c;
uVar1 = *(int8 *)(param_1 + 0x2f0);
__ptr = *(void **)(param_1 + 0x2b8);
__ptr_00 = *(void **)(param_1 + 0x2c0);
__ptr_01 = *(void **)(param_1 + 0x2e8);
if (*(long *)(param_1 + 0x3f8) == 0) {
uVar2 = mysql_find_charset_name("utf8mb4");
*(int8 *)(param_1 + 0x2f0) = uVar2;
}
else {
uVar2 = mysql_find_charset_name(*(int8 *)(param_1 + 0x3f8));
*(int8 *)(param_1 + 0x2f0) = uVar2;
}
local_58 = param_2;
if (param_2 == (char *)0x0) {
local_58 = "";
}
pcVar3 = strdup(local_58);
*(char **)(param_1 + 0x2b8) = pcVar3;
local_60 = param_3;
if (param_3 == (char *)0x0) {
local_60 = "";
}
pcVar3 = strdup(local_60);
*(char **)(param_1 + 0x2c0) = pcVar3;
*(int8 *)(param_1 + 0x2e8) = 0;
local_4c = run_plugin_auth(param_1,0,0,0,param_4);
ma_invalidate_stmts(param_1,"mysql_change_user()");
if (local_4c == 0) {
free(__ptr);
free(__ptr_00);
free(__ptr_01);
if ((*(long *)(param_1 + 0x2e8) == 0) && (param_4 != (char *)0x0)) {
pcVar3 = strdup(param_4);
*(char **)(param_1 + 0x2e8) = pcVar3;
if (pcVar3 == (char *)0x0) {
*(int4 *)(param_1 + 0x90) = 0x7d8;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),PTR_s_Client_run_out_of_memory_00331c60,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
local_4c = 1;
}
}
}
else {
free(*(void **)(param_1 + 0x2b8));
free(*(void **)(param_1 + 0x2c0));
free(*(void **)(param_1 + 0x2e8));
*(void **)(param_1 + 0x2b8) = __ptr;
*(void **)(param_1 + 0x2c0) = __ptr_00;
*(void **)(param_1 + 0x2e8) = __ptr_01;
*(int8 *)(param_1 + 0x2f0) = uVar1;
}
return local_4c;
}
| |
28,409 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[]<char const>(char const*) const | monkey531[P]llama/common/json.hpp | const_reference operator[](T* key) const
{
return operator[](typename object_t::key_type(key));
} | 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> const& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[]<char const>(char const*) const:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x5318a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xabfaa
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa5e55
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa5e7e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8c0
movq %rbx, %rdi
callq 0x1bf90
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERKSD_PT_:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
lea r14, [rsp+38h+var_30]
lea rdx, [rsp+38h+var_31]
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, rbx
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixERKS9_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator[](std::string const&)
mov rbx, rax
lea rax, [rsp+38h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A5E55
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A5E55:
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A5E7E
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A5E7E:
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
long long a1,
_BYTE *a2)
{
long long v2; // rbx
void *v4[2]; // [rsp+8h] [rbp-30h] BYREF
long long v5; // [rsp+18h] [rbp-20h] BYREF
std::string::basic_string<std::allocator<char>>(v4, a2);
v2 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
a1,
v4);
if ( v4[0] != &v5 )
operator delete(v4[0], v5 + 1);
return v2;
}
| operator[]<char_const>:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RDI,R14
CALL 0x0015318a
LAB_001a5e2c:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001abfaa
LAB_001a5e37:
MOV RBX,RAX
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001a5e55
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8c0
LAB_001a5e55:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[]<char const>(char const*) const */
basic_json * __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]<char_const>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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,char *param_1)
{
basic_json *pbVar1;
allocator local_31;
long *local_30 [2];
long local_20 [2];
std::__cxx11::string::string<std::allocator<char>>((string *)local_30,param_1,&local_31);
/* try { // try from 001a5e2c to 001a5e36 has its CatchHandler @ 001a5e60 */
pbVar1 = (basic_json *)operator[](this,(string *)local_30);
if (local_30[0] != local_20) {
operator_delete(local_30[0],local_20[0] + 1);
}
return pbVar1;
}
| |
28,410 | common_sampler_type_to_chr(common_sampler_type) | monkey531[P]llama/common/sampling.cpp | char common_sampler_type_to_chr(enum common_sampler_type cnstr) {
switch (cnstr) {
case COMMON_SAMPLER_TYPE_DRY: return 'd';
case COMMON_SAMPLER_TYPE_TOP_K: return 'k';
case COMMON_SAMPLER_TYPE_TYPICAL_P: return 'y';
case COMMON_SAMPLER_TYPE_TOP_P: return 'p';
case COMMON_SAMPLER_TYPE_MIN_P: return 'm';
case COMMON_SAMPLER_TYPE_TEMPERATURE: return 't';
case COMMON_SAMPLER_TYPE_XTC: return 'x';
case COMMON_SAMPLER_TYPE_INFILL: return 'i';
case COMMON_SAMPLER_TYPE_PENALTIES: return 'e';
default : return '?';
}
} | O1 | cpp | common_sampler_type_to_chr(common_sampler_type):
decl %edi
movb $0x3f, %al
cmpl $0x9, %edi
ja 0xcfb26
movl %edi, %eax
leaq 0x28d5d(%rip), %rcx # 0xf8880
movb (%rax,%rcx), %al
retq
| _Z26common_sampler_type_to_chr19common_sampler_type:
dec edi
mov al, 3Fh ; '?'
cmp edi, 9
ja short locret_CFB26
mov eax, edi
lea rcx, aDkpmYtxie; "dkpm?ytxie"
mov al, [rax+rcx]
locret_CFB26:
retn
| char common_sampler_type_to_chr(int a1)
{
unsigned int v1; // edi
char result; // al
v1 = a1 - 1;
result = 63;
if ( v1 <= 9 )
return aDkpmYtxie[v1];
return result;
}
| common_sampler_type_to_chr:
DEC EDI
MOV AL,0x3f
CMP EDI,0x9
JA 0x001cfb26
MOV EAX,EDI
LEA RCX,[0x1f8880]
MOV AL,byte ptr [RAX + RCX*0x1]
LAB_001cfb26:
RET
|
/* common_sampler_type_to_chr(common_sampler_type) */
char common_sampler_type_to_chr(int param_1)
{
char cVar1;
cVar1 = '?';
if (param_1 - 1U < 10) {
cVar1 = "dkpm?ytxie"[param_1 - 1U];
}
return cVar1;
}
| |
28,411 | common_sampler_type_to_chr(common_sampler_type) | monkey531[P]llama/common/sampling.cpp | char common_sampler_type_to_chr(enum common_sampler_type cnstr) {
switch (cnstr) {
case COMMON_SAMPLER_TYPE_DRY: return 'd';
case COMMON_SAMPLER_TYPE_TOP_K: return 'k';
case COMMON_SAMPLER_TYPE_TYPICAL_P: return 'y';
case COMMON_SAMPLER_TYPE_TOP_P: return 'p';
case COMMON_SAMPLER_TYPE_MIN_P: return 'm';
case COMMON_SAMPLER_TYPE_TEMPERATURE: return 't';
case COMMON_SAMPLER_TYPE_XTC: return 'x';
case COMMON_SAMPLER_TYPE_INFILL: return 'i';
case COMMON_SAMPLER_TYPE_PENALTIES: return 'e';
default : return '?';
}
} | O2 | cpp | common_sampler_type_to_chr(common_sampler_type):
decl %edi
movb $0x3f, %al
cmpl $0x9, %edi
ja 0x9845b
movl %edi, %eax
leaq 0x213f4(%rip), %rcx # 0xb984c
movb (%rax,%rcx), %al
retq
| _Z26common_sampler_type_to_chr19common_sampler_type:
dec edi
mov al, 3Fh ; '?'
cmp edi, 9
ja short locret_9845B
mov eax, edi
lea rcx, aDkpmYtxie; "dkpm?ytxie"
mov al, [rax+rcx]
locret_9845B:
retn
| char common_sampler_type_to_chr(int a1)
{
unsigned int v1; // edi
char result; // al
v1 = a1 - 1;
result = 63;
if ( v1 <= 9 )
return aDkpmYtxie[v1];
return result;
}
| common_sampler_type_to_chr:
DEC EDI
MOV AL,0x3f
CMP EDI,0x9
JA 0x0019845b
MOV EAX,EDI
LEA RCX,[0x1b984c]
MOV AL,byte ptr [RAX + RCX*0x1]
LAB_0019845b:
RET
|
/* common_sampler_type_to_chr(common_sampler_type) */
char common_sampler_type_to_chr(int param_1)
{
char cVar1;
cVar1 = '?';
if (param_1 - 1U < 10) {
cVar1 = "dkpm?ytxie"[param_1 - 1U];
}
return cVar1;
}
| |
28,412 | ctz | bluesky950520[P]quickjs/libbf.c | static inline int ctz(limb_t a)
{
if (a == 0) {
return LIMB_BITS;
} else {
#if LIMB_BITS == 64
return ctz64(a);
#else
return ctz32(a);
#endif
}
} | O0 | c | ctz:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xe8c8b
movl $0x40, 0x14(%rsp)
jmp 0xe8c99
movq 0x8(%rsp), %rdi
callq 0xf64f0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| ctz:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
cmp [rsp+18h+var_10], 0
jnz short loc_E8C8B
mov [rsp+18h+var_4], 40h ; '@'
jmp short loc_E8C99
loc_E8C8B:
mov rdi, [rsp+18h+var_10]
call ctz64
mov [rsp+18h+var_4], eax
loc_E8C99:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long ctz(long long a1)
{
if ( a1 )
return (unsigned int)ctz64(a1);
else
return 64;
}
| ctz:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x001e8c8b
MOV dword ptr [RSP + 0x14],0x40
JMP 0x001e8c99
LAB_001e8c8b:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001f64f0
MOV dword ptr [RSP + 0x14],EAX
LAB_001e8c99:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
int4 ctz(long param_1)
{
int4 local_4;
if (param_1 == 0) {
local_4 = 0x40;
}
else {
local_4 = ctz64(param_1);
}
return local_4;
}
| |
28,413 | fs_create_directory_with_parents(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | bool fs_create_directory_with_parents(const std::string & path) {
#ifdef _WIN32
std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
std::wstring wpath = converter.from_bytes(path);
// if the path already exists, check whether it's a directory
const DWORD attributes = GetFileAttributesW(wpath.c_str());
if ((attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
return true;
}
size_t pos_slash = 0;
// process path from front to back, procedurally creating directories
while ((pos_slash = path.find('\\', pos_slash)) != std::string::npos) {
const std::wstring subpath = wpath.substr(0, pos_slash);
const wchar_t * test = subpath.c_str();
const bool success = CreateDirectoryW(test, NULL);
if (!success) {
const DWORD error = GetLastError();
// if the path already exists, ensure that it's a directory
if (error == ERROR_ALREADY_EXISTS) {
const DWORD attributes = GetFileAttributesW(subpath.c_str());
if (attributes == INVALID_FILE_ATTRIBUTES || !(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
return false;
}
} else {
return false;
}
}
pos_slash += 1;
}
return true;
#else
// if the path already exists, check whether it's a directory
struct stat info;
if (stat(path.c_str(), &info) == 0) {
return S_ISDIR(info.st_mode);
}
size_t pos_slash = 1; // skip leading slashes for directory creation
// process path from front to back, procedurally creating directories
while ((pos_slash = path.find('/', pos_slash)) != std::string::npos) {
const std::string subpath = path.substr(0, pos_slash);
struct stat info;
// if the path already exists, ensure that it's a directory
if (stat(subpath.c_str(), &info) == 0) {
if (!S_ISDIR(info.st_mode)) {
return false;
}
} else {
// create parent directories
const int ret = mkdir(subpath.c_str(), 0755);
if (ret != 0) {
return false;
}
}
pos_slash += 1;
}
return true;
#endif // _WIN32
} | O3 | cpp | fs_create_directory_with_parents(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x18610
testl %eax, %eax
je 0x1fd3f
movl $0x1, %r14d
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %rbx, %rdi
movl $0x2f, %esi
movq %r14, %rdx
callq 0x18850
cmpq $-0x1, %rax
sete %bpl
je 0x1fd54
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x186f0
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x18610
testl %eax, %eax
je 0x1fd00
movq 0x8(%rsp), %rdi
movl $0x1ed, %esi # imm = 0x1ED
callq 0x18340
testl %eax, %eax
je 0x1fd12
xorl %r13d, %r13d
jmp 0x1fd18
movl 0x40(%rsp), %eax
movl $0xf000, %ecx # imm = 0xF000
andl %ecx, %eax
cmpl $0x4000, %eax # imm = 0x4000
jne 0x1fcfb
incq %r14
movb $0x1, %r13b
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1fd34
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
testb %r13b, %r13b
jne 0x1fca6
jmp 0x1fd54
movl $0xf000, %eax # imm = 0xF000
andl 0xd0(%rsp), %eax
cmpl $0x4000, %eax # imm = 0x4000
sete %bpl
movl %ebp, %eax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _Z32fs_create_directory_with_parentsRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 148h
mov rbx, rdi
mov rdi, [rdi]
lea rsi, [rsp+178h+var_C0]
call _stat
test eax, eax
jz loc_1FD3F
mov r14d, 1
lea r15, [rsp+178h+var_170]
lea r12, [rsp+178h+var_150]
loc_1FCA6:
mov rdi, rbx
mov esi, 2Fh ; '/'
mov rdx, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
setz bpl
jz loc_1FD54
mov r14, rax
mov rdi, r15
mov rsi, rbx
xor edx, edx
mov rcx, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, [rsp+178h+var_170]
mov rsi, r12
call _stat
test eax, eax
jz short loc_1FD00
mov rdi, [rsp+178h+var_170]
mov esi, 1EDh
call _mkdir
test eax, eax
jz short loc_1FD12
loc_1FCFB:
xor r13d, r13d
jmp short loc_1FD18
loc_1FD00:
mov eax, [rsp+178h+var_138]
mov ecx, 0F000h
and eax, ecx
cmp eax, 4000h
jnz short loc_1FCFB
loc_1FD12:
inc r14
mov r13b, 1
loc_1FD18:
mov rdi, [rsp+178h+var_170]; void *
lea rax, [rsp+178h+var_160]
cmp rdi, rax
jz short loc_1FD34
mov rsi, [rsp+178h+var_160]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1FD34:
test r13b, r13b
jnz loc_1FCA6
jmp short loc_1FD54
loc_1FD3F:
mov eax, 0F000h
and eax, [rsp+178h+var_A8]
cmp eax, 4000h
setz bpl
loc_1FD54:
mov eax, ebp
add rsp, 148h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long fs_create_directory_with_parents(_QWORD *a1)
{
unsigned int v1; // ebp
long long v2; // r14
long long v3; // rax
char v4; // r13
void *v6; // [rsp+8h] [rbp-170h] BYREF
long long v7; // [rsp+18h] [rbp-160h] BYREF
_BYTE v8[24]; // [rsp+28h] [rbp-150h] BYREF
int v9; // [rsp+40h] [rbp-138h]
_BYTE v10[24]; // [rsp+B8h] [rbp-C0h] BYREF
int v11; // [rsp+D0h] [rbp-A8h]
if ( (unsigned int)stat(*a1, v10) )
{
v2 = 1LL;
while ( 1 )
{
v3 = std::string::find(a1, 47LL, v2);
LOBYTE(v1) = v3 == -1;
if ( v3 == -1 )
return v1;
v2 = v3;
std::string::substr(&v6, a1, 0LL, v3);
if ( (unsigned int)stat(v6, v8) )
{
if ( !(unsigned int)mkdir(v6, 493LL) )
goto LABEL_8;
}
else if ( (v9 & 0xF000) == 0x4000 )
{
LABEL_8:
++v2;
v4 = 1;
goto LABEL_9;
}
v4 = 0;
LABEL_9:
if ( v6 != &v7 )
operator delete(v6, v7 + 1);
if ( !v4 )
return v1;
}
}
LOBYTE(v1) = (v11 & 0xF000) == 0x4000;
return v1;
}
| fs_create_directory_with_parents:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x148
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
LEA RSI,[RSP + 0xb8]
CALL 0x00118610
TEST EAX,EAX
JZ 0x0011fd3f
MOV R14D,0x1
LEA R15,[RSP + 0x8]
LEA R12,[RSP + 0x28]
LAB_0011fca6:
MOV RDI,RBX
MOV ESI,0x2f
MOV RDX,R14
CALL 0x00118850
CMP RAX,-0x1
SETZ BPL
JZ 0x0011fd54
MOV R14,RAX
MOV RDI,R15
MOV RSI,RBX
XOR EDX,EDX
MOV RCX,RAX
CALL 0x001186f0
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R12
CALL 0x00118610
TEST EAX,EAX
JZ 0x0011fd00
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x1ed
CALL 0x00118340
TEST EAX,EAX
JZ 0x0011fd12
LAB_0011fcfb:
XOR R13D,R13D
JMP 0x0011fd18
LAB_0011fd00:
MOV EAX,dword ptr [RSP + 0x40]
MOV ECX,0xf000
AND EAX,ECX
CMP EAX,0x4000
JNZ 0x0011fcfb
LAB_0011fd12:
INC R14
MOV R13B,0x1
LAB_0011fd18:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x0011fd34
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001186a0
LAB_0011fd34:
TEST R13B,R13B
JNZ 0x0011fca6
JMP 0x0011fd54
LAB_0011fd3f:
MOV EAX,0xf000
AND EAX,dword ptr [RSP + 0xd0]
CMP EAX,0x4000
SETZ BPL
LAB_0011fd54:
MOV EAX,EBP
ADD RSP,0x148
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* fs_create_directory_with_parents(std::__cxx11::string const&) */
ulong fs_create_directory_with_parents(string *param_1)
{
bool bVar1;
int iVar2;
long lVar3;
ulong unaff_RBP;
long *local_170 [2];
long local_160 [2];
stat local_150;
stat local_c0;
iVar2 = stat(*(char **)param_1,&local_c0);
if (iVar2 == 0) {
unaff_RBP = CONCAT71((int7)(unaff_RBP >> 8),(local_c0.st_mode & 0xf000) == 0x4000);
}
else {
do {
lVar3 = std::__cxx11::string::find((char)param_1,0x2f);
unaff_RBP = CONCAT71((int7)(unaff_RBP >> 8),lVar3 == -1);
if (lVar3 == -1) break;
std::__cxx11::string::substr((ulong)local_170,(ulong)param_1);
iVar2 = stat((char *)local_170[0],&local_150);
if (iVar2 == 0) {
if ((local_150.st_mode & 0xf000) != 0x4000) goto LAB_0011fcfb;
LAB_0011fd12:
bVar1 = true;
}
else {
iVar2 = mkdir((char *)local_170[0],0x1ed);
if (iVar2 == 0) goto LAB_0011fd12;
LAB_0011fcfb:
bVar1 = false;
}
if (local_170[0] != local_160) {
operator_delete(local_170[0],local_160[0] + 1);
}
} while (bVar1);
}
return unaff_RBP & 0xffffffff;
}
| |
28,414 | 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>>>>>::unget() | monkey531[P]llama/common/json.hpp | void unget()
{
next_unget = true;
--position.chars_read_total;
// in case we "unget" a newline, we have to also decrement the lines_read
if (position.chars_read_current_line == 0)
{
if (position.lines_read > 0)
{
--position.lines_read;
}
}
else
{
--position.chars_read_current_line;
}
if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
{
JSON_ASSERT(!token_string.empty());
token_string.pop_back();
}
} | O2 | 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>>>>>::unget():
movb $0x1, 0x18(%rdi)
decq 0x20(%rdi)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x41633
leaq 0x28(%rdi), %rcx
jmp 0x41640
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x41646
leaq 0x30(%rdi), %rcx
decq %rax
movq %rax, (%rcx)
cmpl $-0x1, 0x14(%rdi)
je 0x4165d
movq 0x40(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x4165e
decq %rax
movq %rax, 0x40(%rdi)
retq
pushq %rax
leaq 0x70a56(%rip), %rdi # 0xb20bc
leaq 0x70a99(%rip), %rdx # 0xb2106
leaq 0x70c27(%rip), %rcx # 0xb229b
movl $0x2240, %esi # imm = 0x2240
xorl %eax, %eax
callq 0x250e0
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv:
mov byte ptr [rdi+18h], 1
dec qword ptr [rdi+20h]
mov rax, [rdi+28h]
test rax, rax
jz short loc_41633
lea rcx, [rdi+28h]
jmp short loc_41640
loc_41633:
mov rax, [rdi+30h]
test rax, rax
jz short loc_41646
lea rcx, [rdi+30h]
loc_41640:
dec rax
mov [rcx], rax
loc_41646:
cmp dword ptr [rdi+14h], 0FFFFFFFFh
jz short locret_4165D
mov rax, [rdi+40h]
cmp [rdi+38h], rax
jz short loc_4165E
dec rax
mov [rdi+40h], rax
locret_4165D:
retn
loc_4165E:
push rax
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTokenStringEmp; "!token_string.empty()"
mov esi, 2240h
xor eax, eax
call _ggml_abort
| 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>>>::unget(
long long a1)
{
long long result; // rax
_QWORD *v2; // rcx
long long v3; // rax
*(_BYTE *)(a1 + 24) = 1;
--*(_QWORD *)(a1 + 32);
result = *(_QWORD *)(a1 + 40);
if ( result )
{
v2 = (_QWORD *)(a1 + 40);
}
else
{
result = *(_QWORD *)(a1 + 48);
if ( !result )
goto LABEL_6;
v2 = (_QWORD *)(a1 + 48);
}
*v2 = --result;
LABEL_6:
if ( *(_DWORD *)(a1 + 20) != -1 )
{
v3 = *(_QWORD *)(a1 + 64);
if ( *(_QWORD *)(a1 + 56) == v3 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
8768LL,
"GGML_ASSERT(%s) failed",
"!token_string.empty()");
return std::vector<char>::emplace_back<char>("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
else
{
result = v3 - 1;
*(_QWORD *)(a1 + 64) = result;
}
}
return result;
}
| unget:
MOV byte ptr [RDI + 0x18],0x1
DEC qword ptr [RDI + 0x20]
MOV RAX,qword ptr [RDI + 0x28]
TEST RAX,RAX
JZ 0x00141633
LEA RCX,[RDI + 0x28]
JMP 0x00141640
LAB_00141633:
MOV RAX,qword ptr [RDI + 0x30]
TEST RAX,RAX
JZ 0x00141646
LEA RCX,[RDI + 0x30]
LAB_00141640:
DEC RAX
MOV qword ptr [RCX],RAX
LAB_00141646:
CMP dword ptr [RDI + 0x14],-0x1
JZ 0x0014165d
MOV RAX,qword ptr [RDI + 0x40]
CMP qword ptr [RDI + 0x38],RAX
JZ 0x0014165e
DEC RAX
MOV qword ptr [RDI + 0x40],RAX
LAB_0014165d:
RET
LAB_0014165e:
PUSH RAX
LEA RDI,[0x1b20bc]
LEA RDX,[0x1b2106]
LEA RCX,[0x1b229b]
MOV ESI,0x2240
XOR EAX,EAX
CALL 0x001250e0
|
/* 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 > > >::unget() */
void __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>>>
::unget(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)
{
long lVar1;
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>>>
*plVar2;
int8 in_R8;
int8 in_R9;
this[0x18] = (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>>>
)0x1;
*(long *)(this + 0x20) = *(long *)(this + 0x20) + -1;
lVar1 = *(long *)(this + 0x28);
if (lVar1 == 0) {
lVar1 = *(long *)(this + 0x30);
if (lVar1 == 0) goto LAB_00141646;
plVar2 = this + 0x30;
}
else {
plVar2 = this + 0x28;
}
*(long *)plVar2 = lVar1 + -1;
LAB_00141646:
if (*(int *)(this + 0x14) != -1) {
lVar1 = *(long *)(this + 0x40);
if (*(long *)(this + 0x38) == lVar1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x2240,
"GGML_ASSERT(%s) failed","!token_string.empty()",in_R8,in_R9,lVar1);
}
*(long *)(this + 0x40) = lVar1 + -1;
}
return;
}
| |
28,415 | common_batch_add(llama_batch&, int, int, std::vector<int, std::allocator<int>> const&, bool) | llama.cpp/common/common.cpp | void common_batch_add(
struct llama_batch & batch,
llama_token id,
llama_pos pos,
const std::vector<llama_seq_id> & seq_ids,
bool logits) {
GGML_ASSERT(batch.seq_id[batch.n_tokens] && "llama_batch size exceeded");
batch.token [batch.n_tokens] = id;
batch.pos [batch.n_tokens] = pos;
batch.n_seq_id[batch.n_tokens] = seq_ids.size();
for (size_t i = 0; i < seq_ids.size(); ++i) {
batch.seq_id[batch.n_tokens][i] = seq_ids[i];
}
batch.logits [batch.n_tokens] = logits;
batch.n_tokens++;
} | O3 | cpp | common_batch_add(llama_batch&, int, int, std::vector<int, std::allocator<int>> const&, bool):
pushq %rax
movq 0x28(%rdi), %rax
movslq (%rdi), %r9
cmpq $0x0, (%rax,%r9,8)
je 0xf923d
movq 0x8(%rdi), %r10
movl %esi, (%r10,%r9,4)
movq 0x18(%rdi), %rsi
movslq (%rdi), %r9
movl %edx, (%rsi,%r9,4)
movq (%rcx), %rdx
movq 0x8(%rcx), %rsi
movq %rsi, %rcx
subq %rdx, %rcx
sarq $0x2, %rcx
movq 0x20(%rdi), %r9
movslq (%rdi), %r10
movl %ecx, (%r9,%r10,4)
cmpq %rdx, %rsi
je 0xf922e
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movl (%rdx,%rsi,4), %r9d
movslq (%rdi), %r10
movq (%rax,%r10,8), %r10
movl %r9d, (%r10,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0xf9217
movq 0x30(%rdi), %rax
movslq (%rdi), %rcx
movb %r8b, (%rax,%rcx)
incl (%rdi)
popq %rax
retq
leaq 0x29f91(%rip), %rdi # 0x1231d5
leaq 0x1f512(%rip), %rdx # 0x11875d
leaq 0x2a556(%rip), %rcx # 0x1237a8
movl $0x478, %esi # imm = 0x478
xorl %eax, %eax
callq 0x20e70
| _Z16common_batch_addR11llama_batchiiRKSt6vectorIiSaIiEEb:
push rax
mov rax, [rdi+28h]
movsxd r9, dword ptr [rdi]
cmp qword ptr [rax+r9*8], 0
jz short loc_F923D
mov r10, [rdi+8]
mov [r10+r9*4], esi
mov rsi, [rdi+18h]
movsxd r9, dword ptr [rdi]
mov [rsi+r9*4], edx
mov rdx, [rcx]
mov rsi, [rcx+8]
mov rcx, rsi
sub rcx, rdx
sar rcx, 2
mov r9, [rdi+20h]
movsxd r10, dword ptr [rdi]
mov [r9+r10*4], ecx
cmp rsi, rdx
jz short loc_F922E
cmp rcx, 1
adc rcx, 0
xor esi, esi
loc_F9217:
mov r9d, [rdx+rsi*4]
movsxd r10, dword ptr [rdi]
mov r10, [rax+r10*8]
mov [r10+rsi*4], r9d
inc rsi
cmp rcx, rsi
jnz short loc_F9217
loc_F922E:
mov rax, [rdi+30h]
movsxd rcx, dword ptr [rdi]
mov [rax+rcx], r8b
inc dword ptr [rdi]
pop rax
retn
loc_F923D:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aBatchSeqIdBatc; "batch.seq_id[batch.n_tokens] && \"llama"...
mov esi, 478h
xor eax, eax
call _ggml_abort
| long long common_batch_add(int *a1, int a2, int a3, long long *a4, char a5)
{
long long v5; // rax
long long v6; // rax
long long v7; // r9
long long v8; // rdx
long long v9; // rsi
long long v10; // rcx
long long v11; // rcx
long long v12; // rsi
double v14; // xmm0_8
long long v15; // [rsp-8h] [rbp-8h]
v15 = v5;
v6 = *((_QWORD *)a1 + 5);
v7 = *a1;
if ( *(_QWORD *)(v6 + 8 * v7) )
{
*(_DWORD *)(*((_QWORD *)a1 + 1) + 4 * v7) = a2;
*(_DWORD *)(*((_QWORD *)a1 + 3) + 4LL * *a1) = a3;
v8 = *a4;
v9 = a4[1];
v10 = (v9 - *a4) >> 2;
*(_DWORD *)(*((_QWORD *)a1 + 4) + 4LL * *a1) = v10;
if ( v9 != v8 )
{
v11 = (v10 == 0) + v10;
v12 = 0LL;
do
{
*(_DWORD *)(*(_QWORD *)(v6 + 8LL * *a1) + 4 * v12) = *(_DWORD *)(v8 + 4 * v12);
++v12;
}
while ( v11 != v12 );
}
*(_BYTE *)(*((_QWORD *)a1 + 6) + (*a1)++) = a5;
return v15;
}
else
{
v14 = ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",
1144LL,
"GGML_ASSERT(%s) failed",
"batch.seq_id[batch.n_tokens] && \"llama_batch size exceeded\"");
return common_lcp(v14);
}
}
| common_batch_add:
PUSH RAX
MOV RAX,qword ptr [RDI + 0x28]
MOVSXD R9,dword ptr [RDI]
CMP qword ptr [RAX + R9*0x8],0x0
JZ 0x001f923d
MOV R10,qword ptr [RDI + 0x8]
MOV dword ptr [R10 + R9*0x4],ESI
MOV RSI,qword ptr [RDI + 0x18]
MOVSXD R9,dword ptr [RDI]
MOV dword ptr [RSI + R9*0x4],EDX
MOV RDX,qword ptr [RCX]
MOV RSI,qword ptr [RCX + 0x8]
MOV RCX,RSI
SUB RCX,RDX
SAR RCX,0x2
MOV R9,qword ptr [RDI + 0x20]
MOVSXD R10,dword ptr [RDI]
MOV dword ptr [R9 + R10*0x4],ECX
CMP RSI,RDX
JZ 0x001f922e
CMP RCX,0x1
ADC RCX,0x0
XOR ESI,ESI
LAB_001f9217:
MOV R9D,dword ptr [RDX + RSI*0x4]
MOVSXD R10,dword ptr [RDI]
MOV R10,qword ptr [RAX + R10*0x8]
MOV dword ptr [R10 + RSI*0x4],R9D
INC RSI
CMP RCX,RSI
JNZ 0x001f9217
LAB_001f922e:
MOV RAX,qword ptr [RDI + 0x30]
MOVSXD RCX,dword ptr [RDI]
MOV byte ptr [RAX + RCX*0x1],R8B
INC dword ptr [RDI]
POP RAX
RET
LAB_001f923d:
LEA RDI,[0x2231d5]
LEA RDX,[0x21875d]
LEA RCX,[0x2237a8]
MOV ESI,0x478
XOR EAX,EAX
CALL 0x00120e70
|
/* common_batch_add(llama_batch&, int, int, std::vector<int, std::allocator<int> > const&, bool) */
int8
common_batch_add(llama_batch *param_1,int param_2,int param_3,vector *param_4,bool param_5)
{
long lVar1;
long lVar2;
int8 in_RAX;
long lVar3;
long lVar4;
lVar1 = *(long *)(param_1 + 0x28);
if (*(long *)(lVar1 + (long)*(int *)param_1 * 8) != 0) {
*(int *)(*(long *)(param_1 + 8) + (long)*(int *)param_1 * 4) = param_2;
*(int *)(*(long *)(param_1 + 0x18) + (long)*(int *)param_1 * 4) = param_3;
lVar2 = *(long *)param_4;
lVar4 = *(long *)(param_4 + 8);
lVar3 = lVar4 - lVar2 >> 2;
*(int *)(*(long *)(param_1 + 0x20) + (long)*(int *)param_1 * 4) = (int)lVar3;
if (lVar4 != lVar2) {
lVar4 = 0;
do {
*(int4 *)(*(long *)(lVar1 + (long)*(int *)param_1 * 8) + lVar4 * 4) =
*(int4 *)(lVar2 + lVar4 * 4);
lVar4 = lVar4 + 1;
} while (lVar3 + (ulong)(lVar3 == 0) != lVar4);
}
*(bool *)(*(long *)(param_1 + 0x30) + (long)*(int *)param_1) = param_5;
*(int *)param_1 = *(int *)param_1 + 1;
return in_RAX;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",0x478,
"GGML_ASSERT(%s) failed",
"batch.seq_id[batch.n_tokens] && \"llama_batch size exceeded\"");
}
| |
28,416 | void testing::internal::PointerPrinter::PrintValue<YGConfig>(YGConfig*, std::ostream*) | yoga-mod/tests/build_O0/_deps/googletest-src/googletest/include/gtest/gtest-printers.h | static void PrintValue(T* p, ::std::ostream* os) {
if (p == nullptr) {
*os << "NULL";
} else {
// T is not a function type. We just call << to print p,
// relying on ADL to pick up user-defined << for their pointer
// types, if any.
*os << p;
}
} | O0 | c | void testing::internal::PointerPrinter::PrintValue<YGConfig>(YGConfig*, std::ostream*):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x96049
movq -0x10(%rbp), %rdi
leaq 0x6af716(%rip), %rsi # 0x745758
callq 0x35490
jmp 0x96056
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x353c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN7testing8internal14PointerPrinter10PrintValueI8YGConfigEEvPT_PSo:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
cmp [rbp+var_8], 0
jnz short loc_96049
mov rdi, [rbp+var_10]
lea rsi, aNull; "NULL"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short loc_96056
loc_96049:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_8]
call __ZNSolsEPKv; std::ostream::operator<<(void const*)
loc_96056:
add rsp, 10h
pop rbp
retn
| long long testing::internal::PointerPrinter::PrintValue<YGConfig>(long long a1, long long a2)
{
if ( a1 )
return std::ostream::operator<<(a2, a1);
else
return std::operator<<<std::char_traits<char>>(a2, "NULL");
}
| PrintValue<YGConfig>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x00196049
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x845758]
CALL 0x00135490
JMP 0x00196056
LAB_00196049:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x001353c0
LAB_00196056:
ADD RSP,0x10
POP RBP
RET
|
/* void testing::internal::PointerPrinter::PrintValue<YGConfig>(YGConfig*, std::ostream*) */
void testing::internal::PointerPrinter::PrintValue<YGConfig>(YGConfig *param_1,ostream *param_2)
{
if (param_1 == (YGConfig *)0x0) {
std::operator<<(param_2,"NULL");
}
else {
std::ostream::operator<<(param_2,param_1);
}
return;
}
| |
28,417 | 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>>>>>::get_token_string() const | monkey531[P]llama/common/./json.hpp | std::string get_token_string() const
{
// escape control characters
std::string result;
for (const auto c : token_string)
{
if (static_cast<unsigned char>(c) <= '\x1F')
{
// escape control characters
std::array<char, 9> cs{{}};
static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
result += cs.data();
}
else
{
// add character as is
result.push_back(static_cast<std::string::value_type>(c));
}
}
return result;
} | O0 | 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>>>>>::get_token_string() const:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x67(%rsp)
callq 0x525d0
movq 0x20(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x7b600
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x7b630
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x7b660
testb $0x1, %al
jne 0x1b4ca3
jmp 0x1b4d5b
leaq 0x50(%rsp), %rdi
callq 0x7b6a0
movb (%rax), %al
movb %al, 0x47(%rsp)
movzbl 0x47(%rsp), %eax
cmpl $0x1f, %eax
jg 0x1b4d37
movb $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7b6b0
movq 0x8(%rsp), %rdi
movq %rax, (%rsp)
callq 0x7b6c0
movq (%rsp), %rdi
movq %rax, %rsi
movzbl 0x47(%rsp), %ecx
leaq 0x27583(%rip), %rdx # 0x1dc27e
xorl %eax, %eax
callq 0x52870
movq 0x8(%rsp), %rdi
callq 0x7b6b0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x52290
jmp 0x1b4d1b
jmp 0x1b4d4a
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x53408
jmp 0x1b4d7b
movq 0x10(%rsp), %rdi
movsbl 0x47(%rsp), %esi
callq 0x53340
jmp 0x1b4d48
jmp 0x1b4d4a
jmp 0x1b4d4c
leaq 0x50(%rsp), %rdi
callq 0x7b6d0
jmp 0x1b4c8b
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x1b4d71
movq 0x10(%rsp), %rdi
callq 0x53408
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x52ae0
nopw %cs:(%rax,%rax)
nop
| _ZNK8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcS5_IcSA_EEEEEE16get_token_stringEv:
sub rsp, 78h
mov [rsp+78h+var_68], rdi
mov rax, rdi
mov [rsp+78h+var_60], rax
mov [rsp+78h+var_8], rdi
mov [rsp+78h+var_10], rsi
mov rax, [rsp+78h+var_10]
mov [rsp+78h+var_58], rax
mov [rsp+78h+var_11], 0
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rax, [rsp+78h+var_58]
add rax, 38h ; '8'
mov [rsp+78h+var_20], rax
mov rdi, [rsp+78h+var_20]
call _ZNKSt6vectorIcSaIcEE5beginEv; std::vector<char>::begin(void)
mov [rsp+78h+var_28], rax
mov rdi, [rsp+78h+var_20]
call _ZNKSt6vectorIcSaIcEE3endEv; std::vector<char>::end(void)
mov [rsp+78h+var_30], rax
loc_1B4C8B:
lea rdi, [rsp+78h+var_28]
lea rsi, [rsp+78h+var_30]
call _ZN9__gnu_cxxneIPKcSt6vectorIcSaIcEEEEbRKNS_17__normal_iteratorIT_T0_EESB_; __gnu_cxx::operator!=<char const*,std::vector<char>>(__gnu_cxx::__normal_iterator<char const*,std::vector<char>> const&,__gnu_cxx::__normal_iterator<char const*,std::vector<char>> const&)
test al, 1
jnz short loc_1B4CA3
jmp loc_1B4D5B
loc_1B4CA3:
lea rdi, [rsp+78h+var_28]
call _ZNK9__gnu_cxx17__normal_iteratorIPKcSt6vectorIcSaIcEEEdeEv; __gnu_cxx::__normal_iterator<char const*,std::vector<char>>::operator*(void)
mov al, [rax]
mov [rsp+78h+var_31], al
movzx eax, [rsp+78h+var_31]
cmp eax, 1Fh
jg short loc_1B4D37
mov [rsp+78h+var_38], 0
mov [rsp+78h+var_40], 0
lea rdi, [rsp+78h+var_40]
mov [rsp+78h+var_70], rdi
call _ZNSt5arrayIcLm9EE4dataEv; std::array<char,9ul>::data(void)
mov rdi, [rsp+78h+var_70]
mov [rsp+78h+var_78], rax
call _ZNKSt5arrayIcLm9EE4sizeEv; std::array<char,9ul>::size(void)
mov rdi, [rsp+78h+var_78]
mov rsi, rax
movzx ecx, [rsp+78h+var_31]
lea rdx, aU4x; "<U+%.4X>"
xor eax, eax
call _snprintf
mov rdi, [rsp+78h+var_70]
call _ZNSt5arrayIcLm9EE4dataEv; std::array<char,9ul>::data(void)
mov rdi, [rsp+78h+var_68]
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLEPKc; std::string::operator+=(char const*)
jmp short $+2
loc_1B4D1B:
jmp short loc_1B4D4A
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_1B4D7B
loc_1B4D37:
mov rdi, [rsp+78h+var_68]
movsx esi, [rsp+78h+var_31]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short $+2
loc_1B4D48:
jmp short $+2
loc_1B4D4A:
jmp short $+2
loc_1B4D4C:
lea rdi, [rsp+78h+var_28]
call _ZN9__gnu_cxx17__normal_iteratorIPKcSt6vectorIcSaIcEEEppEv; __gnu_cxx::__normal_iterator<char const*,std::vector<char>>::operator++(void)
jmp loc_1B4C8B
loc_1B4D5B:
mov [rsp+78h+var_11], 1
test [rsp+78h+var_11], 1
jnz short loc_1B4D71
mov rdi, [rsp+78h+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1B4D71:
mov rax, [rsp+78h+var_60]
add rsp, 78h
retn
loc_1B4D7B:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
| 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::vector<char>>>>::get_token_string(
long long a1,
long long a2)
{
long long v2; // rax
long long v3; // rax
long long v5; // [rsp+0h] [rbp-78h]
long long v6; // [rsp+38h] [rbp-40h] BYREF
char v7; // [rsp+40h] [rbp-38h]
unsigned __int8 v8; // [rsp+47h] [rbp-31h]
long long v9; // [rsp+48h] [rbp-30h] BYREF
_QWORD v10[2]; // [rsp+50h] [rbp-28h] BYREF
char v11; // [rsp+67h] [rbp-11h]
long long v12; // [rsp+68h] [rbp-10h]
long long v13; // [rsp+70h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = 0;
std::string::basic_string(a1);
v10[1] = a2 + 56;
v10[0] = std::vector<char>::begin(a2 + 56);
v9 = std::vector<char>::end(a2 + 56);
while ( __gnu_cxx::operator!=<char const*,std::vector<char>>((long long)v10, (long long)&v9) )
{
v8 = *(_BYTE *)__gnu_cxx::__normal_iterator<char const*,std::vector<char>>::operator*((long long)v10);
if ( v8 > 0x1Fu )
{
std::string::push_back(a1, (unsigned int)(char)v8);
}
else
{
v7 = 0;
v6 = 0LL;
v5 = std::array<char,9ul>::data((long long)&v6);
v2 = std::array<char,9ul>::size();
snprintf(v5, v2, "<U+%.4X>", v8);
v3 = std::array<char,9ul>::data((long long)&v6);
std::string::operator+=(a1, v3);
}
__gnu_cxx::__normal_iterator<char const*,std::vector<char>>::operator++(v10);
}
return a1;
}
| 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>>:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
MOV RAX,qword ptr [RSP + 0x10]
MOVZX ESI,byte ptr [RAX]
CALL 0x0018d9e0
MOV RAX,qword ptr [RSP + 0x10]
MOV byte ptr [RAX],0x3
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,RSP
CALL 0x001b4c90
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,0x1
CALL 0x00187bc0
ADD RSP,0x18
RET
|
/* void
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)3>::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> >(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, 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::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::string_t&&) */
void nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)3>::
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>>
(basic_json *param_1,string_t *param_2)
{
int8 local_18;
string *local_10;
basic_json *local_8;
local_10 = (string *)param_2;
local_8 = param_1;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy((json_value *)(param_1 + 8),*param_1);
*local_8 = (basic_json)0x3;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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::json_value((json_value *)&local_18,local_10);
*(int8 *)(local_8 + 8) = local_18;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_8,0));
return;
}
| |
28,418 | ma_apply_redo_index_new_page | eloqsql/storage/maria/ma_key_recover.c | uint _ma_apply_redo_index_new_page(MARIA_HA *info, LSN lsn,
const uchar *header, uint length)
{
pgcache_page_no_t root_page= page_korr(header);
pgcache_page_no_t free_page= page_korr(header + PAGE_STORE_SIZE);
uint key_nr= key_nr_korr(header + PAGE_STORE_SIZE * 2);
my_bool page_type_flag= header[PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE];
enum pagecache_page_lock unlock_method;
enum pagecache_page_pin unpin_method;
MARIA_PINNED_PAGE page_link;
my_off_t file_size;
uchar *buff;
uint result;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_apply_redo_index_new_page");
DBUG_PRINT("enter", ("root_page: %lu free_page: %lu",
(ulong) root_page, (ulong) free_page));
/* Set header to point at key data */
share->state.changed|= (STATE_CHANGED | STATE_NOT_OPTIMIZED_KEYS |
STATE_NOT_SORTED_PAGES | STATE_NOT_ZEROFILLED |
STATE_NOT_MOVABLE);
header+= PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE + 1;
length-= PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE + 1;
file_size= (my_off_t) (root_page + 1) * share->block_size;
if (cmp_translog_addr(lsn, share->state.is_of_horizon) >= 0)
{
/* free_page is 0 if we shouldn't set key_del */
if (free_page)
{
if (free_page != IMPOSSIBLE_PAGE_NO)
share->state.key_del= (my_off_t) free_page * share->block_size;
else
share->state.key_del= HA_OFFSET_ERROR;
}
if (page_type_flag) /* root page */
share->state.key_root[key_nr]= file_size - share->block_size;
}
if (file_size > share->state.state.key_file_length)
{
share->state.state.key_file_length= file_size;
buff= info->keyread_buff;
info->keyread_buff_used= 1;
unlock_method= PAGECACHE_LOCK_WRITE;
unpin_method= PAGECACHE_PIN;
}
else
{
if (!(buff= pagecache_read(share->pagecache, &share->kfile,
root_page, 0, 0,
PAGECACHE_PLAIN_PAGE, PAGECACHE_LOCK_WRITE,
&page_link.link)))
{
if (my_errno != HA_ERR_FILE_TOO_SHORT &&
my_errno != HA_ERR_WRONG_CRC &&
my_errno != HA_ERR_DECRYPTION_FAILED)
{
result= 1;
_ma_set_fatal_error(info, my_errno);
goto err;
}
buff= pagecache_block_link_to_buffer(page_link.link);
}
else if (lsn_korr(buff) >= lsn)
{
/* Already applied */
check_skipped_lsn(info, lsn_korr(buff), 0, root_page);
result= 0;
goto err;
}
unlock_method= PAGECACHE_LOCK_LEFT_WRITELOCKED;
unpin_method= PAGECACHE_PIN_LEFT_PINNED;
}
/* Write modified page */
bzero(buff, LSN_STORE_SIZE);
memcpy(buff + LSN_STORE_SIZE, header, length);
bzero(buff + LSN_STORE_SIZE + length,
share->max_index_block_size - LSN_STORE_SIZE - length);
bfill(buff + share->block_size - KEYPAGE_CHECKSUM_SIZE,
KEYPAGE_CHECKSUM_SIZE, (uchar) 255);
result= 0;
if (unlock_method == PAGECACHE_LOCK_WRITE &&
pagecache_write(share->pagecache,
&share->kfile, root_page, 0,
buff, PAGECACHE_PLAIN_PAGE,
unlock_method, unpin_method,
PAGECACHE_WRITE_DELAY, &page_link.link,
LSN_IMPOSSIBLE))
result= 1;
/* Mark page to be unlocked and written at _ma_unpin_all_pages() */
page_link.unlock= PAGECACHE_LOCK_WRITE_UNLOCK;
page_link.changed= 1;
push_dynamic(&info->pinned_pages, (void*) &page_link);
DBUG_RETURN(result);
err:
pagecache_unlock_by_link(share->pagecache, page_link.link,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 0, FALSE);
DBUG_RETURN(result);
} | O0 | c | ma_apply_redo_index_new_page:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x70c80
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
addq $0x5, %rdi
callq 0x70c80
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movzbl 0xa(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x30(%rbp), %rax
movb 0xb(%rax), %al
movb %al, -0x4d(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
jmp 0x70860
movq -0x90(%rbp), %rax
movl 0x170(%rax), %ecx
orl $0x1b1, %ecx # imm = 0x1B1
movl %ecx, 0x170(%rax)
movq -0x30(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
subl $0xc, %eax
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq -0x90(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
imulq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rax
movq -0x90(%rbp), %rcx
subq 0x180(%rcx), %rax
cmpq $0x0, %rax
jl 0x70948
cmpq $0x0, -0x48(%rbp)
je 0x70917
movabsq $0xffffffffff, %rax # imm = 0xFFFFFFFFFF
cmpq %rax, -0x48(%rbp)
je 0x70903
movq -0x48(%rbp), %rcx
movq -0x90(%rbp), %rax
movl 0x7bc(%rax), %eax
imulq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x120(%rax)
jmp 0x70915
movq -0x90(%rbp), %rax
movq $-0x1, 0x120(%rax)
jmp 0x70917
cmpb $0x0, -0x4d(%rbp)
je 0x70946
movq -0x78(%rbp), %rdx
movq -0x90(%rbp), %rax
movl 0x7bc(%rax), %eax
subq %rax, %rdx
movq -0x90(%rbp), %rax
movq 0x118(%rax), %rax
movl -0x4c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x70948
movq -0x78(%rbp), %rax
movq -0x90(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jbe 0x70995
movq -0x78(%rbp), %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq 0x380(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0x685(%rax)
movl $0x4, -0x54(%rbp)
movl $0x2, -0x58(%rbp)
jmp 0x70add
movq -0x90(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x90(%rbp), %rsi
addq $0x750, %rsi # imm = 0x750
movq -0x40(%rbp), %rdx
leaq -0x70(%rbp), %rax
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
movl $0x4, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x589a0
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
jne 0x70a45
callq 0xf55f0
cmpl $0xaf, (%rax)
je 0x70a33
callq 0xf55f0
cmpl $0xb0, (%rax)
je 0x70a33
callq 0xf55f0
cmpl $0xc0, (%rax)
je 0x70a33
movl $0x1, -0x84(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0xf55f0
movq -0x98(%rbp), %rdi
movl (%rax), %esi
callq 0x2e940
jmp 0x70c23
movq -0x70(%rbp), %rdi
callq 0x5b4f0
movq %rax, -0x80(%rbp)
jmp 0x70acf
movq -0x80(%rbp), %rax
movzbl (%rax), %eax
movq -0x80(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x80(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
shlq $0x20, %rax
movq -0x80(%rbp), %rcx
movl 0x3(%rcx), %ecx
orq %rcx, %rax
cmpq -0x28(%rbp), %rax
jl 0x70acd
movq -0x20(%rbp), %rdi
movq -0x80(%rbp), %rax
movzbl (%rax), %eax
movq -0x80(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x80(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x20, %rsi
movq -0x80(%rbp), %rax
movl 0x3(%rax), %eax
orq %rax, %rsi
movq -0x40(%rbp), %rcx
xorl %edx, %edx
callq 0x4f800
movl $0x0, -0x84(%rbp)
jmp 0x70c23
jmp 0x70acf
movl $0x2, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
movq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0x2a2b0
movq -0x80(%rbp), %rdi
addq $0x7, %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %eax
movl %eax, %edx
callq 0x2a0a0
movq -0x80(%rbp), %rdi
addq $0x7, %rdi
movl -0x34(%rbp), %eax
addq %rax, %rdi
movq -0x90(%rbp), %rax
movl 0x7c0(%rax), %eax
subl $0x7, %eax
subl -0x34(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2b0
movq -0x80(%rbp), %rdi
movq -0x90(%rbp), %rax
movl 0x7bc(%rax), %eax
addq %rax, %rdi
addq $-0x4, %rdi
movl $0xff, %esi
movl $0x4, %edx
callq 0x2a2b0
movl $0x0, -0x84(%rbp)
cmpl $0x4, -0x54(%rbp)
jne 0x70bf9
movq -0x90(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x90(%rbp), %rsi
addq $0x750, %rsi # imm = 0x750
movq -0x40(%rbp), %rdx
movq -0x80(%rbp), %r8
movl -0x54(%rbp), %ebx
movl -0x58(%rbp), %r11d
leaq -0x70(%rbp), %r10
movq -0x90(%rbp), %rax
movq 0x600(%rax), %rax
movl 0x80(%rax), %eax
xorl %ecx, %ecx
movl $0x1, %r9d
xorl %r14d, %r14d
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movl %eax, 0x30(%rsp)
callq 0x5a0a0
movsbl %al, %eax
cmpl $0x0, %eax
je 0x70bf9
movl $0x1, -0x84(%rbp)
movl $0x6, -0x68(%rbp)
movb $0x1, -0x60(%rbp)
movq -0x20(%rbp), %rdi
addq $0x2e8, %rdi # imm = 0x2E8
leaq -0x70(%rbp), %rsi
callq 0xd9f10
movl -0x84(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x70c66
movq -0x90(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x70(%rbp), %rsi
movl $0x6, %edx
movl $0x3, %ecx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %r8
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x58740
movl -0x84(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_apply_redo_index_new_page:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 0C0h
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov [rbp+var_30], rdx
mov [rbp+var_34], ecx
mov rdi, [rbp+var_30]
call uint5korr_0
mov [rbp+var_40], rax
mov rdi, [rbp+var_30]
add rdi, 5
call uint5korr_0
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+0Ah]
mov [rbp+var_4C], eax
mov rax, [rbp+var_30]
mov al, [rax+0Bh]
mov [rbp+var_4D], al
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_90], rax
jmp short $+2
loc_70860:
mov rax, [rbp+var_90]
mov ecx, [rax+170h]
or ecx, 1B1h
mov [rax+170h], ecx
mov rax, [rbp+var_30]
add rax, 0Ch
mov [rbp+var_30], rax
mov eax, [rbp+var_34]
sub eax, 0Ch
mov [rbp+var_34], eax
mov rax, [rbp+var_40]
add rax, 1
mov rcx, [rbp+var_90]
mov ecx, [rcx+7BCh]
imul rax, rcx
mov [rbp+var_78], rax
mov rax, [rbp+var_28]
mov rcx, [rbp+var_90]
sub rax, [rcx+180h]
cmp rax, 0
jl loc_70948
cmp [rbp+var_48], 0
jz short loc_70917
mov rax, 0FFFFFFFFFFh
cmp [rbp+var_48], rax
jz short loc_70903
mov rcx, [rbp+var_48]
mov rax, [rbp+var_90]
mov eax, [rax+7BCh]
imul rcx, rax
mov rax, [rbp+var_90]
mov [rax+120h], rcx
jmp short loc_70915
loc_70903:
mov rax, [rbp+var_90]
mov qword ptr [rax+120h], 0FFFFFFFFFFFFFFFFh
loc_70915:
jmp short $+2
loc_70917:
cmp [rbp+var_4D], 0
jz short loc_70946
mov rdx, [rbp+var_78]
mov rax, [rbp+var_90]
mov eax, [rax+7BCh]
sub rdx, rax
mov rax, [rbp+var_90]
mov rax, [rax+118h]
mov ecx, [rbp+var_4C]
mov [rax+rcx*8], rdx
loc_70946:
jmp short $+2
loc_70948:
mov rax, [rbp+var_78]
mov rcx, [rbp+var_90]
cmp rax, [rcx+38h]
jbe short loc_70995
mov rcx, [rbp+var_78]
mov rax, [rbp+var_90]
mov [rax+38h], rcx
mov rax, [rbp+var_20]
mov rax, [rax+380h]
mov [rbp+var_80], rax
mov rax, [rbp+var_20]
mov byte ptr [rax+685h], 1
mov [rbp+var_54], 4
mov [rbp+var_58], 2
jmp loc_70ADD
loc_70995:
mov rax, [rbp+var_90]
mov rdi, [rax+600h]
mov rsi, [rbp+var_90]
add rsi, 750h
mov rdx, [rbp+var_40]
lea rax, [rbp+var_70]
xor ecx, ecx
xor r8d, r8d
mov r9d, 1
mov [rsp+0D0h+var_D0], 4
mov [rsp+0D0h+var_C8], rax
call pagecache_read
mov [rbp+var_80], rax
cmp rax, 0
jnz short loc_70A45
call _my_thread_var
cmp dword ptr [rax], 0AFh
jz short loc_70A33
call _my_thread_var
cmp dword ptr [rax], 0B0h
jz short loc_70A33
call _my_thread_var
cmp dword ptr [rax], 0C0h
jz short loc_70A33
mov [rbp+var_84], 1
mov rax, [rbp+var_20]
mov [rbp+var_98], rax
call _my_thread_var
mov rdi, [rbp+var_98]
mov esi, [rax]
call _ma_set_fatal_error
jmp loc_70C23
loc_70A33:
mov rdi, [rbp+var_70]
call pagecache_block_link_to_buffer
mov [rbp+var_80], rax
jmp loc_70ACF
loc_70A45:
mov rax, [rbp+var_80]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_80]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_80]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
shl rax, 20h
mov rcx, [rbp+var_80]
mov ecx, [rcx+3]
or rax, rcx
cmp rax, [rbp+var_28]
jl short loc_70ACD
mov rdi, [rbp+var_20]
mov rax, [rbp+var_80]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_80]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_80]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
mov esi, eax
shl rsi, 20h
mov rax, [rbp+var_80]
mov eax, [rax+3]
or rsi, rax
mov rcx, [rbp+var_40]
xor edx, edx
call check_skipped_lsn
mov [rbp+var_84], 0
jmp loc_70C23
loc_70ACD:
jmp short $+2
loc_70ACF:
mov [rbp+var_54], 2
mov [rbp+var_58], 0
loc_70ADD:
mov rdi, [rbp+var_80]
xor esi, esi
mov edx, 7
call _memset
mov rdi, [rbp+var_80]
add rdi, 7
mov rsi, [rbp+var_30]
mov eax, [rbp+var_34]
mov edx, eax
call _memcpy
mov rdi, [rbp+var_80]
add rdi, 7
mov eax, [rbp+var_34]
add rdi, rax
mov rax, [rbp+var_90]
mov eax, [rax+7C0h]
sub eax, 7
sub eax, [rbp+var_34]
mov eax, eax
mov edx, eax
xor esi, esi
call _memset
mov rdi, [rbp+var_80]
mov rax, [rbp+var_90]
mov eax, [rax+7BCh]
add rdi, rax
add rdi, 0FFFFFFFFFFFFFFFCh
mov esi, 0FFh
mov edx, 4
call _memset
mov [rbp+var_84], 0
cmp [rbp+var_54], 4
jnz loc_70BF9
mov rax, [rbp+var_90]
mov rdi, [rax+600h]
mov rsi, [rbp+var_90]
add rsi, 750h
mov rdx, [rbp+var_40]
mov r8, [rbp+var_80]
mov ebx, [rbp+var_54]
mov r11d, [rbp+var_58]
lea r10, [rbp+var_70]
mov rax, [rbp+var_90]
mov rax, [rax+600h]
mov eax, [rax+80h]
xor ecx, ecx
mov r9d, 1
xor r14d, r14d
mov [rsp+0D0h+var_D0], ebx
mov dword ptr [rsp+0D0h+var_C8], r11d
mov [rsp+0D0h+var_C0], 0
mov [rsp+0D0h+var_B8], r10
mov [rsp+0D0h+var_B0], 0
mov [rsp+0D0h+var_A8], 0
mov [rsp+0D0h+var_A0], eax
call pagecache_write_part
movsx eax, al
cmp eax, 0
jz short loc_70BF9
mov [rbp+var_84], 1
loc_70BF9:
mov [rbp+var_68], 6
mov [rbp+var_60], 1
mov rdi, [rbp+var_20]
add rdi, 2E8h
lea rsi, [rbp+var_70]
call insert_dynamic
mov eax, [rbp+var_84]
mov [rbp+var_14], eax
jmp short loc_70C66
loc_70C23:
mov rax, [rbp+var_90]
mov rdi, [rax+600h]
mov rsi, [rbp+var_70]
mov edx, 6
mov ecx, 3
xor eax, eax
mov r9d, eax
xor eax, eax
mov r8, r9
mov [rsp+0D0h+var_D0], 0
mov dword ptr [rsp+0D0h+var_C8], 0
call pagecache_unlock_by_link
mov eax, [rbp+var_84]
mov [rbp+var_14], eax
loc_70C66:
mov eax, [rbp+var_14]
add rsp, 0C0h
pop rbx
pop r14
pop rbp
retn
| long long ma_apply_redo_index_new_page(_QWORD *a1, signed long long a2, long long a3, unsigned int a4, double a5)
{
int *v5; // rax
long long v6; // rdx
long long v7; // rcx
long long v8; // r8
int v9; // r9d
_DWORD *v11; // [rsp+38h] [rbp-98h]
long long v12; // [rsp+40h] [rbp-90h]
unsigned int v13; // [rsp+4Ch] [rbp-84h]
BOOL v14; // [rsp+4Ch] [rbp-84h]
unsigned __int16 *v15; // [rsp+50h] [rbp-80h]
unsigned long long v16; // [rsp+58h] [rbp-78h]
long long v17; // [rsp+60h] [rbp-70h] BYREF
int v18; // [rsp+68h] [rbp-68h]
char v19; // [rsp+70h] [rbp-60h]
unsigned int v20; // [rsp+78h] [rbp-58h]
int v21; // [rsp+7Ch] [rbp-54h]
char v22; // [rsp+83h] [rbp-4Dh]
unsigned int v23; // [rsp+84h] [rbp-4Ch]
long long v24; // [rsp+88h] [rbp-48h]
long long v25; // [rsp+90h] [rbp-40h]
unsigned int v26; // [rsp+9Ch] [rbp-34h]
long long v27; // [rsp+A0h] [rbp-30h]
signed long long v28; // [rsp+A8h] [rbp-28h]
_QWORD *v29; // [rsp+B0h] [rbp-20h]
v29 = a1;
v28 = a2;
v27 = a3;
v26 = a4;
v25 = uint5korr_0(a3);
v24 = uint5korr_0(v27 + 5);
v23 = *(unsigned __int8 *)(v27 + 10);
v22 = *(_BYTE *)(v27 + 11);
v12 = *a1;
*(_DWORD *)(v12 + 368) |= 0x1B1u;
v27 += 12LL;
v26 -= 12;
v16 = *(unsigned int *)(v12 + 1980) * (v25 + 1);
if ( v28 - *(_QWORD *)(v12 + 384) >= 0 )
{
if ( v24 )
{
if ( v24 == 0xFFFFFFFFFFLL )
*(_QWORD *)(v12 + 288) = -1LL;
else
*(_QWORD *)(v12 + 288) = *(unsigned int *)(v12 + 1980) * v24;
}
if ( v22 )
*(_QWORD *)(*(_QWORD *)(v12 + 280) + 8LL * v23) = v16 - *(unsigned int *)(v12 + 1980);
}
if ( v16 <= *(_QWORD *)(v12 + 56) )
{
v15 = (unsigned __int16 *)pagecache_read(*(_QWORD **)(v12 + 1536), v12 + 1872, v25, 0, 0LL, 1, a5, 4u, (char *)&v17);
if ( v15 )
{
if ( (long long)(*(unsigned int *)((char *)v15 + 3) | ((unsigned long long)((*((unsigned __int8 *)v15 + 2) << 16) | (unsigned int)*v15) << 32)) >= v28 )
{
check_skipped_lsn(
(long long)v29,
*(unsigned int *)((char *)v15 + 3) | ((unsigned long long)((*((unsigned __int8 *)v15 + 2) << 16) | (unsigned int)*v15) << 32),
0,
v25);
v13 = 0;
goto LABEL_22;
}
}
else
{
if ( *(_DWORD *)my_thread_var(a5) != 175
&& *(_DWORD *)my_thread_var(a5) != 176
&& *(_DWORD *)my_thread_var(a5) != 192 )
{
v13 = 1;
v11 = v29;
v5 = (int *)my_thread_var(a5);
ma_set_fatal_error(v11, *v5, v6, v7, v8, v9);
LABEL_22:
pagecache_unlock_by_link(*(_QWORD **)(v12 + 1536), v17, 6, 3, 0LL, 0LL, 0, 0);
return v13;
}
v15 = (unsigned __int16 *)pagecache_block_link_to_buffer(v17);
}
v21 = 2;
v20 = 0;
memset(v15, 0LL, 7LL);
goto LABEL_19;
}
*(_QWORD *)(v12 + 56) = v16;
v15 = (unsigned __int16 *)v29[112];
*((_BYTE *)v29 + 1669) = 1;
v21 = 4;
v20 = 2;
memset(v15, 0LL, 7LL);
LABEL_19:
memcpy((char *)v15 + 7, v27, v26);
memset((char *)v15 + v26 + 7, 0LL, *(_DWORD *)(v12 + 1984) - 7 - v26);
memset((char *)v15 + *(unsigned int *)(v12 + 1980) - 4, 255LL, 4LL);
v14 = 0;
if ( v21 == 4 )
v14 = pagecache_write_part(
*(_QWORD **)(v12 + 1536),
v12 + 1872,
v25,
0,
(long long)v15,
1u,
a5,
4u,
v20,
0,
(char *)&v17,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(v12 + 1536) + 128LL)) != 0;
v18 = 6;
v19 = 1;
insert_dynamic(v29 + 93, &v17);
return v14;
}
| _ma_apply_redo_index_new_page:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0xc0
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV qword ptr [RBP + -0x30],RDX
MOV dword ptr [RBP + -0x34],ECX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00170c80
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x5
CALL 0x00170c80
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0xa]
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV AL,byte ptr [RAX + 0xb]
MOV byte ptr [RBP + -0x4d],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x00170860
LAB_00170860:
MOV RAX,qword ptr [RBP + -0x90]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x1b1
MOV dword ptr [RAX + 0x170],ECX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0xc
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0xc
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV RCX,qword ptr [RBP + -0x90]
MOV ECX,dword ptr [RCX + 0x7bc]
IMUL RAX,RCX
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x90]
SUB RAX,qword ptr [RCX + 0x180]
CMP RAX,0x0
JL 0x00170948
CMP qword ptr [RBP + -0x48],0x0
JZ 0x00170917
MOV RAX,0xffffffffff
CMP qword ptr [RBP + -0x48],RAX
JZ 0x00170903
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x90]
MOV EAX,dword ptr [RAX + 0x7bc]
IMUL RCX,RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RAX + 0x120],RCX
JMP 0x00170915
LAB_00170903:
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RAX + 0x120],-0x1
LAB_00170915:
JMP 0x00170917
LAB_00170917:
CMP byte ptr [RBP + -0x4d],0x0
JZ 0x00170946
MOV RDX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x90]
MOV EAX,dword ptr [RAX + 0x7bc]
SUB RDX,RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RAX + 0x118]
MOV ECX,dword ptr [RBP + -0x4c]
MOV qword ptr [RAX + RCX*0x8],RDX
LAB_00170946:
JMP 0x00170948
LAB_00170948:
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x90]
CMP RAX,qword ptr [RCX + 0x38]
JBE 0x00170995
MOV RCX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x380]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x685],0x1
MOV dword ptr [RBP + -0x54],0x4
MOV dword ptr [RBP + -0x58],0x2
JMP 0x00170add
LAB_00170995:
MOV RAX,qword ptr [RBP + -0x90]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x90]
ADD RSI,0x750
MOV RDX,qword ptr [RBP + -0x40]
LEA RAX,[RBP + -0x70]
XOR ECX,ECX
XOR R8D,R8D
MOV R9D,0x1
MOV dword ptr [RSP],0x4
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001589a0
MOV qword ptr [RBP + -0x80],RAX
CMP RAX,0x0
JNZ 0x00170a45
CALL 0x001f55f0
CMP dword ptr [RAX],0xaf
JZ 0x00170a33
CALL 0x001f55f0
CMP dword ptr [RAX],0xb0
JZ 0x00170a33
CALL 0x001f55f0
CMP dword ptr [RAX],0xc0
JZ 0x00170a33
MOV dword ptr [RBP + -0x84],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x98],RAX
CALL 0x001f55f0
MOV RDI,qword ptr [RBP + -0x98]
MOV ESI,dword ptr [RAX]
CALL 0x0012e940
JMP 0x00170c23
LAB_00170a33:
MOV RDI,qword ptr [RBP + -0x70]
CALL 0x0015b4f0
MOV qword ptr [RBP + -0x80],RAX
JMP 0x00170acf
LAB_00170a45:
MOV RAX,qword ptr [RBP + -0x80]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x80]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x80]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
SHL RAX,0x20
MOV RCX,qword ptr [RBP + -0x80]
MOV ECX,dword ptr [RCX + 0x3]
OR RAX,RCX
CMP RAX,qword ptr [RBP + -0x28]
JL 0x00170acd
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x80]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x80]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x80]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
MOV ESI,EAX
SHL RSI,0x20
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x3]
OR RSI,RAX
MOV RCX,qword ptr [RBP + -0x40]
XOR EDX,EDX
CALL 0x0014f800
MOV dword ptr [RBP + -0x84],0x0
JMP 0x00170c23
LAB_00170acd:
JMP 0x00170acf
LAB_00170acf:
MOV dword ptr [RBP + -0x54],0x2
MOV dword ptr [RBP + -0x58],0x0
LAB_00170add:
MOV RDI,qword ptr [RBP + -0x80]
XOR ESI,ESI
MOV EDX,0x7
CALL 0x0012a2b0
MOV RDI,qword ptr [RBP + -0x80]
ADD RDI,0x7
MOV RSI,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x34]
MOV EDX,EAX
CALL 0x0012a0a0
MOV RDI,qword ptr [RBP + -0x80]
ADD RDI,0x7
MOV EAX,dword ptr [RBP + -0x34]
ADD RDI,RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV EAX,dword ptr [RAX + 0x7c0]
SUB EAX,0x7
SUB EAX,dword ptr [RBP + -0x34]
MOV EAX,EAX
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2b0
MOV RDI,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RBP + -0x90]
MOV EAX,dword ptr [RAX + 0x7bc]
ADD RDI,RAX
ADD RDI,-0x4
MOV ESI,0xff
MOV EDX,0x4
CALL 0x0012a2b0
MOV dword ptr [RBP + -0x84],0x0
CMP dword ptr [RBP + -0x54],0x4
JNZ 0x00170bf9
MOV RAX,qword ptr [RBP + -0x90]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x90]
ADD RSI,0x750
MOV RDX,qword ptr [RBP + -0x40]
MOV R8,qword ptr [RBP + -0x80]
MOV EBX,dword ptr [RBP + -0x54]
MOV R11D,dword ptr [RBP + -0x58]
LEA R10,[RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RAX + 0x600]
MOV EAX,dword ptr [RAX + 0x80]
XOR ECX,ECX
MOV R9D,0x1
XOR R14D,R14D
MOV dword ptr [RSP],EBX
MOV dword ptr [RSP + 0x8],R11D
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],R10
MOV qword ptr [RSP + 0x20],0x0
MOV dword ptr [RSP + 0x28],0x0
MOV dword ptr [RSP + 0x30],EAX
CALL 0x0015a0a0
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00170bf9
MOV dword ptr [RBP + -0x84],0x1
LAB_00170bf9:
MOV dword ptr [RBP + -0x68],0x6
MOV byte ptr [RBP + -0x60],0x1
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x2e8
LEA RSI,[RBP + -0x70]
CALL 0x001d9f10
MOV EAX,dword ptr [RBP + -0x84]
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00170c66
LAB_00170c23:
MOV RAX,qword ptr [RBP + -0x90]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x70]
MOV EDX,0x6
MOV ECX,0x3
XOR EAX,EAX
MOV R9D,EAX
XOR EAX,EAX
MOV R8,R9
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
CALL 0x00158740
MOV EAX,dword ptr [RBP + -0x84]
MOV dword ptr [RBP + -0x14],EAX
LAB_00170c66:
MOV EAX,dword ptr [RBP + -0x14]
ADD RSP,0xc0
POP RBX
POP R14
POP RBP
RET
|
int4 _ma_apply_redo_index_new_page(long *param_1,long param_2,long param_3,int param_4)
{
long lVar1;
long *plVar2;
char cVar3;
ulong uVar4;
int *piVar5;
int4 *puVar6;
int8 *puVar7;
int4 local_8c;
int3 *local_88;
int8 local_78;
int4 local_70;
int1 local_68;
int4 local_60;
int local_5c;
char local_55;
uint local_54;
long local_50;
long local_48;
uint local_3c;
void *local_38;
long local_30;
long *local_28;
local_3c = param_4;
local_38 = (void *)param_3;
local_30 = param_2;
local_28 = param_1;
local_48 = uint5korr(param_3);
local_50 = uint5korr((long)local_38 + 5);
local_54 = (uint)*(byte *)((long)local_38 + 10);
local_55 = *(char *)((long)local_38 + 0xb);
lVar1 = *local_28;
*(uint *)(lVar1 + 0x170) = *(uint *)(lVar1 + 0x170) | 0x1b1;
local_38 = (void *)((long)local_38 + 0xc);
local_3c = local_3c - 0xc;
uVar4 = (local_48 + 1) * (ulong)*(uint *)(lVar1 + 0x7bc);
if (-1 < local_30 - *(long *)(lVar1 + 0x180)) {
if (local_50 != 0) {
if (local_50 == 0xffffffffff) {
*(int8 *)(lVar1 + 0x120) = 0xffffffffffffffff;
}
else {
*(ulong *)(lVar1 + 0x120) = local_50 * (ulong)*(uint *)(lVar1 + 0x7bc);
}
}
if (local_55 != '\0') {
*(ulong *)(*(long *)(lVar1 + 0x118) + (ulong)local_54 * 8) = uVar4 - *(uint *)(lVar1 + 0x7bc);
}
}
if (*(ulong *)(lVar1 + 0x38) < uVar4) {
*(ulong *)(lVar1 + 0x38) = uVar4;
local_88 = (int3 *)local_28[0x70];
*(int1 *)((long)local_28 + 0x685) = 1;
local_5c = 4;
local_60 = 2;
}
else {
puVar7 = &local_78;
local_88 = (int3 *)
pagecache_read(*(int8 *)(lVar1 + 0x600),lVar1 + 0x750,local_48,0,0,1,4,puVar7);
if (local_88 == (int3 *)0x0) {
piVar5 = (int *)_my_thread_var();
if (((*piVar5 != 0xaf) && (piVar5 = (int *)_my_thread_var(), *piVar5 != 0xb0)) &&
(piVar5 = (int *)_my_thread_var(), plVar2 = local_28, *piVar5 != 0xc0)) {
local_8c = 1;
puVar6 = (int4 *)_my_thread_var();
_ma_set_fatal_error(plVar2,*puVar6);
LAB_00170c23:
pagecache_unlock_by_link
(*(int8 *)(lVar1 + 0x600),local_78,6,3,0,0,0,
(ulong)puVar7 & 0xffffffff00000000);
return local_8c;
}
local_88 = (int3 *)pagecache_block_link_to_buffer(local_78);
}
else if (local_30 <= (long)(ulong)CONCAT34(*local_88,*(int4 *)((long)local_88 + 3))) {
check_skipped_lsn(local_28,(ulong)CONCAT34(*local_88,*(int4 *)((long)local_88 + 3)),0,
local_48);
local_8c = 0;
goto LAB_00170c23;
}
local_5c = 2;
local_60 = 0;
}
memset(local_88,0,7);
memcpy((void *)((long)local_88 + 7),local_38,(ulong)local_3c);
memset((void *)((long)local_88 + (ulong)local_3c + 7),0,
(ulong)((*(int *)(lVar1 + 0x7c0) + -7) - local_3c));
memset((void *)((long)local_88 + ((ulong)*(uint *)(lVar1 + 0x7bc) - 4)),0xff,4);
local_8c = 0;
if ((local_5c == 4) &&
(cVar3 = pagecache_write_part
(*(int8 *)(lVar1 + 0x600),lVar1 + 0x750,local_48,0,local_88,1,4,
local_60,0,&local_78,0,0,*(int4 *)(*(long *)(lVar1 + 0x600) + 0x80)),
cVar3 != '\0')) {
local_8c = 1;
}
local_70 = 6;
local_68 = 1;
insert_dynamic(local_28 + 0x5d,&local_78);
return local_8c;
}
| |
28,419 | ma_delete_block_record | eloqsql/storage/maria/ma_blockrec.c | my_bool _ma_delete_block_record(MARIA_HA *info, const uchar *record)
{
pgcache_page_no_t page;
uint record_number;
MARIA_SHARE *share= info->s;
LSN lsn= LSN_IMPOSSIBLE;
DBUG_ENTER("_ma_delete_block_record");
page= ma_recordpos_to_page(info->cur_row.lastpos);
record_number= ma_recordpos_to_dir_entry(info->cur_row.lastpos);
DBUG_PRINT("enter", ("rowid: %lu (%lu:%u)", (ulong) info->cur_row.lastpos,
(ulong) page, record_number));
_ma_bitmap_flushable(info, 1);
if (delete_head_or_tail(info, page, record_number, 1, 0) ||
delete_tails(info, info->cur_row.tail_positions))
goto err;
if (info->cur_row.extents_count && free_full_pages(info, &info->cur_row))
goto err;
if (share->now_transactional)
{
uchar log_data[LSN_STORE_SIZE + FILEID_STORE_SIZE + PAGE_STORE_SIZE +
DIRPOS_STORE_SIZE + 2 + PAGERANGE_STORE_SIZE +
HA_CHECKSUM_STORE_SIZE];
uchar *log_pos;
size_t row_length;
uint row_parts_count, extents_length;
ha_checksum checksum_delta;
/* Write UNDO record */
lsn_store(log_data, info->trn->undo_lsn);
page_store(log_data + LSN_STORE_SIZE + FILEID_STORE_SIZE, page);
log_pos= log_data + LSN_STORE_SIZE + FILEID_STORE_SIZE + PAGE_STORE_SIZE;
dirpos_store(log_pos, record_number);
log_pos+= DIRPOS_STORE_SIZE;
int2store(log_pos, info->cur_row.head_length -
info->cur_row.header_length);
log_pos+= 2;
pagerange_store(log_pos, info->cur_row.extents_count);
log_pos+= PAGERANGE_STORE_SIZE;
info->log_row_parts[TRANSLOG_INTERNAL_PARTS].str= log_data;
info->log_row_parts[TRANSLOG_INTERNAL_PARTS].length=
sizeof(log_data) - HA_CHECKSUM_STORE_SIZE;
store_checksum_in_rec(share, checksum_delta,
(ha_checksum) 0 - info->cur_row.checksum, log_pos,
info->log_row_parts[TRANSLOG_INTERNAL_PARTS +
0].length);
info->log_row_parts[TRANSLOG_INTERNAL_PARTS+1].str=
info->cur_row.extents;
info->log_row_parts[TRANSLOG_INTERNAL_PARTS+1].length=
extents_length= info->cur_row.extents_count * ROW_EXTENT_SIZE;
row_length= fill_insert_undo_parts(info, record,
(info->log_row_parts +
TRANSLOG_INTERNAL_PARTS + 2),
&row_parts_count);
if (translog_write_record(&lsn, LOGREC_UNDO_ROW_DELETE, info->trn,
info,
(translog_size_t)
(info->log_row_parts[TRANSLOG_INTERNAL_PARTS +
0].length + row_length +
extents_length),
TRANSLOG_INTERNAL_PARTS + 2 + row_parts_count,
info->log_row_parts,
log_data + LSN_STORE_SIZE,
&checksum_delta))
goto err;
}
_ma_bitmap_flushable(info, -1);
_ma_unpin_all_pages_and_finalize_row(info, lsn);
DBUG_RETURN(0);
err:
DBUG_ASSERT(!maria_assert_if_crashed_table);
_ma_bitmap_flushable(info, -1);
_ma_unpin_all_pages_and_finalize_row(info, LSN_IMPOSSIBLE);
DBUG_RETURN(1);
} | O3 | c | ma_delete_block_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %r14
movq $0x0, -0x78(%rbp)
movq 0x98(%rdi), %r13
movq %r13, %r15
shrq $0x8, %r15
movzbl %r13b, %r12d
movl $0x1, %esi
callq 0x3e611
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x355cd
testb %al, %al
jne 0x35cb3
movq 0xa8(%rbx), %rsi
movq %rbx, %rdi
callq 0x360b8
testb %al, %al
je 0x35d01
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x3e611
movb $0x1, %r14b
xorl %esi, %esi
movq %rbx, %rdi
callq 0x604f8
movq 0x8(%rbx), %rax
movq $0x0, 0x90(%rax)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x360b3
movl %r14d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0x12c(%rbx)
je 0x35d1d
leaq 0x80(%rbx), %rsi
movq %rbx, %rdi
callq 0x3611f
testb %al, %al
jne 0x35cb3
cmpb $0x0, 0x7e7(%r14)
je 0x3609a
movq 0x8(%rbx), %rax
movq 0x98(%rax), %rax
movq %rax, %rcx
shrq $0x20, %rcx
leaq -0x50(%rbp), %rdx
movb %cl, (%rdx)
movq %rax, %rcx
shrq $0x28, %rcx
movb %cl, 0x1(%rdx)
movq %rax, %rcx
shrq $0x30, %rcx
movb %cl, 0x2(%rdx)
movl %eax, 0x3(%rdx)
movl %r15d, 0x9(%rdx)
movq %r13, %rax
shrq $0x28, %rax
movb %al, 0xd(%rdx)
movb %r13b, 0xe(%rdx)
movl 0x120(%rbx), %eax
subl 0x124(%rbx), %eax
movw %ax, 0xf(%rdx)
movzwl 0x12c(%rbx), %eax
movw %ax, 0x11(%rdx)
movq 0x318(%rbx), %rax
movq %rdx, 0x20(%rax)
movq 0x318(%rbx), %rax
movq $0x13, 0x28(%rax)
movl $0x0, -0x5c(%rbp)
cmpq $0x0, 0x6a8(%r14)
je 0x35dcc
xorl %eax, %eax
subl 0xb0(%rbx), %eax
movl %eax, -0x5c(%rbp)
movl %eax, -0x3d(%rbp)
movq 0x318(%rbx), %rax
addq $0x4, 0x28(%rax)
movq 0x90(%rbx), %rax
movq 0x318(%rbx), %rcx
movq %rax, 0x30(%rcx)
movl 0x12c(%rbx), %eax
leal (,%rax,8), %ecx
subl %eax, %ecx
movq 0x318(%rbx), %rax
movq %rcx, -0x80(%rbp)
movq %rcx, 0x38(%rax)
movq 0x318(%rbx), %rdx
movq (%rbx), %r13
movq 0xd0(%rbx), %rsi
movq -0x58(%rbp), %rdi
movq %rdi, 0x40(%rdx)
movl 0x3fc(%r13), %eax
movq %rax, 0x48(%rdx)
movq 0xc8(%rbx), %rcx
movq %rcx, 0x50(%rdx)
movl 0x3f4(%r13), %r15d
movq %r15, 0x58(%rdx)
addq %rax, %r15
cmpl $0x0, 0x3d4(%r13)
je 0x35e6d
leaq -0x2(%rsi), %rax
movq %rax, 0x60(%rdx)
movl 0x128(%rbx), %eax
addl $0x2, %eax
movq %rax, 0x68(%rdx)
movzwl 0x128(%rbx), %eax
movw %ax, -0x2(%rsi)
addq 0x68(%rdx), %r15
leaq 0x70(%rdx), %r12
jmp 0x35e71
leaq 0x60(%rdx), %r12
movq %rsi, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
cmpl $0x0, 0x3f0(%r13)
je 0x35eae
leaq 0x6e8(%rbx), %rdi
movq %rdi, (%r12)
movq 0x108(%rbx), %rsi
callq 0x3767e
movq -0x58(%rbp), %rdi
subl (%r12), %eax
movq %rax, 0x8(%r12)
addq %rax, %r15
addq $0x10, %r12
movq 0x588(%r13), %r14
movl 0x3cc(%r13), %eax
testq %rax, %rax
je 0x35efe
imulq $0x38, %rax, %rax
addq %r14, %rax
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %r8
movl 0x4(%r14), %ecx
addq %rdi, %rcx
movq %rcx, (%r12)
movzwl 0x8(%r14), %ecx
movq %rcx, 0x8(%r12)
addq %rcx, %r15
addq $0x10, %r12
addq $0x38, %r14
cmpq %rax, %r14
jb 0x35ed0
movq 0x588(%r13), %rcx
jmp 0x35f09
movq %r14, %rcx
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %r8
movl 0x3c8(%r13), %edx
movl 0x3f0(%r13), %eax
imulq $0x38, %rdx, %rdx
addq %rcx, %rdx
movq %rax, %rcx
negq %rcx
imulq $0x38, %rcx, %r9
addq %rdx, %r9
cmpq %r9, %r14
movq %rbx, -0x88(%rbp)
jae 0x35fd7
movzwl 0xe(%r14), %eax
movb 0x12(%r14), %cl
testb %cl, (%rdi,%rax)
jne 0x35fbd
movq 0xc8(%rbx), %rax
movzwl 0x10(%r14), %ecx
movb 0x13(%r14), %dl
testb %dl, (%rax,%rcx)
jne 0x35fbd
movl (%r14), %edx
movl 0x4(%r14), %eax
addq %rdi, %rax
cmpl $0x8, %edx
je 0x35f88
movzwl 0x8(%r14), %ecx
cmpl $0x1, %edx
jne 0x35fad
cmpl $0xff, %ecx
ja 0x35f99
movzbl (%r8), %ecx
incq %r8
jmp 0x35fad
movzwl 0xc(%r14), %edx
cmpq $0x1, %rdx
jne 0x35fa3
movzbl (%r8), %ecx
jmp 0x35fa7
movzwl (%r8), %ecx
addq $0x2, %r8
jmp 0x35fad
movzwl (%r8), %ecx
addq %rdx, %r8
addq %rdx, %rax
movq %rax, (%r12)
movq %rcx, 0x8(%r12)
addq %rcx, %r15
addq $0x10, %r12
addq $0x38, %r14
cmpq %r9, %r14
jb 0x35f3b
movq %r15, -0x58(%rbp)
movl 0x3f0(%r13), %eax
jmp 0x35fdb
movq %r15, -0x58(%rbp)
addq $0x40, %rsi
movq %rsi, -0x68(%rbp)
imulq $0x38, %rax, %rax
addq %rax, %r9
cmpq %r9, %r14
jae 0x3603d
movq %r9, %r15
movl 0x4(%r14), %esi
addq %rdi, %rsi
movzwl 0x8(%r14), %r13d
addl $-0x8, %r13d
movq %rdi, %rbx
movl %r13d, %edi
callq 0x691c3
testq %rax, %rax
je 0x36031
movl 0x4(%r14), %ecx
addq %rbx, %rcx
movl %r13d, %edx
movq (%rdx,%rcx), %rcx
movq %rcx, (%r12)
movq %rax, 0x8(%r12)
addq %rax, -0x58(%rbp)
addq $0x10, %r12
movq %rbx, %rdi
movq %r15, %r9
addq $0x38, %r14
jmp 0x35fea
subq -0x68(%rbp), %r12
shrq $0x4, %r12
movq -0x88(%rbp), %rbx
movq 0x8(%rbx), %rdx
movq 0x318(%rbx), %rax
movq -0x58(%rbp), %rcx
addl 0x28(%rax), %ecx
movq -0x80(%rbp), %r8
addl %ecx, %r8d
addl $0x4, %r12d
subq $0x8, %rsp
leaq -0x5c(%rbp), %r10
leaq -0x78(%rbp), %rdi
movl $0x13, %esi
movq %rbx, %rcx
movl %r12d, %r9d
pushq %r10
leaq -0x49(%rbp), %r10
pushq %r10
pushq %rax
callq 0x2b425
addq $0x20, %rsp
testb %al, %al
jne 0x35cb3
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x3e611
xorl %r14d, %r14d
movq -0x78(%rbp), %rsi
jmp 0x35cc5
callq 0x2a280
| _ma_delete_block_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov [rbp+var_58], rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r14, [rdi]
mov [rbp+var_78], 0
mov r13, [rdi+98h]
mov r15, r13
shr r15, 8
movzx r12d, r13b
mov esi, 1
call _ma_bitmap_flushable
mov rdi, rbx
mov rsi, r15
mov edx, r12d
mov ecx, 1
xor r8d, r8d
call delete_head_or_tail
test al, al
jnz short loc_35CB3
mov rsi, [rbx+0A8h]
mov rdi, rbx
call delete_tails
test al, al
jz short loc_35D01
loc_35CB3:
mov rdi, rbx
mov esi, 0FFFFFFFFh
call _ma_bitmap_flushable
mov r14b, 1
xor esi, esi
loc_35CC5:
mov rdi, rbx
call _ma_unpin_all_pages
mov rax, [rbx+8]
mov qword ptr [rax+90h], 0
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_360B3
mov eax, r14d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_35D01:
cmp dword ptr [rbx+12Ch], 0
jz short loc_35D1D
lea rsi, [rbx+80h]
mov rdi, rbx
call free_full_pages
test al, al
jnz short loc_35CB3
loc_35D1D:
cmp byte ptr [r14+7E7h], 0
jz loc_3609A
mov rax, [rbx+8]
mov rax, [rax+98h]
mov rcx, rax
shr rcx, 20h
lea rdx, [rbp+var_50]
mov [rdx], cl
mov rcx, rax
shr rcx, 28h
mov [rdx+1], cl
mov rcx, rax
shr rcx, 30h
mov [rdx+2], cl
mov [rdx+3], eax
mov [rdx+9], r15d
mov rax, r13
shr rax, 28h
mov [rdx+0Dh], al
mov [rdx+0Eh], r13b
mov eax, [rbx+120h]
sub eax, [rbx+124h]
mov [rdx+0Fh], ax
movzx eax, word ptr [rbx+12Ch]
mov [rdx+11h], ax
mov rax, [rbx+318h]
mov [rax+20h], rdx
mov rax, [rbx+318h]
mov qword ptr [rax+28h], 13h
mov [rbp+var_5C], 0
cmp qword ptr [r14+6A8h], 0
jz short loc_35DCC
xor eax, eax
sub eax, [rbx+0B0h]
mov [rbp+var_5C], eax
mov [rbp+var_3D], eax
mov rax, [rbx+318h]
add qword ptr [rax+28h], 4
loc_35DCC:
mov rax, [rbx+90h]
mov rcx, [rbx+318h]
mov [rcx+30h], rax
mov eax, [rbx+12Ch]
lea ecx, ds:0[rax*8]
sub ecx, eax
mov rax, [rbx+318h]
mov [rbp+var_80], rcx
mov [rax+38h], rcx
mov rdx, [rbx+318h]
mov r13, [rbx]
mov rsi, [rbx+0D0h]
mov rdi, [rbp+var_58]
mov [rdx+40h], rdi
mov eax, [r13+3FCh]
mov [rdx+48h], rax
mov rcx, [rbx+0C8h]
mov [rdx+50h], rcx
mov r15d, [r13+3F4h]
mov [rdx+58h], r15
add r15, rax
cmp dword ptr [r13+3D4h], 0
jz short loc_35E6D
lea rax, [rsi-2]
mov [rdx+60h], rax
mov eax, [rbx+128h]
add eax, 2
mov [rdx+68h], rax
movzx eax, word ptr [rbx+128h]
mov [rsi-2], ax
add r15, [rdx+68h]
lea r12, [rdx+70h]
jmp short loc_35E71
loc_35E6D:
lea r12, [rdx+60h]
loc_35E71:
mov [rbp+var_70], rsi
mov [rbp+var_68], rdx
cmp dword ptr [r13+3F0h], 0
jz short loc_35EAE
lea rdi, [rbx+6E8h]
mov [r12], rdi
mov rsi, [rbx+108h]
call ma_store_length
mov rdi, [rbp+var_58]
sub eax, [r12]
mov [r12+8], rax
add r15, rax
add r12, 10h
loc_35EAE:
mov r14, [r13+588h]
mov eax, [r13+3CCh]
test rax, rax
jz short loc_35EFE
imul rax, 38h ; '8'
add rax, r14
mov rsi, [rbp+var_68]
mov r8, [rbp+var_70]
loc_35ED0:
mov ecx, [r14+4]
add rcx, rdi
mov [r12], rcx
movzx ecx, word ptr [r14+8]
mov [r12+8], rcx
add r15, rcx
add r12, 10h
add r14, 38h ; '8'
cmp r14, rax
jb short loc_35ED0
mov rcx, [r13+588h]
jmp short loc_35F09
loc_35EFE:
mov rcx, r14
mov rsi, [rbp+var_68]
mov r8, [rbp+var_70]
loc_35F09:
mov edx, [r13+3C8h]
mov eax, [r13+3F0h]
imul rdx, 38h ; '8'
add rdx, rcx
mov rcx, rax
neg rcx
imul r9, rcx, 38h ; '8'
add r9, rdx
cmp r14, r9
mov [rbp+var_88], rbx
jnb loc_35FD7
loc_35F3B:
movzx eax, word ptr [r14+0Eh]
mov cl, [r14+12h]
test [rdi+rax], cl
jnz short loc_35FBD
mov rax, [rbx+0C8h]
movzx ecx, word ptr [r14+10h]
mov dl, [r14+13h]
test [rax+rcx], dl
jnz short loc_35FBD
mov edx, [r14]
mov eax, [r14+4]
add rax, rdi
cmp edx, 8
jz short loc_35F88
movzx ecx, word ptr [r14+8]
cmp edx, 1
jnz short loc_35FAD
cmp ecx, 0FFh
ja short loc_35F99
movzx ecx, byte ptr [r8]
inc r8
jmp short loc_35FAD
loc_35F88:
movzx edx, word ptr [r14+0Ch]
cmp rdx, 1
jnz short loc_35FA3
movzx ecx, byte ptr [r8]
jmp short loc_35FA7
loc_35F99:
movzx ecx, word ptr [r8]
add r8, 2
jmp short loc_35FAD
loc_35FA3:
movzx ecx, word ptr [r8]
loc_35FA7:
add r8, rdx
add rax, rdx
loc_35FAD:
mov [r12], rax
mov [r12+8], rcx
add r15, rcx
add r12, 10h
loc_35FBD:
add r14, 38h ; '8'
cmp r14, r9
jb loc_35F3B
mov [rbp+var_58], r15
mov eax, [r13+3F0h]
jmp short loc_35FDB
loc_35FD7:
mov [rbp+var_58], r15
loc_35FDB:
add rsi, 40h ; '@'
mov [rbp+var_68], rsi
imul rax, 38h ; '8'
add r9, rax
loc_35FEA:
cmp r14, r9
jnb short loc_3603D
mov r15, r9
mov esi, [r14+4]
add rsi, rdi
movzx r13d, word ptr [r14+8]
add r13d, 0FFFFFFF8h
mov rbx, rdi
mov edi, r13d
call _ma_calc_blob_length
test rax, rax
jz short loc_36031
mov ecx, [r14+4]
add rcx, rbx
mov edx, r13d
mov rcx, [rdx+rcx]
mov [r12], rcx
mov [r12+8], rax
add [rbp+var_58], rax
add r12, 10h
loc_36031:
mov rdi, rbx
mov r9, r15
add r14, 38h ; '8'
jmp short loc_35FEA
loc_3603D:
sub r12, [rbp+var_68]
shr r12, 4
mov rbx, [rbp+var_88]
mov rdx, [rbx+8]
mov rax, [rbx+318h]
mov rcx, [rbp+var_58]
add ecx, [rax+28h]
mov r8, [rbp+var_80]
add r8d, ecx
add r12d, 4
sub rsp, 8
lea r10, [rbp+var_5C]
lea rdi, [rbp+var_78]
mov esi, 13h
mov rcx, rbx
mov r9d, r12d
push r10
lea r10, [rbp+var_49]
push r10
push rax
call translog_write_record
add rsp, 20h
test al, al
jnz loc_35CB3
loc_3609A:
mov rdi, rbx
mov esi, 0FFFFFFFFh
call _ma_bitmap_flushable
xor r14d, r14d
mov rsi, [rbp+var_78]
jmp loc_35CC5
loc_360B3:
call ___stack_chk_fail
| long long ma_delete_block_record(long long a1, long long a2)
{
unsigned long long v3; // r14
unsigned long long v4; // r13
long long v5; // rsi
long long v7; // rax
char *v8; // rdx
unsigned long long v9; // r13
unsigned __int8 *v10; // rsi
long long v11; // rdi
long long v12; // rax
long long v13; // r15
long long v14; // r15
char *v15; // r12
long long v16; // rax
unsigned long long v17; // rax
char *v18; // rsi
unsigned __int8 *v19; // r8
long long v20; // rcx
long long v21; // rcx
long long v22; // rax
unsigned long long v23; // r9
long long v24; // rax
long long v25; // rcx
long long v26; // rdx
unsigned long long v27; // r9
unsigned long long v28; // r15
unsigned int v29; // r13d
long long v30; // rax
long long v31; // [rsp+10h] [rbp-80h]
long long v32; // [rsp+18h] [rbp-78h] BYREF
unsigned __int8 *v33; // [rsp+20h] [rbp-70h]
char *v34; // [rsp+28h] [rbp-68h]
int v35; // [rsp+34h] [rbp-5Ch] BYREF
long long v36; // [rsp+38h] [rbp-58h]
_BYTE v37[3]; // [rsp+40h] [rbp-50h] BYREF
int v38; // [rsp+43h] [rbp-4Dh]
__int16 v39; // [rsp+47h] [rbp-49h] BYREF
int v40; // [rsp+49h] [rbp-47h]
char v41; // [rsp+4Dh] [rbp-43h]
char v42; // [rsp+4Eh] [rbp-42h]
__int16 v43; // [rsp+4Fh] [rbp-41h]
__int16 v44; // [rsp+51h] [rbp-3Fh]
int v45; // [rsp+53h] [rbp-3Dh]
unsigned long long v46; // [rsp+60h] [rbp-30h]
v36 = a2;
v46 = __readfsqword(0x28u);
v3 = *(_QWORD *)a1;
v32 = 0LL;
v4 = *(_QWORD *)(a1 + 152);
ma_bitmap_flushable(a1, 1LL);
if ( (unsigned __int8)delete_head_or_tail((_QWORD *)a1, v4 >> 8, (unsigned __int8)v4, 1, 0)
|| (unsigned __int8)delete_tails(a1)
|| *(_DWORD *)(a1 + 300) && (unsigned __int8)free_full_pages(a1, a1 + 128) )
{
goto LABEL_3;
}
if ( !*(_BYTE *)(v3 + 2023) )
goto LABEL_42;
v7 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 152LL);
v37[0] = BYTE4(v7);
v37[1] = BYTE5(v7);
v37[2] = BYTE6(v7);
v38 = v7;
v40 = v4 >> 8;
v41 = BYTE5(v4);
v42 = v4;
v43 = *(_WORD *)(a1 + 288) - *(_WORD *)(a1 + 292);
v44 = *(_WORD *)(a1 + 300);
*(_QWORD *)(*(_QWORD *)(a1 + 792) + 32LL) = v37;
*(_QWORD *)(*(_QWORD *)(a1 + 792) + 40LL) = 19LL;
v35 = 0;
if ( *(_QWORD *)(v3 + 1704) )
{
v35 = -*(_DWORD *)(a1 + 176);
v45 = v35;
*(_QWORD *)(*(_QWORD *)(a1 + 792) + 40LL) += 4LL;
}
*(_QWORD *)(*(_QWORD *)(a1 + 792) + 48LL) = *(_QWORD *)(a1 + 144);
v31 = (unsigned int)(7 * *(_DWORD *)(a1 + 300));
*(_QWORD *)(*(_QWORD *)(a1 + 792) + 56LL) = v31;
v8 = *(char **)(a1 + 792);
v9 = *(_QWORD *)a1;
v10 = *(unsigned __int8 **)(a1 + 208);
v11 = v36;
*((_QWORD *)v8 + 8) = v36;
v12 = *(unsigned int *)(v9 + 1020);
*((_QWORD *)v8 + 9) = v12;
*((_QWORD *)v8 + 10) = *(_QWORD *)(a1 + 200);
v13 = *(unsigned int *)(v9 + 1012);
*((_QWORD *)v8 + 11) = v13;
v14 = v12 + v13;
if ( *(_DWORD *)(v9 + 980) )
{
*((_QWORD *)v8 + 12) = v10 - 2;
*((_QWORD *)v8 + 13) = (unsigned int)(*(_DWORD *)(a1 + 296) + 2);
*((_WORD *)v10 - 1) = *(_WORD *)(a1 + 296);
v14 += *((_QWORD *)v8 + 13);
v15 = v8 + 112;
}
else
{
v15 = v8 + 96;
}
v33 = v10;
v34 = v8;
if ( *(_DWORD *)(v9 + 1008) )
{
*(_QWORD *)v15 = a1 + 1768;
v11 = v36;
v16 = (unsigned int)ma_store_length(a1 + 1768, *(_QWORD *)(a1 + 264)) - *(_DWORD *)v15;
*((_QWORD *)v15 + 1) = v16;
v14 += v16;
v15 += 16;
}
v3 = *(_QWORD *)(v9 + 1416);
if ( *(_DWORD *)(v9 + 972) )
{
v17 = v3 + 56LL * *(unsigned int *)(v9 + 972);
v18 = v34;
v19 = v33;
do
{
*(_QWORD *)v15 = v11 + *(unsigned int *)(v3 + 4);
v20 = *(unsigned __int16 *)(v3 + 8);
*((_QWORD *)v15 + 1) = v20;
v14 += v20;
v15 += 16;
v3 += 56LL;
}
while ( v3 < v17 );
v21 = *(_QWORD *)(v9 + 1416);
}
else
{
v21 = *(_QWORD *)(v9 + 1416);
v18 = v34;
v19 = v33;
}
v22 = *(unsigned int *)(v9 + 1008);
v23 = v21 + 56LL * *(unsigned int *)(v9 + 968) - 56 * v22;
if ( v3 >= v23 )
{
v36 = v14;
}
else
{
do
{
if ( (*(_BYTE *)(v3 + 18) & *(_BYTE *)(v11 + *(unsigned __int16 *)(v3 + 14))) == 0
&& (*(_BYTE *)(v3 + 19) & *(_BYTE *)(*(_QWORD *)(a1 + 200) + *(unsigned __int16 *)(v3 + 16))) == 0 )
{
v24 = v11 + *(unsigned int *)(v3 + 4);
if ( *(_DWORD *)v3 == 8 )
{
v26 = *(unsigned __int16 *)(v3 + 12);
if ( v26 == 1 )
v25 = *v19;
else
v25 = *(unsigned __int16 *)v19;
v19 += v26;
v24 += v26;
}
else
{
v25 = *(unsigned __int16 *)(v3 + 8);
if ( *(_DWORD *)v3 == 1 )
{
if ( (unsigned int)v25 > 0xFF )
{
v25 = *(unsigned __int16 *)v19;
v19 += 2;
}
else
{
v25 = *v19++;
}
}
}
*(_QWORD *)v15 = v24;
*((_QWORD *)v15 + 1) = v25;
v14 += v25;
v15 += 16;
}
v3 += 56LL;
}
while ( v3 < v23 );
v36 = v14;
v22 = *(unsigned int *)(v9 + 1008);
}
v34 = v18 + 64;
v27 = 56 * v22 + v23;
while ( v3 < v27 )
{
v28 = v27;
v29 = *(unsigned __int16 *)(v3 + 8) - 8;
v30 = ma_calc_blob_length(v29, v11 + *(unsigned int *)(v3 + 4));
if ( v30 )
{
*(_QWORD *)v15 = *(_QWORD *)(v29 + v11 + *(unsigned int *)(v3 + 4));
*((_QWORD *)v15 + 1) = v30;
v36 += v30;
v15 += 16;
}
v27 = v28;
v3 += 56LL;
}
if ( (unsigned __int8)translog_write_record(
(unsigned long long)&v32,
(__int16 *)((char *)&word_12 + 1),
*(_QWORD *)(a1 + 8),
(_QWORD *)a1,
*(_DWORD *)(*(_QWORD *)(a1 + 792) + 40LL) + (int)v36 + (int)v31,
(unsigned int)((unsigned long long)(v15 - v34) >> 4) + 4,
*(_OWORD **)(a1 + 792),
&v39,
(long long)&v35) )
{
LABEL_3:
ma_bitmap_flushable(a1, 0xFFFFFFFFLL);
LOBYTE(v3) = 1;
v5 = 0LL;
}
else
{
LABEL_42:
ma_bitmap_flushable(a1, 0xFFFFFFFFLL);
LODWORD(v3) = 0;
v5 = v32;
}
ma_unpin_all_pages(a1, v5);
*(_QWORD *)(*(_QWORD *)(a1 + 8) + 144LL) = 0LL;
return (unsigned int)v3;
}
| _ma_delete_block_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x58],RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R14,qword ptr [RDI]
MOV qword ptr [RBP + -0x78],0x0
MOV R13,qword ptr [RDI + 0x98]
MOV R15,R13
SHR R15,0x8
MOVZX R12D,R13B
MOV ESI,0x1
CALL 0x0013e611
MOV RDI,RBX
MOV RSI,R15
MOV EDX,R12D
MOV ECX,0x1
XOR R8D,R8D
CALL 0x001355cd
TEST AL,AL
JNZ 0x00135cb3
MOV RSI,qword ptr [RBX + 0xa8]
MOV RDI,RBX
CALL 0x001360b8
TEST AL,AL
JZ 0x00135d01
LAB_00135cb3:
MOV RDI,RBX
MOV ESI,0xffffffff
CALL 0x0013e611
MOV R14B,0x1
XOR ESI,ESI
LAB_00135cc5:
MOV RDI,RBX
CALL 0x001604f8
MOV RAX,qword ptr [RBX + 0x8]
MOV qword ptr [RAX + 0x90],0x0
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001360b3
MOV EAX,R14D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00135d01:
CMP dword ptr [RBX + 0x12c],0x0
JZ 0x00135d1d
LEA RSI,[RBX + 0x80]
MOV RDI,RBX
CALL 0x0013611f
TEST AL,AL
JNZ 0x00135cb3
LAB_00135d1d:
CMP byte ptr [R14 + 0x7e7],0x0
JZ 0x0013609a
MOV RAX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RAX + 0x98]
MOV RCX,RAX
SHR RCX,0x20
LEA RDX,[RBP + -0x50]
MOV byte ptr [RDX],CL
MOV RCX,RAX
SHR RCX,0x28
MOV byte ptr [RDX + 0x1],CL
MOV RCX,RAX
SHR RCX,0x30
MOV byte ptr [RDX + 0x2],CL
MOV dword ptr [RDX + 0x3],EAX
MOV dword ptr [RDX + 0x9],R15D
MOV RAX,R13
SHR RAX,0x28
MOV byte ptr [RDX + 0xd],AL
MOV byte ptr [RDX + 0xe],R13B
MOV EAX,dword ptr [RBX + 0x120]
SUB EAX,dword ptr [RBX + 0x124]
MOV word ptr [RDX + 0xf],AX
MOVZX EAX,word ptr [RBX + 0x12c]
MOV word ptr [RDX + 0x11],AX
MOV RAX,qword ptr [RBX + 0x318]
MOV qword ptr [RAX + 0x20],RDX
MOV RAX,qword ptr [RBX + 0x318]
MOV qword ptr [RAX + 0x28],0x13
MOV dword ptr [RBP + -0x5c],0x0
CMP qword ptr [R14 + 0x6a8],0x0
JZ 0x00135dcc
XOR EAX,EAX
SUB EAX,dword ptr [RBX + 0xb0]
MOV dword ptr [RBP + -0x5c],EAX
MOV dword ptr [RBP + -0x3d],EAX
MOV RAX,qword ptr [RBX + 0x318]
ADD qword ptr [RAX + 0x28],0x4
LAB_00135dcc:
MOV RAX,qword ptr [RBX + 0x90]
MOV RCX,qword ptr [RBX + 0x318]
MOV qword ptr [RCX + 0x30],RAX
MOV EAX,dword ptr [RBX + 0x12c]
LEA ECX,[RAX*0x8]
SUB ECX,EAX
MOV RAX,qword ptr [RBX + 0x318]
MOV qword ptr [RBP + -0x80],RCX
MOV qword ptr [RAX + 0x38],RCX
MOV RDX,qword ptr [RBX + 0x318]
MOV R13,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0xd0]
MOV RDI,qword ptr [RBP + -0x58]
MOV qword ptr [RDX + 0x40],RDI
MOV EAX,dword ptr [R13 + 0x3fc]
MOV qword ptr [RDX + 0x48],RAX
MOV RCX,qword ptr [RBX + 0xc8]
MOV qword ptr [RDX + 0x50],RCX
MOV R15D,dword ptr [R13 + 0x3f4]
MOV qword ptr [RDX + 0x58],R15
ADD R15,RAX
CMP dword ptr [R13 + 0x3d4],0x0
JZ 0x00135e6d
LEA RAX,[RSI + -0x2]
MOV qword ptr [RDX + 0x60],RAX
MOV EAX,dword ptr [RBX + 0x128]
ADD EAX,0x2
MOV qword ptr [RDX + 0x68],RAX
MOVZX EAX,word ptr [RBX + 0x128]
MOV word ptr [RSI + -0x2],AX
ADD R15,qword ptr [RDX + 0x68]
LEA R12,[RDX + 0x70]
JMP 0x00135e71
LAB_00135e6d:
LEA R12,[RDX + 0x60]
LAB_00135e71:
MOV qword ptr [RBP + -0x70],RSI
MOV qword ptr [RBP + -0x68],RDX
CMP dword ptr [R13 + 0x3f0],0x0
JZ 0x00135eae
LEA RDI,[RBX + 0x6e8]
MOV qword ptr [R12],RDI
MOV RSI,qword ptr [RBX + 0x108]
CALL 0x0013767e
MOV RDI,qword ptr [RBP + -0x58]
SUB EAX,dword ptr [R12]
MOV qword ptr [R12 + 0x8],RAX
ADD R15,RAX
ADD R12,0x10
LAB_00135eae:
MOV R14,qword ptr [R13 + 0x588]
MOV EAX,dword ptr [R13 + 0x3cc]
TEST RAX,RAX
JZ 0x00135efe
IMUL RAX,RAX,0x38
ADD RAX,R14
MOV RSI,qword ptr [RBP + -0x68]
MOV R8,qword ptr [RBP + -0x70]
LAB_00135ed0:
MOV ECX,dword ptr [R14 + 0x4]
ADD RCX,RDI
MOV qword ptr [R12],RCX
MOVZX ECX,word ptr [R14 + 0x8]
MOV qword ptr [R12 + 0x8],RCX
ADD R15,RCX
ADD R12,0x10
ADD R14,0x38
CMP R14,RAX
JC 0x00135ed0
MOV RCX,qword ptr [R13 + 0x588]
JMP 0x00135f09
LAB_00135efe:
MOV RCX,R14
MOV RSI,qword ptr [RBP + -0x68]
MOV R8,qword ptr [RBP + -0x70]
LAB_00135f09:
MOV EDX,dword ptr [R13 + 0x3c8]
MOV EAX,dword ptr [R13 + 0x3f0]
IMUL RDX,RDX,0x38
ADD RDX,RCX
MOV RCX,RAX
NEG RCX
IMUL R9,RCX,0x38
ADD R9,RDX
CMP R14,R9
MOV qword ptr [RBP + -0x88],RBX
JNC 0x00135fd7
LAB_00135f3b:
MOVZX EAX,word ptr [R14 + 0xe]
MOV CL,byte ptr [R14 + 0x12]
TEST byte ptr [RDI + RAX*0x1],CL
JNZ 0x00135fbd
MOV RAX,qword ptr [RBX + 0xc8]
MOVZX ECX,word ptr [R14 + 0x10]
MOV DL,byte ptr [R14 + 0x13]
TEST byte ptr [RAX + RCX*0x1],DL
JNZ 0x00135fbd
MOV EDX,dword ptr [R14]
MOV EAX,dword ptr [R14 + 0x4]
ADD RAX,RDI
CMP EDX,0x8
JZ 0x00135f88
MOVZX ECX,word ptr [R14 + 0x8]
CMP EDX,0x1
JNZ 0x00135fad
CMP ECX,0xff
JA 0x00135f99
MOVZX ECX,byte ptr [R8]
INC R8
JMP 0x00135fad
LAB_00135f88:
MOVZX EDX,word ptr [R14 + 0xc]
CMP RDX,0x1
JNZ 0x00135fa3
MOVZX ECX,byte ptr [R8]
JMP 0x00135fa7
LAB_00135f99:
MOVZX ECX,word ptr [R8]
ADD R8,0x2
JMP 0x00135fad
LAB_00135fa3:
MOVZX ECX,word ptr [R8]
LAB_00135fa7:
ADD R8,RDX
ADD RAX,RDX
LAB_00135fad:
MOV qword ptr [R12],RAX
MOV qword ptr [R12 + 0x8],RCX
ADD R15,RCX
ADD R12,0x10
LAB_00135fbd:
ADD R14,0x38
CMP R14,R9
JC 0x00135f3b
MOV qword ptr [RBP + -0x58],R15
MOV EAX,dword ptr [R13 + 0x3f0]
JMP 0x00135fdb
LAB_00135fd7:
MOV qword ptr [RBP + -0x58],R15
LAB_00135fdb:
ADD RSI,0x40
MOV qword ptr [RBP + -0x68],RSI
IMUL RAX,RAX,0x38
ADD R9,RAX
LAB_00135fea:
CMP R14,R9
JNC 0x0013603d
MOV R15,R9
MOV ESI,dword ptr [R14 + 0x4]
ADD RSI,RDI
MOVZX R13D,word ptr [R14 + 0x8]
ADD R13D,-0x8
MOV RBX,RDI
MOV EDI,R13D
CALL 0x001691c3
TEST RAX,RAX
JZ 0x00136031
MOV ECX,dword ptr [R14 + 0x4]
ADD RCX,RBX
MOV EDX,R13D
MOV RCX,qword ptr [RDX + RCX*0x1]
MOV qword ptr [R12],RCX
MOV qword ptr [R12 + 0x8],RAX
ADD qword ptr [RBP + -0x58],RAX
ADD R12,0x10
LAB_00136031:
MOV RDI,RBX
MOV R9,R15
ADD R14,0x38
JMP 0x00135fea
LAB_0013603d:
SUB R12,qword ptr [RBP + -0x68]
SHR R12,0x4
MOV RBX,qword ptr [RBP + -0x88]
MOV RDX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RBX + 0x318]
MOV RCX,qword ptr [RBP + -0x58]
ADD ECX,dword ptr [RAX + 0x28]
MOV R8,qword ptr [RBP + -0x80]
ADD R8D,ECX
ADD R12D,0x4
SUB RSP,0x8
LEA R10,[RBP + -0x5c]
LEA RDI,[RBP + -0x78]
MOV ESI,0x13
MOV RCX,RBX
MOV R9D,R12D
PUSH R10
LEA R10,[RBP + -0x49]
PUSH R10
PUSH RAX
CALL 0x0012b425
ADD RSP,0x20
TEST AL,AL
JNZ 0x00135cb3
LAB_0013609a:
MOV RDI,RBX
MOV ESI,0xffffffff
CALL 0x0013e611
XOR R14D,R14D
MOV RSI,qword ptr [RBP + -0x78]
JMP 0x00135cc5
LAB_001360b3:
CALL 0x0012a280
|
ulong _ma_delete_block_record(long *param_1,long param_2)
{
ushort uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
char cVar5;
int iVar6;
ulong uVar7;
long lVar8;
long lVar9;
int *piVar10;
ulong uVar11;
int8 uVar12;
long lVar13;
ushort *puVar14;
long *plVar15;
int *piVar16;
long lVar17;
long in_FS_OFFSET;
int8 local_80;
ushort *local_78;
long local_70;
int local_64;
long local_60;
int1 local_58;
int1 local_57;
int1 local_56;
int4 local_55;
int1 local_51 [2];
int4 local_4f;
int1 local_4b;
int1 local_4a;
short local_49;
int2 local_47;
int local_45;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
piVar16 = (int *)*param_1;
local_80 = 0;
uVar7 = param_1[0x13];
local_60 = param_2;
_ma_bitmap_flushable(param_1,1);
cVar5 = delete_head_or_tail(param_1,uVar7 >> 8,uVar7 & 0xff,1,0);
if (((cVar5 == '\0') && (cVar5 = delete_tails(param_1,param_1[0x15]), cVar5 == '\0')) &&
((*(int *)((long)param_1 + 300) == 0 ||
(cVar5 = free_full_pages(param_1,param_1 + 0x10), cVar5 == '\0')))) {
if (*(char *)((long)piVar16 + 0x7e7) != '\0') {
uVar12 = *(int8 *)(param_1[1] + 0x98);
local_58 = (int1)((ulong)uVar12 >> 0x20);
local_57 = (int1)((ulong)uVar12 >> 0x28);
local_56 = (int1)((ulong)uVar12 >> 0x30);
local_55 = (int4)uVar12;
local_4f = (int4)(uVar7 >> 8);
local_4b = (int1)(uVar7 >> 0x28);
local_49 = (short)(int)param_1[0x24] - (short)*(int4 *)((long)param_1 + 0x124);
local_47 = *(int2 *)((long)param_1 + 300);
*(int1 **)(param_1[99] + 0x20) = &local_58;
*(int8 *)(param_1[99] + 0x28) = 0x13;
local_64 = 0;
if (*(long *)(piVar16 + 0x1aa) != 0) {
local_64 = -(int)param_1[0x16];
*(long *)(param_1[99] + 0x28) = *(long *)(param_1[99] + 0x28) + 4;
local_45 = local_64;
}
*(long *)(param_1[99] + 0x30) = param_1[0x12];
uVar4 = *(int *)((long)param_1 + 300) * 7;
*(ulong *)(param_1[99] + 0x38) = (ulong)uVar4;
local_70 = param_1[99];
lVar9 = *param_1;
local_78 = (ushort *)param_1[0x1a];
*(long *)(local_70 + 0x40) = local_60;
uVar2 = *(uint *)(lVar9 + 0x3fc);
*(ulong *)(local_70 + 0x48) = (ulong)uVar2;
*(long *)(local_70 + 0x50) = param_1[0x19];
uVar3 = *(uint *)(lVar9 + 0x3f4);
*(ulong *)(local_70 + 0x58) = (ulong)uVar3;
lVar17 = (ulong)uVar3 + (ulong)uVar2;
if (*(int *)(lVar9 + 0x3d4) == 0) {
plVar15 = (long *)(local_70 + 0x60);
}
else {
*(ushort **)(local_70 + 0x60) = local_78 + -1;
*(ulong *)(local_70 + 0x68) = (ulong)((int)param_1[0x25] + 2);
local_78[-1] = *(ushort *)(param_1 + 0x25);
lVar17 = lVar17 + *(long *)(local_70 + 0x68);
plVar15 = (long *)(local_70 + 0x70);
}
lVar13 = local_60;
local_4a = (char)uVar7;
if (*(int *)(lVar9 + 0x3f0) != 0) {
*plVar15 = (long)(param_1 + 0xdd);
iVar6 = ma_store_length(param_1 + 0xdd,param_1[0x21]);
uVar7 = (ulong)(uint)(iVar6 - (int)*plVar15);
plVar15[1] = uVar7;
lVar17 = lVar17 + uVar7;
plVar15 = plVar15 + 2;
lVar13 = local_60;
}
piVar10 = *(int **)(lVar9 + 0x588);
uVar2 = *(uint *)(lVar9 + 0x3cc);
piVar16 = piVar10;
if ((ulong)uVar2 != 0) {
do {
*plVar15 = (ulong)(uint)piVar16[1] + lVar13;
uVar1 = *(ushort *)(piVar16 + 2);
plVar15[1] = (ulong)uVar1;
lVar17 = lVar17 + (ulong)uVar1;
plVar15 = plVar15 + 2;
piVar16 = piVar16 + 0xe;
} while (piVar16 < piVar10 + (ulong)uVar2 * 0xe);
piVar10 = *(int **)(lVar9 + 0x588);
}
uVar7 = (ulong)*(uint *)(lVar9 + 0x3f0);
piVar10 = piVar10 + (ulong)*(uint *)(lVar9 + 0x3c8) * 0xe + uVar7 * -0xe;
puVar14 = local_78;
local_60 = lVar17;
if (piVar16 < piVar10) {
do {
if (((*(byte *)(lVar13 + (ulong)*(ushort *)((long)piVar16 + 0xe)) &
*(byte *)((long)piVar16 + 0x12)) == 0) &&
((*(byte *)(param_1[0x19] + (ulong)*(ushort *)(piVar16 + 4)) &
*(byte *)((long)piVar16 + 0x13)) == 0)) {
lVar8 = (ulong)(uint)piVar16[1] + lVar13;
if (*piVar16 == 8) {
uVar7 = (ulong)*(ushort *)(piVar16 + 3);
if (uVar7 == 1) {
uVar11 = (ulong)(byte)*puVar14;
}
else {
uVar11 = (ulong)*puVar14;
}
puVar14 = (ushort *)((long)puVar14 + uVar7);
lVar8 = lVar8 + uVar7;
}
else {
uVar11 = (ulong)*(ushort *)(piVar16 + 2);
if (*piVar16 == 1) {
if (*(ushort *)(piVar16 + 2) < 0x100) {
uVar11 = (ulong)(byte)*puVar14;
puVar14 = (ushort *)((long)puVar14 + 1);
}
else {
uVar11 = (ulong)*puVar14;
puVar14 = puVar14 + 1;
}
}
}
*plVar15 = lVar8;
plVar15[1] = uVar11;
lVar17 = lVar17 + uVar11;
plVar15 = plVar15 + 2;
}
piVar16 = piVar16 + 0xe;
} while (piVar16 < piVar10);
uVar7 = (ulong)*(uint *)(lVar9 + 0x3f0);
local_60 = lVar17;
}
local_70 = local_70 + 0x40;
for (; piVar16 < piVar10 + uVar7 * 0xe; piVar16 = piVar16 + 0xe) {
uVar1 = *(ushort *)(piVar16 + 2);
lVar9 = _ma_calc_blob_length(uVar1 - 8,(ulong)(uint)piVar16[1] + lVar13);
if (lVar9 != 0) {
*plVar15 = *(long *)((ulong)(uVar1 - 8) + (ulong)(uint)piVar16[1] + lVar13);
plVar15[1] = lVar9;
local_60 = local_60 + lVar9;
plVar15 = plVar15 + 2;
}
}
cVar5 = translog_write_record
(&local_80,0x13,param_1[1],param_1,
uVar4 + (int)local_60 + *(int *)(param_1[99] + 0x28),
(int)((ulong)((long)plVar15 - local_70) >> 4) + 4,param_1[99],local_51,
&local_64);
if (cVar5 != '\0') goto LAB_00135cb3;
}
_ma_bitmap_flushable(param_1,0xffffffff);
uVar7 = 0;
uVar12 = local_80;
}
else {
LAB_00135cb3:
_ma_bitmap_flushable(param_1,0xffffffff);
uVar7 = CONCAT71((int7)((ulong)piVar16 >> 8),1);
uVar12 = 0;
}
_ma_unpin_all_pages(param_1,uVar12);
*(int8 *)(param_1[1] + 0x90) = 0;
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar7 & 0xffffffff;
}
| |
28,420 | my_collation_get_by_name | eloqsql/mysys/charset.c | CHARSET_INFO *
my_collation_get_by_name(MY_CHARSET_LOADER *loader,
const char *name, myf flags)
{
uint cs_number;
CHARSET_INFO *cs;
my_pthread_once(&charsets_initialized, init_available_charsets);
cs_number= get_collation_number(name,flags);
my_charset_loader_init_mysys(loader);
cs= cs_number ? get_internal_charset(loader, cs_number, flags) : NULL;
if (!cs && (flags & MY_WME))
{
char index_file[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
strmov(get_charsets_dir(index_file),MY_CHARSET_INDEX);
my_error(EE_UNKNOWN_COLLATION, MYF(ME_BELL), name, index_file);
}
return cs;
} | O0 | c | my_collation_get_by_name:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x228(%rbp)
movq %rsi, -0x230(%rbp)
movq %rdx, -0x238(%rbp)
leaq 0x361f50(%rip), %rdi # 0x395e94
leaq -0x90b(%rip), %rsi # 0x33640
callq 0x24250
movq -0x230(%rbp), %rdi
movq -0x238(%rbp), %rsi
callq 0x33590
movl %eax, -0x23c(%rbp)
movq -0x228(%rbp), %rdi
callq 0x32c60
cmpl $0x0, -0x23c(%rbp)
je 0x33fa0
movq -0x228(%rbp), %rdi
movl -0x23c(%rbp), %esi
movq -0x238(%rbp), %rdx
callq 0x33c90
movq %rax, -0x250(%rbp)
jmp 0x33fab
xorl %eax, %eax
movq %rax, -0x250(%rbp)
jmp 0x33fab
movq -0x250(%rbp), %rax
movq %rax, -0x248(%rbp)
cmpq $0x0, -0x248(%rbp)
jne 0x3400e
movq -0x238(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x3400e
leaq -0x220(%rbp), %rdi
callq 0x33300
movq %rax, %rdi
leaq 0x4c62e(%rip), %rsi # 0x80618
callq 0x242a0
movq -0x230(%rbp), %rdx
leaq -0x220(%rbp), %rcx
movl $0x1c, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x38de0
movq -0x248(%rbp), %rax
movq %rax, -0x258(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3403e
movq -0x258(%rbp), %rax
addq $0x260, %rsp # imm = 0x260
popq %rbp
retq
callq 0x24300
nopw %cs:(%rax,%rax)
| my_collation_get_by_name:
push rbp
mov rbp, rsp
sub rsp, 260h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_228], rdi
mov [rbp+var_230], rsi
mov [rbp+var_238], rdx
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, [rbp+var_230]
mov rsi, [rbp+var_238]
call get_collation_number
mov [rbp+var_23C], eax
mov rdi, [rbp+var_228]
call my_charset_loader_init_mysys
cmp [rbp+var_23C], 0
jz short loc_33FA0
mov rdi, [rbp+var_228]
mov esi, [rbp+var_23C]
mov rdx, [rbp+var_238]
call get_internal_charset
mov [rbp+var_250], rax
jmp short loc_33FAB
loc_33FA0:
xor eax, eax
mov [rbp+var_250], rax
jmp short $+2
loc_33FAB:
mov rax, [rbp+var_250]
mov [rbp+var_248], rax
cmp [rbp+var_248], 0
jnz short loc_3400E
mov rax, [rbp+var_238]
and rax, 10h
cmp rax, 0
jz short loc_3400E
lea rdi, [rbp+var_220]
call get_charsets_dir
mov rdi, rax
lea rsi, aIndexXml; "Index.xml"
call _stpcpy
mov rdx, [rbp+var_230]
lea rcx, [rbp+var_220]
mov edi, 1Ch
mov esi, 4
mov al, 0
call my_error
loc_3400E:
mov rax, [rbp+var_248]
mov [rbp+var_258], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3403E
mov rax, [rbp+var_258]
add rsp, 260h
pop rbp
retn
loc_3403E:
call ___stack_chk_fail
| long long my_collation_get_by_name(long long a1, long long a2, long long a3)
{
_BYTE *charsets_dir; // rax
int v4; // r8d
int v5; // r9d
long long internal_charset; // [rsp+10h] [rbp-250h]
unsigned int collation_number; // [rsp+24h] [rbp-23Ch]
_BYTE v10[536]; // [rsp+40h] [rbp-220h] BYREF
unsigned long long v11; // [rsp+258h] [rbp-8h]
v11 = __readfsqword(0x28u);
pthread_once(&charsets_initialized, init_available_charsets);
collation_number = get_collation_number(a2, a3);
my_charset_loader_init_mysys(a1);
if ( collation_number )
internal_charset = get_internal_charset(a1, collation_number, a3);
else
internal_charset = 0LL;
if ( !internal_charset && (a3 & 0x10) != 0 )
{
charsets_dir = get_charsets_dir(v10);
stpcpy(charsets_dir, "Index.xml");
my_error(28, 4, a2, (unsigned int)v10, v4, v5);
}
return internal_charset;
}
| my_collation_get_by_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x260
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x228],RDI
MOV qword ptr [RBP + -0x230],RSI
MOV qword ptr [RBP + -0x238],RDX
LEA RDI,[0x495e94]
LEA RSI,[0x133640]
CALL 0x00124250
MOV RDI,qword ptr [RBP + -0x230]
MOV RSI,qword ptr [RBP + -0x238]
CALL 0x00133590
MOV dword ptr [RBP + -0x23c],EAX
MOV RDI,qword ptr [RBP + -0x228]
CALL 0x00132c60
CMP dword ptr [RBP + -0x23c],0x0
JZ 0x00133fa0
MOV RDI,qword ptr [RBP + -0x228]
MOV ESI,dword ptr [RBP + -0x23c]
MOV RDX,qword ptr [RBP + -0x238]
CALL 0x00133c90
MOV qword ptr [RBP + -0x250],RAX
JMP 0x00133fab
LAB_00133fa0:
XOR EAX,EAX
MOV qword ptr [RBP + -0x250],RAX
JMP 0x00133fab
LAB_00133fab:
MOV RAX,qword ptr [RBP + -0x250]
MOV qword ptr [RBP + -0x248],RAX
CMP qword ptr [RBP + -0x248],0x0
JNZ 0x0013400e
MOV RAX,qword ptr [RBP + -0x238]
AND RAX,0x10
CMP RAX,0x0
JZ 0x0013400e
LEA RDI,[RBP + -0x220]
CALL 0x00133300
MOV RDI,RAX
LEA RSI,[0x180618]
CALL 0x001242a0
MOV RDX,qword ptr [RBP + -0x230]
LEA RCX,[RBP + -0x220]
MOV EDI,0x1c
MOV ESI,0x4
MOV AL,0x0
CALL 0x00138de0
LAB_0013400e:
MOV RAX,qword ptr [RBP + -0x248]
MOV qword ptr [RBP + -0x258],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013403e
MOV RAX,qword ptr [RBP + -0x258]
ADD RSP,0x260
POP RBP
RET
LAB_0013403e:
CALL 0x00124300
|
long my_collation_get_by_name(int8 param_1,int8 param_2,ulong param_3)
{
int iVar1;
char *__dest;
long in_FS_OFFSET;
long local_258;
int1 local_228 [536];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pthread_once(&charsets_initialized,init_available_charsets);
iVar1 = get_collation_number(param_2,param_3);
my_charset_loader_init_mysys(param_1);
if (iVar1 == 0) {
local_258 = 0;
}
else {
local_258 = get_internal_charset(param_1,iVar1,param_3);
}
if ((local_258 == 0) && ((param_3 & 0x10) != 0)) {
__dest = (char *)get_charsets_dir(local_228);
stpcpy(__dest,"Index.xml");
my_error(0x1c,4,param_2,local_228);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_258;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
28,421 | remapped_memory_access::write(unsigned int, unsigned char*, unsigned int) | msxemulator/build_O0/_deps/picotool-src/main.cpp | void write(uint32_t address, uint8_t *buffer, unsigned int size) override {
while (size) {
auto result = get_remapped(address);
unsigned int this_size = std::min(size, result.first.max_offset - result.first.offset);
assert( this_size);
wrap.write(result.second + result.first.offset, buffer, this_size);
buffer += this_size;
address += this_size;
size -= this_size;
}
} | O0 | cpp | remapped_memory_access::write(unsigned int, unsigned char*, unsigned int):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x88f37
movq (%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x88f70
movl %edx, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x24(%rsp), %eax
subl 0x20(%rsp), %eax
movl %eax, 0x8(%rsp)
leaq 0x2c(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5bc00
movq %rax, %rcx
movq (%rsp), %rax
movl (%rcx), %ecx
movl %ecx, 0xc(%rsp)
movq 0x8(%rax), %rdi
movl 0x28(%rsp), %esi
addl 0x20(%rsp), %esi
movq 0x30(%rsp), %rdx
movl 0xc(%rsp), %ecx
movq (%rdi), %rax
callq *0x10(%rax)
movl 0xc(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movl 0xc(%rsp), %eax
addl 0x3c(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0xc(%rsp), %ecx
movl 0x2c(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x2c(%rsp)
jmp 0x88e8f
addq $0x48, %rsp
retq
nopl (%rax)
| _ZN22remapped_memory_access5writeEjPhj:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_C], esi
mov [rsp+48h+var_18], rdx
mov [rsp+48h+var_1C], ecx
mov rax, [rsp+48h+var_8]
mov [rsp+48h+var_48], rax
loc_88E8F:
cmp [rsp+48h+var_1C], 0
jz loc_88F37
mov rdi, [rsp+48h+var_48]; this
mov esi, [rsp+48h+var_C]; unsigned int
call _ZN22remapped_memory_access12get_remappedEj; remapped_memory_access::get_remapped(uint)
mov [rsp+48h+var_30], edx
mov [rsp+48h+var_38], rax
mov rax, [rsp+48h+var_38]
mov [rsp+48h+var_28], rax
mov eax, [rsp+48h+var_30]
mov [rsp+48h+var_20], eax
mov eax, dword ptr [rsp+48h+var_28+4]
sub eax, dword ptr [rsp+48h+var_28]
mov [rsp+48h+var_40], eax
lea rdi, [rsp+48h+var_1C]
lea rsi, [rsp+48h+var_40]
call _ZSt3minIjERKT_S2_S2_; std::min<uint>(uint const&,uint const&)
mov rcx, rax
mov rax, [rsp+48h+var_48]
mov ecx, [rcx]
mov [rsp+48h+var_3C], ecx
mov rdi, [rax+8]
mov esi, [rsp+48h+var_20]
add esi, dword ptr [rsp+48h+var_28]
mov rdx, [rsp+48h+var_18]
mov ecx, [rsp+48h+var_3C]
mov rax, [rdi]
call qword ptr [rax+10h]
mov ecx, [rsp+48h+var_3C]
mov rax, [rsp+48h+var_18]
mov ecx, ecx
add rax, rcx
mov [rsp+48h+var_18], rax
mov eax, [rsp+48h+var_3C]
add eax, [rsp+48h+var_C]
mov [rsp+48h+var_C], eax
mov ecx, [rsp+48h+var_3C]
mov eax, [rsp+48h+var_1C]
sub eax, ecx
mov [rsp+48h+var_1C], eax
jmp loc_88E8F
loc_88F37:
add rsp, 48h
retn
| long long remapped_memory_access::write(
remapped_memory_access *this,
unsigned int a2,
unsigned __int8 *a3,
int a4)
{
long long result; // rax
long long remapped; // rax
int v6; // edx
int v7; // [rsp+8h] [rbp-40h] BYREF
unsigned int v8; // [rsp+Ch] [rbp-3Ch]
long long v9; // [rsp+10h] [rbp-38h]
int v10; // [rsp+18h] [rbp-30h]
long long v11; // [rsp+20h] [rbp-28h]
int v12; // [rsp+28h] [rbp-20h]
int v13; // [rsp+2Ch] [rbp-1Ch] BYREF
unsigned __int8 *v14; // [rsp+30h] [rbp-18h]
unsigned int v15; // [rsp+3Ch] [rbp-Ch]
remapped_memory_access *v16; // [rsp+40h] [rbp-8h]
v16 = this;
v15 = a2;
v14 = a3;
v13 = a4;
result = (long long)this;
while ( v13 )
{
remapped = remapped_memory_access::get_remapped(this, v15);
v10 = v6;
v9 = remapped;
v11 = remapped;
v12 = v6;
v7 = HIDWORD(remapped) - remapped;
v8 = *std::min<unsigned int>(&v13, &v7);
(*(void ( **)(_QWORD, _QWORD, unsigned __int8 *, _QWORD))(**((_QWORD **)this + 1) + 16LL))(
*((_QWORD *)this + 1),
(unsigned int)(v11 + v12),
v14,
v8);
v14 += v8;
v15 += v8;
result = v13 - v8;
v13 -= v8;
}
return result;
}
| write:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV dword ptr [RSP + 0x3c],ESI
MOV qword ptr [RSP + 0x30],RDX
MOV dword ptr [RSP + 0x2c],ECX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP],RAX
LAB_00188e8f:
CMP dword ptr [RSP + 0x2c],0x0
JZ 0x00188f37
MOV RDI,qword ptr [RSP]
MOV ESI,dword ptr [RSP + 0x3c]
CALL 0x00188f70
MOV dword ptr [RSP + 0x18],EDX
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x20],RAX
MOV EAX,dword ptr [RSP + 0x18]
MOV dword ptr [RSP + 0x28],EAX
MOV EAX,dword ptr [RSP + 0x24]
SUB EAX,dword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x8],EAX
LEA RDI,[RSP + 0x2c]
LEA RSI,[RSP + 0x8]
CALL 0x0015bc00
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV ECX,dword ptr [RCX]
MOV dword ptr [RSP + 0xc],ECX
MOV RDI,qword ptr [RAX + 0x8]
MOV ESI,dword ptr [RSP + 0x28]
ADD ESI,dword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x30]
MOV ECX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RSP + 0x30]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RSP + 0x30],RAX
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,dword ptr [RSP + 0x3c]
MOV dword ptr [RSP + 0x3c],EAX
MOV ECX,dword ptr [RSP + 0xc]
MOV EAX,dword ptr [RSP + 0x2c]
SUB EAX,ECX
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x00188e8f
LAB_00188f37:
ADD RSP,0x48
RET
|
/* remapped_memory_access::write(unsigned int, unsigned char*, unsigned int) */
void __thiscall
remapped_memory_access::write(remapped_memory_access *this,uint param_1,uchar *param_2,uint param_3)
{
uint *puVar1;
int1 auVar2 [12];
uint local_40;
uint local_3c;
int1 local_38 [12];
int1 local_28 [12];
uint local_1c;
uchar *local_18;
uint local_c;
remapped_memory_access *local_8;
local_18 = param_2;
local_c = param_1;
local_8 = this;
for (local_1c = param_3; local_1c != 0; local_1c = local_1c - local_3c) {
auVar2 = get_remapped(this,local_c);
local_28._4_4_ = auVar2._4_4_;
local_28._0_4_ = auVar2._0_4_;
local_40 = local_28._4_4_ - local_28._0_4_;
local_38 = auVar2;
local_28 = auVar2;
puVar1 = std::min<unsigned_int>(&local_1c,&local_40);
local_3c = *puVar1;
(**(code **)(**(long **)(this + 8) + 0x10))
(*(long **)(this + 8),local_28._8_4_ + local_28._0_4_,local_18,local_3c);
local_18 = local_18 + local_3c;
local_c = local_3c + local_c;
}
return;
}
| |
28,422 | simple_cs_is_full | eloqsql/mysys/charset.c | static my_bool simple_cs_is_full(CHARSET_INFO *cs)
{
return cs->number && cs->cs_name.str && cs->coll_name.str &&
simple_8bit_charset_data_is_full(cs) &&
(simple_8bit_collation_data_is_full(cs) || cs->tailoring);
} | O3 | c | simple_cs_is_full:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, (%rdi)
je 0x2fb6f
cmpq $0x0, 0x10(%rdi)
je 0x2fb6f
cmpq $0x0, 0x20(%rdi)
je 0x2fb6f
cmpq $0x0, 0x40(%rdi)
je 0x2fb6f
cmpq $0x0, 0x50(%rdi)
je 0x2fb6f
cmpq $0x0, 0x48(%rdi)
je 0x2fb6f
cmpq $0x0, 0x68(%rdi)
je 0x2fb6f
movb $0x1, %al
cmpq $0x0, 0x58(%rdi)
jne 0x2fb71
testb $0x10, 0xc(%rdi)
jne 0x2fb71
cmpq $0x0, 0x38(%rdi)
setne %al
jmp 0x2fb71
xorl %eax, %eax
popq %rbp
retq
| simple_cs_is_full:
push rbp
mov rbp, rsp
cmp dword ptr [rdi], 0
jz short loc_2FB6F
cmp qword ptr [rdi+10h], 0
jz short loc_2FB6F
cmp qword ptr [rdi+20h], 0
jz short loc_2FB6F
cmp qword ptr [rdi+40h], 0
jz short loc_2FB6F
cmp qword ptr [rdi+50h], 0
jz short loc_2FB6F
cmp qword ptr [rdi+48h], 0
jz short loc_2FB6F
cmp qword ptr [rdi+68h], 0
jz short loc_2FB6F
mov al, 1
cmp qword ptr [rdi+58h], 0
jnz short loc_2FB71
test byte ptr [rdi+0Ch], 10h
jnz short loc_2FB71
cmp qword ptr [rdi+38h], 0
setnz al
jmp short loc_2FB71
loc_2FB6F:
xor eax, eax
loc_2FB71:
pop rbp
retn
| bool simple_cs_is_full(long long a1)
{
bool result; // al
if ( !*(_DWORD *)a1
|| !*(_QWORD *)(a1 + 16)
|| !*(_QWORD *)(a1 + 32)
|| !*(_QWORD *)(a1 + 64)
|| !*(_QWORD *)(a1 + 80)
|| !*(_QWORD *)(a1 + 72)
|| !*(_QWORD *)(a1 + 104) )
{
return 0;
}
result = 1;
if ( !*(_QWORD *)(a1 + 88) && (*(_BYTE *)(a1 + 12) & 0x10) == 0 )
return *(_QWORD *)(a1 + 56) != 0LL;
return result;
}
| simple_cs_is_full:
PUSH RBP
MOV RBP,RSP
CMP dword ptr [RDI],0x0
JZ 0x0012fb6f
CMP qword ptr [RDI + 0x10],0x0
JZ 0x0012fb6f
CMP qword ptr [RDI + 0x20],0x0
JZ 0x0012fb6f
CMP qword ptr [RDI + 0x40],0x0
JZ 0x0012fb6f
CMP qword ptr [RDI + 0x50],0x0
JZ 0x0012fb6f
CMP qword ptr [RDI + 0x48],0x0
JZ 0x0012fb6f
CMP qword ptr [RDI + 0x68],0x0
JZ 0x0012fb6f
MOV AL,0x1
CMP qword ptr [RDI + 0x58],0x0
JNZ 0x0012fb71
TEST byte ptr [RDI + 0xc],0x10
JNZ 0x0012fb71
CMP qword ptr [RDI + 0x38],0x0
SETNZ AL
JMP 0x0012fb71
LAB_0012fb6f:
XOR EAX,EAX
LAB_0012fb71:
POP RBP
RET
|
bool simple_cs_is_full(int *param_1)
{
bool bVar1;
if (((((*param_1 == 0) || (*(long *)(param_1 + 4) == 0)) || (*(long *)(param_1 + 8) == 0)) ||
((*(long *)(param_1 + 0x10) == 0 || (*(long *)(param_1 + 0x14) == 0)))) ||
((*(long *)(param_1 + 0x12) == 0 || (*(long *)(param_1 + 0x1a) == 0)))) {
bVar1 = false;
}
else {
bVar1 = true;
if ((*(long *)(param_1 + 0x16) == 0) && ((*(byte *)(param_1 + 3) & 0x10) == 0)) {
bVar1 = *(long *)(param_1 + 0xe) != 0;
}
}
return bVar1;
}
| |
28,423 | js_parse_skip_parens_token | bluesky950520[P]quickjs/quickjs.c | static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_terminator)
{
char state[256];
size_t level = 0;
JSParsePos pos;
int last_tok, tok = TOK_EOF;
int c, tok_len, bits = 0;
/* protect from underflow */
state[level++] = 0;
js_parse_get_pos(s, &pos);
last_tok = 0;
for (;;) {
switch(s->token.val) {
case '(':
case '[':
case '{':
if (level >= sizeof(state))
goto done;
state[level++] = s->token.val;
break;
case ')':
if (state[--level] != '(')
goto done;
break;
case ']':
if (state[--level] != '[')
goto done;
break;
case '}':
c = state[--level];
if (c == '`') {
/* continue the parsing of the template */
free_token(s, &s->token);
/* Resume TOK_TEMPLATE parsing (s->token.line_num and
* s->token.ptr are OK) */
s->got_lf = FALSE;
s->last_line_num = s->token.line_num;
s->last_col_num = s->token.col_num;
if (js_parse_template_part(s, s->buf_ptr))
goto done;
goto handle_template;
} else if (c != '{') {
goto done;
}
break;
case TOK_TEMPLATE:
handle_template:
if (s->token.u.str.sep != '`') {
/* '${' inside the template : closing '}' and continue
parsing the template */
if (level >= sizeof(state))
goto done;
state[level++] = '`';
}
break;
case TOK_EOF:
goto done;
case ';':
if (level == 2) {
bits |= SKIP_HAS_SEMI;
}
break;
case TOK_ELLIPSIS:
if (level == 2) {
bits |= SKIP_HAS_ELLIPSIS;
}
break;
case '=':
bits |= SKIP_HAS_ASSIGNMENT;
break;
case TOK_DIV_ASSIGN:
tok_len = 2;
goto parse_regexp;
case '/':
tok_len = 1;
parse_regexp:
if (is_regexp_allowed(last_tok)) {
s->buf_ptr -= tok_len;
if (js_parse_regexp(s)) {
/* XXX: should clear the exception */
goto done;
}
}
break;
}
/* last_tok is only used to recognize regexps */
if (s->token.val == TOK_IDENT &&
(token_is_pseudo_keyword(s, JS_ATOM_of) ||
token_is_pseudo_keyword(s, JS_ATOM_yield))) {
last_tok = TOK_OF;
} else {
last_tok = s->token.val;
}
if (next_token(s)) {
/* XXX: should clear the exception generated by next_token() */
break;
}
if (level <= 1) {
tok = s->token.val;
if (token_is_pseudo_keyword(s, JS_ATOM_of))
tok = TOK_OF;
if (no_line_terminator && s->last_line_num != s->token.line_num)
tok = '\n';
break;
}
}
done:
if (pbits) {
*pbits = bits;
}
if (js_parse_seek_token(s, &pos))
return -1;
return tok;
} | O0 | c | js_parse_skip_parens_token:
subq $0x178, %rsp # imm = 0x178
movq %rdi, 0x168(%rsp)
movq %rsi, 0x160(%rsp)
movl %edx, 0x15c(%rsp)
movq $0x0, 0x48(%rsp)
movl $0xffffffaa, 0x10(%rsp) # imm = 0xFFFFFFAA
movl $0x0, 0x4(%rsp)
movq 0x48(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rsp)
movb $0x0, 0x50(%rsp,%rax)
movq 0x168(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa5820
movl $0x0, 0x14(%rsp)
movq 0x168(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, (%rsp)
subl $-0x7e, %eax
je 0xab659
jmp 0xab490
movl (%rsp), %eax
subl $-0x7a, %eax
je 0xab6d0
jmp 0xab49e
movl (%rsp), %eax
subl $-0x5b, %eax
je 0xab6ae
jmp 0xab4ac
movl (%rsp), %eax
subl $-0x56, %eax
je 0xab694
jmp 0xab4ba
movl (%rsp), %eax
subl $0x28, %eax
je 0xab52b
jmp 0xab4c4
movl (%rsp), %eax
subl $0x29, %eax
je 0xab562
jmp 0xab4d2
movl (%rsp), %eax
subl $0x2f, %eax
je 0xab6da
jmp 0xab4e0
movl (%rsp), %eax
subl $0x3b, %eax
je 0xab699
jmp 0xab4ee
movl (%rsp), %eax
subl $0x3d, %eax
je 0xab6c3
jmp 0xab4fc
movl (%rsp), %eax
subl $0x5b, %eax
je 0xab52b
jmp 0xab506
movl (%rsp), %eax
subl $0x5d, %eax
je 0xab587
jmp 0xab510
movl (%rsp), %eax
subl $0x7b, %eax
je 0xab52b
jmp 0xab51a
movl (%rsp), %eax
subl $0x7d, %eax
je 0xab5ac
jmp 0xab72a
cmpq $0x100, 0x48(%rsp) # imm = 0x100
jb 0xab53b
jmp 0xab7fc
movq 0x168(%rsp), %rax
movl 0x20(%rax), %eax
movb %al, %cl
movq 0x48(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x48(%rsp)
movb %cl, 0x50(%rsp,%rax)
jmp 0xab72a
movq 0x48(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x48(%rsp)
movzbl 0x4f(%rsp,%rax), %eax
cmpl $0x28, %eax
je 0xab582
jmp 0xab7fc
jmp 0xab72a
movq 0x48(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x48(%rsp)
movzbl 0x4f(%rsp,%rax), %eax
cmpl $0x5b, %eax
je 0xab5a7
jmp 0xab7fc
jmp 0xab72a
movq 0x48(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x48(%rsp)
movzbl 0x4f(%rsp,%rax), %eax
movl %eax, 0xc(%rsp)
cmpl $0x60, 0xc(%rsp)
jne 0xab646
movq 0x168(%rsp), %rdi
movq 0x168(%rsp), %rsi
addq $0x20, %rsi
callq 0x55a10
movq 0x168(%rsp), %rax
movl $0x0, 0x58(%rax)
movq 0x168(%rsp), %rax
movl 0x24(%rax), %ecx
movq 0x168(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x168(%rsp), %rax
movl 0x28(%rax), %ecx
movq 0x168(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x168(%rsp), %rdi
movq 0x168(%rsp), %rax
movq 0x70(%rax), %rsi
callq 0xa4b50
cmpl $0x0, %eax
je 0xab644
jmp 0xab7fc
jmp 0xab65b
cmpl $0x7b, 0xc(%rsp)
je 0xab652
jmp 0xab7fc
jmp 0xab654
jmp 0xab72a
jmp 0xab65b
movq 0x168(%rsp), %rax
cmpl $0x60, 0x48(%rax)
je 0xab68f
cmpq $0x100, 0x48(%rsp) # imm = 0x100
jb 0xab679
jmp 0xab7fc
movq 0x48(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rsp)
movb $0x60, 0x50(%rsp,%rax)
jmp 0xab72a
jmp 0xab7fc
cmpq $0x2, 0x48(%rsp)
jne 0xab6ac
movl 0x4(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xab72a
cmpq $0x2, 0x48(%rsp)
jne 0xab6c1
movl 0x4(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x4(%rsp)
jmp 0xab72a
movl 0x4(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x4(%rsp)
jmp 0xab72a
movl $0x2, 0x8(%rsp)
jmp 0xab6e2
movl $0x1, 0x8(%rsp)
movl 0x14(%rsp), %edi
callq 0xadd10
cmpl $0x0, %eax
je 0xab728
movl 0x8(%rsp), %edx
movq 0x168(%rsp), %rax
movq 0x70(%rax), %rcx
movslq %edx, %rsi
xorl %edx, %edx
subq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, 0x70(%rax)
movq 0x168(%rsp), %rdi
callq 0xadda0
cmpl $0x0, %eax
je 0xab726
jmp 0xab7fc
jmp 0xab728
jmp 0xab72a
movq 0x168(%rsp), %rax
cmpl $-0x7d, 0x20(%rax)
jne 0xab770
movq 0x168(%rsp), %rdi
movl $0x44, %esi
callq 0xa5bf0
cmpl $0x0, %eax
jne 0xab766
movq 0x168(%rsp), %rdi
movl $0x2d, %esi
callq 0xa5bf0
cmpl $0x0, %eax
je 0xab770
movl $0xffffffd9, 0x14(%rsp) # imm = 0xFFFFFFD9
jmp 0xab77f
movq 0x168(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x168(%rsp), %rdi
callq 0xa32b0
cmpl $0x0, %eax
je 0xab793
jmp 0xab7fa
cmpq $0x1, 0x48(%rsp)
ja 0xab7f5
movq 0x168(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x168(%rsp), %rdi
movl $0x44, %esi
callq 0xa5bf0
cmpl $0x0, %eax
je 0xab7c9
movl $0xffffffd9, 0x10(%rsp) # imm = 0xFFFFFFD9
cmpl $0x0, 0x15c(%rsp)
je 0xab7f3
movq 0x168(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x168(%rsp), %rcx
cmpl 0x24(%rcx), %eax
je 0xab7f3
movl $0xa, 0x10(%rsp)
jmp 0xab7fa
jmp 0xab477
jmp 0xab7fc
cmpq $0x0, 0x160(%rsp)
je 0xab815
movl 0x4(%rsp), %ecx
movq 0x160(%rsp), %rax
movl %ecx, (%rax)
movq 0x168(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa58c0
cmpl $0x0, %eax
je 0xab839
movl $0xffffffff, 0x174(%rsp) # imm = 0xFFFFFFFF
jmp 0xab844
movl 0x10(%rsp), %eax
movl %eax, 0x174(%rsp)
movl 0x174(%rsp), %eax
addq $0x178, %rsp # imm = 0x178
retq
nopw %cs:(%rax,%rax)
| js_parse_skip_parens_token:
sub rsp, 178h
mov [rsp+178h+var_10], rdi
mov [rsp+178h+var_18], rsi
mov [rsp+178h+var_1C], edx
mov [rsp+178h+var_130], 0
mov [rsp+178h+var_168], 0FFFFFFAAh
mov [rsp+178h+var_174], 0
mov rax, [rsp+178h+var_130]
mov rcx, rax
add rcx, 1
mov [rsp+178h+var_130], rcx
mov [rsp+rax+178h+var_128], 0
mov rdi, [rsp+178h+var_10]
lea rsi, [rsp+178h+var_160]
call js_parse_get_pos
mov [rsp+178h+var_164], 0
loc_AB477:
mov rax, [rsp+178h+var_10]
mov eax, [rax+20h]
mov [rsp+178h+var_178], eax
sub eax, 0FFFFFF82h
jz loc_AB659
jmp short $+2
loc_AB490:
mov eax, [rsp+178h+var_178]
sub eax, 0FFFFFF86h
jz loc_AB6D0
jmp short $+2
loc_AB49E:
mov eax, [rsp+178h+var_178]
sub eax, 0FFFFFFA5h
jz loc_AB6AE
jmp short $+2
loc_AB4AC:
mov eax, [rsp+178h+var_178]
sub eax, 0FFFFFFAAh
jz loc_AB694
jmp short $+2
loc_AB4BA:
mov eax, [rsp+178h+var_178]
sub eax, 28h ; '('
jz short loc_AB52B
jmp short $+2
loc_AB4C4:
mov eax, [rsp+178h+var_178]
sub eax, 29h ; ')'
jz loc_AB562
jmp short $+2
loc_AB4D2:
mov eax, [rsp+178h+var_178]
sub eax, 2Fh ; '/'
jz loc_AB6DA
jmp short $+2
loc_AB4E0:
mov eax, [rsp+178h+var_178]
sub eax, 3Bh ; ';'
jz loc_AB699
jmp short $+2
loc_AB4EE:
mov eax, [rsp+178h+var_178]
sub eax, 3Dh ; '='
jz loc_AB6C3
jmp short $+2
loc_AB4FC:
mov eax, [rsp+178h+var_178]
sub eax, 5Bh ; '['
jz short loc_AB52B
jmp short $+2
loc_AB506:
mov eax, [rsp+178h+var_178]
sub eax, 5Dh ; ']'
jz short loc_AB587
jmp short $+2
loc_AB510:
mov eax, [rsp+178h+var_178]
sub eax, 7Bh ; '{'
jz short loc_AB52B
jmp short $+2
loc_AB51A:
mov eax, [rsp+178h+var_178]
sub eax, 7Dh ; '}'
jz loc_AB5AC
jmp loc_AB72A
loc_AB52B:
cmp [rsp+178h+var_130], 100h
jb short loc_AB53B
jmp loc_AB7FC
loc_AB53B:
mov rax, [rsp+178h+var_10]
mov eax, [rax+20h]
mov cl, al
mov rax, [rsp+178h+var_130]
mov rdx, rax
add rdx, 1
mov [rsp+178h+var_130], rdx
mov [rsp+rax+178h+var_128], cl
jmp loc_AB72A
loc_AB562:
mov rax, [rsp+178h+var_130]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rsp+178h+var_130], rcx
movzx eax, byte ptr [rsp+rax+178h+var_130+7]
cmp eax, 28h ; '('
jz short loc_AB582
jmp loc_AB7FC
loc_AB582:
jmp loc_AB72A
loc_AB587:
mov rax, [rsp+178h+var_130]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rsp+178h+var_130], rcx
movzx eax, byte ptr [rsp+rax+178h+var_130+7]
cmp eax, 5Bh ; '['
jz short loc_AB5A7
jmp loc_AB7FC
loc_AB5A7:
jmp loc_AB72A
loc_AB5AC:
mov rax, [rsp+178h+var_130]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rsp+178h+var_130], rcx
movzx eax, byte ptr [rsp+rax+178h+var_130+7]
mov [rsp+178h+var_16C], eax
cmp [rsp+178h+var_16C], 60h ; '`'
jnz short loc_AB646
mov rdi, [rsp+178h+var_10]
mov rsi, [rsp+178h+var_10]
add rsi, 20h ; ' '
call free_token
mov rax, [rsp+178h+var_10]
mov dword ptr [rax+58h], 0
mov rax, [rsp+178h+var_10]
mov ecx, [rax+24h]
mov rax, [rsp+178h+var_10]
mov [rax+8], ecx
mov rax, [rsp+178h+var_10]
mov ecx, [rax+28h]
mov rax, [rsp+178h+var_10]
mov [rax+0Ch], ecx
mov rdi, [rsp+178h+var_10]
mov rax, [rsp+178h+var_10]
mov rsi, [rax+70h]
call js_parse_template_part
cmp eax, 0
jz short loc_AB644
jmp loc_AB7FC
loc_AB644:
jmp short loc_AB65B
loc_AB646:
cmp [rsp+178h+var_16C], 7Bh ; '{'
jz short loc_AB652
jmp loc_AB7FC
loc_AB652:
jmp short $+2
loc_AB654:
jmp loc_AB72A
loc_AB659:
jmp short $+2
loc_AB65B:
mov rax, [rsp+178h+var_10]
cmp dword ptr [rax+48h], 60h ; '`'
jz short loc_AB68F
cmp [rsp+178h+var_130], 100h
jb short loc_AB679
jmp loc_AB7FC
loc_AB679:
mov rax, [rsp+178h+var_130]
mov rcx, rax
add rcx, 1
mov [rsp+178h+var_130], rcx
mov [rsp+rax+178h+var_128], 60h ; '`'
loc_AB68F:
jmp loc_AB72A
loc_AB694:
jmp loc_AB7FC
loc_AB699:
cmp [rsp+178h+var_130], 2
jnz short loc_AB6AC
mov eax, [rsp+178h+var_174]
or eax, 1
mov [rsp+178h+var_174], eax
loc_AB6AC:
jmp short loc_AB72A
loc_AB6AE:
cmp [rsp+178h+var_130], 2
jnz short loc_AB6C1
mov eax, [rsp+178h+var_174]
or eax, 2
mov [rsp+178h+var_174], eax
loc_AB6C1:
jmp short loc_AB72A
loc_AB6C3:
mov eax, [rsp+178h+var_174]
or eax, 4
mov [rsp+178h+var_174], eax
jmp short loc_AB72A
loc_AB6D0:
mov [rsp+178h+var_170], 2
jmp short loc_AB6E2
loc_AB6DA:
mov [rsp+178h+var_170], 1
loc_AB6E2:
mov edi, [rsp+178h+var_164]
call is_regexp_allowed
cmp eax, 0
jz short loc_AB728
mov edx, [rsp+178h+var_170]
mov rax, [rsp+178h+var_10]
mov rcx, [rax+70h]
movsxd rsi, edx
xor edx, edx
sub rdx, rsi
add rcx, rdx
mov [rax+70h], rcx
mov rdi, [rsp+178h+var_10]
call js_parse_regexp
cmp eax, 0
jz short loc_AB726
jmp loc_AB7FC
loc_AB726:
jmp short $+2
loc_AB728:
jmp short $+2
loc_AB72A:
mov rax, [rsp+178h+var_10]
cmp dword ptr [rax+20h], 0FFFFFF83h
jnz short loc_AB770
mov rdi, [rsp+178h+var_10]
mov esi, 44h ; 'D'
call token_is_pseudo_keyword
cmp eax, 0
jnz short loc_AB766
mov rdi, [rsp+178h+var_10]
mov esi, 2Dh ; '-'
call token_is_pseudo_keyword
cmp eax, 0
jz short loc_AB770
loc_AB766:
mov [rsp+178h+var_164], 0FFFFFFD9h
jmp short loc_AB77F
loc_AB770:
mov rax, [rsp+178h+var_10]
mov eax, [rax+20h]
mov [rsp+178h+var_164], eax
loc_AB77F:
mov rdi, [rsp+178h+var_10]
call next_token
cmp eax, 0
jz short loc_AB793
jmp short loc_AB7FA
loc_AB793:
cmp [rsp+178h+var_130], 1
ja short loc_AB7F5
mov rax, [rsp+178h+var_10]
mov eax, [rax+20h]
mov [rsp+178h+var_168], eax
mov rdi, [rsp+178h+var_10]
mov esi, 44h ; 'D'
call token_is_pseudo_keyword
cmp eax, 0
jz short loc_AB7C9
mov [rsp+178h+var_168], 0FFFFFFD9h
loc_AB7C9:
cmp [rsp+178h+var_1C], 0
jz short loc_AB7F3
mov rax, [rsp+178h+var_10]
mov eax, [rax+8]
mov rcx, [rsp+178h+var_10]
cmp eax, [rcx+24h]
jz short loc_AB7F3
mov [rsp+178h+var_168], 0Ah
loc_AB7F3:
jmp short loc_AB7FA
loc_AB7F5:
jmp loc_AB477
loc_AB7FA:
jmp short $+2
loc_AB7FC:
cmp [rsp+178h+var_18], 0
jz short loc_AB815
mov ecx, [rsp+178h+var_174]
mov rax, [rsp+178h+var_18]
mov [rax], ecx
loc_AB815:
mov rdi, [rsp+178h+var_10]
lea rsi, [rsp+178h+var_160]
call js_parse_seek_token
cmp eax, 0
jz short loc_AB839
mov [rsp+178h+var_4], 0FFFFFFFFh
jmp short loc_AB844
loc_AB839:
mov eax, [rsp+178h+var_168]
mov [rsp+178h+var_4], eax
loc_AB844:
mov eax, [rsp+178h+var_4]
add rsp, 178h
retn
| long long js_parse_skip_parens_token(
long long *a1,
_DWORD *a2,
int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
double v11; // xmm4_8
double v12; // xmm5_8
char v13; // cl
unsigned long long v14; // rax
unsigned long long v15; // rax
unsigned long long v16; // rax
unsigned long long v17; // rax
double v18; // xmm4_8
double v19; // xmm5_8
unsigned long long v20; // rax
int v22; // [rsp+0h] [rbp-178h]
int v23; // [rsp+4h] [rbp-174h]
int v24; // [rsp+8h] [rbp-170h]
int v25; // [rsp+Ch] [rbp-16Ch]
unsigned int v26; // [rsp+10h] [rbp-168h]
unsigned int v27; // [rsp+14h] [rbp-164h]
_BYTE v28[48]; // [rsp+18h] [rbp-160h] BYREF
unsigned long long v29; // [rsp+48h] [rbp-130h]
_BYTE v30[268]; // [rsp+50h] [rbp-128h]
int v31; // [rsp+15Ch] [rbp-1Ch]
_DWORD *v32; // [rsp+160h] [rbp-18h]
long long *v33; // [rsp+168h] [rbp-10h]
v33 = a1;
v32 = a2;
v31 = a3;
v26 = -86;
v23 = 0;
v29 = 1LL;
v30[0] = 0;
js_parse_get_pos((long long)a1, (long long)v28);
v27 = 0;
do
{
v22 = *((_DWORD *)v33 + 8);
switch ( v22 )
{
case -126:
goto LABEL_27;
case -122:
v24 = 2;
break;
case -91:
if ( v29 == 2 )
v23 |= 2u;
goto LABEL_43;
case -86:
goto LABEL_57;
case 40:
LABEL_16:
if ( v29 >= 0x100 )
goto LABEL_57;
v13 = *((_DWORD *)v33 + 8);
v14 = v29++;
v30[v14] = v13;
goto LABEL_43;
case 41:
v15 = v29--;
if ( v30[v15 - 1] != 40 )
goto LABEL_57;
goto LABEL_43;
case 47:
v24 = 1;
break;
case 59:
if ( v29 == 2 )
v23 |= 1u;
goto LABEL_43;
case 61:
v23 |= 4u;
goto LABEL_43;
case 91:
goto LABEL_16;
case 93:
v16 = v29--;
if ( v30[v16 - 1] != 91 )
goto LABEL_57;
goto LABEL_43;
case 123:
goto LABEL_16;
case 125:
v17 = v29--;
v25 = (unsigned __int8)v30[v17 - 1];
if ( v25 != 96 )
{
if ( v25 != 123 )
goto LABEL_57;
goto LABEL_43;
}
free_token(v33, (long long)(v33 + 4));
*((_DWORD *)v33 + 22) = 0;
*((_DWORD *)v33 + 2) = *((_DWORD *)v33 + 9);
*((_DWORD *)v33 + 3) = *((_DWORD *)v33 + 10);
if ( (unsigned int)js_parse_template_part(v33, (unsigned __int8 *)v33[14], a4, a5, a6, a7, v18, v19, a10, a11) )
goto LABEL_57;
LABEL_27:
if ( *((_DWORD *)v33 + 18) != 96 )
{
if ( v29 >= 0x100 )
goto LABEL_57;
v20 = v29++;
v30[v20] = 96;
}
goto LABEL_43;
default:
goto LABEL_43;
}
if ( (unsigned int)is_regexp_allowed(v27) )
{
v33[14] -= v24;
if ( (unsigned int)js_parse_regexp(v33) )
goto LABEL_57;
}
LABEL_43:
if ( *((_DWORD *)v33 + 8) == -125
&& ((unsigned int)token_is_pseudo_keyword(v33, 68) || (unsigned int)token_is_pseudo_keyword(v33, 45)) )
{
v27 = -39;
}
else
{
v27 = *((_DWORD *)v33 + 8);
}
if ( (unsigned int)next_token(v33, a4, a5, a6, a7, v11, v12, a10, a11) )
goto LABEL_57;
}
while ( v29 > 1 );
v26 = *((_DWORD *)v33 + 8);
if ( (unsigned int)token_is_pseudo_keyword(v33, 68) )
v26 = -39;
if ( v31 && *((_DWORD *)v33 + 2) != *((_DWORD *)v33 + 9) )
v26 = 10;
LABEL_57:
if ( v32 )
*v32 = v23;
if ( (unsigned int)js_parse_seek_token((long long)v33, (long long)v28, a4, a5, a6, a7, v11, v12, a10, a11) )
return (unsigned int)-1;
else
return v26;
}
| js_parse_skip_parens_token:
SUB RSP,0x178
MOV qword ptr [RSP + 0x168],RDI
MOV qword ptr [RSP + 0x160],RSI
MOV dword ptr [RSP + 0x15c],EDX
MOV qword ptr [RSP + 0x48],0x0
MOV dword ptr [RSP + 0x10],0xffffffaa
MOV dword ptr [RSP + 0x4],0x0
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0x48],RCX
MOV byte ptr [RSP + RAX*0x1 + 0x50],0x0
MOV RDI,qword ptr [RSP + 0x168]
LEA RSI,[RSP + 0x18]
CALL 0x001a5820
MOV dword ptr [RSP + 0x14],0x0
LAB_001ab477:
MOV RAX,qword ptr [RSP + 0x168]
MOV EAX,dword ptr [RAX + 0x20]
MOV dword ptr [RSP],EAX
SUB EAX,-0x7e
JZ 0x001ab659
JMP 0x001ab490
LAB_001ab490:
MOV EAX,dword ptr [RSP]
SUB EAX,-0x7a
JZ 0x001ab6d0
JMP 0x001ab49e
LAB_001ab49e:
MOV EAX,dword ptr [RSP]
SUB EAX,-0x5b
JZ 0x001ab6ae
JMP 0x001ab4ac
LAB_001ab4ac:
MOV EAX,dword ptr [RSP]
SUB EAX,-0x56
JZ 0x001ab694
JMP 0x001ab4ba
LAB_001ab4ba:
MOV EAX,dword ptr [RSP]
SUB EAX,0x28
JZ 0x001ab52b
JMP 0x001ab4c4
LAB_001ab4c4:
MOV EAX,dword ptr [RSP]
SUB EAX,0x29
JZ 0x001ab562
JMP 0x001ab4d2
LAB_001ab4d2:
MOV EAX,dword ptr [RSP]
SUB EAX,0x2f
JZ 0x001ab6da
JMP 0x001ab4e0
LAB_001ab4e0:
MOV EAX,dword ptr [RSP]
SUB EAX,0x3b
JZ 0x001ab699
JMP 0x001ab4ee
LAB_001ab4ee:
MOV EAX,dword ptr [RSP]
SUB EAX,0x3d
JZ 0x001ab6c3
JMP 0x001ab4fc
LAB_001ab4fc:
MOV EAX,dword ptr [RSP]
SUB EAX,0x5b
JZ 0x001ab52b
JMP 0x001ab506
LAB_001ab506:
MOV EAX,dword ptr [RSP]
SUB EAX,0x5d
JZ 0x001ab587
JMP 0x001ab510
LAB_001ab510:
MOV EAX,dword ptr [RSP]
SUB EAX,0x7b
JZ 0x001ab52b
JMP 0x001ab51a
LAB_001ab51a:
MOV EAX,dword ptr [RSP]
SUB EAX,0x7d
JZ 0x001ab5ac
JMP 0x001ab72a
LAB_001ab52b:
CMP qword ptr [RSP + 0x48],0x100
JC 0x001ab53b
JMP 0x001ab7fc
LAB_001ab53b:
MOV RAX,qword ptr [RSP + 0x168]
MOV EAX,dword ptr [RAX + 0x20]
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x48]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RSP + 0x48],RDX
MOV byte ptr [RSP + RAX*0x1 + 0x50],CL
JMP 0x001ab72a
LAB_001ab562:
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RSP + 0x48],RCX
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x4f]
CMP EAX,0x28
JZ 0x001ab582
JMP 0x001ab7fc
LAB_001ab582:
JMP 0x001ab72a
LAB_001ab587:
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RSP + 0x48],RCX
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x4f]
CMP EAX,0x5b
JZ 0x001ab5a7
JMP 0x001ab7fc
LAB_001ab5a7:
JMP 0x001ab72a
LAB_001ab5ac:
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RSP + 0x48],RCX
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x4f]
MOV dword ptr [RSP + 0xc],EAX
CMP dword ptr [RSP + 0xc],0x60
JNZ 0x001ab646
MOV RDI,qword ptr [RSP + 0x168]
MOV RSI,qword ptr [RSP + 0x168]
ADD RSI,0x20
CALL 0x00155a10
MOV RAX,qword ptr [RSP + 0x168]
MOV dword ptr [RAX + 0x58],0x0
MOV RAX,qword ptr [RSP + 0x168]
MOV ECX,dword ptr [RAX + 0x24]
MOV RAX,qword ptr [RSP + 0x168]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RSP + 0x168]
MOV ECX,dword ptr [RAX + 0x28]
MOV RAX,qword ptr [RSP + 0x168]
MOV dword ptr [RAX + 0xc],ECX
MOV RDI,qword ptr [RSP + 0x168]
MOV RAX,qword ptr [RSP + 0x168]
MOV RSI,qword ptr [RAX + 0x70]
CALL 0x001a4b50
CMP EAX,0x0
JZ 0x001ab644
JMP 0x001ab7fc
LAB_001ab644:
JMP 0x001ab65b
LAB_001ab646:
CMP dword ptr [RSP + 0xc],0x7b
JZ 0x001ab652
JMP 0x001ab7fc
LAB_001ab652:
JMP 0x001ab654
LAB_001ab654:
JMP 0x001ab72a
LAB_001ab659:
JMP 0x001ab65b
LAB_001ab65b:
MOV RAX,qword ptr [RSP + 0x168]
CMP dword ptr [RAX + 0x48],0x60
JZ 0x001ab68f
CMP qword ptr [RSP + 0x48],0x100
JC 0x001ab679
JMP 0x001ab7fc
LAB_001ab679:
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0x48],RCX
MOV byte ptr [RSP + RAX*0x1 + 0x50],0x60
LAB_001ab68f:
JMP 0x001ab72a
LAB_001ab694:
JMP 0x001ab7fc
LAB_001ab699:
CMP qword ptr [RSP + 0x48],0x2
JNZ 0x001ab6ac
MOV EAX,dword ptr [RSP + 0x4]
OR EAX,0x1
MOV dword ptr [RSP + 0x4],EAX
LAB_001ab6ac:
JMP 0x001ab72a
LAB_001ab6ae:
CMP qword ptr [RSP + 0x48],0x2
JNZ 0x001ab6c1
MOV EAX,dword ptr [RSP + 0x4]
OR EAX,0x2
MOV dword ptr [RSP + 0x4],EAX
LAB_001ab6c1:
JMP 0x001ab72a
LAB_001ab6c3:
MOV EAX,dword ptr [RSP + 0x4]
OR EAX,0x4
MOV dword ptr [RSP + 0x4],EAX
JMP 0x001ab72a
LAB_001ab6d0:
MOV dword ptr [RSP + 0x8],0x2
JMP 0x001ab6e2
LAB_001ab6da:
MOV dword ptr [RSP + 0x8],0x1
LAB_001ab6e2:
MOV EDI,dword ptr [RSP + 0x14]
CALL 0x001add10
CMP EAX,0x0
JZ 0x001ab728
MOV EDX,dword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x168]
MOV RCX,qword ptr [RAX + 0x70]
MOVSXD RSI,EDX
XOR EDX,EDX
SUB RDX,RSI
ADD RCX,RDX
MOV qword ptr [RAX + 0x70],RCX
MOV RDI,qword ptr [RSP + 0x168]
CALL 0x001adda0
CMP EAX,0x0
JZ 0x001ab726
JMP 0x001ab7fc
LAB_001ab726:
JMP 0x001ab728
LAB_001ab728:
JMP 0x001ab72a
LAB_001ab72a:
MOV RAX,qword ptr [RSP + 0x168]
CMP dword ptr [RAX + 0x20],-0x7d
JNZ 0x001ab770
MOV RDI,qword ptr [RSP + 0x168]
MOV ESI,0x44
CALL 0x001a5bf0
CMP EAX,0x0
JNZ 0x001ab766
MOV RDI,qword ptr [RSP + 0x168]
MOV ESI,0x2d
CALL 0x001a5bf0
CMP EAX,0x0
JZ 0x001ab770
LAB_001ab766:
MOV dword ptr [RSP + 0x14],0xffffffd9
JMP 0x001ab77f
LAB_001ab770:
MOV RAX,qword ptr [RSP + 0x168]
MOV EAX,dword ptr [RAX + 0x20]
MOV dword ptr [RSP + 0x14],EAX
LAB_001ab77f:
MOV RDI,qword ptr [RSP + 0x168]
CALL 0x001a32b0
CMP EAX,0x0
JZ 0x001ab793
JMP 0x001ab7fa
LAB_001ab793:
CMP qword ptr [RSP + 0x48],0x1
JA 0x001ab7f5
MOV RAX,qword ptr [RSP + 0x168]
MOV EAX,dword ptr [RAX + 0x20]
MOV dword ptr [RSP + 0x10],EAX
MOV RDI,qword ptr [RSP + 0x168]
MOV ESI,0x44
CALL 0x001a5bf0
CMP EAX,0x0
JZ 0x001ab7c9
MOV dword ptr [RSP + 0x10],0xffffffd9
LAB_001ab7c9:
CMP dword ptr [RSP + 0x15c],0x0
JZ 0x001ab7f3
MOV RAX,qword ptr [RSP + 0x168]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RSP + 0x168]
CMP EAX,dword ptr [RCX + 0x24]
JZ 0x001ab7f3
MOV dword ptr [RSP + 0x10],0xa
LAB_001ab7f3:
JMP 0x001ab7fa
LAB_001ab7f5:
JMP 0x001ab477
LAB_001ab7fa:
JMP 0x001ab7fc
LAB_001ab7fc:
CMP qword ptr [RSP + 0x160],0x0
JZ 0x001ab815
MOV ECX,dword ptr [RSP + 0x4]
MOV RAX,qword ptr [RSP + 0x160]
MOV dword ptr [RAX],ECX
LAB_001ab815:
MOV RDI,qword ptr [RSP + 0x168]
LEA RSI,[RSP + 0x18]
CALL 0x001a58c0
CMP EAX,0x0
JZ 0x001ab839
MOV dword ptr [RSP + 0x174],0xffffffff
JMP 0x001ab844
LAB_001ab839:
MOV EAX,dword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x174],EAX
LAB_001ab844:
MOV EAX,dword ptr [RSP + 0x174]
ADD RSP,0x178
RET
|
int4 js_parse_skip_parens_token(long param_1,uint *param_2,int param_3)
{
long lVar1;
int iVar2;
ulong uVar3;
uint local_174;
int local_170;
int4 local_168;
int4 local_164;
int1 local_160 [48];
int8 local_130;
int1 auStack_128 [268];
int local_1c;
uint *local_18;
long local_10;
int4 local_4;
local_168 = 0xffffffaa;
local_174 = 0;
local_130 = 1;
auStack_128[0] = 0;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
js_parse_get_pos(param_1,local_160);
local_164 = 0;
do {
iVar2 = *(int *)(local_10 + 0x20);
if (iVar2 == -0x7e) {
LAB_001ab65b:
if (*(int *)(local_10 + 0x48) != 0x60) {
if (0xff < local_130) goto LAB_001ab7fc;
auStack_128[local_130] = 0x60;
local_130 = local_130 + 1;
}
}
else if (iVar2 == -0x7a) {
local_170 = 2;
LAB_001ab6e2:
iVar2 = is_regexp_allowed(local_164);
if (iVar2 != 0) {
*(long *)(local_10 + 0x70) = *(long *)(local_10 + 0x70) - (long)local_170;
iVar2 = js_parse_regexp(local_10);
if (iVar2 != 0) goto LAB_001ab7fc;
}
}
else if (iVar2 == -0x5b) {
if (local_130 == 2) {
local_174 = local_174 | 2;
}
}
else {
if (iVar2 == -0x56) goto LAB_001ab7fc;
if (iVar2 == 0x28) goto LAB_001ab52b;
if (iVar2 == 0x29) {
uVar3 = local_130 - 1;
lVar1 = local_130 - 1;
local_130 = uVar3;
if (auStack_128[lVar1] != '(') goto LAB_001ab7fc;
}
else {
if (iVar2 == 0x2f) {
local_170 = 1;
goto LAB_001ab6e2;
}
if (iVar2 == 0x3b) {
if (local_130 == 2) {
local_174 = local_174 | 1;
}
}
else if (iVar2 == 0x3d) {
local_174 = local_174 | 4;
}
else if (iVar2 == 0x5b) {
LAB_001ab52b:
if (0xff < local_130) goto LAB_001ab7fc;
auStack_128[local_130] = (char)*(int4 *)(local_10 + 0x20);
local_130 = local_130 + 1;
}
else if (iVar2 == 0x5d) {
uVar3 = local_130 - 1;
lVar1 = local_130 - 1;
local_130 = uVar3;
if (auStack_128[lVar1] != '[') goto LAB_001ab7fc;
}
else {
if (iVar2 == 0x7b) goto LAB_001ab52b;
if (iVar2 == 0x7d) {
uVar3 = local_130 - 1;
lVar1 = local_130 - 1;
local_130 = uVar3;
if (auStack_128[lVar1] == '`') {
free_token(local_10,local_10 + 0x20);
*(int4 *)(local_10 + 0x58) = 0;
*(int4 *)(local_10 + 8) = *(int4 *)(local_10 + 0x24);
*(int4 *)(local_10 + 0xc) = *(int4 *)(local_10 + 0x28);
iVar2 = js_parse_template_part(local_10,*(int8 *)(local_10 + 0x70));
if (iVar2 == 0) goto LAB_001ab65b;
goto LAB_001ab7fc;
}
if (auStack_128[lVar1] != '{') goto LAB_001ab7fc;
}
}
}
}
if ((*(int *)(local_10 + 0x20) == -0x7d) &&
((iVar2 = token_is_pseudo_keyword(local_10,0x44), iVar2 != 0 ||
(iVar2 = token_is_pseudo_keyword(local_10,0x2d), iVar2 != 0)))) {
local_164 = 0xffffffd9;
}
else {
local_164 = *(int4 *)(local_10 + 0x20);
}
iVar2 = next_token(local_10);
if (iVar2 != 0) goto LAB_001ab7fc;
} while (1 < local_130);
local_168 = *(int4 *)(local_10 + 0x20);
iVar2 = token_is_pseudo_keyword(local_10,0x44);
if (iVar2 != 0) {
local_168 = 0xffffffd9;
}
if ((local_1c != 0) && (*(int *)(local_10 + 8) != *(int *)(local_10 + 0x24))) {
local_168 = 10;
}
LAB_001ab7fc:
if (local_18 != (uint *)0x0) {
*local_18 = local_174;
}
iVar2 = js_parse_seek_token(local_10,local_160);
if (iVar2 == 0) {
local_4 = local_168;
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
| |
28,424 | js_parse_skip_parens_token | bluesky950520[P]quickjs/quickjs.c | static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_terminator)
{
char state[256];
size_t level = 0;
JSParsePos pos;
int last_tok, tok = TOK_EOF;
int c, tok_len, bits = 0;
/* protect from underflow */
state[level++] = 0;
js_parse_get_pos(s, &pos);
last_tok = 0;
for (;;) {
switch(s->token.val) {
case '(':
case '[':
case '{':
if (level >= sizeof(state))
goto done;
state[level++] = s->token.val;
break;
case ')':
if (state[--level] != '(')
goto done;
break;
case ']':
if (state[--level] != '[')
goto done;
break;
case '}':
c = state[--level];
if (c == '`') {
/* continue the parsing of the template */
free_token(s, &s->token);
/* Resume TOK_TEMPLATE parsing (s->token.line_num and
* s->token.ptr are OK) */
s->got_lf = FALSE;
s->last_line_num = s->token.line_num;
s->last_col_num = s->token.col_num;
if (js_parse_template_part(s, s->buf_ptr))
goto done;
goto handle_template;
} else if (c != '{') {
goto done;
}
break;
case TOK_TEMPLATE:
handle_template:
if (s->token.u.str.sep != '`') {
/* '${' inside the template : closing '}' and continue
parsing the template */
if (level >= sizeof(state))
goto done;
state[level++] = '`';
}
break;
case TOK_EOF:
goto done;
case ';':
if (level == 2) {
bits |= SKIP_HAS_SEMI;
}
break;
case TOK_ELLIPSIS:
if (level == 2) {
bits |= SKIP_HAS_ELLIPSIS;
}
break;
case '=':
bits |= SKIP_HAS_ASSIGNMENT;
break;
case TOK_DIV_ASSIGN:
tok_len = 2;
goto parse_regexp;
case '/':
tok_len = 1;
parse_regexp:
if (is_regexp_allowed(last_tok)) {
s->buf_ptr -= tok_len;
if (js_parse_regexp(s)) {
/* XXX: should clear the exception */
goto done;
}
}
break;
}
/* last_tok is only used to recognize regexps */
if (s->token.val == TOK_IDENT &&
(token_is_pseudo_keyword(s, JS_ATOM_of) ||
token_is_pseudo_keyword(s, JS_ATOM_yield))) {
last_tok = TOK_OF;
} else {
last_tok = s->token.val;
}
if (next_token(s)) {
/* XXX: should clear the exception generated by next_token() */
break;
}
if (level <= 1) {
tok = s->token.val;
if (token_is_pseudo_keyword(s, JS_ATOM_of))
tok = TOK_OF;
if (no_line_terminator && s->last_line_num != s->token.line_num)
tok = '\n';
break;
}
}
done:
if (pbits) {
*pbits = bits;
}
if (js_parse_seek_token(s, &pos))
return -1;
return tok;
} | O2 | c | js_parse_skip_parens_token:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl %edx, 0xc(%rsp)
movq %rsi, (%rsp)
movq %rdi, %rbx
movb $0x0, 0x40(%rsp)
movsd 0x24(%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movlhps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movaps %xmm1, 0x10(%rsp)
movq 0x30(%rdi), %rax
movq %rax, 0x28(%rsp)
movups 0x80(%rdi), %xmm0
movaps %xmm0, 0x30(%rsp)
movl 0x58(%rdi), %eax
movl %eax, 0x20(%rsp)
leaq 0x20(%rdi), %r15
xorl %ebp, %ebp
pushq $0x1
popq %r14
pushq $-0x2
popq %r12
xorl %r13d, %r13d
movl (%r15), %eax
cmpl $-0x7e, %eax
je 0x58cdc
movq %r12, %rcx
cmpl $-0x7a, %eax
je 0x58c43
cmpl $-0x5b, %eax
je 0x58c2b
cmpl $0x28, %eax
je 0x58ce4
cmpl $0x29, %eax
je 0x58d13
cmpl $0x2f, %eax
je 0x58c40
cmpl $0x3b, %eax
je 0x58d03
cmpl $0x3d, %eax
je 0x58cfb
cmpl $0x5b, %eax
je 0x58ce4
cmpl $0x5d, %eax
je 0x58d1d
cmpl $0x7b, %eax
je 0x58ce4
cmpl $0x7d, %eax
je 0x58c96
cmpl $-0x56, %eax
jne 0x58d2b
jmp 0x58de6
movl %r13d, %eax
orl $0x2, %eax
cmpq $0x2, %r14
cmovel %eax, %r13d
pushq $-0x5b
jmp 0x58d41
pushq $-0x1
popq %rcx
leal 0x80(%rbp), %eax
cmpl $0x32, %eax
ja 0x58c62
movabsq $0x438000030001b, %rdx # imm = 0x438000030001B
btq %rax, %rdx
jb 0x58d28
cmpl $0x29, %ebp
je 0x58d28
cmpl $0x5d, %ebp
je 0x58d28
cmpl $0x7d, %ebp
je 0x58d28
addq %rcx, 0x70(%rbx)
movq %rbx, %rdi
callq 0x5a0f0
testl %eax, %eax
je 0x58d28
jmp 0x58d7a
movzbl 0x3f(%rsp,%r14), %eax
decq %r14
cmpl $0x7b, %eax
je 0x58d76
cmpl $0x60, %eax
jne 0x58d7a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3160b
andl $0x0, 0x58(%rbx)
movq 0x24(%rbx), %rax
movq 0x70(%rbx), %rsi
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x54f3c
testl %eax, %eax
jne 0x58d7a
cmpl $0x60, 0x48(%rbx)
je 0x58d28
movb $0x60, %al
cmpq $0xff, %r14
ja 0x58d7a
movb %al, 0x40(%rsp,%r14)
incq %r14
jmp 0x58d28
orl $0x4, %r13d
pushq $0x3d
jmp 0x58d41
xorl %eax, %eax
cmpq $0x2, %r14
sete %al
orl %eax, %r13d
pushq $0x3b
jmp 0x58d41
cmpb $0x28, 0x3f(%rsp,%r14)
je 0x58d25
jmp 0x58d7a
cmpb $0x5b, 0x3f(%rsp,%r14)
jne 0x58d7a
decq %r14
movl (%r15), %eax
cmpl $-0x7d, %eax
jne 0x58d42
movq %rbx, %rdi
pushq $0x44
popq %rsi
callq 0x556da
testl %eax, %eax
je 0x58d5c
pushq $-0x27
popq %rax
movl %eax, %ebp
movq %rbx, %rdi
callq 0x535fe
testl %eax, %eax
jne 0x58d7a
cmpq $0x1, %r14
ja 0x58bbb
jmp 0x58d84
movq %rbx, %rdi
pushq $0x2d
popq %rsi
callq 0x556da
testl %eax, %eax
pushq $-0x27
popq %rax
movl %eax, %ebp
pushq $-0x7d
popq %rax
cmovel %eax, %ebp
jmp 0x58d44
pushq $0x7d
jmp 0x58d41
movq (%rsp), %rax
pushq $-0x56
popq %r14
jmp 0x58db4
movl 0x20(%rbx), %ebp
pushq $0x44
popq %rsi
movq %rbx, %rdi
callq 0x556da
testl %eax, %eax
pushq $-0x27
popq %r14
cmovel %ebp, %r14d
cmpl $0x0, 0xc(%rsp)
je 0x58db0
movl 0x8(%rbx), %eax
cmpl 0x24(%rbx), %eax
pushq $0xa
popq %rax
cmovnel %eax, %r14d
movq (%rsp), %rax
testq %rax, %rax
je 0x58dbc
movl %r13d, (%rax)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x55688
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
orl %r14d, %ecx
movl %ecx, %eax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r14d
jmp 0x58db0
| js_parse_skip_parens_token:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 148h
mov [rsp+178h+var_16C], edx
mov [rsp+178h+var_178], rsi
mov rbx, rdi
mov [rsp+178h+var_138], 0
movsd xmm0, qword ptr [rdi+24h]
movsd xmm1, qword ptr [rdi+8]
movlhps xmm1, xmm0
movaps [rsp+178h+var_168], xmm1
mov rax, [rdi+30h]
mov [rsp+178h+var_150], rax
movups xmm0, xmmword ptr [rdi+80h]
movaps [rsp+178h+var_148], xmm0
mov eax, [rdi+58h]
mov [rsp+178h+var_158], eax
lea r15, [rdi+20h]
xor ebp, ebp
push 1
pop r14
push 0FFFFFFFFFFFFFFFEh
pop r12
xor r13d, r13d
loc_58BBB:
mov eax, [r15]
cmp eax, 0FFFFFF82h
jz loc_58CDC
mov rcx, r12
cmp eax, 0FFFFFF86h
jz short loc_58C43
cmp eax, 0FFFFFFA5h
jz short loc_58C2B
cmp eax, 28h ; '('
jz loc_58CE4
cmp eax, 29h ; ')'
jz loc_58D13
cmp eax, 2Fh ; '/'
jz short loc_58C40
cmp eax, 3Bh ; ';'
jz loc_58D03
cmp eax, 3Dh ; '='
jz loc_58CFB
cmp eax, 5Bh ; '['
jz loc_58CE4
cmp eax, 5Dh ; ']'
jz loc_58D1D
cmp eax, 7Bh ; '{'
jz loc_58CE4
cmp eax, 7Dh ; '}'
jz short loc_58C96
cmp eax, 0FFFFFFAAh
jnz loc_58D2B
jmp loc_58DE6
loc_58C2B:
mov eax, r13d
or eax, 2
cmp r14, 2
cmovz r13d, eax
push 0FFFFFFFFFFFFFFA5h
jmp loc_58D41
loc_58C40:
push 0FFFFFFFFFFFFFFFFh
pop rcx
loc_58C43:
lea eax, [rbp+80h]
cmp eax, 32h ; '2'
ja short loc_58C62
mov rdx, 438000030001Bh
bt rdx, rax
jb loc_58D28
loc_58C62:
cmp ebp, 29h ; ')'
jz loc_58D28
cmp ebp, 5Dh ; ']'
jz loc_58D28
cmp ebp, 7Dh ; '}'
jz loc_58D28
add [rbx+70h], rcx
mov rdi, rbx
call js_parse_regexp
test eax, eax
jz loc_58D28
jmp loc_58D7A
loc_58C96:
movzx eax, byte ptr [rsp+r14+178h+var_148+0Fh]
dec r14
cmp eax, 7Bh ; '{'
jz loc_58D76
cmp eax, 60h ; '`'
jnz loc_58D7A
mov rdi, rbx
mov rsi, r15
call free_token
and dword ptr [rbx+58h], 0
mov rax, [rbx+24h]
mov rsi, [rbx+70h]
mov [rbx+8], rax
mov rdi, rbx
call js_parse_template_part
test eax, eax
jnz loc_58D7A
loc_58CDC:
cmp dword ptr [rbx+48h], 60h ; '`'
jz short loc_58D28
mov al, 60h ; '`'
loc_58CE4:
cmp r14, 0FFh
ja loc_58D7A
mov [rsp+r14+178h+var_138], al
inc r14
jmp short loc_58D28
loc_58CFB:
or r13d, 4
push 3Dh ; '='
jmp short loc_58D41
loc_58D03:
xor eax, eax
cmp r14, 2
setz al
or r13d, eax
push 3Bh ; ';'
jmp short loc_58D41
loc_58D13:
cmp byte ptr [rsp+r14+178h+var_148+0Fh], 28h ; '('
jz short loc_58D25
jmp short loc_58D7A
loc_58D1D:
cmp byte ptr [rsp+r14+178h+var_148+0Fh], 5Bh ; '['
jnz short loc_58D7A
loc_58D25:
dec r14
loc_58D28:
mov eax, [r15]
loc_58D2B:
cmp eax, 0FFFFFF83h
jnz short loc_58D42
mov rdi, rbx
push 44h ; 'D'
pop rsi
call token_is_pseudo_keyword
test eax, eax
jz short loc_58D5C
push 0FFFFFFFFFFFFFFD9h
loc_58D41:
pop rax
loc_58D42:
mov ebp, eax
loc_58D44:
mov rdi, rbx
call next_token
test eax, eax
jnz short loc_58D7A
cmp r14, 1
ja loc_58BBB
jmp short loc_58D84
loc_58D5C:
mov rdi, rbx
push 2Dh ; '-'
pop rsi
call token_is_pseudo_keyword
test eax, eax
push 0FFFFFFFFFFFFFFD9h
pop rax
mov ebp, eax
push 0FFFFFFFFFFFFFF83h
pop rax
cmovz ebp, eax
jmp short loc_58D44
loc_58D76:
push 7Dh ; '}'
jmp short loc_58D41
loc_58D7A:
mov rax, [rsp+178h+var_178]
push 0FFFFFFFFFFFFFFAAh
pop r14
jmp short loc_58DB4
loc_58D84:
mov ebp, [rbx+20h]
push 44h ; 'D'
pop rsi
mov rdi, rbx
call token_is_pseudo_keyword
test eax, eax
push 0FFFFFFFFFFFFFFD9h
pop r14
cmovz r14d, ebp
cmp [rsp+178h+var_16C], 0
jz short loc_58DB0
mov eax, [rbx+8]
cmp eax, [rbx+24h]
push 0Ah
pop rax
cmovnz r14d, eax
loc_58DB0:
mov rax, [rsp+178h+var_178]
loc_58DB4:
test rax, rax
jz short loc_58DBC
mov [rax], r13d
loc_58DBC:
lea rsi, [rsp+178h+var_168]
mov rdi, rbx
call js_parse_seek_token
xor ecx, ecx
neg eax
sbb ecx, ecx
or ecx, r14d
mov eax, ecx
add rsp, 148h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_58DE6:
mov r14d, eax
jmp short loc_58DB0
| long long js_parse_skip_parens_token(
long long a1,
char *a2,
long long a3,
long long a4,
long long a5,
long long a6,
double a7,
double a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
__m128 v14; // xmm1
__m128 v15; // xmm0
int *v16; // r15
int v17; // ebp
unsigned long long v18; // r14
int v19; // r13d
int v20; // eax
unsigned long long v21; // rax
int v22; // eax
double v23; // xmm4_8
double v24; // xmm5_8
char *v25; // rax
int v26; // ebp
BOOL is_pseudo_keyword; // eax
int v29; // r14d
int v30; // [rsp-8h] [rbp-180h]
char *v31; // [rsp+0h] [rbp-178h]
int v32; // [rsp+Ch] [rbp-16Ch]
__m128 v33; // [rsp+10h] [rbp-168h] BYREF
int v34; // [rsp+20h] [rbp-158h]
long long v35; // [rsp+28h] [rbp-150h]
__m128 v36; // [rsp+30h] [rbp-148h]
_BYTE v37[312]; // [rsp+40h] [rbp-138h]
v32 = a3;
v31 = a2;
v37[0] = 0;
v14 = _mm_movelh_ps((__m128)*(unsigned long long *)(a1 + 8), (__m128)*(unsigned long long *)(a1 + 36));
v33 = v14;
v35 = *(_QWORD *)(a1 + 48);
v15 = *(__m128 *)(a1 + 128);
v36 = v15;
v34 = *(_DWORD *)(a1 + 88);
v16 = (int *)(a1 + 32);
v17 = 0;
v18 = 1LL;
v19 = 0;
do
{
v20 = *v16;
if ( *v16 == -126 )
goto LABEL_30;
a4 = -2LL;
switch ( v20 )
{
case -122:
goto LABEL_20;
case -91:
if ( v18 == 2 )
v19 |= 2u;
v30 = -91;
goto LABEL_44;
case 40:
goto LABEL_32;
case 41:
if ( v36.m128_i8[v18 + 15] != 40 )
goto LABEL_53;
LABEL_39:
--v18;
goto LABEL_40;
case 47:
a4 = -1LL;
LABEL_20:
v21 = (unsigned int)(v17 + 128);
if ( (unsigned int)v21 > 0x32 || (a3 = 0x438000030001BLL, !_bittest64(&a3, v21)) )
{
if ( v17 != 41 && v17 != 93 && v17 != 125 )
{
*(_QWORD *)(a1 + 112) += a4;
if ( (unsigned int)js_parse_regexp(a1) )
{
LABEL_53:
v25 = v31;
v29 = -86;
goto LABEL_60;
}
}
}
goto LABEL_40;
case 59:
v19 |= v18 == 2;
v30 = 59;
goto LABEL_44;
case 61:
v19 |= 4u;
v30 = 61;
LABEL_44:
v20 = v30;
LABEL_45:
v17 = v20;
goto LABEL_46;
case 91:
goto LABEL_32;
case 93:
if ( v36.m128_i8[v18 + 15] != 91 )
goto LABEL_53;
goto LABEL_39;
case 123:
goto LABEL_32;
case 125:
v22 = v36.m128_u8[v18-- + 15];
if ( v22 == 123 )
{
v30 = 125;
goto LABEL_44;
}
if ( v22 != 96 )
goto LABEL_53;
free_token((long long *)a1, v16);
*(_DWORD *)(a1 + 88) = 0;
a2 = *(char **)(a1 + 112);
*(_QWORD *)(a1 + 8) = *(_QWORD *)(a1 + 36);
if ( (unsigned int)js_parse_template_part(a1, a2, v15, v14, a9, a10, v23, v24, a13, a14) )
goto LABEL_53;
LABEL_30:
if ( *(_DWORD *)(a1 + 72) != 96 )
{
LOBYTE(v20) = 96;
LABEL_32:
if ( v18 > 0xFF )
goto LABEL_53;
v37[v18++] = v20;
}
LABEL_40:
v20 = *v16;
break;
case -86:
v29 = -86;
goto LABEL_59;
}
if ( v20 != -125 )
goto LABEL_45;
a2 = (char *)&dword_44;
if ( token_is_pseudo_keyword((_DWORD *)a1, 68) )
{
v30 = -39;
goto LABEL_44;
}
a2 = (_BYTE *)(&qword_28 + 5);
v17 = -39;
if ( !token_is_pseudo_keyword((_DWORD *)a1, 45) )
v17 = -125;
LABEL_46:
if ( (unsigned int)next_token(a1, (long long)a2, a3, v15, v14, a9, a10, a11, a12, a13, a14, a4, a5, a6) )
goto LABEL_53;
}
while ( v18 > 1 );
v26 = *(_DWORD *)(a1 + 32);
is_pseudo_keyword = token_is_pseudo_keyword((_DWORD *)a1, 68);
v29 = -39;
if ( !is_pseudo_keyword )
v29 = v26;
if ( v32 && *(_DWORD *)(a1 + 8) != *(_DWORD *)(a1 + 36) )
v29 = 10;
LABEL_59:
v25 = v31;
LABEL_60:
if ( v25 )
*(_DWORD *)v25 = v19;
return v29 | (unsigned int)-((unsigned int)js_parse_seek_token(
a1,
(long long)&v33,
a3,
a4,
a5,
a6,
*(double *)v15.m128_u64,
v14,
a9,
a10,
a11,
a12,
a13,
a14) != 0);
}
| js_parse_skip_parens_token:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x148
MOV dword ptr [RSP + 0xc],EDX
MOV qword ptr [RSP],RSI
MOV RBX,RDI
MOV byte ptr [RSP + 0x40],0x0
MOVSD XMM0,qword ptr [RDI + 0x24]
MOVSD XMM1,qword ptr [RDI + 0x8]
MOVLHPS XMM1,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM1
MOV RAX,qword ptr [RDI + 0x30]
MOV qword ptr [RSP + 0x28],RAX
MOVUPS XMM0,xmmword ptr [RDI + 0x80]
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOV EAX,dword ptr [RDI + 0x58]
MOV dword ptr [RSP + 0x20],EAX
LEA R15,[RDI + 0x20]
XOR EBP,EBP
PUSH 0x1
POP R14
PUSH -0x2
POP R12
XOR R13D,R13D
LAB_00158bbb:
MOV EAX,dword ptr [R15]
CMP EAX,-0x7e
JZ 0x00158cdc
MOV RCX,R12
CMP EAX,-0x7a
JZ 0x00158c43
CMP EAX,-0x5b
JZ 0x00158c2b
CMP EAX,0x28
JZ 0x00158ce4
CMP EAX,0x29
JZ 0x00158d13
CMP EAX,0x2f
JZ 0x00158c40
CMP EAX,0x3b
JZ 0x00158d03
CMP EAX,0x3d
JZ 0x00158cfb
CMP EAX,0x5b
JZ 0x00158ce4
CMP EAX,0x5d
JZ 0x00158d1d
CMP EAX,0x7b
JZ 0x00158ce4
CMP EAX,0x7d
JZ 0x00158c96
CMP EAX,-0x56
JNZ 0x00158d2b
JMP 0x00158de6
LAB_00158c2b:
MOV EAX,R13D
OR EAX,0x2
CMP R14,0x2
CMOVZ R13D,EAX
PUSH -0x5b
JMP 0x00158d41
LAB_00158c40:
PUSH -0x1
POP RCX
LAB_00158c43:
LEA EAX,[RBP + 0x80]
CMP EAX,0x32
JA 0x00158c62
MOV RDX,0x438000030001b
BT RDX,RAX
JC 0x00158d28
LAB_00158c62:
CMP EBP,0x29
JZ 0x00158d28
CMP EBP,0x5d
JZ 0x00158d28
CMP EBP,0x7d
JZ 0x00158d28
ADD qword ptr [RBX + 0x70],RCX
MOV RDI,RBX
CALL 0x0015a0f0
TEST EAX,EAX
JZ 0x00158d28
JMP 0x00158d7a
LAB_00158c96:
MOVZX EAX,byte ptr [RSP + R14*0x1 + 0x3f]
DEC R14
CMP EAX,0x7b
JZ 0x00158d76
CMP EAX,0x60
JNZ 0x00158d7a
MOV RDI,RBX
MOV RSI,R15
CALL 0x0013160b
AND dword ptr [RBX + 0x58],0x0
MOV RAX,qword ptr [RBX + 0x24]
MOV RSI,qword ptr [RBX + 0x70]
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,RBX
CALL 0x00154f3c
TEST EAX,EAX
JNZ 0x00158d7a
LAB_00158cdc:
CMP dword ptr [RBX + 0x48],0x60
JZ 0x00158d28
MOV AL,0x60
LAB_00158ce4:
CMP R14,0xff
JA 0x00158d7a
MOV byte ptr [RSP + R14*0x1 + 0x40],AL
INC R14
JMP 0x00158d28
LAB_00158cfb:
OR R13D,0x4
PUSH 0x3d
JMP 0x00158d41
LAB_00158d03:
XOR EAX,EAX
CMP R14,0x2
SETZ AL
OR R13D,EAX
PUSH 0x3b
JMP 0x00158d41
LAB_00158d13:
CMP byte ptr [RSP + R14*0x1 + 0x3f],0x28
JZ 0x00158d25
JMP 0x00158d7a
LAB_00158d1d:
CMP byte ptr [RSP + R14*0x1 + 0x3f],0x5b
JNZ 0x00158d7a
LAB_00158d25:
DEC R14
LAB_00158d28:
MOV EAX,dword ptr [R15]
LAB_00158d2b:
CMP EAX,-0x7d
JNZ 0x00158d42
MOV RDI,RBX
PUSH 0x44
POP RSI
CALL 0x001556da
TEST EAX,EAX
JZ 0x00158d5c
PUSH -0x27
LAB_00158d41:
POP RAX
LAB_00158d42:
MOV EBP,EAX
LAB_00158d44:
MOV RDI,RBX
CALL 0x001535fe
TEST EAX,EAX
JNZ 0x00158d7a
CMP R14,0x1
JA 0x00158bbb
JMP 0x00158d84
LAB_00158d5c:
MOV RDI,RBX
PUSH 0x2d
POP RSI
CALL 0x001556da
TEST EAX,EAX
PUSH -0x27
POP RAX
MOV EBP,EAX
PUSH -0x7d
POP RAX
CMOVZ EBP,EAX
JMP 0x00158d44
LAB_00158d76:
PUSH 0x7d
JMP 0x00158d41
LAB_00158d7a:
MOV RAX,qword ptr [RSP]
PUSH -0x56
POP R14
JMP 0x00158db4
LAB_00158d84:
MOV EBP,dword ptr [RBX + 0x20]
PUSH 0x44
POP RSI
MOV RDI,RBX
CALL 0x001556da
TEST EAX,EAX
PUSH -0x27
POP R14
CMOVZ R14D,EBP
CMP dword ptr [RSP + 0xc],0x0
JZ 0x00158db0
MOV EAX,dword ptr [RBX + 0x8]
CMP EAX,dword ptr [RBX + 0x24]
PUSH 0xa
POP RAX
CMOVNZ R14D,EAX
LAB_00158db0:
MOV RAX,qword ptr [RSP]
LAB_00158db4:
TEST RAX,RAX
JZ 0x00158dbc
MOV dword ptr [RAX],R13D
LAB_00158dbc:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00155688
XOR ECX,ECX
NEG EAX
SBB ECX,ECX
OR ECX,R14D
MOV EAX,ECX
ADD RSP,0x148
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00158de6:
MOV R14D,EAX
JMP 0x00158db0
|
uint js_parse_skip_parens_token(long param_1,uint *param_2,int param_3)
{
int *piVar1;
uint uVar2;
int iVar3;
int iVar4;
long lVar5;
uint uVar6;
uint uVar7;
ulong uVar8;
int8 local_168;
int8 uStack_160;
int4 local_158;
int8 local_150;
int4 local_148;
int4 uStack_144;
int4 uStack_140;
int4 uStack_13c;
char local_138 [264];
local_138[0] = '\0';
uStack_160 = *(int8 *)(param_1 + 0x24);
local_168 = *(int8 *)(param_1 + 8);
local_150 = *(int8 *)(param_1 + 0x30);
local_148 = *(int4 *)(param_1 + 0x80);
uStack_144 = *(int4 *)(param_1 + 0x84);
uStack_140 = *(int4 *)(param_1 + 0x88);
uStack_13c = *(int4 *)(param_1 + 0x8c);
local_158 = *(int4 *)(param_1 + 0x58);
piVar1 = (int *)(param_1 + 0x20);
iVar4 = 0;
uVar8 = 1;
uVar6 = 0;
do {
iVar3 = *piVar1;
if (iVar3 != -0x7e) {
lVar5 = -2;
if (iVar3 == -0x7a) {
LAB_00158c43:
if ((((0x32 < iVar4 + 0x80U) ||
((0x438000030001bU >> ((ulong)(iVar4 + 0x80U) & 0x3f) & 1) == 0)) && (iVar4 != 0x29))
&& ((iVar4 != 0x5d && (iVar4 != 0x7d)))) {
*(long *)(param_1 + 0x70) = *(long *)(param_1 + 0x70) + lVar5;
iVar4 = js_parse_regexp(param_1);
if (iVar4 != 0) goto LAB_00158d7a;
}
goto LAB_00158d28;
}
if (iVar3 == -0x5b) {
if (uVar8 == 2) {
uVar6 = uVar6 | 2;
}
iVar4 = -0x5b;
goto LAB_00158d44;
}
if (iVar3 == 0x28) goto LAB_00158ce4;
if (iVar3 == 0x29) {
if (local_138[uVar8 - 1] == '(') {
LAB_00158d25:
uVar8 = uVar8 - 1;
goto LAB_00158d28;
}
goto LAB_00158d7a;
}
if (iVar3 == 0x2f) {
lVar5 = -1;
goto LAB_00158c43;
}
if (iVar3 == 0x3b) {
uVar6 = uVar6 | uVar8 == 2;
iVar4 = 0x3b;
goto LAB_00158d44;
}
if (iVar3 == 0x3d) {
uVar6 = uVar6 | 4;
iVar4 = 0x3d;
goto LAB_00158d44;
}
if (iVar3 == 0x5b) {
LAB_00158ce4:
if (uVar8 < 0x100) {
local_138[uVar8] = (char)iVar3;
uVar8 = uVar8 + 1;
goto LAB_00158d28;
}
LAB_00158d7a:
uVar7 = 0xffffffaa;
}
else {
if (iVar3 == 0x5d) {
if (local_138[uVar8 - 1] == '[') goto LAB_00158d25;
goto LAB_00158d7a;
}
if (iVar3 == 0x7b) goto LAB_00158ce4;
if (iVar3 == 0x7d) {
lVar5 = uVar8 - 1;
uVar8 = uVar8 - 1;
if (local_138[lVar5] == '{') {
iVar4 = 0x7d;
goto LAB_00158d44;
}
if (local_138[lVar5] == '`') {
free_token(param_1,piVar1);
*(int4 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 8) = *(int8 *)(param_1 + 0x24);
iVar4 = js_parse_template_part(param_1,*(int8 *)(param_1 + 0x70));
if (iVar4 == 0) goto LAB_00158cdc;
}
goto LAB_00158d7a;
}
if (iVar3 != -0x56) goto LAB_00158d2b;
uVar7 = 0xffffffaa;
}
goto LAB_00158db4;
}
LAB_00158cdc:
if (*(int *)(param_1 + 0x48) != 0x60) {
iVar3 = 0x60;
goto LAB_00158ce4;
}
LAB_00158d28:
iVar3 = *piVar1;
LAB_00158d2b:
iVar4 = iVar3;
if (iVar3 == -0x7d) {
iVar4 = token_is_pseudo_keyword(param_1,0x44);
if (iVar4 == 0) {
iVar3 = token_is_pseudo_keyword(param_1,0x2d);
iVar4 = -0x27;
if (iVar3 == 0) {
iVar4 = -0x7d;
}
}
else {
iVar4 = -0x27;
}
}
LAB_00158d44:
iVar3 = next_token(param_1);
if (iVar3 != 0) goto LAB_00158d7a;
} while (1 < uVar8);
uVar2 = *(uint *)(param_1 + 0x20);
iVar4 = token_is_pseudo_keyword(param_1,0x44);
uVar7 = 0xffffffd9;
if (iVar4 == 0) {
uVar7 = uVar2;
}
if ((param_3 != 0) && (*(int *)(param_1 + 8) != *(int *)(param_1 + 0x24))) {
uVar7 = 10;
}
LAB_00158db4:
if (param_2 != (uint *)0x0) {
*param_2 = uVar6;
}
iVar4 = js_parse_seek_token(param_1,&local_168);
return -(uint)(iVar4 != 0) | uVar7;
}
| |
28,425 | used_buffs_add | eloqsql/storage/maria/ma_loghandler.c | static void
used_buffs_add(TRUNSLOG_USED_BUFFERS *buffs,
struct st_translog_buffer *buff)
{
DBUG_ENTER("used_buffs_add");
DBUG_PRINT("enter", ("ADD buffs: %p unlk %u (%p) wrt_ptr: %u (%p)"
" buff %p (%u)",
buffs,
buffs->wrt_ptr, buffs->buff[buffs->wrt_ptr],
buffs->unlck_ptr, buffs->buff[buffs->unlck_ptr],
buff, buff->buffer_no));
DBUG_ASSERT(buffs->wrt_ptr < MAX_TRUNSLOG_USED_BUFFERS);
buffs->buff[buffs->wrt_ptr++]= buff;
DBUG_VOID_RETURN;
} | O0 | c | used_buffs_add:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x93c1e
jmp 0x93c20
jmp 0x93c22
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movb 0x18(%rsi), %cl
movb %cl, %dil
addb $0x1, %dil
movb %dil, 0x18(%rsi)
movzbl %cl, %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x93c45
popq %rbp
retq
nopw (%rax,%rax)
| used_buffs_add:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_93C1E:
jmp short $+2
loc_93C20:
jmp short $+2
loc_93C22:
mov rdx, [rbp+var_10]
mov rax, [rbp+var_8]
mov rsi, [rbp+var_8]
mov cl, [rsi+18h]
mov dil, cl
add dil, 1
mov [rsi+18h], dil
movzx ecx, cl
mov [rax+rcx*8], rdx
jmp short $+2
loc_93C45:
pop rbp
retn
| long long used_buffs_add(long long a1, long long a2)
{
long long result; // rax
unsigned __int8 v3; // cl
result = a1;
v3 = *(_BYTE *)(a1 + 24);
*(_BYTE *)(a1 + 24) = v3 + 1;
*(_QWORD *)(a1 + 8LL * v3) = a2;
return result;
}
| used_buffs_add:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x00193c1e
LAB_00193c1e:
JMP 0x00193c20
LAB_00193c20:
JMP 0x00193c22
LAB_00193c22:
MOV RDX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x8]
MOV CL,byte ptr [RSI + 0x18]
MOV DIL,CL
ADD DIL,0x1
MOV byte ptr [RSI + 0x18],DIL
MOVZX ECX,CL
MOV qword ptr [RAX + RCX*0x8],RDX
JMP 0x00193c45
LAB_00193c45:
POP RBP
RET
|
void used_buffs_add(long param_1,int8 param_2)
{
byte bVar1;
bVar1 = *(byte *)(param_1 + 0x18);
*(byte *)(param_1 + 0x18) = bVar1 + 1;
*(int8 *)(param_1 + (ulong)bVar1 * 8) = param_2;
return;
}
| |
28,426 | mi_uniquedef_write | eloqsql/storage/myisam/mi_open.c | uint mi_uniquedef_write(File file, MI_UNIQUEDEF *def)
{
uchar buff[MI_UNIQUEDEF_SIZE];
uchar *ptr=buff;
mi_int2store(ptr,def->keysegs); ptr+=2;
*ptr++= (uchar) def->key;
*ptr++ = (uchar) def->null_are_equal;
return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
} | O3 | c | mi_uniquedef_write:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
movzwl (%rsi), %eax
rolw $0x8, %ax
movl %edi, %ebx
movw %ax, -0x1c(%rbp)
movb 0x2(%rsi), %al
movb %al, -0x1a(%rbp)
movb 0x3(%rsi), %al
movb %al, -0x19(%rbp)
leaq 0x305a5d(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x70(%rbp), %rdi
movl %ebx, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x80606
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
movl $0x4, %ecx
movl %ebx, %edi
callq 0x2f004
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %cl
movq %fs:0x28, %rdx
cmpq -0x18(%rbp), %rdx
jne 0x80620
movb %cl, %al
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x1c(%rbp), %rdx
leaq -0x28(%rbp), %r14
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rcx
callq 0x2e2ff
movq (%r14), %rcx
jmp 0x805e4
callq 0x29270
| mi_uniquedef_write:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 60h
mov rax, fs:28h
mov [rbp+var_18], rax
movzx eax, word ptr [rsi]
rol ax, 8
mov ebx, edi
mov [rbp+var_1C], ax
mov al, [rsi+2]
mov [rbp+var_1A], al
mov al, [rsi+3]
mov [rbp+var_19], al
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_70]
mov esi, ebx
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz short loc_80606
lea rsi, [rbp+var_1C]
mov edx, 4
mov ecx, 4
mov edi, ebx
call my_write
mov rcx, rax
loc_805E4:
xor eax, eax
test rcx, rcx
setnz cl
mov rdx, fs:28h
cmp rdx, [rbp+var_18]
jnz short loc_80620
mov al, cl
add rsp, 60h
pop rbx
pop r14
pop rbp
retn
loc_80606:
lea rdx, [rbp+var_1C]
lea r14, [rbp+var_28]
mov rdi, rax
mov esi, ebx
mov rcx, r14
call mi_uniquedef_write_cold_1
mov rcx, [r14]
jmp short loc_805E4
loc_80620:
call ___stack_chk_fail
| bool mi_uniquedef_write(unsigned int a1, long long a2)
{
long long v2; // rax
long long v3; // rcx
_BYTE v6[72]; // [rsp+0h] [rbp-70h] BYREF
long long v7; // [rsp+48h] [rbp-28h] BYREF
__int16 v8; // [rsp+54h] [rbp-1Ch] BYREF
char v9; // [rsp+56h] [rbp-1Ah]
char v10; // [rsp+57h] [rbp-19h]
unsigned long long v11; // [rsp+58h] [rbp-18h]
v11 = __readfsqword(0x28u);
v8 = __ROL2__(*(_WORD *)a2, 8);
v9 = *(_BYTE *)(a2 + 2);
v10 = *(_BYTE *)(a2 + 3);
v2 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v6, a1, 7LL);
if ( v2 )
{
mi_uniquedef_write_cold_1(v2, a1, (long long)&v8, &v7);
v3 = v7;
}
else
{
v3 = my_write(a1, (long long)&v8, 4LL, 4LL);
}
return v3 != 0;
}
| mi_uniquedef_write:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
MOVZX EAX,word ptr [RSI]
ROL AX,0x8
MOV EBX,EDI
MOV word ptr [RBP + -0x1c],AX
MOV AL,byte ptr [RSI + 0x2]
MOV byte ptr [RBP + -0x1a],AL
MOV AL,byte ptr [RSI + 0x3]
MOV byte ptr [RBP + -0x19],AL
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x70]
MOV ESI,EBX
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00180606
LEA RSI,[RBP + -0x1c]
MOV EDX,0x4
MOV ECX,0x4
MOV EDI,EBX
CALL 0x0012f004
MOV RCX,RAX
LAB_001805e4:
XOR EAX,EAX
TEST RCX,RCX
SETNZ CL
MOV RDX,qword ptr FS:[0x28]
CMP RDX,qword ptr [RBP + -0x18]
JNZ 0x00180620
MOV AL,CL
ADD RSP,0x60
POP RBX
POP R14
POP RBP
RET
LAB_00180606:
LEA RDX,[RBP + -0x1c]
LEA R14,[RBP + -0x28]
MOV RDI,RAX
MOV ESI,EBX
MOV RCX,R14
CALL 0x0012e2ff
MOV RCX,qword ptr [R14]
JMP 0x001805e4
LAB_00180620:
CALL 0x00129270
|
bool mi_uniquedef_write(int4 param_1,ushort *param_2)
{
long lVar1;
long in_FS_OFFSET;
int1 local_78 [72];
long local_30;
ushort local_24;
int1 local_22;
int1 local_21;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_24 = *param_2 << 8 | *param_2 >> 8;
local_22 = (int1)param_2[1];
local_21 = *(int1 *)((long)param_2 + 3);
lVar1 = (**(code **)(PSI_server + 0x158))(local_78,param_1,7);
if (lVar1 == 0) {
local_30 = my_write(param_1,&local_24,4,4);
}
else {
mi_uniquedef_write_cold_1(lVar1,param_1,&local_24,&local_30);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return local_30 != 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
28,427 | set_prealloc_root | eloqsql/mysys/my_alloc.c | void set_prealloc_root(MEM_ROOT *root, char *ptr)
{
USED_MEM *next;
for (next=root->used; next ; next=next->next)
{
if ((char*) next <= ptr && (char*) next + next->size > ptr)
{
root->pre_alloc=next;
return;
}
}
for (next=root->free ; next ; next=next->next)
{
if ((char*) next <= ptr && (char*) next + next->size > ptr)
{
root->pre_alloc=next;
return;
}
}
} | O0 | c | set_prealloc_root:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3ac28
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x3ac19
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
addq 0x10(%rcx), %rax
cmpq -0x10(%rbp), %rax
jbe 0x3ac19
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x3ac73
jmp 0x3ac1b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3abe8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3ac73
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x3ac64
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
addq 0x10(%rcx), %rax
cmpq -0x10(%rbp), %rax
jbe 0x3ac64
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x3ac73
jmp 0x3ac66
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3ac33
popq %rbp
retq
nopw %cs:(%rax,%rax)
| set_prealloc_root:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_18], rax
loc_3ABE8:
cmp [rbp+var_18], 0
jz short loc_3AC28
mov rax, [rbp+var_18]
cmp rax, [rbp+var_10]
ja short loc_3AC19
mov rax, [rbp+var_18]
mov rcx, [rbp+var_18]
add rax, [rcx+10h]
cmp rax, [rbp+var_10]
jbe short loc_3AC19
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
jmp short loc_3AC73
loc_3AC19:
jmp short $+2
loc_3AC1B:
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_18], rax
jmp short loc_3ABE8
loc_3AC28:
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
loc_3AC33:
cmp [rbp+var_18], 0
jz short loc_3AC73
mov rax, [rbp+var_18]
cmp rax, [rbp+var_10]
ja short loc_3AC64
mov rax, [rbp+var_18]
mov rcx, [rbp+var_18]
add rax, [rcx+10h]
cmp rax, [rbp+var_10]
jbe short loc_3AC64
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
jmp short loc_3AC73
loc_3AC64:
jmp short $+2
loc_3AC66:
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_18], rax
jmp short loc_3AC33
loc_3AC73:
pop rbp
retn
| _QWORD * set_prealloc_root(_QWORD *a1, unsigned long long a2)
{
_QWORD *result; // rax
_QWORD *i; // [rsp+0h] [rbp-18h]
_QWORD *j; // [rsp+0h] [rbp-18h]
for ( i = (_QWORD *)a1[1]; i; i = (_QWORD *)*i )
{
if ( (unsigned long long)i <= a2 && (unsigned long long)i + i[2] > a2 )
{
result = a1;
a1[2] = i;
return result;
}
}
result = (_QWORD *)*a1;
for ( j = (_QWORD *)*a1; j; j = (_QWORD *)*j )
{
if ( (unsigned long long)j <= a2 && (unsigned long long)j + j[2] > a2 )
{
result = a1;
a1[2] = j;
return result;
}
result = (_QWORD *)*j;
}
return result;
}
| set_prealloc_root:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
LAB_0013abe8:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0013ac28
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x10]
JA 0x0013ac19
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RCX + 0x10]
CMP RAX,qword ptr [RBP + -0x10]
JBE 0x0013ac19
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x0013ac73
LAB_0013ac19:
JMP 0x0013ac1b
LAB_0013ac1b:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0013abe8
LAB_0013ac28:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LAB_0013ac33:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0013ac73
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x10]
JA 0x0013ac64
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RCX + 0x10]
CMP RAX,qword ptr [RBP + -0x10]
JBE 0x0013ac64
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x0013ac73
LAB_0013ac64:
JMP 0x0013ac66
LAB_0013ac66:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0013ac33
LAB_0013ac73:
POP RBP
RET
|
void set_prealloc_root(int8 *param_1,int8 *param_2)
{
int8 *local_20;
local_20 = (int8 *)param_1[1];
while( true ) {
if (local_20 == (int8 *)0x0) {
local_20 = (int8 *)*param_1;
while( true ) {
if (local_20 == (int8 *)0x0) {
return;
}
if ((local_20 <= param_2) && (param_2 < (int8 *)((long)local_20 + local_20[2])))
break;
local_20 = (int8 *)*local_20;
}
param_1[2] = local_20;
return;
}
if ((local_20 <= param_2) && (param_2 < (int8 *)((long)local_20 + local_20[2]))) break;
local_20 = (int8 *)*local_20;
}
param_1[2] = local_20;
return;
}
| |
28,428 | list_add | eloqsql/mysys/list.c | LIST *list_add(LIST *root, LIST *element)
{
DBUG_ENTER("list_add");
DBUG_PRINT("enter",("root: %p element: %p", root, element));
if (root)
{
if (root->prev) /* If add in mid of list */
root->prev->next= element;
element->prev=root->prev;
root->prev=element;
}
else
element->prev=0;
element->next=root;
DBUG_RETURN(element); /* New root */
} | O0 | c | list_add:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x2785e
cmpq $0x0, -0x8(%rbp)
je 0x27899
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2787e
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x278a4
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nop
| list_add:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_2785E:
cmp [rbp+var_8], 0
jz short loc_27899
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz short loc_2787E
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rax+8], rcx
loc_2787E:
mov rax, [rbp+var_8]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax], rcx
jmp short loc_278A4
loc_27899:
mov rax, [rbp+var_10]
mov qword ptr [rax], 0
loc_278A4:
mov rcx, [rbp+var_8]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
pop rbp
retn
| _QWORD * list_add(long long a1, _QWORD *a2)
{
if ( a1 )
{
if ( *(_QWORD *)a1 )
*(_QWORD *)(*(_QWORD *)a1 + 8LL) = a2;
*a2 = *(_QWORD *)a1;
*(_QWORD *)a1 = a2;
}
else
{
*a2 = 0LL;
}
a2[1] = a1;
return a2;
}
| list_add:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x0012785e
LAB_0012785e:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00127899
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX],0x0
JZ 0x0012787e
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
LAB_0012787e:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
JMP 0x001278a4
LAB_00127899:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],0x0
LAB_001278a4:
MOV RCX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET
|
long * list_add(long *param_1,long *param_2)
{
if (param_1 == (long *)0x0) {
*param_2 = 0;
}
else {
if (*param_1 != 0) {
*(long **)(*param_1 + 8) = param_2;
}
*param_2 = *param_1;
*param_1 = (long)param_2;
}
param_2[1] = (long)param_1;
return param_2;
}
| |
28,429 | get_hash_link | eloqsql/storage/maria/ma_pagecache.c | static PAGECACHE_HASH_LINK *get_hash_link(PAGECACHE *pagecache,
PAGECACHE_FILE *file,
pgcache_page_no_t pageno)
{
reg1 PAGECACHE_HASH_LINK *hash_link;
PAGECACHE_HASH_LINK **start;
DBUG_ENTER("get_hash_link");
restart:
/* try to find the page in the cache */
hash_link= get_present_hash_link(pagecache, file, pageno,
&start);
if (!hash_link)
{
/* There is no hash link in the hash table for the pair (file, pageno) */
if (pagecache->free_hash_list)
{
DBUG_PRINT("info", ("free_hash_list: %p free_hash_list->next: %p",
pagecache->free_hash_list,
pagecache->free_hash_list->next));
hash_link= pagecache->free_hash_list;
pagecache->free_hash_list= hash_link->next;
}
else if (pagecache->hash_links_used < pagecache->hash_links)
{
hash_link= &pagecache->hash_link_root[pagecache->hash_links_used++];
}
else
{
/* Wait for a free hash link */
struct st_my_thread_var *thread= my_thread_var;
PAGECACHE_PAGE page;
page.file= *file;
page.pageno= pageno;
thread->keycache_link= (void *) &page;
wqueue_link_into_queue(&pagecache->waiting_for_hash_link, thread);
DBUG_PRINT("wait",
("suspend thread %s %ld", thread->name, (ulong) thread->id));
pagecache_pthread_cond_wait(&thread->suspend,
&pagecache->cache_lock);
thread->keycache_link= NULL;
DBUG_PRINT("thread", ("restarting..."));
goto restart;
}
hash_link->file= *file;
DBUG_ASSERT(pageno < ((1ULL) << 40));
hash_link->pageno= pageno;
link_hash(start, hash_link);
/* Register the request for the page */
hash_link->requests++;
DBUG_ASSERT(hash_link->block == 0);
DBUG_ASSERT(hash_link->requests == 1);
}
else
{
/*
We have to copy the flush_log callback, as it may change if the table
goes from non_transactional to transactional during recovery
*/
hash_link->file.flush_log_callback= file->flush_log_callback;
}
DBUG_PRINT("exit", ("hash_link: %p block: %p", hash_link,
hash_link->block));
DBUG_RETURN(hash_link);
} | O0 | c | get_hash_link:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x2ee90
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3082d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x30723
jmp 0x306fb
jmp 0x306fd
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x98(%rax)
jmp 0x307e7
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jge 0x30763
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x38(%rdx)
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x307e5
callq 0xf6090
movq %rax, -0x30(%rbp)
leaq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x48, %edx
callq 0x2a090
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
leaq -0x80(%rbp), %rcx
movq %rcx, 0xa8(%rax)
movq -0x8(%rbp), %rdi
addq $0x118, %rdi # imm = 0x118
movq -0x30(%rbp), %rsi
callq 0xff540
jmp 0x307ab
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0xc8, %rsi
leaq 0x120c5c(%rip), %rdx # 0x151421
movl $0x736, %ecx # imm = 0x736
callq 0x30420
movq -0x30(%rbp), %rax
movq $0x0, 0xa8(%rax)
jmp 0x307e0
jmp 0x306c7
jmp 0x307e7
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movl $0x48, %edx
callq 0x2a090
jmp 0x307ff
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x30db0
movq -0x20(%rbp), %rax
movl 0x68(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x68(%rax)
jmp 0x30827
jmp 0x30829
jmp 0x3082b
jmp 0x3083d
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
jmp 0x3083f
jmp 0x30841
jmp 0x30843
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop
| get_hash_link:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
loc_306C7:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rcx, [rbp+var_28]
call get_present_hash_link
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jnz loc_3082D
mov rax, [rbp+var_8]
cmp qword ptr [rax+98h], 0
jz short loc_30723
jmp short $+2
loc_306FB:
jmp short $+2
loc_306FD:
mov rax, [rbp+var_8]
mov rax, [rax+98h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rbp+var_8]
mov [rax+98h], rcx
jmp loc_307E7
loc_30723:
mov rax, [rbp+var_8]
mov rax, [rax+38h]
mov rcx, [rbp+var_8]
cmp rax, [rcx+30h]
jge short loc_30763
mov rax, [rbp+var_8]
mov rax, [rax+90h]
mov rdx, [rbp+var_8]
mov rcx, [rdx+38h]
mov rsi, rcx
add rsi, 1
mov [rdx+38h], rsi
imul rcx, 70h ; 'p'
add rax, rcx
mov [rbp+var_20], rax
jmp loc_307E5
loc_30763:
call _my_thread_var
mov [rbp+var_30], rax
lea rdi, [rbp+var_80]
mov rsi, [rbp+var_10]
mov edx, 48h ; 'H'
call _memcpy
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
lea rcx, [rbp+var_80]
mov [rax+0A8h], rcx
mov rdi, [rbp+var_8]
add rdi, 118h
mov rsi, [rbp+var_30]
call wqueue_link_into_queue
jmp short $+2
loc_307AB:
mov rdi, [rbp+var_30]
add rdi, 8
mov rsi, [rbp+var_8]
add rsi, 0C8h
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 736h
call inline_mysql_cond_wait
mov rax, [rbp+var_30]
mov qword ptr [rax+0A8h], 0
jmp short $+2
loc_307E0:
jmp loc_306C7
loc_307E5:
jmp short $+2
loc_307E7:
mov rdi, [rbp+var_20]
add rdi, 18h
mov rsi, [rbp+var_10]
mov edx, 48h ; 'H'
call _memcpy
jmp short $+2
loc_307FF:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+60h], rcx
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_20]
call link_hash
mov rax, [rbp+var_20]
mov ecx, [rax+68h]
add ecx, 1
mov [rax+68h], ecx
jmp short $+2
loc_30827:
jmp short $+2
loc_30829:
jmp short $+2
loc_3082B:
jmp short loc_3083D
loc_3082D:
mov rax, [rbp+var_10]
mov rcx, [rax+38h]
mov rax, [rbp+var_20]
mov [rax+50h], rcx
loc_3083D:
jmp short $+2
loc_3083F:
jmp short $+2
loc_30841:
jmp short $+2
loc_30843:
mov rax, [rbp+var_20]
mov [rbp+var_88], rax
mov rax, [rbp+var_88]
add rsp, 90h
pop rbp
retn
| long long * get_hash_link(_QWORD *a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rcx
_BYTE v6[72]; // [rsp+10h] [rbp-80h] BYREF
long long v7; // [rsp+58h] [rbp-38h]
long long v8; // [rsp+60h] [rbp-30h]
long long v9; // [rsp+68h] [rbp-28h] BYREF
long long *present_hash_link; // [rsp+70h] [rbp-20h]
long long v11; // [rsp+78h] [rbp-18h]
long long v12; // [rsp+80h] [rbp-10h]
_QWORD *v13; // [rsp+88h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
while ( 1 )
{
present_hash_link = get_present_hash_link((long long)v13, v12, v11, &v9);
if ( present_hash_link )
break;
if ( v13[19] )
{
present_hash_link = (long long *)v13[19];
v13[19] = *present_hash_link;
LABEL_8:
memcpy(present_hash_link + 3, v12, 72LL);
present_hash_link[12] = v11;
link_hash(v9, present_hash_link);
++*((_DWORD *)present_hash_link + 26);
return present_hash_link;
}
if ( v13[7] < v13[6] )
{
v3 = v13[18];
v4 = v13[7];
v13[7] = v4 + 1;
present_hash_link = (long long *)(112 * v4 + v3);
goto LABEL_8;
}
v8 = my_thread_var();
memcpy(v6, v12, sizeof(v6));
v7 = v11;
*(_QWORD *)(v8 + 168) = v6;
wqueue_link_into_queue(v13 + 35, v8);
inline_mysql_cond_wait(
v8 + 8,
(long long)(v13 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x736u);
*(_QWORD *)(v8 + 168) = 0LL;
}
present_hash_link[10] = *(_QWORD *)(v12 + 56);
return present_hash_link;
}
| get_hash_link:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LAB_001306c7:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RCX,[RBP + -0x28]
CALL 0x0012ee90
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0013082d
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x98],0x0
JZ 0x00130723
JMP 0x001306fb
LAB_001306fb:
JMP 0x001306fd
LAB_001306fd:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x98],RCX
JMP 0x001307e7
LAB_00130723:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x30]
JGE 0x00130763
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x90]
MOV RDX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RDX + 0x38]
MOV RSI,RCX
ADD RSI,0x1
MOV qword ptr [RDX + 0x38],RSI
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001307e5
LAB_00130763:
CALL 0x001f6090
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x48
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x80]
MOV qword ptr [RAX + 0xa8],RCX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x118
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x001ff540
JMP 0x001307ab
LAB_001307ab:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xc8
LEA RDX,[0x251421]
MOV ECX,0x736
CALL 0x00130420
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0xa8],0x0
JMP 0x001307e0
LAB_001307e0:
JMP 0x001306c7
LAB_001307e5:
JMP 0x001307e7
LAB_001307e7:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x18
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x48
CALL 0x0012a090
JMP 0x001307ff
LAB_001307ff:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x60],RCX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00130db0
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x68]
ADD ECX,0x1
MOV dword ptr [RAX + 0x68],ECX
JMP 0x00130827
LAB_00130827:
JMP 0x00130829
LAB_00130829:
JMP 0x0013082b
LAB_0013082b:
JMP 0x0013083d
LAB_0013082d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x50],RCX
LAB_0013083d:
JMP 0x0013083f
LAB_0013083f:
JMP 0x00130841
LAB_00130841:
JMP 0x00130843
LAB_00130843:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x88]
ADD RSP,0x90
POP RBP
RET
|
int8 * get_hash_link(long param_1,void *param_2,int8 param_3)
{
long lVar1;
int1 local_88 [72];
int8 local_40;
long local_38;
int8 local_30;
int8 *local_28;
int8 local_20;
void *local_18;
long local_10;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
local_28 = (int8 *)get_present_hash_link(local_10,local_18,local_20,&local_30);
if (local_28 != (int8 *)0x0) {
local_28[10] = *(int8 *)((long)local_18 + 0x38);
return local_28;
}
if (*(long *)(local_10 + 0x98) != 0) break;
if (*(long *)(local_10 + 0x38) < *(long *)(local_10 + 0x30)) {
lVar1 = *(long *)(local_10 + 0x38);
*(long *)(local_10 + 0x38) = lVar1 + 1;
local_28 = (int8 *)(*(long *)(local_10 + 0x90) + lVar1 * 0x70);
goto LAB_001307e7;
}
local_38 = _my_thread_var();
memcpy(local_88,local_18,0x48);
local_40 = local_20;
*(int1 **)(local_38 + 0xa8) = local_88;
wqueue_link_into_queue(local_10 + 0x118,local_38);
inline_mysql_cond_wait
(local_38 + 8,local_10 + 200,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",0x736);
*(int8 *)(local_38 + 0xa8) = 0;
}
local_28 = *(int8 **)(local_10 + 0x98);
*(int8 *)(local_10 + 0x98) = *local_28;
LAB_001307e7:
memcpy(local_28 + 3,local_18,0x48);
local_28[0xc] = local_20;
link_hash(local_30,local_28);
*(int *)(local_28 + 0xd) = *(int *)(local_28 + 0xd) + 1;
return local_28;
}
| |
28,430 | inline_mysql_cond_signal | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_cond_signal(
mysql_cond_t *that)
{
int result;
#ifdef HAVE_PSI_COND_INTERFACE
if (psi_likely(that->m_psi != NULL))
PSI_COND_CALL(signal_cond)(that->m_psi);
#endif
result= pthread_cond_signal(&that->m_cond);
return result;
} | O0 | c | inline_mysql_cond_signal:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x6fe7b
leaq 0x1c9129(%rip), %rax # 0x238f90
movq (%rax), %rax
movq 0x170(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x28030
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
| inline_mysql_cond_signal:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+30h], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_6FE7B
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+170h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+30h]
call rax
loc_6FE7B:
mov rdi, [rbp+var_8]
call _pthread_cond_signal
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
add rsp, 10h
pop rbp
retn
| long long inline_mysql_cond_signal(long long a1)
{
if ( *(_QWORD *)(a1 + 48) )
((void ( *)(_QWORD))PSI_server[46])(*(_QWORD *)(a1 + 48));
return (unsigned int)pthread_cond_signal(a1);
}
| inline_mysql_cond_signal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0016fe7b
LEA RAX,[0x338f90]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x170]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x30]
CALL RAX
LAB_0016fe7b:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00128030
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD RSP,0x10
POP RBP
RET
|
int inline_mysql_cond_signal(pthread_cond_t *param_1)
{
int iVar1;
if (param_1[1].__align != 0) {
(**(code **)(PSI_server + 0x170))(param_1[1].__align);
}
iVar1 = pthread_cond_signal(param_1);
return iVar1;
}
| |
28,431 | Dimension::remove_chunk(Chunk*) | untodesu[P]voxelius/game/shared/dimension.cc | void Dimension::remove_chunk(Chunk *chunk)
{
if(chunk) {
const auto &component = chunks.get<ChunkComponent>(chunk->get_entity());
m_chunkmap.erase(component.cpos);
chunks.destroy(chunk->get_entity());
}
} | O3 | cpp | Dimension::remove_chunk(Chunk*):
testq %rsi, %rsi
je 0x3b0d0
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rdi), %r14
movq %rsi, %rdi
callq 0x37198
movl %eax, %ebp
movq %r14, %rdi
movl $0x52f76421, %esi # imm = 0x52F76421
callq 0x30ea8
movq %rax, %r12
movq %rax, %rdi
movl %ebp, %esi
callq 0x232e6
movq 0x50(%r12), %rcx
movq %rax, %rdx
shrq $0xa, %rdx
andl $0x3ff, %eax # imm = 0x3FF
leaq (%rax,%rax,2), %rsi
shll $0x3, %esi
addq (%rcx,%rdx,8), %rsi
addq $0x2c8, %r15 # imm = 0x2C8
movq %r15, %rdi
callq 0x3b40e
movq %rbx, %rdi
callq 0x37198
movq %r14, %rdi
movl %eax, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2ab9e
retq
nop
| _ZN9Dimension12remove_chunkEP5Chunk:
test rsi, rsi
jz short locret_3B0D0
push rbp
push r15
push r14
push r12
push rbx
mov rbx, rsi
mov r15, rdi
lea r14, [rdi+8]
mov rdi, rsi; this
call _ZNK5Chunk10get_entityEv; Chunk::get_entity(void)
mov ebp, eax
mov rdi, r14
mov esi, 52F76421h
call _ZN4entt14basic_registryINS_6entityESaIS1_EE6assureI14ChunkComponentEERDaj
mov r12, rax
mov rdi, rax
mov esi, ebp
call _ZNK4entt16basic_sparse_setINS_6entityESaIS1_EE5indexES1_; entt::basic_sparse_set<entt::entity,std::allocator<entt::entity>>::index(entt::entity)
mov rcx, [r12+50h]
mov rdx, rax
shr rdx, 0Ah
and eax, 3FFh
lea rsi, [rax+rax*2]
shl esi, 3
add rsi, [rcx+rdx*8]
add r15, 2C8h
mov rdi, r15
call _ZN7emhash87HashMapIN3glm3vecILi3EiLNS1_9qualifierE0EEEP5ChunkSt4hashIS4_ESt8equal_toIS4_EE5eraseERKS4_; emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::erase(glm::vec<3,int,(glm::qualifier)0> const&)
mov rdi, rbx; this
call _ZNK5Chunk10get_entityEv; Chunk::get_entity(void)
mov rdi, r14
mov esi, eax
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _ZN4entt14basic_registryINS_6entityESaIS1_EE7destroyES1_; entt::basic_registry<entt::entity,std::allocator<entt::entity>>::destroy(entt::entity)
locret_3B0D0:
retn
| void Dimension::remove_chunk(Dimension *this, Chunk *a2)
{
int entity; // ebp
long long v3; // r12
unsigned long long v4; // rax
unsigned int v5; // eax
if ( a2 )
{
entity = Chunk::get_entity(a2);
v3 = entt::basic_registry<entt::entity,std::allocator<entt::entity>>::assure<ChunkComponent>(
(long long)this + 8,
1391944737);
v4 = entt::basic_sparse_set<entt::entity,std::allocator<entt::entity>>::index(v3, entity);
emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::erase(
(char *)this + 712,
*(_QWORD *)(*(_QWORD *)(v3 + 80) + 8 * (v4 >> 10)) + 24 * (unsigned int)(v4 & 0x3FF));
v5 = Chunk::get_entity(a2);
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::destroy((_QWORD *)this + 1, v5);
}
}
| remove_chunk:
TEST RSI,RSI
JZ 0x0013b0d0
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RSI
MOV R15,RDI
LEA R14,[RDI + 0x8]
MOV RDI,RSI
CALL 0x00137198
MOV EBP,EAX
MOV RDI,R14
MOV ESI,0x52f76421
CALL 0x00130ea8
MOV R12,RAX
MOV RDI,RAX
MOV ESI,EBP
CALL 0x001232e6
MOV RCX,qword ptr [R12 + 0x50]
MOV RDX,RAX
SHR RDX,0xa
AND EAX,0x3ff
LEA RSI,[RAX + RAX*0x2]
SHL ESI,0x3
ADD RSI,qword ptr [RCX + RDX*0x8]
ADD R15,0x2c8
MOV RDI,R15
CALL 0x0013b40e
MOV RDI,RBX
CALL 0x00137198
MOV RDI,R14
MOV ESI,EAX
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x0012ab9e
LAB_0013b0d0:
RET
|
/* Dimension::remove_chunk(Chunk*) */
void __thiscall Dimension::remove_chunk(Dimension *this,Chunk *param_1)
{
int4 uVar1;
basic_sparse_set<entt::entity,std::allocator<entt::entity>> *pbVar2;
ulong uVar3;
if (param_1 != (Chunk *)0x0) {
uVar1 = Chunk::get_entity(param_1);
pbVar2 = (basic_sparse_set<entt::entity,std::allocator<entt::entity>> *)
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::assure<ChunkComponent>
((basic_registry<entt::entity,std::allocator<entt::entity>> *)(this + 8),
0x52f76421);
uVar3 = entt::basic_sparse_set<entt::entity,std::allocator<entt::entity>>::index(pbVar2,uVar1);
emhash8::
HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk*,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>
::erase((HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk*,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>
*)(this + 0x2c8),
(vec *)((ulong)(((uint)uVar3 & 0x3ff) * 0x18) +
*(long *)(*(long *)(pbVar2 + 0x50) + (uVar3 >> 10) * 8)));
uVar1 = Chunk::get_entity(param_1);
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::destroy
((basic_registry<entt::entity,std::allocator<entt::entity>> *)(this + 8),uVar1);
return;
}
return;
}
| |
28,432 | nlohmann::json_abi_v3_11_3::detail::exception::name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | monkey531[P]llama/common/./json.hpp | static std::string name(const std::string& ename, int id_)
{
return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::exception::name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r15d
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movb $0x2e, 0xf(%rsp)
movl %edx, %ebp
negl %ebp
cmovsl %edx, %ebp
movl $0x1, %r12d
cmpl $0xa, %ebp
jb 0x44b8f
movl $0x4, %r12d
movl $0xd1b71759, %eax # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x44b86
cmpl $0x3e7, %ecx # imm = 0x3E7
jbe 0x44b8c
cmpl $0x2710, %ecx # imm = 0x2710
jb 0x44b8f
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r12d
cmpl $0x1869f, %ecx # imm = 0x1869F
movl %edx, %ecx
ja 0x44b53
addl $-0x3, %r12d
jmp 0x44b8f
addl $-0x2, %r12d
jmp 0x44b8f
decl %r12d
shrl $0x1f, %r15d
leal (%r12,%r15), %esi
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movl $0x2d, %edx
callq 0x1fc80
addq (%r13), %r15
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x43d16
leaq 0x107227(%rip), %rsi # 0x14bdf1
leaq 0x11c975(%rip), %r9 # 0x161546
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
movq 0x10(%rsp), %rdx
movq %r13, %r8
callq 0x44c31
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x44bfd
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1fae0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x44c29
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1fae0
movq %rbx, %rdi
callq 0x20380
| _ZN8nlohmann16json_abi_v3_11_36detail9exception4nameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15d, edx
mov [rsp+68h+var_58], rsi
mov rbx, rdi
mov [rsp+68h+var_59], 2Eh ; '.'
mov ebp, edx
neg ebp
cmovs ebp, edx
mov r12d, 1
cmp ebp, 0Ah
jb short loc_44B8F
mov r12d, 4
mov eax, 0D1B71759h
mov ecx, ebp
loc_44B53:
cmp ecx, 63h ; 'c'
jbe short loc_44B86
cmp ecx, 3E7h
jbe short loc_44B8C
cmp ecx, 2710h
jb short loc_44B8F
mov edx, ecx
imul rdx, rax
shr rdx, 2Dh
add r12d, 4
cmp ecx, 1869Fh
mov ecx, edx
ja short loc_44B53
add r12d, 0FFFFFFFDh
jmp short loc_44B8F
loc_44B86:
add r12d, 0FFFFFFFEh
jmp short loc_44B8F
loc_44B8C:
dec r12d
loc_44B8F:
shr r15d, 1Fh
lea esi, [r12+r15]
lea r14, [rsp+68h+var_40]
mov [r14-10h], r14
lea r13, [rsp+68h+var_50]
mov rdi, r13
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
add r15, [r13+0]
mov rdi, r15
mov esi, r12d
mov edx, ebp
call _ZNSt8__detail18__to_chars_10_implIjEEvPcjT_; std::__detail::__to_chars_10_impl<uint>(char *,uint,uint)
lea rsi, aJsonException; "[json.exception."
lea r9, a19+8; "] "
lea rcx, [rsp+68h+var_59]
mov rdi, rbx
mov rdx, [rsp+68h+var_58]
mov r8, r13
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA17_KcRKS8_cS8_RA3_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[17],std::string const&,char,std::string,char const(&)[3]>(char const(&)[17],std::string const&,char,std::string,char const(&)[3] &&)
mov rdi, [rsp+68h+var_50]; void *
cmp rdi, r14
jz short loc_44BFD
mov rsi, [rsp+68h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_44BFD:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_10]; void *
cmp rdi, r14
jz short loc_44C29
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_44C29:
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::exception::name(long long a1, long long a2, int a3)
{
unsigned int v3; // ebp
int v4; // r12d
unsigned int v5; // ecx
bool v6; // cc
unsigned int v7; // r15d
char v9; // [rsp+Fh] [rbp-59h] BYREF
long long v10; // [rsp+10h] [rbp-58h]
void *v11[2]; // [rsp+18h] [rbp-50h] BYREF
_QWORD v12[8]; // [rsp+28h] [rbp-40h] BYREF
v10 = a2;
v9 = 46;
v3 = -a3;
if ( a3 > 0 )
v3 = a3;
v4 = 1;
if ( v3 >= 0xA )
{
v4 = 4;
v5 = v3;
while ( 1 )
{
if ( v5 <= 0x63 )
{
v4 -= 2;
goto LABEL_12;
}
if ( v5 <= 0x3E7 )
break;
if ( v5 < 0x2710 )
goto LABEL_12;
v4 += 4;
v6 = v5 <= 0x1869F;
v5 /= 0x2710u;
if ( v6 )
{
v4 -= 3;
goto LABEL_12;
}
}
--v4;
}
LABEL_12:
v7 = (unsigned int)a3 >> 31;
v11[0] = v12;
std::string::_M_construct(v11, v4 + ((unsigned int)a3 >> 31), 45LL);
std::__detail::__to_chars_10_impl<unsigned int>((char *)v11[0] + v7, v4, v3);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[17],std::string const&,char,std::string,char const(&)[3]>(
a1,
(unsigned int)"[json.exception.",
v10,
(unsigned int)&v9,
(unsigned int)v11,
(unsigned int)"] ");
if ( v11[0] != v12 )
operator delete(v11[0], v12[0] + 1LL);
return a1;
}
| name:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15D,EDX
MOV qword ptr [RSP + 0x10],RSI
MOV RBX,RDI
MOV byte ptr [RSP + 0xf],0x2e
MOV EBP,EDX
NEG EBP
CMOVS EBP,EDX
MOV R12D,0x1
CMP EBP,0xa
JC 0x00144b8f
MOV R12D,0x4
MOV EAX,0xd1b71759
MOV ECX,EBP
LAB_00144b53:
CMP ECX,0x63
JBE 0x00144b86
CMP ECX,0x3e7
JBE 0x00144b8c
CMP ECX,0x2710
JC 0x00144b8f
MOV EDX,ECX
IMUL RDX,RAX
SHR RDX,0x2d
ADD R12D,0x4
CMP ECX,0x1869f
MOV ECX,EDX
JA 0x00144b53
ADD R12D,-0x3
JMP 0x00144b8f
LAB_00144b86:
ADD R12D,-0x2
JMP 0x00144b8f
LAB_00144b8c:
DEC R12D
LAB_00144b8f:
SHR R15D,0x1f
LEA ESI,[R12 + R15*0x1]
LEA R14,[RSP + 0x28]
MOV qword ptr [R14 + -0x10],R14
LEA R13,[RSP + 0x18]
MOV RDI,R13
MOV EDX,0x2d
CALL 0x0011fc80
ADD R15,qword ptr [R13]
MOV RDI,R15
MOV ESI,R12D
MOV EDX,EBP
CALL 0x00143d16
LAB_00144bc3:
LEA RSI,[0x24bdf1]
LEA R9,[0x261546]
LEA RCX,[RSP + 0xf]
MOV RDI,RBX
MOV RDX,qword ptr [RSP + 0x10]
MOV R8,R13
CALL 0x00144c31
LAB_00144be6:
MOV RDI,qword ptr [RSP + 0x18]
CMP RDI,R14
JZ 0x00144bfd
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x0011fae0
LAB_00144bfd:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::exception::name(std::__cxx11::string const&, int) */
exception * __thiscall
nlohmann::json_abi_v3_11_3::detail::exception::name(exception *this,string *param_1,int param_2)
{
uint uVar1;
uint uVar2;
ulong uVar3;
uint uVar4;
uint uVar5;
char local_59;
string *local_58;
long *local_50 [2];
long local_40 [2];
local_59 = '.';
uVar4 = -param_2;
if (0 < param_2) {
uVar4 = param_2;
}
uVar5 = 1;
if (9 < uVar4) {
uVar3 = (ulong)uVar4;
uVar1 = 4;
do {
uVar5 = uVar1;
uVar2 = (uint)uVar3;
if (uVar2 < 100) {
uVar5 = uVar5 - 2;
goto LAB_00144b8f;
}
if (uVar2 < 1000) {
uVar5 = uVar5 - 1;
goto LAB_00144b8f;
}
if (uVar2 < 10000) goto LAB_00144b8f;
uVar3 = uVar3 / 10000;
uVar1 = uVar5 + 4;
} while (99999 < uVar2);
uVar5 = uVar5 + 1;
}
LAB_00144b8f:
local_58 = param_1;
local_50[0] = local_40;
std::__cxx11::string::_M_construct((ulong)local_50,(char)uVar5 - (char)(param_2 >> 0x1f));
std::__detail::__to_chars_10_impl<unsigned_int>
((char *)((ulong)((uint)param_2 >> 0x1f) + (long)local_50[0]),uVar5,uVar4);
/* try { // try from 00144bc3 to 00144be5 has its CatchHandler @ 00144c0f */
concat<std::__cxx11::string,char_const(&)[17],std::__cxx11::string_const&,char,std::__cxx11::string,char_const(&)[3]>
((detail *)this,"[json.exception.",local_58,&local_59,(string *)local_50,"] ");
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return this;
}
| |
28,433 | BanExpiryHandler(std::weak_ptr<boost::asio::basic_waitable_timer<std::chrono::_V2::steady_clock, boost::asio::wait_traits<std::chrono::_V2::steady_clock>, boost::asio::any_io_executor>>, int, boost::system::error_code const&) | SylCore-WoTLK/src/server/apps/authserver/Main.cpp | void BanExpiryHandler(std::weak_ptr<boost::asio::steady_timer> banExpiryCheckTimerRef, int32 banExpiryCheckInterval, boost::system::error_code const& error)
{
if (!error)
{
if (std::shared_ptr<boost::asio::steady_timer> banExpiryCheckTimer = banExpiryCheckTimerRef.lock())
{
LoginDatabase.Execute(LoginDatabase.GetPreparedStatement(LOGIN_DEL_EXPIRED_IP_BANS));
LoginDatabase.Execute(LoginDatabase.GetPreparedStatement(LOGIN_UPD_EXPIRED_ACCOUNT_BANS));
banExpiryCheckTimer->expires_at(Acore::Asio::SteadyTimer::GetExpirationTime(banExpiryCheckInterval));
banExpiryCheckTimer->async_wait(std::bind(&BanExpiryHandler, banExpiryCheckTimerRef, banExpiryCheckInterval, std::placeholders::_1));
}
}
} | O3 | cpp | BanExpiryHandler(std::weak_ptr<boost::asio::basic_waitable_timer<std::chrono::_V2::steady_clock, boost::asio::wait_traits<std::chrono::_V2::steady_clock>, boost::asio::any_io_executor>>, int, boost::system::error_code const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebp
movq %rdi, %r14
movq 0x10(%rdx), %rax
testb $0x1, %al
je 0x27654
cmpq $0x1, %rax
jne 0x27787
cmpl $0x0, (%rdx)
jne 0x27787
leaq 0x8(%rsp), %rbx
movq 0x8(%r14), %rcx
movq %rcx, (%rbx)
testq %rcx, %rcx
je 0x27777
movl 0x8(%rcx), %eax
testl %eax, %eax
je 0x2776e
leal 0x1(%rax), %edx
lock
cmpxchgl %edx, 0x8(%rcx)
jne 0x2766c
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x27777
movl 0x8(%rax), %eax
testl %eax, %eax
je 0x27777
movq (%r14), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x2777f
leaq 0x14603a(%rip), %rdi # 0x16d6e8
movl $0x1, %esi
callq 0x5d3b0
leaq 0x146029(%rip), %rdi # 0x16d6e8
movq %rax, %rsi
callq 0x5cb14
leaq 0x14601a(%rip), %rdi # 0x16d6e8
movl $0x2, %esi
callq 0x5d3b0
leaq 0x146009(%rip), %rdi # 0x16d6e8
movq %rax, %rsi
callq 0x5cb14
movq (%rsp), %r12
callq 0x1c2d0
movq %rax, %r15
cmpb $0x1, 0x10(%r12)
movq %r12, %rcx
jne 0x27725
movq (%r12), %rsi
movq 0x58(%rsi), %rdi
addq $0x28, %rsi
leaq 0x18(%r12), %rdx
movq $-0x1, %rcx
callq 0x2ac98
movb $0x0, 0x10(%r12)
movq (%rsp), %rcx
movslq %ebp, %rax
imulq $0x3b9aca00, %rax, %rdx # imm = 0x3B9ACA00
addq %rdx, %r15
movq %r15, 0x8(%r12)
leaq -0x116(%rip), %rdx # 0x27628
movq %rdx, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movq (%r14), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x27798
movq 0x1447a4(%rip), %rdx # 0x16bf08
cmpb $0x0, (%rdx)
je 0x27794
incl 0xc(%rax)
jmp 0x27798
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %rbx, %rdi
callq 0x2b998
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
lock
incl 0xc(%rax)
movq (%rcx), %rdi
leaq 0x8(%rcx), %rsi
addq $0x40, %rcx
leaq 0x10(%rsp), %rdx
callq 0x39e50
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2777f
movq 0x14474a(%rip), %rax # 0x16bf08
cmpb $0x0, (%rax)
je 0x277ce
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x277d8
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x2777f
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x2777f
jmp 0x277fb
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x277fe
callq 0x1cad4
jmp 0x277fe
movq %rax, %r14
movq %rbx, %rdi
callq 0x2b998
movq %r14, %rdi
callq 0x1bba0
| _Z16BanExpiryHandlerSt8weak_ptrIN5boost4asio20basic_waitable_timerINSt6chrono3_V212steady_clockENS1_11wait_traitsIS5_EENS1_15any_io_executorEEEEiRKNS0_6system10error_codeE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 30h
mov ebp, esi
mov r14, rdi
mov rax, [rdx+10h]
test al, 1
jz short loc_27654
cmp rax, 1
jnz loc_27787
cmp dword ptr [rdx], 0
jnz loc_27787
loc_27654:
lea rbx, [rsp+58h+var_50]
mov rcx, [r14+8]
mov [rbx], rcx
test rcx, rcx
jz loc_27777
mov eax, [rcx+8]
loc_2766C:
test eax, eax
jz loc_2776E
lea edx, [rax+1]
lock cmpxchg [rcx+8], edx
jnz short loc_2766C
mov rax, [rsp+58h+var_50]
test rax, rax
jz loc_27777
mov eax, [rax+8]
test eax, eax
jz loc_27777
mov rax, [r14]
mov [rsp+58h+var_58], rax
test rax, rax
jz loc_2777F
lea rdi, LoginDatabase
mov esi, 1
call _ZN18DatabaseWorkerPoolI23LoginDatabaseConnectionE20GetPreparedStatementE23LoginDatabaseStatements; DatabaseWorkerPool<LoginDatabaseConnection>::GetPreparedStatement(LoginDatabaseStatements)
lea rdi, LoginDatabase
mov rsi, rax
call _ZN18DatabaseWorkerPoolI23LoginDatabaseConnectionE7ExecuteEP17PreparedStatementIS0_E; DatabaseWorkerPool<LoginDatabaseConnection>::Execute(PreparedStatement<LoginDatabaseConnection> *)
lea rdi, LoginDatabase
mov esi, 2
call _ZN18DatabaseWorkerPoolI23LoginDatabaseConnectionE20GetPreparedStatementE23LoginDatabaseStatements; DatabaseWorkerPool<LoginDatabaseConnection>::GetPreparedStatement(LoginDatabaseStatements)
lea rdi, LoginDatabase; this
mov rsi, rax
call _ZN18DatabaseWorkerPoolI23LoginDatabaseConnectionE7ExecuteEP17PreparedStatementIS0_E; DatabaseWorkerPool<LoginDatabaseConnection>::Execute(PreparedStatement<LoginDatabaseConnection> *)
mov r12, [rsp+58h+var_58]
call __ZNSt6chrono3_V212steady_clock3nowEv; std::chrono::_V2::steady_clock::now(void)
mov r15, rax
cmp byte ptr [r12+10h], 1
mov rcx, r12
jnz short loc_27725
mov rsi, [r12]
mov rdi, [rsi+58h]
add rsi, 28h ; '('
lea rdx, [r12+18h]
mov rcx, 0FFFFFFFFFFFFFFFFh
call _ZN5boost4asio6detail13epoll_reactor12cancel_timerINS1_18chrono_time_traitsINSt6chrono3_V212steady_clockENS0_11wait_traitsIS7_EEEEEEmRNS1_11timer_queueIT_EERNSD_14per_timer_dataEm; boost::asio::detail::epoll_reactor::cancel_timer<boost::asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>>>(boost::asio::detail::timer_queue<boost::asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>>> &,boost::asio::detail::timer_queue<boost::asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>>>::per_timer_data &,ulong)
mov byte ptr [r12+10h], 0
mov rcx, [rsp+58h+var_58]
loc_27725:
movsxd rax, ebp
imul rdx, rax, 3B9ACA00h
add r15, rdx
mov [r12+8], r15
lea rdx, _Z16BanExpiryHandlerSt8weak_ptrIN5boost4asio20basic_waitable_timerINSt6chrono3_V212steady_clockENS1_11wait_traitsIS5_EENS1_15any_io_executorEEEEiRKNS0_6system10error_codeE; BanExpiryHandler(std::weak_ptr<boost::asio::basic_waitable_timer<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>,boost::asio::any_io_executor>>,int,boost::system::error_code const&)
mov [rsp+58h+var_48], rdx
mov [rsp+58h+var_40], eax
mov rax, [r14]
mov [rsp+58h+var_38], rax
mov rax, [r14+8]
mov [rsp+58h+var_30], rax
test rax, rax
jz short loc_27798
mov rdx, cs:__libc_single_threaded_ptr
cmp byte ptr [rdx], 0
jz short loc_27794
inc dword ptr [rax+0Ch]
jmp short loc_27798
loc_2776E:
mov [rsp+58h+var_50], 0
loc_27777:
mov [rsp+58h+var_58], 0
loc_2777F:
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_27787:
add rsp, 30h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_27794:
lock inc dword ptr [rax+0Ch]
loc_27798:
mov rdi, [rcx]
lea rsi, [rcx+8]
add rcx, 40h ; '@'
lea rdx, [rsp+58h+var_48]
call _ZN5boost4asio6detail22deadline_timer_serviceINS1_18chrono_time_traitsINSt6chrono3_V212steady_clockENS0_11wait_traitsIS6_EEEEE10async_waitISt5_BindIFPFvSt8weak_ptrINS0_20basic_waitable_timerIS6_S8_NS0_15any_io_executorEEEEiRKNS_6system10error_codeEESH_iSt12_PlaceholderILi1EEEESF_EEvRNSA_19implementation_typeERT_RKT0_; boost::asio::detail::deadline_timer_service<boost::asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>>>::async_wait<std::_Bind<void (*)(std::weak_ptr<boost::asio::basic_waitable_timer<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>,boost::asio::any_io_executor>>,int,boost::system::error_code const&) ()(std::weak_ptr<boost::asio::basic_waitable_timer<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>,boost::asio::any_io_executor>>,int,std::_Placeholder<1>)>,boost::asio::any_io_executor>(boost::asio::detail::deadline_timer_service<boost::asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>>>::implementation_type &,std::_Bind<void (*)(std::weak_ptr<boost::asio::basic_waitable_timer<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>,boost::asio::any_io_executor>>,int,boost::system::error_code const&) ()(std::weak_ptr<boost::asio::basic_waitable_timer<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>,boost::asio::any_io_executor>>,int,std::_Placeholder<1>)> &,boost::asio::any_io_executor const&)
mov rdi, [rsp+58h+var_30]
test rdi, rdi
jz short loc_2777F
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_277CE
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_277D8
loc_277CE:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_277D8:
cmp eax, 1
jnz short loc_2777F
mov rax, [rdi]
call qword ptr [rax+18h]
jmp short loc_2777F
jmp short loc_277FB
mov r14, rax
mov rdi, [rsp+arg_20]
test rdi, rdi
jz short loc_277FE
call _Z16BanExpiryHandlerSt8weak_ptrIN5boost4asio20basic_waitable_timerINSt6chrono3_V212steady_clockENS1_11wait_traitsIS5_EENS1_15any_io_executorEEEEiRKNS0_6system10error_codeE_cold_1; BanExpiryHandler(std::weak_ptr<boost::asio::basic_waitable_timer<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>,boost::asio::any_io_executor>>,int,boost::system::error_code const&) [clone]
jmp short loc_277FE
loc_277FB:
mov r14, rax
loc_277FE:
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call __Unwind_Resume
| long long BanExpiryHandler(long long *a1, int a2, long long a3)
{
long long result; // rax
long long v4; // rcx
signed __int32 v5; // eax
signed __int32 v6; // ett
long long PreparedStatement; // rax
long long v8; // rax
int v9; // r8d
int v10; // r9d
long long v11; // r15
_QWORD *v12; // rcx
long long v13; // rax
long long v14; // rdi
signed __int32 v15; // eax
long long v16; // [rsp+0h] [rbp-58h]
long long v17; // [rsp+8h] [rbp-50h] BYREF
long long ( *v18)(int, int, int, int, int, int, int, int, int, int, long long); // [rsp+10h] [rbp-48h] BYREF
int v19; // [rsp+18h] [rbp-40h]
long long v20; // [rsp+20h] [rbp-38h]
long long v21; // [rsp+28h] [rbp-30h]
result = *(_QWORD *)(a3 + 16);
if ( (result & 1) == 0 || result == 1 && !*(_DWORD *)a3 )
{
v4 = a1[1];
v17 = v4;
if ( v4 )
{
v5 = *(_DWORD *)(v4 + 8);
do
{
if ( !v5 )
{
v17 = 0LL;
return std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v17);
}
v6 = v5;
v5 = _InterlockedCompareExchange((volatile signed __int32 *)(v4 + 8), v5 + 1, v5);
}
while ( v6 != v5 );
if ( v17 )
{
if ( *(_DWORD *)(v17 + 8) )
{
v16 = *a1;
if ( *a1 )
{
PreparedStatement = DatabaseWorkerPool<LoginDatabaseConnection>::GetPreparedStatement(&LoginDatabase, 1LL);
DatabaseWorkerPool<LoginDatabaseConnection>::Execute(&LoginDatabase, PreparedStatement);
v8 = DatabaseWorkerPool<LoginDatabaseConnection>::GetPreparedStatement(&LoginDatabase, 2LL);
DatabaseWorkerPool<LoginDatabaseConnection>::Execute(&LoginDatabase, v8);
v11 = std::chrono::_V2::steady_clock::now((std::chrono::_V2::steady_clock *)&LoginDatabase);
v12 = (_QWORD *)v16;
if ( *(_BYTE *)(v16 + 16) == 1 )
{
boost::asio::detail::epoll_reactor::cancel_timer<boost::asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>>>(
*(_QWORD *)(*(_QWORD *)v16 + 88LL),
*(_QWORD *)v16 + 40LL,
v16 + 24,
-1LL);
*(_BYTE *)(v16 + 16) = 0;
v12 = (_QWORD *)v16;
}
*(_QWORD *)(v16 + 8) = 1000000000LL * a2 + v11;
v18 = BanExpiryHandler;
v19 = a2;
v20 = *a1;
v13 = a1[1];
v21 = v13;
if ( v13 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v13 + 12);
else
_InterlockedIncrement((volatile signed __int32 *)(v13 + 12));
}
boost::asio::detail::deadline_timer_service<boost::asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>>>::async_wait<std::_Bind<void (*)(std::weak_ptr<boost::asio::basic_waitable_timer<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>,boost::asio::any_io_executor>>,int,boost::system::error_code const&) ()(std::weak_ptr<boost::asio::basic_waitable_timer<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>,boost::asio::any_io_executor>>,int,std::_Placeholder<1>)>,boost::asio::any_io_executor>(
*v12,
(_DWORD)v12 + 8,
(unsigned int)&v18,
(_DWORD)v12 + 64,
v9,
v10,
v16);
v14 = v21;
if ( v21 )
{
if ( _libc_single_threaded )
{
v15 = *(_DWORD *)(v21 + 12);
*(_DWORD *)(v21 + 12) = v15 - 1;
}
else
{
v15 = _InterlockedExchangeAdd((volatile signed __int32 *)(v21 + 12), 0xFFFFFFFF);
}
if ( v15 == 1 )
(*(void ( **)(long long))(*(_QWORD *)v14 + 24LL))(v14);
}
}
}
}
}
return std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v17);
}
return result;
}
| BanExpiryHandler:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV EBP,ESI
MOV R14,RDI
MOV RAX,qword ptr [RDX + 0x10]
TEST AL,0x1
JZ 0x00127654
CMP RAX,0x1
JNZ 0x00127787
CMP dword ptr [RDX],0x0
JNZ 0x00127787
LAB_00127654:
LEA RBX,[RSP + 0x8]
MOV RCX,qword ptr [R14 + 0x8]
MOV qword ptr [RBX],RCX
TEST RCX,RCX
JZ 0x00127777
MOV EAX,dword ptr [RCX + 0x8]
LAB_0012766c:
TEST EAX,EAX
JZ 0x0012776e
LEA EDX,[RAX + 0x1]
CMPXCHG.LOCK dword ptr [RCX + 0x8],EDX
JNZ 0x0012766c
MOV RAX,qword ptr [RSP + 0x8]
TEST RAX,RAX
JZ 0x00127777
MOV EAX,dword ptr [RAX + 0x8]
TEST EAX,EAX
JZ 0x00127777
MOV RAX,qword ptr [R14]
MOV qword ptr [RSP],RAX
TEST RAX,RAX
JZ 0x0012777f
LAB_001276a7:
LEA RDI,[0x26d6e8]
MOV ESI,0x1
CALL 0x0015d3b0
LEA RDI,[0x26d6e8]
MOV RSI,RAX
CALL 0x0015cb14
LEA RDI,[0x26d6e8]
MOV ESI,0x2
CALL 0x0015d3b0
LEA RDI,[0x26d6e8]
MOV RSI,RAX
CALL 0x0015cb14
MOV R12,qword ptr [RSP]
CALL 0x0011c2d0
MOV R15,RAX
CMP byte ptr [R12 + 0x10],0x1
MOV RCX,R12
JNZ 0x00127725
MOV RSI,qword ptr [R12]
MOV RDI,qword ptr [RSI + 0x58]
ADD RSI,0x28
LEA RDX,[R12 + 0x18]
LAB_0012770f:
MOV RCX,-0x1
CALL 0x0012ac98
MOV byte ptr [R12 + 0x10],0x0
MOV RCX,qword ptr [RSP]
LAB_00127725:
MOVSXD RAX,EBP
IMUL RDX,RAX,0x3b9aca00
ADD R15,RDX
MOV qword ptr [R12 + 0x8],R15
LEA RDX,[0x127628]
MOV qword ptr [RSP + 0x10],RDX
MOV dword ptr [RSP + 0x18],EAX
MOV RAX,qword ptr [R14]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RSP + 0x28],RAX
TEST RAX,RAX
JZ 0x00127798
MOV RDX,qword ptr [0x0026bf08]
CMP byte ptr [RDX],0x0
JZ 0x00127794
INC dword ptr [RAX + 0xc]
JMP 0x00127798
LAB_0012776e:
MOV qword ptr [RSP + 0x8],0x0
LAB_00127777:
MOV qword ptr [RSP],0x0
LAB_0012777f:
MOV RDI,RBX
CALL 0x0012b998
LAB_00127787:
ADD RSP,0x30
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00127794:
INC.LOCK dword ptr [RAX + 0xc]
LAB_00127798:
MOV RDI,qword ptr [RCX]
LEA RSI,[RCX + 0x8]
ADD RCX,0x40
LAB_001277a3:
LEA RDX,[RSP + 0x10]
CALL 0x00139e50
LAB_001277ad:
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x0012777f
MOV RAX,qword ptr [0x0026bf08]
CMP byte ptr [RAX],0x0
JZ 0x001277ce
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001277d8
LAB_001277ce:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001277d8:
CMP EAX,0x1
JNZ 0x0012777f
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
JMP 0x0012777f
|
/* BanExpiryHandler(std::weak_ptr<boost::asio::basic_waitable_timer<std::chrono::_V2::steady_clock,
boost::asio::wait_traits<std::chrono::_V2::steady_clock>, boost::asio::any_io_executor> >, int,
boost::system::error_code const&) */
void BanExpiryHandler(long *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
long *plVar3;
int iVar4;
PreparedStatement *pPVar5;
long lVar6;
bool bVar7;
long local_50;
code *local_48;
int local_40;
long local_38;
long *local_30;
if (((*(ulong *)(param_3 + 4) & 1) == 0) || ((*(ulong *)(param_3 + 4) == 1 && (*param_3 == 0)))) {
local_50 = param_1[1];
if (local_50 != 0) {
iVar4 = *(int *)(local_50 + 8);
do {
if (iVar4 == 0) {
local_50 = 0;
goto LAB_0012777f;
}
LOCK();
iVar2 = *(int *)(local_50 + 8);
bVar7 = iVar4 == iVar2;
if (bVar7) {
*(int *)(local_50 + 8) = iVar4 + 1;
iVar2 = iVar4;
}
iVar4 = iVar2;
UNLOCK();
} while (!bVar7);
if (((local_50 != 0) && (*(int *)(local_50 + 8) != 0)) &&
(plVar3 = (long *)*param_1, plVar3 != (long *)0x0)) {
/* try { // try from 001276a7 to 001276e6 has its CatchHandler @ 001277fb */
pPVar5 = (PreparedStatement *)
DatabaseWorkerPool<LoginDatabaseConnection>::GetPreparedStatement
((DatabaseWorkerPool<LoginDatabaseConnection> *)LoginDatabase,1);
DatabaseWorkerPool<LoginDatabaseConnection>::Execute
((DatabaseWorkerPool<LoginDatabaseConnection> *)LoginDatabase,pPVar5);
pPVar5 = (PreparedStatement *)
DatabaseWorkerPool<LoginDatabaseConnection>::GetPreparedStatement
((DatabaseWorkerPool<LoginDatabaseConnection> *)LoginDatabase,2);
DatabaseWorkerPool<LoginDatabaseConnection>::Execute
((DatabaseWorkerPool<LoginDatabaseConnection> *)LoginDatabase,pPVar5);
lVar6 = std::chrono::_V2::steady_clock::now();
if ((char)plVar3[2] == '\x01') {
/* try { // try from 0012770f to 0012771a has its CatchHandler @ 001277e5 */
boost::asio::detail::epoll_reactor::
cancel_timer<boost::asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>>>
(*(epoll_reactor **)(*plVar3 + 0x58),(timer_queue *)(*plVar3 + 0x28),
(per_timer_data *)(plVar3 + 3),0xffffffffffffffff);
*(int1 *)(plVar3 + 2) = 0;
}
plVar3[1] = lVar6 + (long)param_2 * 1000000000;
local_48 = BanExpiryHandler;
local_38 = *param_1;
local_30 = (long *)param_1[1];
if (local_30 != (long *)0x0) {
if (*PTR___libc_single_threaded_0026bf08 == '\0') {
LOCK();
*(int *)((long)local_30 + 0xc) = *(int *)((long)local_30 + 0xc) + 1;
UNLOCK();
}
else {
*(int *)((long)local_30 + 0xc) = *(int *)((long)local_30 + 0xc) + 1;
}
}
/* try { // try from 001277a3 to 001277ac has its CatchHandler @ 001277e7 */
local_40 = param_2;
boost::asio::detail::
deadline_timer_service<boost::asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>>>
::
async_wait<std::_Bind<void(*(std::weak_ptr<boost::asio::basic_waitable_timer<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>,boost::asio::any_io_executor>>,int,std::_Placeholder<1>))(std::weak_ptr<boost::asio::basic_waitable_timer<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>,boost::asio::any_io_executor>>,int,boost::system::error_code_const&)>,boost::asio::any_io_executor>
((deadline_timer_service<boost::asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock,boost::asio::wait_traits<std::chrono::_V2::steady_clock>>>
*)*plVar3,(implementation_type *)(plVar3 + 1),(_Bind *)&local_48,
(any_io_executor *)(plVar3 + 8));
if (local_30 != (long *)0x0) {
if (*PTR___libc_single_threaded_0026bf08 == '\0') {
LOCK();
piVar1 = (int *)((long)local_30 + 0xc);
iVar4 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)((long)local_30 + 0xc);
*(int *)((long)local_30 + 0xc) = iVar4 + -1;
}
if (iVar4 == 1) {
(**(code **)(*local_30 + 0x18))();
}
}
}
}
LAB_0012777f:
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&local_50);
}
return;
}
| |
28,434 | pow5mult | eloqsql/strings/dtoa.c | static Bigint *pow5mult(Bigint *b, int k, Stack_alloc *alloc)
{
Bigint *b1, *p5, *p51=NULL;
int i;
static int p05[3]= { 5, 25, 125 };
my_bool overflow= FALSE;
if ((i= k & 3))
b= multadd(b, p05[i-1], 0, alloc);
if (!(k>>= 2))
return b;
p5= p5_a;
for (;;)
{
if (k & 1)
{
b1= mult(b, p5, alloc);
Bfree(b, alloc);
b= b1;
}
if (!(k>>= 1))
break;
/* Calculate next power of 5 */
if (overflow)
{
p51= mult(p5, p5, alloc);
Bfree(p5, alloc);
p5= p51;
}
else if (p5 < p5_a + P5A_MAX)
++p5;
else if (p5 == p5_a + P5A_MAX)
{
p5= mult(p5, p5, alloc);
overflow= TRUE;
}
}
if (p51)
Bfree(p51, alloc);
return b;
} | O0 | c | pow5mult:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x3d(%rbp)
movl -0x14(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x821b3
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x31639f(%rip), %rax # 0x398540
movl (%rax,%rcx,4), %esi
movq -0x20(%rbp), %rcx
xorl %edx, %edx
callq 0x82b00
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x821ce
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x822c4
leaq 0x31637b(%rip), %rax # 0x398550
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8220e
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x822d0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x82520
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x82220
jmp 0x822a8
cmpb $0x0, -0x3d(%rbp)
je 0x82252
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x822d0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x82520
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x822a3
leaq 0x3162f7(%rip), %rax # 0x398550
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jae 0x82273
movq -0x30(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
jmp 0x822a1
leaq 0x3162d6(%rip), %rax # 0x398550
addq $0x90, %rax
cmpq %rax, -0x30(%rbp)
jne 0x8229f
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x822d0
movq %rax, -0x30(%rbp)
movb $0x1, -0x3d(%rbp)
jmp 0x822a1
jmp 0x822a3
jmp 0x821d9
cmpq $0x0, -0x38(%rbp)
je 0x822bc
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x82520
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| pow5mult:
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_38], 0
mov [rbp+var_3D], 0
mov eax, [rbp+var_14]
and eax, 3
mov [rbp+var_3C], eax
cmp eax, 0
jz short loc_821B3
mov rdi, [rbp+var_10]
mov eax, [rbp+var_3C]
sub eax, 1
movsxd rcx, eax
lea rax, pow5mult_p05
mov esi, [rax+rcx*4]
mov rcx, [rbp+var_20]
xor edx, edx
call multadd
mov [rbp+var_10], rax
loc_821B3:
mov eax, [rbp+var_14]
sar eax, 2
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_821CE
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_822C4
loc_821CE:
lea rax, p5_a
mov [rbp+var_30], rax
loc_821D9:
mov eax, [rbp+var_14]
and eax, 1
cmp eax, 0
jz short loc_8220E
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_28]
mov [rbp+var_10], rax
loc_8220E:
mov eax, [rbp+var_14]
sar eax, 1
mov [rbp+var_14], eax
cmp eax, 0
jnz short loc_82220
jmp loc_822A8
loc_82220:
cmp [rbp+var_3D], 0
jz short loc_82252
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_38], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_20]
call Bfree
mov rax, [rbp+var_38]
mov [rbp+var_30], rax
jmp short loc_822A3
loc_82252:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnb short loc_82273
mov rax, [rbp+var_30]
add rax, 18h
mov [rbp+var_30], rax
jmp short loc_822A1
loc_82273:
lea rax, p5_a
add rax, 90h
cmp [rbp+var_30], rax
jnz short loc_8229F
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
call mult
mov [rbp+var_30], rax
mov [rbp+var_3D], 1
loc_8229F:
jmp short $+2
loc_822A1:
jmp short $+2
loc_822A3:
jmp loc_821D9
loc_822A8:
cmp [rbp+var_38], 0
jz short loc_822BC
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_20]
call Bfree
loc_822BC:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_822C4:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long pow5mult(long long a1, int a2, long long a3)
{
char v4; // [rsp+3h] [rbp-3Dh]
_BYTE v5[12]; // [rsp+4h] [rbp-3Ch]
_UNKNOWN **v6; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+18h] [rbp-28h]
int v9; // [rsp+2Ch] [rbp-14h]
long long v10; // [rsp+30h] [rbp-10h]
v10 = a1;
*(_DWORD *)&v5[8] = 0;
v4 = 0;
*(_QWORD *)v5 = a2 & 3;
if ( (a2 & 3) != 0 )
v10 = multadd(a1, pow5mult_p05[*(_DWORD *)v5 - 1], 0LL, a3);
v9 = a2 >> 2;
if ( !(a2 >> 2) )
return v10;
v6 = &p5_a;
while ( 1 )
{
if ( (v9 & 1) != 0 )
{
v7 = mult(v10, v6, a3);
Bfree(v10, a3);
v10 = v7;
}
v9 >>= 1;
if ( !v9 )
break;
if ( v4 )
{
*(_QWORD *)&v5[4] = mult(v6, v6, a3);
Bfree(v6, a3);
v6 = *(_UNKNOWN ***)&v5[4];
}
else if ( v6 >= &p5_a + 18 )
{
if ( v6 == &p5_a + 18 )
{
v6 = (_UNKNOWN **)mult(v6, v6, a3);
v4 = 1;
}
}
else
{
v6 += 3;
}
}
if ( *(_QWORD *)&v5[4] )
Bfree(*(_QWORD *)&v5[4], a3);
return v10;
}
| pow5mult:
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 qword ptr [RBP + -0x38],0x0
MOV byte ptr [RBP + -0x3d],0x0
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x3
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JZ 0x001821b3
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x1
MOVSXD RCX,EAX
LEA RAX,[0x498540]
MOV ESI,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RBP + -0x20]
XOR EDX,EDX
CALL 0x00182b00
MOV qword ptr [RBP + -0x10],RAX
LAB_001821b3:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x2
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x001821ce
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001822c4
LAB_001821ce:
LEA RAX,[0x498550]
MOV qword ptr [RBP + -0x30],RAX
LAB_001821d9:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0018220e
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001822d0
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00182520
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x10],RAX
LAB_0018220e:
MOV EAX,dword ptr [RBP + -0x14]
SAR EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JNZ 0x00182220
JMP 0x001822a8
LAB_00182220:
CMP byte ptr [RBP + -0x3d],0x0
JZ 0x00182252
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001822d0
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00182520
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001822a3
LAB_00182252:
LEA RAX,[0x498550]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNC 0x00182273
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x18
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001822a1
LAB_00182273:
LEA RAX,[0x498550]
ADD RAX,0x90
CMP qword ptr [RBP + -0x30],RAX
JNZ 0x0018229f
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001822d0
MOV qword ptr [RBP + -0x30],RAX
MOV byte ptr [RBP + -0x3d],0x1
LAB_0018229f:
JMP 0x001822a1
LAB_001822a1:
JMP 0x001822a3
LAB_001822a3:
JMP 0x001821d9
LAB_001822a8:
CMP qword ptr [RBP + -0x38],0x0
JZ 0x001822bc
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00182520
LAB_001822bc:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_001822c4:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8 pow5mult(int8 param_1,uint param_2,int8 param_3)
{
bool bVar1;
int8 uVar2;
int1 *local_40;
int1 *local_38;
uint local_1c;
int8 local_18;
int8 local_10;
local_40 = (int1 *)0x0;
bVar1 = false;
local_18 = param_1;
if ((param_2 & 3) != 0) {
local_18 = multadd(param_1,*(int4 *)(pow5mult_p05 + (long)(int)((param_2 & 3) - 1) * 4),0,
param_3);
}
local_1c = (int)param_2 >> 2;
if (local_1c == 0) {
local_10 = local_18;
}
else {
local_38 = p5_a;
while( true ) {
if ((local_1c & 1) != 0) {
uVar2 = mult(local_18,local_38,param_3);
Bfree(local_18,param_3);
local_18 = uVar2;
}
local_1c = (int)local_1c >> 1;
if (local_1c == 0) break;
if (bVar1) {
local_40 = (int1 *)mult(local_38,local_38,param_3);
Bfree(local_38,param_3);
local_38 = local_40;
}
else if (local_38 < (int1 *)0x4985e0) {
local_38 = local_38 + 0x18;
}
else if (local_38 == (int1 *)0x4985e0) {
local_38 = (int1 *)mult(0x4985e0,0x4985e0,param_3);
bVar1 = true;
}
}
if (local_40 != (int1 *)0x0) {
Bfree(local_40,param_3);
}
local_10 = local_18;
}
return local_10;
}
| |
28,435 | my_hash_sort_utf8mb4_nopad | eloqsql/strings/ctype-utf8.c | static void
my_hash_sort_utf8mb4_nopad(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
int res;
const uchar *e= s + slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((res= my_mb_wc_utf8mb4(cs, &wc, (uchar*) s, (uchar*) e)) > 0)
{
my_tosort_unicode(uni_plane, &wc, cs->state);
MY_HASH_ADD_16(m1, m2, (uint) (wc & 0xFFFF));
if (wc > 0xFFFF)
{
/*
Put the highest byte only if it is non-zero,
to make hash functions for utf8mb3 and utf8mb4
compatible for BMP characters.
This is useful to keep order of records in
test results, e.g. for "SHOW GRANTS".
*/
MY_HASH_ADD(m1, m2, (uint) ((wc >> 16) & 0xFF));
}
s+= res;
}
*nr1= m1;
*nr2= m2;
} | O3 | c | my_hash_sort_utf8mb4_nopad:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r12
addq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq 0x78(%rdi), %r14
movq %rcx, -0x48(%rbp)
movq (%rcx), %r13
movq %r8, -0x50(%rbp)
movq (%r8), %rbx
leaq -0x38(%rbp), %rdi
movq %r15, %rdx
callq 0x5260a
testl %eax, %eax
jle 0x5310e
movq -0x30(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, -0x3c(%rbp)
movq %r14, -0x58(%rbp)
movq (%r14), %rcx
movq %rcx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movl $0xfffd, %esi # imm = 0xFFFD
cmpq -0x30(%rbp), %rcx
ja 0x53065
movq -0x58(%rbp), %rdx
movq 0x8(%rdx), %rsi
movq %rcx, %rdx
shrq $0x8, %rdx
movq (%rsi,%rdx,8), %rsi
testq %rsi, %rsi
je 0x53071
xorl %edx, %edx
cmpw $0x0, -0x3c(%rbp)
setns %dl
movzbl %cl, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rsi,%rcx,4), %rcx
movl 0x4(%rcx,%rdx,4), %esi
movq %rsi, -0x38(%rbp)
movl %esi, %edx
shrl $0x8, %edx
movq %rsi, %rcx
movl %r13d, %esi
andl $0x3f, %esi
addq %rbx, %rsi
movq %rcx, %rdi
movl $0xff, %r8d
andq %r8, %rdi
imulq %rsi, %rdi
movq %r13, %rsi
shlq $0x8, %rsi
addq %rdi, %rsi
xorq %r13, %rsi
movl %esi, %edi
andl $0x3f, %edi
addq %rbx, %rdi
addq $0x3, %rdi
andq %r8, %rdx
imulq %rdi, %rdx
movq %rsi, %r13
shlq $0x8, %r13
addq %rdx, %r13
xorq %rsi, %r13
leaq 0x6(%rbx), %r14
cmpq $0x10000, %rcx # imm = 0x10000
jb 0x530ed
movl %r13d, %edx
andl $0x3f, %edx
addq %r14, %rdx
shrl $0x10, %ecx
movzbl %cl, %ecx
imulq %rdx, %rcx
movq %r13, %rdx
shlq $0x8, %rdx
addq %rcx, %rdx
xorq %rdx, %r13
addq $0x9, %rbx
movq %rbx, %r14
jmp 0x530f0
movq %r14, %rbx
movl %eax, %eax
addq %rax, %r12
leaq -0x38(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x5260a
testl %eax, %eax
jg 0x53025
jmp 0x53111
movq %rbx, %r14
movq -0x48(%rbp), %rax
movq %r13, (%rax)
movq -0x50(%rbp), %rax
movq %r14, (%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_hash_sort_utf8mb4_nopad:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, rdx
mov r12, rsi
add r15, rsi
mov [rbp+var_30], rdi
mov r14, [rdi+78h]
mov [rbp+var_48], rcx
mov r13, [rcx]
mov [rbp+var_50], r8
mov rbx, [r8]
lea rdi, [rbp+var_38]
mov rdx, r15
call my_mb_wc_utf8mb4_quick_0
test eax, eax
jle loc_5310E
mov rcx, [rbp+var_30]
mov ecx, [rcx+0Ch]
mov [rbp+var_3C], ecx
mov [rbp+var_58], r14
mov rcx, [r14]
mov [rbp+var_30], rcx
loc_53025:
mov rcx, [rbp+var_38]
mov esi, 0FFFDh
cmp rcx, [rbp+var_30]
ja short loc_53065
mov rdx, [rbp+var_58]
mov rsi, [rdx+8]
mov rdx, rcx
shr rdx, 8
mov rsi, [rsi+rdx*8]
test rsi, rsi
jz short loc_53071
xor edx, edx
cmp word ptr [rbp+var_3C], 0
setns dl
movzx ecx, cl
lea rcx, [rcx+rcx*2]
lea rcx, [rsi+rcx*4]
mov esi, [rcx+rdx*4+4]
loc_53065:
mov [rbp+var_38], rsi
mov edx, esi
shr edx, 8
mov rcx, rsi
loc_53071:
mov esi, r13d
and esi, 3Fh
add rsi, rbx
mov rdi, rcx
mov r8d, 0FFh
and rdi, r8
imul rdi, rsi
mov rsi, r13
shl rsi, 8
add rsi, rdi
xor rsi, r13
mov edi, esi
and edi, 3Fh
add rdi, rbx
add rdi, 3
and rdx, r8
imul rdx, rdi
mov r13, rsi
shl r13, 8
add r13, rdx
xor r13, rsi
lea r14, [rbx+6]
cmp rcx, 10000h
jb short loc_530ED
mov edx, r13d
and edx, 3Fh
add rdx, r14
shr ecx, 10h
movzx ecx, cl
imul rcx, rdx
mov rdx, r13
shl rdx, 8
add rdx, rcx
xor r13, rdx
add rbx, 9
mov r14, rbx
jmp short loc_530F0
loc_530ED:
mov rbx, r14
loc_530F0:
mov eax, eax
add r12, rax
lea rdi, [rbp+var_38]
mov rsi, r12
mov rdx, r15
call my_mb_wc_utf8mb4_quick_0
test eax, eax
jg loc_53025
jmp short loc_53111
loc_5310E:
mov r14, rbx
loc_53111:
mov rax, [rbp+var_48]
mov [rax], r13
mov rax, [rbp+var_50]
mov [rax], r14
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _QWORD * my_hash_sort_utf8mb4_nopad(
unsigned long long a1,
unsigned __int8 *a2,
long long a3,
long long *a4,
_QWORD *a5)
{
unsigned __int8 *v5; // r12
unsigned long long v6; // r15
unsigned long long *v7; // r14
long long v8; // r13
long long v9; // rbx
int v10; // eax
unsigned long long v11; // rcx
long long v12; // rsi
unsigned long long v13; // rdx
long long v14; // rsi
long long v15; // r14
_QWORD *result; // rax
unsigned long long *v17; // [rsp+8h] [rbp-58h]
int v20; // [rsp+24h] [rbp-3Ch]
unsigned long long v21; // [rsp+28h] [rbp-38h] BYREF
unsigned long long v22; // [rsp+30h] [rbp-30h]
v5 = a2;
v6 = (unsigned long long)&a2[a3];
v22 = a1;
v7 = *(unsigned long long **)(a1 + 120);
v8 = *a4;
v9 = *a5;
v10 = my_mb_wc_utf8mb4_quick_0(&v21, a2, (unsigned long long)&a2[a3]);
if ( v10 > 0 )
{
v20 = *(_DWORD *)(v22 + 12);
v17 = v7;
v22 = *v7;
while ( 1 )
{
v11 = v21;
v12 = 65533LL;
if ( v21 > v22 )
goto LABEL_6;
v13 = v21 >> 8;
v14 = *(_QWORD *)(v17[1] + 8 * (v21 >> 8));
if ( v14 )
break;
LABEL_7:
v8 ^= ((v9 + (v8 & 0x3F)) * (unsigned __int8)v11 + (v8 << 8)) ^ ((v9
+ (((unsigned __int8)v8 ^ (unsigned __int8)((v9 + (v8 & 0x3F)) * v11)) & 0x3F)
+ 3)
* (unsigned __int8)v13
+ ((v8 ^ ((v9 + (v8 & 0x3F)) * (unsigned __int8)v11
+ (v8 << 8))) << 8));
v15 = v9 + 6;
if ( v11 < 0x10000 )
{
v9 += 6LL;
}
else
{
v8 ^= (v15 + (v8 & 0x3F)) * BYTE2(v11) + (v8 << 8);
v9 += 9LL;
v15 = v9;
}
v5 += (unsigned int)v10;
v10 = my_mb_wc_utf8mb4_quick_0(&v21, v5, v6);
if ( v10 <= 0 )
goto LABEL_13;
}
v12 = *(unsigned int *)(v14 + 12LL * (unsigned __int8)v21 + 4LL * ((v20 & 0x8000u) == 0) + 4);
LABEL_6:
v21 = v12;
LODWORD(v13) = (unsigned int)v12 >> 8;
v11 = v12;
goto LABEL_7;
}
v15 = v9;
LABEL_13:
*a4 = v8;
result = a5;
*a5 = v15;
return result;
}
| my_hash_sort_utf8mb4_nopad:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,RDX
MOV R12,RSI
ADD R15,RSI
MOV qword ptr [RBP + -0x30],RDI
MOV R14,qword ptr [RDI + 0x78]
MOV qword ptr [RBP + -0x48],RCX
MOV R13,qword ptr [RCX]
MOV qword ptr [RBP + -0x50],R8
MOV RBX,qword ptr [R8]
LEA RDI,[RBP + -0x38]
MOV RDX,R15
CALL 0x0015260a
TEST EAX,EAX
JLE 0x0015310e
MOV RCX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RCX + 0xc]
MOV dword ptr [RBP + -0x3c],ECX
MOV qword ptr [RBP + -0x58],R14
MOV RCX,qword ptr [R14]
MOV qword ptr [RBP + -0x30],RCX
LAB_00153025:
MOV RCX,qword ptr [RBP + -0x38]
MOV ESI,0xfffd
CMP RCX,qword ptr [RBP + -0x30]
JA 0x00153065
MOV RDX,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RDX + 0x8]
MOV RDX,RCX
SHR RDX,0x8
MOV RSI,qword ptr [RSI + RDX*0x8]
TEST RSI,RSI
JZ 0x00153071
XOR EDX,EDX
CMP word ptr [RBP + -0x3c],0x0
SETNS DL
MOVZX ECX,CL
LEA RCX,[RCX + RCX*0x2]
LEA RCX,[RSI + RCX*0x4]
MOV ESI,dword ptr [RCX + RDX*0x4 + 0x4]
LAB_00153065:
MOV qword ptr [RBP + -0x38],RSI
MOV EDX,ESI
SHR EDX,0x8
MOV RCX,RSI
LAB_00153071:
MOV ESI,R13D
AND ESI,0x3f
ADD RSI,RBX
MOV RDI,RCX
MOV R8D,0xff
AND RDI,R8
IMUL RDI,RSI
MOV RSI,R13
SHL RSI,0x8
ADD RSI,RDI
XOR RSI,R13
MOV EDI,ESI
AND EDI,0x3f
ADD RDI,RBX
ADD RDI,0x3
AND RDX,R8
IMUL RDX,RDI
MOV R13,RSI
SHL R13,0x8
ADD R13,RDX
XOR R13,RSI
LEA R14,[RBX + 0x6]
CMP RCX,0x10000
JC 0x001530ed
MOV EDX,R13D
AND EDX,0x3f
ADD RDX,R14
SHR ECX,0x10
MOVZX ECX,CL
IMUL RCX,RDX
MOV RDX,R13
SHL RDX,0x8
ADD RDX,RCX
XOR R13,RDX
ADD RBX,0x9
MOV R14,RBX
JMP 0x001530f0
LAB_001530ed:
MOV RBX,R14
LAB_001530f0:
MOV EAX,EAX
ADD R12,RAX
LEA RDI,[RBP + -0x38]
MOV RSI,R12
MOV RDX,R15
CALL 0x0015260a
TEST EAX,EAX
JG 0x00153025
JMP 0x00153111
LAB_0015310e:
MOV R14,RBX
LAB_00153111:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX],R13
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX],R14
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void my_hash_sort_utf8mb4_nopad(long param_1,long param_2,long param_3,ulong *param_4,long *param_5)
{
int4 uVar1;
ulong *puVar2;
uint uVar3;
ulong uVar4;
long lVar5;
long lVar6;
ulong uVar7;
ulong uVar8;
short local_44;
ulong local_40;
ulong local_38;
param_3 = param_3 + param_2;
puVar2 = *(ulong **)(param_1 + 0x78);
uVar8 = *param_4;
lVar6 = *param_5;
local_38 = param_1;
uVar3 = my_mb_wc_utf8mb4_quick(&local_40,param_2,param_3);
if (0 < (int)uVar3) {
uVar1 = *(int4 *)(local_38 + 0xc);
local_38 = *puVar2;
lVar5 = lVar6;
do {
uVar7 = 0xfffd;
if (local_38 < local_40) {
LAB_00153065:
uVar4 = uVar7 >> 8;
local_40 = uVar7;
}
else {
uVar4 = local_40 >> 8;
lVar6 = *(long *)(puVar2[1] + uVar4 * 8);
if (lVar6 != 0) {
local_44 = (short)uVar1;
uVar7 = (ulong)*(uint *)(lVar6 + (local_40 & 0xff) * 0xc + 4 + (ulong)(-1 < local_44) * 4)
;
goto LAB_00153065;
}
}
uVar8 = uVar8 * 0x100 + (local_40 & 0xff) * ((ulong)((uint)uVar8 & 0x3f) + lVar5) ^ uVar8;
uVar8 = uVar8 * 0x100 + (uVar4 & 0xff) * ((ulong)((uint)uVar8 & 0x3f) + lVar5 + 3) ^ uVar8;
lVar6 = lVar5 + 6;
if (0xffff < local_40) {
uVar8 = uVar8 ^ uVar8 * 0x100 +
(local_40 >> 0x10 & 0xff) * ((ulong)((uint)uVar8 & 0x3f) + lVar6);
lVar6 = lVar5 + 9;
}
param_2 = param_2 + (ulong)uVar3;
uVar3 = my_mb_wc_utf8mb4_quick(&local_40,param_2,param_3);
lVar5 = lVar6;
} while (0 < (int)uVar3);
}
*param_4 = uVar8;
*param_5 = lVar6;
return;
}
| |
28,436 | PFS_buffer_scalable_container<PFS_rwlock, 1024, 1024, PFS_buffer_default_array<PFS_rwlock>, PFS_buffer_default_allocator<PFS_rwlock>>::init(long) | eloqsql/storage/perfschema/pfs_buffer_container.h | int init(long max_size)
{
int i;
m_initialized= true;
m_full= true;
m_max= PFS_PAGE_COUNT * PFS_PAGE_SIZE;
m_max_page_count= PFS_PAGE_COUNT;
m_last_page_size= PFS_PAGE_SIZE;
m_lost= 0;
m_monotonic.m_u32= 0;
m_max_page_index.m_u32= 0;
for (i=0 ; i < PFS_PAGE_COUNT; i++)
{
m_pages[i]= NULL;
}
if (max_size == 0)
{
/* No allocation. */
m_max_page_count= 0;
}
else if (max_size > 0)
{
if (max_size % PFS_PAGE_SIZE == 0)
{
m_max_page_count= max_size / PFS_PAGE_SIZE;
}
else
{
m_max_page_count= max_size / PFS_PAGE_SIZE + 1;
m_last_page_size= max_size % PFS_PAGE_SIZE;
}
/* Bounded allocation. */
m_full= false;
if (m_max_page_count > PFS_PAGE_COUNT)
{
m_max_page_count= PFS_PAGE_COUNT;
m_last_page_size= PFS_PAGE_SIZE;
}
}
else
{
/* max_size = -1 means unbounded allocation */
m_full= false;
}
assert(m_max_page_count <= PFS_PAGE_COUNT);
assert(0 < m_last_page_size);
assert(m_last_page_size <= PFS_PAGE_SIZE);
pthread_mutex_init(& m_critical_section, NULL);
return 0;
} | O0 | c | PFS_buffer_scalable_container<PFS_rwlock, 1024, 1024, PFS_buffer_default_array<PFS_rwlock>, PFS_buffer_default_allocator<PFS_rwlock>>::init(long):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, 0x8(%rax)
movb $0x1, 0x9(%rax)
movq $0x100000, 0x10(%rax) # imm = 0x100000
movq $0x400, 0x98(%rax) # imm = 0x400
movq $0x400, 0xa0(%rax) # imm = 0x400
movq $0x0, (%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x58(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x400, -0x14(%rbp) # imm = 0x400
jge 0x53f52
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, 0xa8(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x53f2a
cmpq $0x0, -0x10(%rbp)
jne 0x53f6d
movq -0x20(%rbp), %rax
movq $0x0, 0x98(%rax)
jmp 0x5401e
cmpq $0x0, -0x10(%rbp)
jle 0x54014
movq -0x10(%rbp), %rax
movl $0x400, %ecx # imm = 0x400
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x53faa
movq -0x10(%rbp), %rax
movl $0x400, %ecx # imm = 0x400
cqto
idivq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x98(%rax)
jmp 0x53fe3
movq -0x10(%rbp), %rax
movl $0x400, %ecx # imm = 0x400
cqto
idivq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movl $0x400, %ecx # imm = 0x400
cqto
idivq %rcx
movq -0x20(%rbp), %rax
movq %rdx, 0xa0(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x9(%rax)
cmpq $0x400, 0x98(%rax) # imm = 0x400
jbe 0x54012
movq -0x20(%rbp), %rax
movq $0x400, 0x98(%rax) # imm = 0x400
movq $0x400, 0xa0(%rax) # imm = 0x400
jmp 0x5401c
movq -0x20(%rbp), %rax
movb $0x0, 0x9(%rax)
jmp 0x5401e
movq -0x20(%rbp), %rdi
addq $0x20b0, %rdi # imm = 0x20B0
xorl %eax, %eax
movl %eax, %esi
callq 0x264f0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZN29PFS_buffer_scalable_containerI17PFS_prepared_stmtLi1024ELi1024E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE4initEl:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov byte ptr [rax+8], 1
mov byte ptr [rax+9], 1
mov qword ptr [rax+10h], offset unk_100000
mov qword ptr [rax+98h], 400h
mov qword ptr [rax+0A0h], 400h
mov qword ptr [rax], 0
mov dword ptr [rax+18h], 0
mov dword ptr [rax+58h], 0
mov [rbp+var_14], 0
loc_53F2A:
cmp [rbp+var_14], 400h
jge short loc_53F52
mov rax, [rbp+var_20]
movsxd rcx, [rbp+var_14]
mov qword ptr [rax+rcx*8+0A8h], 0
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_53F2A
loc_53F52:
cmp [rbp+var_10], 0
jnz short loc_53F6D
mov rax, [rbp+var_20]
mov qword ptr [rax+98h], 0
jmp loc_5401E
loc_53F6D:
cmp [rbp+var_10], 0
jle loc_54014
mov rax, [rbp+var_10]
mov ecx, 400h
cqo
idiv rcx
cmp rdx, 0
jnz short loc_53FAA
mov rax, [rbp+var_10]
mov ecx, 400h
cqo
idiv rcx
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax+98h], rcx
jmp short loc_53FE3
loc_53FAA:
mov rax, [rbp+var_10]
mov ecx, 400h
cqo
idiv rcx
mov rcx, rax
mov rax, [rbp+var_20]
add rcx, 1
mov [rax+98h], rcx
mov rax, [rbp+var_10]
mov ecx, 400h
cqo
idiv rcx
mov rax, [rbp+var_20]
mov [rax+0A0h], rdx
loc_53FE3:
mov rax, [rbp+var_20]
mov byte ptr [rax+9], 0
cmp qword ptr [rax+98h], 400h
jbe short loc_54012
mov rax, [rbp+var_20]
mov qword ptr [rax+98h], 400h
mov qword ptr [rax+0A0h], 400h
loc_54012:
jmp short loc_5401C
loc_54014:
mov rax, [rbp+var_20]
mov byte ptr [rax+9], 0
loc_5401C:
jmp short $+2
loc_5401E:
mov rdi, [rbp+var_20]
add rdi, 20B0h
xor eax, eax
mov esi, eax
call _pthread_mutex_init
xor eax, eax
add rsp, 20h
pop rbp
retn
| long long PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>::init(
long long a1,
long long a2)
{
int i; // [rsp+Ch] [rbp-14h]
*(_BYTE *)(a1 + 8) = 1;
*(_BYTE *)(a1 + 9) = 1;
*(_QWORD *)(a1 + 16) = &unk_100000;
*(_QWORD *)(a1 + 152) = 1024LL;
*(_QWORD *)(a1 + 160) = 1024LL;
*(_QWORD *)a1 = 0LL;
*(_DWORD *)(a1 + 24) = 0;
*(_DWORD *)(a1 + 88) = 0;
for ( i = 0; i < 1024; ++i )
*(_QWORD *)(a1 + 8LL * i + 168) = 0LL;
if ( a2 )
{
if ( a2 <= 0 )
{
*(_BYTE *)(a1 + 9) = 0;
}
else
{
if ( a2 % 1024 )
{
*(_QWORD *)(a1 + 152) = a2 / 1024 + 1;
*(_QWORD *)(a1 + 160) = a2 % 1024;
}
else
{
*(_QWORD *)(a1 + 152) = a2 / 1024;
}
*(_BYTE *)(a1 + 9) = 0;
if ( *(_QWORD *)(a1 + 152) > 0x400uLL )
{
*(_QWORD *)(a1 + 152) = 1024LL;
*(_QWORD *)(a1 + 160) = 1024LL;
}
}
}
else
{
*(_QWORD *)(a1 + 152) = 0LL;
}
pthread_mutex_init(a1 + 8368, 0LL);
return 0LL;
}
| init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV byte ptr [RAX + 0x8],0x1
MOV byte ptr [RAX + 0x9],0x1
MOV qword ptr [RAX + 0x10],0x100000
MOV qword ptr [RAX + 0x98],0x400
MOV qword ptr [RAX + 0xa0],0x400
MOV qword ptr [RAX],0x0
MOV dword ptr [RAX + 0x18],0x0
MOV dword ptr [RAX + 0x58],0x0
MOV dword ptr [RBP + -0x14],0x0
LAB_00153f2a:
CMP dword ptr [RBP + -0x14],0x400
JGE 0x00153f52
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,dword ptr [RBP + -0x14]
MOV qword ptr [RAX + RCX*0x8 + 0xa8],0x0
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00153f2a
LAB_00153f52:
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x00153f6d
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],0x0
JMP 0x0015401e
LAB_00153f6d:
CMP qword ptr [RBP + -0x10],0x0
JLE 0x00154014
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x400
CQO
IDIV RCX
CMP RDX,0x0
JNZ 0x00153faa
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x400
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],RCX
JMP 0x00153fe3
LAB_00153faa:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x400
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RCX,0x1
MOV qword ptr [RAX + 0x98],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,0x400
CQO
IDIV RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0xa0],RDX
LAB_00153fe3:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x9],0x0
CMP qword ptr [RAX + 0x98],0x400
JBE 0x00154012
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],0x400
MOV qword ptr [RAX + 0xa0],0x400
LAB_00154012:
JMP 0x0015401c
LAB_00154014:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x9],0x0
LAB_0015401c:
JMP 0x0015401e
LAB_0015401e:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x20b0
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001264f0
XOR EAX,EAX
ADD RSP,0x20
POP RBP
RET
|
/* PFS_buffer_scalable_container<PFS_prepared_stmt, 1024, 1024,
PFS_buffer_default_array<PFS_prepared_stmt>, PFS_buffer_default_allocator<PFS_prepared_stmt>
>::init(long) */
int8 __thiscall
PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
::init(PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
*this,long param_1)
{
int local_1c;
this[8] = (PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
)0x1;
this[9] = (PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
)0x1;
*(int8 *)(this + 0x10) = 0x100000;
*(int8 *)(this + 0x98) = 0x400;
*(int8 *)(this + 0xa0) = 0x400;
*(int8 *)this = 0;
*(int4 *)(this + 0x18) = 0;
*(int4 *)(this + 0x58) = 0;
for (local_1c = 0; local_1c < 0x400; local_1c = local_1c + 1) {
*(int8 *)(this + (long)local_1c * 8 + 0xa8) = 0;
}
if (param_1 == 0) {
*(int8 *)(this + 0x98) = 0;
}
else if (param_1 < 1) {
this[9] = (PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
)0x0;
}
else {
if (param_1 % 0x400 == 0) {
*(long *)(this + 0x98) = param_1 / 0x400;
}
else {
*(long *)(this + 0x98) = param_1 / 0x400 + 1;
*(long *)(this + 0xa0) = param_1 % 0x400;
}
this[9] = (PFS_buffer_scalable_container<PFS_prepared_stmt,1024,1024,PFS_buffer_default_array<PFS_prepared_stmt>,PFS_buffer_default_allocator<PFS_prepared_stmt>>
)0x0;
if (0x400 < *(ulong *)(this + 0x98)) {
*(int8 *)(this + 0x98) = 0x400;
*(int8 *)(this + 0xa0) = 0x400;
}
}
pthread_mutex_init((pthread_mutex_t *)(this + 0x20b0),(pthread_mutexattr_t *)0x0);
return 0;
}
| |
28,437 | minja::CallExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!object) throw std::runtime_error("CallExpr.object is null");
auto obj = object->evaluate(context);
if (!obj.is_callable()) {
throw std::runtime_error("Object is not callable: " + obj.dump(2));
}
auto vargs = args.evaluate(context);
return obj.call(context, vargs);
} | O3 | cpp | minja::CallExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r15
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x5593c
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x3cabe
cmpq $0x0, 0x30(%r12)
je 0x5596e
addq $0x30, %r15
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x52ee0
leaq 0x50(%rsp), %rsi
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x54260
leaq 0x18(%rsp), %rdi
callq 0x555a8
movq %rsp, %rdi
callq 0x4e342
leaq 0x90(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3ce3c
movq %r14, %rdi
callq 0x49a2a
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x558d5
callq 0x2ef66
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x558e4
callq 0x2ef66
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x558f3
callq 0x2ef66
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x55929
movq 0x86694(%rip), %rax # 0xdbf98
cmpb $0x0, (%rax)
je 0x55914
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x5591e
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x55929
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x18350
movq %rax, %rbx
leaq 0x558f7(%rip), %rsi # 0xab247
movq %rax, %rdi
callq 0x18260
movq 0x86691(%rip), %rsi # 0xdbff0
movq 0x8660a(%rip), %rdx # 0xdbf70
movq %rbx, %rdi
callq 0x18b30
movl $0x10, %edi
callq 0x18350
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x3d172
leaq 0x55b4a(%rip), %rsi # 0xab4e2
movq %rsp, %rdi
leaq 0x30(%rsp), %rdx
callq 0x2434d
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x86634(%rip), %rsi # 0xdbff0
movq 0x865ad(%rip), %rdx # 0xdbf70
movq %rbx, %rdi
callq 0x18b30
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x559e9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55a04
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x186a0
testb %bpl, %bpl
jne 0x55a2e
jmp 0x55a5f
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55a2e
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x55a2e
movq %rax, %r14
movq %rbx, %rdi
callq 0x184f0
jmp 0x55a5f
movq %rax, %r14
movq %rbx, %rdi
callq 0x184f0
jmp 0x55a69
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x555a8
movq %rsp, %rdi
callq 0x4e342
jmp 0x55a5f
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x3cdb0
movq %r14, %rdi
callq 0x18ba0
nop
| _ZNK5minja8CallExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 0A0h
mov r15, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz loc_5593C
mov r14, rdx
mov rbx, rdi
lea r12, [rsp+0C8h+var_78]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
cmp qword ptr [r12+30h], 0
jz loc_5596E
add r15, 30h ; '0'
mov rdi, rsp
mov rsi, r15
mov rdx, r14
call _ZNK5minja19ArgumentsExpression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)
lea rsi, [rsp+0C8h+var_78]
mov rcx, rsp
mov rdi, rbx
mov rdx, r14
call _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE; minja::Value::call(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
lea rdi, [rsp+0C8h+var_B0]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
mov rdi, rsp
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
lea r14, [rsp+0C8h+var_38]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_558D5
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_558D5:
mov rdi, [rsp+0C8h+var_50]
test rdi, rdi
jz short loc_558E4
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_558E4:
mov rdi, [rsp+0C8h+var_60]
test rdi, rdi
jz short loc_558F3
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_558F3:
mov rdi, [rsp+0C8h+var_70]
test rdi, rdi
jz short loc_55929
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_55914
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_5591E
loc_55914:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_5591E:
cmp eax, 1
jnz short loc_55929
mov rax, [rdi]
call qword ptr [rax+18h]
loc_55929:
mov rax, rbx
add rsp, 0A0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_5593C:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aMethodcallexpr+6; char *
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_5596E:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+0C8h+var_98]
lea rsi, [rsp+0C8h+var_78]
mov edx, 2
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aObjectIsNotCal; "Object is not callable: "
mov rdi, rsp
lea rdx, [rsp+0C8h+var_98]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+0C8h+var_B8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_559E9
mov rsi, [rsp+0C8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_559E9:
lea rax, [rsp+0C8h+var_88]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_55A04
mov rsi, [rsp+0C8h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_55A04:
test bpl, bpl
jnz short loc_55A2E
jmp short loc_55A5F
mov r14, rax
lea rax, [rsp+0C8h+var_88]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_55A2E
mov rsi, [rsp+0C8h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_55A2E
mov r14, rax
loc_55A2E:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_55A5F
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_55A69
mov r14, rax
lea rdi, [rsp+0C8h+var_B0]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
mov rdi, rsp
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
jmp short loc_55A5F
mov r14, rax
loc_55A5F:
lea rdi, [rsp+0C8h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_55A69:
mov rdi, r14
call __Unwind_Resume
| long long minja::CallExpr::do_evaluate(long long a1, long long a2, long long a3)
{
void (***v4)(void); // rsi
long long v7; // rdi
signed __int32 v8; // eax
std::runtime_error *exception; // rbx
void *v11; // rbx
__int128 v12; // [rsp+0h] [rbp-C8h] BYREF
char *v13; // [rsp+18h] [rbp-B0h] BYREF
_BYTE v14[16]; // [rsp+30h] [rbp-98h] BYREF
_BYTE v15[8]; // [rsp+50h] [rbp-78h] BYREF
long long v16; // [rsp+58h] [rbp-70h]
volatile signed __int32 *v17; // [rsp+68h] [rbp-60h]
volatile signed __int32 *v18; // [rsp+78h] [rbp-50h]
long long v19; // [rsp+80h] [rbp-48h]
volatile signed __int32 *v20; // [rsp+88h] [rbp-40h]
void **v21[7]; // [rsp+90h] [rbp-38h] BYREF
v4 = *(void (****)(void))(a2 + 32);
if ( !v4 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "CallExpr.object is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v15, v4);
if ( !v19 )
{
v11 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v14, (long long)v15, 2u, 0);
std::operator+<char>((long long)&v12, (long long)"Object is not callable: ", (long long)v14);
std::runtime_error::runtime_error(v11, &v12);
__cxa_throw(
v11,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::ArgumentsExpression::evaluate(&v12, (_QWORD *)(a2 + 48), a3);
minja::Value::call(a1, (long long)v15);
std::vector<std::pair<std::string,minja::Value>>::~vector(&v13);
std::vector<minja::Value>::~vector(&v12);
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 *)v21);
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(v21);
if ( v20 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v20);
if ( v18 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v18);
if ( v17 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v17);
v7 = v16;
if ( v16 )
{
if ( _libc_single_threaded )
{
v8 = *(_DWORD *)(v16 + 12);
*(_DWORD *)(v16 + 12) = v8 - 1;
}
else
{
v8 = _InterlockedExchangeAdd((volatile signed __int32 *)(v16 + 12), 0xFFFFFFFF);
}
if ( v8 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v7 + 24LL))(v7, 0LL);
}
return a1;
}
| do_evaluate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xa0
MOV R15,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x0015593c
MOV R14,RDX
MOV RBX,RDI
LEA R12,[RSP + 0x50]
MOV RDI,R12
CALL 0x0013cabe
CMP qword ptr [R12 + 0x30],0x0
JZ 0x0015596e
ADD R15,0x30
LAB_0015587a:
MOV RDI,RSP
MOV RSI,R15
MOV RDX,R14
CALL 0x00152ee0
LAB_00155888:
LEA RSI,[RSP + 0x50]
MOV RCX,RSP
MOV RDI,RBX
MOV RDX,R14
CALL 0x00154260
LAB_0015589b:
LEA RDI,[RSP + 0x18]
CALL 0x001555a8
MOV RDI,RSP
CALL 0x0014e342
LEA R14,[RSP + 0x90]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013ce3c
MOV RDI,R14
CALL 0x00149a2a
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x001558d5
CALL 0x0012ef66
LAB_001558d5:
MOV RDI,qword ptr [RSP + 0x78]
TEST RDI,RDI
JZ 0x001558e4
CALL 0x0012ef66
LAB_001558e4:
MOV RDI,qword ptr [RSP + 0x68]
TEST RDI,RDI
JZ 0x001558f3
CALL 0x0012ef66
LAB_001558f3:
MOV RDI,qword ptr [RSP + 0x58]
TEST RDI,RDI
JZ 0x00155929
MOV RAX,qword ptr [0x001dbf98]
CMP byte ptr [RAX],0x0
JZ 0x00155914
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0015591e
LAB_00155914:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0015591e:
CMP EAX,0x1
JNZ 0x00155929
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00155929:
MOV RAX,RBX
ADD RSP,0xa0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0015593c:
MOV EDI,0x10
CALL 0x00118350
MOV RBX,RAX
LAB_00155949:
LEA RSI,[0x1ab247]
MOV RDI,RAX
CALL 0x00118260
LAB_00155958:
MOV RSI,qword ptr [0x001dbff0]
MOV RDX,qword ptr [0x001dbf70]
MOV RDI,RBX
CALL 0x00118b30
LAB_0015596e:
MOV EDI,0x10
CALL 0x00118350
MOV RBX,RAX
LAB_0015597b:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x50]
MOV EDX,0x2
XOR ECX,ECX
CALL 0x0013d172
LAB_00155991:
LEA RSI,[0x1ab4e2]
MOV RDI,RSP
LEA RDX,[RSP + 0x30]
CALL 0x0012434d
MOV BPL,0x1
LAB_001559a8:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001dbff0]
MOV RDX,qword ptr [0x001dbf70]
MOV RDI,RBX
CALL 0x00118b30
|
/* minja::CallExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
CallExpr * __thiscall minja::CallExpr::do_evaluate(CallExpr *this,shared_ptr *param_1)
{
int *piVar1;
int iVar2;
runtime_error *prVar3;
shared_ptr asStack_c8 [24];
vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
local_b0 [24];
int1 local_98 [32];
Expression local_78 [8];
long *local_70;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_60;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_50;
long local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
data local_38 [16];
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00155949 to 00155957 has its CatchHandler @ 00155a38 */
std::runtime_error::runtime_error(prVar3,"CallExpr.object is null");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001dbff0,PTR__runtime_error_001dbf70);
}
Expression::evaluate(local_78,*(shared_ptr **)(param_1 + 0x20));
if (local_48 != 0) {
/* try { // try from 0015587a to 00155887 has its CatchHandler @ 00155a5c */
ArgumentsExpression::evaluate(asStack_c8);
/* try { // try from 00155888 to 0015589a has its CatchHandler @ 00155a45 */
Value::call((shared_ptr *)this,(ArgumentsValue *)local_78);
std::
vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
::~vector(local_b0);
std::vector<minja::Value,std::allocator<minja::Value>>::~vector
((vector<minja::Value,std::allocator<minja::Value>> *)asStack_c8);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_38,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_38);
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
if (local_50 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_50);
}
if (local_60 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_60);
}
if (local_70 != (long *)0x0) {
if (*PTR___libc_single_threaded_001dbf98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_70 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_70 + 0xc);
*(int *)((long)local_70 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_70 + 0x18))();
}
}
return this;
}
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015597b to 00155990 has its CatchHandler @ 00155a2b */
Value::dump_abi_cxx11_((int)local_98,SUB81(local_78,0));
/* try { // try from 00155991 to 001559a4 has its CatchHandler @ 00155a0b */
std::operator+((char *)asStack_c8,(string *)"Object is not callable: ");
/* try { // try from 001559a8 to 001559ca has its CatchHandler @ 001559cb */
std::runtime_error::runtime_error(prVar3,(string *)asStack_c8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001dbff0,PTR__runtime_error_001dbf70);
}
| |
28,438 | my_load_path | eloqsql/mysys/mf_loadpath.c | char * my_load_path(char * to, const char *path,
const char *own_path_prefix)
{
char buff[FN_REFLEN+1];
const char *from= buff;
int is_cur;
DBUG_ENTER("my_load_path");
DBUG_PRINT("enter",("path: %s prefix: %s",path,
own_path_prefix ? own_path_prefix : ""));
if ((path[0] == FN_HOMELIB && path[1] == FN_LIBCHAR) ||
test_if_hard_path(path))
from= path;
else if ((is_cur=(path[0] == FN_CURLIB && path[1] == FN_LIBCHAR)) ||
(is_prefix(path,FN_PARENTDIR)) ||
! own_path_prefix)
{
if (is_cur)
is_cur=2; /* Remove current dir */
if (! my_getwd(buff,(uint) (FN_REFLEN-strlen(path)+is_cur),MYF(0)))
{
size_t length= strlen(buff);
(void) strmake(buff + length, path+is_cur, FN_REFLEN - length);
}
else
from= path; /* Return org file name */
}
else
(void) strxnmov(buff, FN_REFLEN, own_path_prefix, path, NullS);
strmake(to, from, FN_REFLEN-1);
DBUG_PRINT("exit",("to: %s",to));
DBUG_RETURN(to);
} | O0 | c | my_load_path:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
movq %rdx, -0x228(%rbp)
leaq -0x210(%rbp), %rax
movq %rax, -0x230(%rbp)
jmp 0xc06dd
movq -0x220(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jne 0xc06fc
movq -0x220(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
je 0xc070d
movq -0x220(%rbp), %rdi
callq 0xb9a30
cmpl $0x0, %eax
je 0xc0720
movq -0x220(%rbp), %rax
movq %rax, -0x230(%rbp)
jmp 0xc0864
movq -0x220(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0x241(%rbp)
jne 0xc074e
movq -0x220(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x241(%rbp)
movb -0x241(%rbp), %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x234(%rbp)
testb $0x1, %al
jne 0xc078c
movq -0x220(%rbp), %rdi
leaq 0x57c4a(%rip), %rsi # 0x1183be
callq 0x109330
cmpl $0x0, %eax
jne 0xc078c
cmpq $0x0, -0x228(%rbp)
jne 0xc083c
cmpl $0x0, -0x234(%rbp)
je 0xc079f
movl $0x2, -0x234(%rbp)
leaq -0x210(%rbp), %rax
movq %rax, -0x250(%rbp)
movq -0x220(%rbp), %rdi
callq 0x3b4b0
movq -0x250(%rbp), %rdi
movq %rax, %rcx
movl $0x200, %eax # imm = 0x200
subq %rcx, %rax
movslq -0x234(%rbp), %rcx
addq %rcx, %rax
movl %eax, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xb97e0
cmpl $0x0, %eax
jne 0xc082c
leaq -0x210(%rbp), %rdi
callq 0x3b4b0
movq %rax, -0x240(%rbp)
leaq -0x210(%rbp), %rdi
addq -0x240(%rbp), %rdi
movq -0x220(%rbp), %rsi
movslq -0x234(%rbp), %rax
addq %rax, %rsi
movl $0x200, %edx # imm = 0x200
subq -0x240(%rbp), %rdx
callq 0x10cb40
jmp 0xc083a
movq -0x220(%rbp), %rax
movq %rax, -0x230(%rbp)
jmp 0xc0862
leaq -0x210(%rbp), %rdi
movq -0x228(%rbp), %rdx
movq -0x220(%rbp), %rcx
movl $0x200, %esi # imm = 0x200
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x10cd60
jmp 0xc0864
movq -0x218(%rbp), %rdi
movq -0x230(%rbp), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x10cb40
jmp 0xc087e
jmp 0xc0880
movq -0x218(%rbp), %rax
movq %rax, -0x258(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xc08b0
movq -0x258(%rbp), %rax
addq $0x260, %rsp # imm = 0x260
popq %rbp
retq
callq 0x3b340
nopw %cs:(%rax,%rax)
nop
| my_load_path:
push rbp
mov rbp, rsp
sub rsp, 260h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
mov [rbp+var_228], rdx
lea rax, [rbp+var_210]
mov [rbp+var_230], rax
jmp short $+2
loc_C06DD:
mov rax, [rbp+var_220]
movsx eax, byte ptr [rax]
cmp eax, 7Eh ; '~'
jnz short loc_C06FC
mov rax, [rbp+var_220]
movsx eax, byte ptr [rax+1]
cmp eax, 2Fh ; '/'
jz short loc_C070D
loc_C06FC:
mov rdi, [rbp+var_220]
call test_if_hard_path
cmp eax, 0
jz short loc_C0720
loc_C070D:
mov rax, [rbp+var_220]
mov [rbp+var_230], rax
jmp loc_C0864
loc_C0720:
mov rax, [rbp+var_220]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 2Eh ; '.'
mov [rbp+var_241], al
jnz short loc_C074E
mov rax, [rbp+var_220]
movsx eax, byte ptr [rax+1]
cmp eax, 2Fh ; '/'
setz al
mov [rbp+var_241], al
loc_C074E:
mov al, [rbp+var_241]
mov cl, al
and cl, 1
movzx ecx, cl
mov [rbp+var_234], ecx
test al, 1
jnz short loc_C078C
mov rdi, [rbp+var_220]
lea rsi, asc_1183BE; ".."
call is_prefix
cmp eax, 0
jnz short loc_C078C
cmp [rbp+var_228], 0
jnz loc_C083C
loc_C078C:
cmp [rbp+var_234], 0
jz short loc_C079F
mov [rbp+var_234], 2
loc_C079F:
lea rax, [rbp+var_210]
mov [rbp+var_250], rax
mov rdi, [rbp+var_220]
call _strlen
mov rdi, [rbp+var_250]
mov rcx, rax
mov eax, 200h
sub rax, rcx
movsxd rcx, [rbp+var_234]
add rax, rcx
mov eax, eax
mov esi, eax
xor eax, eax
mov edx, eax
call my_getwd
cmp eax, 0
jnz short loc_C082C
lea rdi, [rbp+var_210]
call _strlen
mov [rbp+var_240], rax
lea rdi, [rbp+var_210]
add rdi, [rbp+var_240]
mov rsi, [rbp+var_220]
movsxd rax, [rbp+var_234]
add rsi, rax
mov edx, 200h
sub rdx, [rbp+var_240]
call strmake
jmp short loc_C083A
loc_C082C:
mov rax, [rbp+var_220]
mov [rbp+var_230], rax
loc_C083A:
jmp short loc_C0862
loc_C083C:
lea rdi, [rbp+var_210]
mov rdx, [rbp+var_228]
mov rcx, [rbp+var_220]
mov esi, 200h
xor eax, eax
mov r8d, eax
mov al, 0
call strxnmov
loc_C0862:
jmp short $+2
loc_C0864:
mov rdi, [rbp+var_218]
mov rsi, [rbp+var_230]
mov edx, 1FFh
call strmake
jmp short $+2
loc_C087E:
jmp short $+2
loc_C0880:
mov rax, [rbp+var_218]
mov [rbp+var_258], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_C08B0
mov rax, [rbp+var_258]
add rsp, 260h
pop rbp
retn
loc_C08B0:
call ___stack_chk_fail
| long long my_load_path(long long a1, char *a2, long long a3)
{
int v3; // r9d
int v4; // eax
bool v6; // [rsp+1Fh] [rbp-241h]
long long v7; // [rsp+20h] [rbp-240h]
int v8; // [rsp+2Ch] [rbp-234h]
_BYTE v10[520]; // [rsp+50h] [rbp-210h] BYREF
unsigned long long v11; // [rsp+258h] [rbp-8h]
v11 = __readfsqword(0x28u);
if ( (*a2 != 126 || a2[1] != 47) && !test_if_hard_path(a2) )
{
v6 = 0;
if ( *a2 == 46 )
v6 = a2[1] == 47;
v8 = v6;
if ( v6 || (unsigned int)is_prefix(a2, "..") || !a3 )
{
if ( v6 )
v8 = 2;
v4 = strlen(a2);
if ( (unsigned int)my_getwd((long long)v10, (unsigned int)(v8 + 512 - v4), 0) )
goto LABEL_4;
v7 = strlen(v10);
strmake(&v10[v7], &a2[v8], 512 - v7);
}
else
{
strxnmov((unsigned int)v10, 512, a3, (_DWORD)a2, 0, v3);
}
strmake(a1, v10, 511LL);
return a1;
}
LABEL_4:
strmake(a1, a2, 511LL);
return a1;
}
| my_load_path:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x260
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
MOV qword ptr [RBP + -0x228],RDX
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0x230],RAX
JMP 0x001c06dd
LAB_001c06dd:
MOV RAX,qword ptr [RBP + -0x220]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x7e
JNZ 0x001c06fc
MOV RAX,qword ptr [RBP + -0x220]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x2f
JZ 0x001c070d
LAB_001c06fc:
MOV RDI,qword ptr [RBP + -0x220]
CALL 0x001b9a30
CMP EAX,0x0
JZ 0x001c0720
LAB_001c070d:
MOV RAX,qword ptr [RBP + -0x220]
MOV qword ptr [RBP + -0x230],RAX
JMP 0x001c0864
LAB_001c0720:
MOV RAX,qword ptr [RBP + -0x220]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x2e
MOV byte ptr [RBP + -0x241],AL
JNZ 0x001c074e
MOV RAX,qword ptr [RBP + -0x220]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x2f
SETZ AL
MOV byte ptr [RBP + -0x241],AL
LAB_001c074e:
MOV AL,byte ptr [RBP + -0x241]
MOV CL,AL
AND CL,0x1
MOVZX ECX,CL
MOV dword ptr [RBP + -0x234],ECX
TEST AL,0x1
JNZ 0x001c078c
MOV RDI,qword ptr [RBP + -0x220]
LEA RSI,[0x2183be]
CALL 0x00209330
CMP EAX,0x0
JNZ 0x001c078c
CMP qword ptr [RBP + -0x228],0x0
JNZ 0x001c083c
LAB_001c078c:
CMP dword ptr [RBP + -0x234],0x0
JZ 0x001c079f
MOV dword ptr [RBP + -0x234],0x2
LAB_001c079f:
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0x250],RAX
MOV RDI,qword ptr [RBP + -0x220]
CALL 0x0013b4b0
MOV RDI,qword ptr [RBP + -0x250]
MOV RCX,RAX
MOV EAX,0x200
SUB RAX,RCX
MOVSXD RCX,dword ptr [RBP + -0x234]
ADD RAX,RCX
MOV EAX,EAX
MOV ESI,EAX
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001b97e0
CMP EAX,0x0
JNZ 0x001c082c
LEA RDI,[RBP + -0x210]
CALL 0x0013b4b0
MOV qword ptr [RBP + -0x240],RAX
LEA RDI,[RBP + -0x210]
ADD RDI,qword ptr [RBP + -0x240]
MOV RSI,qword ptr [RBP + -0x220]
MOVSXD RAX,dword ptr [RBP + -0x234]
ADD RSI,RAX
MOV EDX,0x200
SUB RDX,qword ptr [RBP + -0x240]
CALL 0x0020cb40
JMP 0x001c083a
LAB_001c082c:
MOV RAX,qword ptr [RBP + -0x220]
MOV qword ptr [RBP + -0x230],RAX
LAB_001c083a:
JMP 0x001c0862
LAB_001c083c:
LEA RDI,[RBP + -0x210]
MOV RDX,qword ptr [RBP + -0x228]
MOV RCX,qword ptr [RBP + -0x220]
MOV ESI,0x200
XOR EAX,EAX
MOV R8D,EAX
MOV AL,0x0
CALL 0x0020cd60
LAB_001c0862:
JMP 0x001c0864
LAB_001c0864:
MOV RDI,qword ptr [RBP + -0x218]
MOV RSI,qword ptr [RBP + -0x230]
MOV EDX,0x1ff
CALL 0x0020cb40
JMP 0x001c087e
LAB_001c087e:
JMP 0x001c0880
LAB_001c0880:
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x258],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001c08b0
MOV RAX,qword ptr [RBP + -0x258]
ADD RSP,0x260
POP RBP
RET
LAB_001c08b0:
CALL 0x0013b340
|
int8 my_load_path(int8 param_1,char *param_2,long param_3)
{
int iVar1;
size_t sVar2;
long in_FS_OFFSET;
bool local_249;
uint local_23c;
char *local_238;
char local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_238 = param_2;
if (((*param_2 != '~') || (param_2[1] != '/')) && (iVar1 = test_if_hard_path(param_2), iVar1 == 0)
) {
local_249 = false;
if (*param_2 == '.') {
local_249 = param_2[1] == '/';
}
local_23c = (uint)local_249;
if (((local_249 == false) && (iVar1 = is_prefix(param_2,&DAT_002183be), iVar1 == 0)) &&
(param_3 != 0)) {
strxnmov(local_218,0x200,param_3,param_2,0);
local_238 = local_218;
}
else {
if (local_23c != 0) {
local_23c = 2;
}
sVar2 = strlen(param_2);
iVar1 = my_getwd(local_218,(0x200 - (int)sVar2) + local_23c,0);
if (iVar1 == 0) {
sVar2 = strlen(local_218);
strmake(local_218 + sVar2,param_2 + (int)local_23c,0x200 - sVar2);
local_238 = local_218;
}
}
}
strmake(param_1,local_238,0x1ff);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
| |
28,439 | std::pair<bool, 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::json_sax_dom_callback_parser<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>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool) | msxemulator/build_O3/_deps/picotool-src/lib/nlohmann_json/single_include/nlohmann/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O3 | cpp | std::pair<bool, 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::json_sax_dom_callback_parser<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>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
movl 0x38(%rdi), %eax
leaq -0x1(%rax), %rcx
addq $0x3e, %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq 0x30(%rdi), %rax
leaq 0x3f(%r14), %rdx
andq %rcx, %rdx
xorl %edi, %edi
cmpq %r14, %rdx
setbe %dil
movq -0x8(%rax,%rdi,8), %rax
btq %rcx, %rax
jae 0x6a926
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq (%rsi), %rsi
callq 0x6aa4a
testb %bpl, %bpl
jne 0x6a8e3
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0x2c(%rsp)
movb $0x5, 0xf(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x6aa2f
leaq 0x80(%rbx), %rdi
leaq 0x2c(%rsp), %rsi
leaq 0xf(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x6aa12
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x6a930
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x6aa12
cmpb $0x2, (%rax)
jne 0x6a973
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5ca7e
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x6aa0e
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x6aa21
movaps 0x10(%rsp), %xmm0
leaq 0x40(%rsp), %rdi
movaps %xmm0, (%rdi)
movb $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq (%rbx), %rax
movb (%rax), %cl
movb (%rdi), %dl
movb %dl, (%rax)
movb %cl, (%rdi)
movq 0x8(%rax), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
callq 0x5c638
movq (%rbx), %r14
jmp 0x6aa0e
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r14), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r14, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0x6a9c9
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x6aa12
movaps 0x10(%rsp), %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movb $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x70(%rbx), %rax
movb (%rax), %cl
movb (%rdi), %dl
movb %dl, (%rax)
movb %cl, (%rdi)
movq 0x8(%rax), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
callq 0x5c638
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x6aa17
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %rdi
callq 0x5c638
movl %ebx, %eax
movq %r14, %rdx
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0xf1d0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5c638
movq %rbx, %rdi
callq 0xf7d0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIRmEESt4pairIbPSF_EOT_b:
push rbp
push r14
push rbx
sub rsp, 50h
mov ebp, edx
mov rbx, rdi
mov r14, 8000000000000000h
mov eax, [rdi+38h]
lea rcx, [rax-1]
add rax, 3Eh ; '>'
test rcx, rcx
cmovns rax, rcx
sar rax, 6
shl rax, 3
add rax, [rdi+30h]
lea rdx, [r14+3Fh]
and rdx, rcx
xor edi, edi
cmp rdx, r14
setbe dil
mov rax, [rax+rdi*8-8]
bt rax, rcx
jnb loc_6A926
xorps xmm0, xmm0
lea rdi, [rsp+68h+var_58]
movaps xmmword ptr [rdi], xmm0
mov rsi, [rsi]
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE6EE9constructINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_17number_unsigned_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::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<std::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<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_unsigned_t)
test bpl, bpl
jnz short loc_6A8E3
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+68h+var_3C], eax
mov [rsp+68h+var_59], 5
cmp qword ptr [rbx+90h], 0
jz loc_6AA2F
lea rdi, [rbx+80h]
lea rsi, [rsp+68h+var_3C]
lea rdx, [rsp+68h+var_59]
lea rcx, [rsp+68h+var_58]
call qword ptr [rbx+98h]
test al, al
jz loc_6AA12
loc_6A8E3:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_6A930
mov rax, [rax-8]
test rax, rax
jz loc_6AA12
cmp byte ptr [rax], 2
jnz short loc_6A973
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEEvDpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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<std::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<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_6AA0E
loc_6A926:
xor ebx, ebx
xor r14d, r14d
jmp loc_6AA21
loc_6A930:
movaps xmm0, [rsp+68h+var_58]
lea rdi, [rsp+68h+var_28]
movaps xmmword ptr [rdi], xmm0
mov byte ptr [rsp+68h+var_58], 0
mov qword ptr [rsp+68h+var_58+8], 0
mov rax, [rbx]
mov cl, [rax]
mov dl, [rdi]
mov [rax], dl
mov [rdi], cl
mov rcx, [rax+8]
mov rdx, [rdi+8]
mov [rax+8], rdx
mov [rdi+8], rcx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::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 r14, [rbx]
jmp loc_6AA0E
loc_6A973:
mov rax, [rbx+58h]
mov esi, [rbx+60h]
lea rcx, [rsi-1]
mov rdx, rsi
add rdx, 3Eh ; '>'
test rcx, rcx
cmovns rdx, rcx
sar rdx, 6
lea rdi, [rax+rdx*8]
lea rdx, [r14+3Fh]
and rdx, rcx
xor r8d, r8d
cmp rdx, r14
setbe r8b
mov edx, 1
shl rdx, cl
and rdx, [rdi+r8*8-8]
sub esi, 1
mov [rbx+60h], esi
jnb short loc_6A9C9
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_6A9C9:
test rdx, rdx
jz short loc_6AA12
movaps xmm0, [rsp+68h+var_58]
lea rdi, [rsp+68h+var_38]
movaps xmmword ptr [rdi], xmm0
mov byte ptr [rsp+68h+var_58], 0
mov qword ptr [rsp+68h+var_58+8], 0
mov rax, [rbx+70h]
mov cl, [rax]
mov dl, [rdi]
mov [rax], dl
mov [rdi], cl
mov rcx, [rax+8]
mov rdx, [rdi+8]
mov [rax+8], rdx
mov [rdi+8], rcx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::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 r14, [rbx+70h]
loc_6AA0E:
mov bl, 1
jmp short loc_6AA17
loc_6AA12:
xor ebx, ebx
xor r14d, r14d
loc_6AA17:
lea rdi, [rsp+68h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::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_6AA21:
mov eax, ebx
mov rdx, r14
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_6AA2F:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov rbx, rax
lea rdi, [rsp+68h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::handle_value<unsigned long &>(
char **a1,
_QWORD *a2,
char a3)
{
unsigned int v4; // ebx
long long v5; // rax
signed long long v6; // rcx
long long v7; // rax
long long v8; // rax
char *v9; // rax
long long v10; // rax
char *v11; // rax
char v12; // cl
long long v13; // rcx
char *v14; // rax
long long v15; // rsi
long long v16; // rdx
long long v17; // rdx
char *v18; // rax
char v19; // cl
long long v20; // rcx
char v22; // [rsp+Fh] [rbp-59h] BYREF
__int128 v23; // [rsp+10h] [rbp-58h] BYREF
int v24; // [rsp+2Ch] [rbp-3Ch] BYREF
__int128 v25; // [rsp+30h] [rbp-38h] BYREF
__int128 v26; // [rsp+40h] [rbp-28h] BYREF
v4 = (unsigned int)a1;
v5 = *((unsigned int *)a1 + 14);
v6 = v5 - 1;
v7 = v5 + 62;
if ( v6 >= 0 )
v7 = v6;
v8 = *(_QWORD *)&a1[6][8 * (v7 >> 6) - 8 + 8 * ((v6 & 0x800000000000003FLL) <= 0x8000000000000000LL)];
if ( _bittest64(&v8, v6) )
{
v23 = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::construct<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>>(
&v23,
*a2);
if ( a3 )
goto LABEL_7;
v24 = (unsigned long long)(a1[2] - a1[1]) >> 3;
v22 = 5;
if ( !a1[18] )
std::__throw_bad_function_call();
if ( ((unsigned __int8 ( *)(char **, int *, char *, __int128 *))a1[19])(a1 + 16, &v24, &v22, &v23) )
{
LABEL_7:
v9 = a1[2];
if ( a1[1] == v9 )
{
v26 = v23;
LOBYTE(v23) = 0;
*((_QWORD *)&v23 + 1) = 0LL;
v11 = *a1;
v12 = **a1;
*v11 = v26;
LOBYTE(v26) = v12;
v13 = *((_QWORD *)v11 + 1);
*((_QWORD *)v11 + 1) = *((_QWORD *)&v26 + 1);
*((_QWORD *)&v26 + 1) = v13;
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>::data::~data(&v26);
goto LABEL_19;
}
v10 = *((_QWORD *)v9 - 1);
if ( v10 )
{
if ( *(_BYTE *)v10 == 2 )
{
std::vector<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>>::emplace_back<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>>(
*(_QWORD *)(v10 + 8),
(long long)&v23);
LABEL_19:
LOBYTE(v4) = 1;
LABEL_21:
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>::data::~data(&v23);
return v4;
}
v14 = a1[11];
v15 = *((unsigned int *)a1 + 24);
v16 = v15 + 62;
if ( v15 - 1 >= 0 )
v16 = v15 - 1;
v17 = *(_QWORD *)&v14[8 * (v16 >> 6) - 8 + 8 * (((v15 - 1) & 0x800000000000003FLL) <= 0x8000000000000000LL)] & (1LL << ((unsigned __int8)v15 - 1));
*((_DWORD *)a1 + 24) = v15 - 1;
if ( !(_DWORD)v15 )
{
*((_DWORD *)a1 + 24) = 63;
a1[11] = v14 - 8;
}
if ( v17 )
{
v25 = v23;
LOBYTE(v23) = 0;
*((_QWORD *)&v23 + 1) = 0LL;
v18 = a1[14];
v19 = *v18;
*v18 = v25;
LOBYTE(v25) = v19;
v20 = *((_QWORD *)v18 + 1);
*((_QWORD *)v18 + 1) = *((_QWORD *)&v25 + 1);
*((_QWORD *)&v25 + 1) = v20;
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>::data::~data(&v25);
goto LABEL_19;
}
}
}
v4 = 0;
goto LABEL_21;
}
return 0;
}
| handle_value<unsigned_long&>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV EBP,EDX
MOV RBX,RDI
MOV R14,-0x8000000000000000
MOV EAX,dword ptr [RDI + 0x38]
LEA RCX,[RAX + -0x1]
ADD RAX,0x3e
TEST RCX,RCX
CMOVNS RAX,RCX
SAR RAX,0x6
SHL RAX,0x3
ADD RAX,qword ptr [RDI + 0x30]
LEA RDX,[R14 + 0x3f]
AND RDX,RCX
XOR EDI,EDI
CMP RDX,R14
SETBE DIL
MOV RAX,qword ptr [RAX + RDI*0x8 + -0x8]
BT RAX,RCX
JNC 0x0016a926
XORPS XMM0,XMM0
LEA RDI,[RSP + 0x10]
MOVAPS xmmword ptr [RDI],XMM0
MOV RSI,qword ptr [RSI]
CALL 0x0016aa4a
TEST BPL,BPL
JNZ 0x0016a8e3
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0x2c],EAX
MOV byte ptr [RSP + 0xf],0x5
CMP qword ptr [RBX + 0x90],0x0
JZ 0x0016aa2f
LEA RDI,[RBX + 0x80]
LAB_0016a8c6:
LEA RSI,[RSP + 0x2c]
LEA RDX,[RSP + 0xf]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x0016aa12
LAB_0016a8e3:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x0016a930
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x0016aa12
CMP byte ptr [RAX],0x2
JNZ 0x0016a973
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x0015ca7e
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x0016aa0e
LAB_0016a926:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0016aa21
LAB_0016a930:
MOVAPS XMM0,xmmword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x40]
MOVAPS xmmword ptr [RDI],XMM0
MOV byte ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV RAX,qword ptr [RBX]
MOV CL,byte ptr [RAX]
MOV DL,byte ptr [RDI]
MOV byte ptr [RAX],DL
MOV byte ptr [RDI],CL
MOV RCX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RDI + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RDI + 0x8],RCX
CALL 0x0015c638
MOV R14,qword ptr [RBX]
JMP 0x0016aa0e
LAB_0016a973:
MOV RAX,qword ptr [RBX + 0x58]
MOV ESI,dword ptr [RBX + 0x60]
LEA RCX,[RSI + -0x1]
MOV RDX,RSI
ADD RDX,0x3e
TEST RCX,RCX
CMOVNS RDX,RCX
SAR RDX,0x6
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[R14 + 0x3f]
AND RDX,RCX
XOR R8D,R8D
CMP RDX,R14
SETBE R8B
MOV EDX,0x1
SHL RDX,CL
AND RDX,qword ptr [RDI + R8*0x8 + -0x8]
SUB ESI,0x1
MOV dword ptr [RBX + 0x60],ESI
JNC 0x0016a9c9
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_0016a9c9:
TEST RDX,RDX
JZ 0x0016aa12
MOVAPS XMM0,xmmword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x30]
MOVAPS xmmword ptr [RDI],XMM0
MOV byte ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV RAX,qword ptr [RBX + 0x70]
MOV CL,byte ptr [RAX]
MOV DL,byte ptr [RDI]
MOV byte ptr [RAX],DL
MOV byte ptr [RDI],CL
MOV RCX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RDI + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RDI + 0x8],RCX
CALL 0x0015c638
MOV R14,qword ptr [RBX + 0x70]
LAB_0016aa0e:
MOV BL,0x1
JMP 0x0016aa17
LAB_0016aa12:
XOR EBX,EBX
XOR R14D,R14D
LAB_0016aa17:
LEA RDI,[RSP + 0x10]
CALL 0x0015c638
LAB_0016aa21:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_0016aa2f:
CALL 0x0010f1d0
|
/* std::pair<bool, 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::json_sax_dom_callback_parser<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> >::handle_value<unsigned long&>(unsigned long&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<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>>
::handle_value<unsigned_long&>
(json_sax_dom_callback_parser<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>>
*this,ulong *param_1,bool param_2)
{
data dVar1;
uint uVar2;
char *pcVar3;
data *pdVar4;
uint7 uVar5;
int8 uVar6;
int8 uVar7;
char cVar8;
ulong uVar9;
ulong uVar10;
long lVar11;
int1 auVar12 [16];
int1 local_59;
long local_58;
int8 uStack_50;
int4 local_3c;
data local_38;
uint7 uStack_37;
int8 uStack_30;
data local_28;
uint7 uStack_27;
int8 uStack_20;
uVar10 = (ulong)*(uint *)(this + 0x38) - 1;
uVar9 = (ulong)*(uint *)(this + 0x38) + 0x3e;
if (-1 < (long)uVar10) {
uVar9 = uVar10;
}
if ((*(ulong *)(((long)uVar9 >> 6) * 8 + *(long *)(this + 0x30) + -8 +
(ulong)((uVar10 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar10 & 0x3f)
& 1) == 0) {
uVar10 = 0;
lVar11 = 0;
goto LAB_0016aa21;
}
local_58 = 0;
uStack_50 = 0;
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::
construct<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>>
(&local_58,*param_1);
if (param_2) {
LAB_0016a8e3:
uVar7 = _local_28;
uVar6 = uStack_50;
uVar5 = local_58._1_7_;
local_28 = SUB81(local_58,0);
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
local_58 = (ulong)local_58._1_7_ << 8;
uStack_50 = 0;
pdVar4 = *(data **)this;
dVar1 = *pdVar4;
*pdVar4 = local_28;
_local_28 = CONCAT71(uVar5,dVar1);
uStack_20 = *(int8 *)(pdVar4 + 8);
*(int8 *)(pdVar4 + 8) = uVar6;
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>
::data::~data(&local_28);
lVar11 = *(long *)this;
}
else {
pcVar3 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar3 == (char *)0x0) goto LAB_0016aa12;
_local_28 = uVar7;
if (*pcVar3 == '\x02') {
std::
vector<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>,std::allocator<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>>>
::
emplace_back<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>>
(*(vector<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>,std::allocator<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>>>
**)(pcVar3 + 8),(basic_json *)&local_58);
lVar11 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
else {
uVar2 = *(uint *)(this + 0x60);
uVar10 = (ulong)uVar2 - 1;
uVar9 = (ulong)uVar2 + 0x3e;
if (-1 < (long)uVar10) {
uVar9 = uVar10;
}
uVar9 = *(ulong *)(*(long *)(this + 0x58) + ((long)uVar9 >> 6) * 8 + -8 +
(ulong)((uVar10 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar2 - 1;
if (uVar2 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = *(long *)(this + 0x58) + -8;
}
if ((1L << ((byte)uVar10 & 0x3f) & uVar9) == 0) goto LAB_0016aa12;
local_58 = (ulong)local_58._1_7_ << 8;
uStack_50 = 0;
pdVar4 = *(data **)(this + 0x70);
dVar1 = *pdVar4;
*pdVar4 = local_28;
_local_38 = CONCAT71(uVar5,dVar1);
uStack_30 = *(int8 *)(pdVar4 + 8);
*(int8 *)(pdVar4 + 8) = uVar6;
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>
::data::~data(&local_38);
lVar11 = *(long *)(this + 0x70);
}
}
uVar10 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
local_3c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_59 = 5;
if (*(long *)(this + 0x90) == 0) {
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
/* try { // try from 0016a8c6 to 0016aa33 has its CatchHandler @ 0016aa34 */
cVar8 = (**(code **)(this + 0x98))(this + 0x80,&local_3c,&local_59,&local_58);
uVar7 = _local_28;
if (cVar8 != '\0') goto LAB_0016a8e3;
LAB_0016aa12:
_local_28 = uVar7;
uVar10 = 0;
lVar11 = 0;
}
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>
::data::~data((data *)&local_58);
LAB_0016aa21:
auVar12._0_8_ = uVar10 & 0xffffffff;
auVar12._8_8_ = lVar11;
return auVar12;
}
| |
28,440 | my_free_open_file_info | eloqsql/mysys/my_file.c | void my_free_open_file_info()
{
DBUG_ENTER("my_free_file_info");
if (my_file_info != my_file_info_default)
{
/* Copy data back for my_print_open_files */
memcpy((char*) my_file_info_default, my_file_info,
sizeof(*my_file_info_default)* MY_NFILE);
my_free(my_file_info);
my_file_info= my_file_info_default;
my_file_limit= MY_NFILE;
}
DBUG_VOID_RETURN;
} | O0 | c | my_free_open_file_info:
pushq %rbp
movq %rsp, %rbp
leaq 0xb92aa5(%rip), %rcx # 0xc82aa0
leaq 0x1cfd36(%rip), %rax # 0x2bfd38
cmpq %rcx, (%rax)
je 0xf004f
leaq 0x1cfd2a(%rip), %rax # 0x2bfd38
movq (%rax), %rsi
leaq 0xb92a88(%rip), %rdi # 0xc82aa0
movl $0x400, %edx # imm = 0x400
callq 0x2a090
leaq 0x1cfd0f(%rip), %rax # 0x2bfd38
movq (%rax), %rdi
callq 0xf3ba0
leaq 0x1cfd00(%rip), %rax # 0x2bfd38
leaq 0xb92a61(%rip), %rcx # 0xc82aa0
movq %rcx, (%rax)
leaq 0x1cfce7(%rip), %rax # 0x2bfd30
movl $0x40, (%rax)
jmp 0xf0051
jmp 0xf0053
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| my_free_open_file_info:
push rbp
mov rbp, rsp
lea rcx, my_file_info_default
lea rax, my_file_info
cmp [rax], rcx
jz short loc_F004F
lea rax, my_file_info
mov rsi, [rax]
lea rdi, my_file_info_default
mov edx, 400h
call _memcpy
lea rax, my_file_info
mov rdi, [rax]
call my_free
lea rax, my_file_info
lea rcx, my_file_info_default
mov [rax], rcx
lea rax, my_file_limit
mov dword ptr [rax], 40h ; '@'
loc_F004F:
jmp short $+2
loc_F0051:
jmp short $+2
loc_F0053:
pop rbp
retn
| _UNKNOWN **my_free_open_file_info()
{
_UNKNOWN **result; // rax
result = &my_file_info;
if ( my_file_info != &my_file_info_default )
{
memcpy(&my_file_info_default, my_file_info, 1024LL);
my_free(my_file_info);
my_file_info = &my_file_info_default;
result = (_UNKNOWN **)my_file_limit;
my_file_limit[0] = 64;
}
return result;
}
| my_free_open_file_info:
PUSH RBP
MOV RBP,RSP
LEA RCX,[0xd82aa0]
LEA RAX,[0x3bfd38]
CMP qword ptr [RAX],RCX
JZ 0x001f004f
LEA RAX,[0x3bfd38]
MOV RSI,qword ptr [RAX]
LEA RDI,[0xd82aa0]
MOV EDX,0x400
CALL 0x0012a090
LEA RAX,[0x3bfd38]
MOV RDI,qword ptr [RAX]
CALL 0x001f3ba0
LEA RAX,[0x3bfd38]
LEA RCX,[0xd82aa0]
MOV qword ptr [RAX],RCX
LEA RAX,[0x3bfd30]
MOV dword ptr [RAX],0x40
LAB_001f004f:
JMP 0x001f0051
LAB_001f0051:
JMP 0x001f0053
LAB_001f0053:
POP RBP
RET
|
void my_free_open_file_info(void)
{
if (my_file_info != my_file_info_default) {
memcpy(my_file_info_default,my_file_info,0x400);
my_free(my_file_info);
my_file_info = my_file_info_default;
my_file_limit = 0x40;
}
return;
}
| |
28,441 | 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 0x846dd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a892
leaq 0x70(%r14), %rcx
testb %al, %al
je 0x846c2
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_846C2:
mov r14, rcx
cmp rcx, r15
jz short loc_846DD
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_846C2
loc_846DD:
cmp r14, r15
setnz al
pop rbx
pop r14
pop r15
retn
| bool minja::ArgumentsValue::has_named(long long a1, _QWORD *a2)
{
_QWORD *v2; // rcx
_QWORD *v3; // r15
_QWORD *v4; // r14
bool v5; // al
v2 = *(_QWORD **)(a1 + 24);
v3 = *(_QWORD **)(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_001846c2:
MOV R14,RCX
CMP RCX,R15
JZ 0x001846dd
MOV RDI,R14
MOV RSI,RBX
CALL 0x0013a892
LEA RCX,[R14 + 0x70]
TEST AL,AL
JZ 0x001846c2
LAB_001846dd:
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;
}
| |
28,442 | minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&) | monkey531[P]llama/common/minja.hpp | Value(const std::shared_ptr<CallableType> & callable) : object_(std::make_shared<ObjectType>()), callable_(callable) {} | O1 | cpp | minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
movl $0x30, %edi
callq 0x196d0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x8615f(%rip), %rcx # 0xe3458
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, 0x28(%rbx)
movq %rcx, 0x20(%rbx)
movq (%r14), %rax
movq %rax, 0x30(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x5d347
movq 0x87c5f(%rip), %rcx # 0xe4f98
cmpb $0x0, (%rcx)
je 0x5d343
incl 0x8(%rax)
jmp 0x5d347
lock
incl 0x8(%rax)
leaq 0x40(%rbx), %r14
movb $0x0, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x42e48
movq %r14, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42e48
movq %rax, %r14
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5d389
callq 0x3503e
movq %rbx, %rdi
callq 0x44e98
movq %r14, %rdi
callq 0x19c10
nop
| _ZN5minja5ValueC2ERKSt10shared_ptrISt8functionIFS0_RKS1_INS_7ContextEERNS_14ArgumentsValueEEEE:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+20h], 0
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
mov rcx, 100000001h
mov [rax+8], rcx
lea rcx, _ZTVSt23_Sp_counted_ptr_inplaceIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEESaISN_ELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>,std::allocator<nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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<std::pair<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,minja::Value>>>>,(__gnu_cxx::_Lock_policy)2>
add rcx, 10h
mov [rax], rcx
mov rcx, rax
add rcx, 10h
xorps xmm0, xmm0
movups xmmword ptr [rax+10h], xmm0
mov qword ptr [rax+20h], 0
mov [rbx+28h], rax
mov [rbx+20h], rcx
mov rax, [r14]
mov [rbx+30h], rax
mov rax, [r14+8]
mov [rbx+38h], rax
test rax, rax
jz short loc_5D347
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_5D343
inc dword ptr [rax+8]
jmp short loc_5D347
loc_5D343:
lock inc dword ptr [rax+8]
loc_5D347:
lea r14, [rbx+40h]
mov byte ptr [rbx+40h], 0
mov qword ptr [rbx+48h], 0
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 rdi, r14
mov esi, 1
add rsp, 8
pop rbx
pop r14
jmp _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 r14, rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_5D389
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5D389:
mov rdi, rbx
call _ZNSt23enable_shared_from_thisIN5minja5ValueEED2Ev; std::enable_shared_from_this<minja::Value>::~enable_shared_from_this()
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::Value(long long a1, _QWORD *a2)
{
long long v2; // rax
long long result; // rax
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 32) = 0LL;
v2 = operator new(0x30uLL);
*(_QWORD *)(v2 + 8) = 0x100000001LL;
*(_QWORD *)v2 = &`vtable for'std::_Sp_counted_ptr_inplace<nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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<std::pair<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> const,minja::Value>>>,std::allocator<nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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<std::pair<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> const,minja::Value>>>>,(__gnu_cxx::_Lock_policy)2>
+ 2;
*(_OWORD *)(v2 + 16) = 0LL;
*(_QWORD *)(v2 + 32) = 0LL;
*(_QWORD *)(a1 + 40) = v2;
*(_QWORD *)(a1 + 32) = v2 + 16;
*(_QWORD *)(a1 + 48) = *a2;
result = a2[1];
*(_QWORD *)(a1 + 56) = result;
if ( result )
{
if ( _libc_single_threaded )
++*(_DWORD *)(result + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(result + 8));
}
*(_BYTE *)(a1 + 64) = 0;
*(_QWORD *)(a1 + 72) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a1 + 64));
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a1 + 64));
return result;
}
| Value:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x20],0x0
LAB_0015d2da:
MOV EDI,0x30
CALL 0x001196d0
LAB_0015d2e4:
MOV RCX,0x100000001
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x1e3458]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
MOV RCX,RAX
ADD RCX,0x10
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOV qword ptr [RAX + 0x20],0x0
MOV qword ptr [RBX + 0x28],RAX
MOV qword ptr [RBX + 0x20],RCX
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX + 0x30],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RBX + 0x38],RAX
TEST RAX,RAX
JZ 0x0015d347
MOV RCX,qword ptr [0x001e4f98]
CMP byte ptr [RCX],0x0
JZ 0x0015d343
INC dword ptr [RAX + 0x8]
JMP 0x0015d347
LAB_0015d343:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0015d347:
LEA R14,[RBX + 0x40]
MOV byte ptr [RBX + 0x40],0x0
MOV qword ptr [RBX + 0x48],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x00142e48
MOV RDI,R14
MOV ESI,0x1
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00142e48
|
/* minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context>
const&, minja::ArgumentsValue&)> > const&) */
void __thiscall minja::Value::Value(Value *this,shared_ptr *param_1)
{
long lVar1;
int8 *puVar2;
bool bVar3;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x20) = 0;
/* try { // try from 0015d2da to 0015d2e3 has its CatchHandler @ 0015d378 */
puVar2 = (int8 *)operator_new(0x30);
puVar2[1] = 0x100000001;
*puVar2 = &PTR___Sp_counted_ptr_inplace_001e3468;
puVar2[2] = 0;
puVar2[3] = 0;
puVar2[4] = 0;
*(int8 **)(this + 0x28) = puVar2;
*(int8 **)(this + 0x20) = puVar2 + 2;
*(int8 *)(this + 0x30) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x38) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001e4f98 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
bVar3 = (bool)((char)this + '@');
this[0x40] = (Value)0x0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar3);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar3);
return;
}
| |
28,443 | my_strnxfrm_simple_nopad | eloqsql/strings/ctype-simple.c | size_t my_strnxfrm_simple_nopad(CHARSET_INFO * cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
uchar *d0= dst;
dst= d0 + my_strnxfrm_simple_internal(cs, dst, dstlen, &nweights,
src, srclen);
return my_strxfrm_pad_desc_and_reverse_nopad(cs, d0, dst, d0 + dstlen,
nweights, flags, 0);
} | O0 | c | my_strnxfrm_simple_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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 -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x1c(%rbp), %rcx
callq 0x413b0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
addq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x41710
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnxfrm_simple_nopad:
push rbp
mov rbp, rsp
sub rsp, 50h
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_10]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov r8, [rbp+var_28]
mov r9, [rbp+var_30]
lea rcx, [rbp+var_1C]
call my_strnxfrm_simple_internal
mov rcx, rax
mov rax, [rbp+var_40]
add rax, rcx
mov [rbp+var_10], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_38]
add rcx, [rbp+var_18]
mov r8d, [rbp+var_1C]
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+50h+var_50], 0
call my_strxfrm_pad_desc_and_reverse_nopad
add rsp, 50h
pop rbp
retn
| long long my_strnxfrm_simple_nopad(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
unsigned __int8 *a5,
unsigned long long a6,
int a7)
{
_BYTE *v7; // rax
unsigned int v9; // [rsp+34h] [rbp-1Ch] BYREF
unsigned long long v10; // [rsp+38h] [rbp-18h]
unsigned __int8 *v11; // [rsp+40h] [rbp-10h]
long long v12; // [rsp+48h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v7 = my_strnxfrm_simple_internal(a1, a2, a3, &v9, a5, a6);
v11 = &a2[(_QWORD)v7];
return my_strxfrm_pad_desc_and_reverse_nopad(v12, (_DWORD)a2, (int)v7 + (int)a2, (int)v10 + (int)a2, v9, a7, 0);
}
| my_strnxfrm_simple_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
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 + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x1c]
CALL 0x001413b0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,qword ptr [RBP + -0x18]
MOV R8D,dword ptr [RBP + -0x1c]
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x00141710
ADD RSP,0x50
POP RBP
RET
|
void my_strnxfrm_simple_nopad
(int8 param_1,long param_2,long param_3,int4 param_4,int8 param_5,
int8 param_6,int4 param_7)
{
int4 local_24;
long local_20;
long local_18;
int8 local_10;
local_24 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_18 = my_strnxfrm_simple_internal(param_1,param_2,param_3,&local_24,param_5,param_6);
local_18 = param_2 + local_18;
my_strxfrm_pad_desc_and_reverse_nopad
(local_10,param_2,local_18,param_2 + local_20,local_24,param_7,0);
return;
}
| |
28,444 | common_set_adapter_lora(llama_context*, std::vector<common_adapter_lora_info, std::allocator<common_adapter_lora_info>>&) | monkey531[P]llama/common/common.cpp | void common_set_adapter_lora(struct llama_context * ctx, std::vector<common_adapter_lora_info> & lora) {
llama_clear_adapter_lora(ctx);
for (auto & la : lora) {
if (la.scale != 0.0f) {
llama_set_adapter_lora(ctx, la.ptr, la.scale);
}
}
} | O2 | cpp | common_set_adapter_lora(llama_context*, std::vector<common_adapter_lora_info, std::allocator<common_adapter_lora_info>>&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x239b0
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x55d3a
movss 0x20(%r15), %xmm0
ucomiss 0x5bcc4(%rip), %xmm0 # 0xb19e8
jne 0x55d28
jnp 0x55d34
movq 0x28(%r15), %rsi
movq %rbx, %rdi
callq 0x23990
addq $0x30, %r15
jmp 0x55d12
popq %rbx
popq %r14
popq %r15
retq
| _Z23common_set_adapter_loraP13llama_contextRSt6vectorI24common_adapter_lora_infoSaIS2_EE:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
call _llama_clear_adapter_lora
mov r15, [r14]
mov r14, [r14+8]
loc_55D12:
cmp r15, r14
jz short loc_55D3A
movss xmm0, dword ptr [r15+20h]
ucomiss xmm0, cs:dword_B19E8
jnz short loc_55D28
jnp short loc_55D34
loc_55D28:
mov rsi, [r15+28h]
mov rdi, rbx
call _llama_set_adapter_lora
loc_55D34:
add r15, 30h ; '0'
jmp short loc_55D12
loc_55D3A:
pop rbx
pop r14
pop r15
retn
| long long common_set_adapter_lora(long long a1, long long *a2)
{
long long result; // rax
long long v3; // r15
long long v4; // r14
result = llama_clear_adapter_lora();
v3 = *a2;
v4 = a2[1];
while ( v3 != v4 )
{
if ( *(float *)(v3 + 32) != 0.0 )
result = llama_set_adapter_lora(a1, *(_QWORD *)(v3 + 40));
v3 += 48LL;
}
return result;
}
| common_set_adapter_lora:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
CALL 0x001239b0
MOV R15,qword ptr [R14]
MOV R14,qword ptr [R14 + 0x8]
LAB_00155d12:
CMP R15,R14
JZ 0x00155d3a
MOVSS XMM0,dword ptr [R15 + 0x20]
UCOMISS XMM0,dword ptr [0x001b19e8]
JNZ 0x00155d28
JNP 0x00155d34
LAB_00155d28:
MOV RSI,qword ptr [R15 + 0x28]
MOV RDI,RBX
CALL 0x00123990
LAB_00155d34:
ADD R15,0x30
JMP 0x00155d12
LAB_00155d3a:
POP RBX
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* common_set_adapter_lora(llama_context*, std::vector<common_adapter_lora_info,
std::allocator<common_adapter_lora_info> >&) */
void common_set_adapter_lora(llama_context *param_1,vector *param_2)
{
long lVar1;
long lVar2;
llama_clear_adapter_lora();
lVar1 = *(long *)(param_2 + 8);
for (lVar2 = *(long *)param_2; lVar2 != lVar1; lVar2 = lVar2 + 0x30) {
if ((*(float *)(lVar2 + 0x20) != _DAT_001b19e8) ||
(NAN(*(float *)(lVar2 + 0x20)) || NAN(_DAT_001b19e8))) {
llama_set_adapter_lora(param_1,*(int8 *)(lVar2 + 0x28));
}
}
return;
}
| |
28,445 | ftparser_alloc_param | eloqsql/storage/myisam/ft_parser.c | MYSQL_FTPARSER_PARAM* ftparser_alloc_param(MI_INFO *info)
{
if (!info->ftparser_param)
{
/*
. info->ftparser_param can not be zero after the initialization,
because it always includes built-in fulltext parser. And built-in
parser can be called even if the table has no fulltext indexes and
no varchar/text fields.
ftb_find_relevance... parser (ftb_find_relevance_parse,
ftb_find_relevance_add_word) calls ftb_check_phrase... parser
(ftb_check_phrase_internal, ftb_phrase_add_word). Thus MAX_PARAM_NR=2.
*/
info->ftparser_param= (MYSQL_FTPARSER_PARAM *)
my_malloc(mi_key_memory_FTPARSER_PARAM,
MAX_PARAM_NR * sizeof(MYSQL_FTPARSER_PARAM) * info->s->ftkeys,
MYF(MY_WME | MY_ZEROFILL));
init_alloc_root(mi_key_memory_ft_memroot, &info->ft_memroot,
FTPARSER_MEMROOT_ALLOC_SIZE, 0, MYF(0));
}
return info->ftparser_param;
} | O3 | c | ftparser_alloc_param:
movq 0xd0(%rdi), %rax
testq %rax, %rax
je 0x73a10
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb8bf64(%rip), %rax # 0xbff984
movl (%rax), %edi
movq (%rbx), %rax
movl 0x34c(%rax), %esi
shlq $0x7, %rsi
movl $0x30, %edx
callq 0x9f901
movq %rax, 0xd0(%rbx)
leaq 0xb8bf41(%rip), %rax # 0xbff988
movl (%rax), %edi
leaq 0x90(%rbx), %rsi
movl $0x10000, %edx # imm = 0x10000
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x9c694
movq 0xd0(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| ftparser_alloc_param:
mov rax, [rdi+0D0h]
test rax, rax
jz short loc_73A10
retn
loc_73A10:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
lea rax, mi_key_memory_FTPARSER_PARAM
mov edi, [rax]
mov rax, [rbx]
mov esi, [rax+34Ch]
shl rsi, 7
mov edx, 30h ; '0'
call my_malloc
mov [rbx+0D0h], rax
lea rax, mi_key_memory_ft_memroot
mov edi, [rax]
lea rsi, [rbx+90h]
mov edx, offset stru_10000
xor ecx, ecx
xor r8d, r8d
call init_alloc_root
mov rax, [rbx+0D0h]
add rsp, 8
pop rbx
pop rbp
retn
| long long ftparser_alloc_param(_QWORD *a1)
{
long long result; // rax
result = a1[26];
if ( !result )
{
a1[26] = my_malloc(mi_key_memory_FTPARSER_PARAM, (unsigned long long)*(unsigned int *)(*a1 + 844LL) << 7, 48LL);
init_alloc_root(mi_key_memory_ft_memroot, a1 + 18, &stru_10000, 0LL, 0LL);
return a1[26];
}
return result;
}
| ftparser_alloc_param:
MOV RAX,qword ptr [RDI + 0xd0]
TEST RAX,RAX
JZ 0x00173a10
RET
LAB_00173a10:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0xcff984]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBX]
MOV ESI,dword ptr [RAX + 0x34c]
SHL RSI,0x7
MOV EDX,0x30
CALL 0x0019f901
MOV qword ptr [RBX + 0xd0],RAX
LEA RAX,[0xcff988]
MOV EDI,dword ptr [RAX]
LEA RSI,[RBX + 0x90]
MOV EDX,0x10000
XOR ECX,ECX
XOR R8D,R8D
CALL 0x0019c694
MOV RAX,qword ptr [RBX + 0xd0]
ADD RSP,0x8
POP RBX
POP RBP
RET
|
long ftparser_alloc_param(long *param_1)
{
long lVar1;
int8 in_R9;
long lVar2;
lVar2 = param_1[0x1a];
if (lVar2 != 0) {
return lVar2;
}
lVar1 = my_malloc(mi_key_memory_FTPARSER_PARAM,(ulong)*(uint *)(*param_1 + 0x34c) << 7,0x30);
param_1[0x1a] = lVar1;
init_alloc_root(mi_key_memory_ft_memroot,param_1 + 0x12,0x10000,0,0,in_R9,lVar2);
return param_1[0x1a];
}
| |
28,446 | add_import | bluesky950520[P]quickjs/quickjs.c | static int add_import(JSParseState *s, JSModuleDef *m,
JSAtom local_name, JSAtom import_name)
{
JSContext *ctx = s->ctx;
int i, var_idx;
JSImportEntry *mi;
BOOL is_local;
if (local_name == JS_ATOM_arguments || local_name == JS_ATOM_eval)
return js_parse_error(s, "invalid import binding");
if (local_name != JS_ATOM_default) {
for (i = 0; i < s->cur_func->closure_var_count; i++) {
if (s->cur_func->closure_var[i].var_name == local_name)
return js_parse_error(s, "duplicate import binding");
}
}
is_local = (import_name == JS_ATOM__star_);
var_idx = add_closure_var(ctx, s->cur_func, is_local, FALSE,
m->import_entries_count,
local_name, TRUE, TRUE, JS_VAR_NORMAL);
if (var_idx < 0)
return -1;
if (js_resize_array(ctx, (void **)&m->import_entries,
sizeof(JSImportEntry),
&m->import_entries_size,
m->import_entries_count + 1))
return -1;
mi = &m->import_entries[m->import_entries_count++];
mi->import_name = JS_DupAtom(ctx, import_name);
mi->var_idx = var_idx;
return 0;
} | O0 | c | add_import:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl %ecx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
cmpl $0x4e, 0x3c(%rsp)
je 0xb0761
cmpl $0x3b, 0x3c(%rsp)
jne 0xb077d
movq 0x48(%rsp), %rdi
leaq 0x5e4ef(%rip), %rsi # 0x10ec5c
movb $0x0, %al
callq 0x473d0
movl %eax, 0x54(%rsp)
jmp 0xb08ed
cmpl $0x16, 0x3c(%rsp)
je 0xb07f3
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x48(%rsp), %rcx
movq 0x90(%rcx), %rcx
cmpl 0x198(%rcx), %eax
jge 0xb07f1
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x1a0(%rax), %rax
movslq 0x2c(%rsp), %rcx
movl 0x4(%rax,%rcx,8), %eax
cmpl 0x3c(%rsp), %eax
jne 0xb07e2
movq 0x48(%rsp), %rdi
leaq 0x5e4a1(%rip), %rsi # 0x10ec73
movb $0x0, %al
callq 0x473d0
movl %eax, 0x54(%rsp)
jmp 0xb08ed
jmp 0xb07e4
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xb078c
jmp 0xb07f3
cmpl $0x7e, 0x38(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rsi
movl 0x1c(%rsp), %edx
movq 0x40(%rsp), %rax
movl 0x50(%rax), %r8d
movl 0x3c(%rsp), %r9d
xorl %ecx, %ecx
movl $0x1, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0xb0900
movl %eax, 0x28(%rsp)
cmpl $0x0, 0x28(%rsp)
jge 0xb085d
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0xb08ed
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
addq $0x48, %rsi
movq 0x40(%rsp), %rcx
addq $0x54, %rcx
movq 0x40(%rsp), %rax
movl 0x50(%rax), %r8d
addl $0x1, %r8d
movl $0xc, %edx
callq 0x71e80
cmpl $0x0, %eax
je 0xb089a
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0xb08ed
movq 0x40(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x40(%rsp), %rdx
movl 0x50(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x50(%rdx)
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0x26ce0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x28(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
| add_import:
sub rsp, 58h
mov [rsp+58h+var_10], rdi
mov [rsp+58h+var_18], rsi
mov [rsp+58h+var_1C], edx
mov [rsp+58h+var_20], ecx
mov rax, [rsp+58h+var_10]
mov rax, [rax]
mov [rsp+58h+var_28], rax
cmp [rsp+58h+var_1C], 4Eh ; 'N'
jz short loc_B0761
cmp [rsp+58h+var_1C], 3Bh ; ';'
jnz short loc_B077D
loc_B0761:
mov rdi, [rsp+58h+var_10]
lea rsi, aInvalidImportB; "invalid import binding"
mov al, 0
call js_parse_error
mov [rsp+58h+var_4], eax
jmp loc_B08ED
loc_B077D:
cmp [rsp+58h+var_1C], 16h
jz short loc_B07F3
mov [rsp+58h+var_2C], 0
loc_B078C:
mov eax, [rsp+58h+var_2C]
mov rcx, [rsp+58h+var_10]
mov rcx, [rcx+90h]
cmp eax, [rcx+198h]
jge short loc_B07F1
mov rax, [rsp+58h+var_10]
mov rax, [rax+90h]
mov rax, [rax+1A0h]
movsxd rcx, [rsp+58h+var_2C]
mov eax, [rax+rcx*8+4]
cmp eax, [rsp+58h+var_1C]
jnz short loc_B07E2
mov rdi, [rsp+58h+var_10]
lea rsi, aDuplicateImpor; "duplicate import binding"
mov al, 0
call js_parse_error
mov [rsp+58h+var_4], eax
jmp loc_B08ED
loc_B07E2:
jmp short $+2
loc_B07E4:
mov eax, [rsp+58h+var_2C]
add eax, 1
mov [rsp+58h+var_2C], eax
jmp short loc_B078C
loc_B07F1:
jmp short $+2
loc_B07F3:
cmp [rsp+58h+var_20], 7Eh ; '~'
setz al
and al, 1
movzx eax, al
mov [rsp+58h+var_3C], eax
mov rdi, [rsp+58h+var_28]
mov rax, [rsp+58h+var_10]
mov rsi, [rax+90h]
mov edx, [rsp+58h+var_3C]
mov rax, [rsp+58h+var_18]
mov r8d, [rax+50h]
mov r9d, [rsp+58h+var_1C]
xor ecx, ecx
mov [rsp+58h+var_58], 1
mov [rsp+58h+var_50], 1
mov [rsp+58h+var_48], 0
call add_closure_var
mov [rsp+58h+var_30], eax
cmp [rsp+58h+var_30], 0
jge short loc_B085D
mov [rsp+58h+var_4], 0FFFFFFFFh
jmp loc_B08ED
loc_B085D:
mov rdi, [rsp+58h+var_28]
mov rsi, [rsp+58h+var_18]
add rsi, 48h ; 'H'
mov rcx, [rsp+58h+var_18]
add rcx, 54h ; 'T'
mov rax, [rsp+58h+var_18]
mov r8d, [rax+50h]
add r8d, 1
mov edx, 0Ch
call js_resize_array
cmp eax, 0
jz short loc_B089A
mov [rsp+58h+var_4], 0FFFFFFFFh
jmp short loc_B08ED
loc_B089A:
mov rax, [rsp+58h+var_18]
mov rax, [rax+48h]
mov rdx, [rsp+58h+var_18]
mov ecx, [rdx+50h]
mov esi, ecx
add esi, 1
mov [rdx+50h], esi
movsxd rcx, ecx
imul rcx, 0Ch
add rax, rcx
mov [rsp+58h+var_38], rax
mov rdi, [rsp+58h+var_28]
mov esi, [rsp+58h+var_20]
call JS_DupAtom
mov ecx, eax
mov rax, [rsp+58h+var_38]
mov [rax+4], ecx
mov ecx, [rsp+58h+var_30]
mov rax, [rsp+58h+var_38]
mov [rax], ecx
mov [rsp+58h+var_4], 0
loc_B08ED:
mov eax, [rsp+58h+var_4]
add rsp, 58h
retn
| long long add_import(
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)
{
long long v14; // rax
int v15; // ecx
char v17; // [rsp+0h] [rbp-58h]
int *v18; // [rsp+20h] [rbp-38h]
int v19; // [rsp+28h] [rbp-30h]
int i; // [rsp+2Ch] [rbp-2Ch]
long long v21; // [rsp+30h] [rbp-28h]
unsigned int v22; // [rsp+38h] [rbp-20h]
v22 = a4;
v21 = *a1;
if ( (_DWORD)a3 == 78 || (_DWORD)a3 == 59 )
{
return (unsigned int)js_parse_error(
a1,
(long long)"invalid import binding",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v17);
}
else
{
if ( (_DWORD)a3 != 22 )
{
for ( i = 0; i < *(_DWORD *)(a1[18] + 408); ++i )
{
if ( *(_DWORD *)(*(_QWORD *)(a1[18] + 416) + 8LL * i + 4) == (_DWORD)a3 )
return (unsigned int)js_parse_error(
a1,
(long long)"duplicate import binding",
a3,
i,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v17);
}
}
v19 = add_closure_var(v21, a1[18], a4 == 126, 0, *(_DWORD *)(a2 + 80), a3, 1, 1, 0);
if ( v19 >= 0 )
{
if ( (unsigned int)js_resize_array(v21, a2 + 72, 0xCu, (_DWORD *)(a2 + 84), *(_DWORD *)(a2 + 80) + 1) )
{
return (unsigned int)-1;
}
else
{
v14 = *(_QWORD *)(a2 + 72);
v15 = *(_DWORD *)(a2 + 80);
*(_DWORD *)(a2 + 80) = v15 + 1;
v18 = (int *)(12LL * v15 + v14);
v18[1] = JS_DupAtom(v21, v22);
*v18 = v19;
return 0;
}
}
else
{
return (unsigned int)-1;
}
}
}
| add_import:
SUB RSP,0x58
MOV qword ptr [RSP + 0x48],RDI
MOV qword ptr [RSP + 0x40],RSI
MOV dword ptr [RSP + 0x3c],EDX
MOV dword ptr [RSP + 0x38],ECX
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x30],RAX
CMP dword ptr [RSP + 0x3c],0x4e
JZ 0x001b0761
CMP dword ptr [RSP + 0x3c],0x3b
JNZ 0x001b077d
LAB_001b0761:
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[0x20ec5c]
MOV AL,0x0
CALL 0x001473d0
MOV dword ptr [RSP + 0x54],EAX
JMP 0x001b08ed
LAB_001b077d:
CMP dword ptr [RSP + 0x3c],0x16
JZ 0x001b07f3
MOV dword ptr [RSP + 0x2c],0x0
LAB_001b078c:
MOV EAX,dword ptr [RSP + 0x2c]
MOV RCX,qword ptr [RSP + 0x48]
MOV RCX,qword ptr [RCX + 0x90]
CMP EAX,dword ptr [RCX + 0x198]
JGE 0x001b07f1
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x90]
MOV RAX,qword ptr [RAX + 0x1a0]
MOVSXD RCX,dword ptr [RSP + 0x2c]
MOV EAX,dword ptr [RAX + RCX*0x8 + 0x4]
CMP EAX,dword ptr [RSP + 0x3c]
JNZ 0x001b07e2
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[0x20ec73]
MOV AL,0x0
CALL 0x001473d0
MOV dword ptr [RSP + 0x54],EAX
JMP 0x001b08ed
LAB_001b07e2:
JMP 0x001b07e4
LAB_001b07e4:
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x001b078c
LAB_001b07f1:
JMP 0x001b07f3
LAB_001b07f3:
CMP dword ptr [RSP + 0x38],0x7e
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + 0x1c],EAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RAX + 0x90]
MOV EDX,dword ptr [RSP + 0x1c]
MOV RAX,qword ptr [RSP + 0x40]
MOV R8D,dword ptr [RAX + 0x50]
MOV R9D,dword ptr [RSP + 0x3c]
XOR ECX,ECX
MOV dword ptr [RSP],0x1
MOV dword ptr [RSP + 0x8],0x1
MOV dword ptr [RSP + 0x10],0x0
CALL 0x001b0900
MOV dword ptr [RSP + 0x28],EAX
CMP dword ptr [RSP + 0x28],0x0
JGE 0x001b085d
MOV dword ptr [RSP + 0x54],0xffffffff
JMP 0x001b08ed
LAB_001b085d:
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x40]
ADD RSI,0x48
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,0x54
MOV RAX,qword ptr [RSP + 0x40]
MOV R8D,dword ptr [RAX + 0x50]
ADD R8D,0x1
MOV EDX,0xc
CALL 0x00171e80
CMP EAX,0x0
JZ 0x001b089a
MOV dword ptr [RSP + 0x54],0xffffffff
JMP 0x001b08ed
LAB_001b089a:
MOV RAX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RAX + 0x48]
MOV RDX,qword ptr [RSP + 0x40]
MOV ECX,dword ptr [RDX + 0x50]
MOV ESI,ECX
ADD ESI,0x1
MOV dword ptr [RDX + 0x50],ESI
MOVSXD RCX,ECX
IMUL RCX,RCX,0xc
ADD RAX,RCX
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV ESI,dword ptr [RSP + 0x38]
CALL 0x00126ce0
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX + 0x4],ECX
MOV ECX,dword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x54],0x0
LAB_001b08ed:
MOV EAX,dword ptr [RSP + 0x54]
ADD RSP,0x58
RET
|
int4 add_import(int8 *param_1,long param_2,int param_3,int param_4)
{
int8 uVar1;
int4 uVar2;
int iVar3;
int iVar4;
int *piVar5;
int local_2c;
int4 local_4;
uVar1 = *param_1;
if ((param_3 == 0x4e) || (param_3 == 0x3b)) {
local_4 = js_parse_error(param_1,"invalid import binding");
}
else {
if (param_3 != 0x16) {
for (local_2c = 0; local_2c < *(int *)(param_1[0x12] + 0x198); local_2c = local_2c + 1) {
if (*(int *)(*(long *)(param_1[0x12] + 0x1a0) + 4 + (long)local_2c * 8) == param_3) {
uVar2 = js_parse_error(param_1,"duplicate import binding");
return uVar2;
}
}
}
iVar3 = add_closure_var(uVar1,param_1[0x12],param_4 == 0x7e,0,*(int4 *)(param_2 + 0x50),
param_3,1,1,0);
if (iVar3 < 0) {
local_4 = 0xffffffff;
}
else {
iVar4 = js_resize_array(uVar1,param_2 + 0x48,0xc,param_2 + 0x54,*(int *)(param_2 + 0x50) + 1);
if (iVar4 == 0) {
iVar4 = *(int *)(param_2 + 0x50);
*(int *)(param_2 + 0x50) = iVar4 + 1;
piVar5 = (int *)(*(long *)(param_2 + 0x48) + (long)iVar4 * 0xc);
iVar4 = JS_DupAtom(uVar1,param_4);
piVar5[1] = iVar4;
*piVar5 = iVar3;
local_4 = 0;
}
else {
local_4 = 0xffffffff;
}
}
}
return local_4;
}
| |
28,447 | add_import | bluesky950520[P]quickjs/quickjs.c | static int add_import(JSParseState *s, JSModuleDef *m,
JSAtom local_name, JSAtom import_name)
{
JSContext *ctx = s->ctx;
int i, var_idx;
JSImportEntry *mi;
BOOL is_local;
if (local_name == JS_ATOM_arguments || local_name == JS_ATOM_eval)
return js_parse_error(s, "invalid import binding");
if (local_name != JS_ATOM_default) {
for (i = 0; i < s->cur_func->closure_var_count; i++) {
if (s->cur_func->closure_var[i].var_name == local_name)
return js_parse_error(s, "duplicate import binding");
}
}
is_local = (import_name == JS_ATOM__star_);
var_idx = add_closure_var(ctx, s->cur_func, is_local, FALSE,
m->import_entries_count,
local_name, TRUE, TRUE, JS_VAR_NORMAL);
if (var_idx < 0)
return -1;
if (js_resize_array(ctx, (void **)&m->import_entries,
sizeof(JSImportEntry),
&m->import_entries_size,
m->import_entries_count + 1))
return -1;
mi = &m->import_entries[m->import_entries_count++];
mi->import_name = JS_DupAtom(ctx, import_name);
mi->var_idx = var_idx;
return 0;
} | O3 | c | add_import:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rsi, %r15
movq (%rdi), %r14
cmpl $0x16, %edx
je 0x6e329
movl %edx, %r9d
cmpl $0x3b, %edx
je 0x6e310
cmpl $0x4e, %r9d
jne 0x6e356
leaq 0x34903(%rip), %rsi # 0xa2c1a
xorl %eax, %eax
callq 0x2fed1
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
jmp 0x6e407
xorl %edx, %edx
cmpl $0x7e, %ebx
sete %dl
movq 0x90(%rdi), %rsi
leaq 0x50(%r15), %r13
movl 0x50(%r15), %r8d
subq $0x8, %rsp
movl $0x1, %eax
movq %r14, %rdi
xorl %ecx, %ecx
movl $0x16, %r9d
jmp 0x6e3a3
movq 0x90(%rdi), %rsi
movslq 0x198(%rsi), %rax
testq %rax, %rax
jle 0x6e385
movq 0x1a0(%rsi), %rcx
xorl %edx, %edx
cmpl %r9d, 0x4(%rcx,%rdx,8)
je 0x6e419
incq %rdx
cmpq %rdx, %rax
jne 0x6e372
xorl %edx, %edx
cmpl $0x7e, %ebx
sete %dl
leaq 0x50(%r15), %r13
movl 0x50(%r15), %r8d
subq $0x8, %rsp
movl $0x1, %eax
movq %r14, %rdi
xorl %ecx, %ecx
pushq $0x0
pushq %rax
pushq %rax
callq 0x6e44c
addq $0x20, %rsp
movl %eax, %ebp
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x6e407
movq %r13, (%rsp)
leaq 0x48(%r15), %r13
movl 0x50(%r15), %r8d
cmpl %r8d, 0x54(%r15)
jle 0x6e425
movslq %r8d, %rax
incl %r8d
leaq (%rax,%rax,2), %rax
shlq $0x2, %rax
addq (%r13), %rax
movq (%rsp), %rcx
movl %r8d, (%rcx)
cmpl $0xe0, %ebx
jl 0x6e3ff
movq 0x18(%r14), %rcx
movq 0x68(%rcx), %rcx
movl %ebx, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl %ebx, 0x4(%rax)
movl %ebp, (%rax)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x34811(%rip), %rsi # 0xa2c31
jmp 0x6e317
addq $0x54, %r15
incl %r8d
movq %r14, %rdi
movq %r13, %rsi
movl $0xc, %edx
movq %r15, %rcx
callq 0x444ee
testl %eax, %eax
jne 0x6e407
movq (%rsp), %rax
movl (%rax), %r8d
jmp 0x6e3ce
| add_import:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, ecx
mov r15, rsi
mov r14, [rdi]
cmp edx, 16h
jz short loc_6E329
mov r9d, edx
cmp edx, 3Bh ; ';'
jz short loc_6E310
cmp r9d, 4Eh ; 'N'
jnz short loc_6E356
loc_6E310:
lea rsi, aInvalidImportB; "invalid import binding"
loc_6E317:
xor eax, eax
call js_parse_error
mov r12d, 0FFFFFFFFh
jmp loc_6E407
loc_6E329:
xor edx, edx
cmp ebx, 7Eh ; '~'
setz dl
mov rsi, [rdi+90h]
lea r13, [r15+50h]
mov r8d, [r15+50h]
sub rsp, 8
mov eax, 1
mov rdi, r14
xor ecx, ecx
mov r9d, 16h
jmp short loc_6E3A3
loc_6E356:
mov rsi, [rdi+90h]
movsxd rax, dword ptr [rsi+198h]
test rax, rax
jle short loc_6E385
mov rcx, [rsi+1A0h]
xor edx, edx
loc_6E372:
cmp [rcx+rdx*8+4], r9d
jz loc_6E419
inc rdx
cmp rax, rdx
jnz short loc_6E372
loc_6E385:
xor edx, edx
cmp ebx, 7Eh ; '~'
setz dl
lea r13, [r15+50h]
mov r8d, [r15+50h]
sub rsp, 8
mov eax, 1
mov rdi, r14
xor ecx, ecx
loc_6E3A3:
push 0
push rax
push rax
call add_closure_var
add rsp, 20h
mov ebp, eax
mov r12d, 0FFFFFFFFh
test eax, eax
js short loc_6E407
mov [rsp+38h+var_38], r13
lea r13, [r15+48h]
mov r8d, [r15+50h]
cmp [r15+54h], r8d
jle short loc_6E425
loc_6E3CE:
movsxd rax, r8d
inc r8d
lea rax, [rax+rax*2]
shl rax, 2
add rax, [r13+0]
mov rcx, [rsp+38h+var_38]
mov [rcx], r8d
cmp ebx, 0E0h
jl short loc_6E3FF
mov rcx, [r14+18h]
mov rcx, [rcx+68h]
mov edx, ebx
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
loc_6E3FF:
mov [rax+4], ebx
mov [rax], ebp
xor r12d, r12d
loc_6E407:
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6E419:
lea rsi, aDuplicateImpor; "duplicate import binding"
jmp loc_6E317
loc_6E425:
add r15, 54h ; 'T'
inc r8d
mov rdi, r14
mov rsi, r13
mov edx, 0Ch
mov rcx, r15
call js_realloc_array
test eax, eax
jnz short loc_6E407
mov rax, [rsp+38h+var_38]
mov r8d, [rax]
jmp short loc_6E3CE
| long long add_import(
long long *a1,
long long a2,
long long a3,
long long a4,
long long a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13)
{
char v13; // al
int v14; // ebx
long long v16; // r14
long long v17; // r9
const char *v18; // rsi
unsigned int v19; // r12d
BOOL v20; // edx
long long v21; // rsi
int *v22; // r13
int v23; // r8d
long long v24; // rdi
long long v25; // rax
int v26; // ebp
long long *v27; // r13
int v28; // r8d
int *v29; // rax
_DWORD *v30; // rcx
char v32; // [rsp+0h] [rbp-38h]
int *v33; // [rsp+0h] [rbp-38h]
v32 = v13;
v14 = a4;
v16 = *a1;
if ( (_DWORD)a3 == 22 )
{
v20 = a4 == 126;
v21 = a1[18];
v22 = (int *)(a2 + 80);
v23 = *(_DWORD *)(a2 + 80);
v24 = *a1;
LODWORD(v17) = 22;
}
else
{
v17 = (unsigned int)a3;
if ( (_DWORD)a3 == 59 || (_DWORD)a3 == 78 )
{
v18 = "invalid import binding";
LABEL_5:
js_parse_error(a1, (long long)v18, a3, a4, a5, v17, a6, a7, a8, a9, a10, a11, a12, a13, v32);
return (unsigned int)-1;
}
v21 = a1[18];
v25 = *(int *)(v21 + 408);
if ( v25 > 0 )
{
a4 = *(_QWORD *)(v21 + 416);
a3 = 0LL;
while ( *(_DWORD *)(a4 + 8 * a3 + 4) != (_DWORD)v17 )
{
if ( v25 == ++a3 )
goto LABEL_11;
}
v18 = "duplicate import binding";
goto LABEL_5;
}
LABEL_11:
v20 = v14 == 126;
v22 = (int *)(a2 + 80);
v23 = *(_DWORD *)(a2 + 80);
v24 = *a1;
}
v26 = add_closure_var(v24, v21, v20, 0, v23, v17, 1, 1, 0);
v19 = -1;
if ( v26 >= 0 )
{
v33 = v22;
v27 = (long long *)(a2 + 72);
v28 = *(_DWORD *)(a2 + 80);
if ( *(_DWORD *)(a2 + 84) <= v28 )
{
if ( (unsigned int)js_realloc_array(v16, v27, 0xCu, (_DWORD *)(a2 + 84), v28 + 1) )
return v19;
v28 = *v33;
}
v29 = (int *)(*v27 + 12LL * v28);
*v33 = v28 + 1;
if ( v14 >= 224 )
{
v30 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(v16 + 24) + 104LL) + 8LL * (unsigned int)v14);
++*v30;
}
v29[1] = v14;
*v29 = v26;
return 0;
}
return v19;
}
| add_import:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,ECX
MOV R15,RSI
MOV R14,qword ptr [RDI]
CMP EDX,0x16
JZ 0x0016e329
MOV R9D,EDX
CMP EDX,0x3b
JZ 0x0016e310
CMP R9D,0x4e
JNZ 0x0016e356
LAB_0016e310:
LEA RSI,[0x1a2c1a]
LAB_0016e317:
XOR EAX,EAX
CALL 0x0012fed1
MOV R12D,0xffffffff
JMP 0x0016e407
LAB_0016e329:
XOR EDX,EDX
CMP EBX,0x7e
SETZ DL
MOV RSI,qword ptr [RDI + 0x90]
LEA R13,[R15 + 0x50]
MOV R8D,dword ptr [R15 + 0x50]
SUB RSP,0x8
MOV EAX,0x1
MOV RDI,R14
XOR ECX,ECX
MOV R9D,0x16
JMP 0x0016e3a3
LAB_0016e356:
MOV RSI,qword ptr [RDI + 0x90]
MOVSXD RAX,dword ptr [RSI + 0x198]
TEST RAX,RAX
JLE 0x0016e385
MOV RCX,qword ptr [RSI + 0x1a0]
XOR EDX,EDX
LAB_0016e372:
CMP dword ptr [RCX + RDX*0x8 + 0x4],R9D
JZ 0x0016e419
INC RDX
CMP RAX,RDX
JNZ 0x0016e372
LAB_0016e385:
XOR EDX,EDX
CMP EBX,0x7e
SETZ DL
LEA R13,[R15 + 0x50]
MOV R8D,dword ptr [R15 + 0x50]
SUB RSP,0x8
MOV EAX,0x1
MOV RDI,R14
XOR ECX,ECX
LAB_0016e3a3:
PUSH 0x0
PUSH RAX
PUSH RAX
CALL 0x0016e44c
ADD RSP,0x20
MOV EBP,EAX
MOV R12D,0xffffffff
TEST EAX,EAX
JS 0x0016e407
MOV qword ptr [RSP],R13
LEA R13,[R15 + 0x48]
MOV R8D,dword ptr [R15 + 0x50]
CMP dword ptr [R15 + 0x54],R8D
JLE 0x0016e425
LAB_0016e3ce:
MOVSXD RAX,R8D
INC R8D
LEA RAX,[RAX + RAX*0x2]
SHL RAX,0x2
ADD RAX,qword ptr [R13]
MOV RCX,qword ptr [RSP]
MOV dword ptr [RCX],R8D
CMP EBX,0xe0
JL 0x0016e3ff
MOV RCX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV EDX,EBX
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
LAB_0016e3ff:
MOV dword ptr [RAX + 0x4],EBX
MOV dword ptr [RAX],EBP
XOR R12D,R12D
LAB_0016e407:
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016e419:
LEA RSI,[0x1a2c31]
JMP 0x0016e317
LAB_0016e425:
ADD R15,0x54
INC R8D
MOV RDI,R14
MOV RSI,R13
MOV EDX,0xc
MOV RCX,R15
CALL 0x001444ee
TEST EAX,EAX
JNZ 0x0016e407
MOV RAX,qword ptr [RSP]
MOV R8D,dword ptr [RAX]
JMP 0x0016e3ce
|
int8 add_import(long *param_1,long param_2,int param_3,uint param_4)
{
int4 uVar1;
long lVar2;
int *piVar3;
int iVar4;
int iVar5;
int *piVar6;
long lVar7;
char *pcVar8;
long lVar9;
int8 uVar10;
lVar2 = *param_1;
if (param_3 == 0x16) {
lVar9 = param_1[0x12];
uVar1 = *(int4 *)(param_2 + 0x50);
param_3 = 0x16;
}
else {
if ((param_3 == 0x3b) || (param_3 == 0x4e)) {
pcVar8 = "invalid import binding";
LAB_0016e317:
js_parse_error(param_1,pcVar8);
return 0xffffffff;
}
lVar9 = param_1[0x12];
if (0 < (long)*(int *)(lVar9 + 0x198)) {
lVar7 = 0;
do {
if (*(int *)(*(long *)(lVar9 + 0x1a0) + 4 + lVar7 * 8) == param_3) {
pcVar8 = "duplicate import binding";
goto LAB_0016e317;
}
lVar7 = lVar7 + 1;
} while (*(int *)(lVar9 + 0x198) != lVar7);
}
uVar1 = *(int4 *)(param_2 + 0x50);
}
iVar4 = add_closure_var(lVar2,lVar9,param_4 == 0x7e,0,uVar1,param_3,1,1,0);
uVar10 = 0xffffffff;
if (-1 < iVar4) {
iVar5 = *(int *)(param_2 + 0x50);
if (*(int *)(param_2 + 0x54) <= iVar5) {
iVar5 = js_realloc_array(lVar2,(long *)(param_2 + 0x48),0xc,param_2 + 0x54,iVar5 + 1);
if (iVar5 != 0) {
return 0xffffffff;
}
iVar5 = *(int *)(param_2 + 0x50);
}
piVar6 = (int *)((long)iVar5 * 0xc + *(long *)(param_2 + 0x48));
*(int *)(param_2 + 0x50) = iVar5 + 1;
if (0xdf < (int)param_4) {
piVar3 = *(int **)(*(long *)(*(long *)(lVar2 + 0x18) + 0x68) + (ulong)param_4 * 8);
*piVar3 = *piVar3 + 1;
}
piVar6[1] = param_4;
*piVar6 = iVar4;
uVar10 = 0;
}
return uVar10;
}
| |
28,448 | lunasvg::SVGTextPositioningElement::layoutElement(lunasvg::SVGLayoutState const&) | dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp | void SVGTextPositioningElement::layoutElement(const SVGLayoutState& state)
{
m_font = state.font();
m_fill = getPaintServer(state.fill(), state.fill_opacity());
m_stroke = getPaintServer(state.stroke(), state.stroke_opacity());
SVGGraphicsElement::layoutElement(state);
LengthContext lengthContext(this);
m_stroke_width = lengthContext.valueForLength(state.stroke_width(), LengthDirection::Diagonal);
m_baseline_offset = convertBaselineOffset(state.baseline_shit());
m_alignment_baseline = state.alignment_baseline();
m_dominant_baseline = state.dominant_baseline();
m_text_anchor = state.text_anchor();
m_white_space = state.white_space();
m_direction = state.direction();
} | O1 | cpp | lunasvg::SVGTextPositioningElement::layoutElement(lunasvg::SVGLayoutState const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x16c3c
leaq 0x188(%rbx), %rdi
movq %r15, %rsi
callq 0xd47c
movq %rsp, %r15
movss 0x8(%r15), %xmm0
movss %xmm0, 0x190(%rbx)
movq %r15, %rdi
callq 0xd436
leaq 0x10(%r14), %rsi
movss 0x6c(%r14), %xmm0
movq %rbx, %rdi
callq 0x103c8
movq %rax, 0x198(%rbx)
movq %rdx, 0x1a0(%rbx)
leaq 0x38(%r14), %rsi
movss 0x70(%r14), %xmm0
movq %rbx, %rdi
callq 0x103c8
movq %rax, 0x1a8(%rbx)
movq %rdx, 0x1b0(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfe66
movq %rbx, (%r15)
movb $0x0, 0x8(%r15)
leaq 0x8c(%r14), %rsi
movq %rsp, %rdi
movl $0x2, %edx
callq 0x1f7ea
movss %xmm0, 0x1b8(%rbx)
leaq 0x80(%r14), %rsi
movq %rbx, %rdi
callq 0x22214
movss %xmm0, 0x1bc(%rbx)
movb 0xbe(%r14), %al
movb %al, 0x1c0(%rbx)
movb 0xbf(%r14), %al
movb %al, 0x1c1(%rbx)
movb 0xc0(%r14), %al
movb %al, 0x1c2(%rbx)
movb 0xc1(%r14), %al
movb %al, 0x1c3(%rbx)
movb 0xc2(%r14), %al
movb %al, 0x1c4(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd436
movq %rbx, %rdi
callq 0xa5c0
| _ZN7lunasvg25SVGTextPositioningElement13layoutElementERKNS_14SVGLayoutStateE:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
mov r15, rsp
mov rdi, r15; this
call _ZNK7lunasvg14SVGLayoutState4fontEv; lunasvg::SVGLayoutState::font(void)
lea rdi, [rbx+188h]
mov rsi, r15
call _ZN7lunasvg8FontFaceaSEOS0_; lunasvg::FontFace::operator=(lunasvg::FontFace&&)
mov r15, rsp
movss xmm0, dword ptr [r15+8]
movss dword ptr [rbx+190h], xmm0
mov rdi, r15; this
call _ZN7lunasvg8FontFaceD2Ev; lunasvg::FontFace::~FontFace()
lea rsi, [r14+10h]
movss xmm0, dword ptr [r14+6Ch]
mov rdi, rbx
call _ZNK7lunasvg18SVGGraphicsElement14getPaintServerERKNS_5PaintEf; lunasvg::SVGGraphicsElement::getPaintServer(lunasvg::Paint const&,float)
mov [rbx+198h], rax
mov [rbx+1A0h], rdx
lea rsi, [r14+38h]
movss xmm0, dword ptr [r14+70h]
mov rdi, rbx
call _ZNK7lunasvg18SVGGraphicsElement14getPaintServerERKNS_5PaintEf; lunasvg::SVGGraphicsElement::getPaintServer(lunasvg::Paint const&,float)
mov [rbx+1A8h], rax
mov [rbx+1B0h], rdx
mov rdi, rbx; this
mov rsi, r14; lunasvg::SVGLayoutState *
call _ZN7lunasvg10SVGElement13layoutElementERKNS_14SVGLayoutStateE; lunasvg::SVGElement::layoutElement(lunasvg::SVGLayoutState const&)
mov [r15], rbx
mov byte ptr [r15+8], 0
lea rsi, [r14+8Ch]
mov rdi, rsp
mov edx, 2
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_6LengthENS_15LengthDirectionE; lunasvg::LengthContext::valueForLength(lunasvg::Length const&,lunasvg::LengthDirection)
movss dword ptr [rbx+1B8h], xmm0
lea rsi, [r14+80h]
mov rdi, rbx
call _ZNK7lunasvg25SVGTextPositioningElement21convertBaselineOffsetERKNS_13BaselineShiftE; lunasvg::SVGTextPositioningElement::convertBaselineOffset(lunasvg::BaselineShift const&)
movss dword ptr [rbx+1BCh], xmm0
mov al, [r14+0BEh]
mov [rbx+1C0h], al
mov al, [r14+0BFh]
mov [rbx+1C1h], al
mov al, [r14+0C0h]
mov [rbx+1C2h], al
mov al, [r14+0C1h]
mov [rbx+1C3h], al
mov al, [r14+0C2h]
mov [rbx+1C4h], al
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN7lunasvg8FontFaceD2Ev; lunasvg::FontFace::~FontFace()
mov rdi, rbx
call __Unwind_Resume
| char lunasvg::SVGTextPositioningElement::layoutElement(
lunasvg::SVGTextPositioningElement *this,
const lunasvg::SVGLayoutState *a2,
long long a3,
long long a4)
{
long long v4; // rdx
long long v5; // rdx
char result; // al
lunasvg::SVGTextPositioningElement *v7; // [rsp+0h] [rbp-28h] BYREF
int v8; // [rsp+8h] [rbp-20h]
lunasvg::SVGLayoutState::font((lunasvg::SVGLayoutState *)&v7, (long long)a2, a3, a4);
lunasvg::FontFace::operator=((long long *)this + 49, (long long *)&v7);
*((_DWORD *)this + 100) = v8;
lunasvg::FontFace::~FontFace((lunasvg::FontFace *)&v7);
*((_QWORD *)this + 51) = lunasvg::SVGGraphicsElement::getPaintServer((long long)this, (long long)a2 + 16);
*((_QWORD *)this + 52) = v4;
*((_QWORD *)this + 53) = lunasvg::SVGGraphicsElement::getPaintServer((long long)this, (long long)a2 + 56);
*((_QWORD *)this + 54) = v5;
lunasvg::SVGElement::layoutElement(this, a2);
v7 = this;
LOBYTE(v8) = 0;
*((float *)this + 110) = lunasvg::LengthContext::valueForLength(&v7, (unsigned __int8 *)a2 + 140, 2);
*((float *)this + 111) = lunasvg::SVGTextPositioningElement::convertBaselineOffset(this, (char *)a2 + 128);
*((_BYTE *)this + 448) = *((_BYTE *)a2 + 190);
*((_BYTE *)this + 449) = *((_BYTE *)a2 + 191);
*((_BYTE *)this + 450) = *((_BYTE *)a2 + 192);
*((_BYTE *)this + 451) = *((_BYTE *)a2 + 193);
result = *((_BYTE *)a2 + 194);
*((_BYTE *)this + 452) = result;
return result;
}
| layoutElement:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
MOV R15,RSP
MOV RDI,R15
CALL 0x00116c3c
LEA RDI,[RBX + 0x188]
LAB_0012210f:
MOV RSI,R15
CALL 0x0010d47c
LAB_00122117:
MOV R15,RSP
MOVSS XMM0,dword ptr [R15 + 0x8]
MOVSS dword ptr [RBX + 0x190],XMM0
MOV RDI,R15
CALL 0x0010d436
LEA RSI,[R14 + 0x10]
MOVSS XMM0,dword ptr [R14 + 0x6c]
MOV RDI,RBX
CALL 0x001103c8
MOV qword ptr [RBX + 0x198],RAX
MOV qword ptr [RBX + 0x1a0],RDX
LEA RSI,[R14 + 0x38]
MOVSS XMM0,dword ptr [R14 + 0x70]
MOV RDI,RBX
CALL 0x001103c8
MOV qword ptr [RBX + 0x1a8],RAX
MOV qword ptr [RBX + 0x1b0],RDX
MOV RDI,RBX
MOV RSI,R14
CALL 0x0010fe66
MOV qword ptr [R15],RBX
MOV byte ptr [R15 + 0x8],0x0
LEA RSI,[R14 + 0x8c]
MOV RDI,RSP
MOV EDX,0x2
CALL 0x0011f7ea
MOVSS dword ptr [RBX + 0x1b8],XMM0
LEA RSI,[R14 + 0x80]
MOV RDI,RBX
CALL 0x00122214
MOVSS dword ptr [RBX + 0x1bc],XMM0
MOV AL,byte ptr [R14 + 0xbe]
MOV byte ptr [RBX + 0x1c0],AL
MOV AL,byte ptr [R14 + 0xbf]
MOV byte ptr [RBX + 0x1c1],AL
MOV AL,byte ptr [R14 + 0xc0]
MOV byte ptr [RBX + 0x1c2],AL
MOV AL,byte ptr [R14 + 0xc1]
MOV byte ptr [RBX + 0x1c3],AL
MOV AL,byte ptr [R14 + 0xc2]
MOV byte ptr [RBX + 0x1c4],AL
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* lunasvg::SVGTextPositioningElement::layoutElement(lunasvg::SVGLayoutState const&) */
void __thiscall
lunasvg::SVGTextPositioningElement::layoutElement
(SVGTextPositioningElement *this,SVGLayoutState *param_1)
{
int8 uVar1;
int8 extraout_RDX;
int8 extraout_RDX_00;
int4 uVar2;
SVGTextPositioningElement *local_28;
uint local_20;
SVGLayoutState::font();
/* try { // try from 0012210f to 00122116 has its CatchHandler @ 00122201 */
FontFace::operator=((FontFace *)(this + 0x188),(FontFace *)&local_28);
*(uint *)(this + 400) = local_20;
FontFace::~FontFace((FontFace *)&local_28);
uVar1 = SVGGraphicsElement::getPaintServer
((SVGGraphicsElement *)this,(Paint *)(param_1 + 0x10),*(float *)(param_1 + 0x6c)
);
*(int8 *)(this + 0x198) = uVar1;
*(int8 *)(this + 0x1a0) = extraout_RDX;
uVar1 = SVGGraphicsElement::getPaintServer
((SVGGraphicsElement *)this,(Paint *)(param_1 + 0x38),*(float *)(param_1 + 0x70)
);
*(int8 *)(this + 0x1a8) = uVar1;
*(int8 *)(this + 0x1b0) = extraout_RDX_00;
SVGElement::layoutElement((SVGElement *)this,param_1);
local_20 = local_20 & 0xffffff00;
local_28 = this;
uVar2 = LengthContext::valueForLength((LengthContext *)&local_28,param_1 + 0x8c,2);
*(int4 *)(this + 0x1b8) = uVar2;
uVar2 = convertBaselineOffset(this,(BaselineShift *)(param_1 + 0x80));
*(int4 *)(this + 0x1bc) = uVar2;
*(SVGLayoutState *)(this + 0x1c0) = param_1[0xbe];
*(SVGLayoutState *)(this + 0x1c1) = param_1[0xbf];
*(SVGLayoutState *)(this + 0x1c2) = param_1[0xc0];
*(SVGLayoutState *)(this + 0x1c3) = param_1[0xc1];
*(SVGLayoutState *)(this + 0x1c4) = param_1[0xc2];
return;
}
| |
28,449 | lunasvg::SVGTextPositioningElement::layoutElement(lunasvg::SVGLayoutState const&) | dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp | void SVGTextPositioningElement::layoutElement(const SVGLayoutState& state)
{
m_font = state.font();
m_fill = getPaintServer(state.fill(), state.fill_opacity());
m_stroke = getPaintServer(state.stroke(), state.stroke_opacity());
SVGGraphicsElement::layoutElement(state);
LengthContext lengthContext(this);
m_stroke_width = lengthContext.valueForLength(state.stroke_width(), LengthDirection::Diagonal);
m_baseline_offset = convertBaselineOffset(state.baseline_shit());
m_alignment_baseline = state.alignment_baseline();
m_dominant_baseline = state.dominant_baseline();
m_text_anchor = state.text_anchor();
m_white_space = state.white_space();
m_direction = state.direction();
} | O3 | cpp | lunasvg::SVGTextPositioningElement::layoutElement(lunasvg::SVGLayoutState const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x1651c
leaq 0x188(%rbx), %rdi
movq %r15, %rsi
callq 0xd316
movq %rsp, %r15
movss 0x8(%r15), %xmm0
movss %xmm0, 0x190(%rbx)
movq %r15, %rdi
callq 0xd2d0
leaq 0x10(%r14), %rsi
movss 0x6c(%r14), %xmm0
movq %rbx, %rdi
callq 0x10144
movq %rax, 0x198(%rbx)
movq %rdx, 0x1a0(%rbx)
leaq 0x38(%r14), %rsi
movss 0x70(%r14), %xmm0
movq %rbx, %rdi
callq 0x10144
movq %rax, 0x1a8(%rbx)
movq %rdx, 0x1b0(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfc10
movq %rbx, (%r15)
movb $0x0, 0x8(%r15)
leaq 0x8c(%r14), %rsi
movq %rsp, %rdi
movl $0x2, %edx
callq 0x1f696
movss %xmm0, 0x1b8(%rbx)
leaq 0x80(%r14), %rsi
movq %rbx, %rdi
callq 0x22212
movss %xmm0, 0x1bc(%rbx)
movl 0xbe(%r14), %eax
movl %eax, 0x1c0(%rbx)
movb 0xc2(%r14), %al
movb %al, 0x1c4(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd2d0
movq %rbx, %rdi
callq 0xa580
nop
| _ZN7lunasvg25SVGTextPositioningElement13layoutElementERKNS_14SVGLayoutStateE:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
mov r15, rsp
mov rdi, r15; this
call _ZNK7lunasvg14SVGLayoutState4fontEv; lunasvg::SVGLayoutState::font(void)
lea rdi, [rbx+188h]
mov rsi, r15
call _ZN7lunasvg8FontFaceaSEOS0_; lunasvg::FontFace::operator=(lunasvg::FontFace&&)
mov r15, rsp
movss xmm0, dword ptr [r15+8]
movss dword ptr [rbx+190h], xmm0
mov rdi, r15; this
call _ZN7lunasvg8FontFaceD2Ev; lunasvg::FontFace::~FontFace()
lea rsi, [r14+10h]
movss xmm0, dword ptr [r14+6Ch]
mov rdi, rbx
call _ZNK7lunasvg18SVGGraphicsElement14getPaintServerERKNS_5PaintEf; lunasvg::SVGGraphicsElement::getPaintServer(lunasvg::Paint const&,float)
mov [rbx+198h], rax
mov [rbx+1A0h], rdx
lea rsi, [r14+38h]
movss xmm0, dword ptr [r14+70h]
mov rdi, rbx
call _ZNK7lunasvg18SVGGraphicsElement14getPaintServerERKNS_5PaintEf; lunasvg::SVGGraphicsElement::getPaintServer(lunasvg::Paint const&,float)
mov [rbx+1A8h], rax
mov [rbx+1B0h], rdx
mov rdi, rbx; this
mov rsi, r14; lunasvg::SVGLayoutState *
call _ZN7lunasvg10SVGElement13layoutElementERKNS_14SVGLayoutStateE; lunasvg::SVGElement::layoutElement(lunasvg::SVGLayoutState const&)
mov [r15], rbx
mov byte ptr [r15+8], 0
lea rsi, [r14+8Ch]
mov rdi, rsp
mov edx, 2
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_6LengthENS_15LengthDirectionE; lunasvg::LengthContext::valueForLength(lunasvg::Length const&,lunasvg::LengthDirection)
movss dword ptr [rbx+1B8h], xmm0
lea rsi, [r14+80h]
mov rdi, rbx
call _ZNK7lunasvg25SVGTextPositioningElement21convertBaselineOffsetERKNS_13BaselineShiftE; lunasvg::SVGTextPositioningElement::convertBaselineOffset(lunasvg::BaselineShift const&)
movss dword ptr [rbx+1BCh], xmm0
mov eax, [r14+0BEh]
mov [rbx+1C0h], eax
mov al, [r14+0C2h]
mov [rbx+1C4h], al
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN7lunasvg8FontFaceD2Ev; lunasvg::FontFace::~FontFace()
mov rdi, rbx
call __Unwind_Resume
| char lunasvg::SVGTextPositioningElement::layoutElement(
lunasvg::SVGTextPositioningElement *this,
const lunasvg::SVGLayoutState *a2)
{
long long v2; // rdx
long long v3; // rdx
char result; // al
lunasvg::SVGTextPositioningElement *v5; // [rsp+0h] [rbp-28h] BYREF
int v6; // [rsp+8h] [rbp-20h]
lunasvg::SVGLayoutState::font((lunasvg::SVGLayoutState *)&v5, (long long)a2);
lunasvg::FontFace::operator=((long long *)this + 49, (long long *)&v5);
*((_DWORD *)this + 100) = v6;
lunasvg::FontFace::~FontFace((lunasvg::FontFace *)&v5);
*((_QWORD *)this + 51) = lunasvg::SVGGraphicsElement::getPaintServer((long long)this, (long long)a2 + 16);
*((_QWORD *)this + 52) = v2;
*((_QWORD *)this + 53) = lunasvg::SVGGraphicsElement::getPaintServer((long long)this, (long long)a2 + 56);
*((_QWORD *)this + 54) = v3;
lunasvg::SVGElement::layoutElement(this, a2);
v5 = this;
LOBYTE(v6) = 0;
*((float *)this + 110) = lunasvg::LengthContext::valueForLength(&v5, (unsigned __int8 *)a2 + 140, 2);
*((float *)this + 111) = lunasvg::SVGTextPositioningElement::convertBaselineOffset(this, (char *)a2 + 128);
*((_DWORD *)this + 112) = *(_DWORD *)((char *)a2 + 190);
result = *((_BYTE *)a2 + 194);
*((_BYTE *)this + 452) = result;
return result;
}
| layoutElement:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
MOV R15,RSP
MOV RDI,R15
CALL 0x0011651c
LEA RDI,[RBX + 0x188]
LAB_00122133:
MOV RSI,R15
CALL 0x0010d316
LAB_0012213b:
MOV R15,RSP
MOVSS XMM0,dword ptr [R15 + 0x8]
MOVSS dword ptr [RBX + 0x190],XMM0
MOV RDI,R15
CALL 0x0010d2d0
LEA RSI,[R14 + 0x10]
MOVSS XMM0,dword ptr [R14 + 0x6c]
MOV RDI,RBX
CALL 0x00110144
MOV qword ptr [RBX + 0x198],RAX
MOV qword ptr [RBX + 0x1a0],RDX
LEA RSI,[R14 + 0x38]
MOVSS XMM0,dword ptr [R14 + 0x70]
MOV RDI,RBX
CALL 0x00110144
MOV qword ptr [RBX + 0x1a8],RAX
MOV qword ptr [RBX + 0x1b0],RDX
MOV RDI,RBX
MOV RSI,R14
CALL 0x0010fc10
MOV qword ptr [R15],RBX
MOV byte ptr [R15 + 0x8],0x0
LEA RSI,[R14 + 0x8c]
MOV RDI,RSP
MOV EDX,0x2
CALL 0x0011f696
MOVSS dword ptr [RBX + 0x1b8],XMM0
LEA RSI,[R14 + 0x80]
MOV RDI,RBX
CALL 0x00122212
MOVSS dword ptr [RBX + 0x1bc],XMM0
MOV EAX,dword ptr [R14 + 0xbe]
MOV dword ptr [RBX + 0x1c0],EAX
MOV AL,byte ptr [R14 + 0xc2]
MOV byte ptr [RBX + 0x1c4],AL
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* lunasvg::SVGTextPositioningElement::layoutElement(lunasvg::SVGLayoutState const&) */
void __thiscall
lunasvg::SVGTextPositioningElement::layoutElement
(SVGTextPositioningElement *this,SVGLayoutState *param_1)
{
int4 uVar1;
int1 auVar2 [16];
SVGTextPositioningElement *local_28;
uint local_20;
SVGLayoutState::font();
/* try { // try from 00122133 to 0012213a has its CatchHandler @ 001221fe */
FontFace::operator=((FontFace *)(this + 0x188),(FontFace *)&local_28);
*(uint *)(this + 400) = local_20;
FontFace::~FontFace((FontFace *)&local_28);
auVar2 = SVGGraphicsElement::getPaintServer
((SVGGraphicsElement *)this,(Paint *)(param_1 + 0x10),
*(float *)(param_1 + 0x6c));
*(int1 (*) [16])(this + 0x198) = auVar2;
auVar2 = SVGGraphicsElement::getPaintServer
((SVGGraphicsElement *)this,(Paint *)(param_1 + 0x38),
*(float *)(param_1 + 0x70));
*(int1 (*) [16])(this + 0x1a8) = auVar2;
SVGElement::layoutElement((SVGElement *)this,param_1);
local_20 = local_20 & 0xffffff00;
local_28 = this;
uVar1 = LengthContext::valueForLength((LengthContext *)&local_28,param_1 + 0x8c,2);
*(int4 *)(this + 0x1b8) = uVar1;
uVar1 = convertBaselineOffset(this,(BaselineShift *)(param_1 + 0x80));
*(int4 *)(this + 0x1bc) = uVar1;
*(int4 *)(this + 0x1c0) = *(int4 *)(param_1 + 0xbe);
*(SVGLayoutState *)(this + 0x1c4) = param_1[0xc2];
return;
}
| |
28,450 | my_mb_wc_cp932 | eloqsql/strings/ctype-cp932.c | static int
my_mb_wc_cp932(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e){
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII: [00-7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
/* JIS-X-0201 Half width Katakana: [A1..DF] -> [U+FF61..U+FF9F] */
if (hi >= 0xA1 && hi <= 0xDF)
{
*pwc= cp932_to_unicode[hi];
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
/* JIS-X-0208-MS [81..9F,E0..FC][40..7E,80..FC] */
if (!(pwc[0]= cp932_to_unicode[(hi << 8) + s[1]]))
return (iscp932head(hi) && iscp932tail(s[1])) ? -2 : MY_CS_ILSEQ;
return 2;
} | O3 | c | my_mb_wc_cp932:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xac763
movzbl (%rdx), %edi
testb %dil, %dil
js 0xac749
movq %rdi, (%rsi)
jmp 0xac75e
leal 0x5f(%rdi), %eax
cmpb $0x3e, %al
ja 0xac765
leaq 0x4df59(%rip), %rax # 0xfa6b0
movzwl (%rax,%rdi,2), %eax
movq %rax, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0xac763
movzbl 0x1(%rdx), %eax
movl %edi, %ecx
shll $0x9, %ecx
leal (%rcx,%rax,2), %eax
leaq 0x4df2a(%rip), %rcx # 0xfa6b0
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0xac763
cmpb $-0x80, %dil
setne %al
cmpb $-0x60, %dil
setb %cl
andb %al, %cl
addb $0x20, %dil
cmpb $0x1d, %dil
setb %sil
orb %cl, %sil
xorl %eax, %eax
cmpb $0x1, %sil
jne 0xac763
movb 0x1(%rdx), %cl
leal -0x40(%rcx), %edx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpb $0x3f, %dl
jb 0xac763
movl $0x0, %eax
testb %cl, %cl
jns 0xac763
xorl %eax, %eax
cmpb $-0x3, %cl
setae %al
leal -0x2(,%rax,2), %eax
jmp 0xac763
| my_mb_wc_cp932:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_AC763
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_AC749
mov [rsi], rdi
jmp short loc_AC75E
loc_AC749:
lea eax, [rdi+5Fh]
cmp al, 3Eh ; '>'
ja short loc_AC765
lea rax, cp932_to_unicode
movzx eax, word ptr [rax+rdi*2]
mov [rsi], rax
loc_AC75E:
mov eax, 1
loc_AC763:
pop rbp
retn
loc_AC765:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_AC763
movzx eax, byte ptr [rdx+1]
mov ecx, edi
shl ecx, 9
lea eax, [rcx+rax*2]
lea rcx, cp932_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_AC763
cmp dil, 80h
setnz al
cmp dil, 0A0h
setb cl
and cl, al
add dil, 20h ; ' '
cmp dil, 1Dh
setb sil
or sil, cl
xor eax, eax
cmp sil, 1
jnz short loc_AC763
mov cl, [rdx+1]
lea edx, [rcx-40h]
mov eax, 0FFFFFFFEh
cmp dl, 3Fh ; '?'
jb short loc_AC763
mov eax, 0
test cl, cl
jns short loc_AC763
xor eax, eax
cmp cl, 0FDh
setnb al
lea eax, ds:0FFFFFFFFFFFFFFFEh[rax*2]
jmp loc_AC763
| long long my_mb_wc_cp932(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
char v7; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x3Eu )
{
*a2 = cp932_to_unicode[v5];
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = cp932_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
{
result = 0LL;
if ( (_BYTE)v5 != 0x80 && (unsigned __int8)v5 < 0xA0u || (unsigned __int8)(v5 + 32) < 0x1Du )
{
v7 = a3[1];
result = 4294967294LL;
if ( (unsigned __int8)(v7 - 64) >= 0x3Fu )
{
result = 0LL;
if ( v7 < 0 )
return 2 * (unsigned int)((unsigned __int8)v7 >= 0xFDu) - 2;
}
}
}
}
}
return result;
}
| my_mb_wc_cp932:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001ac763
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x001ac749
MOV qword ptr [RSI],RDI
JMP 0x001ac75e
LAB_001ac749:
LEA EAX,[RDI + 0x5f]
CMP AL,0x3e
JA 0x001ac765
LEA RAX,[0x1fa6b0]
MOVZX EAX,word ptr [RAX + RDI*0x2]
MOV qword ptr [RSI],RAX
LAB_001ac75e:
MOV EAX,0x1
LAB_001ac763:
POP RBP
RET
LAB_001ac765:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001ac763
MOVZX EAX,byte ptr [RDX + 0x1]
MOV ECX,EDI
SHL ECX,0x9
LEA EAX,[RCX + RAX*0x2]
LEA RCX,[0x1fa6b0]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x001ac763
CMP DIL,0x80
SETNZ AL
CMP DIL,0xa0
SETC CL
AND CL,AL
ADD DIL,0x20
CMP DIL,0x1d
SETC SIL
OR SIL,CL
XOR EAX,EAX
CMP SIL,0x1
JNZ 0x001ac763
MOV CL,byte ptr [RDX + 0x1]
LEA EDX,[RCX + -0x40]
MOV EAX,0xfffffffe
CMP DL,0x3f
JC 0x001ac763
MOV EAX,0x0
TEST CL,CL
JNS 0x001ac763
XOR EAX,EAX
CMP CL,0xfd
SETNC AL
LEA EAX,[-0x2 + RAX*0x2]
JMP 0x001ac763
|
int my_mb_wc_cp932(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if (0x3e < (byte)(bVar1 + 0x5f)) {
if (param_4 < param_3 + 2) {
return -0x66;
}
uVar2 = *(ushort *)(cp932_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 2;
}
if (0x1c < (byte)(bVar1 + 0x20) && (0x9f < bVar1 || bVar1 == 0x80)) {
return 0;
}
bVar1 = param_3[1];
if ((byte)(bVar1 - 0x40) < 0x3f) {
return -2;
}
if (-1 < (char)bVar1) {
return 0;
}
return (uint)(0xfc < bVar1) * 2 + -2;
}
*param_2 = (ulong)*(ushort *)(cp932_to_unicode + (ulong)bVar1 * 2);
}
else {
*param_2 = (ulong)bVar1;
}
iVar3 = 1;
}
return iVar3;
}
| |
28,451 | SchemaConverter::_resolve_ref(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/json-schema-to-grammar.cpp | std::string _resolve_ref(const std::string & ref) {
std::string ref_name = ref.substr(ref.find_last_of('/') + 1);
if (_rules.find(ref_name) == _rules.end() && _refs_being_resolved.find(ref) == _refs_being_resolved.end()) {
_refs_being_resolved.insert(ref);
json resolved = _refs[ref];
ref_name = visit(resolved, ref_name);
_refs_being_resolved.erase(ref);
}
return ref_name;
} | O2 | cpp | SchemaConverter::_resolve_ref(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x2f
popq %rsi
pushq $-0x1
popq %r12
movq %rdx, %rdi
movq %r12, %rdx
callq 0x27900
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x26ce0
leaq 0x28(%r15), %rdi
movq %rbx, %rsi
callq 0xaac0e
leaq 0x30(%r15), %rcx
cmpq %rcx, %rax
jne 0xacba4
leaq 0x90(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xade72
testq %rax, %rax
jne 0xacba4
movq %r12, %rdi
movq %r14, %rsi
callq 0xa557e
leaq 0x58(%r15), %rdi
movq %r14, %rsi
callq 0xadea0
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x69b80
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r15, %rsi
movq %rbx, %rcx
callq 0xaad94
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26f10
movq %r15, %rdi
callq 0x27998
movq %r12, %rdi
movq %r14, %rsi
callq 0xae29e
leaq 0x8(%rsp), %rdi
callq 0x651aa
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xacbb5
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x651aa
jmp 0xacbcd
jmp 0xacbca
jmp 0xacbca
jmp 0xacbca
movq %rax, %r14
movq %rbx, %rdi
callq 0x27998
movq %r14, %rdi
callq 0x27660
nop
| _ZN15SchemaConverter12_resolve_refERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r12
push rbx
sub rsp, 38h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
push 2Fh ; '/'
pop rsi
push 0FFFFFFFFFFFFFFFFh
pop r12
mov rdi, rdx
mov rdx, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5rfindEcm; std::string::rfind(char,ulong)
lea rdx, [rax+1]
mov rdi, rbx
mov rsi, r14
mov rcx, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rdi, [r15+28h]
mov rsi, rbx
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&)
lea rcx, [r15+30h]
cmp rax, rcx
jnz short loc_ACBA4
lea r12, [r15+90h]
mov rdi, r12
mov rsi, r14
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEE4findERKS5_; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,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,true,true>>::find(std::string const&)
test rax, rax
jnz short loc_ACBA4
mov rdi, r12
mov rsi, r14
call _ZNSt8__detail12_Insert_baseINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_SaIS6_ENS_9_IdentityESt8equal_toIS6_ESt4hashIS6_ENS_18_Mod_range_hashingENS_20_Default_ranged_hashENS_20_Prime_rehash_policyENS_17_Hashtable_traitsILb1ELb1ELb1EEEE6insertERKS6_; std::__detail::_Insert_base<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,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,true,true>>::insert(std::string const&)
lea rdi, [r15+58h]
mov rsi, r14
call _ZNSt8__detail9_Map_baseINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS6_N8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS6_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESaISI_ENS_10_Select1stESt8equal_toIS6_ESt4hashIS6_ENS_18_Mod_range_hashingENS_20_Default_ranged_hashENS_20_Prime_rehash_policyENS_17_Hashtable_traitsILb1ELb0ELb1EEELb1EEixERS8_; std::__detail::_Map_base<std::string,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>>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,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>,true>::operator[](std::string const&)
lea rdi, [rsp+58h+var_50]
mov rsi, rax
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&)
lea rdi, [rsp+58h+var_40]
lea rdx, [rsp+58h+var_50]
mov rsi, r15
mov rcx, rbx
call _ZN15SchemaConverter5visitERKN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_; SchemaConverter::visit(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,std::string const&)
lea r15, [rsp+58h+var_40]
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, r15; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r12
mov rsi, r14
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEE8_M_eraseESt17integral_constantIbLb1EERKS5_; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,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,true,true>>::_M_erase(std::integral_constant<bool,true>,std::string const&)
lea rdi, [rsp+58h+var_50]
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_ACBA4:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r14
pop r15
retn
jmp short $+2
loc_ACBB5:
mov r14, rax
lea rdi, [rsp+arg_0]
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 short loc_ACBCD
jmp short loc_ACBCA
jmp short loc_ACBCA
jmp short $+2
loc_ACBCA:
mov r14, rax
loc_ACBCD:
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
| long long SchemaConverter::_resolve_ref(long long a1, long long a2, long long a3, __m128d a4)
{
long long v5; // rax
long long v6; // rdx
int v7; // ecx
int v8; // r8d
int v9; // r9d
int v10; // edx
int v11; // ecx
int v12; // r8d
int v13; // r9d
unsigned __int8 *v14; // rax
unsigned __int8 v16[16]; // [rsp+8h] [rbp-50h] BYREF
_QWORD v17[8]; // [rsp+18h] [rbp-40h] BYREF
v5 = std::string::rfind(a3, 47LL, -1LL);
std::string::substr(a1, a3, v5 + 1, -1LL);
if ( 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(
a2 + 40,
a1) == a2 + 48
&& !std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,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,true,true>>::find(
a2 + 144,
a3) )
{
std::__detail::_Insert_base<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,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,true,true>>::insert(
a2 + 144,
a3,
v6,
v7,
v8,
v9);
v14 = (unsigned __int8 *)std::__detail::_Map_base<std::string,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>>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,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>,true>::operator[](
(int)a2 + 88,
a3,
v10,
v11,
v12,
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(
v16,
v14);
SchemaConverter::visit(v17, a2, v16, a1, a4);
std::string::operator=(a1, v17);
std::string::~string(v17);
std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,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,true,true>>::_M_erase(
a2 + 144,
a3);
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)v16);
}
return a1;
}
| _resolve_ref:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
PUSH 0x2f
POP RSI
PUSH -0x1
POP R12
MOV RDI,RDX
MOV RDX,R12
CALL 0x00127900
LEA RDX,[RAX + 0x1]
MOV RDI,RBX
MOV RSI,R14
MOV RCX,R12
CALL 0x00126ce0
LEA RDI,[R15 + 0x28]
LAB_001acb16:
MOV RSI,RBX
CALL 0x001aac0e
LEA RCX,[R15 + 0x30]
CMP RAX,RCX
JNZ 0x001acba4
LEA R12,[R15 + 0x90]
LAB_001acb2e:
MOV RDI,R12
MOV RSI,R14
CALL 0x001ade72
TEST RAX,RAX
JNZ 0x001acba4
LAB_001acb3e:
MOV RDI,R12
MOV RSI,R14
CALL 0x001a557e
LEA RDI,[R15 + 0x58]
LAB_001acb4d:
MOV RSI,R14
CALL 0x001adea0
LEA RDI,[RSP + 0x8]
MOV RSI,RAX
CALL 0x00169b80
LAB_001acb62:
LEA RDI,[RSP + 0x18]
LEA RDX,[RSP + 0x8]
MOV RSI,R15
MOV RCX,RBX
CALL 0x001aad94
LEA R15,[RSP + 0x18]
MOV RDI,RBX
MOV RSI,R15
CALL 0x00126f10
MOV RDI,R15
CALL 0x00127998
LAB_001acb8f:
MOV RDI,R12
MOV RSI,R14
CALL 0x001ae29e
LAB_001acb9a:
LEA RDI,[RSP + 0x8]
CALL 0x001651aa
LAB_001acba4:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R14
POP R15
RET
|
/* SchemaConverter::_resolve_ref(std::__cxx11::string const&) */
string * SchemaConverter::_resolve_ref(string *param_1)
{
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,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,true,true>>
*this;
string *psVar1;
long lVar2;
basic_json *pbVar3;
string *in_RDX;
string *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>
local_50 [16];
string local_40 [32];
std::__cxx11::string::rfind((char)in_RDX,0x2f);
std::__cxx11::string::substr((ulong)param_1,(ulong)in_RDX);
/* try { // try from 001acb16 to 001acb1d has its CatchHandler @ 001acbca */
psVar1 = (string *)
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>>>
*)(in_RSI + 0x28),param_1);
if (psVar1 == in_RSI + 0x30) {
this = (_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,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,true,true>>
*)(in_RSI + 0x90);
/* try { // try from 001acb2e to 001acb38 has its CatchHandler @ 001acbc8 */
lVar2 = std::
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,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,true,true>>
::find(this,in_RDX);
if (lVar2 == 0) {
/* try { // try from 001acb3e to 001acb48 has its CatchHandler @ 001acbc4 */
std::__detail::
_Insert_base<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,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,true,true>>
::insert((string *)this);
/* try { // try from 001acb4d to 001acb61 has its CatchHandler @ 001acbc6 */
pbVar3 = (basic_json *)
std::__detail::
_Map_base<std::__cxx11::string,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>>>,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>,true>
::operator[]((_Map_base<std::__cxx11::string,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>>>,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>,true>
*)(in_RSI + 0x58),in_RDX);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_50,pbVar3);
/* try { // try from 001acb62 to 001acb76 has its CatchHandler @ 001acbb5 */
visit(local_40,in_RSI);
std::__cxx11::string::operator=(param_1,local_40);
std::__cxx11::string::~string(local_40);
/* try { // try from 001acb8f to 001acb99 has its CatchHandler @ 001acbb3 */
std::
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,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,true,true>>
::_M_erase(this);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_50);
}
}
return param_1;
}
| |
28,452 | mi_open_keyfile | eloqsql/storage/myisam/mi_open.c | int mi_open_keyfile(MYISAM_SHARE *share)
{
if ((share->kfile= mysql_file_open(mi_key_file_kfile,
share->unique_file_name,
share->mode | O_SHARE | O_NOFOLLOW | O_CLOEXEC,
MYF(MY_NOSYMLINKS | MY_WME))) < 0)
return 1;
return 0;
} | O0 | c | mi_open_keyfile:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xbc07c9(%rip), %rax # 0xc7a5dc
movl (%rax), %edi
movq -0x10(%rbp), %rax
movq 0x258(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x358(%rax), %r8d
orl $0x0, %r8d
orl $0x20000, %r8d # imm = 0x20000
orl $0x80000, %r8d # imm = 0x80000
leaq 0x99d32(%rip), %rsi # 0x153b76
movl $0x504, %edx # imm = 0x504
movl $0x210, %r9d # imm = 0x210
callq 0xb4b90
movq -0x10(%rbp), %rcx
movl %eax, 0x350(%rcx)
cmpl $0x0, %eax
jge 0xb9e6c
movl $0x1, -0x4(%rbp)
jmp 0xb9e73
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| mi_open_keyfile:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_10], rdi
lea rax, mi_key_file_kfile
mov edi, [rax]
mov rax, [rbp+var_10]
mov rcx, [rax+258h]
mov rax, [rbp+var_10]
mov r8d, [rax+358h]
or r8d, 0
or r8d, 20000h
or r8d, 80000h
lea rsi, aWorkspaceLlm4b_29; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 504h
mov r9d, 210h
call inline_mysql_file_open_2
mov rcx, [rbp+var_10]
mov [rcx+350h], eax
cmp eax, 0
jge short loc_B9E6C
mov [rbp+var_4], 1
jmp short loc_B9E73
loc_B9E6C:
mov [rbp+var_4], 0
loc_B9E73:
mov eax, [rbp+var_4]
add rsp, 10h
pop rbp
retn
| _BOOL8 mi_open_keyfile(long long a1)
{
int v1; // eax
v1 = inline_mysql_file_open_2(
mi_key_file_kfile,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",
0x504u,
*(_QWORD *)(a1 + 600),
*(_DWORD *)(a1 + 856) | 0xA0000u,
528LL);
*(_DWORD *)(a1 + 848) = v1;
return v1 < 0;
}
| mi_open_keyfile:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[0xd7a5dc]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x258]
MOV RAX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RAX + 0x358]
OR R8D,0x0
OR R8D,0x20000
OR R8D,0x80000
LEA RSI,[0x253b76]
MOV EDX,0x504
MOV R9D,0x210
CALL 0x001b4b90
MOV RCX,qword ptr [RBP + -0x10]
MOV dword ptr [RCX + 0x350],EAX
CMP EAX,0x0
JGE 0x001b9e6c
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001b9e73
LAB_001b9e6c:
MOV dword ptr [RBP + -0x4],0x0
LAB_001b9e73:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x10
POP RBP
RET
|
bool mi_open_keyfile(long param_1)
{
int iVar1;
iVar1 = inline_mysql_file_open
(mi_key_file_kfile,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",0x504,
*(int8 *)(param_1 + 600),*(uint *)(param_1 + 0x358) | 0xa0000,0x210);
*(int *)(param_1 + 0x350) = iVar1;
return iVar1 < 0;
}
| |
28,453 | mi_open_keyfile | eloqsql/storage/myisam/mi_open.c | int mi_open_keyfile(MYISAM_SHARE *share)
{
if ((share->kfile= mysql_file_open(mi_key_file_kfile,
share->unique_file_name,
share->mode | O_SHARE | O_NOFOLLOW | O_CLOEXEC,
MYF(MY_NOSYMLINKS | MY_WME))) < 0)
return 1;
return 0;
} | O3 | c | mi_open_keyfile:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0xb7f2e0(%rip), %rax # 0xbff9dc
movl (%rax), %esi
movq 0x258(%rdi), %r15
movl $0xa0000, %r14d # imm = 0xA0000
orl 0x358(%rdi), %r14d
leaq 0x3058f7(%rip), %r13 # 0x386010
movq (%r13), %rax
leaq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %r12
movl $0x2, %edx
movq %r15, %rcx
movq %r12, %r8
callq *0x148(%rax)
movq %rax, (%r12)
testq %rax, %rax
jne 0x8076f
movl $0x210, %edx # imm = 0x210
movq %r15, %rdi
movl %r14d, %esi
callq 0xa02c4
movl %eax, %r14d
movl %r14d, 0x350(%rbx)
shrl $0x1f, %r14d
movl %r14d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r13), %rcx
leaq 0x5b575(%rip), %rsi # 0xdbcef
movq %rax, %rdi
movl $0x504, %edx # imm = 0x504
callq *0x1f0(%rcx)
movl $0x210, %edx # imm = 0x210
movq %r15, %rdi
movl %r14d, %esi
callq 0xa02c4
movl %eax, %r14d
movq (%r13), %rax
movq -0x30(%rbp), %rdi
movl %r14d, %esi
callq *0x200(%rax)
jmp 0x80752
| mi_open_keyfile:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
lea rax, mi_key_file_kfile
mov esi, [rax]
mov r15, [rdi+258h]
mov r14d, 0A0000h
or r14d, [rdi+358h]
lea r13, PSI_server
mov rax, [r13+0]
lea rdi, [rbp+var_78]
lea r12, [rbp+var_30]
mov edx, 2
mov rcx, r15
mov r8, r12
call qword ptr [rax+148h]
mov [r12], rax
test rax, rax
jnz short loc_8076F
mov edx, 210h
mov rdi, r15
mov esi, r14d
call my_open
mov r14d, eax
loc_80752:
mov [rbx+350h], r14d
shr r14d, 1Fh
mov eax, r14d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8076F:
mov rcx, [r13+0]
lea rsi, aWorkspaceLlm4b_17; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rax
mov edx, 504h
call qword ptr [rcx+1F0h]
mov edx, 210h
mov rdi, r15
mov esi, r14d
call my_open
mov r14d, eax
mov rax, [r13+0]
mov rdi, [rbp+var_30]
mov esi, r14d
call qword ptr [rax+200h]
jmp short loc_80752
| long long mi_open_keyfile(long long a1)
{
long long v1; // r15
unsigned int v2; // r14d
long long v3; // rax
long long v4; // r14
_BYTE v6[72]; // [rsp+8h] [rbp-78h] BYREF
long long v7[6]; // [rsp+50h] [rbp-30h] BYREF
v1 = *(_QWORD *)(a1 + 600);
v2 = *(_DWORD *)(a1 + 856) | 0xA0000;
v3 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(
v6,
mi_key_file_kfile,
2LL,
v1,
v7);
v7[0] = v3;
if ( v3 )
{
((void ( *)(long long, const char *, long long))PSI_server[62])(
v3,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",
1284LL);
v4 = (unsigned int)my_open(v1, v2, 528LL);
((void ( *)(long long, long long))PSI_server[64])(v7[0], v4);
}
else
{
LODWORD(v4) = my_open(v1, v2, 528LL);
}
*(_DWORD *)(a1 + 848) = v4;
return (unsigned int)v4 >> 31;
}
| mi_open_keyfile:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
LEA RAX,[0xcff9dc]
MOV ESI,dword ptr [RAX]
MOV R15,qword ptr [RDI + 0x258]
MOV R14D,0xa0000
OR R14D,dword ptr [RDI + 0x358]
LEA R13,[0x486010]
MOV RAX,qword ptr [R13]
LEA RDI,[RBP + -0x78]
LEA R12,[RBP + -0x30]
MOV EDX,0x2
MOV RCX,R15
MOV R8,R12
CALL qword ptr [RAX + 0x148]
MOV qword ptr [R12],RAX
TEST RAX,RAX
JNZ 0x0018076f
MOV EDX,0x210
MOV RDI,R15
MOV ESI,R14D
CALL 0x001a02c4
MOV R14D,EAX
LAB_00180752:
MOV dword ptr [RBX + 0x350],R14D
SHR R14D,0x1f
MOV EAX,R14D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018076f:
MOV RCX,qword ptr [R13]
LEA RSI,[0x1dbcef]
MOV RDI,RAX
MOV EDX,0x504
CALL qword ptr [RCX + 0x1f0]
MOV EDX,0x210
MOV RDI,R15
MOV ESI,R14D
CALL 0x001a02c4
MOV R14D,EAX
MOV RAX,qword ptr [R13]
MOV RDI,qword ptr [RBP + -0x30]
MOV ESI,R14D
CALL qword ptr [RAX + 0x200]
JMP 0x00180752
|
uint mi_open_keyfile(long param_1)
{
int8 uVar1;
uint uVar2;
int1 local_80 [72];
long local_38;
uVar1 = *(int8 *)(param_1 + 600);
uVar2 = *(uint *)(param_1 + 0x358) | 0xa0000;
local_38 = (**(code **)(PSI_server + 0x148))(local_80,mi_key_file_kfile,2,uVar1,&local_38);
if (local_38 == 0) {
uVar2 = my_open(uVar1,uVar2,0x210);
}
else {
(**(code **)(PSI_server + 0x1f0))
(local_38,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",0x504);
uVar2 = my_open(uVar1,uVar2,0x210);
(**(code **)(PSI_server + 0x200))(local_38,uVar2);
}
*(uint *)(param_1 + 0x350) = uVar2;
return uVar2 >> 0x1f;
}
| |
28,454 | 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>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) | monkey531[P]llama/common/json.hpp | basic_json(const basic_json& other)
: json_base_class_t(other)
{
m_data.m_type = other.m_data.m_type;
// check of passed value is valid
other.assert_invariant();
switch (m_data.m_type)
{
case value_t::object:
{
m_data.m_value = *other.m_data.m_value.object;
break;
}
case value_t::array:
{
m_data.m_value = *other.m_data.m_value.array;
break;
}
case value_t::string:
{
m_data.m_value = *other.m_data.m_value.string;
break;
}
case value_t::boolean:
{
m_data.m_value = other.m_data.m_value.boolean;
break;
}
case value_t::number_integer:
{
m_data.m_value = other.m_data.m_value.number_integer;
break;
}
case value_t::number_unsigned:
{
m_data.m_value = other.m_data.m_value.number_unsigned;
break;
}
case value_t::number_float:
{
m_data.m_value = other.m_data.m_value.number_float;
break;
}
case value_t::binary:
{
m_data.m_value = *other.m_data.m_value.binary;
break;
}
case value_t::null:
case value_t::discarded:
default:
break;
}
set_parents();
assert_invariant();
} | 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>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movb (%rsi), %al
movb %al, (%rdi)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3eb06
movzbl (%rbx), %eax
decl %eax
cmpl $0x7, %eax
ja 0x433f8
leaq 0x687c4(%rip), %rcx # 0xabb78
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
jmp 0x433f4
movq 0x8(%r14), %rdi
callq 0x43c20
jmp 0x433f4
movq 0x8(%r14), %rdi
callq 0x43ca2
jmp 0x433f4
movzbl 0x8(%r14), %eax
jmp 0x433f4
movq 0x8(%r14), %rdi
callq 0x43800
jmp 0x433f4
movq 0x8(%r14), %rdi
callq 0x43a6e
movq %rax, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3eb06
jmp 0x43410
jmp 0x43410
jmp 0x43410
movq %rax, %r14
movq %rbx, %rdi
callq 0x437e8
movq %r14, %rdi
callq 0x23f80
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov al, [rsi]
mov [rdi], al
push 1
pop rsi
mov rdi, r14
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)
movzx eax, byte ptr [rbx]
dec eax; switch 8 cases
cmp eax, 7
ja short def_433BB; jumptable 00000000000433BB default case
lea rcx, jpt_433BB
movsxd rax, ds:(jpt_433BB - 0ABB78h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_433BD:
mov rax, [r14+8]; jumptable 00000000000433BB cases 5-7
jmp short loc_433F4
loc_433C3:
mov rdi, [r14+8]; jumptable 00000000000433BB case 3
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS9_JRKS9_EEEPT_DpOT0_; 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>::create<std::string,std::string const&>(std::string const&)
jmp short loc_433F4
loc_433CE:
mov rdi, [r14+8]; jumptable 00000000000433BB case 8
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createINS0_27byte_container_with_subtypeISC_EEJRKSG_EEEPT_DpOT0_; 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>::create<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>> const&>(nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>> const&)
jmp short loc_433F4
loc_433D9:
movzx eax, byte ptr [r14+8]; jumptable 00000000000433BB case 4
jmp short loc_433F4
loc_433E0:
mov rdi, [r14+8]; jumptable 00000000000433BB case 1
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createINS2_IS9_SD_St4lessIvESaISt4pairIKS9_SD_EEEEJRKSL_EEEPT_DpOT0_; 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>::create<nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>,nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&>(nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&)
jmp short loc_433F4
loc_433EB:
mov rdi, [r14+8]; jumptable 00000000000433BB case 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJRKSG_EEEPT_DpOT0_; 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>::create<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::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>> const&>(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>> const&)
loc_433F4:
mov [rbx+8], rax
def_433BB:
push 1; jumptable 00000000000433BB default case
pop rsi
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
jmp _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_43410
jmp short loc_43410
jmp short $+2
loc_43410:
mov r14, rax
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
unsigned __int8 *a1,
unsigned __int8 *a2)
{
int v2; // eax
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
long long result; // rax
int v8; // [rsp-8h] [rbp-18h]
v8 = v2;
*(_OWORD *)a1 = 0LL;
*a1 = *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);
result = (unsigned int)*a1 - 1;
switch ( *a1 )
{
case 1u:
result = 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>::create<nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>,nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>> const&>(
*((_QWORD *)a2 + 1),
1,
v3,
v4,
v5,
v6,
v8);
goto LABEL_8;
case 2u:
result = 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>::create<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::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>> const&>(
*((_QWORD *)a2 + 1),
1,
v3,
v4,
v5,
v6,
v8);
goto LABEL_8;
case 3u:
result = 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>::create<std::string,std::string const&>(
*((_QWORD *)a2 + 1),
1,
v3,
v4,
v5,
v6,
v8);
goto LABEL_8;
case 4u:
result = a2[8];
goto LABEL_8;
case 5u:
case 6u:
case 7u:
result = *((_QWORD *)a2 + 1);
goto LABEL_8;
case 8u:
result = 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>::create<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>> const&>(
*((_QWORD *)a2 + 1),
1,
v3,
v4,
v5,
v6,
v8);
LABEL_8:
*((_QWORD *)a1 + 1) = result;
break;
default:
break;
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
return result;
}
| basic_json:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV AL,byte ptr [RSI]
MOV byte ptr [RDI],AL
PUSH 0x1
POP RSI
MOV RDI,R14
CALL 0x0013eb06
MOVZX EAX,byte ptr [RBX]
DEC EAX
CMP EAX,0x7
JA 0x001433f8
LEA RCX,[0x1abb78]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_5:
MOV RAX,qword ptr [R14 + 0x8]
JMP 0x001433f4
caseD_3:
MOV RDI,qword ptr [R14 + 0x8]
LAB_001433c7:
CALL 0x00143c20
JMP 0x001433f4
caseD_8:
MOV RDI,qword ptr [R14 + 0x8]
LAB_001433d2:
CALL 0x00143ca2
JMP 0x001433f4
caseD_4:
MOVZX EAX,byte ptr [R14 + 0x8]
JMP 0x001433f4
caseD_1:
MOV RDI,qword ptr [R14 + 0x8]
LAB_001433e4:
CALL 0x00143800
JMP 0x001433f4
caseD_2:
MOV RDI,qword ptr [R14 + 0x8]
LAB_001433ef:
CALL 0x00143a6e
LAB_001433f4:
MOV qword ptr [RBX + 0x8],RAX
default:
PUSH 0x1
POP RSI
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0013eb06
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
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>
::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>
*this,basic_json *param_1)
{
string *psVar1;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)*param_1;
assert_invariant(SUB81(param_1,0));
switch(*this) {
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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:
/* try { // try from 001433e4 to 001433e8 has its CatchHandler @ 0014340c */
psVar1 = (string *)
create<nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>,nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>const&>
(*(ordered_map **)(param_1 + 8));
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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 001433ef to 001433f3 has its CatchHandler @ 0014340a */
psVar1 = (string *)
create<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>>>,std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>const&>
(*(vector **)(param_1 + 8));
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x3:
/* try { // try from 001433c7 to 001433cb has its CatchHandler @ 00143410 */
psVar1 = create<std::__cxx11::string,std::__cxx11::string_const&>(*(string **)(param_1 + 8));
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x4:
psVar1 = (string *)(ulong)(byte)param_1[8];
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x5:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x6:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x7:
psVar1 = *(string **)(param_1 + 8);
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x8:
/* try { // try from 001433d2 to 001433d6 has its CatchHandler @ 0014340e */
psVar1 = (string *)
create<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>const&>
(*(byte_container_with_subtype **)(param_1 + 8));
break;
default:
goto switchD_001433bb_default;
}
*(string **)(this + 8) = psVar1;
switchD_001433bb_default:
assert_invariant(SUB81(this,0));
return;
}
| |
28,455 | stbtt__cff_index_get | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h | static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i)
{
int count, offsize, start, end;
stbtt__buf_seek(&b, 0);
count = stbtt__buf_get16(&b);
offsize = stbtt__buf_get8(&b);
STBTT_assert(i >= 0 && i < count);
STBTT_assert(offsize >= 1 && offsize <= 4);
stbtt__buf_skip(&b, i*offsize);
start = stbtt__buf_get(&b, offsize);
end = stbtt__buf_get(&b, offsize);
return stbtt__buf_range(&b, 2+(count+1)*offsize+start, end - start);
} | O1 | c | stbtt__cff_index_get:
pushq %rbx
testq %rsi, %rsi
js 0x25d9c
shrq $0x20, %rsi
xorl %ecx, %ecx
movl $0x2, %r8d
xorl %eax, %eax
cmpl %esi, %ecx
jge 0x25cba
movslq %ecx, %r9
incl %ecx
movzbl (%rdi,%r9), %r9d
jmp 0x25cbd
xorl %r9d, %r9d
shll $0x8, %eax
orl %r9d, %eax
decl %r8d
jne 0x25caa
cmpl %esi, %ecx
jge 0x25cd7
movslq %ecx, %r8
incl %ecx
movb (%rdi,%r8), %r10b
jmp 0x25cda
xorl %r10d, %r10d
testl %edx, %edx
js 0x25dbb
cmpl %edx, %eax
jle 0x25dbb
leal -0x1(%r10), %r8d
cmpb $0x4, %r8b
jae 0x25dda
movzbl %r10b, %r8d
imull %r8d, %edx
addl %ecx, %edx
cmpl %esi, %edx
ja 0x25d9c
xorl %ecx, %ecx
xorl %r9d, %r9d
testb %r10b, %r10b
je 0x25d34
movl %r8d, %r11d
cmpl %esi, %edx
jge 0x25d26
movslq %edx, %rbx
incl %edx
movzbl (%rdi,%rbx), %ebx
jmp 0x25d28
xorl %ebx, %ebx
shll $0x8, %r9d
orl %ebx, %r9d
decl %r11d
jne 0x25d17
testb %r10b, %r10b
je 0x25d5c
xorl %ecx, %ecx
movl %r8d, %r10d
cmpl %esi, %edx
jge 0x25d4e
movslq %edx, %r11
incl %edx
movzbl (%rdi,%r11), %r11d
jmp 0x25d51
xorl %r11d, %r11d
shll $0x8, %ecx
orl %r11d, %ecx
decl %r10d
jne 0x25d3e
incl %eax
imull %r8d, %eax
leal (%rax,%r9), %r8d
addl $0x2, %r8d
subl %r9d, %ecx
movl %ecx, %eax
orl %r8d, %eax
js 0x25d96
xorl %eax, %eax
subl %r8d, %esi
jl 0x25d98
movl $0x0, %edx
cmpl %ecx, %esi
jl 0x25d9a
movl %r8d, %eax
addq %rax, %rdi
shlq $0x20, %rcx
movq %rdi, %rax
movq %rcx, %rdx
jmp 0x25d9a
xorl %eax, %eax
xorl %edx, %edx
popq %rbx
retq
leaq 0x1f04f(%rip), %rdi # 0x44df2
leaq 0x1efdc(%rip), %rsi # 0x44d86
leaq 0x1f059(%rip), %rcx # 0x44e0a
movl $0x47d, %edx # imm = 0x47D
callq 0xa200
leaq 0x1f0bb(%rip), %rdi # 0x44e7d
leaq 0x1efbd(%rip), %rsi # 0x44d86
leaq 0x1f0c1(%rip), %rcx # 0x44e91
movl $0x4f2, %edx # imm = 0x4F2
callq 0xa200
leaq 0x1f051(%rip), %rdi # 0x44e32
leaq 0x1ef9e(%rip), %rsi # 0x44d86
leaq 0x1f0a2(%rip), %rcx # 0x44e91
movl $0x4f3, %edx # imm = 0x4F3
callq 0xa200
| stbtt__cff_index_get:
push rbx
test rsi, rsi
js loc_25D9C
shr rsi, 20h
xor ecx, ecx
mov r8d, 2
xor eax, eax
loc_25CAA:
cmp ecx, esi
jge short loc_25CBA
movsxd r9, ecx
inc ecx
movzx r9d, byte ptr [rdi+r9]
jmp short loc_25CBD
loc_25CBA:
xor r9d, r9d
loc_25CBD:
shl eax, 8
or eax, r9d
dec r8d
jnz short loc_25CAA
cmp ecx, esi
jge short loc_25CD7
movsxd r8, ecx
inc ecx
mov r10b, [rdi+r8]
jmp short loc_25CDA
loc_25CD7:
xor r10d, r10d
loc_25CDA:
test edx, edx
js loc_25DBB
cmp eax, edx
jle loc_25DBB
lea r8d, [r10-1]
cmp r8b, 4
jnb loc_25DDA
movzx r8d, r10b
imul edx, r8d
add edx, ecx
cmp edx, esi
ja loc_25D9C
xor ecx, ecx
xor r9d, r9d
test r10b, r10b
jz short loc_25D34
mov r11d, r8d
loc_25D17:
cmp edx, esi
jge short loc_25D26
movsxd rbx, edx
inc edx
movzx ebx, byte ptr [rdi+rbx]
jmp short loc_25D28
loc_25D26:
xor ebx, ebx
loc_25D28:
shl r9d, 8
or r9d, ebx
dec r11d
jnz short loc_25D17
loc_25D34:
test r10b, r10b
jz short loc_25D5C
xor ecx, ecx
mov r10d, r8d
loc_25D3E:
cmp edx, esi
jge short loc_25D4E
movsxd r11, edx
inc edx
movzx r11d, byte ptr [rdi+r11]
jmp short loc_25D51
loc_25D4E:
xor r11d, r11d
loc_25D51:
shl ecx, 8
or ecx, r11d
dec r10d
jnz short loc_25D3E
loc_25D5C:
inc eax
imul eax, r8d
lea r8d, [rax+r9]
add r8d, 2
sub ecx, r9d
mov eax, ecx
or eax, r8d
js short loc_25D96
xor eax, eax
sub esi, r8d
jl short loc_25D98
mov edx, 0
cmp esi, ecx
jl short loc_25D9A
mov eax, r8d
add rdi, rax
shl rcx, 20h
mov rax, rdi
mov rdx, rcx
jmp short loc_25D9A
loc_25D96:
xor eax, eax
loc_25D98:
xor edx, edx
loc_25D9A:
pop rbx
retn
loc_25D9C:
lea rdi, aOBSizeO0; "!(o > b->size || o < 0)"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidStbttBufSe; "void stbtt__buf_seek(stbtt__buf *, int)"
mov edx, 47Dh
call ___assert_fail
loc_25DBB:
lea rdi, aI0ICount; "i >= 0 && i < count"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStbttBufStbttC_0; "stbtt__buf stbtt__cff_index_get(stbtt__"...
mov edx, 4F2h
call ___assert_fail
loc_25DDA:
lea rdi, aOffsize1Offsiz; "offsize >= 1 && offsize <= 4"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStbttBufStbttC_0; "stbtt__buf stbtt__cff_index_get(stbtt__"...
mov edx, 4F3h
call ___assert_fail
| long long stbtt__cff_index_get(long long a1, long long a2, int a3)
{
unsigned long long v3; // rsi
int v4; // ecx
int v5; // r8d
int v6; // eax
long long v7; // r9
int v8; // r9d
long long v9; // r8
int v10; // r10d
int v11; // r8d
int v12; // edx
int v13; // ecx
int v14; // r9d
int v15; // r11d
long long v16; // rbx
int v17; // ebx
long long v18; // r11
int v19; // r11d
int v20; // r8d
int v21; // ecx
long long result; // rax
bool v23; // cc
int v24; // esi
if ( a2 < 0 )
goto LABEL_32;
v3 = HIDWORD(a2);
v4 = 0;
v5 = 2;
v6 = 0;
do
{
if ( v4 >= (int)v3 )
{
v8 = 0;
}
else
{
v7 = v4++;
v8 = *(unsigned __int8 *)(a1 + v7);
}
v6 = v8 | (v6 << 8);
--v5;
}
while ( v5 );
if ( v4 >= (int)v3 )
{
LOBYTE(v10) = 0;
}
else
{
v9 = v4++;
LOBYTE(v10) = *(_BYTE *)(a1 + v9);
}
if ( a3 < 0 || v6 <= a3 )
__assert_fail(
"i >= 0 && i < count",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h",
1266LL,
"stbtt__buf stbtt__cff_index_get(stbtt__buf, int)");
if ( (unsigned __int8)(v10 - 1) >= 4u )
__assert_fail(
"offsize >= 1 && offsize <= 4",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h",
1267LL,
"stbtt__buf stbtt__cff_index_get(stbtt__buf, int)");
v11 = (unsigned __int8)v10;
v12 = v4 + (unsigned __int8)v10 * a3;
if ( v12 > (unsigned int)v3 )
LABEL_32:
__assert_fail(
"!(o > b->size || o < 0)",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h",
1149LL,
"void stbtt__buf_seek(stbtt__buf *, int)");
v13 = 0;
v14 = 0;
if ( (_BYTE)v10 )
{
v15 = (unsigned __int8)v10;
do
{
if ( v12 >= (int)v3 )
{
v17 = 0;
}
else
{
v16 = v12++;
v17 = *(unsigned __int8 *)(a1 + v16);
}
v14 = v17 | (v14 << 8);
--v15;
}
while ( v15 );
}
if ( (_BYTE)v10 )
{
v13 = 0;
v10 = (unsigned __int8)v10;
do
{
if ( v12 >= (int)v3 )
{
v19 = 0;
}
else
{
v18 = v12++;
v19 = *(unsigned __int8 *)(a1 + v18);
}
v13 = v19 | (v13 << 8);
--v10;
}
while ( v10 );
}
v20 = v11 * (v6 + 1) + v14 + 2;
v21 = v13 - v14;
if ( (v20 | v21) < 0 )
return 0LL;
result = 0LL;
v23 = (int)v3 < v20;
v24 = v3 - v20;
if ( !v23 && v24 >= v21 )
return (unsigned int)v20 + a1;
return result;
}
| stbtt__cff_index_get:
PUSH RBX
TEST RSI,RSI
JS 0x00125d9c
SHR RSI,0x20
XOR ECX,ECX
MOV R8D,0x2
XOR EAX,EAX
LAB_00125caa:
CMP ECX,ESI
JGE 0x00125cba
MOVSXD R9,ECX
INC ECX
MOVZX R9D,byte ptr [RDI + R9*0x1]
JMP 0x00125cbd
LAB_00125cba:
XOR R9D,R9D
LAB_00125cbd:
SHL EAX,0x8
OR EAX,R9D
DEC R8D
JNZ 0x00125caa
CMP ECX,ESI
JGE 0x00125cd7
MOVSXD R8,ECX
INC ECX
MOV R10B,byte ptr [RDI + R8*0x1]
JMP 0x00125cda
LAB_00125cd7:
XOR R10D,R10D
LAB_00125cda:
TEST EDX,EDX
JS 0x00125dbb
CMP EAX,EDX
JLE 0x00125dbb
LEA R8D,[R10 + -0x1]
CMP R8B,0x4
JNC 0x00125dda
MOVZX R8D,R10B
IMUL EDX,R8D
ADD EDX,ECX
CMP EDX,ESI
JA 0x00125d9c
XOR ECX,ECX
XOR R9D,R9D
TEST R10B,R10B
JZ 0x00125d34
MOV R11D,R8D
LAB_00125d17:
CMP EDX,ESI
JGE 0x00125d26
MOVSXD RBX,EDX
INC EDX
MOVZX EBX,byte ptr [RDI + RBX*0x1]
JMP 0x00125d28
LAB_00125d26:
XOR EBX,EBX
LAB_00125d28:
SHL R9D,0x8
OR R9D,EBX
DEC R11D
JNZ 0x00125d17
LAB_00125d34:
TEST R10B,R10B
JZ 0x00125d5c
XOR ECX,ECX
MOV R10D,R8D
LAB_00125d3e:
CMP EDX,ESI
JGE 0x00125d4e
MOVSXD R11,EDX
INC EDX
MOVZX R11D,byte ptr [RDI + R11*0x1]
JMP 0x00125d51
LAB_00125d4e:
XOR R11D,R11D
LAB_00125d51:
SHL ECX,0x8
OR ECX,R11D
DEC R10D
JNZ 0x00125d3e
LAB_00125d5c:
INC EAX
IMUL EAX,R8D
LEA R8D,[RAX + R9*0x1]
ADD R8D,0x2
SUB ECX,R9D
MOV EAX,ECX
OR EAX,R8D
JS 0x00125d96
XOR EAX,EAX
SUB ESI,R8D
JL 0x00125d98
MOV EDX,0x0
CMP ESI,ECX
JL 0x00125d9a
MOV EAX,R8D
ADD RDI,RAX
SHL RCX,0x20
MOV RAX,RDI
MOV RDX,RCX
JMP 0x00125d9a
LAB_00125d96:
XOR EAX,EAX
LAB_00125d98:
XOR EDX,EDX
LAB_00125d9a:
POP RBX
RET
LAB_00125d9c:
LEA RDI,[0x144df2]
LEA RSI,[0x144d86]
LEA RCX,[0x144e0a]
MOV EDX,0x47d
CALL 0x0010a200
LAB_00125dbb:
LEA RDI,[0x144e7d]
LEA RSI,[0x144d86]
LEA RCX,[0x144e91]
MOV EDX,0x4f2
CALL 0x0010a200
LAB_00125dda:
LEA RDI,[0x144e32]
LEA RSI,[0x144d86]
LEA RCX,[0x144e91]
MOV EDX,0x4f3
CALL 0x0010a200
|
int1 [16] stbtt__cff_index_get(long param_1,long param_2,int param_3)
{
uint uVar1;
int iVar2;
uint uVar3;
uint uVar4;
long lVar5;
uint uVar6;
int iVar7;
uint uVar8;
long lVar9;
byte bVar10;
uint uVar11;
uint uVar12;
int1 auVar13 [16];
if (param_2 < 0) {
LAB_00125d9c:
/* WARNING: Subroutine does not return */
__assert_fail("!(o > b->size || o < 0)",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h"
,0x47d,"void stbtt__buf_seek(stbtt__buf *, int)");
}
iVar2 = 0;
iVar7 = 2;
uVar1 = 0;
do {
uVar6 = (uint)((ulong)param_2 >> 0x20);
if (iVar2 < (int)uVar6) {
lVar9 = (long)iVar2;
iVar2 = iVar2 + 1;
uVar4 = (uint)*(byte *)(param_1 + lVar9);
}
else {
uVar4 = 0;
}
uVar1 = uVar1 << 8 | uVar4;
iVar7 = iVar7 + -1;
} while (iVar7 != 0);
if (iVar2 < (int)uVar6) {
lVar9 = (long)iVar2;
iVar2 = iVar2 + 1;
bVar10 = *(byte *)(param_1 + lVar9);
}
else {
bVar10 = 0;
}
if ((param_3 < 0) || ((int)uVar1 <= param_3)) {
/* WARNING: Subroutine does not return */
__assert_fail("i >= 0 && i < count",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h"
,0x4f2,"stbtt__buf stbtt__cff_index_get(stbtt__buf, int)");
}
if (3 < (byte)(bVar10 - 1)) {
/* WARNING: Subroutine does not return */
__assert_fail("offsize >= 1 && offsize <= 4",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h"
,0x4f3,"stbtt__buf stbtt__cff_index_get(stbtt__buf, int)");
}
uVar11 = (uint)bVar10;
uVar4 = param_3 * uVar11 + iVar2;
if (uVar6 < uVar4) goto LAB_00125d9c;
uVar3 = 0;
uVar8 = 0;
if (bVar10 != 0) {
do {
if ((int)uVar4 < (int)uVar6) {
lVar9 = (long)(int)uVar4;
uVar4 = uVar4 + 1;
uVar12 = (uint)*(byte *)(param_1 + lVar9);
}
else {
uVar12 = 0;
}
uVar8 = uVar8 << 8 | uVar12;
uVar11 = uVar11 - 1;
} while (uVar11 != 0);
}
if (bVar10 != 0) {
uVar3 = 0;
uVar11 = (uint)bVar10;
do {
if ((int)uVar4 < (int)uVar6) {
lVar9 = (long)(int)uVar4;
uVar4 = uVar4 + 1;
uVar12 = (uint)*(byte *)(param_1 + lVar9);
}
else {
uVar12 = 0;
}
uVar3 = uVar3 << 8 | uVar12;
uVar11 = uVar11 - 1;
} while (uVar11 != 0);
}
uVar1 = (uVar1 + 1) * (uint)bVar10 + uVar8 + 2;
uVar3 = uVar3 - uVar8;
if (-1 < (int)(uVar3 | uVar1)) {
lVar9 = 0;
if ((int)uVar1 <= (int)uVar6) {
lVar5 = 0;
if ((int)uVar3 <= (int)(uVar6 - uVar1)) {
lVar9 = param_1 + (ulong)uVar1;
lVar5 = (ulong)uVar3 << 0x20;
}
goto LAB_00125d9a;
}
}
lVar9 = 0;
lVar5 = 0;
LAB_00125d9a:
auVar13._8_8_ = lVar5;
auVar13._0_8_ = lVar9;
return auVar13;
}
| |
28,456 | stbtt__cff_index_get | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h | static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i)
{
int count, offsize, start, end;
stbtt__buf_seek(&b, 0);
count = stbtt__buf_get16(&b);
offsize = stbtt__buf_get8(&b);
STBTT_assert(i >= 0 && i < count);
STBTT_assert(offsize >= 1 && offsize <= 4);
stbtt__buf_skip(&b, i*offsize);
start = stbtt__buf_get(&b, offsize);
end = stbtt__buf_get(&b, offsize);
return stbtt__buf_range(&b, 2+(count+1)*offsize+start, end - start);
} | O2 | c | stbtt__cff_index_get:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsp, %r14
movq %rdi, (%r14)
movq %rsi, 0x8(%r14)
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x21e13
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x221e9
movl %eax, %ebx
movslq 0x8(%r14), %rax
cmpl 0xc(%r14), %eax
jge 0x21f30
movq (%rsp), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x8(%rsp)
movb (%rcx,%rax), %r15b
testl %ebp, %ebp
js 0x21f95
cmpl %ebp, %ebx
jle 0x21f95
leal -0x1(%r15), %eax
cmpb $0x4, %al
jae 0x21fb4
movzbl %r15b, %r14d
imull %r14d, %ebp
movq %rsp, %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x21e0e
movq %r15, %rdi
movl %r14d, %esi
callq 0x221e9
movl %eax, %r12d
movq %r15, %rdi
movl %r14d, %esi
callq 0x221e9
incl %ebx
imull %r14d, %ebx
leal (%rbx,%r12), %esi
addl $0x2, %esi
subl %r12d, %eax
movq %r15, %rdi
movl %eax, %edx
callq 0x221b3
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19fb1(%rip), %rdi # 0x3bf4d
leaq 0x19eb3(%rip), %rsi # 0x3be56
leaq 0x19fb7(%rip), %rcx # 0x3bf61
movl $0x4f2, %edx # imm = 0x4F2
callq 0xa1c0
leaq 0x19f47(%rip), %rdi # 0x3bf02
leaq 0x19e94(%rip), %rsi # 0x3be56
leaq 0x19f98(%rip), %rcx # 0x3bf61
movl $0x4f3, %edx # imm = 0x4F3
callq 0xa1c0
| stbtt__cff_index_get:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov ebp, edx
mov r14, rsp
mov [r14], rdi
mov [r14+8], rsi
xor r15d, r15d
mov rdi, r14
xor esi, esi
call stbtt__buf_seek
push 2
pop rsi
mov rdi, r14
call stbtt__buf_get
mov ebx, eax
movsxd rax, dword ptr [r14+8]
cmp eax, [r14+0Ch]
jge short loc_21F30
mov rcx, [rsp+38h+var_38]
lea edx, [rax+1]
mov [rsp+38h+var_30], edx
mov r15b, [rcx+rax]
loc_21F30:
test ebp, ebp
js short loc_21F95
cmp ebx, ebp
jle short loc_21F95
lea eax, [r15-1]
cmp al, 4
jnb short loc_21FB4
movzx r14d, r15b
imul ebp, r14d
mov r15, rsp
mov rdi, r15
mov esi, ebp
call stbtt__buf_skip
mov rdi, r15
mov esi, r14d
call stbtt__buf_get
mov r12d, eax
mov rdi, r15
mov esi, r14d
call stbtt__buf_get
inc ebx
imul ebx, r14d
lea esi, [rbx+r12]
add esi, 2
sub eax, r12d
mov rdi, r15
mov edx, eax
call stbtt__buf_range
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_21F95:
lea rdi, aI0ICount; "i >= 0 && i < count"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStbttBufStbttC_0; "stbtt__buf stbtt__cff_index_get(stbtt__"...
mov edx, 4F2h
call ___assert_fail
loc_21FB4:
lea rdi, aOffsize1Offsiz; "offsize >= 1 && offsize <= 4"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStbttBufStbttC_0; "stbtt__buf stbtt__cff_index_get(stbtt__"...
mov edx, 4F3h
call ___assert_fail
| long long stbtt__cff_index_get(long long a1, long long a2, int a3)
{
unsigned __int8 v4; // r15
int v5; // ebx
long long v6; // rax
int v7; // r12d
int v8; // eax
long long v10; // [rsp+0h] [rbp-38h] BYREF
long long v11; // [rsp+8h] [rbp-30h]
v10 = a1;
v11 = a2;
v4 = 0;
stbtt__buf_seek((long long)&v10, 0);
v5 = stbtt__buf_get(&v10, 2LL);
v6 = (int)v11;
if ( (int)v11 < SHIDWORD(v11) )
{
LODWORD(v11) = v11 + 1;
v4 = *(_BYTE *)(v10 + v6);
}
if ( a3 < 0 || v5 <= a3 )
__assert_fail(
"i >= 0 && i < count",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h",
1266LL,
"stbtt__buf stbtt__cff_index_get(stbtt__buf, int)");
if ( (unsigned __int8)(v4 - 1) >= 4u )
__assert_fail(
"offsize >= 1 && offsize <= 4",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h",
1267LL,
"stbtt__buf stbtt__cff_index_get(stbtt__buf, int)");
stbtt__buf_skip((long long)&v10, v4 * a3);
v7 = stbtt__buf_get(&v10, v4);
v8 = stbtt__buf_get(&v10, v4);
return stbtt__buf_range(&v10, (unsigned int)v4 * (v5 + 1) + v7 + 2, (unsigned int)(v8 - v7));
}
| stbtt__cff_index_get:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV EBP,EDX
MOV R14,RSP
MOV qword ptr [R14],RDI
MOV qword ptr [R14 + 0x8],RSI
XOR R15D,R15D
MOV RDI,R14
XOR ESI,ESI
CALL 0x00121e13
PUSH 0x2
POP RSI
MOV RDI,R14
CALL 0x001221e9
MOV EBX,EAX
MOVSXD RAX,dword ptr [R14 + 0x8]
CMP EAX,dword ptr [R14 + 0xc]
JGE 0x00121f30
MOV RCX,qword ptr [RSP]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RSP + 0x8],EDX
MOV R15B,byte ptr [RCX + RAX*0x1]
LAB_00121f30:
TEST EBP,EBP
JS 0x00121f95
CMP EBX,EBP
JLE 0x00121f95
LEA EAX,[R15 + -0x1]
CMP AL,0x4
JNC 0x00121fb4
MOVZX R14D,R15B
IMUL EBP,R14D
MOV R15,RSP
MOV RDI,R15
MOV ESI,EBP
CALL 0x00121e0e
MOV RDI,R15
MOV ESI,R14D
CALL 0x001221e9
MOV R12D,EAX
MOV RDI,R15
MOV ESI,R14D
CALL 0x001221e9
INC EBX
IMUL EBX,R14D
LEA ESI,[RBX + R12*0x1]
ADD ESI,0x2
SUB EAX,R12D
MOV RDI,R15
MOV EDX,EAX
CALL 0x001221b3
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00121f95:
LEA RDI,[0x13bf4d]
LEA RSI,[0x13be56]
LEA RCX,[0x13bf61]
MOV EDX,0x4f2
CALL 0x0010a1c0
LAB_00121fb4:
LEA RDI,[0x13bf02]
LEA RSI,[0x13be56]
LEA RCX,[0x13bf61]
MOV EDX,0x4f3
CALL 0x0010a1c0
|
void stbtt__cff_index_get(long param_1,int8 param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
long lVar4;
byte bVar5;
long local_38;
int8 local_30;
bVar5 = 0;
local_38 = param_1;
local_30 = param_2;
stbtt__buf_seek(&local_38,0);
iVar1 = stbtt__buf_get(&local_38,2);
lVar4 = (long)(int)local_30;
if ((int)local_30 < local_30._4_4_) {
local_30 = CONCAT44(local_30._4_4_,(int)local_30 + 1);
bVar5 = *(byte *)(local_38 + lVar4);
}
if ((-1 < param_3) && (param_3 < iVar1)) {
if ((byte)(bVar5 - 1) < 4) {
stbtt__buf_skip(&local_38,param_3 * (uint)bVar5);
iVar2 = stbtt__buf_get(&local_38,(uint)bVar5);
iVar3 = stbtt__buf_get(&local_38,bVar5);
stbtt__buf_range(&local_38,(iVar1 + 1) * (uint)bVar5 + iVar2 + 2,iVar3 - iVar2);
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("offsize >= 1 && offsize <= 4",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h"
,0x4f3,"stbtt__buf stbtt__cff_index_get(stbtt__buf, int)");
}
/* WARNING: Subroutine does not return */
__assert_fail("i >= 0 && i < count",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h"
,0x4f2,"stbtt__buf stbtt__cff_index_get(stbtt__buf, int)");
}
| |
28,457 | js_weakref_finalizer | bluesky950520[P]quickjs/quickjs.c | static void js_weakref_finalizer(JSRuntime *rt, JSValue val)
{
JSWeakRefData *wrd = JS_GetOpaque(val, JS_CLASS_WEAK_REF);
if (!wrd || wrd == &js_weakref_sentinel)
return;
/* Delete weak ref */
JSWeakRefRecord **pwr, *wr;
pwr = get_first_weak_ref(wrd->target);
for(;;) {
wr = *pwr;
assert(wr != NULL);
if (wr->kind == JS_WEAK_REF_KIND_WEAK_REF && wr->u.weak_ref_data == wrd)
break;
pwr = &wr->next_weak_ref;
}
*pwr = wr->next_weak_ref;
js_free_rt(rt, wrd);
js_free_rt(rt, wr);
} | O1 | c | js_weakref_finalizer:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
cmpl $-0x1, %edx
jne 0x83444
movq 0x8(%rsp), %rax
cmpw $0x3a, 0x6(%rax)
jne 0x83444
movq 0x30(%rax), %r14
jmp 0x83447
xorl %r14d, %r14d
testq %r14, %r14
sete %al
leaq 0x48154(%rip), %rcx # 0xcb5a8
cmpq %rcx, %r14
sete %cl
orb %al, %cl
je 0x83468
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsd (%r14), %xmm0
movl 0x8(%r14), %eax
movsd %xmm0, 0x8(%rsp)
cmpl $-0x8, %eax
je 0x83490
cmpl $-0x1, %eax
jne 0x8350a
movq 0x8(%rsp), %rax
addq $0x28, %rax
jmp 0x834a2
movq 0x8(%rsp), %rax
addq $0x10, %rax
jmp 0x834a2
addq $0x8, %r15
movq %r15, %rax
movq (%rax), %r15
cmpl $0x1, (%r15)
jne 0x8349b
cmpq %r14, 0x10(%r15)
jne 0x8349b
movq 0x8(%r15), %rcx
movq %rcx, (%rax)
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %r14, %rsi
callq *0x10(%rbx)
decq 0x28(%rbx)
movq %r15, %rdi
callq *0x20(%rbx)
movq 0x10(%rbx), %rcx
movq 0x30(%rbx), %rdx
subq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x30(%rbx)
movq 0x40(%rbx), %rdi
movq %r15, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
callq 0xe090
| js_weakref_finalizer:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
mov [rsp+28h+var_20], rsi
cmp edx, 0FFFFFFFFh
jnz short loc_83444
mov rax, [rsp+28h+var_20]
cmp word ptr [rax+6], 3Ah ; ':'
jnz short loc_83444
mov r14, [rax+30h]
jmp short loc_83447
loc_83444:
xor r14d, r14d
loc_83447:
test r14, r14
setz al
lea rcx, js_weakref_sentinel
cmp r14, rcx
setz cl
or cl, al
jz short loc_83468
add rsp, 10h
pop rbx
pop r14
pop r15
retn
loc_83468:
movsd xmm0, qword ptr [r14]
mov eax, [r14+8]
movsd [rsp+28h+var_20], xmm0
cmp eax, 0FFFFFFF8h
jz short loc_83490
cmp eax, 0FFFFFFFFh
jnz loc_8350A
mov rax, [rsp+28h+var_20]
add rax, 28h ; '('
jmp short loc_834A2
loc_83490:
mov rax, [rsp+28h+var_20]
add rax, 10h
jmp short loc_834A2
loc_8349B:
add r15, 8
mov rax, r15
loc_834A2:
mov r15, [rax]
cmp dword ptr [r15], 1
jnz short loc_8349B
cmp [r15+10h], r14
jnz short loc_8349B
mov rcx, [r15+8]
mov [rax], rcx
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, r14
call qword ptr [rbx+10h]
dec qword ptr [rbx+28h]
mov rdi, r15
call qword ptr [rbx+20h]
mov rcx, [rbx+10h]
mov rdx, [rbx+30h]
sub rdx, rax
add rdx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rdx
mov rdi, [rbx+40h]
mov rsi, r15
add rsp, 10h
pop rbx
pop r14
pop r15
jmp rcx
loc_8350A:
call _abort
| char js_weakref_finalizer(long long a1, long long a2, int a3)
{
_DWORD *v4; // r14
char result; // al
int v6; // eax
_QWORD *v7; // rax
_DWORD *v8; // r15
long long v9; // rax
long long v10; // rdi
long long v11; // rax
long long ( *v12)(_QWORD, _DWORD *); // rcx
long long v13; // [rsp+8h] [rbp-20h]
if ( a3 == -1 && *(_WORD *)(a2 + 6) == 58 )
v4 = *(_DWORD **)(a2 + 48);
else
v4 = 0LL;
result = v4 == 0LL;
if ( v4 != 0LL && v4 != (_DWORD *)&js_weakref_sentinel )
{
v6 = v4[2];
v13 = *(_QWORD *)v4;
if ( v6 == -8 )
{
v7 = (_QWORD *)(v13 + 16);
}
else
{
if ( v6 != -1 )
abort((const char *)a1);
v7 = (_QWORD *)(v13 + 40);
}
while ( 1 )
{
v8 = (_DWORD *)*v7;
if ( *(_DWORD *)*v7 == 1 && *((_DWORD **)v8 + 2) == v4 )
break;
v7 = v8 + 2;
}
*v7 = *((_QWORD *)v8 + 1);
--*(_QWORD *)(a1 + 40);
v9 = (*(long long ( **)(_DWORD *))(a1 + 32))(v4);
v10 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v9 - 8;
(*(void ( **)(long long, _DWORD *))(a1 + 16))(v10, v4);
--*(_QWORD *)(a1 + 40);
v11 = (*(long long ( **)(_DWORD *))(a1 + 32))(v8);
v12 = *(long long ( **)(_QWORD, _DWORD *))(a1 + 16);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v11 - 8;
return v12(*(_QWORD *)(a1 + 64), v8);
}
return result;
}
| js_weakref_finalizer:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV qword ptr [RSP + 0x8],RSI
CMP EDX,-0x1
JNZ 0x00183444
MOV RAX,qword ptr [RSP + 0x8]
CMP word ptr [RAX + 0x6],0x3a
JNZ 0x00183444
MOV R14,qword ptr [RAX + 0x30]
JMP 0x00183447
LAB_00183444:
XOR R14D,R14D
LAB_00183447:
TEST R14,R14
SETZ AL
LEA RCX,[0x1cb5a8]
CMP R14,RCX
SETZ CL
OR CL,AL
JZ 0x00183468
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
LAB_00183468:
MOVSD XMM0,qword ptr [R14]
MOV EAX,dword ptr [R14 + 0x8]
MOVSD qword ptr [RSP + 0x8],XMM0
CMP EAX,-0x8
JZ 0x00183490
CMP EAX,-0x1
JNZ 0x0018350a
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x28
JMP 0x001834a2
LAB_00183490:
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x10
JMP 0x001834a2
LAB_0018349b:
ADD R15,0x8
MOV RAX,R15
LAB_001834a2:
MOV R15,qword ptr [RAX]
CMP dword ptr [R15],0x1
JNZ 0x0018349b
CMP qword ptr [R15 + 0x10],R14
JNZ 0x0018349b
MOV RCX,qword ptr [R15 + 0x8]
MOV qword ptr [RAX],RCX
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [RBX + 0x30],RCX
MOV RSI,R14
CALL qword ptr [RBX + 0x10]
DEC qword ptr [RBX + 0x28]
MOV RDI,R15
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x30]
SUB RDX,RAX
ADD RDX,-0x8
MOV qword ptr [RBX + 0x30],RDX
MOV RDI,qword ptr [RBX + 0x40]
MOV RSI,R15
ADD RSP,0x10
POP RBX
POP R14
POP R15
JMP RCX
LAB_0018350a:
CALL 0x0010e090
|
void js_weakref_finalizer(long param_1,long param_2,int param_3)
{
int *piVar1;
int *piVar2;
long lVar3;
long *plVar4;
if ((param_3 == -1) && (*(short *)(param_2 + 6) == 0x3a)) {
plVar4 = *(long **)(param_2 + 0x30);
}
else {
plVar4 = (long *)0x0;
}
if (plVar4 == (long *)js_weakref_sentinel || plVar4 == (long *)0x0) {
return;
}
if ((int)plVar4[1] == -8) {
piVar2 = (int *)(*plVar4 + 0x10);
}
else {
if ((int)plVar4[1] != -1) {
/* WARNING: Subroutine does not return */
abort();
}
piVar2 = (int *)(*plVar4 + 0x28);
}
while ((piVar1 = *(int **)piVar2, *piVar1 != 1 || (*(long **)(piVar1 + 4) != plVar4))) {
piVar2 = piVar1 + 2;
}
*(int8 *)piVar2 = *(int8 *)(piVar1 + 2);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar3 = (**(code **)(param_1 + 0x20))(plVar4);
*(long *)(param_1 + 0x30) = (*(long *)(param_1 + 0x30) - lVar3) + -8;
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),plVar4);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar3 = (**(code **)(param_1 + 0x20))(piVar1);
lVar3 = (*(long *)(param_1 + 0x30) - lVar3) + -8;
*(long *)(param_1 + 0x30) = lVar3;
/* WARNING: Could not recover jumptable at 0x00183508. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x40),piVar1,lVar3,*(code **)(param_1 + 0x10));
return;
}
| |
28,458 | js_weakref_finalizer | bluesky950520[P]quickjs/quickjs.c | static void js_weakref_finalizer(JSRuntime *rt, JSValue val)
{
JSWeakRefData *wrd = JS_GetOpaque(val, JS_CLASS_WEAK_REF);
if (!wrd || wrd == &js_weakref_sentinel)
return;
/* Delete weak ref */
JSWeakRefRecord **pwr, *wr;
pwr = get_first_weak_ref(wrd->target);
for(;;) {
wr = *pwr;
assert(wr != NULL);
if (wr->kind == JS_WEAK_REF_KIND_WEAK_REF && wr->u.weak_ref_data == wrd)
break;
pwr = &wr->next_weak_ref;
}
*pwr = wr->next_weak_ref;
js_free_rt(rt, wrd);
js_free_rt(rt, wr);
} | O3 | c | js_weakref_finalizer:
pushq %r15
pushq %r14
pushq %rbx
cmpl $-0x1, %edx
jne 0x85e5c
cmpw $0x3a, 0x6(%rsi)
jne 0x85e5c
movq 0x30(%rsi), %r14
testq %r14, %r14
sete %al
leaq 0x48756(%rip), %rcx # 0xce5a8
cmpq %rcx, %r14
sete %cl
orb %al, %cl
je 0x85e62
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movq (%r14), %rax
movl 0x8(%r14), %edx
movl $0x28, %ecx
cmpl $-0x1, %edx
je 0x85e80
cmpl $-0x8, %edx
jne 0x85ef0
movl $0x10, %ecx
addq %rcx, %rax
movq (%rax), %r15
cmpl $0x1, (%r15)
jne 0x85e92
cmpq %r14, 0x10(%r15)
je 0x85e9b
addq $0x8, %r15
movq %r15, %rax
jmp 0x85e83
movq 0x8(%r15), %rcx
movq %rcx, (%rax)
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %r14, %rsi
callq *0x10(%rbx)
decq 0x28(%rbx)
movq %r15, %rdi
callq *0x20(%rbx)
movq 0x10(%rbx), %rcx
movq 0x30(%rbx), %rdx
subq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x30(%rbx)
movq 0x40(%rbx), %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
callq 0xe090
| js_weakref_finalizer:
push r15
push r14
push rbx
cmp edx, 0FFFFFFFFh
jnz short loc_85E5C
cmp word ptr [rsi+6], 3Ah ; ':'
jnz short loc_85E5C
mov r14, [rsi+30h]
test r14, r14
setz al
lea rcx, js_weakref_sentinel
cmp r14, rcx
setz cl
or cl, al
jz short loc_85E62
loc_85E5C:
pop rbx
pop r14
pop r15
retn
loc_85E62:
mov rbx, rdi
mov rax, [r14]
mov edx, [r14+8]
mov ecx, 28h ; '('
cmp edx, 0FFFFFFFFh
jz short loc_85E80
cmp edx, 0FFFFFFF8h
jnz short loc_85EF0
mov ecx, 10h
loc_85E80:
add rax, rcx
loc_85E83:
mov r15, [rax]
cmp dword ptr [r15], 1
jnz short loc_85E92
cmp [r15+10h], r14
jz short loc_85E9B
loc_85E92:
add r15, 8
mov rax, r15
jmp short loc_85E83
loc_85E9B:
mov rcx, [r15+8]
mov [rax], rcx
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, r14
call qword ptr [rbx+10h]
dec qword ptr [rbx+28h]
mov rdi, r15
call qword ptr [rbx+20h]
mov rcx, [rbx+10h]
mov rdx, [rbx+30h]
sub rdx, rax
add rdx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rdx
mov rdi, [rbx+40h]
mov rsi, r15
pop rbx
pop r14
pop r15
jmp rcx
loc_85EF0:
call _abort
| void js_weakref_finalizer(long long a1, long long a2, int a3)
{
unsigned int *v3; // r14
long long v5; // rdx
long long v6; // rcx
_QWORD *i; // rax
_DWORD *v8; // r15
long long v9; // rax
long long v10; // rdi
long long v11; // rax
void ( *v12)(_QWORD, _DWORD *); // rcx
if ( a3 == -1 && *(_WORD *)(a2 + 6) == 58 )
{
v3 = *(unsigned int **)(a2 + 48);
if ( v3 != 0LL && v3 != (unsigned int *)&js_weakref_sentinel )
{
v5 = v3[2];
v6 = 40LL;
if ( (_DWORD)v5 != -1 )
{
if ( (_DWORD)v5 != -8 )
abort((const char *)a1, a2, v5, 40LL);
v6 = 16LL;
}
for ( i = (_QWORD *)(v6 + *(_QWORD *)v3); ; i = v8 + 2 )
{
v8 = (_DWORD *)*i;
if ( *(_DWORD *)*i == 1 && *((unsigned int **)v8 + 2) == v3 )
break;
}
*i = *((_QWORD *)v8 + 1);
--*(_QWORD *)(a1 + 40);
v9 = (*(long long ( **)(unsigned int *))(a1 + 32))(v3);
v10 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v9 - 8;
(*(void ( **)(long long, unsigned int *))(a1 + 16))(v10, v3);
--*(_QWORD *)(a1 + 40);
v11 = (*(long long ( **)(_DWORD *))(a1 + 32))(v8);
v12 = *(void ( **)(_QWORD, _DWORD *))(a1 + 16);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v11 - 8;
v12(*(_QWORD *)(a1 + 64), v8);
}
}
}
| js_weakref_finalizer:
PUSH R15
PUSH R14
PUSH RBX
CMP EDX,-0x1
JNZ 0x00185e5c
CMP word ptr [RSI + 0x6],0x3a
JNZ 0x00185e5c
MOV R14,qword ptr [RSI + 0x30]
TEST R14,R14
SETZ AL
LEA RCX,[0x1ce5a8]
CMP R14,RCX
SETZ CL
OR CL,AL
JZ 0x00185e62
LAB_00185e5c:
POP RBX
POP R14
POP R15
RET
LAB_00185e62:
MOV RBX,RDI
MOV RAX,qword ptr [R14]
MOV EDX,dword ptr [R14 + 0x8]
MOV ECX,0x28
CMP EDX,-0x1
JZ 0x00185e80
CMP EDX,-0x8
JNZ 0x00185ef0
MOV ECX,0x10
LAB_00185e80:
ADD RAX,RCX
LAB_00185e83:
MOV R15,qword ptr [RAX]
CMP dword ptr [R15],0x1
JNZ 0x00185e92
CMP qword ptr [R15 + 0x10],R14
JZ 0x00185e9b
LAB_00185e92:
ADD R15,0x8
MOV RAX,R15
JMP 0x00185e83
LAB_00185e9b:
MOV RCX,qword ptr [R15 + 0x8]
MOV qword ptr [RAX],RCX
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [RBX + 0x30],RCX
MOV RSI,R14
CALL qword ptr [RBX + 0x10]
DEC qword ptr [RBX + 0x28]
MOV RDI,R15
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x30]
SUB RDX,RAX
ADD RDX,-0x8
MOV qword ptr [RBX + 0x30],RDX
MOV RDI,qword ptr [RBX + 0x40]
MOV RSI,R15
POP RBX
POP R14
POP R15
JMP RCX
LAB_00185ef0:
CALL 0x0010e090
|
void js_weakref_finalizer(long param_1,long param_2,int param_3)
{
long *plVar1;
int *piVar2;
int *piVar3;
long lVar4;
if (((param_3 == -1) && (*(short *)(param_2 + 6) == 0x3a)) &&
(plVar1 = *(long **)(param_2 + 0x30),
plVar1 != (long *)js_weakref_sentinel && plVar1 != (long *)0x0)) {
lVar4 = 0x28;
if ((int)plVar1[1] != -1) {
if ((int)plVar1[1] != -8) {
/* WARNING: Subroutine does not return */
abort();
}
lVar4 = 0x10;
}
piVar3 = (int *)(*plVar1 + lVar4);
while ((piVar2 = *(int **)piVar3, *piVar2 != 1 || (*(long **)(piVar2 + 4) != plVar1))) {
piVar3 = piVar2 + 2;
}
*(int8 *)piVar3 = *(int8 *)(piVar2 + 2);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar4 = (**(code **)(param_1 + 0x20))(plVar1);
*(long *)(param_1 + 0x30) = (*(long *)(param_1 + 0x30) - lVar4) + -8;
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),plVar1);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar4 = (**(code **)(param_1 + 0x20))(piVar2);
lVar4 = (*(long *)(param_1 + 0x30) - lVar4) + -8;
*(long *)(param_1 + 0x30) = lVar4;
/* WARNING: Could not recover jumptable at 0x00185eee. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x40),piVar2,lVar4,*(code **)(param_1 + 0x10));
return;
}
return;
}
| |
28,459 | engine_set_variable | navaro[P]qoraal-tictactoe/build_O3/_deps/qoraal_engine-src/src/engine.c | int32_t
engine_set_variable (PENGINE_T engine, uint32_t var, int32_t val)
{
int32_t res = ENGINE_OK ;
engine_port_lock () ;
if (var < ENGINE_REGISTER_COUNT) {
/* First registers are local to each engine. */
if (!engine) engine = _engine_active_instance ;
if (!engine) res = ENGINE_FAIL ;
else engine->reg[var] = val ;
} else {
/* All other registers are global to all engines. */
res = engine_port_variable_write (var - ENGINE_REGISTER_COUNT, val) ;
ENGINE_LOG (engine, ENGINE_LOG_TYPE_DEBUG,
"[dbg] var %d set %d", var, val) ;
}
engine_port_unlock () ;
return res ;
} | O3 | c | engine_set_variable:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
callq 0xda0b
cmpl $0x4, %r14d
ja 0xe79d
testq %r15, %r15
jne 0xe788
movq 0x320c8(%rip), %r15 # 0x40850
testq %r15, %r15
je 0xe7d2
movl %r14d, %eax
movl %ebx, 0x8c(%r15,%rax,4)
xorl %r12d, %r12d
jmp 0xe7d8
leal -0x5(%r14), %edi
movl %ebx, %esi
callq 0xdda2
movl %eax, %r12d
testb $0x1, 0x2fbc6(%rip) # 0x3e378
je 0xe7d8
leaq 0x17b9c(%rip), %rdx # 0x26357
movq %r15, %rdi
movl $0x1, %esi
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0xe379
jmp 0xe7d8
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
callq 0xda1c
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| engine_set_variable:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov ebx, edx
mov r14d, esi
mov r15, rdi
call engine_port_lock
cmp r14d, 4
ja short loc_E79D
test r15, r15
jnz short loc_E788
mov r15, cs:_engine_active_instance
loc_E788:
test r15, r15
jz short loc_E7D2
mov eax, r14d
mov [r15+rax*4+8Ch], ebx
xor r12d, r12d
jmp short loc_E7D8
loc_E79D:
lea edi, [r14-5]
mov esi, ebx
call engine_port_variable_write
mov r12d, eax
test byte ptr cs:_engine_log_filter, 1
jz short loc_E7D8
lea rdx, aDbgVarDSetD; "[dbg] var %d set %d"
mov rdi, r15
mov esi, 1
mov ecx, r14d
mov r8d, ebx
xor eax, eax
call engine_log
jmp short loc_E7D8
loc_E7D2:
mov r12d, 0FFFFFFFFh
loc_E7D8:
call engine_port_unlock
mov eax, r12d
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long engine_set_variable(
unsigned int *a1,
long long a2,
unsigned int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
unsigned int v12; // r14d
unsigned int *v13; // r15
long long v14; // rdx
long long v15; // rcx
unsigned int v16; // r12d
long long v17; // r9
__m128 v18; // xmm4
__m128 v19; // xmm5
char v21; // [rsp+0h] [rbp-20h]
v12 = a2;
v13 = a1;
engine_port_lock();
if ( (unsigned int)a2 > 4 )
{
a1 = (unsigned int *)(unsigned int)(a2 - 5);
a2 = a3;
v16 = engine_port_variable_write((unsigned int)a1, a3);
if ( (engine_log_filter & 1) != 0 )
{
a1 = v13;
a2 = 1LL;
engine_log(v13, 1, (long long)aDbgVarDSetD, v12, a3, v17, a4, a5, a6, a7, v18, v19, a10, a11, v21);
}
}
else
{
if ( !a1 )
v13 = (unsigned int *)engine_active_instance;
if ( v13 )
{
v13[(unsigned int)a2 + 35] = a3;
v16 = 0;
}
else
{
v16 = -1;
}
}
engine_port_unlock(a1, a2, v14, v15);
return v16;
}
| engine_set_variable:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBX,EDX
MOV R14D,ESI
MOV R15,RDI
CALL 0x0010da0b
CMP R14D,0x4
JA 0x0010e79d
TEST R15,R15
JNZ 0x0010e788
MOV R15,qword ptr [0x00140850]
LAB_0010e788:
TEST R15,R15
JZ 0x0010e7d2
MOV EAX,R14D
MOV dword ptr [R15 + RAX*0x4 + 0x8c],EBX
XOR R12D,R12D
JMP 0x0010e7d8
LAB_0010e79d:
LEA EDI,[R14 + -0x5]
MOV ESI,EBX
CALL 0x0010dda2
MOV R12D,EAX
TEST byte ptr [0x0013e378],0x1
JZ 0x0010e7d8
LEA RDX,[0x126357]
MOV RDI,R15
MOV ESI,0x1
MOV ECX,R14D
MOV R8D,EBX
XOR EAX,EAX
CALL 0x0010e379
JMP 0x0010e7d8
LAB_0010e7d2:
MOV R12D,0xffffffff
LAB_0010e7d8:
CALL 0x0010da1c
MOV EAX,R12D
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int4 engine_set_variable(long param_1,uint param_2,int4 param_3)
{
int4 uVar1;
engine_port_lock();
if (param_2 < 5) {
if (param_1 == 0) {
param_1 = _engine_active_instance;
}
if (param_1 == 0) {
uVar1 = 0xffffffff;
}
else {
*(int4 *)(param_1 + 0x8c + (ulong)param_2 * 4) = param_3;
uVar1 = 0;
}
}
else {
uVar1 = engine_port_variable_write(param_2 - 5,param_3);
if (((byte)_engine_log_filter & 1) != 0) {
engine_log(param_1,1,s__dbg__var__d_set__d_00126357,param_2,param_3);
}
}
engine_port_unlock();
return uVar1;
}
| |
28,460 | blst_bendian_from_scalar | corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/exports.c | void blst_bendian_from_scalar(unsigned char ret[32], const pow256 a)
{
vec256 out;
limbs_from_le_bytes(out, a, sizeof(out));
be_bytes_from_limbs(ret, out, sizeof(out));
vec_zero(out, sizeof(out));
} | O3 | c | blst_bendian_from_scalar:
pushq %rbp
movq %rsp, %rbp
movl $0x1f, %eax
xorl %ecx, %ecx
shlq $0x8, %rcx
movzbl (%rsi,%rax), %edx
orq %rdx, %rcx
movq %rax, %rdx
andq $-0x8, %rdx
movq %rcx, -0x20(%rbp,%rdx)
addq $-0x1, %rax
jb 0x2512b
movl $0x1f, %eax
movl $0xf8, %edx
movq %rax, %rcx
andq $-0x8, %rcx
movq -0x20(%rbp,%rcx), %rsi
movl %edx, %ecx
andb $0x38, %cl
shrq %cl, %rsi
movb %sil, (%rdi)
incq %rdi
addq $-0x8, %rdx
addq $-0x1, %rax
jb 0x25152
xorl %eax, %eax
movq $0x0, -0x20(%rbp,%rax,8)
incq %rax
cmpq $0x4, %rax
jne 0x25178
leaq -0x20(%rbp), %rax
popq %rbp
retq
| blst_bendian_from_scalar:
push rbp
mov rbp, rsp
mov eax, 1Fh
xor ecx, ecx
loc_2512B:
shl rcx, 8
movzx edx, byte ptr [rsi+rax]
or rcx, rdx
mov rdx, rax
and rdx, 0FFFFFFFFFFFFFFF8h
mov [rbp+rdx+var_20], rcx
add rax, 0FFFFFFFFFFFFFFFFh
jb short loc_2512B
mov eax, 1Fh
mov edx, 0F8h
loc_25152:
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF8h
mov rsi, [rbp+rcx+var_20]
mov ecx, edx
and cl, 38h
shr rsi, cl
mov [rdi], sil
inc rdi
add rdx, 0FFFFFFFFFFFFFFF8h
add rax, 0FFFFFFFFFFFFFFFFh
jb short loc_25152
xor eax, eax
loc_25178:
mov [rbp+rax*8+var_20], 0
inc rax
cmp rax, 4
jnz short loc_25178
lea rax, [rbp+var_20]
pop rbp
retn
| _QWORD * blst_bendian_from_scalar(_BYTE *a1, long long a2)
{
long long v2; // rax
unsigned long long v3; // rcx
bool v4; // cf
long long v5; // rax
long long v6; // rdx
long long i; // rax
_QWORD v9[4]; // [rsp+0h] [rbp-20h] BYREF
v2 = 31LL;
v3 = 0LL;
do
{
v3 = *(unsigned __int8 *)(a2 + v2) | (v3 << 8);
*(_QWORD *)((char *)v9 + (v2 & 0xFFFFFFFFFFFFFFF8LL)) = v3;
v4 = v2-- != 0;
}
while ( v4 );
v5 = 31LL;
v6 = 248LL;
do
{
*a1++ = *(_QWORD *)((char *)v9 + (v5 & 0xFFFFFFFFFFFFFFF8LL)) >> (v6 & 0x38);
v6 -= 8LL;
v4 = v5-- != 0;
}
while ( v4 );
for ( i = 0LL; i != 4; ++i )
v9[i] = 0LL;
return v9;
}
| blst_bendian_from_scalar:
PUSH RBP
MOV RBP,RSP
MOV EAX,0x1f
XOR ECX,ECX
LAB_0012512b:
SHL RCX,0x8
MOVZX EDX,byte ptr [RSI + RAX*0x1]
OR RCX,RDX
MOV RDX,RAX
AND RDX,-0x8
MOV qword ptr [RBP + RDX*0x1 + -0x20],RCX
ADD RAX,-0x1
JC 0x0012512b
MOV EAX,0x1f
MOV EDX,0xf8
LAB_00125152:
MOV RCX,RAX
AND RCX,-0x8
MOV RSI,qword ptr [RBP + RCX*0x1 + -0x20]
MOV ECX,EDX
AND CL,0x38
SHR RSI,CL
MOV byte ptr [RDI],SIL
INC RDI
ADD RDX,-0x8
ADD RAX,-0x1
JC 0x00125152
XOR EAX,EAX
LAB_00125178:
MOV qword ptr [RBP + RAX*0x8 + -0x20],0x0
INC RAX
CMP RAX,0x4
JNZ 0x00125178
LEA RAX,[RBP + -0x20]
POP RBP
RET
|
ulong * blst_bendian_from_scalar(int1 *param_1,long param_2)
{
ulong uVar1;
long lVar2;
ulong uVar3;
byte bVar4;
bool bVar5;
ulong local_28 [4];
uVar1 = 0x1f;
uVar3 = 0;
do {
uVar3 = uVar3 << 8 | (ulong)*(byte *)(param_2 + uVar1);
*(ulong *)((long)local_28 + (uVar1 & 0xfffffffffffffff8)) = uVar3;
bVar5 = uVar1 != 0;
uVar1 = uVar1 - 1;
} while (bVar5);
uVar1 = 0x1f;
bVar4 = 0xf8;
do {
*param_1 = (char)(*(ulong *)((long)local_28 + (uVar1 & 0xfffffffffffffff8)) >> (bVar4 & 0x38));
param_1 = param_1 + 1;
bVar4 = bVar4 - 8;
bVar5 = uVar1 != 0;
uVar1 = uVar1 - 1;
} while (bVar5);
lVar2 = 0;
do {
local_28[lVar2] = 0;
lVar2 = lVar2 + 1;
} while (lVar2 != 4);
return local_28;
}
| |
28,461 | mysql_stmt_bind_param | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | my_bool STDCALL mysql_stmt_bind_param(MYSQL_STMT *stmt, MYSQL_BIND *bind)
{
MYSQL *mysql= stmt->mysql;
if (!mysql)
{
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
return(1);
}
/* If number of parameters was specified via mysql_stmt_attr_set we need to realloc
them, e.g. for mariadb_stmt_execute_direct()
*/
if ((stmt->state < MYSQL_STMT_PREPARED || stmt->state >= MYSQL_STMT_EXECUTED) &&
stmt->prebind_params > 0)
{
if (!stmt->params && stmt->prebind_params)
{
if (!(stmt->params= (MYSQL_BIND *)ma_alloc_root(&stmt->mem_root, stmt->prebind_params * sizeof(MYSQL_BIND))))
{
SET_CLIENT_STMT_ERROR(stmt, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return(1);
}
memset(stmt->params, '\0', stmt->prebind_params * sizeof(MYSQL_BIND));
}
stmt->param_count= stmt->prebind_params;
}
else if (stmt->state < MYSQL_STMT_PREPARED) {
SET_CLIENT_STMT_ERROR(stmt, CR_NO_PREPARE_STMT, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->param_count && bind)
{
uint i;
memcpy(stmt->params, bind, sizeof(MYSQL_BIND) * stmt->param_count);
stmt->send_types_to_server= 1;
for (i=0; i < stmt->param_count; i++)
{
if (stmt->mysql->methods->db_supported_buffer_type &&
!stmt->mysql->methods->db_supported_buffer_type(stmt->params[i].buffer_type))
{
SET_CLIENT_STMT_ERROR(stmt, CR_UNSUPPORTED_PARAM_TYPE, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (!stmt->params[i].is_null)
stmt->params[i].is_null= &is_not_null;
if (stmt->params[i].long_data_used)
stmt->params[i].long_data_used= 0;
if (!stmt->params[i].length)
stmt->params[i].length= &stmt->params[i].buffer_length;
switch(stmt->params[i].buffer_type) {
case MYSQL_TYPE_NULL:
stmt->params[i].is_null= &is_null;
break;
case MYSQL_TYPE_TINY:
stmt->params[i].buffer_length= 1;
break;
case MYSQL_TYPE_SHORT:
case MYSQL_TYPE_YEAR:
stmt->params[i].buffer_length= 2;
break;
case MYSQL_TYPE_LONG:
case MYSQL_TYPE_FLOAT:
stmt->params[i].buffer_length= 4;
break;
case MYSQL_TYPE_LONGLONG:
case MYSQL_TYPE_DOUBLE:
stmt->params[i].buffer_length= 8;
break;
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
stmt->params[i].buffer_length= 12;
break;
case MYSQL_TYPE_TIME:
stmt->params[i].buffer_length= 13;
break;
case MYSQL_TYPE_DATE:
stmt->params[i].buffer_length= 5;
break;
case MYSQL_TYPE_STRING:
case MYSQL_TYPE_JSON:
case MYSQL_TYPE_VAR_STRING:
case MYSQL_TYPE_BLOB:
case MYSQL_TYPE_TINY_BLOB:
case MYSQL_TYPE_MEDIUM_BLOB:
case MYSQL_TYPE_LONG_BLOB:
case MYSQL_TYPE_DECIMAL:
case MYSQL_TYPE_NEWDECIMAL:
break;
default:
SET_CLIENT_STMT_ERROR(stmt, CR_UNSUPPORTED_PARAM_TYPE, SQLSTATE_UNKNOWN, 0);
return(1);
break;
}
}
}
stmt->bind_param_done= stmt->send_types_to_server= 1;
CLEAR_CLIENT_STMT_ERROR(stmt);
return(0);
} | O3 | c | mysql_stmt_bind_param:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
je 0x2497b
movq %rsi, %r14
movl 0x50(%rbx), %ecx
cmpl $0x1, %ecx
je 0x249dc
movl 0x378(%rbx), %eax
testq %rax, %rax
je 0x249d4
cmpq $0x0, 0x70(%rbx)
jne 0x24976
imulq $0x70, %rax, %rsi
movq %rbx, %rdi
callq 0x2263f
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0x24bf6
movl 0x378(%rbx), %ecx
imulq $0x70, %rcx, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x13270
movl 0x378(%rbx), %eax
movl %eax, 0x64(%rbx)
jmp 0x249dc
movl $0x7dd, 0x108(%rbx) # imm = 0x7DD
leaq 0x30d(%rbx), %rdi
leaq 0x2b66d(%rip), %rax # 0x50000
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13230
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x2b658(%rip), %rax # 0x50010
movq 0x68(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13230
movb %r14b, 0x30b(%rbx)
movb $0x1, %al
jmp 0x24b55
testl %ecx, %ecx
je 0x24bad
movl 0x64(%rbx), %eax
testq %rax, %rax
sete %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x24b24
movq 0x70(%rbx), %rdi
imulq $0x70, %rax, %rdx
movq %r14, %rsi
callq 0x133a0
movb $0x1, 0x68(%rbx)
cmpl $0x0, 0x64(%rbx)
je 0x24b24
movl $0x40, %r14d
xorl %r15d, %r15d
movl $0x3f3, %r13d # imm = 0x3F3
leaq 0x19c25(%rip), %r12 # 0x3e64c
movq 0x38(%rbx), %rcx
movq 0x70(%rbx), %rax
movq 0x4d0(%rcx), %rcx
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
je 0x24a52
movl 0x20(%rax,%r14), %edi
callq *%rcx
testb %al, %al
je 0x24b64
movq 0x70(%rbx), %rax
cmpq $0x0, -0x38(%rax,%r14)
jne 0x24a6a
leaq 0x2bad1(%rip), %rcx # 0x50532
movq %rcx, -0x38(%rax,%r14)
movq 0x70(%rbx), %rax
cmpb $0x0, 0x26(%rax,%r14)
je 0x24a7c
movb $0x0, 0x26(%rax,%r14)
movq 0x70(%rbx), %rax
cmpq $0x0, -0x40(%rax,%r14)
jne 0x24a91
leaq (%rax,%r14), %rcx
movq %rcx, -0x40(%rax,%r14)
movq 0x70(%rbx), %rax
movl 0x20(%rax,%r14), %ecx
cmpq $0xd, %rcx
ja 0x24aaf
movslq (%r12,%rcx,4), %rcx
addq %r12, %rcx
jmpq *%rcx
movq $0x2, (%rax,%r14)
jmp 0x24b11
addl $0xffffff0b, %ecx # imm = 0xFFFFFF0B
cmpl $0x9, %ecx
ja 0x24b64
btl %ecx, %r13d
jb 0x24b11
jmp 0x24b64
movq $0x4, (%rax,%r14)
jmp 0x24b11
movq $0x8, (%rax,%r14)
jmp 0x24b11
movq $0xc, (%rax,%r14)
jmp 0x24b11
movq $0xd, (%rax,%r14)
jmp 0x24b11
movq $0x1, (%rax,%r14)
jmp 0x24b11
leaq 0x2a61e(%rip), %rcx # 0x4f120
movq %rcx, -0x38(%rax,%r14)
jmp 0x24b11
movq $0x5, (%rax,%r14)
incq %r15
movl 0x64(%rbx), %eax
addq $0x70, %r14
cmpq %rax, %r15
jb 0x24a27
movb $0x1, %al
movb %al, 0x68(%rbx)
movb %al, 0xe9(%rbx)
movl $0x0, 0x108(%rbx)
movl $0x30303030, 0x30d(%rbx) # imm = 0x30303030
movw $0x30, 0x311(%rbx)
movb $0x0, 0x10c(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x7f4, 0x108(%rbx) # imm = 0x7F4
leaq 0x30d(%rbx), %rdi
leaq 0x2b484(%rip), %rax # 0x50000
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13230
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x2b46f(%rip), %rax # 0x50010
movq 0x120(%rax), %rsi
jmp 0x249bc
movl $0x7ee, 0x108(%rbx) # imm = 0x7EE
leaq 0x30d(%rbx), %rdi
leaq 0x2b43b(%rip), %rax # 0x50000
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13230
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x2b426(%rip), %rax # 0x50010
movq 0xf0(%rax), %rsi
jmp 0x249bc
movl $0x7d8, 0x108(%rbx) # imm = 0x7D8
leaq 0x30d(%rbx), %rdi
leaq 0x2b3f2(%rip), %rax # 0x50000
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13230
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x2b3dd(%rip), %rax # 0x50010
movq 0x40(%rax), %rsi
jmp 0x249bc
| mysql_stmt_bind_param:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
cmp qword ptr [rdi+38h], 0
jz short loc_2497B
mov r14, rsi
mov ecx, [rbx+50h]
cmp ecx, 1
jz loc_249DC
mov eax, [rbx+378h]
test rax, rax
jz loc_249D4
cmp qword ptr [rbx+70h], 0
jnz short loc_24976
imul rsi, rax, 70h ; 'p'
mov rdi, rbx
call ma_alloc_root
mov [rbx+70h], rax
test rax, rax
jz loc_24BF6
mov ecx, [rbx+378h]
imul rdx, rcx, 70h ; 'p'
mov rdi, rax
xor esi, esi
call _memset
mov eax, [rbx+378h]
loc_24976:
mov [rbx+64h], eax
jmp short loc_249DC
loc_2497B:
mov dword ptr [rbx+108h], 7DDh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+68h]
loc_249BC:
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
mov al, 1
jmp loc_24B55
loc_249D4:
test ecx, ecx
jz loc_24BAD
loc_249DC:
mov eax, [rbx+64h]
test rax, rax
setz cl
test r14, r14
setz dl
or dl, cl
jnz loc_24B24
mov rdi, [rbx+70h]
imul rdx, rax, 70h ; 'p'
mov rsi, r14
call _memcpy
mov byte ptr [rbx+68h], 1
cmp dword ptr [rbx+64h], 0
jz loc_24B24
mov r14d, 40h ; '@'
xor r15d, r15d
mov r13d, 3F3h
lea r12, jpt_24AA3
loc_24A27:
mov rcx, [rbx+38h]
mov rax, [rbx+70h]
mov rcx, [rcx+4D0h]
mov rcx, [rcx+38h]
test rcx, rcx
jz short loc_24A52
mov edi, [rax+r14+20h]
call rcx
test al, al
jz loc_24B64; jumptable 0000000000024AA3 case 9
mov rax, [rbx+70h]
loc_24A52:
cmp qword ptr [rax+r14-38h], 0
jnz short loc_24A6A
lea rcx, is_not_null
mov [rax+r14-38h], rcx
mov rax, [rbx+70h]
loc_24A6A:
cmp byte ptr [rax+r14+26h], 0
jz short loc_24A7C
mov byte ptr [rax+r14+26h], 0
mov rax, [rbx+70h]
loc_24A7C:
cmp qword ptr [rax+r14-40h], 0
jnz short loc_24A91
lea rcx, [rax+r14]
mov [rax+r14-40h], rcx
mov rax, [rbx+70h]
loc_24A91:
mov ecx, [rax+r14+20h]
cmp rcx, 0Dh; switch 14 cases
ja short def_24AA3; jumptable 0000000000024AA3 default case
movsxd rcx, ds:(jpt_24AA3 - 3E64Ch)[r12+rcx*4]
add rcx, r12
jmp rcx; switch jump
loc_24AA5:
mov qword ptr [rax+r14], 2; jumptable 0000000000024AA3 cases 2,13
jmp short loc_24B11; jumptable 0000000000024AA3 case 0
def_24AA3:
add ecx, 0FFFFFF0Bh; jumptable 0000000000024AA3 default case
cmp ecx, 9
ja loc_24B64; jumptable 0000000000024AA3 case 9
bt r13d, ecx
jb short loc_24B11; jumptable 0000000000024AA3 case 0
jmp loc_24B64; jumptable 0000000000024AA3 case 9
loc_24AC9:
mov qword ptr [rax+r14], 4; jumptable 0000000000024AA3 cases 3,4
jmp short loc_24B11; jumptable 0000000000024AA3 case 0
loc_24AD3:
mov qword ptr [rax+r14], 8; jumptable 0000000000024AA3 cases 5,8
jmp short loc_24B11; jumptable 0000000000024AA3 case 0
loc_24ADD:
mov qword ptr [rax+r14], 0Ch; jumptable 0000000000024AA3 cases 7,12
jmp short loc_24B11; jumptable 0000000000024AA3 case 0
loc_24AE7:
mov qword ptr [rax+r14], 0Dh; jumptable 0000000000024AA3 case 11
jmp short loc_24B11; jumptable 0000000000024AA3 case 0
loc_24AF1:
mov qword ptr [rax+r14], 1; jumptable 0000000000024AA3 case 1
jmp short loc_24B11; jumptable 0000000000024AA3 case 0
loc_24AFB:
lea rcx, is_null; jumptable 0000000000024AA3 case 6
mov [rax+r14-38h], rcx
jmp short loc_24B11; jumptable 0000000000024AA3 case 0
loc_24B09:
mov qword ptr [rax+r14], 5; jumptable 0000000000024AA3 case 10
loc_24B11:
inc r15; jumptable 0000000000024AA3 case 0
mov eax, [rbx+64h]
add r14, 70h ; 'p'
cmp r15, rax
jb loc_24A27
loc_24B24:
mov al, 1
mov [rbx+68h], al
mov [rbx+0E9h], al
mov dword ptr [rbx+108h], 0
mov dword ptr [rbx+30Dh], 30303030h
mov word ptr [rbx+311h], 30h ; '0'
mov byte ptr [rbx+10Ch], 0
xor eax, eax
loc_24B55:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_24B64:
mov dword ptr [rbx+108h], 7F4h; jumptable 0000000000024AA3 case 9
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+120h]
jmp loc_249BC
loc_24BAD:
mov dword ptr [rbx+108h], 7EEh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+0F0h]
jmp loc_249BC
loc_24BF6:
mov dword ptr [rbx+108h], 7D8h
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+40h]
jmp loc_249BC
| char mysql_stmt_bind_param(long long a1, long long a2)
{
int v3; // ecx
long long v4; // rax
char *v5; // rax
long long v6; // rdi
char *v7; // rsi
long long v9; // rax
long long v10; // r14
unsigned long long v11; // r15
int v12; // r13d
long long v13; // rax
unsigned __int8 ( *v14)(_QWORD); // rcx
unsigned int v15; // ecx
if ( !*(_QWORD *)(a1 + 56) )
{
*(_DWORD *)(a1 + 264) = 2013;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v6 = a1 + 268;
v7 = client_errors[13];
goto LABEL_9;
}
v3 = *(_DWORD *)(a1 + 80);
if ( v3 == 1 )
goto LABEL_11;
v4 = *(unsigned int *)(a1 + 888);
if ( *(_DWORD *)(a1 + 888) )
{
if ( *(_QWORD *)(a1 + 112) )
{
LABEL_7:
*(_DWORD *)(a1 + 100) = v4;
goto LABEL_11;
}
v5 = ma_alloc_root(a1, 112 * v4);
*(_QWORD *)(a1 + 112) = v5;
if ( v5 )
{
memset(v5, 0LL, 112LL * *(unsigned int *)(a1 + 888));
LODWORD(v4) = *(_DWORD *)(a1 + 888);
goto LABEL_7;
}
*(_DWORD *)(a1 + 264) = 2008;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v6 = a1 + 268;
v7 = client_errors[8];
LABEL_9:
strncpy(v6, v7, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
if ( !v3 )
{
*(_DWORD *)(a1 + 264) = 2030;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v6 = a1 + 268;
v7 = client_errors[30];
goto LABEL_9;
}
LABEL_11:
v9 = *(unsigned int *)(a1 + 100);
if ( v9 != 0 && a2 != 0 )
{
memcpy(*(_QWORD *)(a1 + 112), a2, 112 * v9);
*(_BYTE *)(a1 + 104) = 1;
if ( *(_DWORD *)(a1 + 100) )
{
v10 = 64LL;
v11 = 0LL;
v12 = 1011;
do
{
v13 = *(_QWORD *)(a1 + 112);
v14 = *(unsigned __int8 ( **)(_QWORD))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL) + 56LL);
if ( v14 )
{
if ( !v14(*(unsigned int *)(v13 + v10 + 32)) )
{
LABEL_38:
*(_DWORD *)(a1 + 264) = 2036;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v6 = a1 + 268;
v7 = client_errors[36];
goto LABEL_9;
}
v13 = *(_QWORD *)(a1 + 112);
}
if ( !*(_QWORD *)(v13 + v10 - 56) )
{
*(_QWORD *)(v13 + v10 - 56) = &is_not_null;
v13 = *(_QWORD *)(a1 + 112);
}
if ( *(_BYTE *)(v13 + v10 + 38) )
{
*(_BYTE *)(v13 + v10 + 38) = 0;
v13 = *(_QWORD *)(a1 + 112);
}
if ( !*(_QWORD *)(v13 + v10 - 64) )
{
*(_QWORD *)(v13 + v10 - 64) = v13 + v10;
v13 = *(_QWORD *)(a1 + 112);
}
switch ( *(_DWORD *)(v13 + v10 + 32) )
{
case 0:
break;
case 1:
*(_QWORD *)(v13 + v10) = 1LL;
break;
case 2:
case 0xD:
*(_QWORD *)(v13 + v10) = 2LL;
break;
case 3:
case 4:
*(_QWORD *)(v13 + v10) = 4LL;
break;
case 5:
case 8:
*(_QWORD *)(v13 + v10) = 8LL;
break;
case 6:
*(_QWORD *)(v13 + v10 - 56) = &is_null;
break;
case 7:
case 0xC:
*(_QWORD *)(v13 + v10) = 12LL;
break;
case 9:
goto LABEL_38;
case 0xA:
*(_QWORD *)(v13 + v10) = 5LL;
break;
case 0xB:
*(_QWORD *)(v13 + v10) = 13LL;
break;
default:
v15 = *(_DWORD *)(v13 + v10 + 32) - 245;
if ( v15 > 9 || !_bittest(&v12, v15) )
goto LABEL_38;
break;
}
++v11;
v10 += 112LL;
}
while ( v11 < *(unsigned int *)(a1 + 100) );
}
}
*(_BYTE *)(a1 + 104) = 1;
*(_BYTE *)(a1 + 233) = 1;
*(_DWORD *)(a1 + 264) = 0;
strcpy((char *)(a1 + 781), "00000");
*(_BYTE *)(a1 + 268) = 0;
return 0;
}
| mysql_stmt_bind_param:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP qword ptr [RDI + 0x38],0x0
JZ 0x0012497b
MOV R14,RSI
MOV ECX,dword ptr [RBX + 0x50]
CMP ECX,0x1
JZ 0x001249dc
MOV EAX,dword ptr [RBX + 0x378]
TEST RAX,RAX
JZ 0x001249d4
CMP qword ptr [RBX + 0x70],0x0
JNZ 0x00124976
IMUL RSI,RAX,0x70
MOV RDI,RBX
CALL 0x0012263f
MOV qword ptr [RBX + 0x70],RAX
TEST RAX,RAX
JZ 0x00124bf6
MOV ECX,dword ptr [RBX + 0x378]
IMUL RDX,RCX,0x70
MOV RDI,RAX
XOR ESI,ESI
CALL 0x00113270
MOV EAX,dword ptr [RBX + 0x378]
LAB_00124976:
MOV dword ptr [RBX + 0x64],EAX
JMP 0x001249dc
LAB_0012497b:
MOV dword ptr [RBX + 0x108],0x7dd
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x150000]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113230
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x150010]
MOV RSI,qword ptr [RAX + 0x68]
LAB_001249bc:
MOV EDX,0x200
CALL 0x00113230
MOV byte ptr [RBX + 0x30b],R14B
MOV AL,0x1
JMP 0x00124b55
LAB_001249d4:
TEST ECX,ECX
JZ 0x00124bad
LAB_001249dc:
MOV EAX,dword ptr [RBX + 0x64]
TEST RAX,RAX
SETZ CL
TEST R14,R14
SETZ DL
OR DL,CL
JNZ 0x00124b24
MOV RDI,qword ptr [RBX + 0x70]
IMUL RDX,RAX,0x70
MOV RSI,R14
CALL 0x001133a0
MOV byte ptr [RBX + 0x68],0x1
CMP dword ptr [RBX + 0x64],0x0
JZ 0x00124b24
MOV R14D,0x40
XOR R15D,R15D
MOV R13D,0x3f3
LEA R12,[0x13e64c]
LAB_00124a27:
MOV RCX,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RBX + 0x70]
MOV RCX,qword ptr [RCX + 0x4d0]
MOV RCX,qword ptr [RCX + 0x38]
TEST RCX,RCX
JZ 0x00124a52
MOV EDI,dword ptr [RAX + R14*0x1 + 0x20]
CALL RCX
TEST AL,AL
JZ 0x00124b64
MOV RAX,qword ptr [RBX + 0x70]
LAB_00124a52:
CMP qword ptr [RAX + R14*0x1 + -0x38],0x0
JNZ 0x00124a6a
LEA RCX,[0x150532]
MOV qword ptr [RAX + R14*0x1 + -0x38],RCX
MOV RAX,qword ptr [RBX + 0x70]
LAB_00124a6a:
CMP byte ptr [RAX + R14*0x1 + 0x26],0x0
JZ 0x00124a7c
MOV byte ptr [RAX + R14*0x1 + 0x26],0x0
MOV RAX,qword ptr [RBX + 0x70]
LAB_00124a7c:
CMP qword ptr [RAX + R14*0x1 + -0x40],0x0
JNZ 0x00124a91
LEA RCX,[RAX + R14*0x1]
MOV qword ptr [RAX + R14*0x1 + -0x40],RCX
MOV RAX,qword ptr [RBX + 0x70]
LAB_00124a91:
MOV ECX,dword ptr [RAX + R14*0x1 + 0x20]
CMP RCX,0xd
JA 0x00124aaf
MOVSXD RCX,dword ptr [R12 + RCX*0x4]
ADD RCX,R12
switchD:
JMP RCX
caseD_2:
MOV qword ptr [RAX + R14*0x1],0x2
JMP 0x00124b11
default:
ADD ECX,0xffffff0b
CMP ECX,0x9
JA 0x00124b64
BT R13D,ECX
JC 0x00124b11
JMP 0x00124b64
caseD_3:
MOV qword ptr [RAX + R14*0x1],0x4
JMP 0x00124b11
caseD_5:
MOV qword ptr [RAX + R14*0x1],0x8
JMP 0x00124b11
caseD_7:
MOV qword ptr [RAX + R14*0x1],0xc
JMP 0x00124b11
caseD_b:
MOV qword ptr [RAX + R14*0x1],0xd
JMP 0x00124b11
caseD_1:
MOV qword ptr [RAX + R14*0x1],0x1
JMP 0x00124b11
caseD_6:
LEA RCX,[0x14f120]
MOV qword ptr [RAX + R14*0x1 + -0x38],RCX
JMP 0x00124b11
caseD_a:
MOV qword ptr [RAX + R14*0x1],0x5
caseD_0:
INC R15
MOV EAX,dword ptr [RBX + 0x64]
ADD R14,0x70
CMP R15,RAX
JC 0x00124a27
LAB_00124b24:
MOV AL,0x1
MOV byte ptr [RBX + 0x68],AL
MOV byte ptr [RBX + 0xe9],AL
MOV dword ptr [RBX + 0x108],0x0
MOV dword ptr [RBX + 0x30d],0x30303030
MOV word ptr [RBX + 0x311],0x30
MOV byte ptr [RBX + 0x10c],0x0
XOR EAX,EAX
LAB_00124b55:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
caseD_9:
MOV dword ptr [RBX + 0x108],0x7f4
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x150000]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113230
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x150010]
MOV RSI,qword ptr [RAX + 0x120]
JMP 0x001249bc
LAB_00124bad:
MOV dword ptr [RBX + 0x108],0x7ee
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x150000]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113230
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x150010]
MOV RSI,qword ptr [RAX + 0xf0]
JMP 0x001249bc
LAB_00124bf6:
MOV dword ptr [RBX + 0x108],0x7d8
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x150000]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113230
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x150010]
MOV RSI,qword ptr [RAX + 0x40]
JMP 0x001249bc
|
int8 mysql_stmt_bind_param(long param_1,void *param_2)
{
code *pcVar1;
char cVar2;
int iVar3;
void *__s;
int8 uVar4;
long lVar5;
uint uVar6;
char *__src;
long lVar7;
ulong uVar8;
if (*(long *)(param_1 + 0x38) == 0) {
*(int4 *)(param_1 + 0x108) = 0x7dd;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Lost_connection_to_server_during_00150078;
LAB_001249bc:
strncpy((char *)(param_1 + 0x10c),__src,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
uVar4 = 1;
}
else {
if (*(int *)(param_1 + 0x50) != 1) {
iVar3 = *(int *)(param_1 + 0x378);
if (iVar3 == 0) {
if (*(int *)(param_1 + 0x50) == 0) {
*(int4 *)(param_1 + 0x108) = 0x7ee;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Statement_is_not_prepared_00150100;
goto LAB_001249bc;
}
}
else {
if (*(long *)(param_1 + 0x70) == 0) {
__s = (void *)ma_alloc_root(param_1);
*(void **)(param_1 + 0x70) = __s;
if (__s == (void *)0x0) {
*(int4 *)(param_1 + 0x108) = 0x7d8;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Client_run_out_of_memory_00150050;
goto LAB_001249bc;
}
memset(__s,0,(ulong)*(uint *)(param_1 + 0x378) * 0x70);
iVar3 = *(int *)(param_1 + 0x378);
}
*(int *)(param_1 + 100) = iVar3;
}
}
if (param_2 != (void *)0x0 && (ulong)*(uint *)(param_1 + 100) != 0) {
memcpy(*(void **)(param_1 + 0x70),param_2,(ulong)*(uint *)(param_1 + 100) * 0x70);
*(int1 *)(param_1 + 0x68) = 1;
if (*(int *)(param_1 + 100) != 0) {
lVar7 = 0x40;
uVar8 = 0;
do {
lVar5 = *(long *)(param_1 + 0x70);
pcVar1 = *(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x38);
if (pcVar1 != (code *)0x0) {
cVar2 = (*pcVar1)(*(int4 *)(lVar5 + 0x20 + lVar7));
if (cVar2 != '\0') {
lVar5 = *(long *)(param_1 + 0x70);
goto LAB_00124a52;
}
switchD_00124aa3_caseD_9:
*(int4 *)(param_1 + 0x108) = 0x7f4;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Buffer_type_is_not_supported_00150130;
goto LAB_001249bc;
}
LAB_00124a52:
if (*(long *)(lVar5 + -0x38 + lVar7) == 0) {
*(int1 **)(lVar5 + -0x38 + lVar7) = &is_not_null;
lVar5 = *(long *)(param_1 + 0x70);
}
if (*(char *)(lVar5 + 0x26 + lVar7) != '\0') {
*(int1 *)(lVar5 + 0x26 + lVar7) = 0;
lVar5 = *(long *)(param_1 + 0x70);
}
if (*(long *)(lVar5 + -0x40 + lVar7) == 0) {
*(long *)(lVar5 + -0x40 + lVar7) = lVar5 + lVar7;
lVar5 = *(long *)(param_1 + 0x70);
}
iVar3 = *(int *)(lVar5 + 0x20 + lVar7);
switch(iVar3) {
case 0:
break;
case 1:
*(int8 *)(lVar5 + lVar7) = 1;
break;
case 2:
case 0xd:
*(int8 *)(lVar5 + lVar7) = 2;
break;
case 3:
case 4:
*(int8 *)(lVar5 + lVar7) = 4;
break;
case 5:
case 8:
*(int8 *)(lVar5 + lVar7) = 8;
break;
case 6:
*(int1 **)(lVar5 + -0x38 + lVar7) = &is_null;
break;
case 7:
case 0xc:
*(int8 *)(lVar5 + lVar7) = 0xc;
break;
case 9:
goto switchD_00124aa3_caseD_9;
case 10:
*(int8 *)(lVar5 + lVar7) = 5;
break;
case 0xb:
*(int8 *)(lVar5 + lVar7) = 0xd;
break;
default:
uVar6 = iVar3 - 0xf5;
if ((9 < uVar6) || ((0x3f3U >> (uVar6 & 0x1f) & 1) == 0)) goto switchD_00124aa3_caseD_9;
}
uVar8 = uVar8 + 1;
lVar7 = lVar7 + 0x70;
} while (uVar8 < *(uint *)(param_1 + 100));
}
}
*(int1 *)(param_1 + 0x68) = 1;
*(int1 *)(param_1 + 0xe9) = 1;
*(int4 *)(param_1 + 0x108) = 0;
*(int4 *)(param_1 + 0x30d) = 0x30303030;
*(int2 *)(param_1 + 0x311) = 0x30;
*(int1 *)(param_1 + 0x10c) = 0;
uVar4 = 0;
}
return uVar4;
}
| |
28,462 | llama_sbatch::split_equal(unsigned long) | monkey531[P]llama/src/llama-batch.cpp | llama_ubatch llama_sbatch::split_equal(size_t n_ubatch) {
n_ubatch = n_tokens < n_ubatch ? n_tokens : n_ubatch;
llama_ubatch ubatch = reserve_ubatch(n_ubatch, /* has_embd */ batch->embd != nullptr);
if (!seq.empty()) {
size_t length = 0;
size_t n_tokens_in_ubatch = 0;
GGML_ASSERT(seq[0].n_seq_id > 0); // should not be mixed with simple splits
// smallest first, because it's easier to split this way;
// starting from the end to pop in constant time.
for (size_t i = seq.size(); i-- > 0;) {
llama_sbatch_seq & s = seq[i];
GGML_ASSERT(s.length > 0);
if (length == 0) {
length = s.length < n_ubatch ? s.length : n_ubatch;
}
add_seq_to_ubatch(ubatch, s, length);
n_tokens_in_ubatch += length;
// shared prompts can't be mixed with any of their sequences,
// so it's safer to compute them in their own ubatch
if (s.n_seq_id > 1) { break; }
// stop when there isn't enough space for another sequence
if (length + n_tokens_in_ubatch > n_ubatch) { break; }
}
}
return ubatch;
} | O3 | cpp | llama_sbatch::split_equal(unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq (%rsi), %rax
movq 0x60(%rsi), %rsi
cmpq %rdx, %rax
cmovbq %rax, %rdx
xorl %ecx, %ecx
cmpq $0x0, 0x10(%rsi)
setne %cl
movq %rdi, 0x8(%rsp)
movq %r14, %rsi
movq %rdx, 0x10(%rsp)
callq 0x6a260
movq 0x48(%r14), %rax
movq 0x50(%r14), %rbp
cmpq %rbp, %rax
je 0x97947
cmpl $0x0, (%rax)
jle 0x9797c
subq %rax, %rbp
movq %rbp, %rbx
sarq $0x5, %rbx
incq %rbx
addq $-0x20, %rbp
xorl %r12d, %r12d
xorl %r15d, %r15d
decq %rbx
je 0x97947
movq 0x48(%r14), %r13
movq 0x18(%r13,%rbp), %rax
testq %rax, %rax
je 0x9795b
addq %rbp, %r13
movq 0x10(%rsp), %rcx
cmpq %rcx, %rax
cmovaeq %rcx, %rax
testq %r12, %r12
cmoveq %rax, %r12
movq %r14, %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x66d30
cmpl $0x1, (%r13)
jg 0x97947
addq $-0x20, %rbp
addq %r12, %r15
leaq (%r15,%r12), %rax
cmpq 0x10(%rsp), %rax
jbe 0x978f2
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7c0fe(%rip), %rdi # 0x113a60
leaq 0x78a5b(%rip), %rdx # 0x1103c4
leaq 0x7c259(%rip), %rcx # 0x113bc9
movl $0xa4, %esi
xorl %eax, %eax
callq 0x6af70
leaq 0x7c0dd(%rip), %rdi # 0x113a60
leaq 0x78a3a(%rip), %rdx # 0x1103c4
leaq 0x7c224(%rip), %rcx # 0x113bb5
movl $0x9f, %esi
jmp 0x97975
| _ZN12llama_sbatch11split_equalEm:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rsi
mov rax, [rsi]
mov rsi, [rsi+60h]
cmp rax, rdx
cmovb rdx, rax; bool
xor ecx, ecx
cmp qword ptr [rsi+10h], 0
setnz cl
mov [rsp+48h+var_40], rdi
mov rsi, r14; unsigned __int64
mov [rsp+48h+var_38], rdx
call __ZN12llama_sbatch14reserve_ubatchEmb; llama_sbatch::reserve_ubatch(ulong,bool)
mov rax, [r14+48h]
mov rbp, [r14+50h]
cmp rax, rbp
jz short loc_97947
cmp dword ptr [rax], 0
jle loc_9797C
sub rbp, rax
mov rbx, rbp
sar rbx, 5
inc rbx
add rbp, 0FFFFFFFFFFFFFFE0h
xor r12d, r12d
xor r15d, r15d
loc_978F2:
dec rbx
jz short loc_97947
mov r13, [r14+48h]
mov rax, [r13+rbp+18h]
test rax, rax
jz short loc_9795B
add r13, rbp
mov rcx, [rsp+48h+var_38]
cmp rax, rcx
cmovnb rax, rcx
test r12, r12
cmovz r12, rax
mov rdi, r14
mov rsi, [rsp+48h+var_40]
mov rdx, r13
mov rcx, r12
call __ZN12llama_sbatch17add_seq_to_ubatchER12llama_ubatchR16llama_sbatch_seqm; llama_sbatch::add_seq_to_ubatch(llama_ubatch &,llama_sbatch_seq &,ulong)
cmp dword ptr [r13+0], 1
jg short loc_97947
add rbp, 0FFFFFFFFFFFFFFE0h
add r15, r12
lea rax, [r15+r12]
cmp rax, [rsp+48h+var_38]
jbe short loc_978F2
loc_97947:
mov rax, [rsp+48h+var_40]
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9795B:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSLength0; "s.length > 0"
mov esi, 0A4h
loc_97975:
xor eax, eax
call _ggml_abort
loc_9797C:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSeq0NSeqId0; "seq[0].n_seq_id > 0"
mov esi, 9Fh
jmp short loc_97975
| llama_sbatch * llama_sbatch::split_equal(llama_sbatch *this, unsigned long long *a2, unsigned long long a3)
{
int *v3; // rax
int *v4; // rbp
long long v5; // rbp
long long v6; // rbx
long long v7; // rbp
unsigned long long v8; // r12
long long v9; // r15
unsigned long long v10; // r13
unsigned long long v11; // rax
int *v12; // r13
unsigned long long v14; // [rsp+10h] [rbp-38h]
if ( *a2 < a3 )
a3 = *a2;
v14 = a3;
llama_sbatch::reserve_ubatch(this, (unsigned long long)a2, a3);
v3 = (int *)a2[9];
v4 = (int *)a2[10];
if ( v3 != v4 )
{
if ( *v3 > 0 )
{
v5 = (char *)v4 - (char *)v3;
v6 = (v5 >> 5) + 1;
v7 = v5 - 32;
v8 = 0LL;
v9 = 0LL;
while ( 1 )
{
if ( !--v6 )
return this;
v10 = a2[9];
v11 = *(_QWORD *)(v10 + v7 + 24);
if ( !v11 )
break;
v12 = (int *)(v7 + v10);
if ( v11 >= v14 )
v11 = v14;
if ( !v8 )
v8 = v11;
llama_sbatch::add_seq_to_ubatch((long long)a2, (char *)this, (long long)v12, v8);
if ( *v12 <= 1 )
{
v7 -= 32LL;
v9 += v8;
if ( v9 + v8 <= v14 )
continue;
}
return this;
}
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/src/llama-batch.cpp",
164LL,
"GGML_ASSERT(%s) failed",
"s.length > 0");
}
while ( 1 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/src/llama-batch.cpp",
159LL,
"GGML_ASSERT(%s) failed",
"seq[0].n_seq_id > 0");
}
return this;
}
| split_equal:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV RAX,qword ptr [RSI]
MOV RSI,qword ptr [RSI + 0x60]
CMP RAX,RDX
CMOVC RDX,RAX
XOR ECX,ECX
CMP qword ptr [RSI + 0x10],0x0
SETNZ CL
MOV qword ptr [RSP + 0x8],RDI
MOV RSI,R14
MOV qword ptr [RSP + 0x10],RDX
CALL 0x0016a260
MOV RAX,qword ptr [R14 + 0x48]
MOV RBP,qword ptr [R14 + 0x50]
CMP RAX,RBP
JZ 0x00197947
CMP dword ptr [RAX],0x0
JLE 0x0019797c
SUB RBP,RAX
MOV RBX,RBP
SAR RBX,0x5
INC RBX
ADD RBP,-0x20
XOR R12D,R12D
XOR R15D,R15D
LAB_001978f2:
DEC RBX
JZ 0x00197947
MOV R13,qword ptr [R14 + 0x48]
MOV RAX,qword ptr [R13 + RBP*0x1 + 0x18]
TEST RAX,RAX
JZ 0x0019795b
ADD R13,RBP
MOV RCX,qword ptr [RSP + 0x10]
CMP RAX,RCX
CMOVNC RAX,RCX
TEST R12,R12
CMOVZ R12,RAX
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R13
MOV RCX,R12
CALL 0x00166d30
CMP dword ptr [R13],0x1
JG 0x00197947
ADD RBP,-0x20
ADD R15,R12
LEA RAX,[R15 + R12*0x1]
CMP RAX,qword ptr [RSP + 0x10]
JBE 0x001978f2
LAB_00197947:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019795b:
LEA RDI,[0x213a60]
LEA RDX,[0x2103c4]
LEA RCX,[0x213bc9]
MOV ESI,0xa4
LAB_00197975:
XOR EAX,EAX
CALL 0x0016af70
LAB_0019797c:
LEA RDI,[0x213a60]
LEA RDX,[0x2103c4]
LEA RCX,[0x213bb5]
MOV ESI,0x9f
JMP 0x00197975
|
/* llama_sbatch::split_equal(unsigned long) */
ulong llama_sbatch::split_equal(ulong param_1)
{
int *piVar1;
ulong uVar2;
char *pcVar3;
ulong in_RDX;
long lVar4;
long lVar5;
llama_sbatch *in_RSI;
int8 uVar6;
ulong uVar7;
llama_sbatch_seq *plVar8;
long lVar9;
if (*(ulong *)in_RSI < in_RDX) {
in_RDX = *(ulong *)in_RSI;
}
reserve_ubatch(param_1,SUB81(in_RSI,0));
piVar1 = *(int **)(in_RSI + 0x48);
if (piVar1 != *(int **)(in_RSI + 0x50)) {
if (*piVar1 < 1) {
pcVar3 = "seq[0].n_seq_id > 0";
uVar6 = 0x9f;
LAB_00197975:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/src/llama-batch.cpp",
uVar6,"GGML_ASSERT(%s) failed",pcVar3);
}
lVar5 = (long)*(int **)(in_RSI + 0x50) - (long)piVar1;
lVar4 = (lVar5 >> 5) + 1;
uVar7 = 0;
lVar9 = 0;
while( true ) {
lVar5 = lVar5 + -0x20;
lVar4 = lVar4 + -1;
if (lVar4 == 0) break;
uVar2 = *(ulong *)(*(long *)(in_RSI + 0x48) + 0x18 + lVar5);
if (uVar2 == 0) {
pcVar3 = "s.length > 0";
uVar6 = 0xa4;
goto LAB_00197975;
}
plVar8 = (llama_sbatch_seq *)(*(long *)(in_RSI + 0x48) + lVar5);
if (in_RDX <= uVar2) {
uVar2 = in_RDX;
}
if (uVar7 == 0) {
uVar7 = uVar2;
}
add_seq_to_ubatch(in_RSI,(llama_ubatch *)param_1,plVar8,uVar7);
if (1 < *(int *)plVar8) {
return param_1;
}
lVar9 = lVar9 + uVar7;
if (in_RDX < lVar9 + uVar7) {
return param_1;
}
}
}
return param_1;
}
| |
28,463 | nlohmann::json_abi_v3_11_3::detail::iter_impl<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::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>::erase<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>, 0>(nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>) | llama.cpp/common/json.hpp | IteratorType erase(IteratorType pos)
{
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
IteratorType result = end();
switch (m_data.m_type)
{
case value_t::boolean:
case value_t::number_float:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::string:
case value_t::binary:
{
if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
{
JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
}
if (is_string())
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
m_data.m_value.string = nullptr;
}
else if (is_binary())
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
m_data.m_value.binary = nullptr;
}
m_data.m_type = value_t::null;
assert_invariant();
break;
}
case value_t::object:
{
result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
break;
}
case value_t::array:
{
result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
break;
}
case value_t::null:
case value_t::discarded:
default:
JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
}
return result;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<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::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>::erase<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>, 0>(nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
cmpq %rsi, (%rdx)
jne 0x788dc
movq %rdx, %r15
movq %rdi, %rbx
movq %r14, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x18(%rdi)
callq 0x798ba
movzbl (%r14), %eax
leal -0x3(%rax), %ecx
cmpl $0x6, %ecx
jae 0x7883a
cmpq $0x0, 0x18(%r15)
jne 0x7893b
cmpl $0x8, %eax
je 0x7885b
cmpl $0x3, %eax
jne 0x7888e
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x78833
movq (%rcx), %rsi
incq %rsi
movq %rax, %rdi
callq 0x21170
movq (%r15), %rdi
movl $0x20, %esi
jmp 0x78882
cmpl $0x1, %eax
je 0x788b1
cmpl $0x2, %eax
jne 0x78997
movq 0x8(%r14), %rdi
movq 0x10(%r15), %rsi
callq 0x79bdc
movq %rax, 0x10(%rbx)
jmp 0x7889f
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x7887d
movq 0x10(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x21170
movq (%r15), %rdi
movl $0x28, %esi
callq 0x21170
movq $0x0, (%r15)
movb $0x0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x72f4a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r13
addq $0x8, %r13
movq 0x8(%r14), %r14
movq 0x8(%r15), %r15
movq %r15, %rdi
callq 0x22040
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x79b9e
movq %r12, (%r13)
jmp 0x7889f
movl $0x20, %edi
callq 0x21630
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa3ce7(%rip), %rsi # 0x11c5e0
leaq 0xa3d03(%rip), %rdx # 0x11c603
movq %rsp, %rdi
callq 0x28112
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0xca, %esi
movq %r14, %rcx
callq 0x796b0
xorl %ebp, %ebp
leaq 0xea6c9(%rip), %rsi # 0x162ff0
leaq -0x2c36(%rip), %rdx # 0x75cf8
movq %rbx, %rdi
callq 0x21a50
jmp 0x789f1
movl $0x20, %edi
callq 0x21630
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa3cac(%rip), %rsi # 0x11c604
leaq 0xa3cba(%rip), %rdx # 0x11c619
movq %rsp, %rdi
callq 0x28112
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0xcd, %esi
movq %r14, %rcx
callq 0x796b0
xorl %ebp, %ebp
leaq 0xea66a(%rip), %rsi # 0x162ff0
leaq -0x2c95(%rip), %rdx # 0x75cf8
movq %rbx, %rdi
callq 0x21a50
jmp 0x789f1
movl $0x20, %edi
callq 0x21630
movq %rax, %rbx
movq %r14, %rdi
callq 0x79b80
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xa3c5f(%rip), %rsi # 0x11c61a
movq %rsp, %rdi
callq 0x79af8
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x133, %esi # imm = 0x133
movq %r14, %rcx
callq 0x79920
xorl %ebp, %ebp
leaq 0xea64e(%rip), %rsi # 0x163030
leaq -0x2cf1(%rip), %rdx # 0x75cf8
movq %rbx, %rdi
callq 0x21a50
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x78a16
jmp 0x78a23
jmp 0x78a2a
jmp 0x78a0a
jmp 0x78a2a
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x78a23
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21170
testb %bpl, %bpl
jne 0x78a2d
jmp 0x78a35
movq %rax, %r14
movq %rbx, %rdi
callq 0x21ef0
movq %r14, %rdi
callq 0x21af0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
push rbp; __int64
push r15; int
push r14; void *
push r13; int
push r12; __int64
push rbx; int
sub rsp, 28h
mov r14, rsi
cmp [rdx], rsi
jnz loc_788DC
mov r15, rdx
mov rbx, rdi
mov [rdi], r14
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
mov rax, 8000000000000000h
mov [rdi+18h], rax
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE7set_endEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::set_end(void)
movzx eax, byte ptr [r14]
lea ecx, [rax-3]
cmp ecx, 6
jnb short loc_7883A
cmp qword ptr [r15+18h], 0
jnz loc_7893B
cmp eax, 8
jz short loc_7885B
cmp eax, 3
jnz loc_7888E
lea r15, [r14+8]
mov rdi, [r14+8]
mov rax, [rdi]
lea rcx, [rdi+10h]
cmp rax, rcx
jz short loc_78833
mov rsi, [rcx]
inc rsi; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [r15]
loc_78833:
mov esi, 20h ; ' '
jmp short loc_78882
loc_7883A:
cmp eax, 1
jz short loc_788B1
cmp eax, 2
jnz loc_78997
mov rdi, [r14+8]
mov rsi, [r15+10h]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE8_M_eraseEN9__gnu_cxx17__normal_iteratorIPSD_SF_EE; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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(__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>*,std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov [rbx+10h], rax
jmp short loc_7889F
loc_7885B:
lea r15, [r14+8]
mov rdi, [r14+8]
mov rax, [rdi]
test rax, rax
jz short loc_7887D
mov rsi, [rdi+10h]
sub rsi, rax; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [r15]; void *
loc_7887D:
mov esi, 28h ; '('; unsigned __int64
loc_78882:
call __ZdlPvm; operator delete(void *,ulong)
mov qword ptr [r15], 0
loc_7888E:
mov byte ptr [r14], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::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_7889F:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_788B1:
mov r13, rbx
add r13, 8
mov r14, [r14+8]
mov r15, [r15+8]
mov rdi, r15
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov r12, rax
mov rdi, r14
mov rsi, r15
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESt10_Select1stISH_ESt4lessIvESaISH_EE12_M_erase_auxESt23_Rb_tree_const_iteratorISH_E; std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::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_aux(std::_Rb_tree_const_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov [r13+0], r12
jmp short loc_7889F
loc_788DC:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+58h+var_48]
mov [r15-10h], r15
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdx, aIteratorDoesNo+23h; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 0CAh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp loc_789F1
loc_7893B:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+58h+var_48]
mov [r15-10h], r15
lea rsi, aIteratorOutOfR; "iterator out of range"
lea rdx, aIteratorOutOfR+15h; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 0CDh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_789F1
loc_78997:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<std::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+58h+var_38]
mov [rdx], rax
lea rsi, aCannotUseErase; "cannot use erase() with "
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA25_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[25],char const*>(char const(&)[25],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 133h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_789F1:
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]
cmp rdi, rax
jnz short loc_78A16
jmp short loc_78A23
jmp short loc_78A2A
jmp short loc_78A0A
jmp short loc_78A2A
loc_78A0A:
mov r14, rax
mov rdi, [rsp+58h+var_58]; void *
cmp rdi, r15
jz short loc_78A23
loc_78A16:
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_78A23:
test bpl, bpl
jnz short loc_78A2D
jmp short loc_78A35
loc_78A2A:
mov r14, rax
loc_78A2D:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_78A35:
mov rdi, r14
call __Unwind_Resume
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
CMP qword ptr [RDX],RSI
JNZ 0x001788dc
MOV R15,RDX
MOV RBX,RDI
MOV qword ptr [RDI],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOV RAX,-0x8000000000000000
MOV qword ptr [RDI + 0x18],RAX
CALL 0x001798ba
MOVZX EAX,byte ptr [R14]
LEA ECX,[RAX + -0x3]
CMP ECX,0x6
JNC 0x0017883a
CMP qword ptr [R15 + 0x18],0x0
JNZ 0x0017893b
CMP EAX,0x8
JZ 0x0017885b
CMP EAX,0x3
JNZ 0x0017888e
LEA R15,[R14 + 0x8]
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RDI]
LEA RCX,[RDI + 0x10]
CMP RAX,RCX
JZ 0x00178833
MOV RSI,qword ptr [RCX]
INC RSI
MOV RDI,RAX
CALL 0x00121170
MOV RDI,qword ptr [R15]
LAB_00178833:
MOV ESI,0x20
JMP 0x00178882
LAB_0017883a:
CMP EAX,0x1
JZ 0x001788b1
CMP EAX,0x2
JNZ 0x00178997
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R15 + 0x10]
CALL 0x00179bdc
MOV qword ptr [RBX + 0x10],RAX
JMP 0x0017889f
LAB_0017885b:
LEA R15,[R14 + 0x8]
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0017887d
MOV RSI,qword ptr [RDI + 0x10]
SUB RSI,RAX
MOV RDI,RAX
CALL 0x00121170
MOV RDI,qword ptr [R15]
LAB_0017887d:
MOV ESI,0x28
LAB_00178882:
CALL 0x00121170
MOV qword ptr [R15],0x0
LAB_0017888e:
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x00172f4a
LAB_0017889f:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001788b1:
MOV R13,RBX
ADD R13,0x8
MOV R14,qword ptr [R14 + 0x8]
MOV R15,qword ptr [R15 + 0x8]
MOV RDI,R15
CALL 0x00122040
MOV R12,RAX
MOV RDI,R14
MOV RSI,R15
CALL 0x00179b9e
MOV qword ptr [R13],R12
JMP 0x0017889f
LAB_001788dc:
MOV EDI,0x20
CALL 0x00121630
MOV RBX,RAX
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
LAB_001788f2:
LEA RSI,[0x21c5e0]
LEA RDX,[0x21c603]
MOV RDI,RSP
CALL 0x00128112
MOV BPL,0x1
LAB_0017890b:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0xca
MOV RCX,R14
CALL 0x001796b0
XOR EBP,EBP
LEA RSI,[0x262ff0]
LEA RDX,[0x175cf8]
MOV RDI,RBX
CALL 0x00121a50
LAB_0017893b:
MOV EDI,0x20
CALL 0x00121630
MOV RBX,RAX
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
LAB_00178951:
LEA RSI,[0x21c604]
LEA RDX,[0x21c619]
MOV RDI,RSP
CALL 0x00128112
MOV BPL,0x1
LAB_0017896a:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0xcd
MOV RCX,R14
CALL 0x001796b0
XOR EBP,EBP
LEA RSI,[0x262ff0]
LEA RDX,[0x175cf8]
MOV RDI,RBX
CALL 0x00121a50
LAB_00178997:
MOV EDI,0x20
CALL 0x00121630
MOV RBX,RAX
MOV RDI,R14
CALL 0x00179b80
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_001789b4:
LEA RSI,[0x21c61a]
MOV RDI,RSP
CALL 0x00179af8
MOV BPL,0x1
LAB_001789c6:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x133
MOV RCX,R14
CALL 0x00179920
XOR EBP,EBP
LEA RSI,[0x263030]
LEA RDX,[0x175cf8]
MOV RDI,RBX
CALL 0x00121a50
|
iter_impl<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>>
* _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
(iter_impl<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>>
*param_1,
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>
*param_2,long *param_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>
bVar1;
void *pvVar2;
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,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>>,std::_Select1st<std::pair<std::__cxx11::string_const,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>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,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>>>>
*p_Var3;
_Rb_tree_node_base *p_Var4;
int8 uVar5;
ulong uVar6;
int8 *puVar7;
int1 *local_58 [2];
int1 local_48 [16];
char *local_38;
if ((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>
*)*param_3 != param_2) {
uVar5 = __cxa_allocate_exception(0x20);
local_58[0] = local_48;
/* try { // try from 001788f2 to 00178907 has its CatchHandler @ 00178a2a */
std::__cxx11::string::_M_construct<char_const*>
(local_58,"iterator does not fit current value","");
/* try { // try from 0017890b to 00178935 has its CatchHandler @ 00178a0a */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar5,0xca,local_58,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,&nlohmann::json_abi_v3_11_3::detail::invalid_iterator::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
*(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>
**)param_1 = param_2;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0x8000000000000000;
nlohmann::json_abi_v3_11_3::detail::
iter_impl<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>>
::set_end(param_1);
bVar1 = *param_2;
if (5 < (byte)bVar1 - 3) {
if (bVar1 == (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>
)0x1) {
p_Var3 = *(_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,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>>,std::_Select1st<std::pair<std::__cxx11::string_const,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>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,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>>>>
**)(param_2 + 8);
p_Var4 = (_Rb_tree_node_base *)param_3[1];
uVar5 = std::_Rb_tree_increment(p_Var4);
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,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>>,std::_Select1st<std::pair<std::__cxx11::string_const,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>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,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>>>>
::_M_erase_aux(p_Var3,p_Var4);
*(int8 *)(param_1 + 8) = uVar5;
return param_1;
}
if (bVar1 == (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>
)0x2) {
uVar5 = std::
vector<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>,std::allocator<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>>>
::_M_erase(*(vector<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>,std::allocator<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>>>
**)(param_2 + 8),param_3[2]);
*(int8 *)(param_1 + 0x10) = uVar5;
return param_1;
}
uVar5 = __cxa_allocate_exception(0x20);
local_38 = (char *)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>
::type_name(param_2);
/* try { // try from 001789b4 to 001789c2 has its CatchHandler @ 00178a04 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[25],char_const*>
((detail *)local_58,"cannot use erase() with ",&local_38);
/* try { // try from 001789c6 to 001789f0 has its CatchHandler @ 001789f1 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar5,0x133,local_58,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if (param_3[3] != 0) {
uVar5 = __cxa_allocate_exception(0x20);
local_58[0] = local_48;
/* try { // try from 00178951 to 00178966 has its CatchHandler @ 00178a08 */
std::__cxx11::string::_M_construct<char_const*>(local_58,"iterator out of range","");
/* try { // try from 0017896a to 00178994 has its CatchHandler @ 00178a06 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar5,0xcd,local_58,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,&nlohmann::json_abi_v3_11_3::detail::invalid_iterator::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if (bVar1 == (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>
)0x8) {
puVar7 = *(int8 **)(param_2 + 8);
pvVar2 = (void *)*puVar7;
if (pvVar2 != (void *)0x0) {
operator_delete(pvVar2,puVar7[2] - (long)pvVar2);
puVar7 = *(int8 **)(param_2 + 8);
}
uVar6 = 0x28;
}
else {
if (bVar1 != (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>
)0x3) goto LAB_0017888e;
puVar7 = *(int8 **)(param_2 + 8);
if ((long *)*puVar7 != puVar7 + 2) {
operator_delete((long *)*puVar7,puVar7[2] + 1);
puVar7 = *(int8 **)(param_2 + 8);
}
uVar6 = 0x20;
}
operator_delete(puVar7,uVar6);
*(int8 *)(param_2 + 8) = 0;
LAB_0017888e:
*param_2 = (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>
)0x0;
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>
::assert_invariant(SUB81(param_2,0));
return param_1;
}
| ||
28,464 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::boundaries nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double) | monkey531[P]llama/common/json.hpp | boundaries compute_boundaries(FloatType value)
{
JSON_ASSERT(std::isfinite(value));
JSON_ASSERT(value > 0);
// Convert the IEEE representation into a diyfp.
//
// If v is denormal:
// value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1))
// If v is normalized:
// value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
static_assert(std::numeric_limits<FloatType>::is_iec559,
"internal error: dtoa_short requires an IEEE-754 floating-point implementation");
constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
constexpr int kMinExp = 1 - kBias;
constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
const std::uint64_t E = bits >> (kPrecision - 1);
const std::uint64_t F = bits & (kHiddenBit - 1);
const bool is_denormal = E == 0;
const diyfp v = is_denormal
? diyfp(F, kMinExp)
: diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
// Compute the boundaries m- and m+ of the floating-point value
// v = f * 2^e.
//
// Determine v- and v+, the floating-point predecessor and successor if v,
// respectively.
//
// v- = v - 2^e if f != 2^(p-1) or e == e_min (A)
// = v - 2^(e-1) if f == 2^(p-1) and e > e_min (B)
//
// v+ = v + 2^e
//
// Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
// between m- and m+ round to v, regardless of how the input rounding
// algorithm breaks ties.
//
// ---+-------------+-------------+-------------+-------------+--- (A)
// v- m- v m+ v+
//
// -----------------+------+------+-------------+-------------+--- (B)
// v- m- v m+ v+
const bool lower_boundary_is_closer = F == 0 && E > 1;
const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
const diyfp m_minus = lower_boundary_is_closer
? diyfp(4 * v.f - 1, v.e - 2) // (B)
: diyfp(2 * v.f - 1, v.e - 1); // (A)
// Determine the normalized w+ = m+.
const diyfp w_plus = diyfp::normalize(m_plus);
// Determine w- = m- such that e_(w-) = e_(w+).
const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
return {diyfp::normalize(v), w_minus, w_plus};
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::boundaries nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %xmm0, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
jge 0x48e50
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x48e6c
movq %rdi, %rbx
movabsq $0x10000000000000, %rcx # imm = 0x10000000000000
decq %rcx
andq %rax, %rcx
movq %rax, %rdx
shrq $0x34, %rdx
movq %rcx, %r14
btsq $0x34, %r14
leal -0x433(%rdx), %esi
testq %rdx, %rdx
cmoveq %rcx, %r14
movl $0xfffffbce, %r15d # imm = 0xFFFFFBCE
cmovnel %esi, %r15d
testq %rcx, %rcx
sete %cl
shrq $0x35, %rax
setne %al
leal -0x1(%r15), %esi
addl $0xfffffbcb, %edx # imm = 0xFFFFFBCB
testb %cl, %al
cmovel %esi, %edx
leaq -0x1(%r14,%r14), %rax
movabsq $0x3fffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFF
cmoveq %rax, %rcx
leaq 0x8(%rsp), %r12
movq %rcx, (%r12)
movl %edx, 0x8(%r12)
leaq 0x1(,%r14,2), %rdi
callq 0x48fbc
movq %rax, (%rsp)
movl %edx, %ebp
movq %r12, %rdi
movl %edx, %esi
callq 0x48ffc
movq %rax, %r12
movl %edx, %r13d
movq %r14, %rdi
movl %r15d, %esi
callq 0x48fbc
movq %rax, (%rbx)
movl %edx, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movl %r13d, 0x18(%rbx)
movq (%rsp), %rax
movq %rax, 0x20(%rbx)
movl %ebp, 0x28(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f906(%rip), %rdi # 0x9875d
leaq 0x4d2d9(%rip), %rdx # 0x96137
leaq 0x4ff93(%rip), %rcx # 0x98df8
movl $0x42cb, %esi # imm = 0x42CB
jmp 0x48e86
leaq 0x4f8ea(%rip), %rdi # 0x9875d
leaq 0x4d2bd(%rip), %rdx # 0x96137
leaq 0x50090(%rip), %rcx # 0x98f11
movl $0x42cc, %esi # imm = 0x42CC
xorl %eax, %eax
callq 0x20b40
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl18compute_boundariesIdEENS2_10boundariesET_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
movq rax, xmm0
mov rcx, rax
btr rcx, 3Fh ; '?'
mov rdx, 7FF0000000000000h
cmp rcx, rdx
jge loc_48E50
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jbe loc_48E6C
mov rbx, rdi
mov rcx, 10000000000000h
dec rcx
and rcx, rax
mov rdx, rax
shr rdx, 34h
mov r14, rcx
bts r14, 34h ; '4'
lea esi, [rdx-433h]
test rdx, rdx
cmovz r14, rcx
mov r15d, 0FFFFFBCEh
cmovnz r15d, esi
test rcx, rcx
setz cl
shr rax, 35h
setnz al
lea esi, [r15-1]
add edx, 0FFFFFBCBh
test al, cl
cmovz edx, esi
lea rax, [r14+r14-1]
mov rcx, 3FFFFFFFFFFFFFh
cmovz rcx, rax
lea r12, [rsp+48h+var_40]
mov [r12], rcx
mov [r12+8], edx
lea rdi, ds:1[r14*2]
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp9normalizeES3_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
mov [rsp+48h+var_48], rax
mov ebp, edx
mov rdi, r12
mov esi, edx
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp12normalize_toERKS3_i; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize_to(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,int)
mov r12, rax
mov r13d, edx
mov rdi, r14
mov esi, r15d
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp9normalizeES3_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
mov [rbx], rax
mov [rbx+8], edx
mov [rbx+10h], r12
mov [rbx+18h], r13d
mov rax, [rsp+48h+var_48]
mov [rbx+20h], rax
mov [rbx+28h], ebp
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_48E50:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aStdIsfiniteVal; "std::isfinite(value)"
mov esi, 42CBh
jmp short loc_48E86
loc_48E6C:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aValue0; "value > 0"
mov esi, 42CCh
loc_48E86:
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(
long long a1,
double a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9,
long long a10,
long long a11)
{
long long v11; // r14
int v12; // r15d
bool v13; // cl
bool v14; // al
int v15; // edx
bool v16; // zf
long long v17; // rcx
unsigned int v18; // edx
unsigned int v19; // ebp
long long v20; // r12
int v21; // edx
int v22; // r13d
int v23; // edx
long long v25; // rsi
long long v26; // rdx
long long v27; // rcx
long long v28; // r8
long long v29; // r9
long long v30; // [rsp+0h] [rbp-48h]
long long v31; // [rsp+8h] [rbp-40h] BYREF
int v32; // [rsp+10h] [rbp-38h]
if ( (*(_QWORD *)&a2 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
{
v25 = 17099LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17099LL,
"GGML_ASSERT(%s) failed",
"std::isfinite(value)");
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v25,
v26,
v27,
v28,
v29,
a8,
a9,
a10,
a11);
}
if ( a2 <= 0.0 )
{
v25 = 17100LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17100LL,
"GGML_ASSERT(%s) failed",
"value > 0");
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v25,
v26,
v27,
v28,
v29,
a8,
a9,
a10,
a11);
}
v11 = *(_QWORD *)&a2 & 0xFFFFFFFFFFFFFLL | 0x10000000000000LL;
if ( !(*(_QWORD *)&a2 >> 52) )
v11 = *(_QWORD *)&a2 & 0xFFFFFFFFFFFFFLL;
v12 = -1074;
if ( *(_QWORD *)&a2 >> 52 )
v12 = (*(_QWORD *)&a2 >> 52) - 1075;
v13 = (*(_QWORD *)&a2 & 0xFFFFFFFFFFFFFLL) == 0;
v14 = *(_QWORD *)&a2 >> 53 != 0LL;
v15 = (*(_QWORD *)&a2 >> 52) - 1077;
v16 = !v13 || !v14;
if ( !v13 || !v14 )
v15 = v12 - 1;
v17 = 0x3FFFFFFFFFFFFFLL;
if ( v16 )
v17 = 2 * v11 - 1;
v31 = v17;
v32 = v15;
v30 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(2 * v11 + 1);
v19 = v18;
v20 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize_to(&v31, v18);
v22 = v21;
*(_QWORD *)a1 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(v11);
*(_DWORD *)(a1 + 8) = v23;
*(_QWORD *)(a1 + 16) = v20;
*(_DWORD *)(a1 + 24) = v22;
*(_QWORD *)(a1 + 32) = v30;
*(_DWORD *)(a1 + 40) = v19;
return a1;
}
| compute_boundaries<double>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOVQ RAX,XMM0
MOV RCX,RAX
BTR RCX,0x3f
MOV RDX,0x7ff0000000000000
CMP RCX,RDX
JGE 0x00148e50
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JBE 0x00148e6c
MOV RBX,RDI
MOV RCX,0x10000000000000
DEC RCX
AND RCX,RAX
MOV RDX,RAX
SHR RDX,0x34
MOV R14,RCX
BTS R14,0x34
LEA ESI,[RDX + -0x433]
TEST RDX,RDX
CMOVZ R14,RCX
MOV R15D,0xfffffbce
CMOVNZ R15D,ESI
TEST RCX,RCX
SETZ CL
SHR RAX,0x35
SETNZ AL
LEA ESI,[R15 + -0x1]
ADD EDX,0xfffffbcb
TEST AL,CL
CMOVZ EDX,ESI
LEA RAX,[R14 + R14*0x1 + -0x1]
MOV RCX,0x3fffffffffffff
CMOVZ RCX,RAX
LEA R12,[RSP + 0x8]
MOV qword ptr [R12],RCX
MOV dword ptr [R12 + 0x8],EDX
LEA RDI,[0x1 + R14*0x2]
CALL 0x00148fbc
MOV qword ptr [RSP],RAX
MOV EBP,EDX
MOV RDI,R12
MOV ESI,EDX
CALL 0x00148ffc
MOV R12,RAX
MOV R13D,EDX
MOV RDI,R14
MOV ESI,R15D
CALL 0x00148fbc
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0x8],EDX
MOV qword ptr [RBX + 0x10],R12
MOV dword ptr [RBX + 0x18],R13D
MOV RAX,qword ptr [RSP]
MOV qword ptr [RBX + 0x20],RAX
MOV dword ptr [RBX + 0x28],EBP
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00148e50:
LEA RDI,[0x19875d]
LEA RDX,[0x196137]
LEA RCX,[0x198df8]
MOV ESI,0x42cb
JMP 0x00148e86
LAB_00148e6c:
LEA RDI,[0x19875d]
LEA RDX,[0x196137]
LEA RCX,[0x198f11]
MOV ESI,0x42cc
LAB_00148e86:
XOR EAX,EAX
CALL 0x00120b40
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::boundaries
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double) */
dtoa_impl * __thiscall
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>
(dtoa_impl *this,double param_1)
{
uint uVar1;
diyfp *pdVar2;
char *pcVar3;
int8 uVar4;
diyfp *pdVar5;
int iVar6;
bool bVar7;
int1 auVar8 [12];
int1 auVar9 [12];
int1 auVar10 [12];
long local_40;
int local_38;
if ((ulong)ABS(param_1) < 0x7ff0000000000000) {
if (0.0 < param_1) {
pdVar2 = (diyfp *)((ulong)param_1 & 0xfffffffffffff);
uVar1 = (uint)((ulong)param_1 >> 0x20);
bVar7 = (ulong)param_1 >> 0x34 == 0;
pdVar5 = (diyfp *)((ulong)pdVar2 | 0x10000000000000);
if (bVar7) {
pdVar5 = pdVar2;
}
iVar6 = -0x432;
if (!bVar7) {
iVar6 = (uVar1 >> 0x14) - 0x433;
}
bVar7 = (ulong)param_1 >> 0x35 == 0;
local_38 = (uVar1 >> 0x14) - 0x435;
if (bVar7 || pdVar2 != (diyfp *)0x0) {
local_38 = iVar6 + -1;
}
local_40 = 0x3fffffffffffff;
if (bVar7 || pdVar2 != (diyfp *)0x0) {
local_40 = (long)pdVar5 * 2 + -1;
}
auVar8 = diyfp::normalize((diyfp *)((long)pdVar5 * 2 + 1));
auVar9 = diyfp::normalize_to((diyfp *)&local_40,auVar8._8_4_);
auVar10 = diyfp::normalize(pdVar5,iVar6);
*(int1 (*) [12])this = auVar10;
*(int1 (*) [12])(this + 0x10) = auVar9;
*(int1 (*) [12])(this + 0x20) = auVar8;
return this;
}
pcVar3 = "value > 0";
uVar4 = 0x42cc;
}
else {
pcVar3 = "std::isfinite(value)";
uVar4 = 0x42cb;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar4,
"GGML_ASSERT(%s) failed",pcVar3);
}
| |
28,465 | nlohmann::json_abi_v3_11_3::detail::iter_impl<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::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>::erase<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>, 0>(nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>) | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | IteratorType erase(IteratorType pos) // NOLINT(performance-unnecessary-value-param)
{
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
IteratorType result = end();
switch (m_data.m_type)
{
case value_t::boolean:
case value_t::number_float:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::string:
case value_t::binary:
{
if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
{
JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
}
if (is_string())
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
m_data.m_value.string = nullptr;
}
else if (is_binary())
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
m_data.m_value.binary = nullptr;
}
m_data.m_type = value_t::null;
assert_invariant();
break;
}
case value_t::object:
{
result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
break;
}
case value_t::array:
{
result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
break;
}
case value_t::null:
case value_t::discarded:
default:
JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
}
return result;
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<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::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>::erase<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>, 0>(nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
cmpq %rsi, (%rdx)
jne 0x1d0fb
movq %rdx, %r15
movq %rdi, %rbx
movq %r14, %rsi
callq 0x114f0
movzbl (%r14), %eax
leal -0x3(%rax), %ecx
cmpl $0x6, %ecx
jae 0x1d05f
cmpq $0x0, 0x18(%r15)
jne 0x1d15e
cmpl $0x8, %eax
je 0x1d080
cmpl $0x3, %eax
jne 0x1d0b6
leaq 0x8(%r14), %r12
movq 0x8(%r14), %rax
movq (%rax), %rdi
addq $0x10, %rax
movl $0x20, %r15d
cmpq %rax, %rdi
je 0x1d0a2
movq (%rax), %rsi
incq %rsi
jmp 0x1d09d
cmpl $0x1, %eax
je 0x1d0d7
cmpl $0x2, %eax
jne 0x1d1be
movq 0x8(%r14), %rdi
movq 0x10(%r15), %rsi
callq 0x11ef0
movq %rax, 0x10(%rbx)
jmp 0x1d0c7
leaq 0x8(%r14), %r12
movq 0x8(%r14), %rax
movq (%rax), %rdi
movl $0x28, %r15d
testq %rdi, %rdi
je 0x1d0a2
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x119b0
movq (%r12), %rdi
movq %r15, %rsi
callq 0x119b0
movq $0x0, (%r12)
movb $0x0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x11430
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %r14
movq 0x8(%r15), %r15
movq %r15, %rdi
callq 0x11690
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x113d0
movq %r12, 0x8(%rbx)
jmp 0x1d0c7
movl $0x20, %edi
callq 0x11460
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7dcb(%rip), %rsi # 0x24ee3
leaq 0x7de7(%rip), %rdx # 0x24f06
leaq 0x8(%rsp), %rdi
callq 0x11370
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xca, %esi
movq %r14, %rcx
callq 0x11930
xorl %ebp, %ebp
movq 0xfe46(%rip), %rsi # 0x2cf90
movq 0xfdff(%rip), %rdx # 0x2cf50
movq %rbx, %rdi
callq 0x11fb0
jmp 0x1d21c
movl $0x20, %edi
callq 0x11460
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7d8c(%rip), %rsi # 0x24f07
leaq 0x7d9a(%rip), %rdx # 0x24f1c
leaq 0x8(%rsp), %rdi
callq 0x11370
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcd, %esi
movq %r14, %rcx
callq 0x11930
xorl %ebp, %ebp
movq 0xfde3(%rip), %rsi # 0x2cf90
movq 0xfd9c(%rip), %rdx # 0x2cf50
movq %rbx, %rdi
callq 0x11fb0
jmp 0x1d21c
movl $0x20, %edi
callq 0x11460
movq %rax, %rbx
movq %r14, %rdi
callq 0x11820
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x7d3b(%rip), %rsi # 0x24f1d
leaq 0x8(%rsp), %rdi
callq 0x11190
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x133, %esi # imm = 0x133
movq %r14, %rcx
callq 0x116c0
xorl %ebp, %ebp
movq 0xfd93(%rip), %rsi # 0x2cfa0
movq 0xfd3c(%rip), %rdx # 0x2cf50
movq %rbx, %rdi
callq 0x11fb0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x1d242
jmp 0x1d257
jmp 0x1d251
jmp 0x1d235
jmp 0x1d251
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d257
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x119b0
jmp 0x1d257
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1d264
movq %rbx, %rdi
callq 0x116b0
movq %r14, %rdi
callq 0x12010
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
push rbp; int
push r15; int
push r14; char
push r12; int
push rbx; __int64
sub rsp, 30h
mov r14, rsi
cmp [rdx], rsi
jnz loc_1D0FB
mov r15, rdx
mov rbx, rdi
mov rsi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE3endEv; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::end(void)
movzx eax, byte ptr [r14]
lea ecx, [rax-3]
cmp ecx, 6
jnb short loc_1D05F
cmp qword ptr [r15+18h], 0
jnz loc_1D15E
cmp eax, 8
jz short loc_1D080
cmp eax, 3
jnz short loc_1D0B6
lea r12, [r14+8]
mov rax, [r14+8]
mov rdi, [rax]
add rax, 10h
mov r15d, 20h ; ' '
cmp rdi, rax
jz short loc_1D0A2
mov rsi, [rax]
inc rsi
jmp short loc_1D09D
loc_1D05F:
cmp eax, 1
jz short loc_1D0D7
cmp eax, 2
jnz loc_1D1BE
mov rdi, [r14+8]
mov rsi, [r15+10h]
call __ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE8_M_eraseEN9__gnu_cxx17__normal_iteratorIPSD_SF_EE; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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(__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>*,std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov [rbx+10h], rax
jmp short loc_1D0C7
loc_1D080:
lea r12, [r14+8]
mov rax, [r14+8]
mov rdi, [rax]; void *
mov r15d, 28h ; '('
test rdi, rdi
jz short loc_1D0A2
mov rsi, [rax+10h]
sub rsi, rdi; unsigned __int64
loc_1D09D:
call __ZdlPvm; operator delete(void *,ulong)
loc_1D0A2:
mov rdi, [r12]; void *
mov rsi, r15; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
mov qword ptr [r12], 0
loc_1D0B6:
mov byte ptr [r14], 0
mov rdi, r14
mov esi, 1
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::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_1D0C7:
mov rax, rbx
add rsp, 30h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_1D0D7:
mov r14, [r14+8]
mov r15, [r15+8]
mov rdi, r15
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov r12, rax
mov rdi, r14
mov rsi, r15
call __ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESt10_Select1stISH_ESt4lessIvESaISH_EE12_M_erase_auxESt23_Rb_tree_const_iteratorISH_E; std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::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_aux(std::_Rb_tree_const_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov [rbx+8], r12
jmp short loc_1D0C7
loc_1D0FB:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+58h+var_40]
mov [r15-10h], r15
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdx, aIteratorDoesNo+23h; ""
lea rdi, [rsp+58h+var_50]
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 bpl, 1
lea rdx, [rsp+58h+var_50]
mov rdi, rbx; this
mov esi, 0CAh; int
mov rcx, r14
call __ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
mov rsi, cs:_ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE_ptr; lptinfo
mov rdx, cs:_ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp loc_1D21C
loc_1D15E:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+58h+var_40]
mov [r15-10h], r15
lea rsi, aIteratorOutOfR; "iterator out of range"
lea rdx, aIteratorOutOfR+15h; ""
lea rdi, [rsp+58h+var_50]
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 bpl, 1
lea rdx, [rsp+58h+var_50]
mov rdi, rbx; this
mov esi, 0CDh; int
mov rcx, r14
call __ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
mov rsi, cs:_ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE_ptr; lptinfo
mov rdx, cs:_ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_1D21C
loc_1D1BE:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<std::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+58h+var_30]
mov [rdx], rax
lea rsi, aCannotUseErase; "cannot use erase() with "
lea rdi, [rsp+58h+var_50]
call __ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA25_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[25],char const*>(char const(&)[25],char const* &&)
mov bpl, 1
lea rdx, [rsp+58h+var_50]
mov rdi, rbx; this
mov esi, 133h; int
mov rcx, r14
call __ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
mov rsi, cs:_ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE_ptr; lptinfo
mov rdx, cs:_ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_1D21C:
mov r14, rax
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]
cmp rdi, rax
jnz short loc_1D242
jmp short loc_1D257
jmp short loc_1D251
jmp short loc_1D235
jmp short loc_1D251
loc_1D235:
mov r14, rax
mov rdi, [rsp+58h+var_50]; void *
cmp rdi, r15
jz short loc_1D257
loc_1D242:
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1D257
loc_1D251:
mov r14, rax
mov bpl, 1
loc_1D257:
test bpl, bpl
jz short loc_1D264
mov rdi, rbx; void *
call ___cxa_free_exception
loc_1D264:
mov rdi, r14
call __Unwind_Resume
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
CMP qword ptr [RDX],RSI
JNZ 0x0011d0fb
MOV R15,RDX
MOV RBX,RDI
MOV RSI,R14
CALL 0x001114f0
MOVZX EAX,byte ptr [R14]
LEA ECX,[RAX + -0x3]
CMP ECX,0x6
JNC 0x0011d05f
CMP qword ptr [R15 + 0x18],0x0
JNZ 0x0011d15e
CMP EAX,0x8
JZ 0x0011d080
CMP EAX,0x3
JNZ 0x0011d0b6
LEA R12,[R14 + 0x8]
MOV RAX,qword ptr [R14 + 0x8]
MOV RDI,qword ptr [RAX]
ADD RAX,0x10
MOV R15D,0x20
CMP RDI,RAX
JZ 0x0011d0a2
MOV RSI,qword ptr [RAX]
INC RSI
JMP 0x0011d09d
LAB_0011d05f:
CMP EAX,0x1
JZ 0x0011d0d7
CMP EAX,0x2
JNZ 0x0011d1be
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R15 + 0x10]
CALL 0x00111ef0
MOV qword ptr [RBX + 0x10],RAX
JMP 0x0011d0c7
LAB_0011d080:
LEA R12,[R14 + 0x8]
MOV RAX,qword ptr [R14 + 0x8]
MOV RDI,qword ptr [RAX]
MOV R15D,0x28
TEST RDI,RDI
JZ 0x0011d0a2
MOV RSI,qword ptr [RAX + 0x10]
SUB RSI,RDI
LAB_0011d09d:
CALL 0x001119b0
LAB_0011d0a2:
MOV RDI,qword ptr [R12]
MOV RSI,R15
CALL 0x001119b0
MOV qword ptr [R12],0x0
LAB_0011d0b6:
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x00111430
LAB_0011d0c7:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0011d0d7:
MOV R14,qword ptr [R14 + 0x8]
MOV R15,qword ptr [R15 + 0x8]
MOV RDI,R15
CALL 0x00111690
MOV R12,RAX
MOV RDI,R14
MOV RSI,R15
CALL 0x001113d0
MOV qword ptr [RBX + 0x8],R12
JMP 0x0011d0c7
LAB_0011d0fb:
MOV EDI,0x20
CALL 0x00111460
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_0011d111:
LEA RSI,[0x124ee3]
LEA RDX,[0x124f06]
LEA RDI,[RSP + 0x8]
CALL 0x00111370
MOV BPL,0x1
LAB_0011d12c:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xca
MOV RCX,R14
CALL 0x00111930
XOR EBP,EBP
MOV RSI,qword ptr [0x0012cf90]
MOV RDX,qword ptr [0x0012cf50]
MOV RDI,RBX
CALL 0x00111fb0
LAB_0011d15e:
MOV EDI,0x20
CALL 0x00111460
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_0011d174:
LEA RSI,[0x124f07]
LEA RDX,[0x124f1c]
LEA RDI,[RSP + 0x8]
CALL 0x00111370
MOV BPL,0x1
LAB_0011d18f:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xcd
MOV RCX,R14
CALL 0x00111930
XOR EBP,EBP
MOV RSI,qword ptr [0x0012cf90]
MOV RDX,qword ptr [0x0012cf50]
MOV RDI,RBX
CALL 0x00111fb0
LAB_0011d1be:
MOV EDI,0x20
CALL 0x00111460
MOV RBX,RAX
MOV RDI,R14
CALL 0x00111820
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],RAX
LAB_0011d1db:
LEA RSI,[0x124f1d]
LEA RDI,[RSP + 0x8]
CALL 0x00111190
MOV BPL,0x1
LAB_0011d1ef:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x133
MOV RCX,R14
CALL 0x001116c0
XOR EBP,EBP
MOV RSI,qword ptr [0x0012cfa0]
MOV RDX,qword ptr [0x0012cf50]
MOV RDI,RBX
CALL 0x00111fb0
|
long _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
(long param_1,
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>
*param_2,long *param_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>
bVar1;
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,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>>,std::_Select1st<std::pair<std::__cxx11::string_const,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>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,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>>>>
*p_Var2;
_Rb_tree_node_base *p_Var3;
long *plVar4;
int8 uVar5;
ulong uVar6;
long *plVar7;
ulong uVar8;
int1 *local_50 [2];
int1 local_40 [16];
char *local_30;
if ((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>
*)*param_3 != param_2) {
uVar5 = __cxa_allocate_exception(0x20);
local_50[0] = local_40;
/* try { // try from 0011d111 to 0011d128 has its CatchHandler @ 0011d251 */
std::__cxx11::string::_M_construct<char_const*>
(local_50,"iterator does not fit current value","");
/* try { // try from 0011d12c to 0011d158 has its CatchHandler @ 0011d235 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar5,0xca,local_50,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,PTR_typeinfo_0012cf90,PTR__exception_0012cf50);
}
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>
::end();
bVar1 = *param_2;
if (5 < (byte)bVar1 - 3) {
if (bVar1 == (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>
)0x1) {
p_Var2 = *(_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,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>>,std::_Select1st<std::pair<std::__cxx11::string_const,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>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,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>>>>
**)(param_2 + 8);
p_Var3 = (_Rb_tree_node_base *)param_3[1];
uVar5 = std::_Rb_tree_increment(p_Var3);
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,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>>,std::_Select1st<std::pair<std::__cxx11::string_const,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>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,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>>>>
::_M_erase_aux(p_Var2,p_Var3);
*(int8 *)(param_1 + 8) = uVar5;
return param_1;
}
if (bVar1 == (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>
)0x2) {
uVar5 = std::
vector<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>,std::allocator<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>>>
::_M_erase(*(vector<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>,std::allocator<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>>>
**)(param_2 + 8),param_3[2]);
*(int8 *)(param_1 + 0x10) = uVar5;
return param_1;
}
uVar5 = __cxa_allocate_exception(0x20);
local_30 = (char *)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>
::type_name(param_2);
/* try { // try from 0011d1db to 0011d1eb has its CatchHandler @ 0011d22f */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[25],char_const*>
((detail *)local_50,"cannot use erase() with ",&local_30);
/* try { // try from 0011d1ef to 0011d21b has its CatchHandler @ 0011d21c */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar5,0x133,local_50,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,PTR_typeinfo_0012cfa0,PTR__exception_0012cf50);
}
if (param_3[3] != 0) {
uVar5 = __cxa_allocate_exception(0x20);
local_50[0] = local_40;
/* try { // try from 0011d174 to 0011d18b has its CatchHandler @ 0011d233 */
std::__cxx11::string::_M_construct<char_const*>(local_50,"iterator out of range","");
/* try { // try from 0011d18f to 0011d1bb has its CatchHandler @ 0011d231 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar5,0xcd,local_50,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,PTR_typeinfo_0012cf90,PTR__exception_0012cf50);
}
if (bVar1 == (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>
)0x8) {
plVar7 = (long *)**(long **)(param_2 + 8);
uVar8 = 0x28;
if (plVar7 != (long *)0x0) {
uVar6 = (*(long **)(param_2 + 8))[2] - (long)plVar7;
LAB_0011d09d:
operator_delete(plVar7,uVar6);
}
}
else {
if (bVar1 != (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>
)0x3) goto LAB_0011d0b6;
plVar7 = (long *)**(long **)(param_2 + 8);
plVar4 = *(long **)(param_2 + 8) + 2;
uVar8 = 0x20;
if (plVar7 != plVar4) {
uVar6 = *plVar4 + 1;
goto LAB_0011d09d;
}
}
operator_delete(*(void **)(param_2 + 8),uVar8);
*(int8 *)(param_2 + 8) = 0;
LAB_0011d0b6:
*param_2 = (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>
)0x0;
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>
::assert_invariant(SUB81(param_2,0));
return param_1;
}
| ||
28,466 | nlohmann::json_abi_v3_11_3::detail::iter_impl<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::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>::erase<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>, 0>(nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>) | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | IteratorType erase(IteratorType pos) // NOLINT(performance-unnecessary-value-param)
{
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
IteratorType result = end();
switch (m_data.m_type)
{
case value_t::boolean:
case value_t::number_float:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::string:
case value_t::binary:
{
if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
{
JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
}
if (is_string())
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
m_data.m_value.string = nullptr;
}
else if (is_binary())
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
m_data.m_value.binary = nullptr;
}
m_data.m_type = value_t::null;
assert_invariant();
break;
}
case value_t::object:
{
result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
break;
}
case value_t::array:
{
result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
break;
}
case value_t::null:
case value_t::discarded:
default:
JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
}
return result;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<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::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>::erase<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>, 0>(nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
cmpq %rsi, (%rdx)
jne 0x2726d
movq %rdx, %r15
movq %rdi, %rbx
movq %r14, %rsi
callq 0x1c8c0
movzbl (%r14), %eax
leal -0x3(%rax), %ecx
cmpl $0x6, %ecx
jae 0x27200
cmpq $0x0, 0x18(%r15)
jne 0x272c1
cmpl $0x8, %eax
je 0x27221
cmpl $0x3, %eax
jne 0x2723d
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
callq 0x1c6f0
pushq $0x20
jmp 0x27230
cmpl $0x1, %eax
je 0x2725a
cmpl $0x2, %eax
jne 0x27312
movq 0x8(%r14), %rdi
movq 0x10(%r15), %rsi
callq 0x1d910
movq %rax, 0x10(%rbx)
jmp 0x2724c
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
callq 0x1da60
pushq $0x28
popq %rsi
movq (%r15), %rdi
callq 0x1d120
andq $0x0, (%r15)
movb $0x0, (%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1c730
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdi
movq 0x8(%r15), %rsi
callq 0x1c2e0
movq %rax, 0x8(%rbx)
jmp 0x2724c
pushq $0x20
popq %rdi
callq 0x1c790
movq %rax, %rbx
leaq 0x6fdf(%rip), %rsi # 0x2e25e
leaq 0x8(%rsp), %rdi
movq %rsp, %rdx
callq 0x1dc00
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xca, %esi
movq %r14, %rcx
callq 0x1d050
xorl %ebp, %ebp
movq 0x11ce3(%rip), %rsi # 0x38f90
movq 0x11c9c(%rip), %rdx # 0x38f50
movq %rbx, %rdi
callq 0x1dc20
jmp 0x2736c
pushq $0x20
popq %rdi
callq 0x1c790
movq %rax, %rbx
leaq 0x6faf(%rip), %rsi # 0x2e282
leaq 0x8(%rsp), %rdi
movq %rsp, %rdx
callq 0x1dc00
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcd, %esi
movq %r14, %rcx
callq 0x1d050
xorl %ebp, %ebp
movq 0x11c8f(%rip), %rsi # 0x38f90
movq 0x11c48(%rip), %rdx # 0x38f50
movq %rbx, %rdi
callq 0x1dc20
jmp 0x2736c
pushq $0x20
popq %rdi
callq 0x1c790
movq %rax, %rbx
movq %r14, %rdi
callq 0x1cea0
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x6f66(%rip), %rsi # 0x2e298
leaq 0x8(%rsp), %rdi
callq 0x1c2d0
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x133, %esi # imm = 0x133
movq %r14, %rcx
callq 0x1cc50
xorl %ebp, %ebp
movq 0x11c43(%rip), %rsi # 0x38fa0
movq 0x11bec(%rip), %rdx # 0x38f50
movq %rbx, %rdi
callq 0x1dc20
jmp 0x27374
jmp 0x27388
jmp 0x27374
jmp 0x27388
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x1c6f0
testb %bpl, %bpl
jne 0x2738b
jmp 0x27393
movq %rax, %r14
movq %rbx, %rdi
callq 0x1cc30
movq %r14, %rdi
callq 0x1dcb0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
push rbp; char
push r15; int
push r14; int
push rbx; int
sub rsp, 28h
mov r14, rsi
cmp [rdx], rsi
jnz loc_2726D
mov r15, rdx
mov rbx, rdi
mov rsi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE3endEv; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::end(void)
movzx eax, byte ptr [r14]
lea ecx, [rax-3]
cmp ecx, 6
jnb short loc_27200
cmp qword ptr [r15+18h], 0
jnz loc_272C1
cmp eax, 8
jz short loc_27221
cmp eax, 3
jnz short loc_2723D
lea r15, [r14+8]
mov rdi, [r14+8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
push 20h ; ' '
jmp short loc_27230
loc_27200:
cmp eax, 1
jz short loc_2725A
cmp eax, 2
jnz loc_27312
mov rdi, [r14+8]
mov rsi, [r15+10h]
call __ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE5eraseEN9__gnu_cxx17__normal_iteratorIPKSD_SF_EE; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::erase(__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const*,std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov [rbx+10h], rax
jmp short loc_2724C
loc_27221:
lea r15, [r14+8]
mov rdi, [r14+8]
call __ZNSt12_Vector_baseIhSaIhEED2Ev; std::_Vector_base<uchar>::~_Vector_base()
push 28h ; '('
loc_27230:
pop rsi; unsigned __int64
mov rdi, [r15]; void *
call __ZdlPvm; operator delete(void *,ulong)
and qword ptr [r15], 0
loc_2723D:
mov byte ptr [r14], 0
push 1
pop rsi
mov rdi, r14
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::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_2724C:
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_2725A:
mov rdi, [r14+8]
mov rsi, [r15+8]
call __ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESt10_Select1stISH_ESt4lessIvESaISH_EE5eraseB5cxx11ESt17_Rb_tree_iteratorISH_E; std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::erase(std::_Rb_tree_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov [rbx+8], rax
jmp short loc_2724C
loc_2726D:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdi, [rsp+48h+var_40]
mov rdx, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 0CAh; int
mov rcx, r14
call __ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
mov rsi, cs:_ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE_ptr; lptinfo
mov rdx, cs:_ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp loc_2736C
loc_272C1:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aIteratorOutOfR; "iterator out of range"
lea rdi, [rsp+48h+var_40]
mov rdx, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 0CDh; int
mov rcx, r14
call __ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
mov rsi, cs:_ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE_ptr; lptinfo
mov rdx, cs:_ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_2736C
loc_27312:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<std::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)
mov rdx, rsp
mov [rdx], rax
lea rsi, aCannotUseErase; "cannot use erase() with "
lea rdi, [rsp+48h+var_40]
call __ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA25_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[25],char const*>(char const(&)[25],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 133h; int
mov rcx, r14
call __ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
mov rsi, cs:_ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE_ptr; lptinfo
mov rdx, cs:_ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_2736C:
jmp short loc_27374
jmp short loc_27388
jmp short loc_27374
jmp short loc_27388
loc_27374:
mov r14, rax
lea rdi, [rsp+48h+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_2738B
jmp short loc_27393
loc_27388:
mov r14, rax
loc_2738B:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_27393:
mov rdi, r14
call __Unwind_Resume
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
CMP qword ptr [RDX],RSI
JNZ 0x0012726d
MOV R15,RDX
MOV RBX,RDI
MOV RSI,R14
CALL 0x0011c8c0
MOVZX EAX,byte ptr [R14]
LEA ECX,[RAX + -0x3]
CMP ECX,0x6
JNC 0x00127200
CMP qword ptr [R15 + 0x18],0x0
JNZ 0x001272c1
CMP EAX,0x8
JZ 0x00127221
CMP EAX,0x3
JNZ 0x0012723d
LEA R15,[R14 + 0x8]
MOV RDI,qword ptr [R14 + 0x8]
CALL 0x0011c6f0
PUSH 0x20
JMP 0x00127230
LAB_00127200:
CMP EAX,0x1
JZ 0x0012725a
CMP EAX,0x2
JNZ 0x00127312
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R15 + 0x10]
CALL 0x0011d910
MOV qword ptr [RBX + 0x10],RAX
JMP 0x0012724c
LAB_00127221:
LEA R15,[R14 + 0x8]
MOV RDI,qword ptr [R14 + 0x8]
CALL 0x0011da60
PUSH 0x28
LAB_00127230:
POP RSI
MOV RDI,qword ptr [R15]
CALL 0x0011d120
AND qword ptr [R15],0x0
LAB_0012723d:
MOV byte ptr [R14],0x0
PUSH 0x1
POP RSI
MOV RDI,R14
CALL 0x0011c730
LAB_0012724c:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0012725a:
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R15 + 0x8]
CALL 0x0011c2e0
MOV qword ptr [RBX + 0x8],RAX
JMP 0x0012724c
LAB_0012726d:
PUSH 0x20
POP RDI
CALL 0x0011c790
MOV RBX,RAX
LAB_00127278:
LEA RSI,[0x12e25e]
LEA RDI,[RSP + 0x8]
MOV RDX,RSP
CALL 0x0011dc00
MOV BPL,0x1
LAB_0012728f:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xca
MOV RCX,R14
CALL 0x0011d050
XOR EBP,EBP
MOV RSI,qword ptr [0x00138f90]
MOV RDX,qword ptr [0x00138f50]
MOV RDI,RBX
CALL 0x0011dc20
LAB_001272c1:
PUSH 0x20
POP RDI
CALL 0x0011c790
MOV RBX,RAX
LAB_001272cc:
LEA RSI,[0x12e282]
LEA RDI,[RSP + 0x8]
MOV RDX,RSP
CALL 0x0011dc00
MOV BPL,0x1
LAB_001272e3:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xcd
MOV RCX,R14
CALL 0x0011d050
XOR EBP,EBP
MOV RSI,qword ptr [0x00138f90]
MOV RDX,qword ptr [0x00138f50]
MOV RDI,RBX
CALL 0x0011dc20
LAB_00127312:
PUSH 0x20
POP RDI
CALL 0x0011c790
MOV RBX,RAX
MOV RDI,R14
CALL 0x0011cea0
MOV RDX,RSP
MOV qword ptr [RDX],RAX
LAB_0012732b:
LEA RSI,[0x12e298]
LEA RDI,[RSP + 0x8]
CALL 0x0011c2d0
MOV BPL,0x1
LAB_0012733f:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x133
MOV RCX,R14
CALL 0x0011cc50
XOR EBP,EBP
MOV RSI,qword ptr [0x00138fa0]
MOV RDX,qword ptr [0x00138f50]
MOV RDI,RBX
CALL 0x0011dc20
|
long _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
(long param_1,
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>
*param_2,long *param_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>
bVar1;
int8 uVar2;
ulong uStack_50;
char *local_48;
string local_40 [32];
if ((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>
*)*param_3 != param_2) {
uVar2 = __cxa_allocate_exception(0x20);
/* try { // try from 00127278 to 0012728b has its CatchHandler @ 00127388 */
std::__cxx11::string::string<std::allocator<char>>
(local_40,"iterator does not fit current value",(allocator *)&local_48);
/* try { // try from 0012728f to 001272bb has its CatchHandler @ 00127374 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0xca,local_40,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,PTR_typeinfo_00138f90,PTR__exception_00138f50);
}
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>
::end();
bVar1 = *param_2;
if (5 < (byte)bVar1 - 3) {
if (bVar1 == (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>
)0x1) {
uVar2 = std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,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>>,std::_Select1st<std::pair<std::__cxx11::string_const,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>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,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>>>>
::erase_abi_cxx11_(*(_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,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>>,std::_Select1st<std::pair<std::__cxx11::string_const,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>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,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>>>>
**)(param_2 + 8),param_3[1]);
*(int8 *)(param_1 + 8) = uVar2;
return param_1;
}
if (bVar1 == (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>
)0x2) {
uVar2 = std::
vector<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>,std::allocator<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>>>
::erase(*(vector<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>,std::allocator<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>>>
**)(param_2 + 8),param_3[2]);
*(int8 *)(param_1 + 0x10) = uVar2;
return param_1;
}
uVar2 = __cxa_allocate_exception(0x20);
local_48 = (char *)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>
::type_name(param_2);
/* try { // try from 0012732b to 0012733b has its CatchHandler @ 0012736e */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[25],char_const*>
((detail *)local_40,"cannot use erase() with ",&local_48);
/* try { // try from 0012733f to 0012736b has its CatchHandler @ 0012736c */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x133,local_40,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,PTR_typeinfo_00138fa0,PTR__exception_00138f50);
}
if (param_3[3] != 0) {
uVar2 = __cxa_allocate_exception(0x20);
/* try { // try from 001272cc to 001272df has its CatchHandler @ 00127372 */
std::__cxx11::string::string<std::allocator<char>>
(local_40,"iterator out of range",(allocator *)&local_48);
/* try { // try from 001272e3 to 0012730f has its CatchHandler @ 00127370 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0xcd,local_40,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,PTR_typeinfo_00138f90,PTR__exception_00138f50);
}
if (bVar1 == (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>
)0x8) {
std::_Vector_base<unsigned_char,std::allocator<unsigned_char>>::~_Vector_base
(*(_Vector_base<unsigned_char,std::allocator<unsigned_char>> **)(param_2 + 8));
uStack_50 = 0x28;
}
else {
if (bVar1 != (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>
)0x3) goto LAB_0012723d;
std::__cxx11::string::~string(*(string **)(param_2 + 8));
uStack_50 = 0x20;
}
operator_delete(*(void **)(param_2 + 8),uStack_50);
*(int8 *)(param_2 + 8) = 0;
LAB_0012723d:
*param_2 = (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>
)0x0;
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>
::assert_invariant(SUB81(param_2,0));
return param_1;
}
| ||
28,467 | nlohmann::json_abi_v3_11_3::detail::iter_impl<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::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>::erase<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>, 0>(nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>) | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | IteratorType erase(IteratorType pos) // NOLINT(performance-unnecessary-value-param)
{
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
IteratorType result = end();
switch (m_data.m_type)
{
case value_t::boolean:
case value_t::number_float:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::string:
case value_t::binary:
{
if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
{
JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
}
if (is_string())
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
m_data.m_value.string = nullptr;
}
else if (is_binary())
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
m_data.m_value.binary = nullptr;
}
m_data.m_type = value_t::null;
assert_invariant();
break;
}
case value_t::object:
{
result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
break;
}
case value_t::array:
{
result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
break;
}
case value_t::null:
case value_t::discarded:
default:
JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
}
return result;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<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::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>::erase<nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>, 0>(nlohmann::json_abi_v3_11_3::detail::iter_impl<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>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
cmpq %rsi, (%rdx)
jne 0x1cd80
movq %rdx, %r15
movq %rdi, %rbx
movq %r14, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x18(%rdi)
callq 0x120c0
movzbl (%r14), %eax
leal -0x3(%rax), %ecx
cmpl $0x6, %ecx
jae 0x1ccde
cmpq $0x0, 0x18(%r15)
jne 0x1cddf
cmpl $0x8, %eax
je 0x1ccff
cmpl $0x3, %eax
jne 0x1cd32
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x1ccd7
movq (%rcx), %rsi
incq %rsi
movq %rax, %rdi
callq 0x119a0
movq (%r15), %rdi
movl $0x20, %esi
jmp 0x1cd26
cmpl $0x1, %eax
je 0x1cd55
cmpl $0x2, %eax
jne 0x1ce3b
movq 0x8(%r14), %rdi
movq 0x10(%r15), %rsi
callq 0x11ec0
movq %rax, 0x10(%rbx)
jmp 0x1cd43
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x1cd21
movq 0x10(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x119a0
movq (%r15), %rdi
movl $0x28, %esi
callq 0x119a0
movq $0x0, (%r15)
movb $0x0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x11430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r13
addq $0x8, %r13
movq 0x8(%r14), %r14
movq 0x8(%r15), %r15
movq %r15, %rdi
callq 0x11680
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x113d0
movq %r12, (%r13)
jmp 0x1cd43
movl $0x20, %edi
callq 0x11460
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7146(%rip), %rsi # 0x23ee3
leaq 0x7162(%rip), %rdx # 0x23f06
movq %rsp, %rdi
callq 0x11370
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0xca, %esi
movq %r14, %rcx
callq 0x11920
xorl %ebp, %ebp
movq 0xf1c5(%rip), %rsi # 0x2bf90
movq 0xf17e(%rip), %rdx # 0x2bf50
movq %rbx, %rdi
callq 0x11f80
jmp 0x1ce95
movl $0x20, %edi
callq 0x11460
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x710b(%rip), %rsi # 0x23f07
leaq 0x7119(%rip), %rdx # 0x23f1c
movq %rsp, %rdi
callq 0x11370
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0xcd, %esi
movq %r14, %rcx
callq 0x11920
xorl %ebp, %ebp
movq 0xf166(%rip), %rsi # 0x2bf90
movq 0xf11f(%rip), %rdx # 0x2bf50
movq %rbx, %rdi
callq 0x11f80
jmp 0x1ce95
movl $0x20, %edi
callq 0x11460
movq %rax, %rbx
movq %r14, %rdi
callq 0x11810
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x70be(%rip), %rsi # 0x23f1d
movq %rsp, %rdi
callq 0x11190
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x133, %esi # imm = 0x133
movq %r14, %rcx
callq 0x116b0
xorl %ebp, %ebp
movq 0xf11a(%rip), %rsi # 0x2bfa0
movq 0xf0c3(%rip), %rdx # 0x2bf50
movq %rbx, %rdi
callq 0x11f80
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x1ceba
jmp 0x1cec7
jmp 0x1cece
jmp 0x1ceae
jmp 0x1cece
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1cec7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x119a0
testb %bpl, %bpl
jne 0x1ced1
jmp 0x1ced9
movq %rax, %r14
movq %rbx, %rdi
callq 0x116a0
movq %r14, %rdi
callq 0x11fe0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
push rbp; int
push r15; int
push r14; char
push r13; int
push r12; __int64
push rbx; int
sub rsp, 28h
mov r14, rsi
cmp [rdx], rsi
jnz loc_1CD80
mov r15, rdx
mov rbx, rdi
mov [rdi], r14
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
mov rax, 8000000000000000h
mov [rdi+18h], rax
call __ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE7set_endEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::set_end(void)
movzx eax, byte ptr [r14]
lea ecx, [rax-3]
cmp ecx, 6
jnb short loc_1CCDE
cmp qword ptr [r15+18h], 0
jnz loc_1CDDF
cmp eax, 8
jz short loc_1CCFF
cmp eax, 3
jnz loc_1CD32
lea r15, [r14+8]
mov rdi, [r14+8]
mov rax, [rdi]
lea rcx, [rdi+10h]
cmp rax, rcx
jz short loc_1CCD7
mov rsi, [rcx]
inc rsi; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [r15]
loc_1CCD7:
mov esi, 20h ; ' '
jmp short loc_1CD26
loc_1CCDE:
cmp eax, 1
jz short loc_1CD55
cmp eax, 2
jnz loc_1CE3B
mov rdi, [r14+8]
mov rsi, [r15+10h]
call __ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE8_M_eraseEN9__gnu_cxx17__normal_iteratorIPSD_SF_EE; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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(__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>*,std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov [rbx+10h], rax
jmp short loc_1CD43
loc_1CCFF:
lea r15, [r14+8]
mov rdi, [r14+8]
mov rax, [rdi]
test rax, rax
jz short loc_1CD21
mov rsi, [rdi+10h]
sub rsi, rax; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [r15]; void *
loc_1CD21:
mov esi, 28h ; '('; unsigned __int64
loc_1CD26:
call __ZdlPvm; operator delete(void *,ulong)
mov qword ptr [r15], 0
loc_1CD32:
mov byte ptr [r14], 0
mov rdi, r14
mov esi, 1
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::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_1CD43:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1CD55:
mov r13, rbx
add r13, 8
mov r14, [r14+8]
mov r15, [r15+8]
mov rdi, r15
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov r12, rax
mov rdi, r14
mov rsi, r15
call __ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESt10_Select1stISH_ESt4lessIvESaISH_EE12_M_erase_auxESt23_Rb_tree_const_iteratorISH_E; std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::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_aux(std::_Rb_tree_const_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov [r13+0], r12
jmp short loc_1CD43
loc_1CD80:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+58h+var_48]
mov [r15-10h], r15
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdx, aIteratorDoesNo+23h; ""
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 0CAh; int
mov rcx, r14
call __ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
mov rsi, cs:_ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE_ptr; lptinfo
mov rdx, cs:_ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp loc_1CE95
loc_1CDDF:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+58h+var_48]
mov [r15-10h], r15
lea rsi, aIteratorOutOfR; "iterator out of range"
lea rdx, aIteratorOutOfR+15h; ""
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 0CDh; int
mov rcx, r14
call __ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
mov rsi, cs:_ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE_ptr; lptinfo
mov rdx, cs:_ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_1CE95
loc_1CE3B:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<std::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+58h+var_38]
mov [rdx], rax
lea rsi, aCannotUseErase; "cannot use erase() with "
mov rdi, rsp
call __ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA25_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[25],char const*>(char const(&)[25],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 133h; int
mov rcx, r14
call __ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
mov rsi, cs:_ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE_ptr; lptinfo
mov rdx, cs:_ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_1CE95:
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]
cmp rdi, rax
jnz short loc_1CEBA
jmp short loc_1CEC7
jmp short loc_1CECE
jmp short loc_1CEAE
jmp short loc_1CECE
loc_1CEAE:
mov r14, rax
mov rdi, [rsp+58h+var_58]; void *
cmp rdi, r15
jz short loc_1CEC7
loc_1CEBA:
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1CEC7:
test bpl, bpl
jnz short loc_1CED1
jmp short loc_1CED9
loc_1CECE:
mov r14, rax
loc_1CED1:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_1CED9:
mov rdi, r14
call __Unwind_Resume
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
CMP qword ptr [RDX],RSI
JNZ 0x0011cd80
MOV R15,RDX
MOV RBX,RDI
MOV qword ptr [RDI],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOV RAX,-0x8000000000000000
MOV qword ptr [RDI + 0x18],RAX
CALL 0x001120c0
MOVZX EAX,byte ptr [R14]
LEA ECX,[RAX + -0x3]
CMP ECX,0x6
JNC 0x0011ccde
CMP qword ptr [R15 + 0x18],0x0
JNZ 0x0011cddf
CMP EAX,0x8
JZ 0x0011ccff
CMP EAX,0x3
JNZ 0x0011cd32
LEA R15,[R14 + 0x8]
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RDI]
LEA RCX,[RDI + 0x10]
CMP RAX,RCX
JZ 0x0011ccd7
MOV RSI,qword ptr [RCX]
INC RSI
MOV RDI,RAX
CALL 0x001119a0
MOV RDI,qword ptr [R15]
LAB_0011ccd7:
MOV ESI,0x20
JMP 0x0011cd26
LAB_0011ccde:
CMP EAX,0x1
JZ 0x0011cd55
CMP EAX,0x2
JNZ 0x0011ce3b
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R15 + 0x10]
CALL 0x00111ec0
MOV qword ptr [RBX + 0x10],RAX
JMP 0x0011cd43
LAB_0011ccff:
LEA R15,[R14 + 0x8]
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0011cd21
MOV RSI,qword ptr [RDI + 0x10]
SUB RSI,RAX
MOV RDI,RAX
CALL 0x001119a0
MOV RDI,qword ptr [R15]
LAB_0011cd21:
MOV ESI,0x28
LAB_0011cd26:
CALL 0x001119a0
MOV qword ptr [R15],0x0
LAB_0011cd32:
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x00111430
LAB_0011cd43:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011cd55:
MOV R13,RBX
ADD R13,0x8
MOV R14,qword ptr [R14 + 0x8]
MOV R15,qword ptr [R15 + 0x8]
MOV RDI,R15
CALL 0x00111680
MOV R12,RAX
MOV RDI,R14
MOV RSI,R15
CALL 0x001113d0
MOV qword ptr [R13],R12
JMP 0x0011cd43
LAB_0011cd80:
MOV EDI,0x20
CALL 0x00111460
MOV RBX,RAX
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
LAB_0011cd96:
LEA RSI,[0x123ee3]
LEA RDX,[0x123f06]
MOV RDI,RSP
CALL 0x00111370
MOV BPL,0x1
LAB_0011cdaf:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0xca
MOV RCX,R14
CALL 0x00111920
XOR EBP,EBP
MOV RSI,qword ptr [0x0012bf90]
MOV RDX,qword ptr [0x0012bf50]
MOV RDI,RBX
CALL 0x00111f80
LAB_0011cddf:
MOV EDI,0x20
CALL 0x00111460
MOV RBX,RAX
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
LAB_0011cdf5:
LEA RSI,[0x123f07]
LEA RDX,[0x123f1c]
MOV RDI,RSP
CALL 0x00111370
MOV BPL,0x1
LAB_0011ce0e:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0xcd
MOV RCX,R14
CALL 0x00111920
XOR EBP,EBP
MOV RSI,qword ptr [0x0012bf90]
MOV RDX,qword ptr [0x0012bf50]
MOV RDI,RBX
CALL 0x00111f80
LAB_0011ce3b:
MOV EDI,0x20
CALL 0x00111460
MOV RBX,RAX
MOV RDI,R14
CALL 0x00111810
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_0011ce58:
LEA RSI,[0x123f1d]
MOV RDI,RSP
CALL 0x00111190
MOV BPL,0x1
LAB_0011ce6a:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x133
MOV RCX,R14
CALL 0x001116b0
XOR EBP,EBP
MOV RSI,qword ptr [0x0012bfa0]
MOV RDX,qword ptr [0x0012bf50]
MOV RDI,RBX
CALL 0x00111f80
|
iter_impl<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>>
* _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
(iter_impl<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>>
*param_1,
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>
*param_2,long *param_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>
bVar1;
void *pvVar2;
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,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>>,std::_Select1st<std::pair<std::__cxx11::string_const,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>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,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>>>>
*p_Var3;
_Rb_tree_node_base *p_Var4;
int8 uVar5;
ulong uVar6;
int8 *puVar7;
int1 *local_58 [2];
int1 local_48 [16];
char *local_38;
if ((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>
*)*param_3 != param_2) {
uVar5 = __cxa_allocate_exception(0x20);
local_58[0] = local_48;
/* try { // try from 0011cd96 to 0011cdab has its CatchHandler @ 0011cece */
std::__cxx11::string::_M_construct<char_const*>
(local_58,"iterator does not fit current value","");
/* try { // try from 0011cdaf to 0011cdd9 has its CatchHandler @ 0011ceae */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar5,0xca,local_58,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,PTR_typeinfo_0012bf90,PTR__exception_0012bf50);
}
*(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>
**)param_1 = param_2;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0x8000000000000000;
nlohmann::json_abi_v3_11_3::detail::
iter_impl<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>>
::set_end(param_1);
bVar1 = *param_2;
if (5 < (byte)bVar1 - 3) {
if (bVar1 == (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>
)0x1) {
p_Var3 = *(_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,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>>,std::_Select1st<std::pair<std::__cxx11::string_const,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>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,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>>>>
**)(param_2 + 8);
p_Var4 = (_Rb_tree_node_base *)param_3[1];
uVar5 = std::_Rb_tree_increment(p_Var4);
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,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>>,std::_Select1st<std::pair<std::__cxx11::string_const,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>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,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>>>>
::_M_erase_aux(p_Var3,p_Var4);
*(int8 *)(param_1 + 8) = uVar5;
return param_1;
}
if (bVar1 == (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>
)0x2) {
uVar5 = std::
vector<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>,std::allocator<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>>>
::_M_erase(*(vector<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>,std::allocator<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>>>
**)(param_2 + 8),param_3[2]);
*(int8 *)(param_1 + 0x10) = uVar5;
return param_1;
}
uVar5 = __cxa_allocate_exception(0x20);
local_38 = (char *)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>
::type_name(param_2);
/* try { // try from 0011ce58 to 0011ce66 has its CatchHandler @ 0011cea8 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[25],char_const*>
((detail *)local_58,"cannot use erase() with ",&local_38);
/* try { // try from 0011ce6a to 0011ce94 has its CatchHandler @ 0011ce95 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar5,0x133,local_58,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,PTR_typeinfo_0012bfa0,PTR__exception_0012bf50);
}
if (param_3[3] != 0) {
uVar5 = __cxa_allocate_exception(0x20);
local_58[0] = local_48;
/* try { // try from 0011cdf5 to 0011ce0a has its CatchHandler @ 0011ceac */
std::__cxx11::string::_M_construct<char_const*>(local_58,"iterator out of range","");
/* try { // try from 0011ce0e to 0011ce38 has its CatchHandler @ 0011ceaa */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar5,0xcd,local_58,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,PTR_typeinfo_0012bf90,PTR__exception_0012bf50);
}
if (bVar1 == (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>
)0x8) {
puVar7 = *(int8 **)(param_2 + 8);
pvVar2 = (void *)*puVar7;
if (pvVar2 != (void *)0x0) {
operator_delete(pvVar2,puVar7[2] - (long)pvVar2);
puVar7 = *(int8 **)(param_2 + 8);
}
uVar6 = 0x28;
}
else {
if (bVar1 != (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>
)0x3) goto LAB_0011cd32;
puVar7 = *(int8 **)(param_2 + 8);
if ((long *)*puVar7 != puVar7 + 2) {
operator_delete((long *)*puVar7,puVar7[2] + 1);
puVar7 = *(int8 **)(param_2 + 8);
}
uVar6 = 0x20;
}
operator_delete(puVar7,uVar6);
*(int8 *)(param_2 + 8) = 0;
LAB_0011cd32:
*param_2 = (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>
)0x0;
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>
::assert_invariant(SUB81(param_2,0));
return param_1;
}
| ||
28,468 | Cache::getId(unsigned int) | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp | uint32_t Cache::getId(uint32_t addr) {
uint32_t offsetBits = log2i(policy.blockSize);
uint32_t idBits = log2i(policy.blockNum / policy.associativity);
uint32_t mask = (1 << idBits) - 1;
return (addr >> offsetBits) & mask;
} | O2 | cpp | Cache::getId(unsigned int):
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x34(%rdi), %esi
callq 0x4a34
movl %eax, %ebp
movl 0x38(%r14), %eax
xorl %edx, %edx
divl 0x3c(%r14)
movl %eax, %esi
callq 0x4a34
pushq $-0x1
popq %rdx
movl %eax, %ecx
shll %cl, %edx
movl %ebp, %ecx
shrl %cl, %ebx
notl %edx
andl %edx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
| _ZN5Cache5getIdEj:
push rbp
push r14
push rbx
mov ebx, esi
mov r14, rdi
mov esi, [rdi+34h]; unsigned int
call _ZN5Cache5log2iEj; Cache::log2i(uint)
mov ebp, eax
mov eax, [r14+38h]
xor edx, edx
div dword ptr [r14+3Ch]
mov esi, eax; unsigned int
call _ZN5Cache5log2iEj; Cache::log2i(uint)
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov ecx, eax
shl edx, cl
mov ecx, ebp
shr ebx, cl
not edx
and ebx, edx
mov eax, ebx
pop rbx
pop r14
pop rbp
retn
| long long Cache::getId(Cache *this, unsigned int a2)
{
char v2; // bp
v2 = Cache::log2i(this, *((_DWORD *)this + 13));
return ~(-1 << Cache::log2i(this, *((_DWORD *)this + 14) / *((_DWORD *)this + 15))) & (a2 >> v2);
}
| getId:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBX,ESI
MOV R14,RDI
MOV ESI,dword ptr [RDI + 0x34]
CALL 0x00104a34
MOV EBP,EAX
MOV EAX,dword ptr [R14 + 0x38]
XOR EDX,EDX
DIV dword ptr [R14 + 0x3c]
MOV ESI,EAX
CALL 0x00104a34
PUSH -0x1
POP RDX
MOV ECX,EAX
SHL EDX,CL
MOV ECX,EBP
SHR EBX,CL
NOT EDX
AND EBX,EDX
MOV EAX,EBX
POP RBX
POP R14
POP RBP
RET
|
/* Cache::getId(unsigned int) */
uint __thiscall Cache::getId(Cache *this,uint param_1)
{
byte bVar1;
byte bVar2;
Cache *this_00;
this_00 = this;
bVar1 = log2i(this,*(uint *)(this + 0x34));
bVar2 = log2i(this_00,*(uint *)(this + 0x38) / *(uint *)(this + 0x3c));
return param_1 >> (bVar1 & 0x1f) & ~(-1 << (bVar2 & 0x1f));
}
| |
28,469 | Cache::getId(unsigned int) | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp | uint32_t Cache::getId(uint32_t addr) {
uint32_t offsetBits = log2i(policy.blockSize);
uint32_t idBits = log2i(policy.blockNum / policy.associativity);
uint32_t mask = (1 << idBits) - 1;
return (addr >> offsetBits) & mask;
} | O3 | cpp | Cache::getId(unsigned int):
movl 0x34(%rdi), %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x46ca
xorl %r8d, %r8d
cmpl $0x1, %eax
je 0x46ca
movl %eax, %edx
shrl %edx
incl %r8d
cmpl $0x3, %eax
movl %edx, %eax
ja 0x46be
movl 0x38(%rdi), %eax
xorl %edx, %edx
divl 0x3c(%rdi)
testl %eax, %eax
je 0x46ea
xorl %ecx, %ecx
cmpl $0x1, %eax
je 0x46ea
movl %eax, %edx
shrl %edx
incl %ecx
cmpl $0x3, %eax
movl %edx, %eax
ja 0x46df
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
shll %cl, %eax
movl %r8d, %ecx
shrl %cl, %esi
notl %eax
andl %eax, %esi
movl %esi, %eax
retq
nop
| _ZN5Cache5getIdEj:
mov eax, [rdi+34h]
mov ecx, 0FFFFFFFFh
mov r8d, 0FFFFFFFFh
test eax, eax
jz short loc_46CA
xor r8d, r8d
cmp eax, 1
jz short loc_46CA
mov edx, eax
loc_46BE:
shr edx, 1
inc r8d
cmp eax, 3
mov eax, edx
ja short loc_46BE
loc_46CA:
mov eax, [rdi+38h]
xor edx, edx
div dword ptr [rdi+3Ch]
test eax, eax
jz short loc_46EA
xor ecx, ecx
cmp eax, 1
jz short loc_46EA
mov edx, eax
loc_46DF:
shr edx, 1
inc ecx
cmp eax, 3
mov eax, edx
ja short loc_46DF
loc_46EA:
mov eax, 0FFFFFFFFh
shl eax, cl
mov ecx, r8d
shr esi, cl
not eax
and esi, eax
mov eax, esi
retn
| long long Cache::getId(Cache *this, unsigned int a2)
{
unsigned int v2; // eax
char v3; // cl
char v4; // r8
unsigned int v5; // edx
bool v6; // cc
unsigned int v7; // eax
unsigned int v8; // edx
v2 = *((_DWORD *)this + 13);
v3 = -1;
v4 = -1;
if ( v2 )
{
v4 = 0;
if ( v2 != 1 )
{
v5 = *((_DWORD *)this + 13);
do
{
v5 >>= 1;
++v4;
v6 = v2 <= 3;
v2 = v5;
}
while ( !v6 );
}
}
v7 = *((_DWORD *)this + 14) / *((_DWORD *)this + 15);
if ( v7 )
{
v3 = 0;
if ( v7 != 1 )
{
v8 = *((_DWORD *)this + 14) / *((_DWORD *)this + 15);
do
{
v8 >>= 1;
++v3;
v6 = v7 <= 3;
v7 = v8;
}
while ( !v6 );
}
}
return ~(-1 << v3) & (a2 >> v4);
}
| getId:
MOV EAX,dword ptr [RDI + 0x34]
MOV ECX,0xffffffff
MOV R8D,0xffffffff
TEST EAX,EAX
JZ 0x001046ca
XOR R8D,R8D
CMP EAX,0x1
JZ 0x001046ca
MOV EDX,EAX
LAB_001046be:
SHR EDX,0x1
INC R8D
CMP EAX,0x3
MOV EAX,EDX
JA 0x001046be
LAB_001046ca:
MOV EAX,dword ptr [RDI + 0x38]
XOR EDX,EDX
DIV dword ptr [RDI + 0x3c]
TEST EAX,EAX
JZ 0x001046ea
XOR ECX,ECX
CMP EAX,0x1
JZ 0x001046ea
MOV EDX,EAX
LAB_001046df:
SHR EDX,0x1
INC ECX
CMP EAX,0x3
MOV EAX,EDX
JA 0x001046df
LAB_001046ea:
MOV EAX,0xffffffff
SHL EAX,CL
MOV ECX,R8D
SHR ESI,CL
NOT EAX
AND ESI,EAX
MOV EAX,ESI
RET
|
/* Cache::getId(unsigned int) */
uint __thiscall Cache::getId(Cache *this,uint param_1)
{
bool bVar1;
uint uVar2;
byte bVar3;
ulong uVar4;
byte bVar5;
byte bVar6;
uVar2 = *(uint *)(this + 0x34);
bVar3 = 0xff;
bVar5 = 0xff;
if (uVar2 != 0) {
bVar6 = 0;
bVar5 = 0;
if (uVar2 != 1) {
do {
bVar5 = bVar6 + 1;
bVar1 = 3 < uVar2;
uVar2 = uVar2 >> 1;
bVar6 = bVar5;
} while (bVar1);
}
}
uVar4 = (ulong)*(uint *)(this + 0x38) / (ulong)*(uint *)(this + 0x3c);
if ((int)uVar4 != 0) {
bVar6 = 0;
bVar3 = 0;
if ((int)uVar4 != 1) {
do {
bVar3 = bVar6 + 1;
uVar2 = (uint)uVar4;
uVar4 = uVar4 >> 1;
bVar6 = bVar3;
} while (3 < uVar2);
}
}
return param_1 >> (bVar5 & 0x1f) & ~(-1 << (bVar3 & 0x1f));
}
| |
28,470 | rw_pr_unlock | eloqsql/mysys/thr_rwlock.c | int rw_pr_unlock(rw_pr_lock_t *rwlock)
{
if (rwlock->active_writer)
{
/* We are unlocking wr-lock. */
#ifdef SAFE_MUTEX
rwlock->writer_thread= 0;
#endif
rwlock->active_writer= FALSE;
if (rwlock->writers_waiting_readers)
{
/*
Avoid expensive cond signal in case when there is no contention
or it is wr-only.
Note that from view point of performance it would be better to
signal on the condition variable after unlocking mutex (as it
reduces number of contex switches).
Unfortunately this would mean that such rwlock can't be safely
used by MDL subsystem, which relies on the fact that it is OK
to destroy rwlock once it is in unlocked state.
*/
pthread_cond_signal(&rwlock->no_active_readers);
}
pthread_mutex_unlock(&rwlock->lock);
}
else
{
/* We are unlocking rd-lock. */
pthread_mutex_lock(&rwlock->lock);
rwlock->active_readers--;
if (rwlock->active_readers == 0 &&
rwlock->writers_waiting_readers)
{
/*
If we are last reader and there are waiting
writers wake them up.
*/
pthread_cond_signal(&rwlock->no_active_readers);
}
pthread_mutex_unlock(&rwlock->lock);
}
return 0;
} | O3 | c | rw_pr_unlock:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x60(%rdi)
je 0xa45b0
movb $0x0, 0x60(%rbx)
cmpl $0x0, 0x5c(%rbx)
je 0xa45bd
leaq 0x28(%rbx), %rdi
callq 0x295b0
jmp 0xa45bd
movq %rbx, %rdi
callq 0x29200
decl 0x58(%rbx)
je 0xa459f
movq %rbx, %rdi
callq 0x291c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| rw_pr_unlock:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
cmp byte ptr [rdi+60h], 0
jz short loc_A45B0
mov byte ptr [rbx+60h], 0
loc_A459F:
cmp dword ptr [rbx+5Ch], 0
jz short loc_A45BD
lea rdi, [rbx+28h]
call _pthread_cond_signal
jmp short loc_A45BD
loc_A45B0:
mov rdi, rbx
call _pthread_mutex_lock
dec dword ptr [rbx+58h]
jz short loc_A459F
loc_A45BD:
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
| long long rw_pr_unlock(long long a1)
{
if ( *(_BYTE *)(a1 + 96) )
{
*(_BYTE *)(a1 + 96) = 0;
}
else
{
pthread_mutex_lock(a1);
if ( (*(_DWORD *)(a1 + 88))-- != 1 )
goto LABEL_6;
}
if ( *(_DWORD *)(a1 + 92) )
pthread_cond_signal(a1 + 40);
LABEL_6:
pthread_mutex_unlock(a1);
return 0LL;
}
| rw_pr_unlock:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP byte ptr [RDI + 0x60],0x0
JZ 0x001a45b0
MOV byte ptr [RBX + 0x60],0x0
LAB_001a459f:
CMP dword ptr [RBX + 0x5c],0x0
JZ 0x001a45bd
LEA RDI,[RBX + 0x28]
CALL 0x001295b0
JMP 0x001a45bd
LAB_001a45b0:
MOV RDI,RBX
CALL 0x00129200
DEC dword ptr [RBX + 0x58]
JZ 0x001a459f
LAB_001a45bd:
MOV RDI,RBX
CALL 0x001291c0
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 rw_pr_unlock(pthread_mutex_t *param_1)
{
int *piVar1;
if (*(char *)((long)param_1 + 0x60) == '\0') {
pthread_mutex_lock(param_1);
piVar1 = (int *)((long)param_1 + 0x58);
*piVar1 = *piVar1 + -1;
if (*piVar1 != 0) goto LAB_001a45bd;
}
else {
*(int1 *)((long)param_1 + 0x60) = 0;
}
if (*(int *)((long)param_1 + 0x5c) != 0) {
pthread_cond_signal((pthread_cond_t *)(param_1 + 1));
}
LAB_001a45bd:
pthread_mutex_unlock(param_1);
return 0;
}
| |
28,471 | Json::OurReader::decodeNumber(Json::OurReader::Token&) | aimrt_mujoco_sim/_deps/jsoncpp-src/src/lib_json/json_reader.cpp | bool OurReader::decodeNumber(Token& token) {
Value decoded;
if (!decodeNumber(token, decoded))
return false;
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
} | O3 | cpp | Json::OurReader::decodeNumber(Json::OurReader::Token&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x76670
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x71d1a
movl %eax, %ebx
testb %al, %al
je 0x71003
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
jne 0x70f9f
movq 0x48(%r14), %rcx
movl $0x200, %eax # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x76d9a
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
jne 0x70fc4
movq 0x48(%r14), %rcx
movl $0x200, %eax # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
movq 0x8(%r15), %rsi
subq 0xc0(%r14), %rsi
callq 0x79aba
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
jne 0x70fef
movq 0x48(%r14), %rcx
movl $0x200, %eax # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
movq 0x10(%r15), %rsi
subq 0xc0(%r14), %rsi
callq 0x79ac0
leaq 0x8(%rsp), %rdi
callq 0x76cde
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x76cde
movq %rbx, %rdi
callq 0x1ffd0
| _ZN4Json9OurReader12decodeNumberERNS0_5TokenE:
push r15
push r14
push rbx
sub rsp, 30h
mov r15, rsi
mov r14, rdi
lea rbx, [rsp+48h+var_40]
mov rdi, rbx
xor esi, esi
call _ZN4Json5ValueC2ENS_9ValueTypeE; Json::Value::Value(Json::ValueType)
mov rdi, r14
mov rsi, r15
mov rdx, rbx
call _ZN4Json9OurReader12decodeNumberERNS0_5TokenERNS_5ValueE; Json::OurReader::decodeNumber(Json::OurReader::Token &,Json::Value &)
mov ebx, eax
test al, al
jz short loc_71003
mov rax, [r14+30h]
cmp rax, [r14+38h]
jnz short loc_70F9F
mov rcx, [r14+48h]
mov eax, 200h
add rax, [rcx-8]
loc_70F9F:
mov rdi, [rax-8]; this
lea rsi, [rsp+48h+var_40]; Json::Value *
call _ZN4Json5Value11swapPayloadERS0_; Json::Value::swapPayload(Json::Value&)
mov rax, [r14+30h]
cmp rax, [r14+38h]
jnz short loc_70FC4
mov rcx, [r14+48h]
mov eax, 200h
add rax, [rcx-8]
loc_70FC4:
mov rdi, [rax-8]; this
mov rsi, [r15+8]
sub rsi, [r14+0C0h]; __int64
call _ZN4Json5Value14setOffsetStartEl; Json::Value::setOffsetStart(long)
mov rax, [r14+30h]
cmp rax, [r14+38h]
jnz short loc_70FEF
mov rcx, [r14+48h]
mov eax, 200h
add rax, [rcx-8]
loc_70FEF:
mov rdi, [rax-8]; this
mov rsi, [r15+10h]
sub rsi, [r14+0C0h]; __int64
call _ZN4Json5Value14setOffsetLimitEl; Json::Value::setOffsetLimit(long)
loc_71003:
lea rdi, [rsp+48h+var_40]; void *
call _ZN4Json5ValueD2Ev; Json::Value::~Value()
mov eax, ebx
add rsp, 30h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZN4Json5ValueD2Ev; Json::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
| long long Json::OurReader::decodeNumber(_QWORD *a1, long long a2)
{
unsigned int v2; // ebx
long long v3; // rax
long long v4; // rax
long long v5; // rax
_BYTE v7[64]; // [rsp+8h] [rbp-40h] BYREF
Json::Value::Value(v7, 0LL);
v2 = Json::OurReader::decodeNumber(a1, a2, v7);
if ( (_BYTE)v2 )
{
v3 = a1[6];
if ( v3 == a1[7] )
v3 = *(_QWORD *)(a1[9] - 8LL) + 512LL;
Json::Value::swapPayload(*(Json::Value **)(v3 - 8), (Json::Value *)v7);
v4 = a1[6];
if ( v4 == a1[7] )
v4 = *(_QWORD *)(a1[9] - 8LL) + 512LL;
Json::Value::setOffsetStart(*(Json::Value **)(v4 - 8), *(_QWORD *)(a2 + 8) - a1[24]);
v5 = a1[6];
if ( v5 == a1[7] )
v5 = *(_QWORD *)(a1[9] - 8LL) + 512LL;
Json::Value::setOffsetLimit(*(Json::Value **)(v5 - 8), *(_QWORD *)(a2 + 16) - a1[24]);
}
Json::Value::~Value(v7);
return v2;
}
| decodeNumber:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R15,RSI
MOV R14,RDI
LEA RBX,[RSP + 0x8]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00176670
LAB_00170f74:
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
CALL 0x00171d1a
MOV EBX,EAX
TEST AL,AL
JZ 0x00171003
MOV RAX,qword ptr [R14 + 0x30]
CMP RAX,qword ptr [R14 + 0x38]
JNZ 0x00170f9f
MOV RCX,qword ptr [R14 + 0x48]
MOV EAX,0x200
ADD RAX,qword ptr [RCX + -0x8]
LAB_00170f9f:
MOV RDI,qword ptr [RAX + -0x8]
LEA RSI,[RSP + 0x8]
CALL 0x00176d9a
MOV RAX,qword ptr [R14 + 0x30]
CMP RAX,qword ptr [R14 + 0x38]
JNZ 0x00170fc4
MOV RCX,qword ptr [R14 + 0x48]
MOV EAX,0x200
ADD RAX,qword ptr [RCX + -0x8]
LAB_00170fc4:
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [R15 + 0x8]
SUB RSI,qword ptr [R14 + 0xc0]
CALL 0x00179aba
MOV RAX,qword ptr [R14 + 0x30]
CMP RAX,qword ptr [R14 + 0x38]
JNZ 0x00170fef
MOV RCX,qword ptr [R14 + 0x48]
MOV EAX,0x200
ADD RAX,qword ptr [RCX + -0x8]
LAB_00170fef:
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [R15 + 0x10]
SUB RSI,qword ptr [R14 + 0xc0]
CALL 0x00179ac0
LAB_00171003:
LEA RDI,[RSP + 0x8]
CALL 0x00176cde
MOV EAX,EBX
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
/* Json::OurReader::decodeNumber(Json::OurReader::Token&) */
int4 __thiscall Json::OurReader::decodeNumber(OurReader *this,Token *param_1)
{
int4 uVar1;
long lVar2;
Value local_40 [40];
Value::Value(local_40,0);
/* try { // try from 00170f74 to 00171002 has its CatchHandler @ 00171019 */
uVar1 = decodeNumber(this,param_1,local_40);
if ((char)uVar1 != '\0') {
lVar2 = *(long *)(this + 0x30);
if (lVar2 == *(long *)(this + 0x38)) {
lVar2 = *(long *)(*(long *)(this + 0x48) + -8) + 0x200;
}
Value::swapPayload(*(Value **)(lVar2 + -8),local_40);
lVar2 = *(long *)(this + 0x30);
if (lVar2 == *(long *)(this + 0x38)) {
lVar2 = *(long *)(*(long *)(this + 0x48) + -8) + 0x200;
}
Value::setOffsetStart(*(Value **)(lVar2 + -8),*(long *)(param_1 + 8) - *(long *)(this + 0xc0));
lVar2 = *(long *)(this + 0x30);
if (lVar2 == *(long *)(this + 0x38)) {
lVar2 = *(long *)(*(long *)(this + 0x48) + -8) + 0x200;
}
Value::setOffsetLimit
(*(Value **)(lVar2 + -8),*(long *)(param_1 + 0x10) - *(long *)(this + 0xc0));
}
Value::~Value(local_40);
return uVar1;
}
| |
28,472 | my_sync_dir | eloqsql/mysys/my_sync.c | int my_sync_dir(const char *dir_name __attribute__((unused)),
myf my_flags __attribute__((unused)))
{
#ifdef NEED_EXPLICIT_SYNC_DIR
static const char cur_dir_name[]= {FN_CURLIB, 0};
File dir_fd;
int res= 0;
const char *correct_dir_name;
DBUG_ENTER("my_sync_dir");
DBUG_PRINT("my",("Dir: '%s' my_flags: %lu", dir_name, my_flags));
/* Sometimes the path does not contain an explicit directory */
correct_dir_name= (dir_name[0] == 0) ? cur_dir_name : dir_name;
/*
Syncing a dir may give EINVAL on tmpfs on Linux, which is ok.
EIO on the other hand is very important. Hence MY_IGNORE_BADFD.
*/
if ((dir_fd= my_open(correct_dir_name, O_RDONLY, MYF(my_flags))) >= 0)
{
if (my_sync(dir_fd, MYF(my_flags | MY_IGNORE_BADFD)))
res= 2;
if (my_close(dir_fd, MYF(my_flags)))
res= 3;
}
else
res= 1;
DBUG_RETURN(res);
#else
return 0;
#endif
} | O0 | c | my_sync_dir:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
jmp 0x59d59
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x59d72
leaq 0x5a274(%rip), %rax # 0xb3fe0
movq %rax, -0x28(%rbp)
jmp 0x59d7a
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x65460
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0x59dcf
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
orq $0x20, %rsi
callq 0x59bb0
cmpl $0x0, %eax
je 0x59db5
movl $0x2, -0x18(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x656f0
cmpl $0x0, %eax
je 0x59dcd
movl $0x3, -0x18(%rbp)
jmp 0x59dd6
movl $0x1, -0x18(%rbp)
jmp 0x59dd8
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| my_sync_dir:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], 0
jmp short $+2
loc_59D59:
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_59D72
lea rax, my_sync_dir_cur_dir_name; "."
mov [rbp+var_28], rax
jmp short loc_59D7A
loc_59D72:
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
loc_59D7A:
mov rax, [rbp+var_28]
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
mov rdx, [rbp+var_10]
xor esi, esi
call my_open
mov [rbp+var_14], eax
cmp eax, 0
jl short loc_59DCF
mov edi, [rbp+var_14]
mov rsi, [rbp+var_10]
or rsi, 20h
call my_sync
cmp eax, 0
jz short loc_59DB5
mov [rbp+var_18], 2
loc_59DB5:
mov edi, [rbp+var_14]
mov rsi, [rbp+var_10]
call my_close
cmp eax, 0
jz short loc_59DCD
mov [rbp+var_18], 3
loc_59DCD:
jmp short loc_59DD6
loc_59DCF:
mov [rbp+var_18], 1
loc_59DD6:
jmp short $+2
loc_59DD8:
mov eax, [rbp+var_18]
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
add rsp, 30h
pop rbp
retn
| long long my_sync_dir(const char *a1, long long a2)
{
const char *v3; // [rsp+8h] [rbp-28h]
unsigned int v4; // [rsp+18h] [rbp-18h]
signed int v5; // [rsp+1Ch] [rbp-14h]
v4 = 0;
if ( *a1 )
v3 = a1;
else
v3 = ".";
v5 = my_open(v3, 0LL, a2);
if ( v5 < 0 )
{
return 1;
}
else
{
if ( (unsigned int)my_sync(v5, (unsigned int)a2 | 0x20) )
v4 = 2;
if ( (unsigned int)my_close((unsigned int)v5, a2) )
return 3;
}
return v4;
}
| my_sync_dir:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00159d59
LAB_00159d59:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x00159d72
LEA RAX,[0x1b3fe0]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00159d7a
LAB_00159d72:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_00159d7a:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x00165460
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JL 0x00159dcf
MOV EDI,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RBP + -0x10]
OR RSI,0x20
CALL 0x00159bb0
CMP EAX,0x0
JZ 0x00159db5
MOV dword ptr [RBP + -0x18],0x2
LAB_00159db5:
MOV EDI,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001656f0
CMP EAX,0x0
JZ 0x00159dcd
MOV dword ptr [RBP + -0x18],0x3
LAB_00159dcd:
JMP 0x00159dd6
LAB_00159dcf:
MOV dword ptr [RBP + -0x18],0x1
LAB_00159dd6:
JMP 0x00159dd8
LAB_00159dd8:
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
ADD RSP,0x30
POP RBP
RET
|
int4 my_sync_dir(char *param_1,ulong param_2)
{
int iVar1;
int iVar2;
char *local_30;
int4 local_20;
local_20 = 0;
local_30 = param_1;
if (*param_1 == '\0') {
local_30 = ".";
}
iVar1 = my_open(local_30,0,param_2);
if (iVar1 < 0) {
local_20 = 1;
}
else {
iVar2 = my_sync(iVar1,param_2 | 0x20);
if (iVar2 != 0) {
local_20 = 2;
}
iVar1 = my_close(iVar1,param_2);
if (iVar1 != 0) {
local_20 = 3;
}
}
return local_20;
}
| |
28,473 | ma_init_block_record | eloqsql/storage/maria/ma_blockrec.c | my_bool _ma_init_block_record(MARIA_HA *info)
{
MARIA_ROW *row= &info->cur_row, *new_row= &info->new_row;
MARIA_SHARE *share= info->s;
myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
uint default_extents;
DBUG_ENTER("_ma_init_block_record");
if (!my_multi_malloc(PSI_INSTRUMENT_ME, flag,
&row->empty_bits, share->base.pack_bytes,
&row->field_lengths,
share->base.max_field_lengths + 2,
&row->blob_lengths, sizeof(ulong) * share->base.blobs,
&row->null_field_lengths, (sizeof(uint) *
(share->base.fields -
share->base.blobs +
EXTRA_LENGTH_FIELDS)),
&row->tail_positions, (sizeof(MARIA_RECORD_POS) *
(share->base.blobs + 2)),
&new_row->empty_bits, share->base.pack_bytes,
&new_row->field_lengths,
share->base.max_field_lengths + 2,
&new_row->blob_lengths,
sizeof(ulong) * share->base.blobs,
&new_row->null_field_lengths, (sizeof(uint) *
(share->base.fields -
share->base.blobs +
EXTRA_LENGTH_FIELDS)),
&info->log_row_parts,
sizeof(*info->log_row_parts) *
(TRANSLOG_INTERNAL_PARTS + 3 +
share->base.fields + 3),
&info->update_field_data,
(share->base.fields * 4 +
share->base.max_field_lengths + 1 + 4),
NullS, 0))
DBUG_RETURN(1);
/* Skip over bytes used to store length of field length for logging */
row->field_lengths+= 2;
new_row->field_lengths+= 2;
/* Reserve some initial space to avoid mallocs during execution */
default_extents= (ELEMENTS_RESERVED_FOR_MAIN_PART + 1 +
(AVERAGE_BLOB_SIZE /
FULL_PAGE_SIZE(share) /
BLOB_SEGMENT_MIN_SIZE));
if (my_init_dynamic_array(PSI_INSTRUMENT_ME, &info->bitmap_blocks,
sizeof(MARIA_BITMAP_BLOCK),
default_extents, 64, flag))
goto err;
info->cur_row.extents_buffer_length= default_extents * ROW_EXTENT_SIZE;
if (!(info->cur_row.extents= my_malloc(PSI_INSTRUMENT_ME,
info->cur_row.extents_buffer_length,
flag)))
goto err;
info->row_base_length= share->base_length;
info->row_flag= share->base.default_row_flag;
/*
We need to reserve 'EXTRA_LENGTH_FIELDS' number of parts in
null_field_lengths to allow splitting of rows in 'find_where_to_split_row'
*/
row->null_field_lengths+= EXTRA_LENGTH_FIELDS;
new_row->null_field_lengths+= EXTRA_LENGTH_FIELDS;
DBUG_RETURN(0);
err:
_ma_end_block_record(info);
DBUG_RETURN(1);
} | O0 | c | ma_init_block_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq $0x140, %rax # imm = 0x140
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movsbl 0x7d9(%rax), %edx
xorl %eax, %eax
movl $0x10000, %ecx # imm = 0x10000
cmpl $0x0, %edx
cmovnel %ecx, %eax
orl $0x10, %eax
movl %eax, %eax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq $0x48, %rdx
movq -0x50(%rbp), %rax
movl 0x3f4(%rax), %ecx
movq -0x40(%rbp), %r8
addq $0x50, %r8
movq -0x50(%rbp), %rax
movl 0x3d4(%rax), %r9d
addl $0x2, %r9d
movq -0x40(%rbp), %rax
addq $0x60, %rax
movq %rax, -0xb0(%rbp)
movq -0x50(%rbp), %rax
movl 0x3f0(%rax), %eax
shlq $0x3, %rax
movq %rax, -0xa8(%rbp)
movq -0x40(%rbp), %rax
addq $0x58, %rax
movq %rax, -0xa0(%rbp)
movq -0x50(%rbp), %rax
movl 0x3c8(%rax), %eax
movq -0x50(%rbp), %rdi
subl 0x3f0(%rdi), %eax
addl $0x3, %eax
movl %eax, %eax
shlq $0x2, %rax
movq %rax, -0x98(%rbp)
movq -0x40(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x90(%rbp)
movq -0x50(%rbp), %rax
movl 0x3f0(%rax), %eax
addl $0x2, %eax
movl %eax, %eax
shlq $0x3, %rax
movq %rax, -0x88(%rbp)
movq -0x48(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x80(%rbp)
movq -0x50(%rbp), %rax
movl 0x3f4(%rax), %eax
movl %eax, -0x74(%rbp)
movq -0x48(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x70(%rbp)
movq -0x50(%rbp), %rax
movl 0x3d4(%rax), %eax
addl $0x2, %eax
movl %eax, -0x64(%rbp)
movq -0x48(%rbp), %r13
addq $0x60, %r13
movq -0x50(%rbp), %rax
movl 0x3f0(%rax), %eax
movl %eax, %r12d
shlq $0x3, %r12
movq -0x48(%rbp), %r15
addq $0x58, %r15
movq -0x50(%rbp), %rax
movl 0x3c8(%rax), %eax
movq -0x50(%rbp), %rdi
subl 0x3f0(%rdi), %eax
addl $0x3, %eax
movl %eax, %eax
movl %eax, %r14d
shlq $0x2, %r14
movq -0x38(%rbp), %rbx
addq $0x318, %rbx # imm = 0x318
movq -0x50(%rbp), %rax
movl 0x3c8(%rax), %eax
addl $0x5, %eax
addl $0x3, %eax
movl %eax, %eax
movl %eax, %r11d
shlq $0x4, %r11
movq -0x38(%rbp), %r10
addq $0x3c8, %r10 # imm = 0x3C8
movq -0x50(%rbp), %rax
movl 0x3c8(%rax), %eax
shll $0x2, %eax
movq -0x50(%rbp), %rdi
addl 0x3d4(%rdi), %eax
addl $0x1, %eax
addl $0x4, %eax
movl %eax, -0x60(%rbp)
xorl %edi, %edi
xorl %eax, %eax
movq -0xb0(%rbp), %rax
movq %rax, (%rsp)
movq -0xa8(%rbp), %rax
movq %rax, 0x8(%rsp)
movq -0xa0(%rbp), %rax
movq %rax, 0x10(%rsp)
movq -0x98(%rbp), %rax
movq %rax, 0x18(%rsp)
movq -0x90(%rbp), %rax
movq %rax, 0x20(%rsp)
movq -0x88(%rbp), %rax
movq %rax, 0x28(%rsp)
movq -0x80(%rbp), %rax
movq %rax, 0x30(%rsp)
movl -0x74(%rbp), %eax
movl %eax, 0x38(%rsp)
movq -0x70(%rbp), %rax
movq %rax, 0x40(%rsp)
movl -0x64(%rbp), %eax
movl %eax, 0x48(%rsp)
movl -0x60(%rbp), %eax
movq %r13, 0x50(%rsp)
movq %r12, 0x58(%rsp)
movq %r15, 0x60(%rsp)
movq %r14, 0x68(%rsp)
movq %rbx, 0x70(%rsp)
movq %r11, 0x78(%rsp)
movq %r10, 0x80(%rsp)
movl %eax, 0x88(%rsp)
movq $0x0, 0x90(%rsp)
movl $0x0, 0x98(%rsp)
movb $0x0, %al
callq 0xf1bb0
cmpq $0x0, %rax
jne 0x523ac
jmp 0x523a3
movb $0x1, -0x29(%rbp)
jmp 0x524d5
movq -0x40(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x50(%rax)
movq -0x48(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x50(%rax)
movq -0x50(%rbp), %rax
movl 0x7bc(%rax), %eax
movq -0x50(%rbp), %rcx
movl 0xc18(%rcx), %ecx
addl $0x8, %ecx
subl %ecx, %eax
subl $0x4, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x100000, %eax # imm = 0x100000
cqto
idivq %rcx
movl $0x80, %ecx
cqto
idivq %rcx
addq $0x5, %rax
movl %eax, -0x5c(%rbp)
movq -0x38(%rbp), %rsi
addq $0x2c0, %rsi # imm = 0x2C0
movl -0x5c(%rbp), %r8d
movq -0x58(%rbp), %rax
xorl %edi, %edi
movl $0x18, %edx
xorl %ecx, %ecx
movl $0x40, %r9d
movq %rax, (%rsp)
callq 0xdf820
cmpb $0x0, %al
je 0x5243b
jmp 0x524c8
imull $0x7, -0x5c(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movq %rcx, 0x118(%rax)
movq -0x38(%rbp), %rax
movq 0x118(%rax), %rsi
movq -0x58(%rbp), %rdx
xorl %edi, %edi
callq 0xfc090
movq -0x38(%rbp), %rcx
movq %rax, 0x90(%rcx)
cmpq $0x0, %rax
jne 0x52477
jmp 0x524c8
movq -0x50(%rbp), %rax
movl 0x7c4(%rax), %eax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movq %rcx, 0x610(%rax)
movq -0x50(%rbp), %rax
movl 0x418(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x618(%rax)
movq -0x40(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0xc, %rcx
movq %rcx, 0x58(%rax)
movq -0x48(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0xc, %rcx
movq %rcx, 0x58(%rax)
movb $0x0, -0x29(%rbp)
jmp 0x524d5
movq -0x38(%rbp), %rdi
callq 0x524f0
movb $0x1, -0x29(%rbp)
movb -0x29(%rbp), %al
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw (%rax,%rax)
| _ma_init_block_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 128h
mov [rbp+var_38], rdi
mov rax, [rbp+var_38]
add rax, 80h
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
add rax, 140h
mov [rbp+var_48], rax
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
movsx edx, byte ptr [rax+7D9h]
xor eax, eax
mov ecx, 10000h
cmp edx, 0
cmovnz eax, ecx
or eax, 10h
mov eax, eax
mov [rbp+var_58], rax
mov rsi, [rbp+var_58]
mov rdx, [rbp+var_40]
add rdx, 48h ; 'H'
mov rax, [rbp+var_50]
mov ecx, [rax+3F4h]
mov r8, [rbp+var_40]
add r8, 50h ; 'P'
mov rax, [rbp+var_50]
mov r9d, [rax+3D4h]
add r9d, 2
mov rax, [rbp+var_40]
add rax, 60h ; '`'
mov [rbp+var_B0], rax
mov rax, [rbp+var_50]
mov eax, [rax+3F0h]
shl rax, 3
mov [rbp+var_A8], rax
mov rax, [rbp+var_40]
add rax, 58h ; 'X'
mov [rbp+var_A0], rax
mov rax, [rbp+var_50]
mov eax, [rax+3C8h]
mov rdi, [rbp+var_50]
sub eax, [rdi+3F0h]
add eax, 3
mov eax, eax
shl rax, 2
mov [rbp+var_98], rax
mov rax, [rbp+var_40]
add rax, 28h ; '('
mov [rbp+var_90], rax
mov rax, [rbp+var_50]
mov eax, [rax+3F0h]
add eax, 2
mov eax, eax
shl rax, 3
mov [rbp+var_88], rax
mov rax, [rbp+var_48]
add rax, 48h ; 'H'
mov [rbp+var_80], rax
mov rax, [rbp+var_50]
mov eax, [rax+3F4h]
mov [rbp+var_74], eax
mov rax, [rbp+var_48]
add rax, 50h ; 'P'
mov [rbp+var_70], rax
mov rax, [rbp+var_50]
mov eax, [rax+3D4h]
add eax, 2
mov [rbp+var_64], eax
mov r13, [rbp+var_48]
add r13, 60h ; '`'
mov rax, [rbp+var_50]
mov eax, [rax+3F0h]
mov r12d, eax
shl r12, 3
mov r15, [rbp+var_48]
add r15, 58h ; 'X'
mov rax, [rbp+var_50]
mov eax, [rax+3C8h]
mov rdi, [rbp+var_50]
sub eax, [rdi+3F0h]
add eax, 3
mov eax, eax
mov r14d, eax
shl r14, 2
mov rbx, [rbp+var_38]
add rbx, 318h
mov rax, [rbp+var_50]
mov eax, [rax+3C8h]
add eax, 5
add eax, 3
mov eax, eax
mov r11d, eax
shl r11, 4
mov r10, [rbp+var_38]
add r10, 3C8h
mov rax, [rbp+var_50]
mov eax, [rax+3C8h]
shl eax, 2
mov rdi, [rbp+var_50]
add eax, [rdi+3D4h]
add eax, 1
add eax, 4
mov [rbp+var_60], eax
xor edi, edi
xor eax, eax
mov rax, [rbp+var_B0]
mov [rsp+150h+var_150], rax
mov rax, [rbp+var_A8]
mov [rsp+150h+var_148], rax
mov rax, [rbp+var_A0]
mov [rsp+150h+var_140], rax
mov rax, [rbp+var_98]
mov [rsp+150h+var_138], rax
mov rax, [rbp+var_90]
mov [rsp+150h+var_130], rax
mov rax, [rbp+var_88]
mov [rsp+150h+var_128], rax
mov rax, [rbp+var_80]
mov [rsp+150h+var_120], rax
mov eax, [rbp+var_74]
mov [rsp+150h+var_118], eax
mov rax, [rbp+var_70]
mov [rsp+150h+var_110], rax
mov eax, [rbp+var_64]
mov [rsp+150h+var_108], eax
mov eax, [rbp+var_60]
mov [rsp+150h+var_100], r13
mov [rsp+150h+var_F8], r12
mov [rsp+150h+var_F0], r15
mov [rsp+150h+var_E8], r14
mov [rsp+150h+var_E0], rbx
mov [rsp+150h+var_D8], r11
mov [rsp+150h+var_D0], r10
mov [rsp+150h+var_C8], eax
mov [rsp+150h+var_C0], 0
mov [rsp+150h+var_B8], 0
mov al, 0
call my_multi_malloc
cmp rax, 0
jnz short loc_523AC
jmp short $+2
loc_523A3:
mov [rbp+var_29], 1
jmp loc_524D5
loc_523AC:
mov rax, [rbp+var_40]
mov rcx, [rax+50h]
add rcx, 2
mov [rax+50h], rcx
mov rax, [rbp+var_48]
mov rcx, [rax+50h]
add rcx, 2
mov [rax+50h], rcx
mov rax, [rbp+var_50]
mov eax, [rax+7BCh]
mov rcx, [rbp+var_50]
mov ecx, [rcx+0C18h]
add ecx, 8
sub eax, ecx
sub eax, 4
mov eax, eax
mov ecx, eax
mov eax, 100000h
cqo
idiv rcx
mov ecx, 80h
cqo
idiv rcx
add rax, 5
mov [rbp+var_5C], eax
mov rsi, [rbp+var_38]
add rsi, 2C0h
mov r8d, [rbp+var_5C]
mov rax, [rbp+var_58]
xor edi, edi
mov edx, 18h
xor ecx, ecx
mov r9d, 40h ; '@'
mov [rsp+150h+var_150], rax
call init_dynamic_array2
cmp al, 0
jz short loc_5243B
jmp loc_524C8
loc_5243B:
imul eax, [rbp+var_5C], 7
mov eax, eax
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax+118h], rcx
mov rax, [rbp+var_38]
mov rsi, [rax+118h]
mov rdx, [rbp+var_58]
xor edi, edi
call my_malloc
mov rcx, [rbp+var_38]
mov [rcx+90h], rax
cmp rax, 0
jnz short loc_52477
jmp short loc_524C8
loc_52477:
mov rax, [rbp+var_50]
mov eax, [rax+7C4h]
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax+610h], rcx
mov rax, [rbp+var_50]
mov ecx, [rax+418h]
mov rax, [rbp+var_38]
mov [rax+618h], ecx
mov rax, [rbp+var_40]
mov rcx, [rax+58h]
add rcx, 0Ch
mov [rax+58h], rcx
mov rax, [rbp+var_48]
mov rcx, [rax+58h]
add rcx, 0Ch
mov [rax+58h], rcx
mov [rbp+var_29], 0
jmp short loc_524D5
loc_524C8:
mov rdi, [rbp+var_38]
call _ma_end_block_record
mov [rbp+var_29], 1
loc_524D5:
mov al, [rbp+var_29]
add rsp, 128h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char ma_init_block_record(long long a1)
{
int v1; // eax
long long v2; // rax
int v4; // [rsp+38h] [rbp-118h]
int v5; // [rsp+48h] [rbp-108h]
int v6; // [rsp+F4h] [rbp-5Ch]
long long v7; // [rsp+F8h] [rbp-58h]
_DWORD *v8; // [rsp+100h] [rbp-50h]
long long v9; // [rsp+108h] [rbp-48h]
long long v10; // [rsp+110h] [rbp-40h]
v8 = *(_DWORD **)a1;
v1 = 0;
if ( *(_BYTE *)(*(_QWORD *)a1 + 2009LL) )
v1 = 0x10000;
v7 = v1 | 0x10u;
v4 = v8[253];
v5 = v8[245] + 2;
v9 = a1 + 320;
v10 = a1 + 128;
if ( !my_multi_malloc(
0,
v1 | 0x10u,
(int)v10 + 72,
v4,
(int)v10 + 80,
v5,
v10 + 96,
8LL * (unsigned int)v8[252],
v10 + 88,
4LL * (unsigned int)(v8[242] - v8[252] + 3),
v10 + 40,
8LL * (unsigned int)(v8[252] + 2),
v9 + 72,
v4,
v9 + 80,
v5,
v9 + 96,
8LL * (unsigned int)v8[252],
v9 + 88,
4LL * (unsigned int)(v8[242] - v8[252] + 3),
a1 + 792,
16LL * (unsigned int)(v8[242] + 8),
a1 + 968,
v8[245] + 4 * v8[242] + 5,
0LL,
0,
v10 + 96,
8LL * (unsigned int)v8[252],
v10 + 88,
4LL * (unsigned int)(v8[242] - v8[252] + 3),
v10 + 40,
8LL * (unsigned int)(v8[252] + 2),
v9 + 72) )
return 1;
*(_QWORD *)(a1 + 208) += 2LL;
*(_QWORD *)(a1 + 400) += 2LL;
v6 = 0x100000LL / (unsigned int)(v8[495] - (v8[774] + 8) - 4) / 128 + 5;
if ( (unsigned __int8)init_dynamic_array2(0, (int)a1 + 704, 24, 0, v6, 64, v7)
|| (*(_QWORD *)(a1 + 280) = (unsigned int)(7 * v6),
v2 = my_malloc(0LL, *(_QWORD *)(a1 + 280), v7),
(*(_QWORD *)(a1 + 144) = v2) == 0LL) )
{
ma_end_block_record(a1);
return 1;
}
else
{
*(_QWORD *)(a1 + 1552) = (unsigned int)v8[497];
*(_DWORD *)(a1 + 1560) = v8[262];
*(_QWORD *)(a1 + 216) += 12LL;
*(_QWORD *)(a1 + 408) += 12LL;
return 0;
}
}
| _ma_init_block_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x128
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x80
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x140
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOVSX EDX,byte ptr [RAX + 0x7d9]
XOR EAX,EAX
MOV ECX,0x10000
CMP EDX,0x0
CMOVNZ EAX,ECX
OR EAX,0x10
MOV EAX,EAX
MOV qword ptr [RBP + -0x58],RAX
MOV RSI,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x40]
ADD RDX,0x48
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RAX + 0x3f4]
MOV R8,qword ptr [RBP + -0x40]
ADD R8,0x50
MOV RAX,qword ptr [RBP + -0x50]
MOV R9D,dword ptr [RAX + 0x3d4]
ADD R9D,0x2
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x60
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x3f0]
SHL RAX,0x3
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x58
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x3c8]
MOV RDI,qword ptr [RBP + -0x50]
SUB EAX,dword ptr [RDI + 0x3f0]
ADD EAX,0x3
MOV EAX,EAX
SHL RAX,0x2
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x28
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x3f0]
ADD EAX,0x2
MOV EAX,EAX
SHL RAX,0x3
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x48
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x3f4]
MOV dword ptr [RBP + -0x74],EAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x50
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x3d4]
ADD EAX,0x2
MOV dword ptr [RBP + -0x64],EAX
MOV R13,qword ptr [RBP + -0x48]
ADD R13,0x60
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x3f0]
MOV R12D,EAX
SHL R12,0x3
MOV R15,qword ptr [RBP + -0x48]
ADD R15,0x58
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x3c8]
MOV RDI,qword ptr [RBP + -0x50]
SUB EAX,dword ptr [RDI + 0x3f0]
ADD EAX,0x3
MOV EAX,EAX
MOV R14D,EAX
SHL R14,0x2
MOV RBX,qword ptr [RBP + -0x38]
ADD RBX,0x318
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x3c8]
ADD EAX,0x5
ADD EAX,0x3
MOV EAX,EAX
MOV R11D,EAX
SHL R11,0x4
MOV R10,qword ptr [RBP + -0x38]
ADD R10,0x3c8
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x3c8]
SHL EAX,0x2
MOV RDI,qword ptr [RBP + -0x50]
ADD EAX,dword ptr [RDI + 0x3d4]
ADD EAX,0x1
ADD EAX,0x4
MOV dword ptr [RBP + -0x60],EAX
XOR EDI,EDI
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0xb0]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RSP + 0x30],RAX
MOV EAX,dword ptr [RBP + -0x74]
MOV dword ptr [RSP + 0x38],EAX
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RSP + 0x40],RAX
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RSP + 0x48],EAX
MOV EAX,dword ptr [RBP + -0x60]
MOV qword ptr [RSP + 0x50],R13
MOV qword ptr [RSP + 0x58],R12
MOV qword ptr [RSP + 0x60],R15
MOV qword ptr [RSP + 0x68],R14
MOV qword ptr [RSP + 0x70],RBX
MOV qword ptr [RSP + 0x78],R11
MOV qword ptr [RSP + 0x80],R10
MOV dword ptr [RSP + 0x88],EAX
MOV qword ptr [RSP + 0x90],0x0
MOV dword ptr [RSP + 0x98],0x0
MOV AL,0x0
CALL 0x001f1bb0
CMP RAX,0x0
JNZ 0x001523ac
JMP 0x001523a3
LAB_001523a3:
MOV byte ptr [RBP + -0x29],0x1
JMP 0x001524d5
LAB_001523ac:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RAX + 0x50]
ADD RCX,0x2
MOV qword ptr [RAX + 0x50],RCX
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RAX + 0x50]
ADD RCX,0x2
MOV qword ptr [RAX + 0x50],RCX
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV RCX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RCX + 0xc18]
ADD ECX,0x8
SUB EAX,ECX
SUB EAX,0x4
MOV EAX,EAX
MOV ECX,EAX
MOV EAX,0x100000
CQO
IDIV RCX
MOV ECX,0x80
CQO
IDIV RCX
ADD RAX,0x5
MOV dword ptr [RBP + -0x5c],EAX
MOV RSI,qword ptr [RBP + -0x38]
ADD RSI,0x2c0
MOV R8D,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x58]
XOR EDI,EDI
MOV EDX,0x18
XOR ECX,ECX
MOV R9D,0x40
MOV qword ptr [RSP],RAX
CALL 0x001df820
CMP AL,0x0
JZ 0x0015243b
JMP 0x001524c8
LAB_0015243b:
IMUL EAX,dword ptr [RBP + -0x5c],0x7
MOV EAX,EAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x118],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RAX + 0x118]
MOV RDX,qword ptr [RBP + -0x58]
XOR EDI,EDI
CALL 0x001fc090
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RCX + 0x90],RAX
CMP RAX,0x0
JNZ 0x00152477
JMP 0x001524c8
LAB_00152477:
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x7c4]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x610],RCX
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RAX + 0x418]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x618],ECX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RAX + 0x58]
ADD RCX,0xc
MOV qword ptr [RAX + 0x58],RCX
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RAX + 0x58]
ADD RCX,0xc
MOV qword ptr [RAX + 0x58],RCX
MOV byte ptr [RBP + -0x29],0x0
JMP 0x001524d5
LAB_001524c8:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001524f0
MOV byte ptr [RBP + -0x29],0x1
LAB_001524d5:
MOV AL,byte ptr [RBP + -0x29]
ADD RSP,0x128
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 _ma_init_block_record(long *param_1)
{
long lVar1;
int1 auVar2 [16];
char cVar3;
uint uVar4;
int iVar5;
long lVar6;
lVar1 = *param_1;
uVar4 = 0;
if (*(char *)(lVar1 + 0x7d9) != '\0') {
uVar4 = 0x10000;
}
uVar4 = uVar4 | 0x10;
lVar6 = my_multi_malloc(0,uVar4,param_1 + 0x19,*(int4 *)(lVar1 + 0x3f4),param_1 + 0x1a,
*(int *)(lVar1 + 0x3d4) + 2,param_1 + 0x1c,
(ulong)*(uint *)(lVar1 + 0x3f0) << 3,param_1 + 0x1b,
(ulong)((*(int *)(lVar1 + 0x3c8) - *(int *)(lVar1 + 0x3f0)) + 3) << 2,
param_1 + 0x15,(ulong)(*(int *)(lVar1 + 0x3f0) + 2) << 3,param_1 + 0x31,
*(int4 *)(lVar1 + 0x3f4),param_1 + 0x32,*(int *)(lVar1 + 0x3d4) + 2,
param_1 + 0x34,(ulong)*(uint *)(lVar1 + 0x3f0) << 3,param_1 + 0x33,
(ulong)((*(int *)(lVar1 + 0x3c8) - *(int *)(lVar1 + 0x3f0)) + 3) << 2,
param_1 + 99,(ulong)(*(int *)(lVar1 + 0x3c8) + 8) << 4,param_1 + 0x79,
*(int *)(lVar1 + 0x3c8) * 4 + *(int *)(lVar1 + 0x3d4) + 5,0,0);
if (lVar6 != 0) {
param_1[0x1a] = param_1[0x1a] + 2;
param_1[0x32] = param_1[0x32] + 2;
auVar2._8_8_ = 0;
auVar2._0_8_ = SUB168(SEXT816(0x100000),8);
iVar5 = (int)(SUB168((auVar2 << 0x40 | ZEXT816(0x100000)) /
SEXT816((long)(ulong)((*(int *)(lVar1 + 0x7bc) -
(*(int *)(lVar1 + 0xc18) + 8)) - 4)),0) / 0x80) + 5;
cVar3 = init_dynamic_array2(0,param_1 + 0x58,0x18,0,iVar5,0x40,uVar4);
if (cVar3 == '\0') {
param_1[0x23] = (ulong)(uint)(iVar5 * 7);
lVar6 = my_malloc(0,param_1[0x23],uVar4);
param_1[0x12] = lVar6;
if (lVar6 != 0) {
param_1[0xc2] = (ulong)*(uint *)(lVar1 + 0x7c4);
*(int4 *)(param_1 + 0xc3) = *(int4 *)(lVar1 + 0x418);
param_1[0x1b] = param_1[0x1b] + 0xc;
param_1[0x33] = param_1[0x33] + 0xc;
return 0;
}
}
_ma_end_block_record(param_1);
}
return 1;
}
| |
28,474 | ma_init_block_record | eloqsql/storage/maria/ma_blockrec.c | my_bool _ma_init_block_record(MARIA_HA *info)
{
MARIA_ROW *row= &info->cur_row, *new_row= &info->new_row;
MARIA_SHARE *share= info->s;
myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
uint default_extents;
DBUG_ENTER("_ma_init_block_record");
if (!my_multi_malloc(PSI_INSTRUMENT_ME, flag,
&row->empty_bits, share->base.pack_bytes,
&row->field_lengths,
share->base.max_field_lengths + 2,
&row->blob_lengths, sizeof(ulong) * share->base.blobs,
&row->null_field_lengths, (sizeof(uint) *
(share->base.fields -
share->base.blobs +
EXTRA_LENGTH_FIELDS)),
&row->tail_positions, (sizeof(MARIA_RECORD_POS) *
(share->base.blobs + 2)),
&new_row->empty_bits, share->base.pack_bytes,
&new_row->field_lengths,
share->base.max_field_lengths + 2,
&new_row->blob_lengths,
sizeof(ulong) * share->base.blobs,
&new_row->null_field_lengths, (sizeof(uint) *
(share->base.fields -
share->base.blobs +
EXTRA_LENGTH_FIELDS)),
&info->log_row_parts,
sizeof(*info->log_row_parts) *
(TRANSLOG_INTERNAL_PARTS + 3 +
share->base.fields + 3),
&info->update_field_data,
(share->base.fields * 4 +
share->base.max_field_lengths + 1 + 4),
NullS, 0))
DBUG_RETURN(1);
/* Skip over bytes used to store length of field length for logging */
row->field_lengths+= 2;
new_row->field_lengths+= 2;
/* Reserve some initial space to avoid mallocs during execution */
default_extents= (ELEMENTS_RESERVED_FOR_MAIN_PART + 1 +
(AVERAGE_BLOB_SIZE /
FULL_PAGE_SIZE(share) /
BLOB_SEGMENT_MIN_SIZE));
if (my_init_dynamic_array(PSI_INSTRUMENT_ME, &info->bitmap_blocks,
sizeof(MARIA_BITMAP_BLOCK),
default_extents, 64, flag))
goto err;
info->cur_row.extents_buffer_length= default_extents * ROW_EXTENT_SIZE;
if (!(info->cur_row.extents= my_malloc(PSI_INSTRUMENT_ME,
info->cur_row.extents_buffer_length,
flag)))
goto err;
info->row_base_length= share->base_length;
info->row_flag= share->base.default_row_flag;
/*
We need to reserve 'EXTRA_LENGTH_FIELDS' number of parts in
null_field_lengths to allow splitting of rows in 'find_where_to_split_row'
*/
row->null_field_lengths+= EXTRA_LENGTH_FIELDS;
new_row->null_field_lengths+= EXTRA_LENGTH_FIELDS;
DBUG_RETURN(0);
err:
_ma_end_block_record(info);
DBUG_RETURN(1);
} | O3 | c | ma_init_block_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
xorl %r14d, %r14d
cmpb $0x0, 0x7d9(%rsi)
setne %r14b
shll $0x10, %r14d
orq $0x10, %r14
leaq 0xc8(%rdi), %rdx
movl 0x3f4(%rsi), %ecx
leaq 0xd0(%rdi), %r8
movl 0x3c8(%rsi), %r11d
movl 0x3d4(%rsi), %eax
leal 0x2(%rax), %r9d
addq $0xe0, %rdi
movq %rdi, -0x78(%rbp)
movq %rsi, -0x30(%rbp)
movl 0x3f0(%rsi), %r15d
leal 0x8(%r11), %r10d
leal (%rax,%r11,4), %eax
addl $0x5, %eax
movq %rax, -0x58(%rbp)
subl %r15d, %r11d
leal 0x2(%r15), %r12d
shlq $0x3, %r15
addl $0x3, %r11d
shlq $0x2, %r11
shlq $0x3, %r12
shlq $0x4, %r10
leaq 0xd8(%rbx), %rax
movq %rax, -0x70(%rbp)
leaq 0xa8(%rbx), %rax
movq %rax, -0x68(%rbp)
leaq 0x188(%rbx), %rax
movq %rax, -0x60(%rbp)
leaq 0x190(%rbx), %rax
movq %rax, -0x50(%rbp)
leaq 0x1a0(%rbx), %rax
movq %rax, -0x48(%rbp)
leaq 0x198(%rbx), %rax
movq %rax, -0x40(%rbp)
leaq 0x318(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq 0x3c8(%rbx), %r13
xorl %edi, %edi
movq %r14, %rsi
xorl %eax, %eax
pushq $0x0
pushq $0x0
pushq -0x58(%rbp)
pushq %r13
pushq %r10
pushq -0x38(%rbp)
pushq %r11
pushq -0x40(%rbp)
pushq %r15
pushq -0x48(%rbp)
pushq %r9
pushq -0x50(%rbp)
pushq %rcx
pushq -0x60(%rbp)
pushq %r12
pushq -0x68(%rbp)
pushq %r11
pushq -0x70(%rbp)
pushq %r15
pushq -0x78(%rbp)
callq 0xa1680
addq $0xa0, %rsp
movb $0x1, %r15b
testq %rax, %rax
je 0x48d4e
addq $0x2, 0xd0(%rbx)
addq $0x2, 0x190(%rbx)
movq -0x30(%rbp), %r13
movl 0x7bc(%r13), %ecx
subl 0xc18(%r13), %ecx
addl $-0xc, %ecx
movl $0x100000, %eax # imm = 0x100000
xorl %edx, %edx
divl %ecx
movl %eax, %r12d
shrl $0x7, %r12d
addl $0x5, %r12d
leaq 0x2c0(%rbx), %rsi
subq $0x8, %rsp
xorl %edi, %edi
movl $0x18, %edx
xorl %ecx, %ecx
movl %r12d, %r8d
movl $0x40, %r9d
pushq %r14
callq 0x9691c
addq $0x10, %rsp
testb %al, %al
je 0x48cf8
movq %rbx, %rdi
callq 0x48d60
jmp 0x48d4e
leal (,%r12,8), %esi
subl %r12d, %esi
movq %rsi, 0x118(%rbx)
xorl %edi, %edi
movq %r14, %rdx
callq 0xa6f99
movq %rax, 0x90(%rbx)
testq %rax, %rax
je 0x48cee
movl 0x7c4(%r13), %eax
movq %rax, 0x610(%rbx)
movl 0x418(%r13), %eax
movl %eax, 0x618(%rbx)
addq $0xc, 0xd8(%rbx)
addq $0xc, 0x198(%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_init_block_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
mov rsi, [rdi]
xor r14d, r14d
cmp byte ptr [rsi+7D9h], 0
setnz r14b
shl r14d, 10h
or r14, 10h
lea rdx, [rdi+0C8h]
mov ecx, [rsi+3F4h]
lea r8, [rdi+0D0h]
mov r11d, [rsi+3C8h]
mov eax, [rsi+3D4h]
lea r9d, [rax+2]
add rdi, 0E0h
mov [rbp+var_78], rdi
mov [rbp+var_30], rsi
mov r15d, [rsi+3F0h]
lea r10d, [r11+8]
lea eax, [rax+r11*4]
add eax, 5
mov [rbp+var_58], rax
sub r11d, r15d
lea r12d, [r15+2]
shl r15, 3
add r11d, 3
shl r11, 2
shl r12, 3
shl r10, 4
lea rax, [rbx+0D8h]
mov [rbp+var_70], rax
lea rax, [rbx+0A8h]
mov [rbp+var_68], rax
lea rax, [rbx+188h]
mov [rbp+var_60], rax
lea rax, [rbx+190h]
mov [rbp+var_50], rax
lea rax, [rbx+1A0h]
mov [rbp+var_48], rax
lea rax, [rbx+198h]
mov [rbp+var_40], rax
lea rax, [rbx+318h]
mov [rbp+var_38], rax
lea r13, [rbx+3C8h]
xor edi, edi
mov rsi, r14
xor eax, eax
push 0
push 0
push [rbp+var_58]
push r13
push r10
push [rbp+var_38]
push r11
push [rbp+var_40]
push r15
push [rbp+var_48]
push r9
push [rbp+var_50]
push rcx
push [rbp+var_60]
push r12
push [rbp+var_68]
push r11
push [rbp+var_70]
push r15
push [rbp+var_78]
call my_multi_malloc
add rsp, 0A0h
mov r15b, 1
test rax, rax
jz loc_48D4E
add qword ptr [rbx+0D0h], 2
add qword ptr [rbx+190h], 2
mov r13, [rbp+var_30]
mov ecx, [r13+7BCh]
sub ecx, [r13+0C18h]
add ecx, 0FFFFFFF4h
mov eax, offset xmmword_100000
xor edx, edx
div ecx
mov r12d, eax
shr r12d, 7
add r12d, 5
lea rsi, [rbx+2C0h]
sub rsp, 8
xor edi, edi
mov edx, 18h
xor ecx, ecx
mov r8d, r12d
mov r9d, 40h ; '@'
push r14
call init_dynamic_array2
add rsp, 10h
test al, al
jz short loc_48CF8
loc_48CEE:
mov rdi, rbx
call _ma_end_block_record
jmp short loc_48D4E
loc_48CF8:
lea esi, ds:0[r12*8]
sub esi, r12d
mov [rbx+118h], rsi
xor edi, edi
mov rdx, r14
call my_malloc
mov [rbx+90h], rax
test rax, rax
jz short loc_48CEE
mov eax, [r13+7C4h]
mov [rbx+610h], rax
mov eax, [r13+418h]
mov [rbx+618h], eax
add qword ptr [rbx+0D8h], 0Ch
add qword ptr [rbx+198h], 0Ch
xor r15d, r15d
loc_48D4E:
mov eax, r15d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_init_block_record(long long a1)
{
long long v1; // r14
int v2; // r11d
int v3; // eax
long long v4; // r15
long long v5; // r10
int v6; // r11d
long long v7; // r12
long long v8; // rax
long long v9; // r15
unsigned int v10; // r12d
long long v11; // rsi
long long v12; // rax
long long v14; // [rsp+28h] [rbp-58h]
_DWORD *v15; // [rsp+50h] [rbp-30h]
v1 = ((unsigned __int8)(*(_BYTE *)(*(_QWORD *)a1 + 2009LL) != 0) << 16) | 0x10LL;
v2 = *(_DWORD *)(*(_QWORD *)a1 + 968LL);
v3 = *(_DWORD *)(*(_QWORD *)a1 + 980LL);
v15 = *(_DWORD **)a1;
v4 = *(unsigned int *)(*(_QWORD *)a1 + 1008LL);
v5 = (unsigned int)(v2 + 8);
v14 = (unsigned int)(v3 + 4 * v2 + 5);
v6 = v2 - v4;
v7 = (unsigned int)(v4 + 2);
v9 = 8 * v4;
v8 = my_multi_malloc(
0,
v1,
(int)a1 + 200,
*(_DWORD *)(*(_QWORD *)a1 + 1012LL),
(int)a1 + 208,
v3 + 2,
a1 + 224,
v9,
a1 + 216,
4LL * (unsigned int)(v6 + 3),
a1 + 168,
8 * v7,
a1 + 392,
*(unsigned int *)(*(_QWORD *)a1 + 1012LL),
a1 + 400,
(unsigned int)(v3 + 2),
a1 + 416,
v9,
a1 + 408,
4LL * (unsigned int)(v6 + 3),
a1 + 792,
16 * v5,
a1 + 968,
v14,
0LL,
0LL);
LOBYTE(v9) = 1;
if ( v8 )
{
*(_QWORD *)(a1 + 208) += 2LL;
*(_QWORD *)(a1 + 400) += 2LL;
v10 = (((unsigned int)&xmmword_100000 / (v15[495] - v15[774] - 12)) >> 7) + 5;
if ( (unsigned __int8)init_dynamic_array2(0, (int)a1 + 704, 24, 0, v10, 64, v1)
|| (v11 = 7 * v10, *(_QWORD *)(a1 + 280) = v11,
v12 = my_malloc(0LL, v11, v1),
(*(_QWORD *)(a1 + 144) = v12) == 0LL) )
{
ma_end_block_record(a1);
}
else
{
*(_QWORD *)(a1 + 1552) = (unsigned int)v15[497];
*(_DWORD *)(a1 + 1560) = v15[262];
*(_QWORD *)(a1 + 216) += 12LL;
*(_QWORD *)(a1 + 408) += 12LL;
LODWORD(v9) = 0;
}
}
return (unsigned int)v9;
}
| _ma_init_block_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RSI,qword ptr [RDI]
XOR R14D,R14D
CMP byte ptr [RSI + 0x7d9],0x0
SETNZ R14B
SHL R14D,0x10
OR R14,0x10
LEA RDX,[RDI + 0xc8]
MOV ECX,dword ptr [RSI + 0x3f4]
LEA R8,[RDI + 0xd0]
MOV R11D,dword ptr [RSI + 0x3c8]
MOV EAX,dword ptr [RSI + 0x3d4]
LEA R9D,[RAX + 0x2]
ADD RDI,0xe0
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV R15D,dword ptr [RSI + 0x3f0]
LEA R10D,[R11 + 0x8]
LEA EAX,[RAX + R11*0x4]
ADD EAX,0x5
MOV qword ptr [RBP + -0x58],RAX
SUB R11D,R15D
LEA R12D,[R15 + 0x2]
SHL R15,0x3
ADD R11D,0x3
SHL R11,0x2
SHL R12,0x3
SHL R10,0x4
LEA RAX,[RBX + 0xd8]
MOV qword ptr [RBP + -0x70],RAX
LEA RAX,[RBX + 0xa8]
MOV qword ptr [RBP + -0x68],RAX
LEA RAX,[RBX + 0x188]
MOV qword ptr [RBP + -0x60],RAX
LEA RAX,[RBX + 0x190]
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[RBX + 0x1a0]
MOV qword ptr [RBP + -0x48],RAX
LEA RAX,[RBX + 0x198]
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[RBX + 0x318]
MOV qword ptr [RBP + -0x38],RAX
LEA R13,[RBX + 0x3c8]
XOR EDI,EDI
MOV RSI,R14
XOR EAX,EAX
PUSH 0x0
PUSH 0x0
PUSH qword ptr [RBP + -0x58]
PUSH R13
PUSH R10
PUSH qword ptr [RBP + -0x38]
PUSH R11
PUSH qword ptr [RBP + -0x40]
PUSH R15
PUSH qword ptr [RBP + -0x48]
PUSH R9
PUSH qword ptr [RBP + -0x50]
PUSH RCX
PUSH qword ptr [RBP + -0x60]
PUSH R12
PUSH qword ptr [RBP + -0x68]
PUSH R11
PUSH qword ptr [RBP + -0x70]
PUSH R15
PUSH qword ptr [RBP + -0x78]
CALL 0x001a1680
ADD RSP,0xa0
MOV R15B,0x1
TEST RAX,RAX
JZ 0x00148d4e
ADD qword ptr [RBX + 0xd0],0x2
ADD qword ptr [RBX + 0x190],0x2
MOV R13,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [R13 + 0x7bc]
SUB ECX,dword ptr [R13 + 0xc18]
ADD ECX,-0xc
MOV EAX,0x100000
XOR EDX,EDX
DIV ECX
MOV R12D,EAX
SHR R12D,0x7
ADD R12D,0x5
LEA RSI,[RBX + 0x2c0]
SUB RSP,0x8
XOR EDI,EDI
MOV EDX,0x18
XOR ECX,ECX
MOV R8D,R12D
MOV R9D,0x40
PUSH R14
CALL 0x0019691c
ADD RSP,0x10
TEST AL,AL
JZ 0x00148cf8
LAB_00148cee:
MOV RDI,RBX
CALL 0x00148d60
JMP 0x00148d4e
LAB_00148cf8:
LEA ESI,[R12*0x8]
SUB ESI,R12D
MOV qword ptr [RBX + 0x118],RSI
XOR EDI,EDI
MOV RDX,R14
CALL 0x001a6f99
MOV qword ptr [RBX + 0x90],RAX
TEST RAX,RAX
JZ 0x00148cee
MOV EAX,dword ptr [R13 + 0x7c4]
MOV qword ptr [RBX + 0x610],RAX
MOV EAX,dword ptr [R13 + 0x418]
MOV dword ptr [RBX + 0x618],EAX
ADD qword ptr [RBX + 0xd8],0xc
ADD qword ptr [RBX + 0x198],0xc
XOR R15D,R15D
LAB_00148d4e:
MOV EAX,R15D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong _ma_init_block_record(long *param_1)
{
int iVar1;
uint uVar2;
long lVar3;
char cVar4;
ulong uVar5;
long lVar6;
int iVar7;
ulong uVar8;
long lVar9;
ulong uVar10;
lVar3 = *param_1;
uVar8 = (ulong)(*(char *)(lVar3 + 0x7d9) != '\0') << 0x10 | 0x10;
iVar1 = *(int *)(lVar3 + 0x3c8);
iVar7 = *(int *)(lVar3 + 0x3d4) + 2;
uVar2 = *(uint *)(lVar3 + 0x3f0);
lVar9 = (ulong)uVar2 << 3;
lVar6 = (ulong)((iVar1 - uVar2) + 3) << 2;
lVar6 = my_multi_malloc(0,uVar8,param_1 + 0x19,*(int4 *)(lVar3 + 0x3f4),param_1 + 0x1a,iVar7
,param_1 + 0x1c,lVar9,param_1 + 0x1b,lVar6,param_1 + 0x15,
(ulong)(uVar2 + 2) << 3,param_1 + 0x31,*(int4 *)(lVar3 + 0x3f4),
param_1 + 0x32,iVar7,param_1 + 0x34,lVar9,param_1 + 0x33,lVar6,
param_1 + 99,(ulong)(iVar1 + 8) << 4,param_1 + 0x79,
*(int *)(lVar3 + 0x3d4) + iVar1 * 4 + 5,0,0);
uVar10 = CONCAT71((int7)((ulong)lVar9 >> 8),1);
if (lVar6 != 0) {
param_1[0x1a] = param_1[0x1a] + 2;
param_1[0x32] = param_1[0x32] + 2;
iVar7 = (int)(0x100000 / (ulong)((*(int *)(lVar3 + 0x7bc) - *(int *)(lVar3 + 0xc18)) - 0xc) >> 7
) + 5;
cVar4 = init_dynamic_array2(0,param_1 + 0x58,0x18,0,iVar7,0x40,uVar8);
if (cVar4 == '\0') {
uVar5 = (ulong)(uint)(iVar7 * 7);
param_1[0x23] = uVar5;
lVar6 = my_malloc(0,uVar5,uVar8);
param_1[0x12] = lVar6;
if (lVar6 != 0) {
param_1[0xc2] = (ulong)*(uint *)(lVar3 + 0x7c4);
*(int4 *)(param_1 + 0xc3) = *(int4 *)(lVar3 + 0x418);
param_1[0x1b] = param_1[0x1b] + 0xc;
param_1[0x33] = param_1[0x33] + 0xc;
uVar10 = 0;
goto LAB_00148d4e;
}
}
_ma_end_block_record(param_1);
}
LAB_00148d4e:
return uVar10 & 0xffffffff;
}
| |
28,475 | inline_mysql_cond_init | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_cond_init(
#ifdef HAVE_PSI_COND_INTERFACE
PSI_cond_key key,
#endif
mysql_cond_t *that,
const pthread_condattr_t *attr)
{
#ifdef HAVE_PSI_COND_INTERFACE
that->m_psi= PSI_COND_CALL(init_cond)(key, &that->m_cond);
#else
that->m_psi= NULL;
#endif
return pthread_cond_init(&that->m_cond, attr);
} | O0 | c | inline_mysql_cond_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x1b60ce(%rip), %rax # 0x238378
movq (%rax), %rax
movq 0x60(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x37420
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| inline_mysql_cond_init:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+60h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+30h], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_cond_init
add rsp, 20h
pop rbp
retn
| long long inline_mysql_cond_init(unsigned int a1, long long a2, long long a3)
{
*(_QWORD *)(a2 + 48) = (*((long long ( **)(_QWORD, long long))PSI_server + 12))(a1, a2);
return pthread_cond_init(a2, a3);
}
| inline_mysql_cond_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RAX,[0x338378]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x60]
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00137420
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_cond_init(int4 param_1,pthread_cond_t *param_2,pthread_condattr_t *param_3)
{
longlong lVar1;
lVar1 = (**(code **)(PSI_server + 0x60))(param_1,param_2);
param_2[1].__align = lVar1;
pthread_cond_init(param_2,param_3);
return;
}
| |
28,476 | inline_mysql_rwlock_destroy | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_rwlock_destroy(
mysql_rwlock_t *that)
{
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
{
PSI_RWLOCK_CALL(destroy_rwlock)(that->m_psi);
that->m_psi= NULL;
}
#endif
return rwlock_destroy(&that->m_rwlock);
} | O0 | c | inline_mysql_rwlock_destroy:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xfe8ed
leaq 0x1c17ee(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x8(%rbp), %rdi
callq 0xf9f40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| inline_mysql_rwlock_destroy_1:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+90h], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_FE8ED
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+58h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+90h]
call rax
mov rax, [rbp+var_8]
mov qword ptr [rax+90h], 0
loc_FE8ED:
mov rdi, [rbp+var_8]
call my_rw_destroy
add rsp, 10h
pop rbp
retn
| long long inline_mysql_rwlock_destroy_1(long long a1)
{
if ( *(_QWORD *)(a1 + 144) )
{
((void ( *)(_QWORD))PSI_server[11])(*(_QWORD *)(a1 + 144));
*(_QWORD *)(a1 + 144) = 0LL;
}
return my_rw_destroy(a1);
}
| inline_mysql_rwlock_destroy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x90],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001fe8ed
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x90]
CALL RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x90],0x0
LAB_001fe8ed:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001f9f40
ADD RSP,0x10
POP RBP
RET
|
void inline_mysql_rwlock_destroy(long param_1)
{
if (*(long *)(param_1 + 0x90) != 0) {
(**(code **)(PSI_server + 0x58))(*(int8 *)(param_1 + 0x90));
*(int8 *)(param_1 + 0x90) = 0;
}
my_rw_destroy(param_1);
return;
}
| |
28,477 | my_hash_next | eloqsql/mysys/hash.c | uchar* my_hash_next(const HASH *hash, const uchar *key, size_t length,
HASH_SEARCH_STATE *current_record)
{
HASH_LINK *pos;
uint idx;
if (*current_record != NO_RECORD)
{
HASH_LINK *data=dynamic_element(&hash->array,0,HASH_LINK*);
for (idx=data[*current_record].next; idx != NO_RECORD ; idx=pos->next)
{
pos=data+idx;
if (!hashcmp(hash,pos,key,length))
{
*current_record= idx;
return pos->data;
}
}
*current_record= NO_RECORD;
}
return 0;
} | O3 | c | my_hash_next:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movl (%rcx), %ebx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %rbx
je 0x29dc9
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, -0x30(%rbp)
movq 0x28(%rdi), %r13
shlq $0x4, %rbx
addq %r13, %rbx
movl (%rbx), %r14d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x29dbf
movq %r14, %rax
shlq $0x4, %rax
leaq (%rax,%r13), %rbx
movq 0x8(%r13,%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq -0x38(%rbp), %rcx
callq 0x29cc1
testl %eax, %eax
jne 0x29d82
movq -0x30(%rbp), %rax
movl %r14d, (%rax)
movq 0x8(%rbx), %rax
jmp 0x29dcb
movq -0x30(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_hash_next:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_38], rdx
mov ebx, [rcx]
mov eax, 0FFFFFFFFh
cmp rbx, rax
jz short loc_29DC9
mov r15, rsi
mov r12, rdi
mov [rbp+var_30], rcx
mov r13, [rdi+28h]
shl rbx, 4
add rbx, r13
loc_29D82:
mov r14d, [rbx]
mov eax, 0FFFFFFFFh
cmp r14, rax
jz short loc_29DBF
mov rax, r14
shl rax, 4
lea rbx, [rax+r13]
mov rsi, [r13+rax+8]
mov rdi, r12
mov rdx, r15
mov rcx, [rbp+var_38]
call hashcmp
test eax, eax
jnz short loc_29D82
mov rax, [rbp+var_30]
mov [rax], r14d
mov rax, [rbx+8]
jmp short loc_29DCB
loc_29DBF:
mov rax, [rbp+var_30]
mov dword ptr [rax], 0FFFFFFFFh
loc_29DC9:
xor eax, eax
loc_29DCB:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_hash_next(_QWORD *a1, long long a2, long long a3, _DWORD *a4)
{
long long v4; // rbx
long long v5; // r13
unsigned int *v6; // rbx
long long v7; // r14
v4 = (unsigned int)*a4;
if ( v4 != 0xFFFFFFFFLL )
{
v5 = a1[5];
v6 = (unsigned int *)(v5 + 16 * v4);
while ( 1 )
{
v7 = *v6;
if ( v7 == 0xFFFFFFFFLL )
break;
v6 = (unsigned int *)(16 * v7 + v5);
if ( !hashcmp(a1, *((_QWORD *)v6 + 1), a2, a3) )
{
*a4 = v7;
return *((_QWORD *)v6 + 1);
}
}
*a4 = -1;
}
return 0LL;
}
| my_hash_next:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x38],RDX
MOV EBX,dword ptr [RCX]
MOV EAX,0xffffffff
CMP RBX,RAX
JZ 0x00129dc9
MOV R15,RSI
MOV R12,RDI
MOV qword ptr [RBP + -0x30],RCX
MOV R13,qword ptr [RDI + 0x28]
SHL RBX,0x4
ADD RBX,R13
LAB_00129d82:
MOV R14D,dword ptr [RBX]
MOV EAX,0xffffffff
CMP R14,RAX
JZ 0x00129dbf
MOV RAX,R14
SHL RAX,0x4
LEA RBX,[RAX + R13*0x1]
MOV RSI,qword ptr [R13 + RAX*0x1 + 0x8]
MOV RDI,R12
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x38]
CALL 0x00129cc1
TEST EAX,EAX
JNZ 0x00129d82
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],R14D
MOV RAX,qword ptr [RBX + 0x8]
JMP 0x00129dcb
LAB_00129dbf:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0xffffffff
LAB_00129dc9:
XOR EAX,EAX
LAB_00129dcb:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 my_hash_next(long param_1,int8 param_2,int8 param_3,uint *param_4)
{
uint uVar1;
long lVar2;
int iVar3;
long lVar4;
int8 uVar5;
uint *puVar6;
if ((ulong)*param_4 == 0xffffffff) {
LAB_00129dc9:
uVar5 = 0;
}
else {
lVar2 = *(long *)(param_1 + 0x28);
puVar6 = (uint *)((ulong)*param_4 * 0x10 + lVar2);
do {
uVar1 = *puVar6;
if ((ulong)uVar1 == 0xffffffff) {
*param_4 = 0xffffffff;
goto LAB_00129dc9;
}
lVar4 = (ulong)uVar1 * 0x10;
puVar6 = (uint *)(lVar4 + lVar2);
iVar3 = hashcmp(param_1,*(int8 *)(lVar2 + 8 + lVar4),param_2,param_3);
} while (iVar3 != 0);
*param_4 = uVar1;
uVar5 = *(int8 *)(puVar6 + 2);
}
return uVar5;
}
| |
28,478 | glfwGetJoystickName | untodesu[P]riteg/build_O3/_deps/glfw-src/src/input.c | GLFWAPI const char* glfwGetJoystickName(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
return NULL;
}
js = _glfw.joysticks + jid;
if (!js->present)
return NULL;
if (!_glfwPlatformPollJoystick(js, _GLFW_POLL_PRESENCE))
return NULL;
return js->name;
} | O3 | c | glfwGetJoystickName:
pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x1a7fc
cmpl $0x10, %edi
jae 0x1a81b
leaq 0x8de94(%rip), %rax # 0xa8638
cmpl $0x0, (%rax)
je 0x1a7dd
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x408(%rax,%rcx)
je 0x1a7ef
leaq (%rax,%rcx), %r14
addq $0x408, %r14 # imm = 0x408
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x28ef5
testl %eax, %eax
je 0x1a7f1
movq 0x38(%r14), %rbx
jmp 0x1a7f1
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x18e91
jmp 0x1a7f1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6897d(%rip), %rdi # 0x83180
leaq 0x684aa(%rip), %rsi # 0x82cb4
leaq 0x68a65(%rip), %rcx # 0x83276
movl $0x404, %edx # imm = 0x404
callq 0xc540
leaq 0x68992(%rip), %rdi # 0x831b4
leaq 0x6848b(%rip), %rsi # 0x82cb4
leaq 0x68a46(%rip), %rcx # 0x83276
movl $0x405, %edx # imm = 0x405
callq 0xc540
| glfwGetJoystickName:
push r14
push rbx
push rax
test edi, edi
js short loc_1A7FC
cmp edi, 10h
jnb short loc_1A81B
lea rax, _glfw
cmp dword ptr [rax], 0
jz short loc_1A7DD
mov ecx, edi
imul rcx, 1FA0h
cmp dword ptr [rax+rcx+408h], 0
jz short loc_1A7EF
lea r14, [rax+rcx]
add r14, 408h
xor ebx, ebx
mov rdi, r14
xor esi, esi
call _glfwPlatformPollJoystick
test eax, eax
jz short loc_1A7F1
mov rbx, [r14+38h]
jmp short loc_1A7F1
loc_1A7DD:
xor ebx, ebx
mov edi, offset loc_10001
xor esi, esi
xor eax, eax
call _glfwInputError
jmp short loc_1A7F1
loc_1A7EF:
xor ebx, ebx
loc_1A7F1:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
loc_1A7FC:
lea rdi, aJidGlfwJoystic; "jid >= GLFW_JOYSTICK_1"
lea rsi, aWorkspaceLlm4b_12; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aConstCharGlfwg; "const char *glfwGetJoystickName(int)"
mov edx, 404h
call ___assert_fail
loc_1A81B:
lea rdi, aJidGlfwJoystic_0; "jid <= GLFW_JOYSTICK_LAST"
lea rsi, aWorkspaceLlm4b_12; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aConstCharGlfwg; "const char *glfwGetJoystickName(int)"
mov edx, 405h
call ___assert_fail
| long long glfwGetJoystickName(int a1)
{
long long v1; // rcx
_DWORD *v2; // r14
long long v3; // rbx
if ( a1 < 0 )
__assert_fail(
"jid >= GLFW_JOYSTICK_1",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O3/_deps/glfw-src/src/input.c",
1028LL,
"const char *glfwGetJoystickName(int)");
if ( (unsigned int)a1 >= 0x10 )
__assert_fail(
"jid <= GLFW_JOYSTICK_LAST",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O3/_deps/glfw-src/src/input.c",
1029LL,
"const char *glfwGetJoystickName(int)");
if ( glfw[0] )
{
v1 = 2024LL * (unsigned int)a1;
if ( glfw[v1 + 258] )
{
v2 = &glfw[v1 + 258];
v3 = 0LL;
if ( (unsigned int)glfwPlatformPollJoystick(v2, 0LL) )
return *((_QWORD *)v2 + 7);
}
else
{
return 0LL;
}
}
else
{
v3 = 0LL;
glfwInputError((unsigned int)&loc_10001, 0LL);
}
return v3;
}
| glfwGetJoystickName:
PUSH R14
PUSH RBX
PUSH RAX
TEST EDI,EDI
JS 0x0011a7fc
CMP EDI,0x10
JNC 0x0011a81b
LEA RAX,[0x1a8638]
CMP dword ptr [RAX],0x0
JZ 0x0011a7dd
MOV ECX,EDI
IMUL RCX,RCX,0x1fa0
CMP dword ptr [RAX + RCX*0x1 + 0x408],0x0
JZ 0x0011a7ef
LEA R14,[RAX + RCX*0x1]
ADD R14,0x408
XOR EBX,EBX
MOV RDI,R14
XOR ESI,ESI
CALL 0x00128ef5
TEST EAX,EAX
JZ 0x0011a7f1
MOV RBX,qword ptr [R14 + 0x38]
JMP 0x0011a7f1
LAB_0011a7dd:
XOR EBX,EBX
MOV EDI,0x10001
XOR ESI,ESI
XOR EAX,EAX
CALL 0x00118e91
JMP 0x0011a7f1
LAB_0011a7ef:
XOR EBX,EBX
LAB_0011a7f1:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0011a7fc:
LEA RDI,[0x183180]
LEA RSI,[0x182cb4]
LEA RCX,[0x183276]
MOV EDX,0x404
CALL 0x0010c540
LAB_0011a81b:
LEA RDI,[0x1831b4]
LEA RSI,[0x182cb4]
LEA RCX,[0x183276]
MOV EDX,0x405
CALL 0x0010c540
|
int8 glfwGetJoystickName(uint param_1)
{
int iVar1;
ulong uVar2;
int8 uVar3;
if ((int)param_1 < 0) {
/* WARNING: Subroutine does not return */
__assert_fail("jid >= GLFW_JOYSTICK_1",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O3/_deps/glfw-src/src/input.c"
,0x404,"const char *glfwGetJoystickName(int)");
}
if (param_1 < 0x10) {
if (_glfw == 0) {
uVar3 = 0;
_glfwInputError(0x10001,0);
}
else {
uVar2 = (ulong)param_1;
if ((&DAT_001a8a40)[uVar2 * 0x7e8] == 0) {
uVar3 = 0;
}
else {
uVar3 = 0;
iVar1 = _glfwPlatformPollJoystick(&DAT_001a8a40 + uVar2 * 0x7e8,0);
if (iVar1 != 0) {
uVar3 = (&DAT_001a8a78)[uVar2 * 0x3f4];
}
}
}
return uVar3;
}
/* WARNING: Subroutine does not return */
__assert_fail("jid <= GLFW_JOYSTICK_LAST",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O3/_deps/glfw-src/src/input.c"
,0x405,"const char *glfwGetJoystickName(int)");
}
| |
28,479 | qdevtools::BuiltinEditor::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) | HuaiminNotSleepYet[P]QDevTools/build_O2/QDevTools_autogen/EWIEGA46WW/moc_qdevtools.cpp | void qdevtools::BuiltinEditor::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
auto *_t = static_cast<BuiltinEditor *>(_o);
(void)_t;
switch (_id) {
case 0: _t->valueChanged(); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
{
using _t = void (BuiltinEditor::*)();
if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&BuiltinEditor::valueChanged)) {
*result = 0;
return;
}
}
}
(void)_a;
} | O2 | cpp | qdevtools::BuiltinEditor::qt_static_metacall(QObject*, QMetaObject::Call, int, void**):
cmpl $0x5, %esi
je 0x1026c
testl %esi, %esi
jne 0x1026b
testl %edx, %edx
je 0x1028a
retq
movq 0x8(%rcx), %rax
movq (%rax), %rdx
cmpq 0x1ccb6(%rip), %rdx # 0x2cf30
jne 0x1026b
cmpq $0x0, 0x8(%rax)
jne 0x1026b
movq (%rcx), %rax
andl $0x0, (%rax)
retq
jmp 0x10290
nop
| _ZN9qdevtools13BuiltinEditor18qt_static_metacallEP7QObjectN11QMetaObject4CallEiPPv:
cmp esi, 5
jz short loc_1026C
test esi, esi
jnz short locret_1026B
test edx, edx
jz short loc_1028A
locret_1026B:
retn
loc_1026C:
mov rax, [rcx+8]
mov rdx, [rax]
cmp rdx, cs:_ZN9qdevtools13BuiltinEditor12valueChangedEv_ptr
jnz short locret_1026B
cmp qword ptr [rax+8], 0
jnz short locret_1026B
mov rax, [rcx]
and dword ptr [rax], 0
retn
loc_1028A:
jmp _ZN9qdevtools13BuiltinEditor12valueChangedEv; qdevtools::BuiltinEditor::valueChanged(void)
| void qdevtools::BuiltinEditor::qt_static_metacall(qdevtools::BuiltinEditor *a1, int a2, int a3, long long a4)
{
long long v4; // rax
if ( a2 == 5 )
{
v4 = *(_QWORD *)(a4 + 8);
if ( *(long long ( **)(qdevtools::BuiltinEditor *__hidden))v4 == qdevtools::BuiltinEditor::valueChanged
&& !*(_QWORD *)(v4 + 8) )
{
**(_DWORD **)a4 = 0;
}
}
else if ( !a2 && !a3 )
{
qdevtools::BuiltinEditor::valueChanged(a1);
}
}
| qt_static_metacall:
CMP ESI,0x5
JZ 0x0011026c
TEST ESI,ESI
JNZ 0x0011026b
TEST EDX,EDX
JZ 0x0011028a
LAB_0011026b:
RET
LAB_0011026c:
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,qword ptr [RAX]
CMP RDX,qword ptr [0x0012cf30]
JNZ 0x0011026b
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x0011026b
MOV RAX,qword ptr [RCX]
AND dword ptr [RAX],0x0
RET
LAB_0011028a:
JMP 0x00110290
|
/* qdevtools::BuiltinEditor::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) */
void qdevtools::BuiltinEditor::qt_static_metacall
(BuiltinEditor *param_1,int param_2,int param_3,int8 *param_4)
{
if (param_2 == 5) {
if ((*(int **)param_4[1] == PTR_valueChanged_0012cf30) && (((long *)param_4[1])[1] == 0))
{
*(int4 *)*param_4 = 0;
return;
}
}
else if ((param_2 == 0) && (param_3 == 0)) {
valueChanged(param_1);
return;
}
return;
}
| |
28,480 | IMatrixCollector::~IMatrixCollector() | monkey531[P]llama/examples/imatrix/imatrix.cpp | IMatrixCollector() = default; | O1 | cpp | IMatrixCollector::~IMatrixCollector():
pushq %rbx
movq %rdi, %rbx
movq 0x1368(%rdi), %rdi
testq %rdi, %rdi
je 0x229f1
movq 0x1378(%rbx), %rsi
subq %rdi, %rsi
callq 0x1b910
movq 0x1350(%rbx), %rdi
testq %rdi, %rdi
je 0x22a0c
movq 0x1360(%rbx), %rsi
subq %rdi, %rsi
callq 0x1b910
leaq 0x38(%rbx), %rdi
callq 0x2482c
movq %rbx, %rdi
popq %rbx
jmp 0x24eae
| _ZN16IMatrixCollectorD2Ev:
push rbx
mov rbx, rdi
mov rdi, [rdi+1368h]; void *
test rdi, rdi
jz short loc_229F1
mov rsi, [rbx+1378h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_229F1:
mov rdi, [rbx+1350h]; void *
test rdi, rdi
jz short loc_22A0C
mov rsi, [rbx+1360h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_22A0C:
lea rdi, [rbx+38h]; this
call _ZN13common_paramsD2Ev; common_params::~common_params()
mov rdi, rbx
pop rbx
jmp _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_5StatsESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,Stats>,std::allocator<std::pair<std::string const,Stats>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable()
| void IMatrixCollector::~IMatrixCollector(_QWORD *a1)
{
void *v2; // rdi
void *v3; // rdi
v2 = (void *)a1[621];
if ( v2 )
operator delete(v2, a1[623] - (_QWORD)v2);
v3 = (void *)a1[618];
if ( v3 )
operator delete(v3, a1[620] - (_QWORD)v3);
common_params::~common_params((common_params *)(a1 + 7));
std::_Hashtable<std::string,std::pair<std::string const,Stats>,std::allocator<std::pair<std::string const,Stats>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable(a1);
}
| ~IMatrixCollector:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x1368]
TEST RDI,RDI
JZ 0x001229f1
MOV RSI,qword ptr [RBX + 0x1378]
SUB RSI,RDI
CALL 0x0011b910
LAB_001229f1:
MOV RDI,qword ptr [RBX + 0x1350]
TEST RDI,RDI
JZ 0x00122a0c
MOV RSI,qword ptr [RBX + 0x1360]
SUB RSI,RDI
CALL 0x0011b910
LAB_00122a0c:
LEA RDI,[RBX + 0x38]
CALL 0x0012482c
MOV RDI,RBX
POP RBX
JMP 0x00124eae
|
/* IMatrixCollector::~IMatrixCollector() */
void __thiscall IMatrixCollector::~IMatrixCollector(IMatrixCollector *this)
{
void *pvVar1;
pvVar1 = *(void **)(this + 0x1368);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x1378) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x1350);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x1360) - (long)pvVar1);
}
common_params::~common_params((common_params *)(this + 0x38));
std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,Stats>,std::allocator<std::pair<std::__cxx11::string_const,Stats>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::~_Hashtable((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,Stats>,std::allocator<std::pair<std::__cxx11::string_const,Stats>>,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>>
*)this);
return;
}
| |
28,481 | R3D_GetLightOuterCutOff | r3d/src/r3d_lighting.c | float R3D_GetLightOuterCutOff(R3D_Light id)
{
r3d_get_and_check_light(light, id, 0);
return acosf(light->outerCutOff) * RAD2DEG;
} | O3 | c | R3D_GetLightOuterCutOff:
pushq %rbp
movq %rsp, %rbp
movl %edi, %edx
testl %edi, %edi
je 0xbe4b6
leaq 0xf1774(%rip), %rax # 0x1afbf0
cmpl %edx, 0x168(%rax)
jbe 0xbe4b6
movq 0x128(%rax), %rsi
leal -0x1(%rdx), %ecx
cmpb $0x1, (%rsi,%rcx)
jne 0xbe4b6
movq 0x108(%rax), %rsi
cmpq %rcx, 0x110(%rax)
setbe %dil
testq %rsi, %rsi
sete %r8b
orb %dil, %r8b
cmpb $0x1, %r8b
jne 0xbe4ce
leaq 0x53920(%rip), %rsi # 0x111ddd
movl $0x5, %edi
xorl %eax, %eax
callq 0xa9b51
xorps %xmm0, %xmm0
popq %rbp
retq
imulq 0x120(%rax), %rcx
movss 0xac(%rsi,%rcx), %xmm0
callq 0x83e0
mulss 0x23b58(%rip), %xmm0 # 0xe2044
jmp 0xbe4cc
| R3D_GetLightOuterCutOff:
push rbp
mov rbp, rsp
mov edx, edi
test edi, edi
jz short loc_BE4B6
lea rax, R3D
cmp [rax+168h], edx
jbe short loc_BE4B6
mov rsi, [rax+128h]
lea ecx, [rdx-1]
cmp byte ptr [rsi+rcx], 1
jnz short loc_BE4B6
mov rsi, [rax+108h]
cmp [rax+110h], rcx
setbe dil
test rsi, rsi
setz r8b
or r8b, dil
cmp r8b, 1
jnz short loc_BE4CE
loc_BE4B6:
lea rsi, aLightIdIIsNotV; "Light [ID %i] is not valid"
mov edi, 5
xor eax, eax
call TraceLog
xorps xmm0, xmm0
loc_BE4CC:
pop rbp
retn
loc_BE4CE:
imul rcx, [rax+120h]
movss xmm0, dword ptr [rsi+rcx+0ACh]
call _acosf
mulss xmm0, cs:dword_E2044
jmp short loc_BE4CC
| float R3D_GetLightOuterCutOff(long long a1)
{
int v1; // edx
unsigned long long v2; // rcx
long long v3; // rsi
v1 = a1;
if ( (_DWORD)a1 )
{
if ( *((_DWORD *)&R3D + 90) > (unsigned int)a1 )
{
v2 = (unsigned int)(a1 - 1);
if ( *(_BYTE *)(*((_QWORD *)&R3D + 37) + v2) == 1 )
{
v3 = *((_QWORD *)&R3D + 33);
LOBYTE(a1) = *((_QWORD *)&R3D + 34) <= v2;
if ( ((unsigned __int8)a1 | (v3 == 0)) != 1 )
return acosf(a1, v3) * 57.295776;
}
}
}
TraceLog(5, (long long)"Light [ID %i] is not valid", v1);
return 0.0;
}
| R3D_GetLightOuterCutOff:
PUSH RBP
MOV RBP,RSP
MOV EDX,EDI
TEST EDI,EDI
JZ 0x001be4b6
LEA RAX,[0x2afbf0]
CMP dword ptr [RAX + 0x168],EDX
JBE 0x001be4b6
MOV RSI,qword ptr [RAX + 0x128]
LEA ECX,[RDX + -0x1]
CMP byte ptr [RSI + RCX*0x1],0x1
JNZ 0x001be4b6
MOV RSI,qword ptr [RAX + 0x108]
CMP qword ptr [RAX + 0x110],RCX
SETBE DIL
TEST RSI,RSI
SETZ R8B
OR R8B,DIL
CMP R8B,0x1
JNZ 0x001be4ce
LAB_001be4b6:
LEA RSI,[0x211ddd]
MOV EDI,0x5
XOR EAX,EAX
CALL 0x001a9b51
XORPS XMM0,XMM0
LAB_001be4cc:
POP RBP
RET
LAB_001be4ce:
IMUL RCX,qword ptr [RAX + 0x120]
MOVSS XMM0,dword ptr [RSI + RCX*0x1 + 0xac]
CALL 0x001083e0
MULSS XMM0,dword ptr [0x001e2044]
JMP 0x001be4cc
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float R3D_GetLightOuterCutOff(uint param_1)
{
ulong uVar1;
float fVar2;
if ((((param_1 != 0) && (param_1 < DAT_002afd58)) &&
(uVar1 = (ulong)(param_1 - 1), *(char *)(DAT_002afd18 + uVar1) == '\x01')) &&
(DAT_002afcf8 != 0 && uVar1 < DAT_002afd00)) {
fVar2 = acosf(*(float *)(DAT_002afcf8 + 0xac + uVar1 * DAT_002afd10));
return fVar2 * _DAT_001e2044;
}
TraceLog(5,"Light [ID %i] is not valid");
return 0.0;
}
| |
28,482 | lunasvg::SVGRootElement::SVGRootElement(lunasvg::Document*) | dmazzella[P]pylunasvg/lunasvg/source/svgelement.cpp | SVGRootElement::SVGRootElement(Document* document)
: SVGSVGElement(document)
{
} | O1 | cpp | lunasvg::SVGRootElement::SVGRootElement(lunasvg::Document*):
pushq %rbx
movq %rdi, %rbx
callq 0x105f0
leaq 0x47f80(%rip), %rax # 0x589f8
movq %rax, (%rbx)
leaq 0x138(%rbx), %rax
movl $0x0, 0x138(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x140(%rbx)
movq %rax, 0x148(%rbx)
movq %rax, 0x150(%rbx)
movq %rcx, 0x158(%rbx)
movabsq $-0x407fffff40800000, %rax # imm = 0xBF800000BF800000
movq %rax, 0x160(%rbx)
popq %rbx
retq
nop
| _ZN7lunasvg14SVGRootElementC2EPNS_8DocumentE:
push rbx
mov rbx, rdi
call _ZN7lunasvg13SVGSVGElementC2EPNS_8DocumentE; lunasvg::SVGSVGElement::SVGSVGElement(lunasvg::Document *)
lea rax, off_589F8
mov [rbx], rax
lea rax, [rbx+138h]
mov dword ptr [rbx+138h], 0
xor ecx, ecx
mov [rbx+140h], rcx
mov [rbx+148h], rax
mov [rbx+150h], rax
mov [rbx+158h], rcx
mov rax, 0BF800000BF800000h
mov [rbx+160h], rax
pop rbx
retn
| long long lunasvg::SVGRootElement::SVGRootElement(lunasvg::SVGRootElement *this, lunasvg::Document *a2)
{
long long result; // rax
lunasvg::SVGSVGElement::SVGSVGElement(this, a2);
*(_QWORD *)this = off_589F8;
*((_DWORD *)this + 78) = 0;
*((_QWORD *)this + 40) = 0LL;
*((_QWORD *)this + 41) = (char *)this + 312;
*((_QWORD *)this + 42) = (char *)this + 312;
*((_QWORD *)this + 43) = 0LL;
result = 0xBF800000BF800000LL;
*((_QWORD *)this + 44) = 0xBF800000BF800000LL;
return result;
}
| SVGRootElement:
PUSH RBX
MOV RBX,RDI
CALL 0x001105f0
LEA RAX,[0x1589f8]
MOV qword ptr [RBX],RAX
LEA RAX,[RBX + 0x138]
MOV dword ptr [RBX + 0x138],0x0
XOR ECX,ECX
MOV qword ptr [RBX + 0x140],RCX
MOV qword ptr [RBX + 0x148],RAX
MOV qword ptr [RBX + 0x150],RAX
MOV qword ptr [RBX + 0x158],RCX
MOV RAX,-0x407fffff40800000
MOV qword ptr [RBX + 0x160],RAX
POP RBX
RET
|
/* lunasvg::SVGRootElement::SVGRootElement(lunasvg::Document*) */
void __thiscall lunasvg::SVGRootElement::SVGRootElement(SVGRootElement *this,Document *param_1)
{
SVGSVGElement::SVGSVGElement((SVGSVGElement *)this,param_1);
*(int ***)this = &PTR__SVGRootElement_001589f8;
*(int4 *)(this + 0x138) = 0;
*(int8 *)(this + 0x140) = 0;
*(SVGRootElement **)(this + 0x148) = this + 0x138;
*(SVGRootElement **)(this + 0x150) = this + 0x138;
*(int8 *)(this + 0x158) = 0;
*(int8 *)(this + 0x160) = 0xbf800000bf800000;
return;
}
| |
28,483 | reset_events_statements_history_long() | eloqsql/storage/perfschema/pfs_events_statements.cc | void reset_events_statements_history_long(void)
{
PFS_atomic::store_u32(&events_statements_history_long_index.m_u32, 0);
events_statements_history_long_full= false;
PFS_events_statements *pfs= events_statements_history_long_array;
PFS_events_statements *pfs_last= pfs + events_statements_history_long_size;
for ( ; pfs < pfs_last; pfs++)
pfs->m_event.m_class= nullptr;
} | O0 | cpp | reset_events_statements_history_long():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3b8871(%rip), %rdi # 0x40dbc0
xorl %esi, %esi
callq 0x36d20
movb $0x0, 0x3b8823(%rip) # 0x40db80
movq 0x3b889c(%rip), %rax # 0x40dc00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
imulq $0x590, 0x3b8709(%rip), %rcx # imm = 0x590
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x553a4
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
addq $0x590, %rax # imm = 0x590
movq %rax, -0x8(%rbp)
jmp 0x5537e
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _Z36reset_events_statements_history_longv:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rdi, events_statements_history_long_index; this
xor esi, esi; unsigned int *
call _ZN10PFS_atomic9store_u32EPjj; PFS_atomic::store_u32(uint *,uint)
mov cs:events_statements_history_long_full, 0
mov rax, cs:events_statements_history_long_array
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
imul rcx, cs:events_statements_history_long_size, 590h
add rax, rcx
mov [rbp+var_10], rax
loc_5537E:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_553A4
mov rax, [rbp+var_8]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_8]
add rax, 590h
mov [rbp+var_8], rax
jmp short loc_5537E
loc_553A4:
add rsp, 10h
pop rbp
retn
| unsigned long long reset_events_statements_history_long(void)
{
unsigned long long result; // rax
unsigned long long v1; // [rsp+0h] [rbp-10h]
unsigned long long v2; // [rsp+8h] [rbp-8h]
PFS_atomic::store_u32((PFS_atomic *)&events_statements_history_long_index, 0LL);
events_statements_history_long_full = 0;
v2 = events_statements_history_long_array;
v1 = 1424 * events_statements_history_long_size + events_statements_history_long_array;
while ( 1 )
{
result = v2;
if ( v2 >= v1 )
break;
*(_QWORD *)(v2 + 48) = 0LL;
v2 += 1424LL;
}
return result;
}
| reset_events_statements_history_long:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RDI,[0x50dbc0]
XOR ESI,ESI
CALL 0x00136d20
MOV byte ptr [0x0050db80],0x0
MOV RAX,qword ptr [0x0050dc00]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
IMUL RCX,qword ptr [0x0050da80],0x590
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
LAB_0015537e:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x001553a4
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x590
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0015537e
LAB_001553a4:
ADD RSP,0x10
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* reset_events_statements_history_long() */
void reset_events_statements_history_long(void)
{
ulong uVar1;
ulong local_10;
PFS_atomic::store_u32((uint *)events_statements_history_long_index,0);
events_statements_history_long_full = 0;
uVar1 = events_statements_history_long_array + events_statements_history_long_size * 0x590;
for (local_10 = events_statements_history_long_array; local_10 < uVar1;
local_10 = local_10 + 0x590) {
*(int8 *)(local_10 + 0x30) = 0;
}
return;
}
| |
28,484 | testing::UnitTest::Run() | seiftnesse[P]memoryallocator/build_O0/_deps/googletest-src/googletest/src/gtest.cc | int UnitTest::Run() {
const bool in_death_test_child_process =
GTEST_FLAG_GET(internal_run_death_test).length() > 0;
// Google Test implements this protocol for catching that a test
// program exits before returning control to Google Test:
//
// 1. Upon start, Google Test creates a file whose absolute path
// is specified by the environment variable
// TEST_PREMATURE_EXIT_FILE.
// 2. When Google Test has finished its work, it deletes the file.
//
// This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
// running a Google-Test-based test program and check the existence
// of the file at the end of the test execution to see if it has
// exited prematurely.
// If we are in the child process of a death test, don't
// create/delete the premature exit file, as doing so is unnecessary
// and will confuse the parent process. Otherwise, create/delete
// the file upon entering/leaving this function. If the program
// somehow exits before this function has a chance to return, the
// premature-exit file will be left undeleted, causing a test runner
// that understands the premature-exit-file protocol to report the
// test as having failed.
const internal::ScopedPrematureExitFile premature_exit_file(
in_death_test_child_process
? nullptr
: internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
// Captures the value of GTEST_FLAG(catch_exceptions). This value will be
// used for the duration of the program.
impl()->set_catch_exceptions(GTEST_FLAG_GET(catch_exceptions));
#if GTEST_OS_WINDOWS
// Either the user wants Google Test to catch exceptions thrown by the
// tests or this is executing in the context of death test child
// process. In either case the user does not want to see pop-up dialogs
// about crashes - they are expected.
if (impl()->catch_exceptions() || in_death_test_child_process) {
#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
// SetErrorMode doesn't exist on CE.
SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
#endif // !GTEST_OS_WINDOWS_MOBILE
#if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
// Death test children can be terminated with _abort(). On Windows,
// _abort() can show a dialog with a warning message. This forces the
// abort message to go to stderr instead.
_set_error_mode(_OUT_TO_STDERR);
#endif
#if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
// In the debug version, Visual Studio pops up a separate dialog
// offering a choice to debug the aborted program. We need to suppress
// this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
// executed. Google Test will notify the user of any unexpected
// failure via stderr.
if (!GTEST_FLAG_GET(break_on_failure))
_set_abort_behavior(
0x0, // Clear the following flags:
_WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump.
// In debug mode, the Windows CRT can crash with an assertion over invalid
// input (e.g. passing an invalid file descriptor). The default handling
// for these assertions is to pop up a dialog and wait for user input.
// Instead ask the CRT to dump such assertions to stderr non-interactively.
if (!IsDebuggerPresent()) {
(void)_CrtSetReportMode(_CRT_ASSERT,
_CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
(void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
}
#endif
}
#endif // GTEST_OS_WINDOWS
return internal::HandleExceptionsInMethodIfSupported(
impl(), &internal::UnitTestImpl::RunAllTests,
"auxiliary test code (environments or event listeners)")
? 0
: 1;
} | O0 | cpp | testing::UnitTest::Run():
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x41648b2(%rip), %rdi # 0x41a7fb0
callq 0xbb50
cmpq $0x0, %rax
seta %al
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x4371d
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x4372d
leaq 0x31a42(%rip), %rdi # 0x75166
callq 0x4c490
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x51e10
movq -0x58(%rbp), %rdi
callq 0x4d030
movq %rax, -0x68(%rbp)
jmp 0x43749
movq -0x68(%rbp), %rdi
movzbl 0x41648c1(%rip), %esi # 0x41a8015
andl $0x1, %esi
callq 0x51f10
jmp 0x4375e
movq -0x58(%rbp), %rdi
callq 0x4d030
movq %rax, -0x70(%rbp)
jmp 0x4376d
movq -0x70(%rbp), %rdi
leaq 0x78(%rip), %rax # 0x437f0
movq %rax, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq 0x319ec(%rip), %rcx # 0x7517f
callq 0x51f40
movb %al, -0x71(%rbp)
jmp 0x4379d
movb -0x71(%rbp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x521d0
movl -0x78(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x521d0
movq -0x38(%rbp), %rdi
callq 0xbcd0
nopw %cs:(%rax,%rax)
| _ZN7testing8UnitTest3RunEv:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_58], rax
lea rdi, _ZN7testing35FLAGS_gtest_internal_run_death_testB5cxx11E; testing::FLAGS_gtest_internal_run_death_test
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
cmp rax, 0
setnbe al
and al, 1
mov [rbp+var_9], al
test [rbp+var_9], 1
jz short loc_4371D
xor eax, eax
mov [rbp+var_60], rax
jmp short loc_4372D
loc_4371D:
lea rdi, aTestPrematureE; "TEST_PREMATURE_EXIT_FILE"
call _ZN7testing8internal5posix6GetEnvEPKc; testing::internal::posix::GetEnv(char const*)
mov [rbp+var_60], rax
loc_4372D:
mov rsi, [rbp+var_60]; char *
lea rdi, [rbp+var_30]; this
call _ZN7testing8internal23ScopedPrematureExitFileC2EPKc; testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*)
mov rdi, [rbp+var_58]; this
call _ZN7testing8UnitTest4implEv; testing::UnitTest::impl(void)
mov [rbp+var_68], rax
jmp short $+2
loc_43749:
mov rdi, [rbp+var_68]; this
movzx esi, cs:_ZN7testing28FLAGS_gtest_catch_exceptionsE; testing::FLAGS_gtest_catch_exceptions
and esi, 1; bool
call _ZN7testing8internal12UnitTestImpl20set_catch_exceptionsEb; testing::internal::UnitTestImpl::set_catch_exceptions(bool)
jmp short $+2
loc_4375E:
mov rdi, [rbp+var_58]; this
call _ZN7testing8UnitTest4implEv; testing::UnitTest::impl(void)
mov [rbp+var_70], rax
jmp short $+2
loc_4376D:
mov rdi, [rbp+var_70]
lea rax, _ZN7testing8internal12UnitTestImpl11RunAllTestsEv; testing::internal::UnitTestImpl::RunAllTests(void)
mov [rbp+var_50], rax
mov [rbp+var_48], 0
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_48]
lea rcx, aAuxiliaryTestC; "auxiliary test code (environments or ev"...
call _ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS0_12UnitTestImplEbEET0_PT_MS4_FS3_vEPKc; testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl,bool>(testing::internal::UnitTestImpl *,bool (testing::internal::UnitTestImpl::*)(void),char const*)
mov [rbp+var_71], al
jmp short $+2
loc_4379D:
mov dl, [rbp+var_71]
mov eax, 1
xor ecx, ecx
test dl, 1
cmovnz eax, ecx
mov [rbp+var_78], eax
lea rdi, [rbp+var_30]; this
call _ZN7testing8internal23ScopedPrematureExitFileD2Ev; testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile()
mov eax, [rbp+var_78]
add rsp, 80h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_38], rcx
mov [rbp+var_3C], eax
lea rdi, [rbp+var_30]; this
call _ZN7testing8internal23ScopedPrematureExitFileD2Ev; testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile()
mov rdi, [rbp+var_38]
call __Unwind_Resume
| _BOOL8 testing::UnitTest::Run(testing::UnitTest *this, const char *a2)
{
long long v2; // rax
BOOL v4; // [rsp+8h] [rbp-78h]
long long v5; // [rsp+10h] [rbp-70h]
testing::internal::UnitTestImpl *v6; // [rsp+18h] [rbp-68h]
char *Env; // [rsp+20h] [rbp-60h]
_BYTE v8[40]; // [rsp+50h] [rbp-30h] BYREF
testing::UnitTest *v9; // [rsp+78h] [rbp-8h]
v9 = this;
v2 = std::string::length(&testing::FLAGS_gtest_internal_run_death_test[abi:cxx11]);
v8[39] = v2 != 0;
if ( v2 )
{
testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(
(testing::internal::ScopedPrematureExitFile *)v8,
0LL);
}
else
{
Env = (char *)testing::internal::posix::GetEnv((testing::internal::posix *)"TEST_PREMATURE_EXIT_FILE", a2);
testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(
(testing::internal::ScopedPrematureExitFile *)v8,
Env);
}
v6 = (testing::internal::UnitTestImpl *)testing::UnitTest::impl(this);
testing::internal::UnitTestImpl::set_catch_exceptions(v6, testing::FLAGS_gtest_catch_exceptions & 1);
v5 = testing::UnitTest::impl(this);
v4 = (testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl,bool>(
v5,
testing::internal::UnitTestImpl::RunAllTests,
0LL,
"auxiliary test code (environments or event listeners)") & 1) == 0;
testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile((testing::internal::ScopedPrematureExitFile *)v8);
return v4;
}
| Run:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x58],RAX
LEA RDI,[0x42a7fb0]
CALL 0x0010bb50
CMP RAX,0x0
SETA AL
AND AL,0x1
MOV byte ptr [RBP + -0x9],AL
TEST byte ptr [RBP + -0x9],0x1
JZ 0x0014371d
XOR EAX,EAX
MOV qword ptr [RBP + -0x60],RAX
JMP 0x0014372d
LAB_0014371d:
LEA RDI,[0x175166]
CALL 0x0014c490
MOV qword ptr [RBP + -0x60],RAX
LAB_0014372d:
MOV RSI,qword ptr [RBP + -0x60]
LEA RDI,[RBP + -0x30]
CALL 0x00151e10
MOV RDI,qword ptr [RBP + -0x58]
LAB_0014373e:
CALL 0x0014d030
MOV qword ptr [RBP + -0x68],RAX
JMP 0x00143749
LAB_00143749:
MOV RDI,qword ptr [RBP + -0x68]
MOVZX ESI,byte ptr [0x042a8015]
AND ESI,0x1
CALL 0x00151f10
JMP 0x0014375e
LAB_0014375e:
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x0014d030
MOV qword ptr [RBP + -0x70],RAX
JMP 0x0014376d
LAB_0014376d:
MOV RDI,qword ptr [RBP + -0x70]
LEA RAX,[0x1437f0]
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBP + -0x48],0x0
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x48]
LEA RCX,[0x17517f]
CALL 0x00151f40
LAB_00143798:
MOV byte ptr [RBP + -0x71],AL
JMP 0x0014379d
LAB_0014379d:
MOV DL,byte ptr [RBP + -0x71]
MOV EAX,0x1
XOR ECX,ECX
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x78],EAX
LEA RDI,[RBP + -0x30]
CALL 0x001521d0
MOV EAX,dword ptr [RBP + -0x78]
ADD RSP,0x80
POP RBP
RET
|
/* testing::UnitTest::Run() */
bool __thiscall testing::UnitTest::Run(UnitTest *this)
{
bool bVar1;
long lVar2;
UnitTestImpl *pUVar3;
char *local_68;
ScopedPrematureExitFile local_38 [39];
int1 local_11;
UnitTest *local_10;
local_10 = this;
lVar2 = std::__cxx11::string::length();
local_11 = lVar2 != 0;
if ((bool)local_11) {
local_68 = (char *)0x0;
}
else {
local_68 = (char *)internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE");
}
internal::ScopedPrematureExitFile::ScopedPrematureExitFile(local_38,local_68);
/* try { // try from 0014373e to 00143797 has its CatchHandler @ 001437c5 */
pUVar3 = (UnitTestImpl *)impl(this);
internal::UnitTestImpl::set_catch_exceptions(pUVar3,(bool)(FLAGS_gtest_catch_exceptions & 1));
pUVar3 = (UnitTestImpl *)impl(this);
bVar1 = internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl,bool>
(pUVar3,internal::UnitTestImpl::RunAllTests,(char *)0x0);
internal::ScopedPrematureExitFile::~ScopedPrematureExitFile(local_38);
return !bVar1;
}
| |
28,485 | HDL_conf_save | xtate/src/xcmd.c | static void HDL_conf_save(void *conf, char *subcmd) {
XConf *xconf = conf;
int err = xconf_save_conf(xconf, subcmd);
if (err) {
LOG(LEVEL_ERROR, "failed to save configuration to %s.\n", subcmd);
} else {
LOG(LEVEL_HINT, "save configuration successfully!\n");
}
} | O3 | c | HDL_conf_save:
pushq %rbx
movq %rsi, %rbx
callq 0x5bad2
testl %eax, %eax
je 0x57ce3
leaq 0x1e123(%rip), %rsi # 0x75df6
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x536da
leaq 0x1ed6b(%rip), %rsi # 0x76a55
movl $0xfffffffe, %edi # imm = 0xFFFFFFFE
xorl %eax, %eax
popq %rbx
jmp 0x536da
| HDL_conf_save:
push rbx
mov rbx, rsi
call xconf_save_conf
test eax, eax
jz short loc_57CE3
lea rsi, aFailedToSaveCo; "failed to save configuration to %s.\n"
mov edi, 0FFFFFFFFh
mov rdx, rbx
xor eax, eax
pop rbx
jmp LOG
loc_57CE3:
lea rsi, aSaveConfigurat; "save configuration successfully!\n"
mov edi, 0FFFFFFFEh
xor eax, eax
pop rbx
jmp LOG
| long long HDL_conf_save(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14,
char a15)
{
long long v15; // rdx
long long v16; // rcx
long long v17; // r8
long long v18; // r9
__m128 v19; // xmm4
__m128 v20; // xmm5
if ( (unsigned int)xconf_save_conf(a1, a2) )
return LOG(
-1,
(long long)"failed to save configuration to %s.\n",
a2,
v16,
v17,
v18,
a3,
a4,
a5,
a6,
v19,
v20,
a9,
a10,
a15);
else
return LOG(
-2,
(long long)"save configuration successfully!\n",
v15,
v16,
v17,
v18,
a3,
a4,
a5,
a6,
v19,
v20,
a9,
a10,
a15);
}
| HDL_conf_save:
PUSH RBX
MOV RBX,RSI
CALL 0x0015bad2
TEST EAX,EAX
JZ 0x00157ce3
LEA RSI,[0x175df6]
MOV EDI,0xffffffff
MOV RDX,RBX
XOR EAX,EAX
POP RBX
JMP 0x001536da
LAB_00157ce3:
LEA RSI,[0x176a55]
MOV EDI,0xfffffffe
XOR EAX,EAX
POP RBX
JMP 0x001536da
|
void HDL_conf_save(int8 param_1,int8 param_2)
{
int iVar1;
iVar1 = xconf_save_conf();
if (iVar1 != 0) {
LOG(0xffffffff,"failed to save configuration to %s.\n",param_2);
return;
}
LOG(0xfffffffe,"save configuration successfully!\n");
return;
}
| |
28,486 | YAML::detail::node& YAML::detail::node_data::get<char [18]>(char const (&) [18], std::shared_ptr<YAML::detail::memory_holder>) | aimrt_mujoco_sim/_deps/yaml-cpp-src/include/yaml-cpp/node/detail/impl.h | inline node& node_data::get(const Key& key, shared_memory_holder pMemory) {
switch (m_type) {
case NodeType::Map:
break;
case NodeType::Undefined:
case NodeType::Null:
case NodeType::Sequence:
if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory)) {
m_type = NodeType::Sequence;
return *pNode;
}
convert_to_map(pMemory);
break;
case NodeType::Scalar:
throw BadSubscript(m_mark, key);
}
auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
return m.first->equals(key, pMemory);
});
if (it != m_map.end()) {
return *it->second;
}
node& k = convert_to_node(key, pMemory);
node& v = pMemory->create_node();
insert_map_pair(k, v);
return v;
} | O0 | c | YAML::detail::node& YAML::detail::node_data::get<char [18]>(char const (&) [18], std::shared_ptr<YAML::detail::memory_holder>):
subq $0xe8, %rsp
movq %rdx, 0x38(%rsp)
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq %rdx, 0xc8(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x10(%rax), %eax
movq %rax, 0x48(%rsp)
subq $0x4, %rax
ja 0xd7b45
movq 0x48(%rsp), %rax
leaq 0xd5de1(%rip), %rcx # 0x1ad810
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xd7b45
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x20(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x9d120
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0xcca60
movq %rax, 0x30(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x9d260
movq 0x30(%rsp), %rax
movq %rax, 0xc0(%rsp)
cmpq $0x0, 0xc0(%rsp)
je 0xd7acc
movq 0x40(%rsp), %rax
movl $0x3, 0x10(%rax)
movq 0xc0(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0xd7caf
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdi
callq 0x1a0c90
jmp 0xd7b45
movl $0x40, %edi
callq 0x89b90
movq 0x40(%rsp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
addq $0x4, %rsi
movq 0xd0(%rsp), %rdx
callq 0xcca80
jmp 0xd7b0a
movq 0x18(%rsp), %rdi
leaq 0x13be92(%rip), %rsi # 0x2139a8
leaq 0xc60d3(%rip), %rdx # 0x19dbf0
callq 0x92530
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
callq 0x8b4e0
jmp 0xd7cbf
movq 0x40(%rsp), %rdi
addq $0x80, %rdi
callq 0xd7d50
movq 0x40(%rsp), %rdi
movq %rax, 0x90(%rsp)
addq $0x80, %rdi
callq 0xd7d80
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x88(%rsp)
movq 0xd0(%rsp), %rcx
movq %rcx, 0x78(%rsp)
movq %rax, 0x80(%rsp)
movq 0x90(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x80(%rsp), %rcx
callq 0xd7cd0
movq 0x40(%rsp), %rdi
movq %rax, 0x98(%rsp)
addq $0x80, %rdi
callq 0xd7d80
movq %rax, 0x70(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xcdab0
xorb $-0x1, %al
testb $0x1, %al
jne 0xd7bee
jmp 0xd7c0c
leaq 0x98(%rsp), %rdi
callq 0xcde00
movq 0x8(%rax), %rax
movq %rax, 0xe0(%rsp)
jmp 0xd7caf
movq 0x38(%rsp), %rsi
movq 0xd0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x9d120
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xd7db0
movq %rax, 0x10(%rsp)
jmp 0xd7c41
leaq 0x58(%rsp), %rdi
callq 0x9d260
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rdi
movq %rax, 0x68(%rsp)
callq 0xcb5e0
movq %rax, %rdi
callq 0xcb5f0
movq 0x40(%rsp), %rdi
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x1a0d00
movq 0x50(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0xd7caf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x9d260
jmp 0xd7cbf
movq 0xe0(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0xa8(%rsp), %rdi
callq 0x92a70
nopl (%rax)
| _ZN4YAML6detail9node_data3getIA18_cEERNS0_4nodeERKT_St10shared_ptrINS0_13memory_holderEE:
sub rsp, 0E8h
mov [rsp+0E8h+var_B0], rdx
mov [rsp+0E8h+var_10], rdi
mov [rsp+0E8h+var_18], rsi
mov [rsp+0E8h+var_20], rdx
mov rax, [rsp+0E8h+var_10]
mov [rsp+0E8h+var_A8], rax
mov eax, [rax+10h]
mov [rsp+0E8h+var_A0], rax
sub rax, 4; switch 5 cases
ja def_D7A36; jumptable 00000000000D7A36 default case
mov rax, [rsp+0E8h+var_A0]
lea rcx, jpt_D7A36
movsxd rax, ds:(jpt_D7A36 - 1AD810h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_D7A38:
jmp def_D7A36; jumptable 00000000000D7A36 case 4
loc_D7A3D:
mov rsi, [rsp+0E8h+var_B0]; jumptable 00000000000D7A36 cases 0,1,3
mov rax, [rsp+0E8h+var_A8]
add rax, 60h ; '`'
mov [rsp+0E8h+var_C8], rax
mov rax, [rsp+0E8h+var_18]
mov [rsp+0E8h+var_C0], rax
lea rdi, [rsp+0E8h+var_38]
call _ZNSt10shared_ptrIN4YAML6detail13memory_holderEEC2ERKS3_; std::shared_ptr<YAML::detail::memory_holder>::shared_ptr(std::shared_ptr<YAML::detail::memory_holder> const&)
mov rdi, [rsp+0E8h+var_C8]
mov rsi, [rsp+0E8h+var_C0]
lea rdx, [rsp+0E8h+var_38]
call _ZN4YAML6detail7get_idxIA18_cvE3getERKSt6vectorIPNS0_4nodeESaIS6_EERA18_KcSt10shared_ptrINS0_13memory_holderEE; YAML::detail::get_idx<char [18],void>::get(std::vector<YAML::detail::node *> const&,char const(&)[18],std::shared_ptr<YAML::detail::memory_holder>)
mov [rsp+0E8h+var_B8], rax
lea rdi, [rsp+0E8h+var_38]
call _ZNSt10shared_ptrIN4YAML6detail13memory_holderEED2Ev; std::shared_ptr<YAML::detail::memory_holder>::~shared_ptr()
mov rax, [rsp+0E8h+var_B8]
mov [rsp+0E8h+var_28], rax
cmp [rsp+0E8h+var_28], 0
jz short loc_D7ACC
mov rax, [rsp+0E8h+var_A8]
mov dword ptr [rax+10h], 3
mov rax, [rsp+0E8h+var_28]
mov [rsp+0E8h+var_8], rax
jmp loc_D7CAF
loc_D7ACC:
mov rsi, [rsp+0E8h+var_B0]
mov rdi, [rsp+0E8h+var_A8]
call _ZN4YAML6detail9node_data14convert_to_mapERKSt10shared_ptrINS0_13memory_holderEE; YAML::detail::node_data::convert_to_map(std::shared_ptr<YAML::detail::memory_holder> const&)
jmp short def_D7A36; jumptable 00000000000D7A36 default case
loc_D7ADD:
mov edi, 40h ; '@'; jumptable 00000000000D7A36 case 2
call ___cxa_allocate_exception
mov rsi, [rsp+0E8h+var_A8]
mov rdi, rax
mov rax, rdi
mov [rsp+0E8h+var_D0], rax
add rsi, 4
mov rdx, [rsp+0E8h+var_18]
call _ZN4YAML12BadSubscriptC2IA18_cEERKNS_4MarkERKT_; YAML::BadSubscript::BadSubscript<char [18]>(YAML::Mark const&,char [18] const&)
jmp short $+2
loc_D7B0A:
mov rdi, [rsp+0E8h+var_D0]; void *
lea rsi, _ZTIN4YAML12BadSubscriptE; lptinfo
lea rdx, _ZN4YAML12BadSubscriptD2Ev; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+0E8h+var_D0]; void *
mov rcx, rax
mov eax, edx
mov [rsp+0E8h+var_40], rcx
mov [rsp+0E8h+var_44], eax
call ___cxa_free_exception
jmp loc_D7CBF
def_D7A36:
mov rdi, [rsp+0E8h+var_A8]; jumptable 00000000000D7A36 default case
add rdi, 80h
call _ZNSt6vectorISt4pairIPN4YAML6detail4nodeES4_ESaIS5_EE5beginEv; std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>::begin(void)
mov rdi, [rsp+0E8h+var_A8]
mov [rsp+0E8h+var_58], rax
add rdi, 80h
call _ZNSt6vectorISt4pairIPN4YAML6detail4nodeES4_ESaIS5_EE3endEv; std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>::end(void)
mov rcx, rax
mov rax, [rsp+0E8h+var_B0]
mov [rsp+0E8h+var_60], rcx
mov rcx, [rsp+0E8h+var_18]
mov [rsp+0E8h+var_70], rcx
mov [rsp+0E8h+var_68], rax
mov rdi, [rsp+0E8h+var_58]
mov rsi, [rsp+0E8h+var_60]
mov rdx, [rsp+0E8h+var_70]
mov rcx, [rsp+0E8h+var_68]
call _ZSt7find_ifIN9__gnu_cxx17__normal_iteratorIPSt4pairIPN4YAML6detail4nodeES6_ESt6vectorIS7_SaIS7_EEEEZNS4_9node_data3getIA18_cEERS5_RKT_St10shared_ptrINS4_13memory_holderEEEUlS7_E_ESH_SH_SH_T0_; std::find_if<__gnu_cxx::__normal_iterator<std::pair<YAML::detail::node *,YAML::detail::node *> *,std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>>,YAML::detail::node_data::get<char [18]>(char [18] const&,std::shared_ptr<YAML::detail::memory_holder>)::{lambda(std::pair<YAML::detail::node *,YAML::detail::node *>)#1}>(char [18],char [18],YAML::detail::node_data::get<char [18]>(char [18] const&,std::shared_ptr<YAML::detail::memory_holder>)::{lambda(std::pair<YAML::detail::node *,YAML::detail::node *>)#1})
mov rdi, [rsp+0E8h+var_A8]
mov [rsp+0E8h+var_50], rax
add rdi, 80h
call _ZNSt6vectorISt4pairIPN4YAML6detail4nodeES4_ESaIS5_EE3endEv; std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>::end(void)
mov [rsp+0E8h+var_78], rax
lea rdi, [rsp+0E8h+var_50]
lea rsi, [rsp+0E8h+var_78]
call _ZN9__gnu_cxxeqIPSt4pairIPN4YAML6detail4nodeES5_ESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESG_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
xor al, 0FFh
test al, 1
jnz short loc_D7BEE
jmp short loc_D7C0C
loc_D7BEE:
lea rdi, [rsp+0E8h+var_50]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIPN4YAML6detail4nodeES5_ESt6vectorIS6_SaIS6_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<YAML::detail::node *,YAML::detail::node *> *,std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>>::operator->(void)
mov rax, [rax+8]
mov [rsp+0E8h+var_8], rax
jmp loc_D7CAF
loc_D7C0C:
mov rsi, [rsp+0E8h+var_B0]
mov rax, [rsp+0E8h+var_18]
mov [rsp+0E8h+var_E8], rax
lea rdi, [rsp+0E8h+var_90]
mov [rsp+0E8h+var_E0], rdi
call _ZNSt10shared_ptrIN4YAML6detail13memory_holderEEC2ERKS3_; std::shared_ptr<YAML::detail::memory_holder>::shared_ptr(std::shared_ptr<YAML::detail::memory_holder> const&)
mov rdi, [rsp+0E8h+var_E8]
mov rsi, [rsp+0E8h+var_E0]
call _ZN4YAML6detail9node_data15convert_to_nodeIA18_cEERNS0_4nodeERKT_St10shared_ptrINS0_13memory_holderEE; YAML::detail::node_data::convert_to_node<char [18]>(char [18] const&,std::shared_ptr<YAML::detail::memory_holder>)
mov [rsp+0E8h+var_D8], rax
jmp short $+2
loc_D7C41:
lea rdi, [rsp+0E8h+var_90]
call _ZNSt10shared_ptrIN4YAML6detail13memory_holderEED2Ev; std::shared_ptr<YAML::detail::memory_holder>::~shared_ptr()
mov rax, [rsp+0E8h+var_D8]
mov rdi, [rsp+0E8h+var_B0]
mov [rsp+0E8h+var_80], rax
call _ZNKSt19__shared_ptr_accessIN4YAML6detail13memory_holderELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<YAML::detail::memory_holder,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax; this
call _ZN4YAML6detail13memory_holder11create_nodeEv; YAML::detail::memory_holder::create_node(void)
mov rdi, [rsp+0E8h+var_A8]; this
mov [rsp+0E8h+var_98], rax
mov rsi, [rsp+0E8h+var_80]; YAML::detail::node *
mov rdx, [rsp+0E8h+var_98]; YAML::detail::node *
call _ZN4YAML6detail9node_data15insert_map_pairERNS0_4nodeES3_; YAML::detail::node_data::insert_map_pair(YAML::detail::node &,YAML::detail::node &)
mov rax, [rsp+0E8h+var_98]
mov [rsp+0E8h+var_8], rax
jmp short loc_D7CAF
mov rcx, rax
mov eax, edx
mov [rsp+0E8h+var_40], rcx
mov [rsp+0E8h+var_44], eax
lea rdi, [rsp+0E8h+var_90]
call _ZNSt10shared_ptrIN4YAML6detail13memory_holderEED2Ev; std::shared_ptr<YAML::detail::memory_holder>::~shared_ptr()
jmp short loc_D7CBF
loc_D7CAF:
mov rax, [rsp+0E8h+var_8]
add rsp, 0E8h
retn
loc_D7CBF:
mov rdi, [rsp+0E8h+var_40]
call __Unwind_Resume
| YAML::detail::node * YAML::detail::node_data::get<char [18]>(
YAML::detail::node_data *a1,
long long a2,
long long a3)
{
int v3; // ecx
int v4; // r8d
int v5; // r9d
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
YAML::detail::memory_holder *v10; // rax
int v12; // [rsp+0h] [rbp-E8h]
YAML::detail::node *v13; // [rsp+10h] [rbp-D8h]
_QWORD *exception; // [rsp+18h] [rbp-D0h]
long long v15; // [rsp+30h] [rbp-B8h]
YAML::detail::node *node; // [rsp+50h] [rbp-98h]
_BYTE v18[16]; // [rsp+58h] [rbp-90h] BYREF
YAML::detail::node *v19; // [rsp+68h] [rbp-80h]
_QWORD v20[3]; // [rsp+70h] [rbp-78h] BYREF
long long v21; // [rsp+88h] [rbp-60h]
long long v22; // [rsp+90h] [rbp-58h]
long long v23; // [rsp+98h] [rbp-50h] BYREF
_BYTE v24[16]; // [rsp+B0h] [rbp-38h] BYREF
long long v25; // [rsp+C0h] [rbp-28h]
long long v26; // [rsp+C8h] [rbp-20h]
long long v27; // [rsp+D0h] [rbp-18h]
YAML::detail::node_data *v28; // [rsp+D8h] [rbp-10h]
v28 = a1;
v27 = a2;
v26 = a3;
switch ( *((_DWORD *)a1 + 4) )
{
case 0:
case 1:
case 3:
std::shared_ptr<YAML::detail::memory_holder>::shared_ptr((long long)v24, a3);
v15 = YAML::detail::get_idx<char [18],void>::get();
std::shared_ptr<YAML::detail::memory_holder>::~shared_ptr((long long)v24);
v25 = v15;
if ( v15 )
{
*((_DWORD *)a1 + 4) = 3;
return (YAML::detail::node *)v25;
}
else
{
YAML::detail::node_data::convert_to_map(a1, a3);
LABEL_6:
v22 = std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>::begin((char *)a1 + 128);
v21 = std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>::end((char *)a1 + 128);
v20[1] = v27;
v20[2] = a3;
v23 = std::find_if<__gnu_cxx::__normal_iterator<std::pair<YAML::detail::node *,YAML::detail::node *> *,std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>>,YAML::detail::node& YAML::detail::node_data::get<char [18]>(char [18] const&,std::shared_ptr<YAML::detail::memory_holder>)::{lambda(std::pair<YAML::detail::node *,YAML::detail::node *>)#1}>(
v22,
v21,
v27,
a3);
v20[0] = std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>::end((char *)a1 + 128);
if ( __gnu_cxx::operator==<std::pair<YAML::detail::node *,YAML::detail::node *> *,std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>>(
(long long)&v23,
(long long)v20) )
{
v12 = v27;
std::shared_ptr<YAML::detail::memory_holder>::shared_ptr((long long)v18, a3);
v13 = (YAML::detail::node *)YAML::detail::node_data::convert_to_node<char [18]>(
v12,
(unsigned int)v18,
v6,
v7,
v8,
v9,
v12,
(unsigned int)v18);
std::shared_ptr<YAML::detail::memory_holder>::~shared_ptr((long long)v18);
v19 = v13;
v10 = (YAML::detail::memory_holder *)std::__shared_ptr_access<YAML::detail::memory_holder,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(a3);
node = (YAML::detail::node *)YAML::detail::memory_holder::create_node(v10);
YAML::detail::node_data::insert_map_pair(a1, v19, node);
return node;
}
else
{
return *(YAML::detail::node **)(__gnu_cxx::__normal_iterator<std::pair<YAML::detail::node *,YAML::detail::node *> *,std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>>::operator->((long long)&v23)
+ 8);
}
}
case 2:
exception = __cxa_allocate_exception(0x40uLL);
YAML::BadSubscript::BadSubscript<char [18]>(exception, (long long)a1 + 4, v27, v3, v4, v5);
__cxa_throw(exception, (struct type_info *)&`typeinfo for'YAML::BadSubscript, YAML::BadSubscript::~BadSubscript);
default:
goto LABEL_6;
}
}
| get<char[18]>:
SUB RSP,0xe8
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0xd8],RDI
MOV qword ptr [RSP + 0xd0],RSI
MOV qword ptr [RSP + 0xc8],RDX
MOV RAX,qword ptr [RSP + 0xd8]
MOV qword ptr [RSP + 0x40],RAX
MOV EAX,dword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x48],RAX
SUB RAX,0x4
JA 0x001d7b45
MOV RAX,qword ptr [RSP + 0x48]
LEA RCX,[0x2ad810]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_4:
JMP 0x001d7b45
caseD_0:
MOV RSI,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x40]
ADD RAX,0x60
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x28],RAX
LEA RDI,[RSP + 0xb0]
CALL 0x0019d120
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
LEA RDX,[RSP + 0xb0]
CALL 0x001cca60
MOV qword ptr [RSP + 0x30],RAX
LEA RDI,[RSP + 0xb0]
CALL 0x0019d260
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0xc0],RAX
CMP qword ptr [RSP + 0xc0],0x0
JZ 0x001d7acc
MOV RAX,qword ptr [RSP + 0x40]
MOV dword ptr [RAX + 0x10],0x3
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0xe0],RAX
JMP 0x001d7caf
LAB_001d7acc:
MOV RSI,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x002a0c90
JMP 0x001d7b45
caseD_2:
MOV EDI,0x40
CALL 0x00189b90
MOV RSI,qword ptr [RSP + 0x40]
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
ADD RSI,0x4
MOV RDX,qword ptr [RSP + 0xd0]
LAB_001d7b03:
CALL 0x001cca80
LAB_001d7b08:
JMP 0x001d7b0a
LAB_001d7b0a:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[0x3139a8]
LEA RDX,[0x29dbf0]
CALL 0x00192530
default:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x80
CALL 0x001d7d50
MOV RDI,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x90],RAX
ADD RDI,0x80
CALL 0x001d7d80
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x88],RCX
MOV RCX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x78],RCX
MOV qword ptr [RSP + 0x80],RAX
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x78]
MOV RCX,qword ptr [RSP + 0x80]
CALL 0x001d7cd0
MOV RDI,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x98],RAX
ADD RDI,0x80
CALL 0x001d7d80
MOV qword ptr [RSP + 0x70],RAX
LEA RDI,[RSP + 0x98]
LEA RSI,[RSP + 0x70]
CALL 0x001cdab0
XOR AL,0xff
TEST AL,0x1
JNZ 0x001d7bee
JMP 0x001d7c0c
LAB_001d7bee:
LEA RDI,[RSP + 0x98]
CALL 0x001cde00
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0xe0],RAX
JMP 0x001d7caf
LAB_001d7c0c:
MOV RSI,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP],RAX
LEA RDI,[RSP + 0x58]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0019d120
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
LAB_001d7c35:
CALL 0x001d7db0
LAB_001d7c3a:
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001d7c41
LAB_001d7c41:
LEA RDI,[RSP + 0x58]
CALL 0x0019d260
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x68],RAX
CALL 0x001cb5e0
MOV RDI,RAX
CALL 0x001cb5f0
MOV RDI,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x50],RAX
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x50]
CALL 0x002a0d00
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0xe0],RAX
JMP 0x001d7caf
LAB_001d7caf:
MOV RAX,qword ptr [RSP + 0xe0]
ADD RSP,0xe8
RET
|
/* YAML::detail::node& YAML::detail::node_data::get<char [18]>(char const (&) [18],
std::shared_ptr<YAML::detail::memory_holder>) */
node * __thiscall
YAML::detail::node_data::get<char[18]>(node_data *this,char *param_1,shared_ptr *param_3)
{
char *pcVar1;
byte bVar2;
BadSubscript *this_00;
long lVar3;
node *pnVar4;
memory_holder *this_01;
shared_ptr<YAML::detail::memory_holder> local_90 [16];
node *local_80;
int8 local_78;
char *local_70;
shared_ptr *local_68;
int8 local_60;
int8 local_58;
int8 local_50 [3];
shared_ptr<YAML::detail::memory_holder> local_38 [16];
node *local_28;
shared_ptr *local_20;
char *local_18;
node_data *local_10;
node *local_8;
local_20 = param_3;
local_18 = param_1;
local_10 = this;
switch(*(int4 *)(this + 0x10)) {
case 0:
case 1:
case 3:
std::shared_ptr<YAML::detail::memory_holder>::shared_ptr(local_38,param_3);
pnVar4 = (node *)get_idx<char[18],void>::get(this + 0x60,param_1,local_38);
std::shared_ptr<YAML::detail::memory_holder>::~shared_ptr(local_38);
if (pnVar4 != (node *)0x0) {
*(int4 *)(this + 0x10) = 3;
return pnVar4;
}
local_28 = pnVar4;
convert_to_map(this,param_3);
break;
case 2:
this_00 = (BadSubscript *)__cxa_allocate_exception(0x40);
/* try { // try from 001d7b03 to 001d7b07 has its CatchHandler @ 001d7b22 */
BadSubscript::BadSubscript<char[18]>(this_00,(Mark *)(this + 4),local_18);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,&BadSubscript::typeinfo,BadSubscript::~BadSubscript);
case 4:
}
local_58 = std::
vector<std::pair<YAML::detail::node*,YAML::detail::node*>,std::allocator<std::pair<YAML::detail::node*,YAML::detail::node*>>>
::begin((vector<std::pair<YAML::detail::node*,YAML::detail::node*>,std::allocator<std::pair<YAML::detail::node*,YAML::detail::node*>>>
*)(this + 0x80));
local_60 = std::
vector<std::pair<YAML::detail::node*,YAML::detail::node*>,std::allocator<std::pair<YAML::detail::node*,YAML::detail::node*>>>
::end((vector<std::pair<YAML::detail::node*,YAML::detail::node*>,std::allocator<std::pair<YAML::detail::node*,YAML::detail::node*>>>
*)(this + 0x80));
local_70 = local_18;
local_68 = param_3;
local_50[0] = std::
find_if<__gnu_cxx::__normal_iterator<std::pair<YAML::detail::node*,YAML::detail::node*>*,std::vector<std::pair<YAML::detail::node*,YAML::detail::node*>,std::allocator<std::pair<YAML::detail::node*,YAML::detail::node*>>>>,YAML::detail::node_data::get<char[18]>(char_const(&)[18],std::shared_ptr<YAML::detail::memory_holder>)::_lambda(std::pair<YAML::detail::node*,YAML::detail::node*>)_1_>
(local_58,local_60,local_18,param_3);
local_78 = std::
vector<std::pair<YAML::detail::node*,YAML::detail::node*>,std::allocator<std::pair<YAML::detail::node*,YAML::detail::node*>>>
::end((vector<std::pair<YAML::detail::node*,YAML::detail::node*>,std::allocator<std::pair<YAML::detail::node*,YAML::detail::node*>>>
*)(this + 0x80));
bVar2 = _ZN9__gnu_cxxeqIPSt4pairIPN4YAML6detail4nodeES5_ESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESG_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
(local_50,&local_78);
pcVar1 = local_18;
if (((bVar2 ^ 0xff) & 1) == 0) {
std::shared_ptr<YAML::detail::memory_holder>::shared_ptr(local_90,param_3);
/* try { // try from 001d7c35 to 001d7c39 has its CatchHandler @ 001d7c8f */
pnVar4 = convert_to_node<char[18]>(pcVar1,local_90);
std::shared_ptr<YAML::detail::memory_holder>::~shared_ptr(local_90);
local_80 = pnVar4;
this_01 = (memory_holder *)
std::
__shared_ptr_access<YAML::detail::memory_holder,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<YAML::detail::memory_holder,(__gnu_cxx::_Lock_policy)2,false,false>
*)param_3);
pnVar4 = (node *)memory_holder::create_node(this_01);
insert_map_pair(this,local_80,pnVar4);
local_8 = pnVar4;
}
else {
lVar3 = __gnu_cxx::
__normal_iterator<std::pair<YAML::detail::node*,YAML::detail::node*>*,std::vector<std::pair<YAML::detail::node*,YAML::detail::node*>,std::allocator<std::pair<YAML::detail::node*,YAML::detail::node*>>>>
::operator->((__normal_iterator<std::pair<YAML::detail::node*,YAML::detail::node*>*,std::vector<std::pair<YAML::detail::node*,YAML::detail::node*>,std::allocator<std::pair<YAML::detail::node*,YAML::detail::node*>>>>
*)local_50);
local_8 = *(node **)(lVar3 + 8);
}
return local_8;
}
| |
28,487 | YAML::detail::node& YAML::detail::node_data::get<char [18]>(char const (&) [18], std::shared_ptr<YAML::detail::memory_holder>) | aimrt_mujoco_sim/_deps/yaml-cpp-src/include/yaml-cpp/node/detail/impl.h | inline node& node_data::get(const Key& key, shared_memory_holder pMemory) {
switch (m_type) {
case NodeType::Map:
break;
case NodeType::Undefined:
case NodeType::Null:
case NodeType::Sequence:
if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory)) {
m_type = NodeType::Sequence;
return *pNode;
}
convert_to_map(pMemory);
break;
case NodeType::Scalar:
throw BadSubscript(m_mark, key);
}
auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
return m.first->equals(key, pMemory);
});
if (it != m_map.end()) {
return *it->second;
}
node& k = convert_to_node(key, pMemory);
node& v = pMemory->create_node();
insert_map_pair(k, v);
return v;
} | O3 | c | YAML::detail::node& YAML::detail::node_data::get<char [18]>(char const (&) [18], std::shared_ptr<YAML::detail::memory_holder>):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl 0x10(%rdi), %eax
cmpl $0x2, %eax
jb 0x6457b
cmpl $0x3, %eax
je 0x6457b
cmpl $0x2, %eax
jne 0x645a9
movl $0x40, %edi
callq 0x1e7e0
movq %rax, %r14
addq $0x4, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x629cc
leaq 0x4b46c(%rip), %rsi # 0xaf9d8
leaq 0x1c211(%rip), %rdx # 0x80784
movq %r14, %rdi
callq 0x1fec0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x6459e
movq 0x4b975(%rip), %rax # 0xaff00
cmpb $0x0, (%rax)
je 0x64595
incl 0x8(%rdi)
jmp 0x64599
lock
incl 0x8(%rdi)
callq 0x1ed80
movq %rbx, %rdi
movq %r14, %rsi
callq 0x815f4
movq 0x80(%rbx), %rdi
movq 0x88(%rbx), %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x646bd
cmpq 0x88(%rbx), %rax
je 0x645d4
movq 0x8(%rax), %r14
jmp 0x64678
movq (%r14), %r13
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x645f7
movq 0x4b919(%rip), %rax # 0xaff00
cmpb $0x0, (%rax)
je 0x645f2
incl 0x8(%r15)
jmp 0x645f7
lock
incl 0x8(%r15)
leaq 0x48(%rsp), %rsi
movq %r12, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x3a6ca
leaq 0x8(%rsp), %rdi
callq 0x35db4
movq 0x30(%rsp), %rsi
movq %r13, %rdi
callq 0x808ec
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %r12
testq %rdi, %rdi
je 0x64634
callq 0x1ed80
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6464f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1f250
testq %r15, %r15
je 0x6465c
movq %r15, %rdi
callq 0x1ed80
movq (%r14), %rax
movq (%rax), %rdi
callq 0x80946
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x8163c
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x1ebc0
jmp 0x646b5
movq %rax, %rbx
jmp 0x646a8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x23de8
testq %r15, %r15
je 0x646b5
movq %r15, %rdi
callq 0x1ed80
movq %rbx, %rdi
callq 0x1ffd0
| _ZN4YAML6detail9node_data3getIA12_cEERNS0_4nodeERKT_St10shared_ptrINS0_13memory_holderEE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 50h
mov r14, rdx
mov r12, rsi
mov rbx, rdi
mov eax, [rdi+10h]
cmp eax, 2
jb short loc_6457B
cmp eax, 3
jz short loc_6457B
cmp eax, 2
jnz short loc_645A9
mov edi, 40h ; '@'; thrown_size
call ___cxa_allocate_exception
mov r14, rax
add rbx, 4
mov rdi, rax
mov rsi, rbx
mov rdx, r12
call _ZN4YAML12BadSubscriptC2IA12_cEERKNS_4MarkERKT_; YAML::BadSubscript::BadSubscript<char [12]>(YAML::Mark const&,char [12] const&)
lea rsi, _ZTIN4YAML12BadSubscriptE; lptinfo
lea rdx, _ZN4YAML9ExceptionD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_6457B:
mov rdi, [r14+8]
test rdi, rdi
jz short loc_6459E
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_64595
inc dword ptr [rdi+8]
jmp short loc_64599
loc_64595:
lock inc dword ptr [rdi+8]
loc_64599:
call __ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_6459E:
mov rdi, rbx; this
mov rsi, r14
call _ZN4YAML6detail9node_data14convert_to_mapERKSt10shared_ptrINS0_13memory_holderEE; YAML::detail::node_data::convert_to_map(std::shared_ptr<YAML::detail::memory_holder> const&)
loc_645A9:
mov rdi, [rbx+80h]
mov rsi, [rbx+88h]
mov rdx, r12
mov rcx, r14
call _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIPSt4pairIPN4YAML6detail4nodeES6_ESt6vectorIS7_SaIS7_EEEENS0_5__ops10_Iter_predIZNS4_9node_data3getIA12_cEERS5_RKT_St10shared_ptrINS4_13memory_holderEEEUlS7_E_EEESJ_SJ_SJ_T0_St26random_access_iterator_tag; std::__find_if<__gnu_cxx::__normal_iterator<std::pair<YAML::detail::node *,YAML::detail::node *> *,std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>>,__gnu_cxx::__ops::_Iter_pred<YAML::detail::node_data::get<char [12]>(char [12] const&,std::shared_ptr<YAML::detail::memory_holder>)::{lambda(std::pair<YAML::detail::node *,YAML::detail::node *>)#1}>>(char [12],char [12],__gnu_cxx::__ops::_Iter_pred<YAML::detail::node_data::get<char [12]>(char [12] const&,std::shared_ptr<YAML::detail::memory_holder>)::{lambda(std::pair<YAML::detail::node *,YAML::detail::node *>)#1}>,std::random_access_iterator_tag)
cmp rax, [rbx+88h]
jz short loc_645D4
mov r14, [rax+8]
jmp loc_64678
loc_645D4:
mov r13, [r14]
mov r15, [r14+8]
test r15, r15
jz short loc_645F7
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_645F2
inc dword ptr [r15+8]
jmp short loc_645F7
loc_645F2:
lock inc dword ptr [r15+8]
loc_645F7:
lea rsi, [rsp+78h+var_30]
mov [rsi], r12
lea rdi, [rsp+78h+var_70]; this
call _ZN4YAML4NodeC2IPKcEERKT_; YAML::Node::Node<char const*>(char const* const&)
lea rdi, [rsp+78h+var_70]; this
call _ZNK4YAML4Node16EnsureNodeExistsEv; YAML::Node::EnsureNodeExists(void)
mov rsi, [rsp+78h+var_48]
mov rdi, r13
call _ZN4YAML6detail13memory_holder5mergeERS1_; YAML::detail::memory_holder::merge(YAML::detail::memory_holder&)
mov rdi, [rsp+78h+var_40]
mov r12, [rsp+78h+var_38]
test rdi, rdi
jz short loc_64634
call __ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_64634:
lea rax, [rsp+78h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_6464F
mov rsi, [rsp+78h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6464F:
test r15, r15
jz short loc_6465C
mov rdi, r15
call __ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_6465C:
mov rax, [r14]
mov rdi, [rax]; this
call _ZN4YAML6detail6memory11create_nodeEv; YAML::detail::memory::create_node(void)
mov r14, rax
mov rdi, rbx; this
mov rsi, r12; YAML::detail::node *
mov rdx, rax; YAML::detail::node *
call _ZN4YAML6detail9node_data15insert_map_pairERNS0_4nodeES3_; YAML::detail::node_data::insert_map_pair(YAML::detail::node &,YAML::detail::node &)
loc_64678:
mov rax, r14
add rsp, 50h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_646B5
mov rbx, rax
jmp short loc_646A8
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN4YAML4NodeD2Ev; YAML::Node::~Node()
loc_646A8:
test r15, r15
jz short loc_646B5
mov rdi, r15
call __ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_646B5:
mov rdi, rbx
call __Unwind_Resume
| YAML::detail::node * YAML::detail::node_data::get<char [12]>(
YAML::detail::node_data *this,
long long a2,
long long a3)
{
unsigned int v5; // eax
_QWORD *exception; // r14
long long v7; // rdi
long long v8; // rax
YAML::detail::node *node; // r14
YAML::detail::memory **v10; // r13
long long v11; // r15
YAML::detail::node *v12; // r12
YAML::detail::memory **v14; // [rsp+8h] [rbp-70h] BYREF
_QWORD *v15; // [rsp+10h] [rbp-68h]
_QWORD v16[3]; // [rsp+20h] [rbp-58h] BYREF
long long v17; // [rsp+38h] [rbp-40h]
YAML::detail::node *v18; // [rsp+40h] [rbp-38h]
long long v19[6]; // [rsp+48h] [rbp-30h] BYREF
v5 = *((_DWORD *)this + 4);
if ( v5 < 2 || v5 == 3 )
{
v7 = *(_QWORD *)(a3 + 8);
if ( v7 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v7 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v7 + 8));
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v7);
}
YAML::detail::node_data::convert_to_map(this);
}
else if ( v5 == 2 )
{
exception = __cxa_allocate_exception(0x40uLL);
YAML::BadSubscript::BadSubscript<char [12]>(exception, (_DWORD)this + 4, a2);
__cxa_throw(exception, (struct type_info *)&`typeinfo for'YAML::BadSubscript, YAML::Exception::~Exception);
}
v8 = std::__find_if<__gnu_cxx::__normal_iterator<std::pair<YAML::detail::node *,YAML::detail::node *> *,std::vector<std::pair<YAML::detail::node *,YAML::detail::node *>>>,__gnu_cxx::__ops::_Iter_pred<YAML::detail::node& YAML::detail::node_data::get<char [12]>(char [12] const&,std::shared_ptr<YAML::detail::memory_holder>)::{lambda(std::pair<YAML::detail::node *,YAML::detail::node *>)#1}>>(
*((_QWORD *)this + 16),
*((_QWORD *)this + 17),
a2,
a3);
if ( v8 != *((_QWORD *)this + 17) )
return *(YAML::detail::node **)(v8 + 8);
v10 = *(YAML::detail::memory ***)a3;
v11 = *(_QWORD *)(a3 + 8);
if ( v11 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v11 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v11 + 8));
}
v19[0] = a2;
YAML::Node::Node<char const*>((YAML::Node *)&v14, v19);
YAML::Node::EnsureNodeExists(&v14);
YAML::detail::memory_holder::merge(v10, v16[2]);
v12 = v18;
if ( v17 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v17);
if ( v15 != v16 )
operator delete(v15, v16[0] + 1LL);
if ( v11 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v11);
node = (YAML::detail::node *)YAML::detail::memory::create_node(**(YAML::detail::memory ***)a3);
YAML::detail::node_data::insert_map_pair(this, v12, node);
return node;
}
| get<char[12]>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV R14,RDX
MOV R12,RSI
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0x10]
CMP EAX,0x2
JC 0x0016457b
CMP EAX,0x3
JZ 0x0016457b
CMP EAX,0x2
JNZ 0x001645a9
MOV EDI,0x40
CALL 0x0011e7e0
MOV R14,RAX
ADD RBX,0x4
LAB_00164557:
MOV RDI,RAX
MOV RSI,RBX
MOV RDX,R12
CALL 0x001629cc
LAB_00164565:
LEA RSI,[0x1af9d8]
LEA RDX,[0x180784]
MOV RDI,R14
CALL 0x0011fec0
LAB_0016457b:
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x0016459e
MOV RAX,qword ptr [0x001aff00]
CMP byte ptr [RAX],0x0
JZ 0x00164595
INC dword ptr [RDI + 0x8]
JMP 0x00164599
LAB_00164595:
INC.LOCK dword ptr [RDI + 0x8]
LAB_00164599:
CALL 0x0011ed80
LAB_0016459e:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001815f4
LAB_001645a9:
MOV RDI,qword ptr [RBX + 0x80]
MOV RSI,qword ptr [RBX + 0x88]
MOV RDX,R12
MOV RCX,R14
CALL 0x001646bd
CMP RAX,qword ptr [RBX + 0x88]
JZ 0x001645d4
MOV R14,qword ptr [RAX + 0x8]
JMP 0x00164678
LAB_001645d4:
MOV R13,qword ptr [R14]
MOV R15,qword ptr [R14 + 0x8]
TEST R15,R15
JZ 0x001645f7
MOV RAX,qword ptr [0x001aff00]
CMP byte ptr [RAX],0x0
JZ 0x001645f2
INC dword ptr [R15 + 0x8]
JMP 0x001645f7
LAB_001645f2:
INC.LOCK dword ptr [R15 + 0x8]
LAB_001645f7:
LEA RSI,[RSP + 0x48]
MOV qword ptr [RSI],R12
LAB_001645ff:
LEA RDI,[RSP + 0x8]
CALL 0x0013a6ca
LAB_00164609:
LEA RDI,[RSP + 0x8]
CALL 0x00135db4
MOV RSI,qword ptr [RSP + 0x30]
MOV RDI,R13
CALL 0x001808ec
LAB_00164620:
MOV RDI,qword ptr [RSP + 0x38]
MOV R12,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x00164634
CALL 0x0011ed80
LAB_00164634:
LEA RAX,[RSP + 0x20]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0016464f
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x0011f250
LAB_0016464f:
TEST R15,R15
JZ 0x0016465c
MOV RDI,R15
CALL 0x0011ed80
LAB_0016465c:
MOV RAX,qword ptr [R14]
MOV RDI,qword ptr [RAX]
CALL 0x00180946
MOV R14,RAX
MOV RDI,RBX
MOV RSI,R12
MOV RDX,RAX
CALL 0x0018163c
LAB_00164678:
MOV RAX,R14
ADD RSP,0x50
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* YAML::detail::node& YAML::detail::node_data::get<char [12]>(char const (&) [12],
std::shared_ptr<YAML::detail::memory_holder>) */
node * __thiscall
YAML::detail::node_data::get<char[12]>(node_data *this,char *param_1,int8 *param_3)
{
uint uVar1;
memory_holder *this_00;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var2;
BadSubscript *this_01;
long lVar3;
node *pnVar4;
Node local_70 [8];
long *local_68;
long local_58 [2];
memory_holder *local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
node *local_38;
char *local_30;
uVar1 = *(uint *)(this + 0x10);
if ((uVar1 < 2) || (uVar1 == 3)) {
p_Var2 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_3[1];
if (p_Var2 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_001aff00 == '\0') {
LOCK();
*(int *)(p_Var2 + 8) = *(int *)(p_Var2 + 8) + 1;
UNLOCK();
}
else {
*(int *)(p_Var2 + 8) = *(int *)(p_Var2 + 8) + 1;
}
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Var2);
}
convert_to_map(this,(shared_ptr *)param_3);
}
else if (uVar1 == 2) {
this_01 = (BadSubscript *)__cxa_allocate_exception(0x40);
/* try { // try from 00164557 to 00164564 has its CatchHandler @ 00164689 */
BadSubscript::BadSubscript<char[12]>(this_01,(Mark *)(this + 4),param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(this_01,&BadSubscript::typeinfo,BadInsert::~BadInsert);
}
lVar3 = std::
__find_if<__gnu_cxx::__normal_iterator<std::pair<YAML::detail::node*,YAML::detail::node*>*,std::vector<std::pair<YAML::detail::node*,YAML::detail::node*>,std::allocator<std::pair<YAML::detail::node*,YAML::detail::node*>>>>,__gnu_cxx::__ops::_Iter_pred<YAML::detail::node_data::get<char[12]>(char_const(&)[12],std::shared_ptr<YAML::detail::memory_holder>)::_lambda(std::pair<YAML::detail::node*,YAML::detail::node*>)_1_>>
(*(int8 *)(this + 0x80),*(int8 *)(this + 0x88),param_1,param_3);
if (lVar3 == *(long *)(this + 0x88)) {
this_00 = (memory_holder *)*param_3;
p_Var2 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_3[1];
if (p_Var2 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_001aff00 == '\0') {
LOCK();
*(int *)(p_Var2 + 8) = *(int *)(p_Var2 + 8) + 1;
UNLOCK();
}
else {
*(int *)(p_Var2 + 8) = *(int *)(p_Var2 + 8) + 1;
}
}
/* try { // try from 001645ff to 00164608 has its CatchHandler @ 00164696 */
local_30 = param_1;
Node::Node<char_const*>(local_70,&local_30);
/* try { // try from 00164609 to 0016461f has its CatchHandler @ 0016469b */
Node::EnsureNodeExists(local_70);
memory_holder::merge(this_00,local_48);
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
if (local_68 != local_58) {
operator_delete(local_68,local_58[0] + 1);
}
if (p_Var2 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Var2);
}
pnVar4 = (node *)memory::create_node(*(memory **)*param_3);
insert_map_pair(this,local_38,pnVar4);
}
else {
pnVar4 = *(node **)(lVar3 + 8);
}
return pnVar4;
}
| |
28,488 | Trie::IsStandardAminoAcidSequence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | MikePodsytnik[P]TCRtrie/src/Trie.cpp | bool Trie::IsStandardAminoAcidSequence(const std::string& seq) const {
static const std::unordered_set<char> validAminoAcids = {
'A', 'R', 'N', 'D', 'C', 'E', 'Q', 'G', 'H', 'I',
'L', 'K', 'M', 'F', 'P', 'S', 'T', 'W', 'Y', 'V'
};
for (char c : seq) {
if (!validAminoAcids.count(c)) {
return false;
}
}
return true;
} | O0 | cpp | Trie::IsStandardAminoAcidSequence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpb $0x0, 0x4dede(%rip) # 0xa2ae8
jne 0x54caf
leaq 0x4ded1(%rip), %rdi # 0xa2ae8
callq 0x9aa0
cmpl $0x0, %eax
je 0x54caf
movups 0x1c5f0(%rip), %xmm0 # 0x7121c
movaps %xmm0, -0x40(%rbp)
movl $0x56595754, -0x30(%rbp) # imm = 0x56595754
leaq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x14, -0x20(%rbp)
leaq -0x43(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x9a80
movq -0x80(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq %rsp, %rax
movq %rcx, (%rax)
leaq 0x4de43(%rip), %rdi # 0xa2ab0
xorl %eax, %eax
movl %eax, %ecx
leaq -0x41(%rbp), %r8
leaq -0x42(%rbp), %r9
callq 0x5b370
jmp 0x54c80
leaq -0x43(%rbp), %rdi
callq 0x9690
leaq 0x6740(%rip), %rdi # 0x5b3d0
leaq 0x4de19(%rip), %rsi # 0xa2ab0
leaq 0x4d92a(%rip), %rdx # 0xa25c8
callq 0x9540
leaq 0x4de3e(%rip), %rdi # 0xa2ae8
callq 0x93d0
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x95b0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x9ac0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2f770
testb $0x1, %al
jne 0x54ce4
jmp 0x54d3e
leaq -0x68(%rbp), %rdi
callq 0x230e0
movb (%rax), %al
movb %al, -0x71(%rbp)
leaq 0x4ddb7(%rip), %rdi # 0xa2ab0
leaq -0x71(%rbp), %rsi
callq 0x5b3f0
cmpq $0x0, %rax
jne 0x54d31
movb $0x0, -0x1(%rbp)
jmp 0x54d42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x43(%rbp), %rdi
callq 0x9690
leaq 0x4ddbe(%rip), %rdi # 0xa2ae8
callq 0x93c0
jmp 0x54d50
jmp 0x54d33
leaq -0x68(%rbp), %rdi
callq 0x23050
jmp 0x54cd1
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x9a70
nopl (%rax)
| _ZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
cmp cs:_ZGVZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids, 0; `guard variable for'Trie::IsStandardAminoAcidSequence(std::string const&)::validAminoAcids
jnz loc_54CAF
lea rdi, _ZGVZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; __guard *
call ___cxa_guard_acquire
cmp eax, 0
jz loc_54CAF
movups xmm0, cs:xmmword_7121C
movaps [rbp+var_40], xmm0
mov [rbp+var_30], 56595754h
lea rax, [rbp+var_40]
mov [rbp+var_28], rax
mov [rbp+var_20], 14h
lea rdi, [rbp+var_43]
mov [rbp+var_80], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rcx, [rbp+var_80]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_20]
mov rax, rsp
mov [rax], rcx
lea rdi, _ZZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; Trie::IsStandardAminoAcidSequence(std::string const&)::validAminoAcids
xor eax, eax
mov ecx, eax
lea r8, [rbp+var_41]
lea r9, [rbp+var_42]
call _ZNSt13unordered_setIcSt4hashIcESt8equal_toIcESaIcEEC2ESt16initializer_listIcEmRKS1_RKS3_RKS4_; std::unordered_set<char>::unordered_set(std::initializer_list<char>,ulong,std::hash<char> const&,std::equal_to<char> const&,std::allocator<char> const&)
jmp short $+2
loc_54C80:
lea rdi, [rbp+var_43]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, _ZNSt13unordered_setIcSt4hashIcESt8equal_toIcESaIcEED2Ev; lpfunc
lea rsi, _ZZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; __guard *
call ___cxa_guard_release
loc_54CAF:
mov rax, [rbp+var_18]
mov [rbp+var_60], rax
mov rdi, [rbp+var_60]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rbp+var_68], rax
mov rdi, [rbp+var_60]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov [rbp+var_70], rax
loc_54CD1:
lea rdi, [rbp+var_68]
lea rsi, [rbp+var_70]
call _ZN9__gnu_cxxneIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEbRKNS_17__normal_iteratorIT_T0_EESE_; __gnu_cxx::operator!=<char const*,std::string>(__gnu_cxx::__normal_iterator<char const*,std::string> const&,__gnu_cxx::__normal_iterator<char const*,std::string> const&)
test al, 1
jnz short loc_54CE4
jmp short loc_54D3E
loc_54CE4:
lea rdi, [rbp+var_68]
call _ZNK9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv; __gnu_cxx::__normal_iterator<char const*,std::string>::operator*(void)
mov al, [rax]
mov [rbp+var_71], al
lea rdi, _ZZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; Trie::IsStandardAminoAcidSequence(std::string const&)::validAminoAcids
lea rsi, [rbp+var_71]
call _ZNKSt13unordered_setIcSt4hashIcESt8equal_toIcESaIcEE5countERKc; std::unordered_set<char>::count(char const&)
cmp rax, 0
jnz short loc_54D31
mov [rbp+var_1], 0
jmp short loc_54D42
mov rcx, rax
mov eax, edx
mov [rbp+var_50], rcx
mov [rbp+var_54], eax
lea rdi, [rbp+var_43]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, _ZGVZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; __guard *
call ___cxa_guard_abort
jmp short loc_54D50
loc_54D31:
jmp short $+2
loc_54D33:
lea rdi, [rbp+var_68]
call _ZN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEppEv; __gnu_cxx::__normal_iterator<char const*,std::string>::operator++(void)
jmp short loc_54CD1
loc_54D3E:
mov [rbp+var_1], 1
loc_54D42:
mov al, [rbp+var_1]
and al, 1
add rsp, 90h
pop rbp
retn
loc_54D50:
mov rdi, [rbp+var_50]
call __Unwind_Resume
| char Trie::IsStandardAminoAcidSequence(long long a1, long long a2)
{
long long v2; // rdx
char v4; // [rsp+1Fh] [rbp-71h] BYREF
long long v5; // [rsp+20h] [rbp-70h] BYREF
long long v6; // [rsp+28h] [rbp-68h] BYREF
long long v7; // [rsp+30h] [rbp-60h]
char v8; // [rsp+4Dh] [rbp-43h] BYREF
char v9; // [rsp+4Eh] [rbp-42h] BYREF
char v10; // [rsp+4Fh] [rbp-41h] BYREF
_BYTE v11[20]; // [rsp+50h] [rbp-40h] BYREF
_BYTE *v12; // [rsp+68h] [rbp-28h]
long long v13; // [rsp+70h] [rbp-20h]
long long v14; // [rsp+78h] [rbp-18h]
long long v15; // [rsp+80h] [rbp-10h]
v15 = a1;
v14 = a2;
if ( !(_BYTE)`guard variable for'Trie::IsStandardAminoAcidSequence(std::string const&)::validAminoAcids
&& __cxa_guard_acquire(&`guard variable for'Trie::IsStandardAminoAcidSequence(std::string const&)::validAminoAcids) )
{
qmemcpy(v11, "ARNDCEQGHILKMFPSTWYV", sizeof(v11));
v12 = v11;
v13 = 20LL;
std::allocator<char>::allocator(&v8, a2, v2);
std::unordered_set<char>::unordered_set(
(unsigned int)&Trie::IsStandardAminoAcidSequence(std::string const&)const::validAminoAcids,
(_DWORD)v12,
v13,
0,
(unsigned int)&v10,
(unsigned int)&v9,
(long long)&v8);
std::allocator<char>::~allocator(&v8);
__cxa_atexit(
std::unordered_set<char>::~unordered_set,
&Trie::IsStandardAminoAcidSequence(std::string const&)const::validAminoAcids,
&_dso_handle);
__cxa_guard_release(&`guard variable for'Trie::IsStandardAminoAcidSequence(std::string const&)::validAminoAcids);
}
v7 = v14;
v6 = std::string::begin(v14);
v5 = std::string::end(v7);
while ( __gnu_cxx::operator!=<char const*,std::string>((long long)&v6, (long long)&v5) )
{
v4 = *(_BYTE *)__gnu_cxx::__normal_iterator<char const*,std::string>::operator*((long long)&v6);
if ( !std::unordered_set<char>::count(
&Trie::IsStandardAminoAcidSequence(std::string const&)const::validAminoAcids,
&v4) )
return 0;
__gnu_cxx::__normal_iterator<char const*,std::string>::operator++(&v6);
}
return 1;
}
| IsStandardAminoAcidSequence:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP byte ptr [0x001a2ae8],0x0
JNZ 0x00154caf
LEA RDI,[0x1a2ae8]
CALL 0x00109aa0
CMP EAX,0x0
JZ 0x00154caf
MOVUPS XMM0,xmmword ptr [0x0017121c]
MOVAPS xmmword ptr [RBP + -0x40],XMM0
MOV dword ptr [RBP + -0x30],0x56595754
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x20],0x14
LEA RDI,[RBP + -0x43]
MOV qword ptr [RBP + -0x80],RDI
CALL 0x00109a80
MOV RCX,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x20]
LAB_00154c60:
MOV RAX,RSP
MOV qword ptr [RAX],RCX
LEA RDI,[0x1a2ab0]
XOR EAX,EAX
MOV ECX,EAX
LEA R8,[RBP + -0x41]
LEA R9,[RBP + -0x42]
CALL 0x0015b370
LAB_00154c7e:
JMP 0x00154c80
LAB_00154c80:
LEA RDI,[RBP + -0x43]
CALL 0x00109690
LEA RDI,[0x15b3d0]
LEA RSI,[0x1a2ab0]
LEA RDX,[0x1a25c8]
CALL 0x00109540
LEA RDI,[0x1a2ae8]
CALL 0x001093d0
LAB_00154caf:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x60]
CALL 0x001095b0
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x60]
CALL 0x00109ac0
MOV qword ptr [RBP + -0x70],RAX
LAB_00154cd1:
LEA RDI,[RBP + -0x68]
LEA RSI,[RBP + -0x70]
CALL 0x0012f770
TEST AL,0x1
JNZ 0x00154ce4
JMP 0x00154d3e
LAB_00154ce4:
LEA RDI,[RBP + -0x68]
CALL 0x001230e0
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x71],AL
LEA RDI,[0x1a2ab0]
LEA RSI,[RBP + -0x71]
CALL 0x0015b3f0
CMP RAX,0x0
JNZ 0x00154d31
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00154d42
LAB_00154d31:
JMP 0x00154d33
LAB_00154d33:
LEA RDI,[RBP + -0x68]
CALL 0x00123050
JMP 0x00154cd1
LAB_00154d3e:
MOV byte ptr [RBP + -0x1],0x1
LAB_00154d42:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x90
POP RBP
RET
|
/* Trie::IsStandardAminoAcidSequence(std::__cxx11::string const&) const */
int8 __thiscall Trie::IsStandardAminoAcidSequence(Trie *this,string *param_1)
{
bool bVar1;
int iVar2;
int7 extraout_var;
char *pcVar3;
long lVar4;
int7 uVar5;
char local_79;
int8 local_78;
int8 local_70;
string *local_68;
allocator<char> local_4b;
int1 local_4a;
int1 local_49;
char local_48 [8];
char acStack_40 [8];
int4 local_38;
char *local_30;
int8 local_28;
string *local_20;
Trie *local_18;
int1 local_9;
local_20 = param_1;
local_18 = this;
if (IsStandardAminoAcidSequence(std::__cxx11::string_const&)::validAminoAcids == '\0') {
iVar2 = __cxa_guard_acquire(&IsStandardAminoAcidSequence(std::__cxx11::string_const&)::
validAminoAcids);
if (iVar2 != 0) {
local_48[0] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[0];
local_48[1] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[1];
local_48[2] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[2];
local_48[3] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[3];
local_48[4] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[4];
local_48[5] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[5];
local_48[6] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[6];
local_48[7] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[7];
acStack_40[0] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[8];
acStack_40[1] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[9];
acStack_40[2] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[10];
acStack_40[3] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[0xb];
acStack_40[4] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[0xc];
acStack_40[5] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[0xd];
acStack_40[6] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[0xe];
acStack_40[7] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0017121c[0xf];
local_38 = 0x56595754;
local_30 = local_48;
local_28 = 0x14;
std::allocator<char>::allocator();
/* try { // try from 00154c60 to 00154c7d has its CatchHandler @ 00154d0e */
std::unordered_set<char,std::hash<char>,std::equal_to<char>,std::allocator<char>>::
unordered_set(IsStandardAminoAcidSequence(std::__cxx11::string_const&)::validAminoAcids,
local_30,local_28,0,&local_49,&local_4a,&local_4b);
std::allocator<char>::~allocator(&local_4b);
__cxa_atexit(std::unordered_set<char,std::hash<char>,std::equal_to<char>,std::allocator<char>>
::~unordered_set,
IsStandardAminoAcidSequence(std::__cxx11::string_const&)::validAminoAcids,
&__dso_handle);
__cxa_guard_release(&IsStandardAminoAcidSequence(std::__cxx11::string_const&)::validAminoAcids
);
}
}
local_68 = local_20;
local_70 = std::__cxx11::string::begin();
local_78 = std::__cxx11::string::end();
do {
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_70,(__normal_iterator *)&local_78);
if (!bVar1) {
local_9 = 1;
uVar5 = extraout_var;
LAB_00154d42:
return CONCAT71(uVar5,local_9);
}
pcVar3 = (char *)__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::operator*
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_70);
local_79 = *pcVar3;
lVar4 = std::unordered_set<char,std::hash<char>,std::equal_to<char>,std::allocator<char>>::count
((unordered_set<char,std::hash<char>,std::equal_to<char>,std::allocator<char>>
*)IsStandardAminoAcidSequence(std::__cxx11::string_const&)::validAminoAcids,
&local_79);
if (lVar4 == 0) {
local_9 = 0;
uVar5 = 0;
goto LAB_00154d42;
}
__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::operator++
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_70);
} while( true );
}
| |
28,489 | Trie::IsStandardAminoAcidSequence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | MikePodsytnik[P]TCRtrie/src/Trie.cpp | bool Trie::IsStandardAminoAcidSequence(const std::string& seq) const {
static const std::unordered_set<char> validAminoAcids = {
'A', 'R', 'N', 'D', 'C', 'E', 'Q', 'G', 'H', 'I',
'L', 'K', 'M', 'F', 'P', 'S', 'T', 'W', 'Y', 'V'
};
for (char c : seq) {
if (!validAminoAcids.count(c)) {
return false;
}
}
return true;
} | O1 | cpp | Trie::IsStandardAminoAcidSequence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movb 0x19cd3(%rip), %al # 0x4a948
testb %al, %al
je 0x30cec
movq 0x8(%rbx), %r15
testq %r15, %r15
sete %bpl
je 0x30cdb
movq (%rbx), %r12
movb (%r12), %al
leaq 0x10(%rsp), %rsi
movb %al, (%rsi)
leaq 0x19c75(%rip), %rdi # 0x4a910
callq 0x34b7c
testq %rax, %rax
je 0x30cdb
movl $0x1, %r13d
leaq 0x19c5e(%rip), %rbx # 0x4a910
leaq 0x10(%rsp), %r14
cmpq %r13, %r15
sete %bpl
je 0x30cdb
movb (%r12,%r13), %al
movb %al, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x34b7c
incq %r13
testq %rax, %rax
jne 0x30cb7
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19c55(%rip), %rdi # 0x4a948
callq 0x77a0
testl %eax, %eax
je 0x30c79
movups 0x8357(%rip), %xmm0 # 0x3905e
leaq 0x24(%rsp), %rdx
movaps %xmm0, -0x14(%rdx)
movl $0x56595754, -0x4(%rdx) # imm = 0x56595754
leaq 0xd(%rsp), %rax
movq %rax, (%rsp)
leaq 0x19be9(%rip), %rdi # 0x4a910
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %r8
leaq 0xe(%rsp), %r9
xorl %ecx, %ecx
callq 0x347b6
leaq 0xfec(%rip), %rdi # 0x31d30
leaq 0x19bc5(%rip), %rsi # 0x4a910
leaq 0x196d6(%rip), %rdx # 0x4a428
callq 0x73b0
leaq 0x19bea(%rip), %rdi # 0x4a948
callq 0x7290
jmp 0x30c79
movq %rax, %rbx
leaq 0x19bd6(%rip), %rdi # 0x4a948
callq 0x7280
movq %rbx, %rdi
callq 0x7780
nop
| _ZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rsi
mov al, cs:_ZGVZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; `guard variable for'Trie::IsStandardAminoAcidSequence(std::string const&)::validAminoAcids
test al, al
jz short loc_30CEC
loc_30C79:
mov r15, [rbx+8]
test r15, r15
setz bpl
jz short loc_30CDB
mov r12, [rbx]
mov al, [r12]
lea rsi, [rsp+58h+var_48]
mov [rsi], al
lea rdi, _ZZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; Trie::IsStandardAminoAcidSequence(std::string const&)::validAminoAcids
call _ZNKSt10_HashtableIccSaIcENSt8__detail9_IdentityESt8equal_toIcESt4hashIcENS1_18_Mod_range_hashingENS1_20_Default_ranged_hashENS1_20_Prime_rehash_policyENS1_17_Hashtable_traitsILb0ELb1ELb1EEEE5countERKc; std::_Hashtable<char,char,std::allocator<char>,std::__detail::_Identity,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,true,true>>::count(char const&)
test rax, rax
jz short loc_30CDB
mov r13d, 1
lea rbx, _ZZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; Trie::IsStandardAminoAcidSequence(std::string const&)::validAminoAcids
lea r14, [rsp+58h+var_48]
loc_30CB7:
cmp r15, r13
setz bpl
jz short loc_30CDB
mov al, [r12+r13]
mov [rsp+58h+var_48], al
mov rdi, rbx
mov rsi, r14
call _ZNKSt10_HashtableIccSaIcENSt8__detail9_IdentityESt8equal_toIcESt4hashIcENS1_18_Mod_range_hashingENS1_20_Default_ranged_hashENS1_20_Prime_rehash_policyENS1_17_Hashtable_traitsILb0ELb1ELb1EEEE5countERKc; std::_Hashtable<char,char,std::allocator<char>,std::__detail::_Identity,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,true,true>>::count(char const&)
inc r13
test rax, rax
jnz short loc_30CB7
loc_30CDB:
mov eax, ebp
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_30CEC:
lea rdi, _ZGVZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_30C79
movups xmm0, cs:xmmword_3905E
lea rdx, [rsp+58h+var_34]
movaps xmmword ptr [rdx-14h], xmm0
mov dword ptr [rdx-4], 56595754h
lea rax, [rsp+58h+var_4B]
mov [rsp+58h+var_58], rax
lea rdi, _ZZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; Trie::IsStandardAminoAcidSequence(std::string const&)::validAminoAcids
lea rsi, [rsp+58h+var_48]
lea r8, [rsp+58h+var_49]
lea r9, [rsp+58h+var_4A]
xor ecx, ecx
call _ZNSt10_HashtableIccSaIcENSt8__detail9_IdentityESt8equal_toIcESt4hashIcENS1_18_Mod_range_hashingENS1_20_Default_ranged_hashENS1_20_Prime_rehash_policyENS1_17_Hashtable_traitsILb0ELb1ELb1EEEEC2IPKcEET_SG_mRKS6_RKS4_RKS0_St17integral_constantIbLb1EE; std::_Hashtable<char,char,std::allocator<char>,std::__detail::_Identity,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,true,true>>::_Hashtable<char const*>(char const*,char const*,ulong,std::hash<char> const&,std::equal_to<char> const&,std::allocator<char> const&,std::integral_constant<bool,true>)
lea rdi, _ZNSt13unordered_setIcSt4hashIcESt8equal_toIcESaIcEED2Ev; lpfunc
lea rsi, _ZZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; __guard *
call ___cxa_guard_release
jmp loc_30C79
mov rbx, rax
lea rdi, _ZGVZNK4Trie27IsStandardAminoAcidSequenceERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE15validAminoAcids; __guard *
call ___cxa_guard_abort
mov rdi, rbx
call __Unwind_Resume
| long long Trie::IsStandardAminoAcidSequence(long long a1, long long a2)
{
unsigned int v2; // ebp
long long v3; // r15
_BYTE *v4; // r12
long long v5; // r13
char v7; // [rsp+Dh] [rbp-4Bh] BYREF
char v8; // [rsp+Eh] [rbp-4Ah] BYREF
char v9; // [rsp+Fh] [rbp-49h] BYREF
_BYTE v10[20]; // [rsp+10h] [rbp-48h] BYREF
char v11; // [rsp+24h] [rbp-34h] BYREF
if ( !(_BYTE)`guard variable for'Trie::IsStandardAminoAcidSequence(std::string const&)::validAminoAcids
&& __cxa_guard_acquire(&`guard variable for'Trie::IsStandardAminoAcidSequence(std::string const&)::validAminoAcids) )
{
qmemcpy(v10, "ARNDCEQGHILKMFPSTWYV", sizeof(v10));
std::_Hashtable<char,char,std::allocator<char>,std::__detail::_Identity,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,true,true>>::_Hashtable<char const*>(
(unsigned int)&Trie::IsStandardAminoAcidSequence(std::string const&)const::validAminoAcids,
(unsigned int)v10,
(unsigned int)&v11,
0,
(unsigned int)&v9,
(unsigned int)&v8,
(long long)&v7);
__cxa_atexit(
std::unordered_set<char>::~unordered_set,
&Trie::IsStandardAminoAcidSequence(std::string const&)const::validAminoAcids,
&_dso_handle);
__cxa_guard_release(&`guard variable for'Trie::IsStandardAminoAcidSequence(std::string const&)::validAminoAcids);
}
v3 = *(_QWORD *)(a2 + 8);
LOBYTE(v2) = v3 == 0;
if ( v3 )
{
v4 = *(_BYTE **)a2;
v10[0] = **(_BYTE **)a2;
if ( std::_Hashtable<char,char,std::allocator<char>,std::__detail::_Identity,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,true,true>>::count(&Trie::IsStandardAminoAcidSequence(std::string const&)const::validAminoAcids) )
{
v5 = 1LL;
do
{
LOBYTE(v2) = v3 == v5;
if ( v3 == v5 )
break;
v10[0] = v4[v5++];
}
while ( std::_Hashtable<char,char,std::allocator<char>,std::__detail::_Identity,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,true,true>>::count(&Trie::IsStandardAminoAcidSequence(std::string const&)const::validAminoAcids) );
}
}
return v2;
}
| IsStandardAminoAcidSequence:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RSI
MOV AL,byte ptr [0x0014a948]
TEST AL,AL
JZ 0x00130cec
LAB_00130c79:
MOV R15,qword ptr [RBX + 0x8]
TEST R15,R15
SETZ BPL
JZ 0x00130cdb
MOV R12,qword ptr [RBX]
MOV AL,byte ptr [R12]
LEA RSI,[RSP + 0x10]
MOV byte ptr [RSI],AL
LEA RDI,[0x14a910]
CALL 0x00134b7c
TEST RAX,RAX
JZ 0x00130cdb
MOV R13D,0x1
LEA RBX,[0x14a910]
LEA R14,[RSP + 0x10]
LAB_00130cb7:
CMP R15,R13
SETZ BPL
JZ 0x00130cdb
MOV AL,byte ptr [R12 + R13*0x1]
MOV byte ptr [RSP + 0x10],AL
MOV RDI,RBX
MOV RSI,R14
CALL 0x00134b7c
INC R13
TEST RAX,RAX
JNZ 0x00130cb7
LAB_00130cdb:
MOV EAX,EBP
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00130cec:
LEA RDI,[0x14a948]
CALL 0x001077a0
TEST EAX,EAX
JZ 0x00130c79
MOVUPS XMM0,xmmword ptr [0x0013905e]
LEA RDX,[RSP + 0x24]
MOVAPS xmmword ptr [RDX + -0x14],XMM0
MOV dword ptr [RDX + -0x4],0x56595754
LAB_00130d17:
LEA RAX,[RSP + 0xd]
MOV qword ptr [RSP],RAX
LEA RDI,[0x14a910]
LEA RSI,[RSP + 0x10]
LEA R8,[RSP + 0xf]
LEA R9,[RSP + 0xe]
XOR ECX,ECX
CALL 0x001347b6
LAB_00130d3d:
LEA RDI,[0x131d30]
LEA RSI,[0x14a910]
LEA RDX,[0x14a428]
CALL 0x001073b0
LEA RDI,[0x14a948]
CALL 0x00107290
JMP 0x00130c79
|
/* Trie::IsStandardAminoAcidSequence(std::__cxx11::string const&) const */
ulong __thiscall Trie::IsStandardAminoAcidSequence(Trie *this,string *param_1)
{
long lVar1;
int1 *puVar2;
int iVar3;
long lVar4;
long lVar5;
int8 unaff_RBP;
ulong uVar6;
int1 local_4b;
int1 local_4a;
int1 local_49;
char local_48 [4];
char acStack_44 [4];
char acStack_40 [4];
char acStack_3c [4];
int4 local_38;
int1 local_34 [4];
if (IsStandardAminoAcidSequence(std::__cxx11::string_const&)::validAminoAcids == '\0') {
iVar3 = __cxa_guard_acquire(&IsStandardAminoAcidSequence(std::__cxx11::string_const&)::
validAminoAcids);
if (iVar3 != 0) {
local_48[0] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[0];
local_48[1] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[1];
local_48[2] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[2];
local_48[3] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[3];
acStack_44[0] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[4];
acStack_44[1] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[5];
acStack_44[2] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[6];
acStack_44[3] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[7];
acStack_40[0] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[8];
acStack_40[1] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[9];
acStack_40[2] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[10];
acStack_40[3] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[0xb];
acStack_3c[0] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[0xc];
acStack_3c[1] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[0xd];
acStack_3c[2] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[0xe];
acStack_3c[3] = s_ARNDCEQGHILKMFPSTWYVSt23_Sp_coun_0013905e[0xf];
local_38 = 0x56595754;
/* try { // try from 00130d17 to 00130d3c has its CatchHandler @ 00130d68 */
std::
_Hashtable<char,char,std::allocator<char>,std::__detail::_Identity,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,true,true>>
::_Hashtable<char_const*>
(IsStandardAminoAcidSequence(std::__cxx11::string_const&)::validAminoAcids,local_48,
local_34,0,&local_49,&local_4a,&local_4b);
__cxa_atexit(std::unordered_set<char,std::hash<char>,std::equal_to<char>,std::allocator<char>>
::~unordered_set,
IsStandardAminoAcidSequence(std::__cxx11::string_const&)::validAminoAcids,
&__dso_handle);
__cxa_guard_release(&IsStandardAminoAcidSequence(std::__cxx11::string_const&)::validAminoAcids
);
}
}
lVar1 = *(long *)(param_1 + 8);
uVar6 = CONCAT71((int7)((ulong)unaff_RBP >> 8),lVar1 == 0);
if (lVar1 != 0) {
puVar2 = *(int1 **)param_1;
local_48[0] = *puVar2;
lVar4 = std::
_Hashtable<char,char,std::allocator<char>,std::__detail::_Identity,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,true,true>>
::count((_Hashtable<char,char,std::allocator<char>,std::__detail::_Identity,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,true,true>>
*)IsStandardAminoAcidSequence(std::__cxx11::string_const&)::validAminoAcids,
local_48);
if (lVar4 != 0) {
lVar4 = 1;
do {
uVar6 = CONCAT71((int7)(uVar6 >> 8),lVar1 == lVar4);
if (lVar1 == lVar4) break;
local_48[0] = puVar2[lVar4];
lVar5 = std::
_Hashtable<char,char,std::allocator<char>,std::__detail::_Identity,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,true,true>>
::count((_Hashtable<char,char,std::allocator<char>,std::__detail::_Identity,std::equal_to<char>,std::hash<char>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,true,true>>
*)IsStandardAminoAcidSequence(std::__cxx11::string_const&)::validAminoAcids
,local_48);
lVar4 = lVar4 + 1;
} while (lVar5 != 0);
}
}
return uVar6 & 0xffffffff;
}
| |
28,490 | processAndWriteFrame(cv::Mat const&, cv::Mat const&, cv::VideoWriter&) | Depths-CPP/src/video_depth_estimation.cpp | void processAndWriteFrame(const cv::Mat& frame, const cv::Mat& depthMap, cv::VideoWriter& writer) {
if (depthMap.empty()) {
std::cerr << "Warning: Skipping empty depth map.\n";
return;
}
// Normalize and colorize the depth map
cv::Mat depthVis, depthColor, combined;
cv::normalize(depthMap, depthVis, 0, 255, cv::NORM_MINMAX, CV_8U);
cv::applyColorMap(depthVis, depthColor, cv::COLORMAP_JET);
// Resize depthColor to match the frame if needed
if (depthColor.size() != frame.size()) {
cv::resize(depthColor, depthColor, frame.size());
}
// Horizontally concatenate the original frame and the colorized depth map
cv::hconcat(frame, depthColor, combined);
writer.write(combined);
} | O0 | cpp | processAndWriteFrame(cv::Mat const&, cv::Mat const&, cv::VideoWriter&):
subq $0x268, %rsp # imm = 0x268
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq 0x258(%rsp), %rdi
callq 0x191e0
testb $0x1, %al
jne 0x1c522
jmp 0x1c53a
movq 0x1aa9f(%rip), %rdi # 0x36fc8
leaq 0x10c81(%rip), %rsi # 0x2d1b1
callq 0x19480
jmp 0x1c8f9
leaq 0x1f0(%rsp), %rdi
callq 0x19050
leaq 0x190(%rsp), %rdi
callq 0x19050
leaq 0x130(%rsp), %rdi
callq 0x19050
movq 0x258(%rsp), %rsi
leaq 0x118(%rsp), %rdi
callq 0x1fc80
jmp 0x1c578
leaq 0xf0(%rsp), %rdi
leaq 0x1f0(%rsp), %rsi
callq 0x20eb0
jmp 0x1c58f
callq 0x193e0
movq %rax, 0x10(%rsp)
jmp 0x1c59b
movq 0x10(%rsp), %r8
leaq 0x118(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
vpxor %xmm0, %xmm0, %xmm0
vmovsd 0x10a54(%rip), %xmm1 # 0x2d010
movl $0x20, %edx
xorl %ecx, %ecx
callq 0x19260
jmp 0x1c5ca
leaq 0xf0(%rsp), %rdi
callq 0x20ef0
leaq 0x118(%rsp), %rdi
callq 0x1fd00
leaq 0xd8(%rsp), %rdi
leaq 0x1f0(%rsp), %rsi
callq 0x1fc80
jmp 0x1c5fb
leaq 0xc0(%rsp), %rdi
leaq 0x190(%rsp), %rsi
callq 0x1fc00
jmp 0x1c612
leaq 0xd8(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movl $0x2, %edx
callq 0x19170
jmp 0x1c62e
leaq 0xc0(%rsp), %rdi
callq 0x1fc60
leaq 0xd8(%rsp), %rdi
callq 0x1fd00
leaq 0x1d0(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
callq 0x209a0
jmp 0x1c65f
movq 0x260(%rsp), %rsi
addq $0x40, %rsi
leaq 0xb0(%rsp), %rdi
callq 0x209a0
jmp 0x1c67a
leaq 0xb8(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x1c9c0
movb %al, 0xf(%rsp)
jmp 0x1c695
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1c6a2
jmp 0x1c824
leaq 0x98(%rsp), %rdi
leaq 0x190(%rsp), %rsi
callq 0x1fc80
jmp 0x1c6b9
leaq 0x80(%rsp), %rdi
leaq 0x190(%rsp), %rsi
callq 0x1fc00
jmp 0x1c6d0
movq 0x260(%rsp), %rsi
addq $0x40, %rsi
leaq 0x78(%rsp), %rdi
callq 0x209a0
jmp 0x1c6e8
leaq 0x98(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x78(%rsp), %rdx
vpxor %xmm1, %xmm1, %xmm1
movl $0x1, %ecx
vmovaps %xmm1, %xmm0
callq 0x19510
jmp 0x1c711
leaq 0x80(%rsp), %rdi
callq 0x1fc60
leaq 0x98(%rsp), %rdi
callq 0x1fd00
jmp 0x1c824
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
jmp 0x1c97f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
jmp 0x1c780
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x20ef0
leaq 0x118(%rsp), %rdi
callq 0x1fd00
jmp 0x1c97f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
jmp 0x1c7c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x1fc60
leaq 0xd8(%rsp), %rdi
callq 0x1fd00
jmp 0x1c97f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
jmp 0x1c812
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x1fc60
leaq 0x98(%rsp), %rdi
callq 0x1fd00
jmp 0x1c97f
movq 0x260(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x1fc80
jmp 0x1c838
leaq 0x48(%rsp), %rdi
leaq 0x190(%rsp), %rsi
callq 0x1fc80
jmp 0x1c84c
leaq 0x30(%rsp), %rdi
leaq 0x130(%rsp), %rsi
callq 0x1fc00
jmp 0x1c860
leaq 0x60(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x192c0
jmp 0x1c876
leaq 0x30(%rsp), %rdi
callq 0x1fc60
leaq 0x48(%rsp), %rdi
callq 0x1fd00
leaq 0x60(%rsp), %rdi
callq 0x1fd00
movq 0x250(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x130(%rsp), %rsi
callq 0x1fc80
jmp 0x1c8b4
movq (%rsp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
leaq 0x18(%rsp), %rsi
callq *%rax
jmp 0x1c8c8
leaq 0x18(%rsp), %rdi
callq 0x1fd00
leaq 0x130(%rsp), %rdi
callq 0x19080
leaq 0x190(%rsp), %rdi
callq 0x19080
leaq 0x1f0(%rsp), %rdi
callq 0x19080
addq $0x268, %rsp # imm = 0x268
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
jmp 0x1c955
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
jmp 0x1c94b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1fc60
leaq 0x48(%rsp), %rdi
callq 0x1fd00
leaq 0x60(%rsp), %rdi
callq 0x1fd00
jmp 0x1c97f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x110(%rsp)
movl %eax, 0x10c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1fd00
leaq 0x130(%rsp), %rdi
callq 0x19080
leaq 0x190(%rsp), %rdi
callq 0x19080
leaq 0x1f0(%rsp), %rdi
callq 0x19080
movq 0x110(%rsp), %rdi
callq 0x19360
nopw %cs:(%rax,%rax)
| _Z20processAndWriteFrameRKN2cv3MatES2_RNS_11VideoWriterE:
sub rsp, 268h
mov [rsp+268h+var_8], rdi
mov [rsp+268h+var_10], rsi
mov [rsp+268h+var_18], rdx
mov rdi, [rsp+268h+var_10]; this
call __ZNK2cv3Mat5emptyEv; cv::Mat::empty(void)
test al, 1
jnz short loc_1C522
jmp short loc_1C53A
loc_1C522:
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aWarningSkippin; "Warning: Skipping empty depth map.\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp loc_1C8F9
loc_1C53A:
lea rdi, [rsp+268h+var_78]; this
call __ZN2cv3MatC1Ev; cv::Mat::Mat(void)
lea rdi, [rsp+268h+var_D8]; this
call __ZN2cv3MatC1Ev; cv::Mat::Mat(void)
lea rdi, [rsp+268h+var_138]; this
call __ZN2cv3MatC1Ev; cv::Mat::Mat(void)
mov rsi, [rsp+268h+var_10]; cv::Mat *
lea rdi, [rsp+268h+var_150]; this
call _ZN2cv11_InputArrayC2ERKNS_3MatE; cv::_InputArray::_InputArray(cv::Mat const&)
jmp short $+2
loc_1C578:
lea rdi, [rsp+268h+var_178]; this
lea rsi, [rsp+268h+var_78]; cv::Mat *
call _ZN2cv17_InputOutputArrayC2ERNS_3MatE; cv::_InputOutputArray::_InputOutputArray(cv::Mat &)
jmp short $+2
loc_1C58F:
call __ZN2cv7noArrayEv; cv::noArray(void)
mov [rsp+268h+var_258], rax
jmp short $+2
loc_1C59B:
mov r8, [rsp+268h+var_258]
lea rdi, [rsp+268h+var_150]
lea rsi, [rsp+268h+var_178]
vpxor xmm0, xmm0, xmm0
vmovsd xmm1, cs:qword_2D010
mov edx, 20h ; ' '
xor ecx, ecx
call __ZN2cv9normalizeERKNS_11_InputArrayERKNS_17_InputOutputArrayEddiiS2_; cv::normalize(cv::_InputArray const&,cv::_InputOutputArray const&,double,double,int,int,cv::_InputArray const&)
jmp short $+2
loc_1C5CA:
lea rdi, [rsp+268h+var_178]; this
call _ZN2cv17_InputOutputArrayD2Ev; cv::_InputOutputArray::~_InputOutputArray()
lea rdi, [rsp+268h+var_150]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
lea rdi, [rsp+268h+var_190]; this
lea rsi, [rsp+268h+var_78]; cv::Mat *
call _ZN2cv11_InputArrayC2ERKNS_3MatE; cv::_InputArray::_InputArray(cv::Mat const&)
jmp short $+2
loc_1C5FB:
lea rdi, [rsp+268h+var_1A8]; this
lea rsi, [rsp+268h+var_D8]; cv::Mat *
call _ZN2cv12_OutputArrayC2ERNS_3MatE; cv::_OutputArray::_OutputArray(cv::Mat &)
jmp short $+2
loc_1C612:
lea rdi, [rsp+268h+var_190]
lea rsi, [rsp+268h+var_1A8]
mov edx, 2
call __ZN2cv13applyColorMapERKNS_11_InputArrayERKNS_12_OutputArrayEi; cv::applyColorMap(cv::_InputArray const&,cv::_OutputArray const&,int)
jmp short $+2
loc_1C62E:
lea rdi, [rsp+268h+var_1A8]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
lea rdi, [rsp+268h+var_190]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
lea rsi, [rsp+268h+var_98]
lea rdi, [rsp+268h+var_1B0]
call _ZNK2cv7MatSizeclEv; cv::MatSize::operator()(void)
jmp short $+2
loc_1C65F:
mov rsi, [rsp+268h+var_8]
add rsi, 40h ; '@'
lea rdi, [rsp+268h+var_1B8]
call _ZNK2cv7MatSizeclEv; cv::MatSize::operator()(void)
jmp short $+2
loc_1C67A:
lea rdi, [rsp+268h+var_1B0]
lea rsi, [rsp+268h+var_1B8]
call _ZN2cvneIiEEbRKNS_5Size_IT_EES5_; cv::operator!=<int>(cv::Size_<int> const&,cv::Size_<int> const&)
mov [rsp+268h+var_259], al
jmp short $+2
loc_1C695:
mov al, [rsp+268h+var_259]
test al, 1
jnz short loc_1C6A2
jmp loc_1C824
loc_1C6A2:
lea rdi, [rsp+268h+var_1D0]; this
lea rsi, [rsp+268h+var_D8]; cv::Mat *
call _ZN2cv11_InputArrayC2ERKNS_3MatE; cv::_InputArray::_InputArray(cv::Mat const&)
jmp short $+2
loc_1C6B9:
lea rdi, [rsp+268h+var_1E8]; this
lea rsi, [rsp+268h+var_D8]; cv::Mat *
call _ZN2cv12_OutputArrayC2ERNS_3MatE; cv::_OutputArray::_OutputArray(cv::Mat &)
jmp short $+2
loc_1C6D0:
mov rsi, [rsp+268h+var_8]
add rsi, 40h ; '@'
lea rdi, [rsp+268h+var_1F0]
call _ZNK2cv7MatSizeclEv; cv::MatSize::operator()(void)
jmp short $+2
loc_1C6E8:
lea rdi, [rsp+268h+var_1D0]
lea rsi, [rsp+268h+var_1E8]
lea rdx, [rsp+268h+var_1F0]
vpxor xmm1, xmm1, xmm1
mov ecx, 1
vmovaps xmm0, xmm1
call __ZN2cv6resizeERKNS_11_InputArrayERKNS_12_OutputArrayENS_5Size_IiEEddi; cv::resize(cv::_InputArray const&,cv::_OutputArray const&,cv::Size_<int>,double,double,int)
jmp short $+2
loc_1C711:
lea rdi, [rsp+268h+var_1E8]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
lea rdi, [rsp+268h+var_1D0]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
jmp loc_1C824
mov rcx, rax
mov eax, edx
mov [rsp+arg_108], rcx
mov [rsp+arg_104], eax
jmp loc_1C97F
mov rcx, rax
mov eax, edx
mov [rsp+arg_108], rcx
mov [rsp+arg_104], eax
jmp short loc_1C780
mov rcx, rax
mov eax, edx
mov [rsp+arg_108], rcx
mov [rsp+arg_104], eax
lea rdi, [rsp+arg_E8]; this
call _ZN2cv17_InputOutputArrayD2Ev; cv::_InputOutputArray::~_InputOutputArray()
loc_1C780:
lea rdi, [rsp+arg_110]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
jmp loc_1C97F
mov rcx, rax
mov eax, edx
mov [rsp+arg_108], rcx
mov [rsp+arg_104], eax
jmp short loc_1C7C9
mov rcx, rax
mov eax, edx
mov [rsp+arg_108], rcx
mov [rsp+arg_104], eax
lea rdi, [rsp+arg_B8]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
loc_1C7C9:
lea rdi, [rsp+arg_D0]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
jmp loc_1C97F
mov rcx, rax
mov eax, edx
mov [rsp+arg_108], rcx
mov [rsp+arg_104], eax
jmp short loc_1C812
mov rcx, rax
mov eax, edx
mov [rsp+arg_108], rcx
mov [rsp+arg_104], eax
lea rdi, [rsp+arg_78]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
loc_1C812:
lea rdi, [rsp+arg_90]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
jmp loc_1C97F
loc_1C824:
mov rsi, [rsp+268h+var_8]; cv::Mat *
lea rdi, [rsp+268h+var_208]; this
call _ZN2cv11_InputArrayC2ERKNS_3MatE; cv::_InputArray::_InputArray(cv::Mat const&)
jmp short $+2
loc_1C838:
lea rdi, [rsp+268h+var_220]; this
lea rsi, [rsp+268h+var_D8]; cv::Mat *
call _ZN2cv11_InputArrayC2ERKNS_3MatE; cv::_InputArray::_InputArray(cv::Mat const&)
jmp short $+2
loc_1C84C:
lea rdi, [rsp+268h+var_238]; this
lea rsi, [rsp+268h+var_138]; cv::Mat *
call _ZN2cv12_OutputArrayC2ERNS_3MatE; cv::_OutputArray::_OutputArray(cv::Mat &)
jmp short $+2
loc_1C860:
lea rdi, [rsp+268h+var_208]
lea rsi, [rsp+268h+var_220]
lea rdx, [rsp+268h+var_238]
call __ZN2cv7hconcatERKNS_11_InputArrayES2_RKNS_12_OutputArrayE; cv::hconcat(cv::_InputArray const&,cv::_InputArray const&,cv::_OutputArray const&)
jmp short $+2
loc_1C876:
lea rdi, [rsp+268h+var_238]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
lea rdi, [rsp+268h+var_220]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
lea rdi, [rsp+268h+var_208]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
mov rax, [rsp+268h+var_18]
mov [rsp+268h+var_268], rax
lea rdi, [rsp+268h+var_250]; this
lea rsi, [rsp+268h+var_138]; cv::Mat *
call _ZN2cv11_InputArrayC2ERKNS_3MatE; cv::_InputArray::_InputArray(cv::Mat const&)
jmp short $+2
loc_1C8B4:
mov rdi, [rsp+268h+var_268]
mov rax, [rdi]
mov rax, [rax+38h]
lea rsi, [rsp+268h+var_250]
call rax
jmp short $+2
loc_1C8C8:
lea rdi, [rsp+268h+var_250]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
lea rdi, [rsp+268h+var_138]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
lea rdi, [rsp+268h+var_D8]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
lea rdi, [rsp+268h+var_78]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
loc_1C8F9:
add rsp, 268h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_108], rcx
mov [rsp+arg_104], eax
jmp short loc_1C955
mov rcx, rax
mov eax, edx
mov [rsp+arg_108], rcx
mov [rsp+arg_104], eax
jmp short loc_1C94B
mov rcx, rax
mov eax, edx
mov [rsp+arg_108], rcx
mov [rsp+arg_104], eax
lea rdi, [rsp+arg_28]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
loc_1C94B:
lea rdi, [rsp+arg_40]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
loc_1C955:
lea rdi, [rsp+arg_58]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
jmp short loc_1C97F
mov rcx, rax
mov eax, edx
mov [rsp+arg_108], rcx
mov [rsp+arg_104], eax
lea rdi, [rsp+arg_10]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
loc_1C97F:
lea rdi, [rsp+arg_128]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
lea rdi, [rsp+arg_188]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
lea rdi, [rsp+arg_1E8]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
mov rdi, [rsp+arg_108]
call __Unwind_Resume
| void processAndWriteFrame(const cv::Mat *a1, const cv::Mat *a2, cv::VideoWriter *a3, __m128 _XMM0)
{
const cv::_InputArray *v6; // r9
int v7; // ecx
const cv::_OutputArray *v10; // rcx
cv::VideoWriter *v11; // [rsp+0h] [rbp-268h]
int v12; // [rsp+10h] [rbp-258h]
_BYTE v13[24]; // [rsp+18h] [rbp-250h] BYREF
_BYTE v14[24]; // [rsp+30h] [rbp-238h] BYREF
_BYTE v15[24]; // [rsp+48h] [rbp-220h] BYREF
_BYTE v16[24]; // [rsp+60h] [rbp-208h] BYREF
_BYTE v17[8]; // [rsp+78h] [rbp-1F0h] BYREF
_BYTE v18[24]; // [rsp+80h] [rbp-1E8h] BYREF
_BYTE v19[24]; // [rsp+98h] [rbp-1D0h] BYREF
_BYTE v20[8]; // [rsp+B0h] [rbp-1B8h] BYREF
_BYTE v21[8]; // [rsp+B8h] [rbp-1B0h] BYREF
_BYTE v22[24]; // [rsp+C0h] [rbp-1A8h] BYREF
_BYTE v23[24]; // [rsp+D8h] [rbp-190h] BYREF
_BYTE v24[40]; // [rsp+F0h] [rbp-178h] BYREF
_BYTE v25[24]; // [rsp+118h] [rbp-150h] BYREF
_BYTE v26[96]; // [rsp+130h] [rbp-138h] BYREF
_BYTE v27[64]; // [rsp+190h] [rbp-D8h] BYREF
_BYTE v28[32]; // [rsp+1D0h] [rbp-98h] BYREF
_BYTE v29[96]; // [rsp+1F0h] [rbp-78h] BYREF
cv::VideoWriter *v30; // [rsp+250h] [rbp-18h]
cv::Mat *v31; // [rsp+258h] [rbp-10h]
cv::Mat *v32; // [rsp+260h] [rbp-8h]
v32 = a1;
v31 = a2;
v30 = a3;
if ( (cv::Mat::empty(a2) & 1) != 0 )
{
std::operator<<<std::char_traits<char>>(&std::cerr, "Warning: Skipping empty depth map.\n");
}
else
{
cv::Mat::Mat((cv::Mat *)v29);
cv::Mat::Mat((cv::Mat *)v27);
cv::Mat::Mat((cv::Mat *)v26);
cv::_InputArray::_InputArray((cv::_InputArray *)v25, v31);
cv::_InputOutputArray::_InputOutputArray((cv::_InputOutputArray *)v24, (cv::Mat *)v29);
v12 = cv::noArray((cv *)v24);
__asm
{
vpxor xmm0, xmm0, xmm0
vmovsd xmm1, cs:qword_2D010
}
cv::normalize(
(cv *)v25,
(const cv::_InputArray *)v24,
(const cv::_InputOutputArray *)&qword_20,
*(double *)&_XMM0,
*(double *)&_XMM1,
0,
v12,
v6);
cv::_InputOutputArray::~_InputOutputArray((cv::_InputOutputArray *)v24);
cv::_InputArray::~_InputArray((cv::_InputArray *)v25);
cv::_InputArray::_InputArray((cv::_InputArray *)v23, (const cv::Mat *)v29);
cv::_OutputArray::_OutputArray((cv::_OutputArray *)v22, (cv::Mat *)v27);
cv::applyColorMap((cv *)v23, (const cv::_InputArray *)v22, (const cv::_OutputArray *)((char *)&dword_0 + 2), v7);
cv::_OutputArray::~_OutputArray((cv::_OutputArray *)v22);
cv::_InputArray::~_InputArray((cv::_InputArray *)v23);
cv::MatSize::operator()(v21, v28);
cv::MatSize::operator()(v20, (char *)v32 + 64);
if ( (cv::operator!=<int>(v21, v20) & 1) != 0 )
{
cv::_InputArray::_InputArray((cv::_InputArray *)v19, (const cv::Mat *)v27);
cv::_OutputArray::_OutputArray((cv::_OutputArray *)v18, (cv::Mat *)v27);
cv::MatSize::operator()(v17, (char *)v32 + 64);
__asm
{
vpxor xmm1, xmm1, xmm1
vmovaps xmm0, xmm1
}
cv::resize(v19, v18, v17, 1LL, *(double *)&_XMM0);
cv::_OutputArray::~_OutputArray((cv::_OutputArray *)v18);
cv::_InputArray::~_InputArray((cv::_InputArray *)v19);
}
cv::_InputArray::_InputArray((cv::_InputArray *)v16, v32);
cv::_InputArray::_InputArray((cv::_InputArray *)v15, (const cv::Mat *)v27);
cv::_OutputArray::_OutputArray((cv::_OutputArray *)v14, (cv::Mat *)v26);
cv::hconcat((cv *)v16, (const cv::_InputArray *)v15, (const cv::_InputArray *)v14, v10);
cv::_OutputArray::~_OutputArray((cv::_OutputArray *)v14);
cv::_InputArray::~_InputArray((cv::_InputArray *)v15);
cv::_InputArray::~_InputArray((cv::_InputArray *)v16);
v11 = v30;
cv::_InputArray::_InputArray((cv::_InputArray *)v13, (const cv::Mat *)v26);
(*(void ( **)(cv::VideoWriter *, _BYTE *))(*(_QWORD *)v11 + 56LL))(v11, v13);
cv::_InputArray::~_InputArray((cv::_InputArray *)v13);
cv::Mat::~Mat((cv::Mat *)v26);
cv::Mat::~Mat((cv::Mat *)v27);
cv::Mat::~Mat((cv::Mat *)v29);
}
}
| processAndWriteFrame:
SUB RSP,0x268
MOV qword ptr [RSP + 0x260],RDI
MOV qword ptr [RSP + 0x258],RSI
MOV qword ptr [RSP + 0x250],RDX
MOV RDI,qword ptr [RSP + 0x258]
CALL 0x001191e0
TEST AL,0x1
JNZ 0x0011c522
JMP 0x0011c53a
LAB_0011c522:
MOV RDI,qword ptr [0x00136fc8]
LEA RSI,[0x12d1b1]
CALL 0x00119480
JMP 0x0011c8f9
LAB_0011c53a:
LEA RDI,[RSP + 0x1f0]
CALL 0x00119050
LEA RDI,[RSP + 0x190]
CALL 0x00119050
LEA RDI,[RSP + 0x130]
CALL 0x00119050
MOV RSI,qword ptr [RSP + 0x258]
LAB_0011c569:
LEA RDI,[RSP + 0x118]
CALL 0x0011fc80
JMP 0x0011c578
LAB_0011c578:
LEA RDI,[RSP + 0xf0]
LEA RSI,[RSP + 0x1f0]
CALL 0x00120eb0
JMP 0x0011c58f
LAB_0011c58f:
CALL 0x001193e0
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0011c59b
LAB_0011c59b:
MOV R8,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x118]
LEA RSI,[RSP + 0xf0]
VPXOR XMM0,XMM0,XMM0
VMOVSD XMM1,qword ptr [0x0012d010]
MOV EDX,0x20
XOR ECX,ECX
CALL 0x00119260
JMP 0x0011c5ca
LAB_0011c5ca:
LEA RDI,[RSP + 0xf0]
CALL 0x00120ef0
LEA RDI,[RSP + 0x118]
CALL 0x0011fd00
LAB_0011c5e4:
LEA RDI,[RSP + 0xd8]
LEA RSI,[RSP + 0x1f0]
CALL 0x0011fc80
JMP 0x0011c5fb
LAB_0011c5fb:
LEA RDI,[RSP + 0xc0]
LEA RSI,[RSP + 0x190]
CALL 0x0011fc00
JMP 0x0011c612
LAB_0011c612:
LEA RDI,[RSP + 0xd8]
LEA RSI,[RSP + 0xc0]
MOV EDX,0x2
CALL 0x00119170
JMP 0x0011c62e
LAB_0011c62e:
LEA RDI,[RSP + 0xc0]
CALL 0x0011fc60
LEA RDI,[RSP + 0xd8]
CALL 0x0011fd00
LEA RSI,[RSP + 0x1d0]
LAB_0011c650:
LEA RDI,[RSP + 0xb8]
CALL 0x001209a0
JMP 0x0011c65f
LAB_0011c65f:
MOV RSI,qword ptr [RSP + 0x260]
ADD RSI,0x40
LEA RDI,[RSP + 0xb0]
CALL 0x001209a0
JMP 0x0011c67a
LAB_0011c67a:
LEA RDI,[RSP + 0xb8]
LEA RSI,[RSP + 0xb0]
CALL 0x0011c9c0
MOV byte ptr [RSP + 0xf],AL
JMP 0x0011c695
LAB_0011c695:
MOV AL,byte ptr [RSP + 0xf]
TEST AL,0x1
JNZ 0x0011c6a2
JMP 0x0011c824
LAB_0011c6a2:
LEA RDI,[RSP + 0x98]
LEA RSI,[RSP + 0x190]
CALL 0x0011fc80
JMP 0x0011c6b9
LAB_0011c6b9:
LEA RDI,[RSP + 0x80]
LEA RSI,[RSP + 0x190]
CALL 0x0011fc00
JMP 0x0011c6d0
LAB_0011c6d0:
MOV RSI,qword ptr [RSP + 0x260]
ADD RSI,0x40
LAB_0011c6dc:
LEA RDI,[RSP + 0x78]
CALL 0x001209a0
JMP 0x0011c6e8
LAB_0011c6e8:
LEA RDI,[RSP + 0x98]
LEA RSI,[RSP + 0x80]
LEA RDX,[RSP + 0x78]
VPXOR XMM1,XMM1,XMM1
MOV ECX,0x1
VMOVAPS XMM0,XMM1
CALL 0x00119510
JMP 0x0011c711
LAB_0011c711:
LEA RDI,[RSP + 0x80]
CALL 0x0011fc60
LEA RDI,[RSP + 0x98]
CALL 0x0011fd00
JMP 0x0011c824
LAB_0011c824:
MOV RSI,qword ptr [RSP + 0x260]
LAB_0011c82c:
LEA RDI,[RSP + 0x60]
CALL 0x0011fc80
JMP 0x0011c838
LAB_0011c838:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x190]
CALL 0x0011fc80
JMP 0x0011c84c
LAB_0011c84c:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x130]
CALL 0x0011fc00
JMP 0x0011c860
LAB_0011c860:
LEA RDI,[RSP + 0x60]
LEA RSI,[RSP + 0x48]
LEA RDX,[RSP + 0x30]
CALL 0x001192c0
JMP 0x0011c876
LAB_0011c876:
LEA RDI,[RSP + 0x30]
CALL 0x0011fc60
LEA RDI,[RSP + 0x48]
CALL 0x0011fd00
LEA RDI,[RSP + 0x60]
CALL 0x0011fd00
MOV RAX,qword ptr [RSP + 0x250]
MOV qword ptr [RSP],RAX
LAB_0011c8a0:
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0x130]
CALL 0x0011fc80
JMP 0x0011c8b4
LAB_0011c8b4:
MOV RDI,qword ptr [RSP]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x38]
LAB_0011c8bf:
LEA RSI,[RSP + 0x18]
CALL RAX
LAB_0011c8c6:
JMP 0x0011c8c8
LAB_0011c8c8:
LEA RDI,[RSP + 0x18]
CALL 0x0011fd00
LEA RDI,[RSP + 0x130]
CALL 0x00119080
LEA RDI,[RSP + 0x190]
CALL 0x00119080
LEA RDI,[RSP + 0x1f0]
CALL 0x00119080
LAB_0011c8f9:
ADD RSP,0x268
RET
|
/* processAndWriteFrame(cv::Mat const&, cv::Mat const&, cv::VideoWriter&) */
void processAndWriteFrame(Mat *param_1,Mat *param_2,VideoWriter *param_3)
{
VideoWriter *pVVar1;
bool bVar2;
ulong uVar3;
_InputArray *p_Var4;
_InputArray local_250 [24];
_OutputArray local_238 [24];
_InputArray local_220 [24];
_InputArray local_208 [24];
MatSize local_1f0 [8];
_OutputArray local_1e8 [24];
_InputArray local_1d0 [24];
MatSize local_1b8 [8];
MatSize local_1b0 [8];
_OutputArray local_1a8 [24];
_InputArray local_190 [24];
_InputOutputArray local_178 [40];
_InputArray local_150 [24];
Mat local_138 [96];
Mat local_d8 [96];
Mat local_78 [96];
VideoWriter *local_18;
Mat *local_10;
Mat *local_8;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
uVar3 = cv::Mat::empty();
if ((uVar3 & 1) == 0) {
cv::Mat::Mat(local_78);
cv::Mat::Mat(local_d8);
cv::Mat::Mat(local_138);
/* try { // try from 0011c569 to 0011c575 has its CatchHandler @ 0011c730 */
cv::_InputArray::_InputArray(local_150,local_10);
/* try { // try from 0011c578 to 0011c58c has its CatchHandler @ 0011c749 */
cv::_InputOutputArray::_InputOutputArray(local_178,local_78);
/* try { // try from 0011c58f to 0011c5c7 has its CatchHandler @ 0011c75f */
p_Var4 = (_InputArray *)cv::noArray();
cv::normalize(local_150,local_178,0.0,DAT_0012d010,0x20,0,p_Var4);
cv::_InputOutputArray::~_InputOutputArray(local_178);
cv::_InputArray::~_InputArray(local_150);
/* try { // try from 0011c5e4 to 0011c5f8 has its CatchHandler @ 0011c730 */
cv::_InputArray::_InputArray(local_190,local_78);
/* try { // try from 0011c5fb to 0011c60f has its CatchHandler @ 0011c792 */
cv::_OutputArray::_OutputArray(local_1a8,local_d8);
/* try { // try from 0011c612 to 0011c62b has its CatchHandler @ 0011c7a8 */
cv::applyColorMap(local_190,local_1a8,2);
cv::_OutputArray::~_OutputArray(local_1a8);
cv::_InputArray::~_InputArray(local_190);
/* try { // try from 0011c650 to 0011c6b6 has its CatchHandler @ 0011c730 */
cv::MatSize::operator()(local_1b0);
cv::MatSize::operator()(local_1b8);
bVar2 = cv::operator!=((Size_ *)local_1b0,(Size_ *)local_1b8);
if (bVar2) {
cv::_InputArray::_InputArray(local_1d0,local_d8);
/* try { // try from 0011c6b9 to 0011c6cd has its CatchHandler @ 0011c7db */
cv::_OutputArray::_OutputArray(local_1e8,local_d8);
/* try { // try from 0011c6dc to 0011c70e has its CatchHandler @ 0011c7f1 */
cv::MatSize::operator()(local_1f0);
cv::resize(0,local_1d0,local_1e8,local_1f0,1);
cv::_OutputArray::~_OutputArray(local_1e8);
cv::_InputArray::~_InputArray(local_1d0);
}
/* try { // try from 0011c82c to 0011c835 has its CatchHandler @ 0011c730 */
cv::_InputArray::_InputArray(local_208,local_8);
/* try { // try from 0011c838 to 0011c849 has its CatchHandler @ 0011c901 */
cv::_InputArray::_InputArray(local_220,local_d8);
/* try { // try from 0011c84c to 0011c85d has its CatchHandler @ 0011c917 */
cv::_OutputArray::_OutputArray(local_238,local_138);
/* try { // try from 0011c860 to 0011c873 has its CatchHandler @ 0011c92d */
cv::hconcat(local_208,local_220,local_238);
cv::_OutputArray::~_OutputArray(local_238);
cv::_InputArray::~_InputArray(local_220);
cv::_InputArray::~_InputArray(local_208);
pVVar1 = local_18;
/* try { // try from 0011c8a0 to 0011c8b1 has its CatchHandler @ 0011c730 */
cv::_InputArray::_InputArray(local_250,local_138);
/* try { // try from 0011c8bf to 0011c8c5 has its CatchHandler @ 0011c961 */
(**(code **)(*(long *)pVVar1 + 0x38))(pVVar1,local_250);
cv::_InputArray::~_InputArray(local_250);
cv::Mat::~Mat(local_138);
cv::Mat::~Mat(local_d8);
cv::Mat::~Mat(local_78);
}
else {
std::operator<<((ostream *)PTR_cerr_00136fc8,"Warning: Skipping empty depth map.\n");
}
return;
}
| |
28,491 | js_async_generator_resolve_function | bluesky950520[P]quickjs/quickjs.c | static JSValue js_async_generator_resolve_function(JSContext *ctx,
JSValue this_obj,
int argc, JSValue *argv,
int magic, JSValue *func_data)
{
BOOL is_reject = magic & 1;
JSAsyncGeneratorData *s = JS_GetOpaque(func_data[0], JS_CLASS_ASYNC_GENERATOR);
JSValue arg = argv[0];
/* XXX: what if s == NULL */
if (magic >= 2) {
/* resume next case in AWAITING_RETURN state */
assert(s->state == JS_ASYNC_GENERATOR_STATE_AWAITING_RETURN ||
s->state == JS_ASYNC_GENERATOR_STATE_COMPLETED);
s->state = JS_ASYNC_GENERATOR_STATE_COMPLETED;
if (is_reject) {
js_async_generator_reject(ctx, s, arg);
} else {
js_async_generator_resolve(ctx, s, arg, TRUE);
}
} else {
/* restart function execution after await() */
assert(s->state == JS_ASYNC_GENERATOR_STATE_EXECUTING);
s->func_state.throw_flag = is_reject;
if (is_reject) {
JS_Throw(ctx, js_dup(arg));
} else {
/* return value of await */
s->func_state.frame.cur_sp[-1] = js_dup(arg);
}
js_async_generator_resume_next(ctx, s);
}
return JS_UNDEFINED;
} | O1 | c | js_async_generator_resolve_function:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
movl 0x8(%rax), %eax
movsd %xmm0, (%rsp)
cmpl $-0x1, %eax
jne 0x55ddc
movq (%rsp), %rax
cmpw $0x39, 0x6(%rax)
jne 0x55ddc
movq 0x30(%rax), %r14
jmp 0x55ddf
xorl %r14d, %r14d
movl %r9d, %eax
andl $0x1, %eax
movq (%r8), %r12
movq 0x8(%r8), %r15
cmpl $0x2, %r9d
jl 0x55e17
movl $0x5, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
movl $0x1, %r8d
testl %eax, %eax
jne 0x55e3d
callq 0x55a90
jmp 0x55e8b
movl %eax, 0x24(%r14)
testl %eax, %eax
jne 0x55e44
movq 0x70(%r14), %rbp
movq %r12, (%rsp)
cmpl $-0x9, %r15d
jb 0x55e33
movq (%rsp), %rax
incl (%rax)
movq %r12, -0x10(%rbp)
addq $-0x8, %rbp
jmp 0x55e7c
callq 0x55c30
jmp 0x55e8b
movq %r12, (%rsp)
cmpl $-0x9, %r15d
jb 0x55e54
movq (%rsp), %rax
incl (%rax)
movq 0x18(%rbx), %r13
leaq 0xf8(%r13), %rbp
movq 0xf0(%r13), %rsi
movq 0xf8(%r13), %rdx
movq %r13, %rdi
callq 0x1d8c6
movq %r12, 0xf0(%r13)
movq %r15, (%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x556ae
movl $0x3, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_async_generator_resolve_function:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov rax, [rsp+38h+arg_0]
movsd xmm0, qword ptr [rax]
mov eax, [rax+8]
movsd [rsp+38h+var_38], xmm0
cmp eax, 0FFFFFFFFh
jnz short loc_55DDC
mov rax, [rsp+38h+var_38]
cmp word ptr [rax+6], 39h ; '9'
jnz short loc_55DDC
mov r14, [rax+30h]
jmp short loc_55DDF
loc_55DDC:
xor r14d, r14d
loc_55DDF:
mov eax, r9d
and eax, 1
mov r12, [r8]
mov r15, [r8+8]
cmp r9d, 2
jl short loc_55E17
mov dword ptr [r14+8], 5
mov rdi, rbx
mov rsi, r14
mov rdx, r12
mov rcx, r15
mov r8d, 1
test eax, eax
jnz short loc_55E3D
call js_async_generator_resolve
jmp short loc_55E8B
loc_55E17:
mov [r14+24h], eax
test eax, eax
jnz short loc_55E44
mov rbp, [r14+70h]
mov [rsp+38h+var_38], r12
cmp r15d, 0FFFFFFF7h
jb short loc_55E33
mov rax, [rsp+38h+var_38]
inc dword ptr [rax]
loc_55E33:
mov [rbp-10h], r12
add rbp, 0FFFFFFFFFFFFFFF8h
jmp short loc_55E7C
loc_55E3D:
call js_async_generator_resolve_or_reject
jmp short loc_55E8B
loc_55E44:
mov [rsp+38h+var_38], r12
cmp r15d, 0FFFFFFF7h
jb short loc_55E54
mov rax, [rsp+38h+var_38]
inc dword ptr [rax]
loc_55E54:
mov r13, [rbx+18h]
lea rbp, [r13+0F8h]
mov rsi, [r13+0F0h]
mov rdx, [r13+0F8h]
mov rdi, r13
call JS_FreeValueRT
mov [r13+0F0h], r12
loc_55E7C:
mov [rbp+0], r15
mov rdi, rbx
mov rsi, r14
call js_async_generator_resume_next
loc_55E8B:
mov edx, 3
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_async_generator_resolve_function(
long long a1,
double a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14,
unsigned long long *a15)
{
__m128 v15; // xmm0
long long v16; // r14
_DWORD *v17; // r12
long long v18; // r15
long long v19; // rbp
long long *v20; // rbp
long long v21; // r13
long long v23; // [rsp+0h] [rbp-38h]
v15 = (__m128)*a15;
v23 = *a15;
if ( *((_DWORD *)a15 + 2) == -1 && *(_WORD *)(v23 + 6) == 57 )
v16 = *(_QWORD *)(v23 + 48);
else
v16 = 0LL;
v17 = *(_DWORD **)a13;
v18 = *(_QWORD *)(a13 + 8);
if ( (int)a14 < 2 )
{
*(_DWORD *)(v16 + 36) = a14 & 1;
if ( (a14 & 1) != 0 )
{
if ( (unsigned int)v18 >= 0xFFFFFFF7 )
++*v17;
v21 = *(_QWORD *)(a1 + 24);
v20 = (long long *)(v21 + 248);
JS_FreeValueRT(v21, *(_DWORD **)(v21 + 240), *(_QWORD *)(v21 + 248));
*(_QWORD *)(v21 + 240) = v17;
}
else
{
v19 = *(_QWORD *)(v16 + 112);
if ( (unsigned int)v18 >= 0xFFFFFFF7 )
++*v17;
*(_QWORD *)(v19 - 16) = v17;
v20 = (long long *)(v19 - 8);
}
*v20 = v18;
js_async_generator_resume_next((const char *)a1, v16, a11, v15, a3, a4, a5, a6, a7, a8, a9, a12, a13, a14);
}
else
{
*(_DWORD *)(v16 + 8) = 5;
if ( (a14 & 1) != 0 )
js_async_generator_resolve_or_reject(
a1,
v16,
(long long)v17,
v18,
1u,
*(double *)v15.m128_u64,
a3,
a4,
a5,
a6,
a7,
a8,
a9);
else
js_async_generator_resolve(
a1,
v16,
v17,
v18,
1,
*(double *)v15.m128_u64,
a3,
a4,
a5,
*(double *)a6.m128_u64,
*(double *)a7.m128_u64,
a8,
a9);
}
return 0LL;
}
| js_async_generator_resolve_function:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RSP + 0x40]
MOVSD XMM0,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x8]
MOVSD qword ptr [RSP],XMM0
CMP EAX,-0x1
JNZ 0x00155ddc
MOV RAX,qword ptr [RSP]
CMP word ptr [RAX + 0x6],0x39
JNZ 0x00155ddc
MOV R14,qword ptr [RAX + 0x30]
JMP 0x00155ddf
LAB_00155ddc:
XOR R14D,R14D
LAB_00155ddf:
MOV EAX,R9D
AND EAX,0x1
MOV R12,qword ptr [R8]
MOV R15,qword ptr [R8 + 0x8]
CMP R9D,0x2
JL 0x00155e17
MOV dword ptr [R14 + 0x8],0x5
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R12
MOV RCX,R15
MOV R8D,0x1
TEST EAX,EAX
JNZ 0x00155e3d
CALL 0x00155a90
JMP 0x00155e8b
LAB_00155e17:
MOV dword ptr [R14 + 0x24],EAX
TEST EAX,EAX
JNZ 0x00155e44
MOV RBP,qword ptr [R14 + 0x70]
MOV qword ptr [RSP],R12
CMP R15D,-0x9
JC 0x00155e33
MOV RAX,qword ptr [RSP]
INC dword ptr [RAX]
LAB_00155e33:
MOV qword ptr [RBP + -0x10],R12
ADD RBP,-0x8
JMP 0x00155e7c
LAB_00155e3d:
CALL 0x00155c30
JMP 0x00155e8b
LAB_00155e44:
MOV qword ptr [RSP],R12
CMP R15D,-0x9
JC 0x00155e54
MOV RAX,qword ptr [RSP]
INC dword ptr [RAX]
LAB_00155e54:
MOV R13,qword ptr [RBX + 0x18]
LEA RBP,[R13 + 0xf8]
MOV RSI,qword ptr [R13 + 0xf0]
MOV RDX,qword ptr [R13 + 0xf8]
MOV RDI,R13
CALL 0x0011d8c6
MOV qword ptr [R13 + 0xf0],R12
LAB_00155e7c:
MOV qword ptr [RBP],R15
MOV RDI,RBX
MOV RSI,R14
CALL 0x001556ae
LAB_00155e8b:
MOV EDX,0x3
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16] js_async_generator_resolve_function(long param_1)
{
int *piVar1;
int8 uVar2;
long lVar3;
uint uVar4;
int8 *puVar5;
int8 *in_R8;
uint in_R9D;
long lVar6;
long *in_stack_00000008;
if (((int)in_stack_00000008[1] == -1) && (*(short *)(*in_stack_00000008 + 6) == 0x39)) {
lVar6 = *(long *)(*in_stack_00000008 + 0x30);
}
else {
lVar6 = 0;
}
uVar4 = in_R9D & 1;
piVar1 = (int *)*in_R8;
uVar2 = in_R8[1];
if ((int)in_R9D < 2) {
*(uint *)(lVar6 + 0x24) = uVar4;
if (uVar4 == 0) {
lVar3 = *(long *)(lVar6 + 0x70);
if (0xfffffff6 < (uint)uVar2) {
*piVar1 = *piVar1 + 1;
}
*(int **)(lVar3 + -0x10) = piVar1;
puVar5 = (int8 *)(lVar3 + -8);
}
else {
if (0xfffffff6 < (uint)uVar2) {
*piVar1 = *piVar1 + 1;
}
lVar3 = *(long *)(param_1 + 0x18);
puVar5 = (int8 *)(lVar3 + 0xf8);
JS_FreeValueRT(lVar3,*(int8 *)(lVar3 + 0xf0),*(int8 *)(lVar3 + 0xf8));
*(int **)(lVar3 + 0xf0) = piVar1;
}
*puVar5 = uVar2;
js_async_generator_resume_next(param_1,lVar6);
}
else {
*(int4 *)(lVar6 + 8) = 5;
if (uVar4 == 0) {
js_async_generator_resolve();
}
else {
js_async_generator_resolve_or_reject(param_1,lVar6,piVar1,uVar2,1);
}
}
return ZEXT816(3) << 0x40;
}
| |
28,492 | js_async_generator_resolve_function | bluesky950520[P]quickjs/quickjs.c | static JSValue js_async_generator_resolve_function(JSContext *ctx,
JSValue this_obj,
int argc, JSValue *argv,
int magic, JSValue *func_data)
{
BOOL is_reject = magic & 1;
JSAsyncGeneratorData *s = JS_GetOpaque(func_data[0], JS_CLASS_ASYNC_GENERATOR);
JSValue arg = argv[0];
/* XXX: what if s == NULL */
if (magic >= 2) {
/* resume next case in AWAITING_RETURN state */
assert(s->state == JS_ASYNC_GENERATOR_STATE_AWAITING_RETURN ||
s->state == JS_ASYNC_GENERATOR_STATE_COMPLETED);
s->state = JS_ASYNC_GENERATOR_STATE_COMPLETED;
if (is_reject) {
js_async_generator_reject(ctx, s, arg);
} else {
js_async_generator_resolve(ctx, s, arg, TRUE);
}
} else {
/* restart function execution after await() */
assert(s->state == JS_ASYNC_GENERATOR_STATE_EXECUTING);
s->func_state.throw_flag = is_reject;
if (is_reject) {
JS_Throw(ctx, js_dup(arg));
} else {
/* return value of await */
s->func_state.frame.cur_sp[-1] = js_dup(arg);
}
js_async_generator_resume_next(ctx, s);
}
return JS_UNDEFINED;
} | O2 | c | js_async_generator_resolve_function:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rsp), %rax
cmpl $-0x1, 0x8(%rax)
jne 0x49977
movq (%rax), %rax
cmpw $0x39, 0x6(%rax)
jne 0x49977
movq 0x30(%rax), %r14
jmp 0x4997a
xorl %r14d, %r14d
movl %r9d, %eax
andl $0x1, %eax
movq (%r8), %rdx
movq 0x8(%r8), %rcx
cmpl $0x2, %r9d
jl 0x499aa
movl $0x5, 0x8(%r14)
testl %eax, %eax
jne 0x499c7
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x497a5
jmp 0x499f4
movl %eax, 0x24(%r14)
testl %eax, %eax
jne 0x499d4
movq 0x70(%r14), %rax
cmpl $-0x9, %ecx
jb 0x499bd
incl (%rdx)
movq %rdx, -0x10(%rax)
movq %rcx, -0x8(%rax)
jmp 0x499e9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x497fe
jmp 0x499f4
cmpl $-0x9, %ecx
jb 0x499db
incl (%rdx)
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x1c446
movq %rbx, %rdi
movq %r14, %rsi
callq 0x49365
pushq $0x3
popq %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| js_async_generator_resolve_function:
push r14
push rbx
push rax
mov rbx, rdi
mov rax, [rsp+18h+arg_0]
cmp dword ptr [rax+8], 0FFFFFFFFh
jnz short loc_49977
mov rax, [rax]
cmp word ptr [rax+6], 39h ; '9'
jnz short loc_49977
mov r14, [rax+30h]
jmp short loc_4997A
loc_49977:
xor r14d, r14d
loc_4997A:
mov eax, r9d
and eax, 1
mov rdx, [r8]
mov rcx, [r8+8]
cmp r9d, 2
jl short loc_499AA
mov dword ptr [r14+8], 5
test eax, eax
jnz short loc_499C7
push 1
pop r8
mov rdi, rbx
mov rsi, r14
call js_async_generator_resolve
jmp short loc_499F4
loc_499AA:
mov [r14+24h], eax
test eax, eax
jnz short loc_499D4
mov rax, [r14+70h]
cmp ecx, 0FFFFFFF7h
jb short loc_499BD
inc dword ptr [rdx]
loc_499BD:
mov [rax-10h], rdx
mov [rax-8], rcx
jmp short loc_499E9
loc_499C7:
mov rdi, rbx
mov rsi, r14
call js_async_generator_reject
jmp short loc_499F4
loc_499D4:
cmp ecx, 0FFFFFFF7h
jb short loc_499DB
inc dword ptr [rdx]
loc_499DB:
mov rdi, rbx
mov rsi, rdx
mov rdx, rcx
call JS_Throw
loc_499E9:
mov rdi, rbx
mov rsi, r14
call js_async_generator_resume_next
loc_499F4:
push 3
pop rdx
xor eax, eax
add rsp, 8
pop rbx
pop r14
retn
| long long js_async_generator_resolve_function(
const char *a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14,
_DWORD *a15)
{
long long v15; // r14
_DWORD *v16; // rdx
long long v17; // rcx
long long v18; // rax
if ( a15[2] == -1 && *(_WORD *)(*(_QWORD *)a15 + 6LL) == 57 )
v15 = *(_QWORD *)(*(_QWORD *)a15 + 48LL);
else
v15 = 0LL;
v16 = *(_DWORD **)a13;
v17 = *(_QWORD *)(a13 + 8);
if ( (int)a14 < 2 )
{
*(_DWORD *)(v15 + 36) = a14 & 1;
if ( (a14 & 1) != 0 )
{
if ( (unsigned int)v17 >= 0xFFFFFFF7 )
++*v16;
JS_Throw((long long)a1, (long long)v16, v17);
}
else
{
v18 = *(_QWORD *)(v15 + 112);
if ( (unsigned int)v17 >= 0xFFFFFFF7 )
++*v16;
*(_QWORD *)(v18 - 16) = v16;
*(_QWORD *)(v18 - 8) = v17;
}
js_async_generator_resume_next(a1, v15, (long long)v16, a2, a3, a4, a5, a6, a7, a8, a9, v17, a13, a14);
}
else
{
*(_DWORD *)(v15 + 8) = 5;
if ( (a14 & 1) != 0 )
js_async_generator_reject((long long)a1, v15, (long long)v16, v17);
else
js_async_generator_resolve(
(long long)a1,
v15,
v16,
v17,
1,
*(double *)a2.m128_u64,
a3,
a4,
a5,
*(double *)a6.m128_u64,
*(double *)a7.m128_u64,
a8,
a9);
}
return 0LL;
}
| js_async_generator_resolve_function:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RSP + 0x20]
CMP dword ptr [RAX + 0x8],-0x1
JNZ 0x00149977
MOV RAX,qword ptr [RAX]
CMP word ptr [RAX + 0x6],0x39
JNZ 0x00149977
MOV R14,qword ptr [RAX + 0x30]
JMP 0x0014997a
LAB_00149977:
XOR R14D,R14D
LAB_0014997a:
MOV EAX,R9D
AND EAX,0x1
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
CMP R9D,0x2
JL 0x001499aa
MOV dword ptr [R14 + 0x8],0x5
TEST EAX,EAX
JNZ 0x001499c7
PUSH 0x1
POP R8
MOV RDI,RBX
MOV RSI,R14
CALL 0x001497a5
JMP 0x001499f4
LAB_001499aa:
MOV dword ptr [R14 + 0x24],EAX
TEST EAX,EAX
JNZ 0x001499d4
MOV RAX,qword ptr [R14 + 0x70]
CMP ECX,-0x9
JC 0x001499bd
INC dword ptr [RDX]
LAB_001499bd:
MOV qword ptr [RAX + -0x10],RDX
MOV qword ptr [RAX + -0x8],RCX
JMP 0x001499e9
LAB_001499c7:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001497fe
JMP 0x001499f4
LAB_001499d4:
CMP ECX,-0x9
JC 0x001499db
INC dword ptr [RDX]
LAB_001499db:
MOV RDI,RBX
MOV RSI,RDX
MOV RDX,RCX
CALL 0x0011c446
LAB_001499e9:
MOV RDI,RBX
MOV RSI,R14
CALL 0x00149365
LAB_001499f4:
PUSH 0x3
POP RDX
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
RET
|
int1 [16] js_async_generator_resolve_function(int8 param_1)
{
int *piVar1;
int8 uVar2;
long lVar3;
uint uVar4;
int8 *in_R8;
uint in_R9D;
long lVar5;
long *in_stack_00000008;
if (((int)in_stack_00000008[1] == -1) && (*(short *)(*in_stack_00000008 + 6) == 0x39)) {
lVar5 = *(long *)(*in_stack_00000008 + 0x30);
}
else {
lVar5 = 0;
}
uVar4 = in_R9D & 1;
piVar1 = (int *)*in_R8;
uVar2 = in_R8[1];
if ((int)in_R9D < 2) {
*(uint *)(lVar5 + 0x24) = uVar4;
if (uVar4 == 0) {
lVar3 = *(long *)(lVar5 + 0x70);
if (0xfffffff6 < (uint)uVar2) {
*piVar1 = *piVar1 + 1;
}
*(int **)(lVar3 + -0x10) = piVar1;
*(int8 *)(lVar3 + -8) = uVar2;
}
else {
if (0xfffffff6 < (uint)uVar2) {
*piVar1 = *piVar1 + 1;
}
JS_Throw(param_1,piVar1,uVar2);
}
js_async_generator_resume_next(param_1,lVar5);
}
else {
*(int4 *)(lVar5 + 8) = 5;
if (uVar4 == 0) {
js_async_generator_resolve(param_1,lVar5,piVar1,uVar2,1);
}
else {
js_async_generator_reject(param_1,lVar5);
}
}
return ZEXT816(3) << 0x40;
}
| |
28,493 | minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!expr) throw std::runtime_error("UnaryOpExpr.expr is null");
auto e = expr->evaluate(context);
switch (op) {
case Op::Plus: return e;
case Op::Minus: return -e;
case Op::LogicalNot: return !e.to_bool();
case Op::Expansion:
case Op::ExpansionDict:
throw std::runtime_error("Expansion operator is only supported in function calls and collections");
}
throw std::runtime_error("Unknown unary operator");
} | O2 | cpp | minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x3c8fe
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3ca02
movl 0x30(%r14), %eax
cmpq $0x4, %rax
ja 0x3c94a
leaq 0x513e1(%rip), %rcx # 0x8dc88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3cb2c
jmp 0x3c8e9
leaq 0x8(%rsp), %rdi
callq 0x3cbd8
xorb $0x1, %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x3cc74
jmp 0x3c8e9
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3cb84
leaq 0x8(%rsp), %rdi
callq 0x3cc92
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20390
movq %rax, %r14
leaq 0x53450(%rip), %rsi # 0x8fd60
movq %rax, %rdi
callq 0x20280
movq 0x946c9(%rip), %rsi # 0xd0fe8
movq 0x9463a(%rip), %rdx # 0xd0f60
movq %r14, %rdi
callq 0x20b30
pushq $0x10
popq %rdi
callq 0x20390
movq %rax, %r14
leaq 0x53439(%rip), %rsi # 0x8fd79
movq %rax, %rdi
callq 0x20280
jmp 0x3c964
pushq $0x10
popq %rdi
callq 0x20390
movq %rax, %r14
leaq 0x53464(%rip), %rsi # 0x8fdc0
movq %rax, %rdi
callq 0x20280
movq 0x9467d(%rip), %rsi # 0xd0fe8
movq 0x945ee(%rip), %rdx # 0xd0f60
movq %r14, %rdi
callq 0x20b30
jmp 0x3c97e
jmp 0x3c998
movq %rax, %rbx
movq %r14, %rdi
callq 0x20510
jmp 0x3c99b
movq %rax, %rbx
movq %r14, %rdi
callq 0x20510
jmp 0x3c9a5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3cc92
movq %rbx, %rdi
callq 0x20b90
nop
| _ZNK5minja11UnaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push r14
push rbx
sub rsp, 58h
mov r14, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz short loc_3C8FE
mov rbx, rdi
lea rdi, [rsp+68h+var_60]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov eax, [r14+30h]
cmp rax, 4; switch 5 cases
ja def_3C8AE; jumptable 000000000003C8AE default case
lea rcx, jpt_3C8AE
movsxd rax, ds:(jpt_3C8AE - 8DC88h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_3C8B0:
lea rsi, [rsp+68h+var_60]; jumptable 000000000003C8AE case 0
mov rdi, rbx
call _ZN5minja5ValueC2EOS0_; minja::Value::Value(minja::Value&&)
jmp short loc_3C8E9
loc_3C8BF:
lea rdi, [rsp+68h+var_60]; jumptable 000000000003C8AE case 2
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
xor al, 1
lea rsi, [rsp+68h+var_61]; bool *
mov [rsi], al
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKb; minja::Value::Value(bool const&)
jmp short loc_3C8E9
loc_3C8DC:
lea rsi, [rsp+68h+var_60]; jumptable 000000000003C8AE case 1
mov rdi, rbx
call _ZNK5minja5ValuengEv; minja::Value::operator-(void)
loc_3C8E9:
lea rdi, [rsp+68h+var_60]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rax, rbx
add rsp, 58h
pop rbx
pop r14
retn
loc_3C8FE:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnaryopexprExp; "UnaryOpExpr.expr is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_3C92E:
push 10h; jumptable 000000000003C8AE cases 3,4
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpansionOpera; "Expansion operator is only supported in"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_3C964
def_3C8AE:
push 10h; jumptable 000000000003C8AE default case
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnknownUnaryOp; "Unknown unary operator"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_3C964:
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_3C97E
jmp short loc_3C998
loc_3C97E:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_3C99B
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_3C9A5
loc_3C998:
mov rbx, rax
loc_3C99B:
lea rdi, [rsp+68h+var_60]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_3C9A5:
mov rdi, rbx
call __Unwind_Resume
| minja::Value * minja::UnaryOpExpr::do_evaluate(
minja::Value *this,
long long a2,
int a3,
int a4,
int a5,
int a6)
{
long long v7; // rsi
std::runtime_error *exception; // r14
std::runtime_error *v10; // r14
bool v11; // [rsp+7h] [rbp-61h] BYREF
_BYTE v12[96]; // [rsp+8h] [rbp-60h] BYREF
v7 = *(_QWORD *)(a2 + 32);
if ( !v7 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "UnaryOpExpr.expr is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((unsigned int)v12, v7, a3, a4, a5, a6);
switch ( *(_DWORD *)(a2 + 48) )
{
case 0:
minja::Value::Value(this, v12);
goto LABEL_6;
case 1:
minja::Value::operator-(this);
goto LABEL_6;
case 2:
v11 = minja::Value::to_bool((minja::Value *)v12) ^ 1;
minja::Value::Value(this, &v11);
LABEL_6:
minja::Value::~Value((minja::Value *)v12);
return this;
case 3:
case 4:
v10 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v10, "Expansion operator is only supported in function calls and collections");
break;
default:
v10 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v10, "Unknown unary operator");
break;
}
__cxa_throw(
v10,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
| do_evaluate:
PUSH R14
PUSH RBX
SUB RSP,0x58
MOV R14,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x0013c8fe
MOV RBX,RDI
LEA RDI,[RSP + 0x8]
CALL 0x0013ca02
MOV EAX,dword ptr [R14 + 0x30]
CMP RAX,0x4
JA 0x0013c94a
LEA RCX,[0x18dc88]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0013cb2c
JMP 0x0013c8e9
caseD_2:
LEA RDI,[RSP + 0x8]
CALL 0x0013cbd8
XOR AL,0x1
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],AL
MOV RDI,RBX
CALL 0x0013cc74
JMP 0x0013c8e9
caseD_1:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0013cb84
LAB_0013c8e9:
LEA RDI,[RSP + 0x8]
CALL 0x0013cc92
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R14
RET
LAB_0013c8fe:
PUSH 0x10
POP RDI
CALL 0x00120390
MOV R14,RAX
LAB_0013c909:
LEA RSI,[0x18fd60]
MOV RDI,RAX
CALL 0x00120280
LAB_0013c918:
MOV RSI,qword ptr [0x001d0fe8]
MOV RDX,qword ptr [0x001d0f60]
MOV RDI,R14
CALL 0x00120b30
caseD_3:
PUSH 0x10
POP RDI
CALL 0x00120390
MOV R14,RAX
LAB_0013c939:
LEA RSI,[0x18fd79]
MOV RDI,RAX
CALL 0x00120280
LAB_0013c948:
JMP 0x0013c964
default:
PUSH 0x10
POP RDI
CALL 0x00120390
MOV R14,RAX
LAB_0013c955:
LEA RSI,[0x18fdc0]
MOV RDI,RAX
CALL 0x00120280
LAB_0013c964:
MOV RSI,qword ptr [0x001d0fe8]
MOV RDX,qword ptr [0x001d0f60]
MOV RDI,R14
CALL 0x00120b30
|
/* minja::UnaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
UnaryOpExpr * __thiscall minja::UnaryOpExpr::do_evaluate(UnaryOpExpr *this,shared_ptr *param_1)
{
runtime_error *prVar1;
bool local_61;
Expression local_60 [80];
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013c909 to 0013c917 has its CatchHandler @ 0013c98b */
std::runtime_error::runtime_error(prVar1,"UnaryOpExpr.expr is null");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_001d0fe8,PTR__runtime_error_001d0f60);
}
Expression::evaluate(local_60,*(shared_ptr **)(param_1 + 0x20));
switch(*(int4 *)(param_1 + 0x30)) {
case 0:
Value::Value((Value *)this,(Value *)local_60);
break;
case 1:
/* try { // try from 0013c8dc to 0013c8e8 has its CatchHandler @ 0013c998 */
Value::operator-((Value *)this);
break;
case 2:
/* try { // try from 0013c8bf to 0013c8c8 has its CatchHandler @ 0013c97c */
local_61 = (bool)Value::to_bool((Value *)local_60);
local_61 = (bool)(local_61 ^ 1);
Value::Value((Value *)this,&local_61);
break;
case 3:
case 4:
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013c939 to 0013c947 has its CatchHandler @ 0013c97e */
std::runtime_error::runtime_error
(prVar1,"Expansion operator is only supported in function calls and collections");
goto LAB_0013c964;
default:
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013c955 to 0013c963 has its CatchHandler @ 0013c97a */
std::runtime_error::runtime_error(prVar1,"Unknown unary operator");
LAB_0013c964:
/* try { // try from 0013c964 to 0013c979 has its CatchHandler @ 0013c998 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_001d0fe8,PTR__runtime_error_001d0f60);
}
Value::~Value((Value *)local_60);
return this;
}
| |
28,494 | my_hash_sort_bin | eloqsql/strings/ctype-bin.c | void my_hash_sort_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,ulong *nr1, ulong *nr2)
{
const uchar *end = key + len;
ulong tmp1= *nr1;
ulong tmp2= *nr2;
for (; key < end ; key++)
{
MY_HASH_ADD(tmp1, tmp2, (uint) *key);
}
*nr1= tmp1;
*nr2= tmp2;
} | O0 | c | my_hash_sort_bin:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x3dc9e
jmp 0x3dc56
movq -0x38(%rbp), %rax
andq $0x3f, %rax
addq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x38(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x40(%rbp)
jmp 0x3dc90
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3dc4a
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_hash_sort_bin:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_40], rax
loc_3DC4A:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_30]
jnb short loc_3DC9E
jmp short $+2
loc_3DC56:
mov rax, [rbp+var_38]
and rax, 3Fh
add rax, [rbp+var_40]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_38]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_38]
mov [rbp+var_38], rax
mov rax, [rbp+var_40]
add rax, 3
mov [rbp+var_40], rax
jmp short $+2
loc_3DC90:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_3DC4A
loc_3DC9E:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_40]
mov rax, [rbp+var_28]
mov [rax], rcx
pop rbp
retn
| _QWORD * my_hash_sort_bin(long long a1, unsigned __int8 *a2, long long a3, long long *a4, _QWORD *a5)
{
_QWORD *result; // rax
long long v6; // [rsp+0h] [rbp-40h]
long long v7; // [rsp+8h] [rbp-38h]
unsigned __int8 *v8; // [rsp+30h] [rbp-10h]
v8 = a2;
v7 = *a4;
v6 = *a5;
while ( v8 < &a2[a3] )
{
v7 ^= (v7 << 8) + *v8 * (v6 + (v7 & 0x3F));
v6 += 3LL;
++v8;
}
*a4 = v7;
result = a5;
*a5 = v6;
return result;
}
| my_hash_sort_bin:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
LAB_0013dc4a:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x0013dc9e
JMP 0x0013dc56
LAB_0013dc56:
MOV RAX,qword ptr [RBP + -0x38]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x38]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x3
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0013dc90
LAB_0013dc90:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0013dc4a
LAB_0013dc9e:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
POP RBP
RET
|
void my_hash_sort_bin(int8 param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
long local_48;
ulong local_40;
byte *local_18;
local_40 = *param_4;
local_48 = *param_5;
for (local_18 = param_2; local_18 < param_2 + param_3; local_18 = local_18 + 1) {
local_40 = ((local_40 & 0x3f) + local_48) * (ulong)*local_18 + local_40 * 0x100 ^ local_40;
local_48 = local_48 + 3;
}
*param_4 = local_40;
*param_5 = local_48;
return;
}
| |
28,495 | get_collation_name_alias | eloqsql/mysys/charset.c | static const char*
get_collation_name_alias(const char *name, char *buf, size_t bufsize, myf flags)
{
if (!strncasecmp(name, "utf8_", 5))
{
my_snprintf(buf, bufsize, "utf8mb%c_%s",
flags & MY_UTF8_IS_UTF8MB3 ? '3' : '4', name + 5);
return buf;
}
return NULL;
} | O0 | c | get_collation_name_alias:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4ff64(%rip), %rsi # 0x796d7
movl $0x5, %edx
callq 0x243b0
cmpl $0x0, %eax
jne 0x297c6
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
andq $0x400, %rdx # imm = 0x400
movl $0x34, %ecx
movl $0x33, %eax
cmpq $0x0, %rdx
cmovnel %eax, %ecx
movq -0x10(%rbp), %r8
addq $0x5, %r8
leaq 0x4ff28(%rip), %rdx # 0x796dd
movb $0x0, %al
callq 0x76430
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x297ce
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| get_collation_name_alias:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rdi, [rbp+var_10]
lea rsi, aUtf8_0; "utf8_"
mov edx, 5
call _strncasecmp
cmp eax, 0
jnz short loc_297C6
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
and rdx, 400h
mov ecx, 34h ; '4'
mov eax, 33h ; '3'
cmp rdx, 0
cmovnz ecx, eax
mov r8, [rbp+var_10]
add r8, 5
lea rdx, aUtf8mbCS; "utf8mb%c_%s"
mov al, 0
call my_snprintf
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
jmp short loc_297CE
loc_297C6:
mov [rbp+var_8], 0
loc_297CE:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long get_collation_name_alias(long long a1, long long a2, int a3, __int16 a4)
{
int v4; // r9d
int v5; // ecx
if ( (unsigned int)strncasecmp(a1, "utf8_", 5LL) )
return 0LL;
v5 = 52;
if ( (a4 & 0x400) != 0 )
v5 = 51;
my_snprintf(a2, a3, (unsigned int)"utf8mb%c_%s", v5, a1 + 5, v4);
return a2;
}
| get_collation_name_alias:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1796d7]
MOV EDX,0x5
CALL 0x001243b0
CMP EAX,0x0
JNZ 0x001297c6
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
AND RDX,0x400
MOV ECX,0x34
MOV EAX,0x33
CMP RDX,0x0
CMOVNZ ECX,EAX
MOV R8,qword ptr [RBP + -0x10]
ADD R8,0x5
LEA RDX,[0x1796dd]
MOV AL,0x0
CALL 0x00176430
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001297ce
LAB_001297c6:
MOV qword ptr [RBP + -0x8],0x0
LAB_001297ce:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
int8
get_collation_name_alias(char *param_1,int8 param_2,int8 param_3,ulong param_4)
{
int iVar1;
int8 uVar2;
int8 local_10;
iVar1 = strncasecmp(param_1,"utf8_",5);
if (iVar1 == 0) {
uVar2 = 0x34;
if ((param_4 & 0x400) != 0) {
uVar2 = 0x33;
}
my_snprintf(param_2,param_3,"utf8mb%c_%s",uVar2,param_1 + 5);
local_10 = param_2;
}
else {
local_10 = 0;
}
return local_10;
}
| |
28,496 | my_strnxfrm_8bit_bin | eloqsql/strings/ctype-bin.c | static size_t
my_strnxfrm_8bit_bin(CHARSET_INFO *cs,
uchar * dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
set_if_smaller(srclen, dstlen);
set_if_smaller(srclen, nweights);
if (srclen && dst != src)
memcpy(dst, src, srclen);
return my_strxfrm_pad_desc_and_reverse(cs, dst, dst + srclen, dst + dstlen,
(uint)(nweights - srclen), flags, 0);
} | O3 | c | my_strnxfrm_8bit_bin:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl 0x10(%rbp), %r9d
cmpq %rdx, %r13
cmovaeq %rdx, %r13
movl %ecx, %eax
cmpq %rax, %r13
cmovaeq %rax, %r13
testq %r13, %r13
sete %al
cmpq %r8, %rsi
sete %cl
orb %al, %cl
jne 0x5e6b6
movq %r12, %rdi
movq %r8, %rsi
movq %r13, %rdx
callq 0x35080
movl 0x10(%rbp), %r9d
leaq (%r12,%r13), %rdx
addq %r12, %r14
subl %r13d, %ebx
movl $0x0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
movl %ebx, %r8d
callq 0x66a2c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_strnxfrm_8bit_bin:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r13, r9
mov ebx, ecx
mov r14, rdx
mov r12, rsi
mov r15, rdi
mov r9d, [rbp+arg_0]
cmp r13, rdx
cmovnb r13, rdx
mov eax, ecx
cmp r13, rax
cmovnb r13, rax
test r13, r13
setz al
cmp rsi, r8
setz cl
or cl, al
jnz short loc_5E6B6
mov rdi, r12
mov rsi, r8
mov rdx, r13
call _memcpy
mov r9d, [rbp+arg_0]
loc_5E6B6:
lea rdx, [r12+r13]
add r14, r12
sub ebx, r13d
mov [rsp+30h+var_30], 0
mov rdi, r15
mov rsi, r12
mov rcx, r14
mov r8d, ebx
call my_strxfrm_pad_desc_and_reverse
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_strnxfrm_8bit_bin(
int a1,
long long a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
int a7)
{
int v9; // r14d
int v10; // r9d
v9 = a3;
v10 = a7;
if ( a6 >= a3 )
a6 = a3;
if ( a6 >= a4 )
a6 = a4;
if ( a6 != 0 && a2 != a5 )
{
memcpy(a2, a5, a6);
v10 = a7;
}
return my_strxfrm_pad_desc_and_reverse(a1, a2, (int)a2 + (int)a6, (int)a2 + v9, a4 - (unsigned int)a6, v10, 0);
}
| my_strnxfrm_8bit_bin:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R13,R9
MOV EBX,ECX
MOV R14,RDX
MOV R12,RSI
MOV R15,RDI
MOV R9D,dword ptr [RBP + 0x10]
CMP R13,RDX
CMOVNC R13,RDX
MOV EAX,ECX
CMP R13,RAX
CMOVNC R13,RAX
TEST R13,R13
SETZ AL
CMP RSI,R8
SETZ CL
OR CL,AL
JNZ 0x0015e6b6
MOV RDI,R12
MOV RSI,R8
MOV RDX,R13
CALL 0x00135080
MOV R9D,dword ptr [RBP + 0x10]
LAB_0015e6b6:
LEA RDX,[R12 + R13*0x1]
ADD R14,R12
SUB EBX,R13D
MOV dword ptr [RSP],0x0
MOV RDI,R15
MOV RSI,R12
MOV RCX,R14
MOV R8D,EBX
CALL 0x00166a2c
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void my_strnxfrm_8bit_bin
(int8 param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,int4 param_7)
{
int8 in_RAX;
uint uVar1;
uVar1 = (uint)((ulong)in_RAX >> 0x20);
if (param_3 <= param_6) {
param_6 = param_3;
}
if (param_4 <= param_6) {
param_6 = (ulong)param_4;
}
if (param_2 != param_5 && param_6 != 0) {
memcpy(param_2,param_5,param_6);
}
my_strxfrm_pad_desc_and_reverse
(param_1,param_2,(long)param_2 + param_6,param_3 + (long)param_2,param_4 - (int)param_6,
param_7,(ulong)uVar1 << 0x20);
return;
}
| |
28,497 | translog_check_sector_protection | eloqsql/storage/maria/ma_loghandler.c | static my_bool
translog_check_sector_protection(uchar *page, TRANSLOG_FILE *file)
{
uint i, offset;
uchar *table= page + page_overhead[page[TRANSLOG_PAGE_FLAGS]] -
TRANSLOG_PAGE_SIZE / DISK_DRIVE_SECTOR_SIZE;
uint8 current= table[0];
DBUG_ENTER("translog_check_sector_protection");
for (i= 1, offset= DISK_DRIVE_SECTOR_SIZE;
i < TRANSLOG_PAGE_SIZE / DISK_DRIVE_SECTOR_SIZE;
i++, offset+= DISK_DRIVE_SECTOR_SIZE)
{
/*
TODO: add chunk counting for "suspecting" sectors (difference is
more than 1-2), if difference more then present chunks then it is
the problem.
*/
uint8 test= page[offset];
DBUG_PRINT("info", ("sector: #%u offset: %u current: %lx "
"read: 0x%x stored: 0x%x%x",
i, offset, (ulong) current,
(uint) uint2korr(page + offset), (uint) table[i],
(uint) table[i + 1]));
/*
3 is minimal possible record length. So we can have "distance"
between 2 sectors value more then DISK_DRIVE_SECTOR_SIZE / 3
only if it is old value, i.e. the sector was not written.
*/
if (((test < current) &&
((uint)(0xFFL - current + test) > DISK_DRIVE_SECTOR_SIZE / 3)) ||
((test >= current) &&
((uint)(test - current) > DISK_DRIVE_SECTOR_SIZE / 3)))
{
if (translog_recover_page_up_to_sector(page, offset))
DBUG_RETURN(1);
file->was_recovered= 1;
DBUG_RETURN(0);
}
/* Restore value on the page */
page[offset]= table[i];
current= test;
DBUG_PRINT("info", ("sector: #%u offset: %u current: %lx "
"read: 0x%x stored: 0x%x",
i, offset, (ulong) current,
(uint) page[offset], (uint) table[i]));
}
DBUG_RETURN(0);
} | O3 | c | translog_check_sector_protection:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movzbl 0x6(%rdi), %ecx
leaq 0xbcc293(%rip), %rax # 0xc04f60
movl (%rax,%rcx,4), %ecx
addq %rdi, %rcx
addq $-0xf, %rcx
movb -0x1(%rcx), %r9b
movl $0x400, %r12d # imm = 0x400
movb -0x200(%r14,%r12), %dl
movzbl %dl, %edi
cmpb %r9b, %dil
jae 0x38d07
movl %r9d, %r8d
notb %r8b
movzbl %r8b, %r8d
addl %edi, %r8d
cmpl $0xaa, %r8d
ja 0x38d41
cmpb %r9b, %dl
jb 0x38d1b
movzbl %r9b, %r8d
subl %r8d, %edi
cmpl $0xab, %edi
jae 0x38d41
movb (%rcx), %dil
movb %dil, -0x200(%r14,%r12)
incq %rcx
addq $0x200, %r12 # imm = 0x200
movl %edx, %r9d
cmpq $0x2200, %r12 # imm = 0x2200
jne 0x38ce1
jmp 0x38e03
movq %rsi, -0x30(%rbp)
leaq -0x200(%r12), %rbx
movzbl 0x6(%r14), %ecx
movsbl (%rax,%rcx,4), %r13d
movzwl %r13w, %r15d
movb (%r14,%r15), %al
cmpw %bx, %r13w
jae 0x38da3
cmpb $-0x1, %al
je 0x38dda
movq %r14, %rdi
movl %r15d, %esi
callq 0x34730
movl %eax, %ecx
movb $0x1, %al
testw %cx, %cx
je 0x38e05
movzwl %cx, %edx
addq %r15, %rdx
cmpq $0x2001, %rdx # imm = 0x2001
movl $0x0, %esi
cmovael %esi, %ecx
addl %ecx, %r13d
cmpl $0x2001, %edx # imm = 0x2001
jb 0x38d57
jmp 0x38e05
cmpb $-0x1, %al
movq -0x30(%rbp), %rbx
je 0x38de7
movzwl %r13w, %esi
movq %r14, %rdi
callq 0x34730
testw %ax, %ax
je 0x38de0
movzwl %ax, %ecx
addq %rcx, %r15
cmpq %r12, %r15
ja 0x38de0
addl %r13d, %eax
movzwl %ax, %r15d
cmpb $-0x1, (%r14,%r15)
movl %eax, %r13d
jne 0x38dab
jmp 0x38de3
movq -0x30(%rbp), %rbx
jmp 0x38de7
movl %r13d, %eax
movzwl %ax, %r15d
addq %r15, %r14
movl $0x2000, %edx # imm = 0x2000
subl %r15d, %edx
movq %r14, %rdi
movl $0xff, %esi
callq 0x2a290
movb $0x1, 0x50(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| translog_check_sector_protection:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdi
movzx ecx, byte ptr [rdi+6]
lea rax, page_overhead
mov ecx, [rax+rcx*4]
add rcx, rdi
add rcx, 0FFFFFFFFFFFFFFF1h
mov r9b, [rcx-1]
mov r12d, 400h
loc_38CE1:
mov dl, [r14+r12-200h]
movzx edi, dl
cmp dil, r9b
jnb short loc_38D07
mov r8d, r9d
not r8b
movzx r8d, r8b
add r8d, edi
cmp r8d, 0AAh
ja short loc_38D41
loc_38D07:
cmp dl, r9b
jb short loc_38D1B
movzx r8d, r9b
sub edi, r8d
cmp edi, 0ABh
jnb short loc_38D41
loc_38D1B:
mov dil, [rcx]
mov [r14+r12-200h], dil
inc rcx
add r12, 200h
mov r9d, edx
cmp r12, 2200h
jnz short loc_38CE1
jmp loc_38E03
loc_38D41:
mov [rbp+var_30], rsi
lea rbx, [r12-200h]
movzx ecx, byte ptr [r14+6]
movsx r13d, byte ptr [rax+rcx*4]
loc_38D57:
movzx r15d, r13w
mov al, [r14+r15]
cmp r13w, bx
jnb short loc_38DA3
cmp al, 0FFh
jz short loc_38DDA
mov rdi, r14
mov esi, r15d
call translog_get_total_chunk_length
mov ecx, eax
mov al, 1
test cx, cx
jz loc_38E05
movzx edx, cx
add rdx, r15
cmp rdx, 2001h
mov esi, 0
cmovnb ecx, esi
add r13d, ecx
cmp edx, 2001h
jb short loc_38D57
jmp short loc_38E05
loc_38DA3:
cmp al, 0FFh
mov rbx, [rbp+var_30]
jz short loc_38DE7
loc_38DAB:
movzx esi, r13w
mov rdi, r14
call translog_get_total_chunk_length
test ax, ax
jz short loc_38DE0
movzx ecx, ax
add r15, rcx
cmp r15, r12
ja short loc_38DE0
add eax, r13d
movzx r15d, ax
cmp byte ptr [r14+r15], 0FFh
mov r13d, eax
jnz short loc_38DAB
jmp short loc_38DE3
loc_38DDA:
mov rbx, [rbp+var_30]
jmp short loc_38DE7
loc_38DE0:
mov eax, r13d
loc_38DE3:
movzx r15d, ax
loc_38DE7:
add r14, r15
mov edx, 2000h
sub edx, r15d
mov rdi, r14
mov esi, 0FFh
call _memset
mov byte ptr [rbx+50h], 1
loc_38E03:
xor eax, eax
loc_38E05:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char translog_check_sector_protection(long long a1, long long a2)
{
_BYTE *v2; // rcx
unsigned __int8 v3; // r9
unsigned long long v4; // r12
unsigned __int8 v5; // dl
int v6; // r13d
long long v7; // r15
char v8; // al
int total_chunk_length; // ecx
char result; // al
unsigned long long v11; // rdx
long long v12; // rbx
int v13; // eax
int v14; // eax
v2 = (_BYTE *)(a1 + *((unsigned int *)&page_overhead + *(unsigned __int8 *)(a1 + 6)) - 15);
v3 = *(_BYTE *)(a1 + *((unsigned int *)&page_overhead + *(unsigned __int8 *)(a1 + 6)) - 16);
v4 = 1024LL;
while ( 1 )
{
v5 = *(_BYTE *)(a1 + v4 - 512);
if ( v5 < v3 && v5 + (unsigned int)(unsigned __int8)~v3 > 0xAA )
break;
if ( v5 >= v3 && v5 - (unsigned int)v3 >= 0xAB )
break;
*(_BYTE *)(a1 + v4 - 512) = *v2++;
v4 += 512LL;
v3 = v5;
if ( v4 == 8704 )
return 0;
}
v6 = *((char *)&page_overhead + 4 * *(unsigned __int8 *)(a1 + 6));
while ( 1 )
{
v7 = (unsigned __int16)v6;
v8 = *(_BYTE *)(a1 + (unsigned __int16)v6);
if ( (unsigned __int16)v6 >= (unsigned __int16)(v4 - 512) )
break;
if ( v8 == -1 )
{
v12 = a2;
goto LABEL_24;
}
total_chunk_length = translog_get_total_chunk_length(a1, (unsigned __int16)v6);
result = 1;
if ( (_WORD)total_chunk_length )
{
v11 = (unsigned __int16)v6 + (unsigned long long)(unsigned __int16)total_chunk_length;
if ( v11 >= 0x2001 )
total_chunk_length = 0;
v6 += total_chunk_length;
if ( (unsigned int)v11 < 0x2001 )
continue;
}
return result;
}
v12 = a2;
if ( v8 != -1 )
{
while ( 1 )
{
v13 = translog_get_total_chunk_length(a1, (unsigned __int16)v6);
if ( !(_WORD)v13 || (unsigned long long)(unsigned __int16)v13 + v7 > v4 )
break;
v14 = v6 + v13;
v7 = (unsigned __int16)v14;
v6 = v14;
if ( *(_BYTE *)(a1 + (unsigned __int16)v14) == 0xFF )
goto LABEL_23;
}
LOWORD(v14) = v6;
LABEL_23:
v7 = (unsigned __int16)v14;
}
LABEL_24:
memset(v7 + a1, 255LL, (unsigned int)(0x2000 - v7));
*(_BYTE *)(v12 + 80) = 1;
return 0;
}
| translog_check_sector_protection:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOVZX ECX,byte ptr [RDI + 0x6]
LEA RAX,[0xd04f60]
MOV ECX,dword ptr [RAX + RCX*0x4]
ADD RCX,RDI
ADD RCX,-0xf
MOV R9B,byte ptr [RCX + -0x1]
MOV R12D,0x400
LAB_00138ce1:
MOV DL,byte ptr [R14 + R12*0x1 + -0x200]
MOVZX EDI,DL
CMP DIL,R9B
JNC 0x00138d07
MOV R8D,R9D
NOT R8B
MOVZX R8D,R8B
ADD R8D,EDI
CMP R8D,0xaa
JA 0x00138d41
LAB_00138d07:
CMP DL,R9B
JC 0x00138d1b
MOVZX R8D,R9B
SUB EDI,R8D
CMP EDI,0xab
JNC 0x00138d41
LAB_00138d1b:
MOV DIL,byte ptr [RCX]
MOV byte ptr [R14 + R12*0x1 + -0x200],DIL
INC RCX
ADD R12,0x200
MOV R9D,EDX
CMP R12,0x2200
JNZ 0x00138ce1
JMP 0x00138e03
LAB_00138d41:
MOV qword ptr [RBP + -0x30],RSI
LEA RBX,[R12 + -0x200]
MOVZX ECX,byte ptr [R14 + 0x6]
MOVSX R13D,byte ptr [RAX + RCX*0x4]
LAB_00138d57:
MOVZX R15D,R13W
MOV AL,byte ptr [R14 + R15*0x1]
CMP R13W,BX
JNC 0x00138da3
CMP AL,0xff
JZ 0x00138dda
MOV RDI,R14
MOV ESI,R15D
CALL 0x00134730
MOV ECX,EAX
MOV AL,0x1
TEST CX,CX
JZ 0x00138e05
MOVZX EDX,CX
ADD RDX,R15
CMP RDX,0x2001
MOV ESI,0x0
CMOVNC ECX,ESI
ADD R13D,ECX
CMP EDX,0x2001
JC 0x00138d57
JMP 0x00138e05
LAB_00138da3:
CMP AL,0xff
MOV RBX,qword ptr [RBP + -0x30]
JZ 0x00138de7
LAB_00138dab:
MOVZX ESI,R13W
MOV RDI,R14
CALL 0x00134730
TEST AX,AX
JZ 0x00138de0
MOVZX ECX,AX
ADD R15,RCX
CMP R15,R12
JA 0x00138de0
ADD EAX,R13D
MOVZX R15D,AX
CMP byte ptr [R14 + R15*0x1],0xff
MOV R13D,EAX
JNZ 0x00138dab
JMP 0x00138de3
LAB_00138dda:
MOV RBX,qword ptr [RBP + -0x30]
JMP 0x00138de7
LAB_00138de0:
MOV EAX,R13D
LAB_00138de3:
MOVZX R15D,AX
LAB_00138de7:
ADD R14,R15
MOV EDX,0x2000
SUB EDX,R15D
MOV RDI,R14
MOV ESI,0xff
CALL 0x0012a290
MOV byte ptr [RBX + 0x50],0x1
LAB_00138e03:
XOR EAX,EAX
LAB_00138e05:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 translog_check_sector_protection(long param_1,long param_2)
{
byte bVar1;
ushort uVar2;
int1 *puVar3;
ulong uVar4;
byte bVar5;
ulong uVar6;
ushort uVar7;
ulong uVar8;
puVar3 = (int1 *)
((ulong)*(uint *)(page_overhead + (ulong)*(byte *)(param_1 + 6) * 4) + param_1 + -0xf);
uVar6 = 0x400;
bVar5 = *(byte *)((ulong)*(uint *)(page_overhead + (ulong)*(byte *)(param_1 + 6) * 4) + param_1 +
-0x10);
while( true ) {
bVar1 = *(byte *)(param_1 + -0x200 + uVar6);
if (((bVar1 < bVar5) && (0xaa < (uint)(byte)~bVar5 + (uint)bVar1)) ||
((bVar5 <= bVar1 && (0xaa < (uint)bVar1 - (uint)bVar5)))) break;
*(int1 *)(param_1 + -0x200 + uVar6) = *puVar3;
puVar3 = puVar3 + 1;
uVar6 = uVar6 + 0x200;
bVar5 = bVar1;
if (uVar6 == 0x2200) {
return 0;
}
}
uVar7 = (ushort)(char)page_overhead[(ulong)*(byte *)(param_1 + 6) * 4];
while( true ) {
uVar8 = (ulong)uVar7;
if ((ushort)((short)uVar6 - 0x200U) <= uVar7) break;
if (*(char *)(param_1 + uVar8) == -1) goto LAB_00138de7;
uVar2 = translog_get_total_chunk_length(param_1,uVar8);
if (uVar2 == 0) {
return 1;
}
uVar4 = (ulong)uVar2;
if (0x2000 < uVar4 + uVar8) {
uVar2 = 0;
}
uVar7 = uVar7 + uVar2;
if (0x2000 < (uint)(uVar4 + uVar8)) {
return 1;
}
}
if (*(char *)(param_1 + uVar8) != -1) {
do {
uVar2 = translog_get_total_chunk_length(param_1,uVar7);
if ((uVar2 == 0) || (uVar6 < uVar8 + uVar2)) break;
uVar7 = uVar2 + uVar7;
uVar8 = (ulong)uVar7;
} while (*(char *)(param_1 + uVar8) != -1);
uVar8 = (ulong)uVar7;
}
LAB_00138de7:
memset((void *)(param_1 + uVar8),0xff,(ulong)(0x2000 - (int)uVar8));
*(int1 *)(param_2 + 0x50) = 1;
return 0;
}
| |
28,498 | bool 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>::contains<char const (&) [12], 0>(char const (&) [12]) const | monkey531[P]llama/common/./json.hpp | constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
} | O1 | cpp | bool 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>::contains<char const (&) [12], 0>(char const (&) [12]) const:
cmpb $0x1, (%rdi)
jne 0x97664
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movq (%r12), %r15
movq 0x8(%r12), %rax
cmpq %rax, %r15
je 0x9766a
movq %rsi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x18190
testl %eax, %eax
je 0x97667
addq $0x30, %r15
movq 0x8(%r12), %rax
cmpq %rax, %r15
jne 0x97645
jmp 0x9766a
xorl %eax, %eax
retq
movq %r15, %rax
movq 0x8(%rbx), %rcx
cmpq 0x8(%rcx), %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_97664
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
mov r12, [rdi+8]
mov r15, [r12]
mov rax, [r12+8]
cmp r15, rax
jz short loc_9766A
mov r14, rsi
loc_97645:
mov rdi, r15
mov rsi, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_97667
add r15, 30h ; '0'
mov rax, [r12+8]
cmp r15, rax
jnz short loc_97645
jmp short loc_9766A
loc_97664:
xor eax, eax
retn
loc_97667:
mov rax, r15
loc_9766A:
mov rcx, [rbx+8]
cmp rax, [rcx+8]
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // r15
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
v4 = v2[1];
if ( *v2 != v4 )
{
while ( (unsigned int)std::string::compare(v3, a2) )
{
v3 += 48LL;
v4 = v2[1];
if ( v3 == v4 )
return v4 != *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
v4 = v3;
}
return v4 != *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x00197664
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV R15,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
CMP R15,RAX
JZ 0x0019766a
MOV R14,RSI
LAB_00197645:
MOV RDI,R15
MOV RSI,R14
CALL 0x00118190
TEST EAX,EAX
JZ 0x00197667
ADD R15,0x30
MOV RAX,qword ptr [R12 + 0x8]
CMP R15,RAX
JNZ 0x00197645
JMP 0x0019766a
LAB_00197664:
XOR EAX,EAX
RET
LAB_00197667:
MOV RAX,R15
LAB_0019766a:
MOV RCX,qword ptr [RBX + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)plVar1[1];
pcVar4 = (char *)*plVar1;
if ((char *)*plVar1 != pcVar3) {
do {
pcVar3 = pcVar4;
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar4 = pcVar3 + 0x30;
pcVar3 = (char *)plVar1[1];
} while (pcVar4 != pcVar3);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != *(char **)(*(long *)(param_1 + 8) + 8));
}
| |
28,499 | bool 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>::contains<char const (&) [12], 0>(char const (&) [12]) const | monkey531[P]llama/common/./json.hpp | constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
} | O3 | cpp | bool 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>::contains<char const (&) [12], 0>(char const (&) [12]) const:
cmpb $0x1, (%rdi)
jne 0x9544f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%r12), %rbx
cmpq 0x8(%r12), %rbx
je 0x95452
movq %rsi, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18190
testl %eax, %eax
je 0x95442
addq $0x30, %rbx
cmpq 0x8(%r12), %rbx
jne 0x95428
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
jmp 0x95455
xorl %eax, %eax
retq
movq %rbx, %rax
cmpq %rbx, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_9544F
push r15
push r14
push r12
push rbx
push rax
mov r14, rdi
mov r12, [rdi+8]
mov rbx, [r12]
cmp rbx, [r12+8]
jz short loc_95452
mov r15, rsi
loc_95428:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_95442
add rbx, 30h ; '0'
cmp rbx, [r12+8]
jnz short loc_95428
loc_95442:
mov rax, rbx
mov rcx, [r14+8]
mov rbx, [rcx+8]
jmp short loc_95455
loc_9544F:
xor eax, eax
retn
loc_95452:
mov rax, rbx
loc_95455:
cmp rax, rbx
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
if ( *v2 == v2[1] )
{
v4 = *v2;
}
else
{
do
{
if ( !(unsigned int)std::string::compare(v3, a2) )
break;
v3 += 48LL;
}
while ( v3 != v2[1] );
v4 = v3;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
return v4 != v3;
}
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x0019544f
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [R12]
CMP RBX,qword ptr [R12 + 0x8]
JZ 0x00195452
MOV R15,RSI
LAB_00195428:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00118190
TEST EAX,EAX
JZ 0x00195442
ADD RBX,0x30
CMP RBX,qword ptr [R12 + 0x8]
JNZ 0x00195428
LAB_00195442:
MOV RAX,RBX
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
JMP 0x00195455
LAB_0019544f:
XOR EAX,EAX
RET
LAB_00195452:
MOV RAX,RBX
LAB_00195455:
CMP RAX,RBX
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)*plVar1;
pcVar4 = pcVar3;
if (pcVar3 != (char *)plVar1[1]) {
do {
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar3 = pcVar3 + 0x30;
} while (pcVar3 != (char *)plVar1[1]);
pcVar4 = *(char **)(*(long *)(param_1 + 8) + 8);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != pcVar4);
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.